/********************************************************************  
//
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
********************************************************************/

/* -*-C++-*-
 *****************************************************************************
 *
 * File:         sqlci_yacc.y
 * Description:  Parser for mxci commands.
 *
 *
 * Created:      7/10/95
 * Modified:     $ $Date: 2006/11/01 01:44:52 $ (GMT)
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */


%{
#include "Platform.h"

#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include "ComAnsiNamePart.h"
#include "ParserMsg.h"			// StoreSyntaxError(...ComDiagsArea&...)
#include "Sqlci.h"
#include "str.h"
#include "nawstring.h"
#define   SQLCIPARSEGLOBALS__INITIALIZE
#include "SqlciParseGlobals.h"
#include "HeapLog.h"
#include "charinfo.h"
#include "conversionHex.h"
#include "ComDistribution.h"
#include "ComObjectName.h"
#include "ComSchemaName.h"

  extern char **environ;
#define ENVIRON environ
#define PUTENV putenv

extern NAHeap sqlci_Heap;

  extern "C" {int yylex (void); }

extern ComDiagsArea sqlci_DA;
extern char *sqlcitext;

static char *identifier_name_internal;
static char *identifier_name_internal2;
static int pos_internal;
static int pos_internal2;
static int pos_internal3;
static char *get_stats_str;

//extern "C" { void yyerror(const char *sb); };


static void sqlcierror(const char *)		// (const char *errtext)
{
  // Re-initialize the following variables which are used in sqlci_lex.l
  SqlciParse_SyntaxErrorCleanup = 0;
  SqlciParse_IdentifierExpected = 0;

  if (!SqlciParse_HelpCmd)
    {
      // So syntax errmsg caret points properly, when input is an extra
      // dangling #else		or	#endif --
      //   emit   ^    		not	  ^
      if (SqlciParse_InputPos <= 2)
        if (*SqlciParse_InputStr == '#')
	  SqlciParse_InputPos = 0;
      SqlciError (SQLCI_SYNTAX_ERROR, (ErrorParam *) 0);
      StoreSyntaxError(SqlciParse_InputStr, SqlciParse_InputPos, sqlci_DA, 0);
    }
} // sqlcierror

enum EQuotedStringWithoutPrefixFlag { eNOT_QUOTED_STRING_WITHOUT_CHARSET_PREFIX = 0,
                                      eQUOTED_STRING_WITHOUT_CHARSET_PREFIX = 1 };

static short trimValueText(int/*offset*/ &i,
			   int/*length*/ &len,
			   int/*bool*/   &quoted,
                           CharInfo::CharSet /*charset code*/ &cs,
                           int/* bool*/ &inhexdecimal,
			   int /*bool*/    quoting_allowed = -1,
			   int/*bool*/	  use_i_as_is = 0,
			   int/*bool*/	  cs_allowed = 0,
                           EQuotedStringWithoutPrefixFlag * pQuotedStrWithoutPrefixFlag = NULL
                           , int/*bool*/ keepValueTextAsIs = 0/*false*/
                          )
{
  // Process the value text:
  // remove the trailing semicolon and any squotes (')
  // but leave in any dquotes (").
  //
  // Returns TRUE if syntax error (error in quoted string, basically --
  // which should be already caught by class InputStmt; see its logic
  // around SQLCI_INPUT_MISSING_QUOTE).

  if (pQuotedStrWithoutPrefixFlag != NULL)
    *pQuotedStrWithoutPrefixFlag = eNOT_QUOTED_STRING_WITHOUT_CHARSET_PREFIX;

  quoted = 0;
  cs =  CharInfo::UnknownCharSet;
  inhexdecimal = 0;

  if (!use_i_as_is)
    {
      i = SqlciParse_InputPos - 1;

      // Now the i'th character is a separator char that Lex found,
      // separating the Define name from its value.
      // The following test allows
      //	SET ENVVAR nam;
      //	SET ENVVAR nam ;
      //	SET ENVVAR nam val;
      //	SET ENVVAR nam 'val';
      //	SET ENVVAR nam "val";
      //	SET ENVVAR nam'val';	-- on the analogy of Ansi syntax which
      //	SET ENVVAR nam"val";	-- allows SELECT * FROM tbl"corrName";
      //	SET ENVVAR nam :val;	-- value is  :val
      //	SET ENVVAR nam =val;	-- value is  =val
      // but not
      //	SET ENVVAR nam:val;
      //	SET ENVVAR nam=val;
      //
      if (SqlciParse_OriginalStr[i] != ';'    &&
          SqlciParse_OriginalStr[i] != '\''   &&
	  SqlciParse_OriginalStr[i] != '\"'   &&
	  !isspace(SqlciParse_OriginalStr[i]) &&
	  !isspace(SqlciParse_OriginalStr[i-1]))
	return -1;				// error: space separator needed
    }

  // skip leading blanks
  while (isspace(SqlciParse_OriginalStr[i])) i++;

  // remember the start position of '_' in case we need to go back to position i
  int i_orig = i; 
  NAString origValueText(&SqlciParse_OriginalStr[i_orig]); // for the keepValueTextAsIs case

  // determine if the value is has a valid character set prefix
  if ( cs_allowed && SqlciParse_OriginalStr[i] == '_' )
  {
     int k = i+1;
     char c;
     while ((c=SqlciParse_OriginalStr[k])) {
       if ( c == '\''|| c == ' ' ) // quoted or hexadecimal value
       {
         SqlciParse_OriginalStr[k] = '\0'; // temp. null terminate the prefix
         NAString csPrefix(&SqlciParse_OriginalStr[i+1]);
         SqlciParse_OriginalStr[k] = c; // restore

         csPrefix.toUpper();
         cs = CharInfo::getCharSetEnum(csPrefix); // check the prefix
         if ( CharInfo::isCharSetFullySupported(cs) ) {
            i = k; // mark the start of the string after the prefix
         }  
         break;
       }
       k++;
     }

     // A string in hexadecimal format begins with ' x' or ' X'.
     if ( SqlciParse_OriginalStr[i] == ' ' && 
          SqlciParse_OriginalStr[i+1] &&
          toupper(SqlciParse_OriginalStr[i+1]) == 'X' ) {
        inhexdecimal = 1; // mark the hexadecimal format.
        i += 2;           // skip ' x'. Suppose to point at '. 
     }
  } else {
     // no cs name prefix. Check if it is a hexadecimal string.
     if ( toupper(SqlciParse_OriginalStr[i]) == 'X' &&
          SqlciParse_OriginalStr[i+1] == '\''
        ) {
        inhexdecimal = 1; // mark the hexadecimal format.
        i += 1;           // skip 'x'. Suppose to point at '. 
     }
  }

  char delimQuote = '\'';
  if (SqlciParse_OriginalStr[i] == '\'' ||	// quoted value
      SqlciParse_OriginalStr[i] == '"')
    {
      delimQuote = SqlciParse_OriginalStr[i];
      quoted = -1;

      // Remove the leading single quote as procedure comments indicate. 
      NAString temptrail(&SqlciParse_OriginalStr[i+1]);
      strcpy(&SqlciParse_OriginalStr[i], temptrail);
    } else
       i = i_orig; // need to abadone the charset name assumption.
    
  SqlciParse_InputPos = i;			// for sqlcierror message
  if (quoted && !quoting_allowed) return -1;	// error

  int j = strlen(SqlciParse_OriginalStr) - 1;

  // skip any blanks between end of SqlciParse_OriginalStr and the semicolon.
  while (isspace(SqlciParse_OriginalStr[j])) j--;

  j--;						// skip semicolon

  while (j >= i &&				// skip trailing blanks
	 isspace(SqlciParse_OriginalStr[j])) j--;

  if (j < i && quoted) return -1;		// error: unmatched begin quote

  if (SqlciParse_OriginalStr[j] == delimQuote)
    {
      if (!quoted) return -1;			// error: unmatched end quote
      quoted = +1;
      j--;
    }
  if (quoted < 0) return -1;			// error: unmatched begin quote

  if (j >= i)
    if (quoted)
      {
	// if nonempty string within quotes, convert any embedded pair of quotes
	// (i.e. a quoted quote) into one quote, by left shifting
	//
	// **this modifies SqlciParse_OriginalStr (which points to the same
	// **buffer as SqlciParse_InputStr)!

	//#ifdef NA_WINNT
   SqlciParse_OriginalStr[j+1] = '\0';	// mark end of value text
   //#else
   // Remove the trailing single quote, but save the semi-colon on the TANDEM
   // platform.
   //   SqlciParse_OriginalStr[j+1] = '\;';	// replace quote with a semi-colon
   //   SqlciParse_OriginalStr[j+2] = '\0';	// mark end of string
   //#endif // NA_WINNT

	for (j = i; SqlciParse_OriginalStr[j]; j++)
	  if (SqlciParse_OriginalStr[j] == delimQuote)
	    {
	      if (SqlciParse_OriginalStr[j+1] != delimQuote)
		return -1;			// error: unmatched embedded q
                
              NAString temptrail(&SqlciParse_OriginalStr[j+1]);
 
	      strcpy(&SqlciParse_OriginalStr[j], temptrail);
	    }
	  j--;
      }
    else if (quoting_allowed)
      {
        // if nonempty nonquoted string -- but quoting allowed --
	// then any embedded quotes or blanks are an error
	for (int k = i; k <= j; k++)
	  if (SqlciParse_OriginalStr[k] == delimQuote ||
	      isspace(SqlciParse_OriginalStr[k]))
	    {
	      SqlciParse_InputPos = j;		// for sqlcierror message
	      return -1;			// error
	    }
      }
    //else embedded quotes allowed and passed thru unchanged

  if (keepValueTextAsIs)
  {
    TrimNAStringSpace(origValueText, 0/*false*/ /*leading?*/, 1/*true*/ /*trailing?*/);
    if (origValueText.data()[origValueText.length()-1] == ';')
      origValueText.remove(origValueText.length()-1);
    TrimNAStringSpace(origValueText, 0/*false*/ /*leading?*/, 1/*true*/ /*trailing?*/);
    strcpy(&SqlciParse_OriginalStr[i_orig], origValueText.data());
    len = origValueText.length();
  }
  else
    len = j - i + 1;
  if (len < 0) len = 0;
 
  if ( quoted ) {
    if ( cs == CharInfo::UnknownCharSet ) {
      if (pQuotedStrWithoutPrefixFlag != NULL)
        *pQuotedStrWithoutPrefixFlag = eQUOTED_STRING_WITHOUT_CHARSET_PREFIX;
      cs = SqlciEnvGlobal->getTerminalCharset();
    }

  } else 
    inhexdecimal = 0; // reset the hex indicator if the value is not quoted.

  // Consumed entire input (need this for pre-YYACCEPT test in sqlci_cmd).
  // Of course, a subsequent call to this routine on the same string will
  // have to use the use_i_as_is parameter and pass in a valid i ...
  //
  SqlciParse_InputPos = strlen(SqlciParse_OriginalStr) + 1;

  return 0;					// no error

} // trimValueText

static char * FCString (const char *idString, int isFC)
{
  char * cmd_str = new char[strlen(SqlciParse_OriginalStr)];
  cmd_str[0]='\0';

  // Skip leading blanks
  int i = 0;
  while (isspace(SqlciParse_OriginalStr[i]))
    i++;

  const char *s;  
  if (isFC)
    // i+2 - to skip the two characters of 'fc'
    s = strstr(&SqlciParse_OriginalStr[i+2], idString);
  else 
    s = strstr(&SqlciParse_OriginalStr[i], idString);
  
  if (s)
  {
    for ( ; *s; s++)
    {
  	  if (*s != ';')
      {
	     strncat (cmd_str, s, 1);
      }
    }
  }

  return cmd_str;
}

#define REPOSITION_SqlciParse_InputPos \
  	  { SqlciParse_InputPos = strlen(SqlciParse_InputStr); }

%}
%token NOSQL
%token CONTAINSQL
%token READSQL
%token MODIFYSQL
%token RESETVIOLATION
%token CHECKVIOLATION
%token NoAutoXact
%token DESCRIBEToken
%token CREATECONTEXT
%token CURRENTCONTEXT
%token SWITCHCONTEXT
%token DELETECONTEXT
%token RESETCONTEXT
%token ADDtoken
%token ALLtoken
%token BACKSLASH
%token BRIEF
%token DETAIL
%token CANCEL
%token CLASStoken
%token CLEANUP
%token CLEAR
%token COMMA
%token COMMANDStoken
%token CONTROL
%token OSIM
%token COPY
%token CPU_VALUE
%token ERRORtoken 
%token DEFAULTtoken
%token DEFAULT_CHARSETtoken
%token DISPLAY
%token DISPLAY_STATISTICS
%token DISPLAY_QUERYID
%token DISPLAY_EXPLAIN
%token DISPLAY_QC
%token DISPLAY_QC_ENTRIES
%token DISPLAY_QC_ENTRIES_NOTIME
%token DISPLAY_USE_OF
%token EDIT
%token MXCI_TOK_ENV
%token EXIT
%token EXPLAIN
%token FIRST
%token FC
%token FILEtoken
%token FILEINFO
%token FILENAMES
%token FILES
%token GENERATEtoken
%token MERGEtoken
%token METADATAtoken
%token REPLICATEtoken
%token GETtoken
%token GETSTATISTICStoken
%token HISTORY
%token HYPHEN
%token INFER_CHARSET
%token INFOtoken
%token INtoken
%token INFILE
%token SHOWSTATS
%token SHOWTRANSACTION
%token INVOKE
%token LISTCOUNT
%token LISTMODULES
%token LOADtoken
%token EXTRACTtoken
%token LOCK
%token LOCKINGtoken
%token LPAREN
%token MAPtoken
%token MIGRATE
%token MODE
%token MODIFY
%token MODIFYV
%token NEXT
%token NOEtoken
%token OBEY
%token OBJECTtoken
%token OFtoken
%token OFF
%token ON
%token OPTIONStoken
%token ISO_MAPPING
%token OUTFILE
%token PARAM
%token PARSERFLAGS
%token SQ_LINUX_PATTERN
%token PATTERN_AS_IS
%token PID_VALUE
%token PROCEDUREtoken
%token PURGEDATA
%token POPULATE
%token VALIDATEtoken
%token QUIESCE
%token REFRESH
%token REPEAT
%token REPORT
%token RESET
%token RESULT
%token RPAREN
%token SETtoken
%token SETENV
%token SHOW
%token SHOWCONTROL
%token SHOWDDL
%token SHOWPLAN
%token SHOWSHAPE
%token SHOWSET
%token SQL
%token SQLINFO
%token SQLNAMES
%token STATEMENTtoken
%token STOREtoken
%token SYNTAX
%token SYSTEMtoken
%token EXAMPLE
%token STATISTICS
%token SET_TABLEtoken   
%token SET_TRANSACTIONtoken
%token TERMINAL_CHARSET
%token TRANSFORM
%token TRUNCATE
%token WITH 
%token UNLOCK
%token UPD_STATS
%token UPD_HIST_STATS
%token USERtoken
%token USING
%token TABLE
%token VALUES
%token VALIDATE
%token VERBOSE
%token VERIFY
%token VERSIONtoken
%token WAITtoken
%token DEFINEtoken ENVVARtoken PREPARED SESSIONtoken
%token LOG LS CD SH SHELL
%token SELECTtoken UPDATEtoken INSERTtoken DELETEtoken UPSERTtoken
%token ROWSETtoken REPOSITORYtoken
%token CREATE ALTER DROP PREPAREtoken EXECUTEtoken FROM
%token DECLAREtoken OPENtoken CLOSEtoken FETCHtoken DEALLOCtoken 
%token CURSORtoken FORtoken CPU PID QID ACTIVEtoken ACCUMULATEDtoken
%token PERTABLEtoken PROGRESStoken 
%token TOK_BEGIN COMMIT ROLLBACK WORK
%token SQLCI_CMD SQL_STMT UTIL_STMT EXIT_STMT ERROR_STMT SHELL_CMD
%token IDENTIFIER NUMBER PARAM_NAME PATTERN_NAME FILENAME
%token QUOTED_STRING
%token DQUOTED_STRING
%token GRANTtoken REVOKEtoken
%token REGISTER UNREGISTER
%token GIVE 
%token INITIALIZE REINITIALIZE
%token CATALOG SCHEMA
%token HIVEtoken
%token PROCESStoken
%token IF WHILE
%token MPLOC
%token NAMETYPE
%token SIGNAL
%token UIDtoken
%token CURSORWITH
%token WITHOUT
%token HOLD
%token INTERNAL  
%token MVLOG
%token UNLOAD   

%token CALLToken
%token COMMENTtoken

%union {
	 enum ComRoutineSQLAccess sql_access_mode_type;
	 SqlCliCmd * sqlcli_cmd_type;
         SqlciCmd * sqlci_cmd_type;
         SqlciNode * sql_cmd_type;
	 ShellCmd * shell_cmd_type;
         int intval_type;
	 char * stringval_type;
	 dml_type dml_stmt_type;
	 Reset::reset_type reset_stmt_type_;
	 Show::show_type show_stmt_type_;
         SqlciCursorInfo *cursor_info_type_;
       }

%type <sql_access_mode_type> sql_access_mode;
%type <sqlcli_cmd_type> sqlcli_cmd
%type <sqlci_cmd_type> sqlci_cmd
%type <sql_cmd_type> sql_cmd
%type <shell_cmd_type> shell_cmd
%type <stringval_type> IDENTIFIER
%type <stringval_type> PARAM_NAME
%type <stringval_type> PATTERN_NAME
%type <stringval_type> PID_VALUE
%type <stringval_type> CPU_VALUE
%type <stringval_type> QUOTED_STRING
%type <stringval_type> DQUOTED_STRING
%type <stringval_type> NUMBER
%type <stringval_type> FILENAME
%type <dml_stmt_type> dml_type
%type <dml_stmt_type> dml_simple_table_type
%type <reset_stmt_type_> reset_type_;
%type <show_stmt_type_> show_type_;
%type <stringval_type> section_name_;
%type <stringval_type> HYPHEN;
%type <intval_type>    commands_only;
%type <intval_type>    stats_active_clause;
%type <intval_type>    stats_merge_clause;
%type <stringval_type> explain_options;
%type <cursor_info_type_> cursor_info;
%type <intval_type> optional_rs_index;
%type <stringval_type> qid_identifier;

%start statement
%%
statement :	sqlcli_cmd
		{

		   SqlciParseTree = (SqlciNode *) $1;
		   YYACCEPT;

		}

	|	sqlci_cmd
		{
			// Accept if we're at/past the end of the cmd
			// or if only blanks and semicolons remain;
			// otherwise, syntax error.
			//
			unsigned pos = SqlciParse_InputPos-1;
			if (pos < strlen(SqlciParse_InputStr))
			  {
			    const char *s = &SqlciParse_InputStr[pos];
			    for ( ; *s; s++)
			      if (!isspace(*s) && *s != ';')
				{sqlcierror("");YYERROR;}
			  }


		   	SqlciParseTree = (SqlciNode *) $1;
			YYACCEPT;
		}

	|	sql_cmd
		{
		   	SqlciParseTree = (SqlciNode *) $1;
			YYACCEPT;
		}

	|	shell_cmd
		{
		   	SqlciParseTree = (SqlciNode *) $1;
			YYACCEPT;
		}
;

sqlcli_cmd :	CHECKVIOLATION
		{
		  $$ = new CheckViolation();
		}
	    |	RESETVIOLATION sql_access_mode
		{
		  $$ = new ResetViolation($2);
		}
	    |	CREATECONTEXT
		{
		  $$ = new CreateContext();
		}
	    |	CREATECONTEXT NoAutoXact
		{
		  $$ = new CreateContext(TRUE/* noAutoXact */);
 		}
            |   CURRENTCONTEXT
                {
		  $$ = new CurrentContext();
		}
	    |	SWITCHCONTEXT NUMBER
		{
		  $$ = new SwitchContext(atoi($2));
		}

	    |	DELETECONTEXT NUMBER
		{
		  $$ = new DeleteContext(atoi($2));
		}
	    |	RESETCONTEXT NUMBER
		{
		  $$ = new ResetContext(atoi($2));
		}
;

sql_access_mode :   NOSQL
		    {
		      $$ = COM_NO_SQL;
		    }
		|   CONTAINSQL
		    {
		      $$ = COM_CONTAINS_SQL;
		    }
		|   READSQL
		    {
		      $$ = COM_READS_SQL;
		    }
		|   MODIFYSQL
		    {
		      $$ = COM_MODIFIES_SQL;
		    }
;

sqlci_cmd :	MODE SQL
		  {
			$$ = new Mode (Mode::SQL_ , TRUE);
		  }	
		|   OBEY FILENAME section_name_
                  { 
			$$ = new Obey($2, strlen($2), $3);
		  }
		|	MXCI_TOK_ENV
		  { 
			$$ = new Env(0,0);
		  }
                |   USERtoken IDENTIFIER
                  {
                    char userName[strlen($2)+1];
                    for (size_t i=0; i < strlen($2); i++)
                      {
                        userName[i] = toupper($2[i]);
                      }
                    userName[strlen($2)] = 0;
                    $$ = new ChangeUser(userName, strlen(userName));
                  }
		|	REPEAT
          	  {
		    // "!" command, a la SQL/MP aRepeat (0,0);
			$$ = new FCRepeat (0,(short)0);
		  }
		|	REPEAT REPEAT
          	  {
		    // "!!" command, a la Unix csh
		    $$ = new FCRepeat (0,(short)0);
		  }
        |   REPEAT NUMBER
          {
		    $$ = new FCRepeat (atoi($2), 0);
		  }
        |   REPEAT HYPHEN NUMBER
          {
		    $$ = new FCRepeat (atoi($3), -1);
		  }
        |   REPEAT IDENTIFIER
          {
		   char *fcString = FCString ($2, 0);
               	   $$ = new FCRepeat(fcString, (long)strlen(fcString));
                   REPOSITION_SqlciParse_InputPos;
          }
        |   REPEAT LPAREN NUMBER RPAREN
          {
		    $$ = new FCRepeat (atoi($3), 0);
	  }
        |   FC
          {
		    $$ = new FixCommand(0, (short)0);
	  }
	|   FC NUMBER
          {
		    $$ = new FixCommand(atoi($2), 0);
	  }
	|  FC HYPHEN NUMBER
          {
		    $$ = new FixCommand(atoi($3), -1);
	  }
	| FC IDENTIFIER
          {
		   char *fcString = FCString ($2, 1);
	           $$ = new FixCommand(fcString, (long)strlen(fcString));
	           REPOSITION_SqlciParse_InputPos;
          }
		| FC LPAREN NUMBER RPAREN
          {
		   $$ = new FixCommand(atoi($3), 0);
          }
		| LOG IDENTIFIER commands_only
         {
		   identifier_name_internal = new char[strlen($2)+1];
		   strcpy(identifier_name_internal, $2);
		 }
		 CLEAR
         { 
			$$ = new Log(identifier_name_internal, strlen(identifier_name_internal), Log::CLEAR_, $3);
		 }
	    |	LOG IDENTIFIER commands_only 
		 { 
			$$ = new Log($2, strlen($2), Log::APPEND_, $3);
		 }
    
		|	LOG FILENAME commands_only
         {
		   identifier_name_internal = new char[strlen($2)+1];
		   strcpy(identifier_name_internal, $2);
		 }
		 CLEAR
           {
	   $$ = new Log(identifier_name_internal, strlen(identifier_name_internal), Log::CLEAR_, $3);
		 }

		|	LOG FILENAME commands_only

		 { 
			$$ = new Log($2, strlen($2), Log::APPEND_, $3);
		 }

		|	LOG
		  { 
			$$ = new Log(0,0, Log::STOP_, 0);
		  }

		|	HISTORY
		  { 
			$$ = new History(0,0);   
		  }

		|	HISTORY NUMBER
		  { 
			$$ = new History($2,strlen($2));
		  }

		|	EXIT
                  { 
			$$ = new Exit(0,0);
		  }
        |       ERRORtoken NUMBER
                  { 
		  $$ = new Error($2, strlen($2), Error::DETAIL_);
		  }
        |       ERRORtoken NUMBER COMMA BRIEF
                  { $$ = new Error($2, strlen($2), Error::BRIEF_);
		  }
        |       ERRORtoken NUMBER COMMA DETAIL
                  { $$ = new Error($2, strlen($2), Error::DETAIL_);
		  }

	|	SETtoken PARAM PARAM_NAME
		  {
		    int i, len, quoted;
                    CharInfo::CharSet cs;
                    int inhexadecimal;
                    EQuotedStringWithoutPrefixFlag quotedStrWithoutPrefixFlag;

		    if (trimValueText(i, len, quoted, cs, inhexadecimal, -1, 0, -1,
                                      &quotedStrWithoutPrefixFlag)) {sqlcierror("");YYERROR;}
		    //if (len <= 0 && !quoted) 	       {sqlcierror("");YYERROR;}

		    // see if input was of form "set param ?p null;".
		    // If yes, this param is a null value.
		    short null_param_val = 0;
		    if (len == 4 && !quoted)
		      {
			char buf[4];
			for (int k = 0; k < 4; k++)
			  buf[k] = toupper(SqlciParse_OriginalStr[i+k]);

			null_param_val = (strncmp(buf, "NULL", 4) == 0);
		      }

		    if (null_param_val)
		      $$ = new SetParam($3, strlen($3), (char*)0, -1);
		    else {
                      char* pvalue = &SqlciParse_OriginalStr[i];

                      if ( inhexadecimal ) {

                         NAWString pvalue_in_wchar(CharInfo::ISO88591, pvalue);

                         void* result = NULL;
                         enum hex_conversion_code code = 
                           verifyAndConvertHex(pvalue_in_wchar, pvalue_in_wchar.length(), 
                                               L'\'', cs, &sqlci_Heap, result);

                         switch ( code ) {

                           case SINGLE_BYTE:
                           {
                             NAString* conv_pvalue = (NAString*)result;

		             $$ = new SetParam($3, strlen($3), 
                                               (char*)(conv_pvalue->data()), conv_pvalue->length(), cs);
                             if (quotedStrWithoutPrefixFlag == eQUOTED_STRING_WITHOUT_CHARSET_PREFIX)
                             {
                               NAWString wstr(SqlciEnvGlobal->getTerminalCharset(),
                                              conv_pvalue->data(), conv_pvalue->length());
                               SetParam * pSetParam = (SetParam *)$$;
                               pSetParam->setUTF16ParamStrLit(wstr.data(), wstr.length());
                               pSetParam->setQuotedStrWithoutPrefixFlag(TRUE);
                               pSetParam->setTermCharSet(SqlciEnvGlobal->getTerminalCharset());
                             }
// NADELETE() is not a const func while this routine is. Mask out the warning
                             NADELETE(conv_pvalue, NAString, &sqlci_Heap);
                           } 
                           break;

                           case DOUBLE_BYTE:
                           {
                             NAWString* conv_pvalue = (NAWString*)result;
		             $$ = new SetParam($3, strlen($3), 
                                               (NAWchar*)(conv_pvalue->data()), conv_pvalue->length(), cs);
// NADELETE() is not a const func while this routine is. Mask out the warning
                             NADELETE(conv_pvalue, NAWString, &sqlci_Heap);
                           } 
                           break;

                           default:
                             sqlcierror("");YYERROR;
                         }
                      } else {

                        switch (cs) {
                           case CharInfo::UNICODE:
                            {
                               NAWString wstr(SqlciEnvGlobal->getTerminalCharset(), pvalue, len); 
		               $$ = new SetParam($3, strlen($3), (NAWchar*)wstr.data(), wstr.length(), cs);
                            }
                            break;

                           case CharInfo::KANJI_MP:
                           case CharInfo::KSC5601_MP:

                            if ( len % 2 != 0 )
                              { 
                                // restore the closing two single quotes and ';' removed 
                                // inside the trimValueText() call. The string starts 
                                // at pvalue. We guarantee to have enough space here 
                                // because trimValueText() will bail out if no single 
                                // quotes present.

                                // We need to restore the closing single quotes and ';'
                                // so that in the second attempt of sqlci cmd parsing,
                                // the error can be caught again. Otherwise, _kanji'a' 
                                // becomes _kanjia after first parsing attempt. That
                                // string is legal and is different than the one actually
                                // typed. 

                                // It is difficult to remove the KLRUGE of 2nd parsing
                                // attempt in sqlciparser.cpp, func sqlci_parser().
                                // A lot of regressions will fail if we do so.
                                int k = strlen(pvalue);

                                for ( int x=k; x>=1; x-- ) {
                                  pvalue[x] = pvalue[x-1];
                                }
                                *pvalue = '\'';
                                *(pvalue+k+1) = '\'';
                                *(pvalue+k+2) = ';';
                                *(pvalue+k+3) = '\0';

                                sqlcierror("");YYERROR; 
                              }

		            $$ = new SetParam($3, strlen($3), (NAWchar*)pvalue, len/2, cs);
                            break;

                            // case CharInfo::ISO88591:
                            // case CharInfo::UTF8:
                            // case CharInfo::SJIS:
                            // case CharInfo::GB2312:
                            // case CharInfo::GBK:
                            // case CharInfo::...:
                           default:
                            {
                              SetParam * pSetParam = NULL;
                              if (quotedStrWithoutPrefixFlag == eQUOTED_STRING_WITHOUT_CHARSET_PREFIX)
                              {
                                // SqlciEnvGlobal->getInferCharset() == TRUE || FALSE
                                pSetParam = new SetParam($3, strlen($3), pvalue, len, cs);
                                NAWString wstr(cs, pvalue, len);
                                pSetParam->setUTF16ParamStrLit(wstr.data(), wstr.length());
                                pSetParam->setQuotedStrWithoutPrefixFlag(TRUE);
                                pSetParam->setTermCharSet(SqlciEnvGlobal->getTerminalCharset());
                              }
                              else
                                pSetParam = new SetParam($3, strlen($3), pvalue, len, cs);
                              $$ = pSetParam;
                            }
                            break;
                            
                        }
                      }
                    }
		  }

	|	SETtoken SQ_LINUX_PATTERN PATTERN_NAME
		  {
		    int i, len, quoted;
                    CharInfo::CharSet cs;
                    int inhexadecimal;
		    if (trimValueText(i, len, quoted, cs, inhexadecimal)) {sqlcierror("");YYERROR;}
		    $$ = new SetPattern($3, strlen($3),
					&SqlciParse_OriginalStr[i], len);
		  }

	|	SETtoken PATTERN_AS_IS PATTERN_NAME
		  {
		    int i, len, quoted;
		    CharInfo::CharSet cs;
		    int inhexadecimal;
		    EQuotedStringWithoutPrefixFlag quotedStrWithoutPrefixFlag;
		    if ( trimValueText( i, len, quoted, cs, inhexadecimal
		                      , -1/*true*/ // quoting_allowed?
		                      , 0/*false*/ // use_i(1st_param)_as_is?
		                      , -1/*true*/ // cs_allowed?
		                      , &quotedStrWithoutPrefixFlag
		                      , -1/*true*/ // keepValueTextAsIs
		                      ) )
		    {sqlcierror("");YYERROR;}
		    $$ = new SetPattern($3, strlen($3),
					&SqlciParse_OriginalStr[i], len);
		  }

        |       SETtoken SHOWSHAPE ON
                  {
		    $$ = new Shape(TRUE, NULL, NULL);
		  }

        |       SETtoken SHOWSHAPE OFF
                  {
		    $$ = new Shape(FALSE, NULL, NULL);
		  }

        |       SETtoken SHOWSHAPE INFILE FILENAME 
                  {
		    identifier_name_internal = new char[strlen($4)+1];
		    strcpy(identifier_name_internal, $4);
		  }
                OUTFILE FILENAME
                  {
		    $$ = new Shape(FALSE, identifier_name_internal, $7);
                  }

	|       SETtoken STATISTICS OFF
                  {
		    $$ = new Statistics(0,0,Statistics::SET_OFF, NULL);
		  }

        |       SETtoken STATISTICS ON
                  {
		    // display statistics in old format
		    $$ = new Statistics(NULL, 0, Statistics::SET_ON,
					(char *)"of");
             	  }

        |       SETtoken STATISTICS PERTABLEtoken
                  {
		    $$ = new Statistics(NULL, 0, Statistics::SET_ON,
					(char *)"PERTABLE");
		  }

        |       SETtoken STATISTICS PROGRESStoken
                  {
		    $$ = new Statistics(NULL, 0, Statistics::SET_ON,
					(char *)"PROGRESS");
		  }

        |       SETtoken STATISTICS DEFAULTtoken
                  {
		    $$ = new Statistics(NULL, 0, Statistics::SET_ON,
					(char *)"DEFAULT");
		  }

        |       SETtoken STATISTICS ALLtoken
                  {
		    $$ = new Statistics(NULL, 0, Statistics::SET_ON,
					(char *)"ALL");
		  }


        |       SETtoken STATISTICS ON COMMA GETtoken STATISTICS
                  {
		    // display stats in new format
		    $$ = new Statistics(NULL, 0, Statistics::SET_ON, NULL);
		  }

        |       SETtoken STATISTICS ON COMMA GETtoken STATISTICS COMMA OPTIONStoken QUOTED_STRING
                  {
		    // display stats in new format based on options in
		    // quoted_string
		    $$ = new Statistics(NULL, 0, Statistics::SET_ON,
					$9);
                  }

        |       SETtoken LISTCOUNT NUMBER
                  {
                    $$ = new ListCount($3, strlen($3));
                  }

        |       SETtoken LISTCOUNT
		  {
		    if ((sqlcitext) && (sqlcitext[0] != ';'))
		      {sqlcierror("");YYERROR;}

		    $$ = new ListCount(0, 0);
		  }

	|	SETtoken VERBOSE ON
		{
		    $$ = new Verbose(0, 0, Verbose::SET_ON);
		}

	|	SETtoken VERBOSE OFF
		{
		    $$ = new Verbose(0, 0, Verbose::SET_OFF);
		}

	|	SETtoken TERMINAL_CHARSET IDENTIFIER
		{
		    $$ = new SetTerminalCharset($3);
		}
	|	SETtoken ISO_MAPPING IDENTIFIER
		{
		    $$ = new SetIsoMapping($3);
		}

	|	SETtoken DEFAULT_CHARSETtoken IDENTIFIER
		{
		    $$ = new SetDefaultCharset($3);
		}

	|	SETtoken INFER_CHARSET NUMBER
		{
		    $$ = new SetInferCharset($3);
		}

	|	SETtoken INFER_CHARSET IDENTIFIER
		{
		    $$ = new SetInferCharset($3);
		}

	|	SETtoken INFER_CHARSET ON
		{
		    $$ = new SetInferCharset((char *)"TRUE");
		}

	|	SETtoken INFER_CHARSET OFF
		{
		    $$ = new SetInferCharset((char *)"FALSE");
		}

        |      SETtoken QID IDENTIFIER
                {
                  // save qid val.
                   identifier_name_internal = new char[strlen($3)+1]; 
                   str_cpy_convert(identifier_name_internal, $3, strlen($3), TRUE); 
                   identifier_name_internal[strlen($3)] = 0;
                }
              FORtoken 
                {
                  pos_internal = SqlciParse_InputPos;
                }
              IDENTIFIER
                {
                  // remove trailing ";"
                  char * id = &SqlciParse_OriginalStr[pos_internal];
                  Lng32 i = strlen(&SqlciParse_OriginalStr[pos_internal]) -1;
                  while ((i > 0) && (id[i] != ';'))
                    i--;
                  id[i] = 0;

                  char * id2 = new char[strlen(id)+1];
                  str_cpy_convert(id2, id, strlen(id), TRUE);
                  id2[strlen(id)] = 0;
                  $$ = new QueryId (id2, strlen(id2),
                                    TRUE, identifier_name_internal);
                }

	|	RESET PARAM PARAM_NAME
		  {
		    $$ = new Reset(Reset::PARAM_, $3, strlen($3));
		  }
	|	RESET SQ_LINUX_PATTERN PATTERN_NAME
		  {
		    $$ = new Reset(Reset::PATTERN_, $3, strlen($3));
		  }
	|	RESET reset_type_
		  {
		    if ((sqlcitext) && (sqlcitext[0] != ';'))
		      {sqlcierror("");YYERROR;}

		    $$ = new Reset($2);
		  }

	|	SHOW show_type_
		  {
		    $$ = new Show($2, TRUE);
		  }
    |       DISPLAY_QUERYID FORtoken IDENTIFIER
                  {
                    identifier_name_internal = new char[strlen($3)+1]; 
                    str_cpy_convert(identifier_name_internal, $3, strlen($3), TRUE); 
                    identifier_name_internal[strlen($3)] = 0;
                    $$ = new QueryId (identifier_name_internal,strlen(identifier_name_internal),
                                      FALSE, NULL);
                  }
    |       DISPLAY_QUERYID
                  {
                    $$ = new QueryId (0,0, FALSE, NULL);
                  }


        |       SHOW PREPARED
		  {
		    if ((sqlcitext) && (sqlcitext[0] != ';'))
		      {sqlcierror("");YYERROR;}

		    $$ = new Show(Show::PREPARED_, TRUE);
		  }

        |       SHOW PREPARED ALLtoken
		  {
		    $$ = new Show(Show::PREPARED_, TRUE);
		  }

        |       WAITtoken
                  {
                    $$ = new Wait(NULL, 0);
                  }

;

commands_only :
               COMMANDStoken   { $$ = 1; }
             | empty { $$ = 0; }
;

empty :
;

section_name_:
	        LPAREN IDENTIFIER RPAREN  {$$ = $2;}
     	|	                          {$$ = 0;}
;

reset_type_ :
                PARAM   	{$$ = Reset::PARAM_;}
;

show_type_ :
                CURSORtoken     {$$ = Show::CURSOR_;}
        |       PARAM    	{$$ = Show::PARAM_;}
        |       SQ_LINUX_PATTERN  	{$$ = Show::PATTERN_;}
        |       SESSIONtoken  	{$$ = Show::SESSION_;}
        |       VERSIONtoken  	{$$ = Show::VERSION_;}
;


stats_active_clause :
               ACTIVEtoken NUMBER       { $$ = atoi($2); }
             | ALLtoken                 { $$ = 0; }
             | empty                    { $$ = 1; }
;

stats_merge_clause :
               ACCUMULATEDtoken       { $$ = SQLCLI_ACCUMULATED_STATS; }
             | PERTABLEtoken          { $$ = SQLCLI_PERTABLE_STATS; }
             | PROGRESStoken          { $$ = SQLCLI_PROGRESS_STATS; }
             | DEFAULTtoken           { $$ = SQLCLI_SAME_STATS; }
             | empty                  { $$ = SQLCLI_DEFAULT_STATS; }
;

qid_identifier :             
               IDENTIFIER              
               { 
                // Convert IDENTIFIER to uppercase
                identifier_name_internal2 = new char[strlen($1)+1];
		str_cpy_convert(identifier_name_internal2, $1, strlen($1), TRUE); 
                identifier_name_internal2[strlen($1)] = '\0';
                $$ = identifier_name_internal2;
              } 
            | DQUOTED_STRING          
            { 
                // keep Double Quoted String as is                
                identifier_name_internal2 = new char[strlen($1)+1];
                strcpy(identifier_name_internal2, $1);
                $$ = identifier_name_internal2;
            } 
;

sql_cmd :
		dml_type
			{
                          $$ = new DML(SqlciParse_OriginalStr, $1, NULL);
                          REPOSITION_SqlciParse_InputPos;
			}

        |       DECLAREtoken IDENTIFIER 
			{
			  identifier_name_internal = new char[strlen($2)+1];
			  str_cpy_convert(identifier_name_internal, $2,
					  strlen($2), TRUE);
			  identifier_name_internal[strlen($2)] = 0;
			}
                CURSORWITH HOLD FORtoken
			{
			  pos_internal = SqlciParse_InputPos;
			}
		       dml_simple_table_type
			{
			  $$ = 
	   		    new Cursor(identifier_name_internal, 
				       Cursor::DECLARE, -1,
				       &SqlciParse_OriginalStr[pos_internal]);
			  REPOSITION_SqlciParse_InputPos;

			  ((Cursor *)$$)->setHoldable(TRUE);
			}

        |       DECLAREtoken IDENTIFIER 
			{
			  identifier_name_internal = new char[strlen($2)+1];
			  str_cpy_convert(identifier_name_internal, $2,
					  (long) strlen($2), TRUE);
			  identifier_name_internal[strlen($2)] = 0;
			}
                CURSORtoken FORtoken
			{
			  pos_internal = (int) SqlciParse_InputPos;
			}
	        cursor_info
			{
                          SqlciCursorInfo *cinfo = $7;

			  Cursor *c = new
                            Cursor(identifier_name_internal, 
                                   Cursor::DECLARE,
                                   (short) cinfo->queryTextSpecified_,
                                   cinfo->queryTextOrStmtName_);

                          c->setResultSetIndex(cinfo->resultSetIndex_);

                          $$ = c;

                          delete [] identifier_name_internal2;
                          identifier_name_internal2 = NULL;

                          delete cinfo;

			  REPOSITION_SqlciParse_InputPos;
			}

        |       OPENtoken IDENTIFIER
			{
			  identifier_name_internal = new char[strlen($2)+1];
			  str_cpy_convert(identifier_name_internal, $2,
					  strlen($2), TRUE);
			  identifier_name_internal[strlen($2)] = 0;
			  $$ = 
			    new Cursor(identifier_name_internal, 
				       Cursor::OPEN, 0, NULL);
			}

        |       FETCHtoken IDENTIFIER
			{
			  identifier_name_internal = new char[strlen($2)+1];
			  str_cpy_convert(identifier_name_internal, $2,
					  strlen($2), TRUE);
			  identifier_name_internal[strlen($2)] = 0;
			  $$ = 
			    new Cursor(identifier_name_internal, 
				       Cursor::FETCH, 0, NULL);
			}

        |       CLOSEtoken IDENTIFIER
			{
			  identifier_name_internal = new char[strlen($2)+1];
			  str_cpy_convert(identifier_name_internal, $2,
					  strlen($2), TRUE);
			  identifier_name_internal[strlen($2)] = 0;
			  $$ = 
			    new Cursor(identifier_name_internal, 
				       Cursor::CLOSE, 0, NULL);
			}

        |       DEALLOCtoken IDENTIFIER
			{
			  identifier_name_internal = new char[strlen($2)+1];
			  str_cpy_convert(identifier_name_internal, $2,
					  strlen($2), TRUE);
			  identifier_name_internal[strlen($2)] = 0;
			  $$ = 
			    new Cursor(identifier_name_internal, 
				       Cursor::DEALLOC, 0, NULL);
			}

		|	PREPAREtoken IDENTIFIER
			{
			  identifier_name_internal = new char[strlen($2)+1];
			  str_cpy_convert(identifier_name_internal, $2,
					  strlen($2), TRUE);
			  identifier_name_internal[strlen($2)] = 0;
			}
			FROM
			{
			  pos_internal = SqlciParse_InputPos;
			}
			dml_type
			{
			  $$ = new Prepare(identifier_name_internal,
				     &SqlciParse_OriginalStr[pos_internal], $6);
			  REPOSITION_SqlciParse_InputPos;
			}

		|	DESCRIBEToken IDENTIFIER
			{
			  identifier_name_internal = new char[strlen($2)+1];
			  str_cpy_convert(identifier_name_internal, $2,
					  strlen($2), TRUE);
			  identifier_name_internal[strlen($2)] = 0;
			  $$ = new DescribeStmt(identifier_name_internal, identifier_name_internal);
			}

		|	EXECUTEtoken IDENTIFIER
			{
			  // ## This kind of foolishness could be partly done
			  // ## away with, consolidated at least, if most of
			  // ## these "sql_cmd" productions were made
			  // ## "sqlci_cmd" ones (the pre-YYACCEPT logic for
			  // ## the latter would handle this generically).
			  if (sqlcitext[0] && sqlcitext[0] != ';')
			    {sqlcierror("");YYERROR;}

			  identifier_name_internal = new char[strlen($2)+1];

			  str_cpy_convert(identifier_name_internal, $2,
					  strlen($2), TRUE);
			  identifier_name_internal[strlen($2)] = 0;

                          $$ = new Execute(identifier_name_internal, 
                                           identifier_name_internal, 0/*flag*/, SqlciEnvGlobal);
			}

		|	EXECUTEtoken IDENTIFIER
			{
			  identifier_name_internal = new char[strlen($2)+1];

			  str_cpy_convert(identifier_name_internal, $2,
					  strlen($2), TRUE);
			  identifier_name_internal[strlen($2)] = 0;
            }
            USING
            {
              pos_internal = SqlciParse_InputPos;
			  if (SqlciParse_OriginalStr[pos_internal-1] == ',')
			    pos_internal--;
                          $$ = new Execute(identifier_name_internal, 
                                           &SqlciParse_OriginalStr[pos_internal], 1/*flag*/, SqlciEnvGlobal);

            }

	|	DISPLAY_EXPLAIN explain_options IDENTIFIER
			{
			  // returns "EXPLAIN [options 'x'] id;", sets deprecated warning
			  // The +16 allows space to add "options 'm' " when defaulted
			  long newStrLen = strlen(SqlciParse_OriginalStr) + 16;
			  char * newStr = new char[newStrLen+1];
			  if ($2)
			    {
			      strcpy(newStr, "EXPLAIN options '");
			      strcat(newStr, $2);
			      strcat(newStr, "' ");
			    }
			  else
			    {
			      strcpy(newStr, "EXPLAIN options 'm' ");
			    }
			  identifier_name_internal = new char[strlen($3)+1];

			  str_cpy_convert(identifier_name_internal, $3,
					  strlen($3), TRUE);
			  identifier_name_internal[strlen($3)] = 0;
			  strcat(newStr, identifier_name_internal);
			  strcat(newStr, ";");
			  sqlci_DA << DgSqlCode(15039);

			  $$ = new DML(newStr, DML_DESCRIBE_TYPE, NULL);

			  delete identifier_name_internal;
			  delete newStr;
                        }

	|	DISPLAY_EXPLAIN explain_options PROCEDUREtoken 
			{
			  // Not a user-documented feature
			  // returns "EXPLAIN [options 'x'] procedure();", sets deprecated warning
			  // The +16 allows space to add "options 'm' " when defaulted
			  long newStrLen = strlen(SqlciParse_OriginalStr) + 16;
			  char * newStr = new char[newStrLen+1];
			  if ($2)
			    {
			      strcpy(newStr, "EXPLAIN ");
			    }
			  else
			    {
			      strcpy(newStr, "EXPLAIN options 'm' ");
			    }
			  strcat(newStr, 
				 &SqlciParse_OriginalStr[strlen("DISPLAY_EXPLAIN")]);
			  sqlci_DA << DgSqlCode(15039);
			  $$ = new DML(newStr,
				       DML_DESCRIBE_TYPE, NULL);
			  REPOSITION_SqlciParse_InputPos;
			  delete newStr;

                        }

	|	DISPLAY_EXPLAIN	explain_options dml_type
			{
			  // returns "EXPLAIN [options 'x'] SQL-cmd;", sets deprecated warning
			  // The +16 allows space to add "options 'm' " when defaulted
			  long newStrLen = strlen(SqlciParse_OriginalStr) + 16;
			  char * newStr = new char[newStrLen+1];
			  if ($2)
			    {
			      strcpy(newStr, "EXPLAIN ");
			    }
			  else
			    {
			      strcpy(newStr, "EXPLAIN options 'm' ");
			    }
			  strcat(newStr, 
				 &SqlciParse_OriginalStr[strlen("DISPLAY_EXPLAIN")]);
			  sqlci_DA << DgSqlCode(15039);
			  $$ = new DML(newStr,
				       DML_DESCRIBE_TYPE, NULL);
			  REPOSITION_SqlciParse_InputPos;
			  delete newStr;
			}

	| 	DISPLAY_STATISTICS
                  {
		    long newStrLen = 
		      strlen("GET STATISTICS , options 'of';");
		    char * newStr = new char[newStrLen+1];
		    strcpy(newStr, "GET STATISTICS , options 'of';");
		    $$ = new DML(newStr, DML_DESCRIBE_TYPE, NULL);
		    
		    delete newStr;
		  }

	| 	DISPLAY_STATISTICS IDENTIFIER
                  {
		    identifier_name_internal = new char[strlen($2)+1];
		    
		    str_cpy_convert(identifier_name_internal, $2,
				    strlen($2), TRUE);
		    identifier_name_internal[strlen($2)] = 0;

		    long newStrLen = 
		      strlen("GET STATISTICS FOR STATEMENT , options 'of';"); 
		    newStrLen += strlen(identifier_name_internal);
		    char * newStr = new char[newStrLen+1];
		    strcpy(newStr, "GET STATISTICS FOR STATEMENT ");
		    strcat(newStr, identifier_name_internal);
		    strcat(newStr, ", options 'of';");
		    $$ = new DML(newStr, DML_DESCRIBE_TYPE, NULL);
		    
		    delete newStr;
		  }
        |   DISPLAY_STATISTICS FORtoken CPU NUMBER 
                  {
                    pos_internal = atoi($4);
                  }
                  stats_active_clause
                  {
                    pos_internal3 = $6;
                  }
                  stats_merge_clause
                  {
                    char * newStr = new char[200];
                    sprintf(newStr, "GET STATISTICS FOR CPU %d ACTIVE %d", 
                            pos_internal, pos_internal3);
                    if ($8 == SQLCLIDEV_ACCUMULATED_STATS)
                      strcat(newStr, " ACCUMULATED");
                    strcat(newStr, " ;");
                    $$ = new DML(newStr, DML_DESCRIBE_TYPE, NULL);
                    delete newStr;
                  }
        |   DISPLAY_STATISTICS FORtoken CPU CPU_VALUE 
                  {
                    // This is of the form "FOR CPU \DOPEY.1"
                    identifier_name_internal2 = new char[strlen($4)+1];  
                    str_cpy_convert (identifier_name_internal2, $4, strlen ($4), TRUE);
                    identifier_name_internal2[strlen($4)] = 0;
                  }
                  stats_active_clause
                  {
                    pos_internal3 = $6;
                  }
                  stats_merge_clause
                  {
                    
                    long strLen = 100+strlen(identifier_name_internal2);
                    char *newStr = new char[strLen];
                    sprintf( newStr, "GET STATISTICS FOR CPU %s ACTIVE %d",
                        identifier_name_internal2, pos_internal3);
                    if ($8 == SQLCLIDEV_ACCUMULATED_STATS)
                        strcat(newStr, " ACCUMULATED");
                    strcat(newStr, " ;");
                    $$ = new DML(newStr, DML_DESCRIBE_TYPE, NULL);
                    delete identifier_name_internal2;
                    delete newStr;
                  }
      |       DISPLAY_STATISTICS FORtoken PID NUMBER 
                  {
                    pos_internal = atoi ($4);
                  }
                  COMMA NUMBER 
                  {
                    pos_internal2 = atoi ($7);
                  }
                  stats_active_clause 
                  {
                    pos_internal3 = $9;
                    
                  }
                  stats_merge_clause
                  {
                    char *newStr = new char[200];
                    sprintf(newStr, "GET STATISTICS FOR PID %d,%d ACTIVE %d", 
                          pos_internal, pos_internal2, pos_internal3);
                    if ($11 == SQLCLIDEV_ACCUMULATED_STATS)
                        strcat(newStr, " ACCUMULATED");
                    strcat(newStr, " ;");
                    $$ = new DML(newStr, DML_DESCRIBE_TYPE, NULL);
                    delete newStr;
                  }
      |       DISPLAY_STATISTICS FORtoken PID PID_VALUE  
                  {
                    // This is of the form "FOR PID \DOPEY.1,5"
                    identifier_name_internal2 = new char[strlen($4)+1];  
                    str_cpy_convert (identifier_name_internal2, $4, strlen($4), TRUE);
                    identifier_name_internal2[strlen($4)] = 0;
                  }
                  stats_active_clause
                  {
                    pos_internal3 = $6;
                  }
                  stats_merge_clause
                  {
                    long strLen = 100 + strlen(identifier_name_internal2);
                    char *newStr = new char[strLen];
                    sprintf(newStr, "GET STATISTICS FOR PID %s ACTIVE %d", 
                      identifier_name_internal2, pos_internal3);
                    if ($8 == SQLCLIDEV_ACCUMULATED_STATS)
                        strcat(newStr, " ACCUMULATED");
                    strcat(newStr, " ;");
                    $$ = new DML(newStr, DML_DESCRIBE_TYPE, NULL);
                    delete identifier_name_internal2;
                    delete newStr;
                  }
      |       DISPLAY_STATISTICS FORtoken QID qid_identifier 
                  {
                    get_stats_str = new char[strlen($4)+100]; 
                    sprintf(get_stats_str, "GET STATISTICS FOR QID %s", $4);
                  }
                  stats_merge_clause
                  {
                    char *newStr1 = new char[25];
                    if ($6 == SQLCLI_ACCUMULATED_STATS)
                        strcpy(newStr1, " ACCUMULATED");
                    else if ($6 == SQLCLI_PERTABLE_STATS)
                        strcpy(newStr1, " PERTABLE");
                    else if ($6 == SQLCLI_PROGRESS_STATS)
                        strcpy(newStr1, " PROGRESS");
                    else if ($6 == SQLCLI_SAME_STATS)
                        strcpy(newStr1, " DEFAULT");
                    else
                        strcpy(newStr1, "");
				    strcat(get_stats_str, newStr1);
					strcat(get_stats_str, " ;");
					$$ = new DML(get_stats_str, DML_DESCRIBE_TYPE, NULL);
	                
					// delete id name internal2 allocated in qid_identifier
					if (identifier_name_internal2)
					{
					  delete [] identifier_name_internal2;
					  identifier_name_internal2 = NULL;
					}
					delete [] get_stats_str;
					delete [] newStr1;
				  }
	| DISPLAY_QC
	  {
	    $$ = new QueryCacheSt(0);
      }
	| DISPLAY_QC_ENTRIES
	  {
	    $$ = new QueryCacheSt(1);
      }
	| DISPLAY_QC_ENTRIES_NOTIME
	  {
	    $$ = new QueryCacheSt(2);
      }
	|	DISPLAY
			{
			  pos_internal = 7;
			}
		 dml_type
			{
			  $$ = new DML(SqlciParse_OriginalStr, $3,
				       "__SQLCI_DML_DISPLAY__");
			  REPOSITION_SqlciParse_InputPos;
			}
       |        GETtoken 
                        {
			  $$ = new DML(SqlciParse_OriginalStr, DML_DISPLAY_NO_HEADING_TYPE, NULL);
			  REPOSITION_SqlciParse_InputPos;
			}

       |        GETSTATISTICStoken
                        {
			  $$ = new DML(SqlciParse_OriginalStr, DML_DESCRIBE_TYPE, NULL);
			  REPOSITION_SqlciParse_InputPos;
			}

       |        GETtoken UIDtoken
                        {
			  $$ = new DML(SqlciParse_OriginalStr, DML_DESCRIBE_TYPE, NULL);
			  REPOSITION_SqlciParse_InputPos;
			}

		|	SETtoken ENVVARtoken IDENTIFIER
		  {
		    int i, len, quoted;
                    CharInfo::CharSet cs;
                    int inhexadecimal;
		    if (trimValueText(i, len, quoted, cs, inhexadecimal)) {sqlcierror("");YYERROR;}

		    char * evNam = new char[strlen($3)+1];
		    for (size_t k=0; k < strlen($3); k++)
		      {
			evNam[k] = toupper($3[k]);
		      }
		    evNam[strlen($3)] = 0;

		    char * evVal = NULL;
		    if (len <= 0)
		      {
			len = 1;
			evVal = new char[len + 1];
			strcpy(evVal, "1");
		      }
		    else
		      {
			evVal = new char[len+1];
			strncpy(evVal, &SqlciParse_OriginalStr[i], len);
			evVal[len] = 0;
		      }

		    $$ = new DML(SqlciParse_OriginalStr, DML_DESCRIBE_TYPE, NULL);

                    int j = setenv(evNam, evVal, 1); 
		    if (j) 
		      {
			delete [] evNam;
			delete [] evVal;

			cerr << "*** ERROR " << j << " from putenv." << endl;
			sqlcierror("");
			YYERROR;
		      }

		    REPOSITION_SqlciParse_InputPos;

		    Envvar * envvar = 
		      SqlciEnvGlobal->get_envvarlist()->get(evNam);
		    if (envvar)
		      {
			envvar->setValue(evVal);
		      }
		    else
		      {
			envvar = new Envvar(evNam, evVal);
			SqlciEnvGlobal->get_envvarlist()->append(envvar);
		      }
		    delete [] evNam;
		    delete [] evVal;
		  }

	|	RESET ENVVARtoken IDENTIFIER
		  {
		    char * evNam = new char[strlen($3)+1];
		    for (size_t k=0; k < strlen($3); k++)
		      {
			evNam[k] = toupper($3[k]);
		      }
		    evNam[strlen($3)] = 0;

		    $$ = new DML(SqlciParse_OriginalStr, DML_DESCRIBE_TYPE, NULL);
		    
		    long putenvLen = 0;
		    putenvLen += strlen(evNam);
		    putenvLen += strlen("=");
		    char * putenvStr = new char[putenvLen+1];

		    strcpy(putenvStr, evNam);
		    strcat(putenvStr, "=");
		    int j = 0;
		    NABoolean found = FALSE;
		    while ((ENVIRON[j]) && (NOT found))
		      {
			if ((strlen(ENVIRON[j]) >= strlen(putenvStr)) &&
			    (memcmp(ENVIRON[j], putenvStr, strlen(putenvStr)) == 0))
			  {
			    found = TRUE;
			  }
			else
			  j++;
		      }

		    if (found)
		      {
			while (ENVIRON[j])
			  {
			    ENVIRON[j] = ENVIRON[j+1];
			    j++;
			  }
		      }
		    SqlciEnvGlobal->get_envvarlist()->remove(evNam);

		    delete [] evNam;
		  }

	|	SHOW ENVVARtoken
                {
		  long newStrLen = 
		    strlen("GET ENVVARS;");
		  char * newStr = new char[newStrLen+1];
		  strcpy(newStr, "GET ENVVARS;");
		  $$ = new DML(newStr, DML_SHOWSHAPE_TYPE, NULL);
		  
		  delete newStr;
		}
	|	SETtoken PARSERFLAGS NUMBER
		{
		  $$ = new DML(SqlciParse_OriginalStr, DML_DESCRIBE_TYPE, NULL);
		}

	|	RESET PARSERFLAGS NUMBER
		{
		  $$ = new DML(SqlciParse_OriginalStr, DML_DESCRIBE_TYPE, NULL);
		}

	|	RESET PARSERFLAGS
		{
		  $$ = new DML(SqlciParse_OriginalStr, DML_DESCRIBE_TYPE, NULL);
		}

        |       QUIESCE
		        { 
                          $$ = new Quiesce();
                        }

        |       ERRORtoken NUMBER COMMA GETtoken
                  { 
		    long newStrLen = 
		      strlen("GET TEXT FOR ERROR ") + 20;
		    char * newStr = new char[newStrLen+1];
		    str_sprintf(newStr, "GET TEXT FOR ERROR %s", $2);
		    $$ = new DML(newStr, DML_DESCRIBE_TYPE, NULL);
		  }

        |      STOREtoken EXPLAIN FORtoken IDENTIFIER INtoken REPOSITORYtoken
                {
                  identifier_name_internal = new char[strlen($4)+1]; 
                  str_cpy_convert(identifier_name_internal, $4, strlen($4), TRUE); 
                  identifier_name_internal[strlen($4)] = 0;
 
                  $$ = new StoreExplain(identifier_name_internal);
                }


optional_rs_index : empty
                    {
                      $$ = 0;
                    }
                  | RESULT SETtoken NUMBER
                    {
                      $$ = atoi($3);
                    }

cursor_info : dml_simple_table_type
              { 
                char *queryText = &SqlciParse_OriginalStr[pos_internal];
                char *queryTextCopy = new char[strlen(queryText) + 1];
                strcpy(queryTextCopy, queryText);

                SqlciCursorInfo *c = new SqlciCursorInfo();
                c->queryTextSpecified_ = -1;
                c->queryTextOrStmtName_ = queryTextCopy;
                $$ = c;
              }
            | IDENTIFIER
              {
                // Not sure exactly why, but we must make a copy of
                // the IDENTIFIER string now before more tokens are
                // parsed. If we wait until the entire rule is
                // matched, the IDENTIFIER string may not be valid
                // anymore. The copy will be pointed to by a global
                // variable and released later by the rule that
                // contains cursor_info as a subrule.
                identifier_name_internal2 = new char[strlen($1) + 1];
                strcpy(identifier_name_internal2, $1);
              }
              optional_rs_index
              {
                SqlciCursorInfo *c = new SqlciCursorInfo();
                c->queryTextSpecified_ = 0;
                c->queryTextOrStmtName_ = identifier_name_internal2;
                c->resultSetIndex_ = $3;
                $$ = c;
              }

dml_type :
	 	dml_simple_table_type	{}
	|	CONTROL 		{$$ = DML_CONTROL_TYPE;}
	|       OSIM                    {$$ = DML_OSIM_TYPE;}
	|	SETtoken CATALOG	{$$ = DML_CONTROL_TYPE;}
	|	SETtoken SCHEMA		{$$ = DML_CONTROL_TYPE;}
	|	SETtoken HIVEtoken	{$$ = DML_CONTROL_TYPE;}
        |       SETtoken MPLOC          {$$ = DML_CONTROL_TYPE;}
        |       SETtoken NAMETYPE       {$$ = DML_CONTROL_TYPE;}
        |       SETtoken SESSIONtoken   {$$ = DML_CONTROL_TYPE;}
	|	UPDATEtoken  		{$$ = DML_UPDATE_TYPE;}
	| 	INSERTtoken  		{$$ = DML_INSERT_TYPE;}
        |       UPSERTtoken             {$$ = DML_INSERT_TYPE;}
	|	ROWSETtoken  		{$$ = DML_INSERT_TYPE;}
	|	DELETEtoken  		{$$ = DML_DELETE_TYPE;}
	|	MERGEtoken  		{$$ = DML_UPDATE_TYPE;}
        |       CREATE  		{$$ = DML_DDL_TYPE;}
	|	ALTER   		{$$ = DML_DDL_TYPE;}
	|       CLEANUP 		{$$ = DML_DESCRIBE_TYPE;}
	|	DROP    		{$$ = DML_DDL_TYPE;}
	|	UPD_STATS       	{$$ = DML_DDL_TYPE;}
	|	UPD_HIST_STATS  	{$$ = DML_DDL_TYPE;}
	|       METADATAtoken 		{$$ = DML_DDL_TYPE;}
        |       INITIALIZE              {$$ = DML_DESCRIBE_TYPE;}
        |       REINITIALIZE            {$$ = DML_DDL_TYPE;}
        |       GIVE                    {$$ = DML_DDL_TYPE;}
        |       GRANTtoken              {$$ = DML_DDL_TYPE;}
        |       REVOKEtoken             {$$ = DML_DDL_TYPE;}
        |       REGISTER                {$$ = DML_DDL_TYPE;}
        |       UNREGISTER              {$$ = DML_DDL_TYPE;}
	|       SHOWCONTROL 		{$$ = DML_DESCRIBE_TYPE;}
	|       SHOWDDL 		{$$ = DML_DESCRIBE_TYPE;}
	|	SHOWSTATS               {$$ = DML_DESCRIBE_TYPE;}
        |	SHOWTRANSACTION         {$$ = DML_DESCRIBE_TYPE;}
	|	INVOKE  		{$$ = DML_DESCRIBE_TYPE;}
	|	SHOWPLAN  		{$$ = DML_DESCRIBE_TYPE;}
        |       SHOWSHAPE               {$$ = DML_DESCRIBE_TYPE;}
        |       SHOWSET                 {$$ = DML_DESCRIBE_TYPE;}
	|	LOCK    		{$$ = DML_CONTROL_TYPE;}
	|	UNLOCK  		{$$ = DML_CONTROL_TYPE;}
	|	TOK_BEGIN   		{$$ = DML_CONTROL_TYPE;}
	|	COMMIT  		{$$ = DML_CONTROL_TYPE;}
	|	ROLLBACK 		{$$ = DML_CONTROL_TYPE;}
        |	SET_TABLEtoken 	        {$$ = DML_CONTROL_TYPE;}  
	|	SET_TRANSACTIONtoken 	{$$ = DML_CONTROL_TYPE;}
	|	MODIFY			{$$ = DML_DDL_TYPE;}
	|	IF			{$$ = DML_CONTROL_TYPE;}
	|	WHILE			{$$ = DML_CONTROL_TYPE;}
	|	SIGNAL			{$$ = DML_CONTROL_TYPE;}
	|	INTERNAL		{$$ = DML_CONTROL_TYPE;}
	|	MVLOG			{$$ = DML_CONTROL_TYPE;} 
	|	PURGEDATA		{$$ = DML_DDL_TYPE;}
	|	TRUNCATE		{$$ = DML_DDL_TYPE;}
	|	WITH                    {$$ = DML_DDL_TYPE;}
	|	POPULATE		{$$ = DML_DDL_TYPE;}
        |       VALIDATEtoken           {$$ = DML_DDL_TYPE;}
	|	REFRESH		        {$$ = DML_DDL_TYPE;}
	|	TRANSFORM		{$$ = DML_DDL_TYPE;}
	|	CALLToken		{$$ = DML_DDL_TYPE;}
	|	LOADtoken		{$$ = DML_DDL_TYPE;}
	|	EXTRACTtoken		{$$ = DML_DESCRIBE_TYPE;}
	|	REPLICATEtoken		{$$ = DML_DESCRIBE_TYPE;}
	|	GENERATEtoken		{$$ = DML_DESCRIBE_TYPE;}
        |	EXPLAIN		        {$$ = DML_DESCRIBE_TYPE;}
        |       GETtoken                {$$ = DML_DESCRIBE_TYPE;}
 	|       PROCESStoken            {$$ = DML_DDL_TYPE;}
 	|     COMMENTtoken       {$$ = DML_DDL_TYPE;}
;

dml_simple_table_type :
	 	SELECTtoken  			{$$ = DML_SELECT_TYPE;}
	|	TABLE   			{$$ = DML_SELECT_TYPE;}
	|	VALUES  			{$$ = DML_SELECT_TYPE;}
	|	LPAREN dml_simple_table_type  	{$$ = DML_SELECT_TYPE;}
        |       LOCKINGtoken                    {$$ = DML_SELECT_TYPE;}
        |       UNLOAD                          {$$ = DML_UNLOAD_TYPE;}
;


explain_options : empty
            { 
              $$ = 0; 
            } 
        | OPTIONStoken QUOTED_STRING
            { 
              if (strcmp($2, "f") != 0)         // accept only old value
                {
                  sqlci_DA << DgSqlCode(-15517);// say invalid option
                  YYERROR;                      // give up processing
                }
              else
                {
                  $$ = $2;
                } 
            } 
;

shell_cmd :
		CD
			{
			  $$ = new Chdir(SqlciParse_OriginalStr);
			  REPOSITION_SqlciParse_InputPos;
			}
	|	LS
			{
			  $$ = new Ls(SqlciParse_OriginalStr);
			  REPOSITION_SqlciParse_InputPos;
			}
	|	SHELL
			{
			  $$ = new Shell(SqlciParse_OriginalStr);
			  REPOSITION_SqlciParse_InputPos;
			}
;


%%