Quelle  sqlbison.y   Sprache: unbekannt

%glr-parser
%token-table
%{
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */

#include <vector>
#include <string.h>

#include <connectivity/sqlnode.hxx>
#include <connectivity/sqlparse.hxx>
#include <connectivity/sqlbison_exports.hxx>
#include <connectivity/sqlscan.hxx>
#include <connectivity/internalnode.hxx>
#include <com/sun/star/lang/Locale.hpp>
#include <com/sun/star/sdbc/DataType.hpp>
#include <com/sun/star/util/Date.hpp>
#include <com/sun/star/util/DateTime.hpp>
#include <com/sun/star/util/Time.hpp>
#include <com/sun/star/util/XNumberFormatter.hpp>
#include <com/sun/star/util/XNumberFormatsSupplier.hpp>
#include <com/sun/star/util/XNumberFormats.hpp>
#include <com/sun/star/util/NumberFormat.hpp>
#include <com/sun/star/util/XNumberFormatTypes.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/i18n/KParseType.hpp>
#include <com/sun/star/i18n/KParseTokens.hpp>

#include <osl/diagnose.h>
#include "connectivity/dbconversion.hxx"
#include <rtl/ustrbuf.hxx>
#include <sal/log.hxx>

#if defined _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4324) // structure was padded due to alignment specifier
#pragma warning(disable: 4065) // switch statement contains 'default' but no 'case' labels
#pragma warning(disable: 4702) // unreachable code
#endif

#ifdef __GNUC__
# pragma GCC diagnostic ignored "-Wwrite-strings"
# pragma GCC diagnostic ignored "-Wunused-function"
#endif

inline connectivity::OSQLInternalNode* newNode(const char* pNewValue,
        const connectivity::SQLNodeType eNodeType,
        const sal_uInt32 nNodeID = 0);

inline connectivity::OSQLInternalNode* newNode(const OString& _newValue,
        const connectivity::SQLNodeType eNodeType,
        const sal_uInt32 nNodeID = 0);

inline connectivity::OSQLInternalNode* newNode(const OUString& _newValue,
        const connectivity::SQLNodeType eNodeType,
        const sal_uInt32 nNodeID = 0);


// yyi is the internal number of the rule that is currently being reduced
// This can be mapped to external rule number via the yyrmap.
#if defined YYBISON && YYBISON >= 30800
#define SQL_NEW_RULE    newNode("", SQLNodeType::Rule, yyr1[yyrule])
#define SQL_NEW_LISTRULE   newNode("", SQLNodeType::ListRule, yyr1[yyrule])
#define SQL_NEW_COMMALISTRULE   newNode("", SQLNodeType::CommaListRule, yyr1[yyrule])
#else
#define SQL_NEW_RULE    newNode("", SQLNodeType::Rule, yyr1[yyn])
#define SQL_NEW_LISTRULE   newNode("", SQLNodeType::ListRule, yyr1[yyn])
#define SQL_NEW_COMMALISTRULE   newNode("", SQLNodeType::CommaListRule, yyr1[yyn])
#endif


extern connectivity::OSQLParser* xxx_pGLOBAL_SQLPARSER;

#define YYERROR_VERBOSE

#define SQLyyerror(s)      \
{           \
 xxx_pGLOBAL_SQLPARSER->error(s);  \
}

using namespace connectivity;
#define SQLyylex xxx_pGLOBAL_SQLPARSER->SQLlex
%}
 /* symbolic tokens */

%union {
 connectivity::OSQLParseNode * pParseNode;
}
%type <pParseNode> '(' ')' ',' ':' ';' '?' '[' ']' '{' '}' '.' 'K' 'M' 'G' 'T' 'P'

%token <pParseNode> SQL_TOKEN_STRING SQL_TOKEN_ACCESS_DATE SQL_TOKEN_INT SQL_TOKEN_REAL_NUM
%token <pParseNode> SQL_TOKEN_INTNUM SQL_TOKEN_APPROXNUM SQL_TOKEN_NOT SQL_TOKEN_NAME


%nonassoc <pParseNode> SQL_TOKEN_UMINUS



 /* literal keyword tokens */

%token <pParseNode> SQL_TOKEN_ALL SQL_TOKEN_ALTER SQL_TOKEN_AMMSC SQL_TOKEN_ANY SQL_TOKEN_AS SQL_TOKEN_ASC SQL_TOKEN_AT SQL_TOKEN_AUTHORIZATION SQL_TOKEN_AVG

%token <pParseNode> SQL_TOKEN_BETWEEN SQL_TOKEN_BIT SQL_TOKEN_BOTH SQL_TOKEN_BY

%token <pParseNode> SQL_TOKEN_CAST SQL_TOKEN_CHARACTER SQL_TOKEN_CHECK SQL_TOKEN_COLLATE SQL_TOKEN_COMMIT SQL_TOKEN_CONTINUE SQL_TOKEN_CONVERT SQL_TOKEN_COUNT SQL_TOKEN_CREATE SQL_TOKEN_CROSS
%token <pParseNode> SQL_TOKEN_CURRENT SQL_TOKEN_CURSOR

%token <pParseNode> SQL_TOKEN_DATE SQL_TOKEN_DATEVALUE SQL_TOKEN_DAY SQL_TOKEN_DEC SQL_TOKEN_DECIMAL SQL_TOKEN_DECLARE SQL_TOKEN_DEFAULT SQL_TOKEN_DELETE SQL_TOKEN_DESC
%token <pParseNode> SQL_TOKEN_DISTINCT SQL_TOKEN_DOUBLE SQL_TOKEN_DROP

%token <pParseNode> SQL_TOKEN_ESCAPE SQL_TOKEN_EXCEPT SQL_TOKEN_EXISTS SQL_TOKEN_FALSE SQL_TOKEN_FETCH SQL_TOKEN_FLOAT SQL_TOKEN_FOR SQL_TOKEN_FOREIGN SQL_TOKEN_FOUND SQL_TOKEN_FROM SQL_TOKEN_FULL

%token <pParseNode> SQL_TOKEN_GRANT SQL_TOKEN_GROUP SQL_TOKEN_HAVING SQL_TOKEN_IN SQL_TOKEN_INDICATOR SQL_TOKEN_INNER SQL_TOKEN_INTEGER SQL_TOKEN_INTO SQL_TOKEN_IS SQL_TOKEN_INTERSECT

%left <pParseNode> SQL_TOKEN_JOIN
%token <pParseNode> SQL_TOKEN_KEY SQL_TOKEN_LEADING SQL_TOKEN_LIKE SQL_TOKEN_LOCAL SQL_TOKEN_LOWER
%token <pParseNode> SQL_TOKEN_MAX SQL_TOKEN_MIN SQL_TOKEN_NATURAL SQL_TOKEN_NCHAR SQL_TOKEN_NULL SQL_TOKEN_NUMERIC

%token <pParseNode> SQL_TOKEN_OCTET_LENGTH SQL_TOKEN_OF SQL_TOKEN_ON SQL_TOKEN_OPTION SQL_TOKEN_ORDER SQL_TOKEN_OUTER

%token <pParseNode> SQL_TOKEN_PRECISION SQL_TOKEN_PRIMARY SQL_TOKEN_PRIVILEGES SQL_TOKEN_PROCEDURE SQL_TOKEN_PUBLIC
%token <pParseNode> SQL_TOKEN_REAL SQL_TOKEN_REFERENCES SQL_TOKEN_ROLLBACK

%token <pParseNode> SQL_TOKEN_SCHEMA SQL_TOKEN_SELECT SQL_TOKEN_SET SQL_TOKEN_SIZE SQL_TOKEN_SMALLINT SQL_TOKEN_SOME SQL_TOKEN_SQLCODE SQL_TOKEN_SQLERROR SQL_TOKEN_SUM

%token <pParseNode> SQL_TOKEN_TABLE SQL_TOKEN_TIME SQL_TOKEN_TIMESTAMP SQL_TOKEN_TIMEZONE_HOUR SQL_TOKEN_TIMEZONE_MINUTE SQL_TOKEN_TO SQL_TOKEN_TRAILING SQL_TOKEN_TRANSLATE SQL_TOKEN_TRIM SQL_TOKEN_TRUE SQL_TOKEN_UNION
%token <pParseNode> SQL_TOKEN_UNIQUE SQL_TOKEN_UNKNOWN SQL_TOKEN_UPDATE SQL_TOKEN_UPPER SQL_TOKEN_USAGE SQL_TOKEN_USER SQL_TOKEN_USING SQL_TOKEN_VALUES SQL_TOKEN_VIEW
%token <pParseNode> SQL_TOKEN_WHERE SQL_TOKEN_WITH SQL_TOKEN_WORK SQL_TOKEN_ZONE

/* ODBC KEYWORDS */
%token <pParseNode> SQL_TOKEN_CALL SQL_TOKEN_D SQL_TOKEN_FN SQL_TOKEN_T SQL_TOKEN_TS SQL_TOKEN_OJ
/* string functions */
%token <pParseNode> SQL_TOKEN_ASCII SQL_TOKEN_BIT_LENGTH  SQL_TOKEN_CHAR  SQL_TOKEN_CHAR_LENGTH  SQL_TOKEN_SQL_TOKEN_INTNUM
%token <pParseNode> SQL_TOKEN_CONCAT
%token <pParseNode> SQL_TOKEN_DIFFERENCE  SQL_TOKEN_INSERT SQL_TOKEN_LCASE  SQL_TOKEN_LEFT SQL_TOKEN_LENGTH  SQL_TOKEN_LOCATE
%token <pParseNode> SQL_TOKEN_LOCATE_2 SQL_TOKEN_LTRIM SQL_TOKEN_POSITION SQL_TOKEN_REPEAT SQL_TOKEN_REPLACE
%token <pParseNode> SQL_TOKEN_RIGHT SQL_TOKEN_RTRIM SQL_TOKEN_SOUNDEX SQL_TOKEN_SPACE  SQL_TOKEN_SUBSTRING SQL_TOKEN_UCASE

/* time and date functions */
%token <pParseNode> SQL_TOKEN_CURRENT_DATE SQL_TOKEN_CURRENT_TIME SQL_TOKEN_CURRENT_TIMESTAMP SQL_TOKEN_CURDATE SQL_TOKEN_CURTIME
%token <pParseNode> SQL_TOKEN_DAYNAME  SQL_TOKEN_DAYOFMONTH  SQL_TOKEN_DAYOFWEEK  SQL_TOKEN_DAYOFYEAR SQL_TOKEN_EXTRACT
%token <pParseNode> SQL_TOKEN_HOUR SQL_TOKEN_MILLISECOND SQL_TOKEN_MINUTE  SQL_TOKEN_MONTH  SQL_TOKEN_MONTHNAME SQL_TOKEN_NOW SQL_TOKEN_QUARTER SQL_TOKEN_DATEDIFF
%token <pParseNode> SQL_TOKEN_SECOND SQL_TOKEN_TIMESTAMPADD SQL_TOKEN_TIMESTAMPDIFF SQL_TOKEN_TIMEVALUE SQL_TOKEN_WEEK SQL_TOKEN_WEEKDAY SQL_TOKEN_YEAR SQL_TOKEN_YEARDAY
%token <pParseNode> SQL_TOKEN_DATEADD

/* numeric functions */
%token <pParseNode> SQL_TOKEN_ABS SQL_TOKEN_ACOS SQL_TOKEN_ASIN SQL_TOKEN_ATAN SQL_TOKEN_ATAN2 SQL_TOKEN_CEILING
%token <pParseNode> SQL_TOKEN_COS SQL_TOKEN_COT SQL_TOKEN_DEGREES SQL_TOKEN_EXP SQL_TOKEN_FLOOR SQL_TOKEN_LOGF  SQL_TOKEN_LOG SQL_TOKEN_LN
%token <pParseNode> SQL_TOKEN_LOG10 SQL_TOKEN_MOD SQL_TOKEN_PI SQL_TOKEN_POWER SQL_TOKEN_RADIANS SQL_TOKEN_RAND SQL_TOKEN_ROUNDMAGIC
%token <pParseNode> SQL_TOKEN_ROUND   SQL_TOKEN_SIGN    SQL_TOKEN_SIN     SQL_TOKEN_SQRT    SQL_TOKEN_TAN SQL_TOKEN_TRUNCATE

// computational operation
%token <pParseNode> SQL_TOKEN_EVERY SQL_TOKEN_INTERSECTION SQL_TOKEN_FUSION SQL_TOKEN_COLLECT SQL_TOKEN_VAR_POP SQL_TOKEN_VAR_SAMP
%token <pParseNode> SQL_TOKEN_STDDEV_SAMP SQL_TOKEN_STDDEV_POP

%token <pParseNode> SQL_TOKEN_RANK SQL_TOKEN_DENSE_RANK SQL_TOKEN_PERCENT_RANK SQL_TOKEN_CUME_DIST SQL_TOKEN_PERCENTILE_CONT SQL_TOKEN_PERCENTILE_DISC SQL_TOKEN_WITHIN SQL_TOKEN_ARRAY_AGG
%token <pParseNode> SQL_TOKEN_CASE SQL_TOKEN_THEN SQL_TOKEN_END SQL_TOKEN_NULLIF SQL_TOKEN_COALESCE SQL_TOKEN_WHEN SQL_TOKEN_ELSE
%token <pParseNode> SQL_TOKEN_BEFORE SQL_TOKEN_AFTER SQL_TOKEN_INSTEAD SQL_TOKEN_EACH SQL_TOKEN_REFERENCING SQL_TOKEN_BEGIN SQL_TOKEN_ATOMIC SQL_TOKEN_TRIGGER SQL_TOKEN_ROW SQL_TOKEN_STATEMENT
%token <pParseNode> SQL_TOKEN_NEW SQL_TOKEN_OLD
%token <pParseNode> SQL_TOKEN_VALUE SQL_TOKEN_CURRENT_CATALOG SQL_TOKEN_CURRENT_DEFAULT_TRANSFORM_GROUP SQL_TOKEN_CURRENT_PATH SQL_TOKEN_CURRENT_ROLE SQL_TOKEN_CURRENT_SCHEMA SQL_TOKEN_CURRENT_USER
%token <pParseNode> SQL_TOKEN_SESSION_USER SQL_TOKEN_SYSTEM_USER SQL_TOKEN_VARCHAR SQL_TOKEN_VARBINARY SQL_TOKEN_VARYING SQL_TOKEN_OBJECT SQL_TOKEN_NCLOB SQL_TOKEN_NATIONAL
%token <pParseNode> SQL_TOKEN_LARGE SQL_TOKEN_CLOB SQL_TOKEN_BLOB SQL_TOKEN_BIGINT SQL_TOKEN_BINARY SQL_TOKEN_WITHOUT SQL_TOKEN_BOOLEAN SQL_TOKEN_INTERVAL
// window function
%token <pParseNode> SQL_TOKEN_OVER SQL_TOKEN_ROW_NUMBER SQL_TOKEN_NTILE SQL_TOKEN_LEAD SQL_TOKEN_LAG SQL_TOKEN_RESPECT SQL_TOKEN_IGNORE SQL_TOKEN_NULLS
%token <pParseNode> SQL_TOKEN_FIRST_VALUE SQL_TOKEN_LAST_VALUE SQL_TOKEN_NTH_VALUE SQL_TOKEN_FIRST SQL_TOKEN_LAST
%token <pParseNode> SQL_TOKEN_EXCLUDE SQL_TOKEN_OTHERS SQL_TOKEN_TIES SQL_TOKEN_FOLLOWING SQL_TOKEN_UNBOUNDED SQL_TOKEN_PRECEDING SQL_TOKEN_RANGE SQL_TOKEN_ROWS
%token <pParseNode> SQL_TOKEN_PARTITION SQL_TOKEN_WINDOW SQL_TOKEN_NO
// LIMIT and OFFSEt
%token <pParseNode> SQL_TOKEN_LIMIT SQL_TOKEN_OFFSET SQL_TOKEN_NEXT SQL_TOKEN_ONLY

 /* operators */
%left SQL_TOKEN_NAME
%left <pParseNode> SQL_TOKEN_OR
%left <pParseNode> SQL_TOKEN_AND

%left <pParseNode> SQL_LESSEQ SQL_GREATEQ SQL_NOTEQUAL SQL_LESS SQL_GREAT SQL_EQUAL /* '<' '>' = <> < > <= >= != */
%left <pParseNode> '+' '-' SQL_CONCAT
%left <pParseNode> '*' '/'
%left SQL_TOKEN_NATURAL SQL_TOKEN_CROSS SQL_TOKEN_FULL SQL_TOKEN_LEFT SQL_TOKEN_RIGHT
%left ')'
%right '='
%right '.'
%right '('


%token <pParseNode> SQL_TOKEN_INVALIDSYMBOL

/*%type <pParseNode> sql_single_statement */

%type <pParseNode> sql /*schema */
%type <pParseNode> column_def_opt_list column_def_opt table_constraint_def column_commalist
%type <pParseNode> view_def opt_with_check_option opt_column_commalist privilege_def
%type <pParseNode> opt_with_grant_option privileges operation_commalist operation
%type <pParseNode> grantee_commalist grantee opt_order_by_clause ordering_spec_commalist
%type <pParseNode> ordering_spec opt_asc_desc manipulative_statement commit_statement
%type <pParseNode> /*delete_statement_positioned*/ delete_statement_searched fetch_statement
%type <pParseNode> insert_statement values_or_query_spec
%type <pParseNode> rollback_statement select_statement_into opt_all_distinct
%type <pParseNode> /*update_statement_positioned*/ assignment_commalist assignment
%type <pParseNode> update_statement_searched target_commalist target opt_where_clause
%type <pParseNode> select_statement selection table_exp from_clause table_ref_commalist table_ref
%type <pParseNode> where_clause opt_group_by_clause column_ref_commalist opt_having_clause
%type <pParseNode> search_condition predicate comparison_predicate comparison_predicate_part_2 between_predicate between_predicate_part_2
%type <pParseNode> like_predicate opt_escape test_for_null null_predicate_part_2 in_predicate in_predicate_part_2 character_like_predicate_part_2 other_like_predicate_part_2
%type <pParseNode> all_or_any_predicate any_all_some existence_test subquery quantified_comparison_predicate_part_2
%type <pParseNode> scalar_exp_commalist parameter_ref literal parenthesized_boolean_value_expression
%type <pParseNode> column_ref data_type column cursor parameter range_variable user /*like_check*/ datetime_unit
/* new rules at OJ */
%type <pParseNode> derived_column as_clause table_name num_primary term num_value_exp
%type <pParseNode> value_exp_primary num_value_fct unsigned_value_spec cast_spec set_fct_spec  scalar_subquery
%type <pParseNode> position_exp extract_exp length_exp general_value_spec
%type <pParseNode> general_set_fct set_fct_type query_exp non_join_query_exp joined_table
%type <pParseNode> non_join_query_term non_join_query_primary simple_table
%type <pParseNode> table_value_const_list row_value_constructor /*row_value_const_list*/ row_value_constructor_elem
%type <pParseNode> qualified_join value_exp query_term join_type outer_join_type join_condition boolean_term
%type <pParseNode> boolean_factor boolean_primary named_columns_join join_spec
%type <pParseNode> cast_operand cast_target factor datetime_value_exp /*interval_value_exp*/ datetime_term datetime_factor
%type <pParseNode> datetime_primary datetime_value_fct time_zone time_zone_specifier /*interval_term*/ interval_qualifier
%type <pParseNode> start_field non_second_datetime_field end_field single_datetime_field extract_field datetime_field time_zone_field
%type <pParseNode> char_length_exp octet_length_exp bit_length_exp select_sublist string_value_exp
%type <pParseNode> char_value_exp concatenation char_factor char_primary string_value_fct char_substring_fct fold
%type <pParseNode> form_conversion char_translation trim_fct trim_operands trim_spec bit_value_fct bit_substring_fct op_column_commalist
%type <pParseNode> /*bit_concatenation*/ bit_value_exp bit_factor bit_primary collate_clause char_value_fct unique_spec value_exp_commalist in_predicate_value unique_test update_source
%type <pParseNode> function_arg_commalist3 string_function_3Argument function_arg_commalist4 string_function_4Argument function_arg_commalist2 string_function_1Argument string_function_2Argument
%type <pParseNode> date_function_0Argument date_function_1Argument function_name12 function_name23 function_name1 function_name2 function_name3 function_name0 numeric_function_0Argument numeric_function_1Argument numeric_function_2Argument
%type <pParseNode> all query_primary sql_not for_length upper_lower comparison column_val  cross_union /*opt_schema_element_list*/
%type <pParseNode> /*op_authorization op_schema*/ nil_fkt schema_element base_table_def base_table_element base_table_element_commalist
%type <pParseNode> column_def odbc_fct_spec odbc_call_spec odbc_fct_type op_parameter union_statement
%type <pParseNode> op_odbc_call_parameter odbc_parameter_commalist odbc_parameter function_args_commalist function_arg
%type <pParseNode> catalog_name schema_name table_node numeric_function string_function function_name date_function table_primary_as_range_column opt_as
%type <pParseNode> ordered_set_function inverse_distribution_function hypothetical_set_function hypothetical_set_function_value_expression_list rank_function_type within_group_specification inverse_distribution_function_type array_aggregate_function inverse_distribution_function_argument
%type <pParseNode> case_expression else_clause result_expression result case_abbreviation case_specification searched_when_clause simple_when_clause searched_case simple_case
%type <pParseNode> when_operand_list when_operand case_operand
%type <pParseNode> trigger_definition trigger_name trigger_action_time trigger_event transition_table_or_variable_list triggered_action trigger_column_list triggered_when_clause triggered_SQL_statement SQL_procedure_statement old_transition_variable_name new_transition_variable_name
%type <pParseNode> op_referencing op_trigger_columnlist op_triggered_action_for opt_row trigger_for SQL_procedure_statement_list transition_table_or_variable old_transition_table_name new_transition_table_name transition_table_name
%type <pParseNode> searched_when_clause_list simple_when_clause_list predefined_type opt_char_set_spec opt_collate_clause character_string_type national_character_string_type
%type <pParseNode> binary_string_type numeric_type boolean_type datetime_type interval_type opt_paren_precision paren_char_length opt_paren_char_large_length paren_character_large_object_length
%type <pParseNode> large_object_length opt_multiplier character_large_object_type national_character_large_object_type binary_large_object_string_type opt_with_or_without_time_zone
%type <pParseNode> approximate_numeric_type exact_numeric_type opt_paren_precision_scale
/* window function rules */
%type <pParseNode> window_function window_function_type ntile_function number_of_tiles lead_or_lag_function lead_or_lag lead_or_lag_extent offset default_expression null_treatment
%type <pParseNode> first_or_last_value_function first_or_last_value nth_value_function nth_row from_first_or_last window_name_or_specification in_line_window_specification opt_lead_or_lag_function
%type <pParseNode> opt_null_treatment opt_from_first_or_last simple_value_specification dynamic_parameter_specification window_name window_clause window_definition_list window_definition
%type <pParseNode> new_window_name existing_window_name window_partition_clause window_partition_column_reference_list window_partition_column_reference window_frame_clause
%type <pParseNode> window_frame_units window_frame_extent window_frame_start window_frame_preceding window_frame_between window_frame_bound_1 window_frame_bound_2 window_frame_bound window_frame_following window_frame_exclusion
%type <pParseNode> opt_window_frame_clause opt_window_partition_clause opt_existing_window_name window_specification opt_window_frame_exclusion opt_window_clause opt_offset
%type <pParseNode> opt_fetch_first_row_count fetch_first_clause offset_row_count fetch_first_row_count first_or_next row_or_rows opt_result_offset_clause result_offset_clause
/* LIMIT and OFFSET */
%type <pParseNode> opt_limit_offset_clause limit_offset_clause opt_fetch_first_clause
%%

/* Return Parse Tree to OSQLParser
 * (the access over yyval after calling the parser fails,
 *
 */
sql_single_statement:
  sql
  { xxx_pGLOBAL_SQLPARSER->setParseTree( $1 ); }
 | sql ';'
  { xxx_pGLOBAL_SQLPARSER->setParseTree( $1 ); }
 ;

 /* schema definition language */
 /* Note: other ``sql:sal_Unicode() rules appear later in the grammar */

sql:
  manipulative_statement
 | schema_element
           {
                $$ = SQL_NEW_RULE;
  $$->append($1);
    }
 ;

/***

op_authorization:
  {$$ = SQL_NEW_RULE;}
 | SQL_TOKEN_AUTHORIZATION user
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 ;
op_schema:
  {$$ = SQL_NEW_RULE;}
 | SQL_TOKEN_NAME
 | SQL_TOKEN_NAME '.' SQL_TOKEN_NAME
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode(".", SQLNodeType::Punctuation));
   $$->append($3);
  }
 ;

schema:
  SQL_TOKEN_CREATE SQL_TOKEN_SCHEMA op_schema op_authorization opt_schema_element_list
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
   $$->append($5);
  }
 ;

opt_schema_element_list:
   {$$ = SQL_NEW_RULE;}
 |       schema_element_list
 ;

schema_element_list:
  schema_element
   {$$ = SQL_NEW_LISTRULE;
   $$->append($1);}
 |       schema_element_list schema_element
   {$1->append($2);
   $$ = $1;}
 ;
*/

schema_element:
   base_table_def
 |       view_def
 |       privilege_def
 |  trigger_definition
 ;

base_table_def:
  SQL_TOKEN_CREATE SQL_TOKEN_TABLE table_node '(' base_table_element_commalist ')'
  {$$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
  $$->append($3);
  $$->append(newNode("(", SQLNodeType::Punctuation));
  $$->append($5);
  $$->append(newNode(")", SQLNodeType::Punctuation));}
 ;

base_table_element_commalist:
  base_table_element
  {$$ = SQL_NEW_COMMALISTRULE;
  $$->append($1);}
 |   base_table_element_commalist ',' base_table_element
  {$1->append($3);
  $$ = $1;}
 ;

base_table_element:
  column_def
 | table_constraint_def
 ;

column_def:
  column data_type column_def_opt_list
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   }
 ;

column_def_opt_list:
  /* empty */                 {$$ = SQL_NEW_LISTRULE;}
 |       column_def_opt_list column_def_opt
   {$1->append($2);
   $$ = $1;}
 ;

nil_fkt:
 datetime_value_fct
 ;
unique_spec:
  SQL_TOKEN_UNIQUE
 | SQL_TOKEN_PRIMARY SQL_TOKEN_KEY
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 ;
column_def_opt:
  SQL_TOKEN_NOT SQL_TOKEN_NULL
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 |       unique_spec
 |       SQL_TOKEN_DEFAULT literal
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 |       SQL_TOKEN_DEFAULT SQL_TOKEN_NULL
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 |       SQL_TOKEN_DEFAULT SQL_TOKEN_USER
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 |  SQL_TOKEN_DEFAULT nil_fkt
   {
    $$ = SQL_NEW_RULE;
    $$->append($1);
    $$->append($2);
   }
 |       SQL_TOKEN_CHECK
 |       SQL_TOKEN_CHECK '(' search_condition ')'
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));}
 |       SQL_TOKEN_REFERENCES table_node
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 |       SQL_TOKEN_REFERENCES table_node '(' column_commalist ')'
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($4);
   $$->append(newNode(")", SQLNodeType::Punctuation));}
 ;

table_constraint_def:
  unique_spec '(' column_commalist ')'
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));}
 |       SQL_TOKEN_FOREIGN SQL_TOKEN_KEY '(' column_commalist ')' SQL_TOKEN_REFERENCES table_node
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($4);
   $$->append(newNode(")", SQLNodeType::Punctuation));
   $$->append($6);
   $$->append($7);}
 |       SQL_TOKEN_FOREIGN SQL_TOKEN_KEY '(' column_commalist ')' SQL_TOKEN_REFERENCES table_node '(' column_commalist ')'
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($4);
   $$->append(newNode(")", SQLNodeType::Punctuation));
   $$->append($6);
   $$->append($7);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($9);
   $$->append(newNode(")", SQLNodeType::Punctuation));}
 |       SQL_TOKEN_CHECK '(' search_condition ')'
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));}
 ;
op_column_commalist:
 /* empty */ {$$ = SQL_NEW_RULE;}
 | '(' column_commalist ')'
  {$$ = SQL_NEW_RULE;
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($2);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 ;
column_commalist:
  column_commalist ',' column
   {$1->append($3);
   $$ = $1;}
 | column
   {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 ;

view_def:
  SQL_TOKEN_CREATE SQL_TOKEN_VIEW table_node opt_column_commalist SQL_TOKEN_AS select_statement opt_with_check_option
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
   $$->append($5);
   $$->append($6);
   $$->append($7);}
 ;

opt_with_check_option:
  /* empty */         {$$ = SQL_NEW_RULE;}
 |       SQL_TOKEN_WITH SQL_TOKEN_CHECK SQL_TOKEN_OPTION
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);}
 ;

opt_column_commalist:
  /* empty */         {$$ = SQL_NEW_RULE;}
 |       '(' column_commalist ')'
   {$$ = SQL_NEW_RULE;
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($2);
   $$->append(newNode(")", SQLNodeType::Punctuation));}
 ;

privilege_def:
  SQL_TOKEN_GRANT privileges SQL_TOKEN_ON table_node SQL_TOKEN_TO grantee_commalist
  opt_with_grant_option
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
   $$->append($5);
   $$->append($6);
   $$->append($7);}
 ;

opt_with_grant_option:
  /* empty */         {$$ = SQL_NEW_RULE;}
 |       SQL_TOKEN_WITH SQL_TOKEN_GRANT SQL_TOKEN_OPTION
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);}
 ;

privileges:
  SQL_TOKEN_ALL SQL_TOKEN_PRIVILEGES
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 |       operation_commalist
 ;

operation_commalist:
  operation
   {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 |       operation_commalist ',' operation
   {$1->append($3);
   $$ = $1;}
 ;

operation:
   SQL_TOKEN_SELECT
 |       SQL_TOKEN_INSERT opt_column_commalist
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 |       SQL_TOKEN_DELETE
 |       SQL_TOKEN_UPDATE opt_column_commalist
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 |       SQL_TOKEN_REFERENCES opt_column_commalist
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 |  SQL_TOKEN_USAGE
 ;


grantee_commalist:
  grantee
   {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 |       grantee_commalist ',' grantee
   {$1->append($3);
   $$ = $1;}
 ;

grantee:
   SQL_TOKEN_PUBLIC
 |       user
 ;

 /* module language */

opt_order_by_clause:
  /* empty */         {$$ = SQL_NEW_RULE;}
 |       SQL_TOKEN_ORDER SQL_TOKEN_BY ordering_spec_commalist
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);}
 ;

ordering_spec_commalist:
  ordering_spec
   {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 |       ordering_spec_commalist ',' ordering_spec
   {$1->append($3);
   $$ = $1;}
 ;

ordering_spec:
/*  SQL_TOKEN_INTNUM opt_asc_desc
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
*/
  predicate opt_asc_desc
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}

 | row_value_constructor_elem opt_asc_desc
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 ;

opt_asc_desc:
  {$$ = SQL_NEW_RULE;}
 | SQL_TOKEN_ASC
 | SQL_TOKEN_DESC
 ;


/***
manipulative_statement_list:
  manipulative_statement
   {$$ = SQL_NEW_LISTRULE;
   $$->append($1);}
 |       manipulative_statement_list manipulative_statement
   {$1->append($2);
   $$ = $1;}
 ;
***/

sql_not:
/* vide */
 {$$ = SQL_NEW_RULE;}
 | SQL_TOKEN_NOT
 ;

/* manipulative statements */

manipulative_statement:
   commit_statement
/* |       delete_statement_positioned*/
 |       delete_statement_searched
 |       fetch_statement
 |       insert_statement
 |       rollback_statement
 |       select_statement_into
/* |       update_statement_positioned*/
 |       update_statement_searched
 |  union_statement
 |  '{' odbc_call_spec '}'
  {
   $$ = SQL_NEW_RULE;
   $$->append(newNode("{", SQLNodeType::Punctuation));
   $$->append($2);
   $$->append(newNode("}", SQLNodeType::Punctuation));
  }
 ;

union_statement:
   select_statement
 |  union_statement SQL_TOKEN_UNION all select_statement
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
  }
 ;
commit_statement:
  SQL_TOKEN_COMMIT SQL_TOKEN_WORK
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 ;
/*
delete_statement_positioned:
  SQL_TOKEN_DELETE SQL_TOKEN_FROM table_node SQL_TOKEN_WHERE SQL_TOKEN_CURRENT SQL_TOKEN_OF cursor
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
   $$->append($5);
   $$->append($6);
   $$->append($7);}
 ;
*/
delete_statement_searched:
  SQL_TOKEN_DELETE SQL_TOKEN_FROM table_node opt_where_clause
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);}
 ;

fetch_statement:
  SQL_TOKEN_FETCH cursor SQL_TOKEN_INTO target_commalist
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);}
 ;

insert_statement:
  SQL_TOKEN_INSERT SQL_TOKEN_INTO table_node opt_column_commalist query_exp
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
   $$->append($5);}
 ;
values_or_query_spec:
  SQL_TOKEN_VALUES '(' table_value_const_list ')'
  {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 ;

table_value_const_list:
   row_value_constructor
   {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 |       table_value_const_list ',' row_value_constructor
   {$1->append($3);
   $$ = $1;}
 ;
/*
row_value_const_list:
   row_value_constructor_elem
   {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 |       row_value_const_list ',' row_value_constructor_elem
   {$1->append($3);
   $$ = $1;}
 ;
*/
row_value_constructor:
   row_value_constructor_elem
/*   |  '(' row_value_const_list ')'
   {
    $$ = SQL_NEW_RULE;
    $$->append(newNode("(", SQLNodeType::Punctuation));
    $$->append($2);
    $$->append(newNode(")", SQLNodeType::Punctuation));
   }
   */
 ;
row_value_constructor_elem:
   value_exp /*[^')']*/
 |  SQL_TOKEN_DEFAULT
 ;


rollback_statement:
  SQL_TOKEN_ROLLBACK SQL_TOKEN_WORK
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 ;


  /* INTO target_commalist herausgenommen */
select_statement_into:
  SQL_TOKEN_SELECT opt_all_distinct selection SQL_TOKEN_INTO target_commalist table_exp
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
   $$->append($5);
   $$->append($6); }
 ;

opt_all_distinct:
   {$$ = SQL_NEW_RULE;}
  | SQL_TOKEN_ALL
  | SQL_TOKEN_DISTINCT

 ;
/*
update_statement_positioned:
  SQL_TOKEN_UPDATE table_node SQL_TOKEN_SET assignment_commalist
  SQL_TOKEN_WHERE SQL_TOKEN_CURRENT SQL_TOKEN_OF cursor
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
   $$->append($5);
   $$->append($6);
   $$->append($7);
   $$->append($8);}
 ;
*/
assignment_commalist:
   assignment
   {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 |       assignment_commalist ',' assignment
   {$1->append($3);
   $$ = $1;}
 ;

assignment:
  column SQL_EQUAL update_source
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);}
 ;
update_source:
  value_exp
   | SQL_TOKEN_DEFAULT
 ;
update_statement_searched:
  SQL_TOKEN_UPDATE table_node SQL_TOKEN_SET assignment_commalist opt_where_clause
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
   $$->append($5);}
 ;

target_commalist:
  target
   {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 |       target_commalist ',' target
   {$1->append($3);
   $$ = $1;}
 ;

target:
  parameter_ref
 ;

opt_where_clause:
  /* empty */             {$$ = SQL_NEW_RULE;}
 |       where_clause
 ;

 /* query expressions */

query_term:
  non_join_query_term
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
  }
    ;
/* SELECT STATEMENT */
select_statement:
  SQL_TOKEN_SELECT opt_all_distinct selection table_exp
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
  }
 ;

selection:
  '*'
  {
   $$ = SQL_NEW_RULE;
   $$->append(newNode("*", SQLNodeType::Punctuation));
  }
 | scalar_exp_commalist
 ;
opt_result_offset_clause:
  /* empty */ {$$ = SQL_NEW_RULE;}
 | result_offset_clause
 ;
result_offset_clause:
 SQL_TOKEN_OFFSET offset_row_count row_or_rows
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
  $$->append($3);
 }
 ;
opt_fetch_first_row_count:
  /* empty */ {$$ = SQL_NEW_RULE;}
 | fetch_first_row_count
 ;
first_or_next:
  SQL_TOKEN_FIRST
 | SQL_TOKEN_NEXT
 ;
row_or_rows:
  SQL_TOKEN_ROW
 | SQL_TOKEN_ROWS
 ;
opt_fetch_first_clause:
  /* empty */ {$$ = SQL_NEW_RULE;}
 | fetch_first_clause
 ;
fetch_first_clause:
 SQL_TOKEN_FETCH first_or_next opt_fetch_first_row_count row_or_rows SQL_TOKEN_ONLY
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
  $$->append($3);
  $$->append($4);
  $$->append($5);
 }
 ;
offset_row_count:
 literal
 ;
fetch_first_row_count:
 literal
 ;

opt_limit_offset_clause:
  /* empty */ {$$ = SQL_NEW_RULE;}
 | limit_offset_clause
 ;
opt_offset:
  /* empty */ {$$ = SQL_NEW_RULE;}
 | SQL_TOKEN_OFFSET SQL_TOKEN_INTNUM
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
 }
 ;
limit_offset_clause:
 SQL_TOKEN_LIMIT SQL_TOKEN_INTNUM opt_offset
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
  $$->append($3);
 }
 ;
table_exp:
  from_clause opt_where_clause opt_group_by_clause opt_having_clause opt_window_clause opt_order_by_clause opt_limit_offset_clause opt_result_offset_clause opt_fetch_first_clause
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
   $$->append($5);
   $$->append($6);
   $$->append($7);
   $$->append($8);
   $$->append($9);
  }
 ;

from_clause:
  SQL_TOKEN_FROM table_ref_commalist
   { $$ = SQL_NEW_RULE;
     $$->append($1);
     $$->append($2); }
 ;

table_ref_commalist:

  table_ref
   { $$ = SQL_NEW_COMMALISTRULE;
     $$->append($1); }
 |       table_ref_commalist ',' table_ref
   { $1->append($3);
     $$ = $1; }
 ;

opt_as:
  /* empty */ {$$ = SQL_NEW_RULE;}
 | SQL_TOKEN_AS
 ;
opt_row:
  /* empty */ {$$ = SQL_NEW_RULE;}
 | SQL_TOKEN_ROW
 ;
table_primary_as_range_column:
        {$$ = SQL_NEW_RULE;}
 |   opt_as SQL_TOKEN_NAME op_column_commalist
  {
      $$ = SQL_NEW_RULE;
      $$->append($1);
      $$->append($2);
      $$->append($3);
  }
    ;
table_ref:
        table_node table_primary_as_range_column
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 |   subquery range_variable op_column_commalist
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
  }
 | joined_table
 | '{' SQL_TOKEN_OJ joined_table '}'
  {
   $$ = SQL_NEW_RULE;
   $$->append(newNode("{", SQLNodeType::Punctuation));
   $$->append($2);
   $$->append($3);
   $$->append(newNode("}", SQLNodeType::Punctuation));
  }
 | '(' joined_table ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($2);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 ;
where_clause:
  SQL_TOKEN_WHERE search_condition
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 ;

opt_group_by_clause:
  /* empty */      {$$ = SQL_NEW_RULE;}
 |   SQL_TOKEN_GROUP SQL_TOKEN_BY column_ref_commalist
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);}
 ;

column_ref_commalist:
  column_ref
   {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 | set_fct_spec
  {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 |   column_ref_commalist ',' column_ref
   {$1->append($3);
   $$ = $1;}
 |   column_ref_commalist ',' set_fct_spec
   {$1->append($3);
   $$ = $1;}
 ;

opt_having_clause:
  /* empty */                 {$$ = SQL_NEW_RULE;}
 |       SQL_TOKEN_HAVING search_condition
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 ;

 /* search conditions */
boolean_primary:
  predicate
 |   '(' search_condition ')'
  { // boolean_primary: rule 2
   $$ = SQL_NEW_RULE;
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($2);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | row_value_constructor_elem  /*[^')' ',']*/
  {
                    if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck())// boolean_primary: rule 3
                    {
                        $$ = SQL_NEW_RULE;
                        sal_Int16 nErg = 0;
                        if ( SQL_ISTOKEN( $1, NULL))
                        {
                            OSQLParseNode* pColumnRef = newNode("", SQLNodeType::Rule,OSQLParser::RuleID(OSQLParseNode::column_ref));
                            pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQLNodeType::Name));
                            OSQLParseNode* pTFN = new OSQLInternalNode("", SQLNodeType::Rule,OSQLParser::RuleID(OSQLParseNode::test_for_null));
                            pTFN->append(pColumnRef);

                            OSQLParseNode* pNPP2 = new OSQLInternalNode("", SQLNodeType::Rule, OSQLParser::RuleID(OSQLParseNode::null_predicate_part_2));
                            pNPP2->append(new OSQLInternalNode("", SQLNodeType::Keyword, SQL_TOKEN_IS));
                            pNPP2->append(new OSQLInternalNode("", SQLNodeType::Rule, OSQLParser::RuleID(OSQLParseNode::sql_not)));
                            pNPP2->append(new OSQLInternalNode("", SQLNodeType::Keyword, SQL_TOKEN_NULL));
                            pTFN->append(pNPP2);

                            $$->append(pTFN);

                            nErg = 1;
                        }
                        else
                        {
                            nErg = xxx_pGLOBAL_SQLPARSER->buildComparisonRule($$,$1);
                        }
                        if(nErg == 1)
                        {
                            OSQLParseNode* pTemp = $$;
                            $$ = pTemp->removeAt((sal_uInt32)0);
                            delete pTemp;
                        }
                        else
                        {
                            delete $$;
                            if(nErg)
                                YYERROR;
                            else
                                YYABORT;
                        }
                    }
                    else
                        YYERROR;
                }
 ;
parenthesized_boolean_value_expression:
   '(' search_condition ')'
 { // boolean_primary: rule 2
  $$ = SQL_NEW_RULE;
  $$->append(newNode("(", SQLNodeType::Punctuation));
  $$->append($2);
  $$->append(newNode(")", SQLNodeType::Punctuation));
 }
 ;
boolean_factor:
     boolean_primary   %dprec 2
 |   SQL_TOKEN_NOT boolean_primary %dprec 1
  { // boolean_factor: rule 1
      $$ = SQL_NEW_RULE;
      $$->append($1);
      $$->append($2);
  }
 ;
boolean_term:
  boolean_factor
 | boolean_term SQL_TOKEN_AND boolean_factor
  {
   $$ = SQL_NEW_RULE; // boolean_term: rule 1
   $$->append($1);
   $$->append($2);
   $$->append($3);
  }
 ;
search_condition:
  boolean_term
 | search_condition SQL_TOKEN_OR boolean_term
  {
   $$ = SQL_NEW_RULE; // search_condition
   $$->append($1);
   $$->append($2);
   $$->append($3);
  }
 ;
predicate:
  comparison_predicate     %dprec 1
 |       between_predicate
 |       all_or_any_predicate
 |       existence_test
 |  unique_test
 |  test_for_null    %dprec 2
 |       in_predicate
 |       like_predicate
 ;
comparison_predicate_part_2:
  comparison row_value_constructor
  {
   $$ = SQL_NEW_RULE; // comparison_predicate: rule 1
   $$->append($1);
   $$->append($2);
  }
comparison_predicate:
  row_value_constructor comparison row_value_constructor
  {
   $$ = SQL_NEW_RULE; // comparison_predicate: rule 1
   $$->append($1);
   $$->append($2);
   $$->append($3);
  }
 | comparison row_value_constructor
  {
   if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // comparison_predicate: rule 2
   {
    $$ = SQL_NEW_RULE;
    sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildPredicateRule($$,$2,$1);
    if(nErg == 1)
    {
     OSQLParseNode* pTemp = $$;
     $$ = pTemp->removeAt((sal_uInt32)0);
     delete pTemp;
    }
    else
    {
     delete $$;
     YYABORT;
    }
   }
   else
   {
    YYERROR;
   }
  }
 ;
comparison:
     SQL_LESS
   | SQL_NOTEQUAL
   | SQL_EQUAL
   | SQL_GREAT
   | SQL_LESSEQ
   | SQL_GREATEQ
   | SQL_TOKEN_IS sql_not SQL_TOKEN_DISTINCT SQL_TOKEN_FROM
    {
    $$ = SQL_NEW_RULE;
    $$->append($1);
    $$->append($2);
    $$->append($3);
    $$->append($4);
  }
   | SQL_TOKEN_IS sql_not
    {
    $$ = SQL_NEW_RULE;
    $$->append($1);
    $$->append($2);
  }
 ;
between_predicate_part_2:
 sql_not SQL_TOKEN_BETWEEN row_value_constructor SQL_TOKEN_AND row_value_constructor
  {
   if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // between_predicate: rule 2
   {
    $$ = SQL_NEW_RULE;

    sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildPredicateRule($$,$3,$2,$5);
    if(nErg == 1)
    {
     OSQLParseNode* pTemp = $$;
     $$ = pTemp->removeAt((sal_uInt32)0);
     OSQLParseNode* pColumnRef = $$->removeAt((sal_uInt32)0);
     $$->insert(0,$1);
     OSQLParseNode* pBetween_predicate = new OSQLInternalNode("", SQLNodeType::Rule,OSQLParser::RuleID(OSQLParseNode::between_predicate));
     pBetween_predicate->append(pColumnRef);
     pBetween_predicate->append($$);
     $$ = pBetween_predicate;

     delete pTemp;
     delete $4;
    }
    else
    {
     delete $$;
     YYABORT;
    }
   }
   else
   {
    $$ = SQL_NEW_RULE; // between_predicate: rule 1
    $$->append($1);
    $$->append($2);
    $$->append($3);
    $$->append($4);
    $$->append($5);
   }
  }
between_predicate:
  row_value_constructor between_predicate_part_2
  {
   $$ = SQL_NEW_RULE; // between_predicate: rule 1
   $$->append($1);
   $$->append($2);
  }
 | between_predicate_part_2
 ;
character_like_predicate_part_2:
 sql_not SQL_TOKEN_LIKE string_value_exp opt_escape
  {
   $$ = SQL_NEW_RULE; // like_predicate: rule 1
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
  }
 ;
other_like_predicate_part_2:
 sql_not SQL_TOKEN_LIKE value_exp_primary opt_escape
  {
   $$ = SQL_NEW_RULE; // like_predicate: rule 1
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
  }
 ;
like_predicate:
  row_value_constructor character_like_predicate_part_2
  {
   $$ = SQL_NEW_RULE; // like_predicate: rule 1
   $$->append($1);
   $$->append($2);
  }
 | row_value_constructor other_like_predicate_part_2
  {
   $$ = SQL_NEW_RULE;  // like_predicate: rule 3
   $$->append($1);
   $$->append($2);
  }
 | character_like_predicate_part_2
  {
   if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())  // like_predicate: rule 5
   {
    OSQLParseNode* pColumnRef = newNode("", SQLNodeType::Rule,OSQLParser::RuleID(OSQLParseNode::column_ref));
    pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQLNodeType::Name));

    $$ = SQL_NEW_RULE;
    $$->append(pColumnRef);
    $$->append($1);
    OSQLParseNode* p2nd = $1->removeAt(2);
    OSQLParseNode* p3rd = $1->removeAt(2);
    if ( !xxx_pGLOBAL_SQLPARSER->buildLikeRule($1,p2nd,p3rd) )
    {
     delete $$;
     YYABORT;
    }
    $1->append(p3rd);
   }
   else
    YYERROR;
  }
 | other_like_predicate_part_2
  {
   if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // like_predicate: rule 6
   {
    OSQLParseNode* pColumnRef = newNode("", SQLNodeType::Rule,OSQLParser::RuleID(OSQLParseNode::column_ref));
    pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQLNodeType::Name));

    $$ = SQL_NEW_RULE;
    $$->append(pColumnRef);
    $$->append($1);
    OSQLParseNode* p2nd = $1->removeAt(2);
    OSQLParseNode* p3rd = $1->removeAt(2);
    if ( !xxx_pGLOBAL_SQLPARSER->buildLikeRule($1,p2nd,p3rd) )
    {
     delete $$;
     YYABORT;
    }
    $1->append(p3rd);
   }
   else
    YYERROR;
  }
 ;

opt_escape:
  /* empty */                 {$$ = SQL_NEW_RULE;}
 |   SQL_TOKEN_ESCAPE string_value_exp
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 | '{' SQL_TOKEN_ESCAPE SQL_TOKEN_STRING '}'
  {
   $$ = SQL_NEW_RULE;
   $$->append(newNode("{", SQLNodeType::Punctuation));
   $$->append($2);
   $$->append($3);
   $$->append(newNode("}", SQLNodeType::Punctuation));
  }
 ;

null_predicate_part_2:
   SQL_TOKEN_IS sql_not SQL_TOKEN_NULL
   {
  $$ = SQL_NEW_RULE; // test_for_null: rule 1
  $$->append($1);
  $$->append($2);
  $$->append($3);
   }
 | SQL_TOKEN_IS sql_not SQL_TOKEN_UNKNOWN
   {
  $$ = SQL_NEW_RULE; // test_for_null: rule 1
  $$->append($1);
  $$->append($2);
  $$->append($3);
   }
 ;
test_for_null:
  row_value_constructor null_predicate_part_2
  {
   $$ = SQL_NEW_RULE; // test_for_null: rule 1
   $$->append($1);
   $$->append($2);
  }
 | null_predicate_part_2
  {
   if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())// test_for_null: rule 2
   {
    OSQLParseNode* pColumnRef = newNode("", SQLNodeType::Rule,OSQLParser::RuleID(OSQLParseNode::column_ref));
    pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQLNodeType::Name));

    $$ = SQL_NEW_RULE;
    $$->append(pColumnRef);
    $$->append($1);
   }
   else
    YYERROR;
  }
 ;
in_predicate_value:
  subquery
  {$$ = SQL_NEW_RULE;
   $$->append($1);
  }
   | '(' value_exp_commalist ')'
  {$$ = SQL_NEW_RULE;
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($2);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 ;
in_predicate_part_2:
 sql_not SQL_TOKEN_IN in_predicate_value
 {
  $$ = SQL_NEW_RULE;// in_predicate: rule 1
  $$->append($1);
  $$->append($2);
  $$->append($3);
 }
 ;
in_predicate:
  row_value_constructor in_predicate_part_2
  {
   $$ = SQL_NEW_RULE;// in_predicate: rule 1
   $$->append($1);
   $$->append($2);
  }
 | in_predicate_part_2
  {
   if ( xxx_pGLOBAL_SQLPARSER->inPredicateCheck() )// in_predicate: rule 2
   {
    OSQLParseNode* pColumnRef = newNode("", SQLNodeType::Rule,OSQLParser::RuleID(OSQLParseNode::column_ref));
    pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQLNodeType::Name));

    $$ = SQL_NEW_RULE;
    $$->append(pColumnRef);
    $$->append($1);
   }
   else
    YYERROR;
  }
 ;
quantified_comparison_predicate_part_2:
 comparison any_all_some subquery
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
  $$->append($3);
 }
 ;
all_or_any_predicate:
  row_value_constructor quantified_comparison_predicate_part_2
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 | quantified_comparison_predicate_part_2
  {
   if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
   {
    OSQLParseNode* pColumnRef = newNode("", SQLNodeType::Rule,OSQLParser::RuleID(OSQLParseNode::column_ref));
    pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQLNodeType::Name));

    $$ = SQL_NEW_RULE;
    $$->append(pColumnRef);
    $$->append($1);
   }
   else
    YYERROR;
  }
 ;

any_all_some:
   SQL_TOKEN_ANY
 |       SQL_TOKEN_ALL
 |       SQL_TOKEN_SOME
 ;

existence_test:
  SQL_TOKEN_EXISTS subquery
   {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 ;
unique_test:
  SQL_TOKEN_UNIQUE subquery
  {$$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);}
 ;
subquery:
  '(' query_exp ')'
   {$$ = SQL_NEW_RULE;
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($2);
   $$->append(newNode(")", SQLNodeType::Punctuation));}
 ;

 /* scalar expressions */
scalar_exp_commalist:
  select_sublist
  {
   $$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);
  }
 |   scalar_exp_commalist ',' select_sublist
  {
   $1->append($3);
   $$ = $1;
  }
 ;
select_sublist:
/*  table_node '.' '*'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode(".", SQLNodeType::Punctuation));
   $$->append(newNode("*", SQLNodeType::Punctuation));
  }
*/
  derived_column

 ;

parameter_ref:
  parameter
 ;

/*
op_like:
  '*'
  {
   $$ = newNode("*", SQLNodeType::Punctuation);
  }
 | '?'
  {
   $$ = newNode("?", SQLNodeType::Punctuation);
  }
 |   op_like '*'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("*", SQLNodeType::Punctuation));
   xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_False);
  }
 | op_like '?'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("?", SQLNodeType::Punctuation));
   xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_False);
  }
 ;
*/

literal:
/*  SQL_TOKEN_STRING
 |   */SQL_TOKEN_INT
 |   SQL_TOKEN_REAL_NUM
 |   SQL_TOKEN_INTNUM
 |   SQL_TOKEN_APPROXNUM
 | SQL_TOKEN_ACCESS_DATE
/* rules for predicate check */
 | literal SQL_TOKEN_STRING
  {
   if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
   {
    $$ = SQL_NEW_RULE;
    $$->append($1);
    $$->append($2);
    OSQLParser::reduceLiteral($$, true);
   }
   else
    YYERROR;
  }
 | literal SQL_TOKEN_INT
  {
   if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
   {
    $$ = SQL_NEW_RULE;
    $$->append($1);
    $$->append($2);
    OSQLParser::reduceLiteral($$, true);
   }
   else
    YYERROR;
  }
 | literal SQL_TOKEN_REAL_NUM
  {
   if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
   {
    $$ = SQL_NEW_RULE;
    $$->append($1);
    $$->append($2);
    OSQLParser::reduceLiteral($$, true);
   }
   else
    YYERROR;
  }
 | literal SQL_TOKEN_APPROXNUM
  {
   if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
   {
    $$ = SQL_NEW_RULE;
    $$->append($1);
    $$->append($2);
    OSQLParser::reduceLiteral($$, true);
   }
   else
    YYERROR;
  }
 ;

 /* miscellaneous */
as_clause:
  /* empty */ {$$ = SQL_NEW_RULE;}
 | SQL_TOKEN_AS column
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 | column
 ;
position_exp:
  SQL_TOKEN_POSITION '(' value_exp SQL_TOKEN_IN value_exp ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append($4);
   $$->append($5);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | SQL_TOKEN_POSITION '(' value_exp_commalist ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 ;
num_value_fct:
  position_exp
 | extract_exp
 | length_exp
 ;
char_length_exp:
  SQL_TOKEN_CHAR_LENGTH '(' value_exp ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | SQL_TOKEN_SQL_TOKEN_INTNUM '(' value_exp ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }

 ;
octet_length_exp:
  SQL_TOKEN_OCTET_LENGTH '(' value_exp ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 ;
bit_length_exp:
  SQL_TOKEN_BIT_LENGTH '(' value_exp ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 ;
length_exp:
  char_length_exp
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
  }
   | octet_length_exp
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
  }
   | bit_length_exp
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
  }
 ;
datetime_field:
  non_second_datetime_field
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
  }
   | SQL_TOKEN_SECOND
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
  }
 ;
extract_field:
    time_zone_field
   | datetime_field
   | value_exp
 ;
time_zone_field:
  SQL_TOKEN_TIMEZONE_HOUR
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
  }
   | SQL_TOKEN_TIMEZONE_MINUTE
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
  }
 ;
extract_exp:
  SQL_TOKEN_EXTRACT '(' extract_field SQL_TOKEN_FROM value_exp ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append($4);
   $$->append($5);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 ;
unsigned_value_spec:
  general_value_spec
 | literal
 ;
general_value_spec:
  parameter
 | SQL_TOKEN_USER
 | SQL_TOKEN_NULL
 | SQL_TOKEN_FALSE
 | SQL_TOKEN_TRUE
 | SQL_TOKEN_VALUE
 | SQL_TOKEN_CURRENT_CATALOG
 | SQL_TOKEN_CURRENT_DEFAULT_TRANSFORM_GROUP
 | SQL_TOKEN_CURRENT_PATH
 | SQL_TOKEN_CURRENT_ROLE
 | SQL_TOKEN_CURRENT_SCHEMA
 | SQL_TOKEN_CURRENT_USER
 | SQL_TOKEN_SESSION_USER
 | SQL_TOKEN_SYSTEM_USER
 ;
set_fct_spec:
  general_set_fct
 | '{' odbc_fct_spec '}'
  {
   $$ = SQL_NEW_RULE;
   $$->append(newNode("{", SQLNodeType::Punctuation));
   $$->append($2);
   $$->append(newNode("}", SQLNodeType::Punctuation));
  }
 | function_name '(' ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | function_name0 '(' ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | function_name1 '(' function_arg ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | function_name2 '(' function_arg_commalist2 ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | function_name3 '(' function_arg_commalist3 ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | string_function_4Argument '(' function_arg_commalist4 ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | function_name '(' function_args_commalist ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | function_name12 '(' function_args_commalist ')'
  {
   if ( $3->count() == 1 || $3->count() == 2 )
   {
    $$ = SQL_NEW_RULE;
    $$->append($1);
    $$->append(newNode("(", SQLNodeType::Punctuation));
    $$->append($3);
    $$->append(newNode(")", SQLNodeType::Punctuation));
   }
   else
    YYERROR;
  }
 | function_name23 '(' function_args_commalist ')'
  {
   if ( $3->count() == 2 || $3->count() == 3)
   {
    $$ = SQL_NEW_RULE;
    $$->append($1);
    $$->append(newNode("(", SQLNodeType::Punctuation));
    $$->append($3);
    $$->append(newNode(")", SQLNodeType::Punctuation));
   }
   else
    YYERROR;
  }
 ;
function_name0:
  date_function_0Argument
 | numeric_function_0Argument
 ;
function_name1:
  string_function_1Argument
 | date_function_1Argument
 | numeric_function_1Argument
 ;
function_name2:
  string_function_2Argument
 | numeric_function_2Argument
 ;
function_name12:
  SQL_TOKEN_ROUND
 | SQL_TOKEN_WEEK
 | SQL_TOKEN_LOGF
 | SQL_TOKEN_LOG
 ;
function_name23:
  SQL_TOKEN_LOCATE
 | SQL_TOKEN_DATEDIFF
 ;
function_name3:
  string_function_3Argument
 ;
function_name:
  string_function
 | date_function
 | numeric_function
 | SQL_TOKEN_NAME
 ;
string_function_1Argument:
  SQL_TOKEN_LENGTH
 | SQL_TOKEN_ASCII
 | SQL_TOKEN_LCASE
 | SQL_TOKEN_LTRIM
 | SQL_TOKEN_RTRIM
 | SQL_TOKEN_SPACE
 | SQL_TOKEN_UCASE
 ;

string_function_2Argument:
  SQL_TOKEN_REPEAT
 | SQL_TOKEN_LEFT
 | SQL_TOKEN_RIGHT
 ;
string_function_3Argument:
  SQL_TOKEN_REPLACE
 ;
string_function_4Argument:
  SQL_TOKEN_INSERT
 ;

string_function:
  SQL_TOKEN_CHAR
 | SQL_TOKEN_CONCAT
 | SQL_TOKEN_DIFFERENCE
 | SQL_TOKEN_LOCATE_2
 | SQL_TOKEN_SOUNDEX
 ;
date_function_0Argument:
  SQL_TOKEN_CURDATE
 | SQL_TOKEN_CURTIME
 | SQL_TOKEN_NOW
 ;
date_function_1Argument:
  SQL_TOKEN_DAYOFWEEK
 | SQL_TOKEN_DAYOFMONTH
 | SQL_TOKEN_DAYOFYEAR
 | SQL_TOKEN_MONTH
 | SQL_TOKEN_DAYNAME
 | SQL_TOKEN_MONTHNAME
 | SQL_TOKEN_QUARTER
 | SQL_TOKEN_HOUR
 | SQL_TOKEN_MINUTE
 | SQL_TOKEN_SECOND
 | SQL_TOKEN_YEAR
 | SQL_TOKEN_DAY
 | SQL_TOKEN_TIMEVALUE
 | SQL_TOKEN_DATEVALUE
 ;

date_function:
  SQL_TOKEN_TIMESTAMPADD
 | SQL_TOKEN_TIMESTAMPDIFF
 | SQL_TOKEN_DATEADD
 ;
numeric_function_0Argument:
  SQL_TOKEN_PI
 ;
numeric_function_1Argument:
  SQL_TOKEN_ABS
 | SQL_TOKEN_ACOS
 | SQL_TOKEN_ASIN
 | SQL_TOKEN_ATAN
 | SQL_TOKEN_CEILING
 | SQL_TOKEN_COS
 | SQL_TOKEN_COT
 | SQL_TOKEN_DEGREES
 | SQL_TOKEN_FLOOR
 | SQL_TOKEN_SIGN
 | SQL_TOKEN_SIN
 | SQL_TOKEN_SQRT
 | SQL_TOKEN_TAN
 | SQL_TOKEN_EXP
 | SQL_TOKEN_LOG10
 | SQL_TOKEN_LN
 | SQL_TOKEN_RADIANS
 | SQL_TOKEN_ROUNDMAGIC
 ;
numeric_function_2Argument:
  SQL_TOKEN_ATAN2
 | SQL_TOKEN_MOD
 | SQL_TOKEN_POWER
 ;
numeric_function:
  SQL_TOKEN_RAND
 | SQL_TOKEN_TRUNCATE
 ;

window_function:
 window_function_type SQL_TOKEN_OVER window_name_or_specification
 {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
 }
 ;
window_function_type :
  rank_function_type '(' ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | SQL_TOKEN_ROW_NUMBER '(' ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | general_set_fct
 | ntile_function
 | lead_or_lag_function
 | first_or_last_value_function
 | nth_value_function
;
ntile_function :
 SQL_TOKEN_NTILE '(' number_of_tiles ')'
 {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
 }
 ;
dynamic_parameter_specification:
 parameter
 ;
simple_value_specification:
 literal
 ;
number_of_tiles :
  simple_value_specification
 | dynamic_parameter_specification
 ;
opt_lead_or_lag_function:
 /* empty */      {$$ = SQL_NEW_RULE;}
 | ',' offset
  {
   $$ = SQL_NEW_RULE;
   $$->append(newNode(",", SQLNodeType::Punctuation));
   $$->append($2);
  }
 | ',' offset ',' default_expression
  {
   $$ = SQL_NEW_RULE;
   $$->append(newNode(",", SQLNodeType::Punctuation));
   $$->append($2);
   $$->append(newNode(",", SQLNodeType::Punctuation));
   $$->append($4);
  }
 ;
opt_null_treatment:
  /* empty */      {$$ = SQL_NEW_RULE;}
 | null_treatment
 ;

lead_or_lag_function:
 lead_or_lag '(' lead_or_lag_extent opt_lead_or_lag_function ')' opt_null_treatment
 {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append($4);
   $$->append(newNode(")", SQLNodeType::Punctuation));
   $$->append($6);
 }
 ;
lead_or_lag:
  SQL_TOKEN_LEAD
 | SQL_TOKEN_LAG
 ;
lead_or_lag_extent:
 value_exp
 ;
offset:
 SQL_TOKEN_INTNUM
 ;
default_expression:
 value_exp
 ;
null_treatment:
  SQL_TOKEN_RESPECT SQL_TOKEN_NULLS
 | SQL_TOKEN_IGNORE SQL_TOKEN_NULLS
 ;
first_or_last_value_function:
 first_or_last_value '(' value_exp ')' opt_null_treatment
 {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(")", SQLNodeType::Punctuation));
   $$->append($5);
 }
 ;
first_or_last_value :
  SQL_TOKEN_FIRST_VALUE
 | SQL_TOKEN_LAST_VALUE
 ;
opt_from_first_or_last:
  /* empty */      {$$ = SQL_NEW_RULE;}
 | from_first_or_last
 ;
nth_value_function:
 SQL_TOKEN_NTH_VALUE '(' value_exp ',' nth_row ')' opt_from_first_or_last opt_null_treatment
 {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append(newNode(",", SQLNodeType::Punctuation));
   $$->append($5);
   $$->append(newNode(")", SQLNodeType::Punctuation));
   $$->append($7);
   $$->append($8);
 }
 ;
nth_row:
  simple_value_specification
 | dynamic_parameter_specification
 ;
from_first_or_last:
  SQL_TOKEN_FROM SQL_TOKEN_FIRST
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 | SQL_TOKEN_FROM SQL_TOKEN_LAST
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 ;
window_name:
 SQL_TOKEN_NAME
 ;
window_name_or_specification:
  window_name
 | in_line_window_specification
 ;
in_line_window_specification:
 window_specification
 ;
opt_window_clause:
  /* empty */      {$$ = SQL_NEW_RULE;}
 | window_clause
 ;
window_clause:
 SQL_TOKEN_WINDOW window_definition_list
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
 }
 ;
window_definition_list:
  window_definition_list ',' window_definition
   {$1->append($3);
   $$ = $1;}
 | window_definition
   {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 ;
window_definition:
 new_window_name SQL_TOKEN_AS window_specification
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
  $$->append($3);
 }
 ;
new_window_name:
 window_name
 ;
window_specification:
 '('
  opt_existing_window_name
  opt_window_partition_clause
  opt_order_by_clause
  opt_window_frame_clause
 ')'
 {
  $$ = SQL_NEW_RULE;
  $$->append(newNode("(", SQLNodeType::Punctuation));
  $$->append($2);
  $$->append($3);
  $$->append($4);
  $$->append($5);
  $$->append(newNode(")", SQLNodeType::Punctuation));
 }
 ;
opt_existing_window_name:
  /* empty */      {$$ = SQL_NEW_RULE;}
 | existing_window_name
 ;
opt_window_partition_clause:
 /* empty */      {$$ = SQL_NEW_RULE;}
 | window_partition_clause
 ;
opt_window_frame_clause:
 /* empty */      {$$ = SQL_NEW_RULE;}
 | window_frame_clause
 ;
existing_window_name:
 window_name
 ;
window_partition_clause:
 SQL_TOKEN_PARTITION SQL_TOKEN_BY window_partition_column_reference_list
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
  $$->append($3);
 }
 ;
window_partition_column_reference_list:
 window_partition_column_reference_list ',' window_partition_column_reference
   {$1->append($3);
   $$ = $1;}
 | window_partition_column_reference
   {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 ;
window_partition_column_reference:
 column_ref opt_collate_clause
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
 }
 ;
opt_window_frame_exclusion:
 /* empty */      {$$ = SQL_NEW_RULE;}
 | window_frame_exclusion
 ;
window_frame_clause:
 window_frame_units window_frame_extent opt_window_frame_exclusion
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
  $$->append($3);
 }
 ;
window_frame_units:
  SQL_TOKEN_ROWS
 | SQL_TOKEN_RANGE
 ;
window_frame_extent:
  window_frame_start
 | window_frame_between
 ;
window_frame_start:
  SQL_TOKEN_UNBOUNDED SQL_TOKEN_PRECEDING
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 | window_frame_preceding
 | SQL_TOKEN_CURRENT SQL_TOKEN_ROW
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 ;
window_frame_preceding:
 unsigned_value_spec SQL_TOKEN_PRECEDING
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
 }
 ;
window_frame_between:
 SQL_TOKEN_BETWEEN window_frame_bound_1 SQL_TOKEN_AND window_frame_bound_2
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
  $$->append($3);
  $$->append($4);
 }
 ;
window_frame_bound_1:
 window_frame_bound
 ;
window_frame_bound_2:
 window_frame_bound
 ;
window_frame_bound:
 window_frame_start
 | SQL_TOKEN_UNBOUNDED SQL_TOKEN_FOLLOWING
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
 }
 | window_frame_following
 ;
window_frame_following:
 unsigned_value_spec SQL_TOKEN_FOLLOWING
 {
  $$ = SQL_NEW_RULE;
  $$->append($1);
  $$->append($2);
 }
 ;
window_frame_exclusion:
  SQL_TOKEN_EXCLUDE SQL_TOKEN_CURRENT SQL_TOKEN_ROW
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
  }
 | SQL_TOKEN_EXCLUDE SQL_TOKEN_GROUP
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 | SQL_TOKEN_EXCLUDE SQL_TOKEN_TIES
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 | SQL_TOKEN_EXCLUDE SQL_TOKEN_NO SQL_TOKEN_OTHERS
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
  }
 ;
op_parameter:
  {$$ = SQL_NEW_RULE;}
 | '?' SQL_EQUAL
  {
   $$ = SQL_NEW_RULE;
   $$->append(newNode("?", SQLNodeType::Punctuation));
   $$->append($2);
  }
 ;
odbc_call_spec:
  op_parameter SQL_TOKEN_CALL table_node op_odbc_call_parameter
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
   $$->append($3);
   $$->append($4);
  }
 ;

op_odbc_call_parameter:
  {$$ = SQL_NEW_RULE;}
 | '(' odbc_parameter_commalist ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($2);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 ;

odbc_parameter_commalist:
  odbc_parameter
  {$$ = SQL_NEW_COMMALISTRULE;
   $$->append($1);}
 | odbc_parameter_commalist ',' odbc_parameter
  {
   $1->append($3);
   $$ = $1;
  }
 ;
odbc_parameter:
 /* empty */  {$$ = SQL_NEW_RULE;}
 | literal
 | parameter
 ;

odbc_fct_spec:
  odbc_fct_type SQL_TOKEN_STRING
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 | SQL_TOKEN_FN set_fct_spec
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append($2);
  }
 ;

odbc_fct_type:
  SQL_TOKEN_D
 |  SQL_TOKEN_T
 |  SQL_TOKEN_TS
 ;

general_set_fct:
  set_fct_type '(' opt_all_distinct function_arg ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append($4);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | SQL_TOKEN_COUNT '(' '*' ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append(newNode("*", SQLNodeType::Punctuation));
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | SQL_TOKEN_COUNT '(' opt_all_distinct function_arg ')'
  {
   $$ = SQL_NEW_RULE;
   $$->append($1);
   $$->append(newNode("(", SQLNodeType::Punctuation));
   $$->append($3);
   $$->append($4);
   $$->append(newNode(")", SQLNodeType::Punctuation));
  }
 | ordered_set_function
 | array_aggregate_function
 ;
set_fct_type:
  SQL_TOKEN_AVG
 |   SQL_TOKEN_MAX
 |   SQL_TOKEN_MIN
 |   SQL_TOKEN_SUM
 |   SQL_TOKEN_EVERY
 |   SQL_TOKEN_ANY
 |   SQL_TOKEN_SOME
 |   SQL_TOKEN_STDDEV_POP
 |   SQL_TOKEN_STDDEV_SAMP
 |   SQL_TOKEN_VAR_SAMP
--> --------------------

--> maximum size reached

--> --------------------