| %{ |
| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| #include <vector> |
| #include <string.h> |
| |
| #ifndef _CONNECTIVITY_SQLNODE_HXX |
| #include <connectivity/sqlnode.hxx> |
| #endif |
| #ifndef _CONNECTIVITY_SQLPARSE_HXX |
| #include <connectivity/sqlparse.hxx> |
| #endif |
| #ifndef _CONNECTIVITY_SQLINTERNALNODE_HXX |
| #include <internalnode.hxx> |
| #endif |
| #ifndef _COM_SUN_STAR_LANG_LOCALE_HPP_ |
| #include <com/sun/star/lang/Locale.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_SDBC_DATATYPE_HPP_ |
| #include <com/sun/star/sdbc/DataType.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_DATE_HPP_ |
| #include <com/sun/star/util/Date.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_DATETIME_HPP_ |
| #include <com/sun/star/util/DateTime.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_TIME_HPP_ |
| #include <com/sun/star/util/Time.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_XNUMBERFORMATTER_HPP_ |
| #include <com/sun/star/util/XNumberFormatter.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_XNUMBERFORMATSSUPPLIER_HPP_ |
| #include <com/sun/star/util/XNumberFormatsSupplier.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_XNUMBERFORMATS_HPP_ |
| #include <com/sun/star/util/XNumberFormats.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_NUMBERFORMAT_HPP_ |
| #include <com/sun/star/util/NumberFormat.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_UTIL_XNUMBERFORMATTYPES_HPP_ |
| #include <com/sun/star/util/XNumberFormatTypes.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_BEANS_XPROPERTYSET_HPP_ |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_I18N_KPARSETYPE_HPP_ |
| #include <com/sun/star/i18n/KParseType.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_I18N_KPARSETOKENS_HPP_ |
| #include <com/sun/star/i18n/KParseTokens.hpp> |
| #endif |
| #ifndef _CONNECTIVITY_SQLSCAN_HXX |
| #include "sqlscan.hxx" |
| #endif |
| #ifndef _OSL_DIAGNOSE_H_ |
| #include <osl/diagnose.h> |
| #endif |
| #ifndef _DBHELPER_DBCONVERSION_HXX_ |
| #include "connectivity/dbconversion.hxx" |
| #endif |
| #include <rtl/ustrbuf.hxx> |
| |
| #if defined __GNUC__ |
| #pragma GCC system_header |
| #elif defined __SUNPRO_CC |
| #pragma disable_warn |
| #elif defined _MSC_VER |
| #pragma warning(push, 1) |
| #pragma warning(disable:4273 4701 4706) |
| #endif |
| |
| static ::rtl::OUString aEmptyString; |
| |
| static connectivity::OSQLInternalNode* newNode(const sal_Char* pNewValue, |
| const connectivity::SQLNodeType eNodeType, |
| const sal_uInt32 nNodeID = 0) |
| { |
| return new connectivity::OSQLInternalNode(pNewValue, eNodeType, nNodeID); |
| } |
| |
| static connectivity::OSQLInternalNode* newNode(const ::rtl::OString& _NewValue, |
| const connectivity::SQLNodeType eNodeType, |
| const sal_uInt32 nNodeID = 0) |
| { |
| return new connectivity::OSQLInternalNode(_NewValue, eNodeType, nNodeID); |
| } |
| |
| static connectivity::OSQLInternalNode* newNode(const ::rtl::OUString& _NewValue, |
| const connectivity::SQLNodeType eNodeType, |
| const sal_uInt32 nNodeID = 0) |
| { |
| return new connectivity::OSQLInternalNode(_NewValue, eNodeType, nNodeID); |
| } |
| |
| |
| // yyi ist die interne Nr. der Regel, die gerade reduziert wird. |
| // Ueber die Mapping-Tabelle yyrmap wird daraus eine externe Regel-Nr. |
| #define SQL_NEW_RULE newNode(aEmptyString, SQL_NODE_RULE, yyr1[yyn]) |
| #define SQL_NEW_LISTRULE newNode(aEmptyString, SQL_NODE_LISTRULE, yyr1[yyn]) |
| #define SQL_NEW_COMMALISTRULE newNode(aEmptyString, SQL_NODE_COMMALISTRULE, yyr1[yyn]) |
| |
| |
| 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 |
| |
| %token <pParseNode> SQL_TOKEN_JOIN 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_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_YEAR |
| |
| /* 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*/ |
| /* neue Regeln bei 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 truth_value boolean_test 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> extract_source 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 window_specification_details 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 |
| %% |
| |
| /* Parse Tree an OSQLParser zurueckliefern |
| * (der Zugriff ueber yyval nach Aufruf des Parsers scheitert, |
| * |
| */ |
| 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($2 = newNode(".", SQL_NODE_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_glement_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($4 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($5); |
| $$->append($6 = newNode(")", SQL_NODE_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($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_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($3 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($4); |
| $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION));} |
| ; |
| |
| table_constraint_def: |
| unique_spec '(' column_commalist ')' |
| {$$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));} |
| | SQL_TOKEN_FOREIGN SQL_TOKEN_KEY '(' column_commalist ')' SQL_TOKEN_REFERENCES table_node |
| {$$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($4); |
| $$->append($5 = newNode(")", SQL_NODE_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($3 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($4); |
| $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); |
| $$->append($6); |
| $$->append($7); |
| $$->append($8 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($9); |
| $$->append($10 = newNode(")", SQL_NODE_PUNCTUATION));} |
| | SQL_TOKEN_CHECK '(' search_condition ')' |
| {$$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));} |
| ; |
| op_column_commalist: |
| /* empty */ {$$ = SQL_NEW_RULE;} |
| | '(' column_commalist ')' |
| {$$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_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($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_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: |
| {$$ = 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($1 = newNode("{", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode("}", SQL_NODE_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 values_or_query_spec |
| {$$ = 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($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_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($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_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($1 = newNode("*", SQL_NODE_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($1 = newNode("{", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4 = newNode("}", SQL_NODE_PUNCTUATION)); |
| } |
| | '(' joined_table ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_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 */ |
| truth_value: |
| SQL_TOKEN_TRUE |
| | SQL_TOKEN_FALSE |
| | SQL_TOKEN_UNKNOWN |
| | SQL_TOKEN_NULL |
| ; |
| boolean_primary: |
| predicate |
| | '(' search_condition ')' |
| { // boolean_primary: rule 2 |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | row_value_constructor_elem /*[^')' ',']*/ |
| { |
| if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck())// boolean_primary: rule 3 |
| { |
| $$ = SQL_NEW_RULE; |
| sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildComparsionRule($$,$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($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| boolean_test: |
| boolean_primary |
| | boolean_primary SQL_TOKEN_IS sql_not truth_value |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| ; |
| boolean_factor: |
| boolean_test |
| | SQL_TOKEN_NOT boolean_test |
| { // 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 |
| | between_predicate |
| | all_or_any_predicate |
| | existence_test |
| | unique_test |
| | test_for_null |
| | 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 |
| ; |
| 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(aEmptyString, SQL_NODE_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(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref)); |
| pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_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(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref)); |
| pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_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($1 = newNode("{", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4 = newNode("}", SQL_NODE_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); |
| } |
| ; |
| 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(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref)); |
| pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_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($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_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(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref)); |
| pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_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(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref)); |
| pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_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($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_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($2 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($3 = newNode("*", SQL_NODE_PUNCTUATION)); |
| } |
| */ |
| derived_column |
| |
| ; |
| |
| parameter_ref: |
| parameter |
| ; |
| |
| /* |
| op_like: |
| '*' |
| { |
| $$ = newNode("*", SQL_NODE_PUNCTUATION); |
| } |
| | '?' |
| { |
| $$ = newNode("?", SQL_NODE_PUNCTUATION); |
| } |
| | op_like '*' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("*", SQL_NODE_PUNCTUATION)); |
| xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_False); |
| } |
| | op_like '?' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("?", SQL_NODE_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); |
| xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_True); |
| } |
| else |
| YYERROR; |
| } |
| | literal SQL_TOKEN_INT |
| { |
| if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_True); |
| } |
| else |
| YYERROR; |
| } |
| | literal SQL_TOKEN_REAL_NUM |
| { |
| if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_True); |
| } |
| else |
| YYERROR; |
| } |
| | literal SQL_TOKEN_APPROXNUM |
| { |
| if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_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($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | SQL_TOKEN_POSITION '(' value_exp_commalist ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_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($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | SQL_TOKEN_SQL_TOKEN_INTNUM '(' value_exp ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| |
| ; |
| octet_length_exp: |
| SQL_TOKEN_OCTET_LENGTH '(' value_exp ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| bit_length_exp: |
| SQL_TOKEN_BIT_LENGTH '(' value_exp ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_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_source: |
| datetime_value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| /* | interval_value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } */ |
| ; |
| extract_exp: |
| SQL_TOKEN_EXTRACT '(' extract_field SQL_TOKEN_FROM value_exp ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| $$->append($6 = newNode(")", SQL_NODE_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($1 = newNode("{", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode("}", SQL_NODE_PUNCTUATION)); |
| } |
| | function_name '(' ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | function_name0 '(' ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | function_name1 '(' function_arg ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | function_name2 '(' function_arg_commalist2 ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | function_name3 '(' function_arg_commalist3 ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | string_function_4Argument '(' function_arg_commalist4 ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | function_name '(' function_args_commalist ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | function_name12 '(' function_args_commalist ')' |
| { |
| if ( $3->count() == 1 || $3->count() == 2 ) |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| else |
| YYERROR; |
| } |
| | function_name23 '(' function_args_commalist ')' |
| { |
| if ( $3->count() == 2 || $3->count() == 3) |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_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 |
| ; |
| 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($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | SQL_TOKEN_ROW_NUMBER '(' ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3 = newNode(")", SQL_NODE_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($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_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($1 = newNode(",", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| } |
| | ',' offset ',' default_expression |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode(",", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(",", SQL_NODE_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($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5 = newNode(")", SQL_NODE_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($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_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($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(",", SQL_NODE_PUNCTUATION)); |
| $$->append($5); |
| $$->append($6 = newNode(")", SQL_NODE_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: |
| '(' window_specification_details ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_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 |
| ; |
| window_specification_details: |
| opt_existing_window_name |
| opt_window_partition_clause |
| opt_order_by_clause |
| opt_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($1 = newNode("?", SQL_NODE_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($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_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($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | SQL_TOKEN_COUNT '(' '*' ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3 = newNode("*", SQL_NODE_PUNCTUATION)); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | SQL_TOKEN_COUNT '(' opt_all_distinct function_arg ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5 = newNode(")", SQL_NODE_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 |
| | SQL_TOKEN_VAR_POP |
| | SQL_TOKEN_COLLECT |
| | SQL_TOKEN_FUSION |
| | SQL_TOKEN_INTERSECTION |
| ; |
| |
| ordered_set_function: |
| hypothetical_set_function |
| | inverse_distribution_function |
| ; |
| hypothetical_set_function: |
| rank_function_type '(' hypothetical_set_function_value_expression_list ')' within_group_specification |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| $$->append($5); |
| } |
| | rank_function_type '(' hypothetical_set_function_value_expression_list SQL_TOKEN_BY value_exp_commalist ')' within_group_specification |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); |
| $$->append($7); |
| } |
| ; |
| |
| within_group_specification: |
| { |
| $$ = SQL_NEW_RULE; |
| } |
| | SQL_TOKEN_WITHIN SQL_TOKEN_GROUP '(' opt_order_by_clause ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($4); |
| $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| hypothetical_set_function_value_expression_list: |
| value_exp_commalist |
| ; |
| |
| inverse_distribution_function: |
| inverse_distribution_function_type '('inverse_distribution_function_argument ')' within_group_specification |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| inverse_distribution_function_argument: |
| num_value_exp |
| ; |
| inverse_distribution_function_type: |
| SQL_TOKEN_PERCENTILE_CONT |
| | SQL_TOKEN_PERCENTILE_DISC |
| ; |
| |
| array_aggregate_function: |
| SQL_TOKEN_ARRAY_AGG '(' value_exp opt_order_by_clause ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| |
| rank_function_type: |
| SQL_TOKEN_RANK |
| | SQL_TOKEN_DENSE_RANK |
| | SQL_TOKEN_PERCENT_RANK |
| | SQL_TOKEN_CUME_DIST |
| ; |
| outer_join_type: |
| SQL_TOKEN_LEFT %prec SQL_TOKEN_LEFT |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| | SQL_TOKEN_RIGHT %prec SQL_TOKEN_RIGHT |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| | SQL_TOKEN_FULL %prec SQL_TOKEN_FULL |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| ; |
| join_condition: |
| SQL_TOKEN_ON search_condition |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| join_spec: |
| join_condition |
| | named_columns_join |
| ; |
| join_type: |
| /* empty */ {$$ = SQL_NEW_RULE;} |
| | SQL_TOKEN_INNER |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| | outer_join_type |
| | outer_join_type SQL_TOKEN_OUTER |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| cross_union: |
| table_ref SQL_TOKEN_CROSS SQL_TOKEN_JOIN table_ref |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| ; |
| |
| qualified_join: |
| /* wenn SQL_TOKEN_NATURAL, dann keine join_spec */ |
| table_ref SQL_TOKEN_NATURAL join_type SQL_TOKEN_JOIN table_ref |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| } |
| | table_ref join_type SQL_TOKEN_JOIN table_ref join_spec |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| } |
| | cross_union |
| ; |
| joined_table: |
| qualified_join |
| ; |
| named_columns_join: |
| SQL_TOKEN_USING '(' column_commalist ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| simple_table: |
| select_statement |
| | values_or_query_spec |
| ; |
| |
| non_join_query_primary: |
| simple_table |
| | '(' non_join_query_exp ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| non_join_query_term: |
| non_join_query_primary |
| | query_term SQL_TOKEN_INTERSECT all query_primary |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| ; |
| query_primary: |
| non_join_query_primary |
| ; |
| non_join_query_exp: |
| non_join_query_term |
| | query_exp SQL_TOKEN_UNION all query_term |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| | query_exp SQL_TOKEN_EXCEPT all query_term |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| ; |
| all: |
| /* empty*/ {$$ = SQL_NEW_RULE;} |
| | SQL_TOKEN_ALL |
| ; |
| query_exp: |
| non_join_query_exp /*[^')']*/ |
| ; |
| scalar_subquery: |
| subquery |
| ; |
| cast_operand: |
| value_exp |
| ; |
| cast_target: |
| table_node |
| | data_type |
| ; |
| cast_spec: |
| SQL_TOKEN_CAST '(' cast_operand SQL_TOKEN_AS cast_target ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| value_exp_primary: |
| unsigned_value_spec |
| | column_ref |
| | set_fct_spec |
| | scalar_subquery |
| | case_expression |
| | window_function |
| | '(' value_exp ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | cast_spec |
| ; |
| |
| num_primary: |
| value_exp_primary |
| | num_value_fct |
| ; |
| factor: |
| num_primary |
| | '-' num_primary %prec SQL_TOKEN_UMINUS |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("-", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| } |
| | '+' num_primary %prec SQL_TOKEN_UMINUS |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("+", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| } |
| ; |
| |
| term: |
| factor |
| | term '*' factor |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("*", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| | term '/' factor |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("/", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| ; |
| |
| num_value_exp: |
| term |
| | num_value_exp '+' term |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| | num_value_exp '-' term |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("-", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| ; |
| datetime_primary: |
| /* value_exp_primary |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| |*/ datetime_value_fct |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| ; |
| datetime_value_fct: |
| SQL_TOKEN_CURRENT_DATE |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| | SQL_TOKEN_CURRENT_TIME |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| | SQL_TOKEN_CURRENT_TIMESTAMP |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| ; |
| time_zone: |
| SQL_TOKEN_AT time_zone_specifier |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| time_zone_specifier: |
| SQL_TOKEN_LOCAL |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| /* | SQL_TOKEN_TIME SQL_TOKEN_ZONE interval_value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| }*/ |
| ; |
| datetime_factor: |
| datetime_primary |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| | datetime_primary time_zone |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| datetime_term: |
| datetime_factor |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| ; |
| /* |
| interval_term: |
| literal |
| | interval_term '*' factor |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("*", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| | interval_term '/' factor |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("/", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| ; |
| */ |
| datetime_value_exp: |
| datetime_term |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| /* | interval_value_exp '+' datetime_term |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| | datetime_value_exp '+' interval_term |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| | datetime_value_exp '-' interval_term |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("-", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| */ ; |
| /* |
| interval_value_exp: |
| interval_term |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| | interval_value_exp '+' interval_term |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| | interval_value_exp '-' interval_term |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("-", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| | '(' datetime_value_exp '-' datetime_term ')' interval_qualifier |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode("-", SQL_NODE_PUNCTUATION)); |
| $$->append($4); |
| $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); |
| $$->append($6); |
| } |
| ; |
| */ |
| non_second_datetime_field: |
| SQL_TOKEN_YEAR |
| | SQL_TOKEN_MONTH |
| | SQL_TOKEN_DAY |
| | SQL_TOKEN_HOUR |
| | SQL_TOKEN_MINUTE |
| ; |
| start_field: |
| non_second_datetime_field opt_paren_precision |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| end_field: |
| non_second_datetime_field |
| | SQL_TOKEN_SECOND opt_paren_precision |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| |
| single_datetime_field: |
| non_second_datetime_field opt_paren_precision |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| | SQL_TOKEN_SECOND opt_paren_precision_scale |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| |
| interval_qualifier: |
| start_field SQL_TOKEN_TO end_field |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | single_datetime_field |
| ; |
| |
| function_arg_commalist2: |
| function_arg ',' function_arg |
| {$$ = SQL_NEW_COMMALISTRULE; |
| $$->append($1); |
| $$->append($3);} |
| ; |
| function_arg_commalist3: |
| function_arg ',' function_arg ',' function_arg |
| { |
| $$ = SQL_NEW_COMMALISTRULE; |
| $$->append($1); |
| $$->append($3); |
| $$->append($5); |
| } |
| ; |
| function_arg_commalist4: |
| function_arg ',' function_arg ',' function_arg ',' function_arg |
| { |
| $$ = SQL_NEW_COMMALISTRULE; |
| $$->append($1); |
| $$->append($3); |
| $$->append($5); |
| $$->append($7); |
| } |
| ; |
| value_exp_commalist: |
| value_exp |
| {$$ = SQL_NEW_COMMALISTRULE; |
| $$->append($1);} |
| | value_exp_commalist ',' value_exp |
| {$1->append($3); |
| $$ = $1;} |
| /* this rule is only valid if we check predicates */ |
| | value_exp_commalist ';' value_exp |
| { |
| if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) |
| { |
| $1->append($3); |
| $$ = $1; |
| } |
| else |
| YYERROR; |
| } |
| ; |
| function_arg: |
| result |
| | value_exp comparison value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | value_exp SQL_TOKEN_USING value_exp comparison value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| | value_exp SQL_TOKEN_BY value_exp_commalist |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| ; |
| function_args_commalist: |
| function_arg |
| {$$ = SQL_NEW_COMMALISTRULE; |
| $$->append($1);} |
| | function_args_commalist ',' function_arg |
| {$1->append($3); |
| $$ = $1;} |
| /* this rule is only valid if we check predicates */ |
| | function_args_commalist ';' function_arg |
| { |
| if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) |
| { |
| $1->append($3); |
| $$ = $1; |
| } |
| else |
| YYERROR; |
| } |
| ; |
| |
| value_exp: |
| num_value_exp /*[^')']*/ |
| | string_value_exp |
| | datetime_value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| ; |
| string_value_exp: |
| char_value_exp |
| /* | bit_value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| */ ; |
| char_value_exp: |
| char_factor |
| | concatenation |
| ; |
| concatenation: |
| char_value_exp '+' char_factor |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| | value_exp SQL_CONCAT value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| ; |
| |
| char_primary: |
| SQL_TOKEN_STRING |
| | string_value_fct |
| ; |
| collate_clause: |
| SQL_TOKEN_COLLATE table_node |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| char_factor: |
| char_primary |
| | char_primary collate_clause |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| string_value_fct: |
| char_value_fct |
| | bit_value_fct |
| ; |
| bit_value_fct: |
| bit_substring_fct |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| ; |
| bit_substring_fct: |
| SQL_TOKEN_SUBSTRING '(' bit_value_exp SQL_TOKEN_FROM string_value_exp for_length ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| $$->append($6); |
| $$->append($7 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| bit_value_exp: |
| bit_factor |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| ; |
| /* |
| bit_concatenation |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| | |
| bit_concatenation: |
| bit_value_exp '+' bit_factor |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| ; |
| */ |
| bit_factor: |
| bit_primary |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| ; |
| bit_primary: |
| {$$ = SQL_NEW_RULE;} |
| /* value_exp_primary |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| | string_value_fct |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| }*/ |
| ; |
| char_value_fct: |
| char_substring_fct |
| | fold |
| | form_conversion |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| | char_translation |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| | trim_fct |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| } |
| ; |
| for_length: |
| {$$ = SQL_NEW_RULE;} |
| | SQL_TOKEN_FOR value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| char_substring_fct: |
| SQL_TOKEN_SUBSTRING '(' value_exp SQL_TOKEN_FROM value_exp for_length ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| $$->append($6); |
| $$->append($7 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | SQL_TOKEN_SUBSTRING '(' value_exp_commalist ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| upper_lower: |
| SQL_TOKEN_UPPER |
| | SQL_TOKEN_LOWER |
| ; |
| fold: |
| upper_lower '(' value_exp ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| form_conversion: |
| SQL_TOKEN_CONVERT '(' string_value_exp SQL_TOKEN_USING table_node ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | SQL_TOKEN_CONVERT '(' cast_operand ',' cast_target ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($2 = newNode(",", SQL_NODE_PUNCTUATION)); |
| $$->append($5); |
| $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| char_translation: |
| SQL_TOKEN_TRANSLATE '(' string_value_exp SQL_TOKEN_USING table_node ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| trim_fct: |
| SQL_TOKEN_TRIM '(' trim_operands ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| trim_operands: |
| trim_spec value_exp SQL_TOKEN_FROM value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| | trim_spec SQL_TOKEN_FROM value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | value_exp SQL_TOKEN_FROM value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | SQL_TOKEN_FROM value_exp |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| | value_exp |
| ; |
| |
| trim_spec: |
| SQL_TOKEN_BOTH |
| | SQL_TOKEN_LEADING |
| | SQL_TOKEN_TRAILING |
| ; |
| |
| derived_column: |
| value_exp as_clause |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| /* Tabellenname */ |
| table_node: |
| table_name |
| | schema_name |
| | catalog_name |
| ; |
| catalog_name: |
| SQL_TOKEN_NAME '.' schema_name |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| | SQL_TOKEN_NAME ':' schema_name |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode(":", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| ; |
| schema_name: |
| SQL_TOKEN_NAME '.' table_name |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| ; |
| |
| table_name: |
| SQL_TOKEN_NAME |
| {$$ = SQL_NEW_RULE; |
| $$->append($1);} |
| ; |
| /* Columns */ |
| column_ref: |
| column |
| {$$ = SQL_NEW_RULE; |
| $$->append($1);} |
| /* | table_node '.' column_val %prec '.' |
| {$$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($3);} |
| */ |
| | SQL_TOKEN_NAME '.' column_val %prec '.' |
| {$$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| } |
| | SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' column_val %prec '.' |
| {$$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($5);} |
| | SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' column_val %prec '.' |
| {$$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2= newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($5); |
| $$->append($6 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($7); |
| } |
| | SQL_TOKEN_NAME ':' SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' column_val %prec '.' |
| {$$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2= newNode(":", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($5); |
| $$->append($6 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($7); |
| } |
| /* | SQL_TOKEN_NAME ';' SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' column_val |
| {$$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2= newNode(";", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($5); |
| $$->append($6 = newNode(".", SQL_NODE_PUNCTUATION)); |
| $$->append($7); |
| } |
| */ ; |
| |
| /* data types */ |
| column_val: |
| column |
| {$$ = SQL_NEW_RULE; |
| $$->append($1);} |
| | '*' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("*", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| data_type: |
| predefined_type |
| ; |
| opt_char_set_spec: |
| {$$ = SQL_NEW_RULE;} |
| | SQL_TOKEN_CHARACTER SQL_TOKEN_SET SQL_TOKEN_NAME |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| ; |
| opt_collate_clause: |
| {$$ = SQL_NEW_RULE;} |
| | collate_clause |
| ; |
| predefined_type: |
| character_string_type opt_char_set_spec opt_collate_clause |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | national_character_string_type opt_collate_clause |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| | binary_string_type |
| | numeric_type |
| | boolean_type |
| | datetime_type |
| | interval_type |
| ; |
| character_string_type: |
| SQL_TOKEN_CHARACTER opt_paren_precision |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| | SQL_TOKEN_CHAR opt_paren_precision |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| | SQL_TOKEN_CHARACTER SQL_TOKEN_VARYING paren_char_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | SQL_TOKEN_CHAR SQL_TOKEN_VARYING paren_char_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | SQL_TOKEN_VARCHAR paren_char_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| | character_large_object_type |
| ; |
| opt_paren_precision: |
| {$$ = SQL_NEW_RULE;} |
| | paren_char_length |
| ; |
| paren_char_length: |
| '(' SQL_TOKEN_INTNUM ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| opt_paren_char_large_length: |
| {$$ = SQL_NEW_RULE;} |
| | paren_character_large_object_length |
| ; |
| paren_character_large_object_length: |
| '(' large_object_length ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| |
| large_object_length: |
| SQL_TOKEN_INTNUM opt_multiplier |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| opt_multiplier: |
| {$$ = SQL_NEW_RULE;} |
| | 'K' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("K", SQL_NODE_PUNCTUATION)); |
| } |
| | 'M' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("M", SQL_NODE_PUNCTUATION)); |
| } |
| | 'G' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("G", SQL_NODE_PUNCTUATION)); |
| } |
| | 'T' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("T", SQL_NODE_PUNCTUATION)); |
| } |
| | 'P' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("P", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| character_large_object_type: |
| SQL_TOKEN_CHARACTER SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| | SQL_TOKEN_CHAR SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| | SQL_TOKEN_CLOB opt_paren_char_large_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| national_character_string_type: |
| SQL_TOKEN_NATIONAL SQL_TOKEN_CHARACTER opt_paren_precision |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | SQL_TOKEN_NATIONAL SQL_TOKEN_CHAR opt_paren_precision |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | SQL_TOKEN_NCHAR opt_paren_precision |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| | SQL_TOKEN_NATIONAL SQL_TOKEN_CHARACTER SQL_TOKEN_VARYING paren_char_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| | SQL_TOKEN_NATIONAL SQL_TOKEN_CHAR SQL_TOKEN_VARYING paren_char_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| | SQL_TOKEN_NCHAR SQL_TOKEN_VARYING paren_char_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | national_character_large_object_type |
| ; |
| national_character_large_object_type: |
| SQL_TOKEN_NATIONAL SQL_TOKEN_CHARACTER SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| } |
| | SQL_TOKEN_NCHAR SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| | SQL_TOKEN_NCLOB opt_paren_char_large_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| binary_string_type: |
| SQL_TOKEN_BINARY opt_paren_precision |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| | SQL_TOKEN_BINARY SQL_TOKEN_VARYING paren_char_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | SQL_TOKEN_VARBINARY paren_char_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| | binary_large_object_string_type |
| ; |
| binary_large_object_string_type: |
| SQL_TOKEN_BINARY SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| | SQL_TOKEN_BLOB opt_paren_char_large_length |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| numeric_type: |
| exact_numeric_type |
| | approximate_numeric_type |
| ; |
| opt_paren_precision_scale: |
| {$$ = SQL_NEW_RULE;} |
| | '(' SQL_TOKEN_INTNUM ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | '(' SQL_TOKEN_INTNUM ',' SQL_TOKEN_INTNUM ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode(",", SQL_NODE_PUNCTUATION)); |
| $$->append($4); |
| $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| exact_numeric_type: |
| SQL_TOKEN_NUMERIC opt_paren_precision_scale |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| | SQL_TOKEN_DECIMAL opt_paren_precision_scale |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| | SQL_TOKEN_DEC opt_paren_precision_scale |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| | SQL_TOKEN_SMALLINT |
| | SQL_TOKEN_INTEGER |
| | SQL_TOKEN_INT |
| | SQL_TOKEN_BIGINT |
| ; |
| approximate_numeric_type: |
| SQL_TOKEN_FLOAT '(' SQL_TOKEN_INTNUM ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | SQL_TOKEN_FLOAT |
| | SQL_TOKEN_REAL |
| | SQL_TOKEN_DOUBLE |
| | SQL_TOKEN_DOUBLE SQL_TOKEN_PRECISION |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| boolean_type: |
| SQL_TOKEN_BOOLEAN |
| ; |
| datetime_type: |
| SQL_TOKEN_DATE |
| | SQL_TOKEN_TIME opt_paren_precision opt_with_or_without_time_zone |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | SQL_TOKEN_TIMESTAMP opt_paren_precision opt_with_or_without_time_zone |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| ; |
| opt_with_or_without_time_zone: |
| {$$ = SQL_NEW_RULE;} |
| | SQL_TOKEN_WITH SQL_TOKEN_TIME SQL_TOKEN_ZONE |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| | SQL_TOKEN_WITHOUT SQL_TOKEN_TIME SQL_TOKEN_ZONE |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| ; |
| interval_type: |
| SQL_TOKEN_INTERVAL interval_qualifier |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| /* the various things you can name */ |
| |
| column: |
| SQL_TOKEN_NAME |
| | SQL_TOKEN_POSITION |
| { |
| sal_uInt32 nNod = $$->getRuleID(); |
| delete $$; |
| $$ = newNode(xxx_pGLOBAL_SQLPARSER->TokenIDToStr(nNod), SQL_NODE_NAME); |
| } |
| | SQL_TOKEN_CHAR_LENGTH |
| { |
| sal_uInt32 nNod = $$->getRuleID(); |
| delete $$; |
| $$ = newNode(xxx_pGLOBAL_SQLPARSER->TokenIDToStr(nNod), SQL_NODE_NAME); |
| } |
| | SQL_TOKEN_EXTRACT |
| { |
| sal_uInt32 nNod = $$->getRuleID(); |
| delete $$; |
| $$ = newNode(xxx_pGLOBAL_SQLPARSER->TokenIDToStr(nNod), SQL_NODE_NAME); |
| } |
| ; |
| case_expression: |
| case_abbreviation |
| | case_specification |
| ; |
| case_abbreviation: |
| SQL_TOKEN_NULLIF '(' value_exp_commalist ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | SQL_TOKEN_COALESCE '(' value_exp ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| | SQL_TOKEN_COALESCE '(' value_exp_commalist ')' |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append($3); |
| $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| ; |
| case_specification: |
| simple_case |
| | searched_case |
| ; |
| simple_case: |
| SQL_TOKEN_CASE case_operand simple_when_clause_list else_clause SQL_TOKEN_END |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| } |
| ; |
| searched_case: |
| SQL_TOKEN_CASE searched_when_clause_list else_clause SQL_TOKEN_END |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| ; |
| simple_when_clause_list: |
| simple_when_clause |
| { |
| $$ = SQL_NEW_LISTRULE; |
| $$->append($1); |
| } |
| | searched_when_clause_list simple_when_clause |
| { |
| $1->append($2); |
| $$ = $1; |
| } |
| ; |
| simple_when_clause: |
| SQL_TOKEN_WHEN when_operand_list SQL_TOKEN_THEN result |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| ; |
| when_operand_list: |
| when_operand |
| {$$ = SQL_NEW_COMMALISTRULE; |
| $$->append($1);} |
| | when_operand_list ',' when_operand |
| {$1->append($3); |
| $$ = $1;} |
| ; |
| when_operand: |
| row_value_constructor_elem |
| | comparison_predicate_part_2 |
| | between_predicate_part_2 |
| | in_predicate_part_2 |
| | character_like_predicate_part_2 |
| | null_predicate_part_2 |
| ; |
| searched_when_clause_list: |
| searched_when_clause |
| { |
| $$ = SQL_NEW_LISTRULE; |
| $$->append($1); |
| } |
| | searched_when_clause_list searched_when_clause |
| { |
| $1->append($2); |
| $$ = $1; |
| } |
| ; |
| searched_when_clause: |
| SQL_TOKEN_WHEN search_condition SQL_TOKEN_THEN result |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| ; |
| else_clause: |
| {$$ = SQL_NEW_RULE;} |
| | SQL_TOKEN_ELSE result |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| result: |
| result_expression |
| | SQL_TOKEN_NULL |
| ; |
| result_expression: |
| value_exp |
| ; |
| case_operand: |
| row_value_constructor_elem |
| ; |
| |
| cursor: SQL_TOKEN_NAME |
| {$$ = SQL_NEW_RULE; |
| $$->append($1);} |
| ; |
| |
| /*** |
| module: SQL_TOKEN_NAME |
| {$$ = SQL_NEW_RULE; |
| $$->append($1);} |
| ; |
| ***/ |
| |
| parameter: |
| ':' SQL_TOKEN_NAME |
| {$$ = SQL_NEW_RULE; |
| $$->append($1 = newNode(":", SQL_NODE_PUNCTUATION)); |
| $$->append($2);} |
| | '?' |
| {$$ = SQL_NEW_RULE; // test |
| $$->append($1 = newNode("?", SQL_NODE_PUNCTUATION));} |
| | '[' SQL_TOKEN_NAME ']' |
| {$$ = SQL_NEW_RULE; |
| $$->append($1 = newNode("[", SQL_NODE_PUNCTUATION)); |
| $$->append($2); |
| $$->append($3 = newNode("]", SQL_NODE_PUNCTUATION));} |
| ; |
| |
| /*** |
| procedure: SQL_TOKEN_NAME |
| {$$ = SQL_NEW_RULE; |
| $$->append($1);} |
| ; |
| ***/ |
| |
| range_variable: |
| {$$ = SQL_NEW_RULE;} |
| | opt_as SQL_TOKEN_NAME |
| {$$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| |
| user: SQL_TOKEN_NAME |
| ; |
| |
| /* PREDICATECHECK RULES */ |
| sql: |
| search_condition /* checking predicats */ |
| { |
| if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // sql: rule 1 |
| { |
| $$ = $1; |
| if ( SQL_ISRULE($$,search_condition) ) |
| { |
| $$->insert(0,newNode("(", SQL_NODE_PUNCTUATION)); |
| $$->append(newNode(")", SQL_NODE_PUNCTUATION)); |
| } |
| } |
| else |
| YYERROR; |
| } |
| | '(' sql ')' /* checking predicats */ |
| ; |
| trigger_definition: |
| SQL_TOKEN_CREATE SQL_TOKEN_TRIGGER trigger_name trigger_action_time trigger_event SQL_TOKEN_ON table_name op_referencing triggered_action |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| $$->append($5); |
| $$->append($6); |
| $$->append($7); |
| $$->append($8); |
| $$->append($9); |
| } |
| ; |
| op_referencing: |
| { |
| $$ = SQL_NEW_RULE; |
| } |
| | SQL_TOKEN_REFERENCING transition_table_or_variable_list |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| trigger_action_time: |
| SQL_TOKEN_BEFORE |
| | SQL_TOKEN_AFTER |
| | SQL_TOKEN_INSTEAD SQL_TOKEN_OF |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| trigger_event: |
| SQL_TOKEN_INSERT |
| | SQL_TOKEN_DELETE |
| | SQL_TOKEN_UPDATE op_trigger_columnlist |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| op_trigger_columnlist: |
| { |
| $$ = SQL_NEW_RULE; |
| } |
| | SQL_TOKEN_OF trigger_column_list |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| trigger_column_list: |
| column_commalist |
| ; |
| triggered_action: |
| op_triggered_action_for triggered_when_clause triggered_SQL_statement |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| ; |
| op_triggered_action_for: |
| { |
| $$ = SQL_NEW_RULE; |
| } |
| | SQL_TOKEN_FOR SQL_TOKEN_EACH trigger_for |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| } |
| ; |
| trigger_for: |
| SQL_TOKEN_ROW |
| | SQL_TOKEN_STATEMENT |
| ; |
| triggered_when_clause: |
| { |
| $$ = SQL_NEW_RULE; |
| } |
| | SQL_TOKEN_WHEN parenthesized_boolean_value_expression |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| } |
| ; |
| triggered_SQL_statement: |
| SQL_procedure_statement |
| | SQL_TOKEN_BEGIN SQL_TOKEN_ATOMIC SQL_procedure_statement_list ';' SQL_TOKEN_END |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4 = newNode(";", SQL_NODE_PUNCTUATION)); |
| $$->append($5); |
| } |
| ; |
| SQL_procedure_statement_list: |
| SQL_procedure_statement |
| { |
| $$ = SQL_NEW_LISTRULE; |
| $$->append($1); |
| } |
| | SQL_procedure_statement_list ';' SQL_procedure_statement |
| { |
| $1->append($3); |
| $$ = $1; |
| } |
| ; |
| SQL_procedure_statement: |
| sql |
| ; |
| |
| transition_table_or_variable_list: |
| transition_table_or_variable |
| { |
| $$ = SQL_NEW_LISTRULE; |
| $$->append($1); |
| } |
| | transition_table_or_variable_list transition_table_or_variable |
| { |
| $1->append($2); |
| $$ = $1; |
| } |
| ; |
| |
| transition_table_or_variable: |
| SQL_TOKEN_OLD opt_row opt_as old_transition_variable_name |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| | SQL_TOKEN_NEW opt_row opt_as new_transition_variable_name |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| | SQL_TOKEN_OLD SQL_TOKEN_TABLE opt_as old_transition_table_name |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| | SQL_TOKEN_NEW SQL_TOKEN_TABLE opt_as new_transition_table_name |
| { |
| $$ = SQL_NEW_RULE; |
| $$->append($1); |
| $$->append($2); |
| $$->append($3); |
| $$->append($4); |
| } |
| ; |
| old_transition_table_name: |
| transition_table_name |
| ; |
| new_transition_table_name: |
| transition_table_name |
| ; |
| transition_table_name: |
| SQL_TOKEN_NAME |
| ; |
| old_transition_variable_name: |
| SQL_TOKEN_NAME |
| ; |
| new_transition_variable_name: |
| SQL_TOKEN_NAME |
| ; |
| trigger_name: |
| SQL_TOKEN_NAME |
| ; |
| %% |
| |
| |
| using namespace ::com::sun::star::sdbc; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::i18n; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::util; |
| using namespace ::osl; |
| using namespace ::dbtools; |
| // using namespace connectivity; |
| |
| //============================================================ |
| //= a helper for static ascii pseudo-unicode strings |
| //============================================================ |
| // string constants |
| struct _ConstAsciiString_ |
| { |
| sal_Int32 length; |
| sal_Char const* str; |
| |
| operator rtl::OUString () const { return rtl::OUString(str, length, RTL_TEXTENCODING_ASCII_US); } |
| // operator ::rtl::OUString () const { return ::rtl::OUString(str, length, RTL_TEXTENCODING_ASCII_US); } |
| operator const sal_Char * () const { return str; } |
| operator ::rtl::OString() const { return str; } |
| }; |
| |
| #define IMPLEMENT_CONSTASCII_STRING( name, string ) \ |
| _ConstAsciiString_ const name = { sizeof(string)-1, string } |
| |
| IMPLEMENT_CONSTASCII_STRING(ERROR_STR_GENERAL, "Syntax error in SQL expression"); |
| IMPLEMENT_CONSTASCII_STRING(ERROR_STR_VALUE_NO_LIKE, "The value #1 can not be used with LIKE."); |
| IMPLEMENT_CONSTASCII_STRING(ERROR_STR_FIELD_NO_LIKE, "LIKE can not be used with this field."); |
| IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_COMPARE, "The entered criterion can not be compared with this field."); |
| IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_DATE_COMPARE, "The field can not be compared with a date."); |
| IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_REAL_COMPARE, "The field can not be compared with a floating point number."); |
| IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_INT_COMPARE, "The field can not be compared with a number."); |
| IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_TABLE, "The database does not contain a table named \"#\"."); |
| IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_TABLE_OR_QUERY, "The database does contain neither a table nor a query named \"#\"."); |
| IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_COLUMN, "The column \"#1\" is unknown in the table \"#2\"."); |
| IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_TABLE_EXIST, "The database already contains a table or view with name \"#\"."); |
| IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_QUERY_EXIST, "The database already contains a query with name \"#\"."); |
| |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_LIKE, "LIKE"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_NOT, "NOT"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_NULL, "NULL"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_TRUE, "True"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_FALSE, "False"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_IS, "IS"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_BETWEEN, "BETWEEN"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_OR, "OR"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_AND, "AND"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_AVG, "AVG"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_COUNT, "COUNT"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_MAX, "MAX"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_MIN, "MIN"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_SUM, "SUM"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_EVERY, "EVERY"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_ANY, "ANY"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_SOME, "SOME"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_STDDEV_POP, "STDDEV_POP"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_STDDEV_SAMP, "STDDEV_SAMP"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_VAR_SAMP, "VAR_SAMP"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_VAR_POP, "VAR_POP"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_COLLECT, "COLLECT"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_FUSION, "FUSION"); |
| IMPLEMENT_CONSTASCII_STRING(KEY_STR_INTERSECTION, "INTERSECTION"); |
| |
| IMPLEMENT_CONSTASCII_STRING(FIELD_STR_NULLDATE, "NullDate"); |
| |
| IMPLEMENT_CONSTASCII_STRING(STR_SQL_TOKEN, "SQL_TOKEN_"); |
| |
| //========================================================================== |
| //= OParseContext |
| //========================================================================== |
| //----------------------------------------------------------------------------- |
| OParseContext::OParseContext() |
| { |
| } |
| |
| //----------------------------------------------------------------------------- |
| OParseContext::~OParseContext() |
| { |
| } |
| |
| //----------------------------------------------------------------------------- |
| ::rtl::OUString OParseContext::getErrorMessage(ErrorCode _eCode) const |
| { |
| ::rtl::OUString aMsg; |
| switch (_eCode) |
| { |
| case ERROR_GENERAL: aMsg = ERROR_STR_GENERAL; break; |
| case ERROR_VALUE_NO_LIKE: aMsg = ERROR_STR_VALUE_NO_LIKE; break; |
| case ERROR_FIELD_NO_LIKE: aMsg = ERROR_STR_FIELD_NO_LIKE; break; |
| case ERROR_INVALID_COMPARE: aMsg = ERROR_STR_INVALID_COMPARE; break; |
| case ERROR_INVALID_INT_COMPARE: aMsg = ERROR_STR_INVALID_INT_COMPARE; break; |
| case ERROR_INVALID_DATE_COMPARE: aMsg = ERROR_STR_INVALID_DATE_COMPARE; break; |
| case ERROR_INVALID_REAL_COMPARE: aMsg = ERROR_STR_INVALID_REAL_COMPARE; break; |
| case ERROR_INVALID_TABLE: aMsg = ERROR_STR_INVALID_TABLE; break; |
| case ERROR_INVALID_TABLE_OR_QUERY: aMsg = ERROR_STR_INVALID_TABLE_OR_QUERY; break; |
| case ERROR_INVALID_COLUMN: aMsg = ERROR_STR_INVALID_COLUMN; break; |
| case ERROR_INVALID_TABLE_EXIST: aMsg = ERROR_STR_INVALID_TABLE_EXIST; break; |
| case ERROR_INVALID_QUERY_EXIST: aMsg = ERROR_STR_INVALID_QUERY_EXIST; break; |
| default: |
| OSL_ENSURE( false, "OParseContext::getErrorMessage: unknown error code!" ); |
| break; |
| } |
| return aMsg; |
| } |
| |
| //----------------------------------------------------------------------------- |
| ::rtl::OString OParseContext::getIntlKeywordAscii(InternationalKeyCode _eKey) const |
| { |
| ::rtl::OString aKeyword; |
| switch (_eKey) |
| { |
| case KEY_LIKE: aKeyword = KEY_STR_LIKE; break; |
| case KEY_NOT: aKeyword = KEY_STR_NOT; break; |
| case KEY_NULL: aKeyword = KEY_STR_NULL; break; |
| case KEY_TRUE: aKeyword = KEY_STR_TRUE; break; |
| case KEY_FALSE: aKeyword = KEY_STR_FALSE; break; |
| case KEY_IS: aKeyword = KEY_STR_IS; break; |
| case KEY_BETWEEN: aKeyword = KEY_STR_BETWEEN; break; |
| case KEY_OR: aKeyword = KEY_STR_OR; break; |
| case KEY_AND: aKeyword = KEY_STR_AND; break; |
| case KEY_AVG: aKeyword = KEY_STR_AVG; break; |
| case KEY_COUNT: aKeyword = KEY_STR_COUNT; break; |
| case KEY_MAX: aKeyword = KEY_STR_MAX; break; |
| case KEY_MIN: aKeyword = KEY_STR_MIN; break; |
| case KEY_SUM: aKeyword = KEY_STR_SUM; break; |
| case KEY_EVERY: aKeyword = KEY_STR_EVERY; break; |
| case KEY_ANY: aKeyword = KEY_STR_ANY; break; |
| case KEY_SOME: aKeyword = KEY_STR_SOME; break; |
| case KEY_STDDEV_POP: aKeyword = KEY_STR_STDDEV_POP; break; |
| case KEY_STDDEV_SAMP: aKeyword = KEY_STR_STDDEV_SAMP; break; |
| case KEY_VAR_SAMP: aKeyword = KEY_STR_VAR_SAMP; break; |
| case KEY_VAR_POP: aKeyword = KEY_STR_VAR_POP; break; |
| case KEY_COLLECT: aKeyword = KEY_STR_COLLECT; break; |
| case KEY_FUSION: aKeyword = KEY_STR_FUSION; break; |
| case KEY_INTERSECTION:aKeyword = KEY_STR_INTERSECTION; break; |
| case KEY_NONE: break; |
| default: |
| OSL_ENSURE( false, "OParseContext::getIntlKeywordAscii: unknown key!" ); |
| break; |
| } |
| return aKeyword; |
| } |
| |
| //----------------------------------------------------------------------------- |
| IParseContext::InternationalKeyCode OParseContext::getIntlKeyCode(const ::rtl::OString& rToken) const |
| { |
| static IParseContext::InternationalKeyCode Intl_TokenID[] = |
| { |
| KEY_LIKE, KEY_NOT, KEY_NULL, KEY_TRUE, |
| KEY_FALSE, KEY_IS, KEY_BETWEEN, KEY_OR, |
| KEY_AND, KEY_AVG, KEY_COUNT, KEY_MAX, |
| KEY_MIN, KEY_SUM, KEY_EVERY,KEY_ANY,KEY_SOME, |
| KEY_STDDEV_POP,KEY_STDDEV_SAMP,KEY_VAR_SAMP, |
| KEY_VAR_POP,KEY_COLLECT,KEY_FUSION,KEY_INTERSECTION |
| }; |
| |
| sal_uInt32 nCount = sizeof Intl_TokenID / sizeof Intl_TokenID[0]; |
| for (sal_uInt32 i = 0; i < nCount; i++) |
| { |
| ::rtl::OString aKey = getIntlKeywordAscii(Intl_TokenID[i]); |
| if (rToken.equalsIgnoreAsciiCase(aKey)) |
| return Intl_TokenID[i]; |
| } |
| |
| return KEY_NONE; |
| } |
| |
| //------------------------------------------------------------------------------ |
| static Locale& impl_getLocaleInstance( ) |
| { |
| static Locale s_aLocale( |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "en" ) ), |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "US" ) ), |
| ::rtl::OUString( ) |
| ); |
| return s_aLocale; |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OParseContext::setDefaultLocale( const ::com::sun::star::lang::Locale& _rLocale ) |
| { |
| impl_getLocaleInstance() = _rLocale; |
| } |
| |
| //------------------------------------------------------------------------------ |
| Locale OParseContext::getPreferredLocale( ) const |
| { |
| return getDefaultLocale(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| const Locale& OParseContext::getDefaultLocale() |
| { |
| return impl_getLocaleInstance(); |
| } |
| |
| //========================================================================== |
| //= misc |
| //========================================================================== |
| // Der (leider globale) yylval fuer die Uebergabe von |
| // Werten vom Scanner an den Parser. Die globale Variable |
| // wird nur kurzzeitig verwendet, der Parser liest die Variable |
| // sofort nach dem Scanner-Aufruf in eine gleichnamige eigene |
| // Member-Variable. |
| |
| const double fMilliSecondsPerDay = 86400000.0; |
| |
| //------------------------------------------------------------------------------ |
| |
| |
| //------------------------------------------------------------------ |
| ::rtl::OUString ConvertLikeToken(const OSQLParseNode* pTokenNode, const OSQLParseNode* pEscapeNode, sal_Bool bInternational) |
| { |
| ::rtl::OUStringBuffer aMatchStr; |
| if (pTokenNode->isToken()) |
| { |
| sal_Unicode cEscape = 0; |
| if (pEscapeNode->count()) |
| cEscape = pEscapeNode->getChild(1)->getTokenValue().toChar(); |
| |
| // Platzhalter austauschen |
| aMatchStr = pTokenNode->getTokenValue(); |
| const sal_Int32 nLen = aMatchStr.getLength(); |
| ::rtl::OUStringBuffer sSearch,sReplace; |
| if ( bInternational ) |
| { |
| sSearch.appendAscii("%_",2); |
| sReplace.appendAscii("*?",2); |
| } |
| else |
| { |
| sSearch.appendAscii("*?",2); |
| sReplace.appendAscii("%_",2); |
| } |
| |
| for (sal_Int32 i = 0; i < nLen; i++) |
| { |
| const sal_Unicode c = aMatchStr.charAt(i); |
| if (c == sSearch.charAt(0) || c == sSearch.charAt(1)) |
| { |
| if (i > 0 && aMatchStr.charAt(i-1) == cEscape) |
| continue; |
| else |
| { |
| const sal_Unicode cCharacter = sReplace.charAt( (c == sSearch.charAt(0)) ? 0 : 1); |
| aMatchStr.setCharAt(i , cCharacter); |
| } |
| } |
| } |
| } |
| return aMatchStr.makeStringAndClear(); |
| } |
| |
| //========================================================================== |
| //= OSQLParser |
| //========================================================================== |
| |
| sal_uInt32 OSQLParser::s_nRuleIDs[OSQLParseNode::rule_count + 1]; |
| OSQLParser::RuleIDMap OSQLParser::s_aReverseRuleIDLookup; |
| OParseContext OSQLParser::s_aDefaultContext; |
| |
| sal_Int32 OSQLParser::s_nRefCount = 0; |
| // ::osl::Mutex OSQLParser::s_aMutex; |
| OSQLScanner* OSQLParser::s_pScanner = 0; |
| OSQLParseNodesGarbageCollector* OSQLParser::s_pGarbageCollector = 0; |
| ::com::sun::star::uno::Reference< ::com::sun::star::i18n::XLocaleData> OSQLParser::s_xLocaleData = NULL; |
| //----------------------------------------------------------------------------- |
| void setParser(OSQLParser* _pParser) |
| { |
| xxx_pGLOBAL_SQLPARSER = _pParser; |
| } |
| // ------------------------------------------------------------------------- |
| void OSQLParser::setParseTree(OSQLParseNode * pNewParseTree) |
| { |
| ::osl::MutexGuard aGuard(getMutex()); |
| m_pParseTree = pNewParseTree; |
| } |
| //----------------------------------------------------------------------------- |
| OSQLParseNode* OSQLParser::parseTree(::rtl::OUString& rErrorMessage, |
| const ::rtl::OUString& rStatement, |
| sal_Bool bInternational) |
| { |
| |
| |
| // Guard the parsing |
| ::osl::MutexGuard aGuard(getMutex()); |
| // must be reset |
| setParser(this); |
| |
| // defines how to scan |
| s_pScanner->SetRule(s_pScanner->GetSQLRule()); // initial |
| s_pScanner->prepareScan(rStatement, m_pContext, bInternational); |
| |
| SQLyylval.pParseNode = NULL; |
| // SQLyypvt = NULL; |
| m_pParseTree = NULL; |
| m_sErrorMessage = ::rtl::OUString(); |
| |
| // ... und den Parser anwerfen ... |
| if (SQLyyparse() != 0) |
| { |
| // only set the error message, if it's not already set |
| if (!m_sErrorMessage.getLength()) |
| m_sErrorMessage = s_pScanner->getErrorMessage(); |
| if (!m_sErrorMessage.getLength()) |
| m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_GENERAL); |
| |
| rErrorMessage = m_sErrorMessage; |
| |
| // clear the garbage collector |
| (*s_pGarbageCollector)->clearAndDelete(); |
| return NULL; |
| } |
| else |
| { |
| (*s_pGarbageCollector)->clear(); |
| |
| // Das Ergebnis liefern (den Root Parse Node): |
| |
| // OSL_ENSURE(Sdbyyval.pParseNode != NULL,"OSQLParser: Parser hat keinen ParseNode geliefert"); |
| // return Sdbyyval.pParseNode; |
| // geht nicht wegen Bug in MKS YACC-erzeugtem Code (es wird ein falscher ParseNode |
| // geliefert). |
| |
| // Stattdessen setzt die Parse-Routine jetzt den Member pParseTree |
| // - einfach diesen zurueckliefern: |
| OSL_ENSURE(m_pParseTree != NULL,"OSQLParser: Parser hat keinen ParseTree geliefert"); |
| return m_pParseTree; |
| } |
| } |
| //----------------------------------------------------------------------------- |
| ::rtl::OString OSQLParser::TokenIDToStr(sal_uInt32 nTokenID, const IParseContext* pContext) |
| { |
| ::rtl::OString aStr; |
| if (pContext) |
| { |
| IParseContext::InternationalKeyCode eKeyCode = IParseContext::KEY_NONE; |
| switch( nTokenID ) |
| { |
| case SQL_TOKEN_LIKE: eKeyCode = IParseContext::KEY_LIKE; break; |
| case SQL_TOKEN_NOT: eKeyCode = IParseContext::KEY_NOT; break; |
| case SQL_TOKEN_NULL: eKeyCode = IParseContext::KEY_NULL; break; |
| case SQL_TOKEN_TRUE: eKeyCode = IParseContext::KEY_TRUE; break; |
| case SQL_TOKEN_FALSE: eKeyCode = IParseContext::KEY_FALSE; break; |
| case SQL_TOKEN_IS: eKeyCode = IParseContext::KEY_IS; break; |
| case SQL_TOKEN_BETWEEN: eKeyCode = IParseContext::KEY_BETWEEN; break; |
| case SQL_TOKEN_OR: eKeyCode = IParseContext::KEY_OR; break; |
| case SQL_TOKEN_AND: eKeyCode = IParseContext::KEY_AND; break; |
| case SQL_TOKEN_AVG: eKeyCode = IParseContext::KEY_AVG; break; |
| case SQL_TOKEN_COUNT: eKeyCode = IParseContext::KEY_COUNT; break; |
| case SQL_TOKEN_MAX: eKeyCode = IParseContext::KEY_MAX; break; |
| case SQL_TOKEN_MIN: eKeyCode = IParseContext::KEY_MIN; break; |
| case SQL_TOKEN_SUM: eKeyCode = IParseContext::KEY_SUM; break; |
| } |
| if ( eKeyCode != IParseContext::KEY_NONE ) |
| aStr = pContext->getIntlKeywordAscii(eKeyCode); |
| } |
| |
| if (!aStr.getLength()) |
| { |
| aStr = yytname[YYTRANSLATE(nTokenID)]; |
| if(!aStr.compareTo("SQL_TOKEN_",10)) |
| aStr = aStr.copy(10); |
| } |
| return aStr; |
| } |
| |
| //----------------------------------------------------------------------------- |
| ::rtl::OUString OSQLParser::RuleIDToStr(sal_uInt32 nRuleID) |
| { |
| OSL_ENSURE(nRuleID < (sizeof yytname/sizeof yytname[0]), "OSQLParser::RuleIDToStr: Invalid nRuleId!"); |
| return ::rtl::OUString::createFromAscii(yytname[nRuleID]); |
| } |
| |
| //----------------------------------------------------------------------------- |
| sal_uInt32 OSQLParser::StrToRuleID(const ::rtl::OString & rValue) |
| { |
| // In yysvar nach dem angegebenen Namen suchen, den Index zurueckliefern |
| // (oder 0, wenn nicht gefunden) |
| static sal_uInt32 nLen = sizeof(yytname)/sizeof(yytname[0]); |
| for (sal_uInt32 i = YYTRANSLATE(SQL_TOKEN_INVALIDSYMBOL); i < (nLen-1); i++) |
| { |
| if (yytname && rValue == yytname[i]) |
| return i; |
| } |
| |
| // Nicht gefunden |
| return 0; |
| } |
| |
| //----------------------------------------------------------------------------- |
| OSQLParseNode::Rule OSQLParser::RuleIDToRule( sal_uInt32 _nRule ) |
| { |
| return s_aReverseRuleIDLookup[ _nRule ]; |
| } |
| |
| //----------------------------------------------------------------------------- |
| sal_uInt32 OSQLParser::RuleID(OSQLParseNode::Rule eRule) |
| { |
| return s_nRuleIDs[(sal_uInt16)eRule]; |
| } |
| // ------------------------------------------------------------------------- |
| sal_Int16 OSQLParser::buildNode(OSQLParseNode*& pAppend,OSQLParseNode* pCompare,OSQLParseNode* pLiteral,OSQLParseNode* pLiteral2) |
| { |
| OSQLParseNode* pColumnRef = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref)); |
| pColumnRef->append(new OSQLInternalNode(m_sFieldName,SQL_NODE_NAME)); |
| OSQLParseNode* pComp = NULL; |
| if ( SQL_ISTOKEN( pCompare, BETWEEN) && pLiteral2 ) |
| pComp = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::between_predicate_part_2)); |
| else |
| pComp = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::comparison_predicate)); |
| |
| pComp->append(pColumnRef); |
| pComp->append(pCompare); |
| pComp->append(pLiteral); |
| if ( pLiteral2 ) |
| { |
| pComp->append(new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD,SQL_TOKEN_AND)); |
| pComp->append(pLiteral2); |
| } |
| pAppend->append(pComp); |
| return 1; |
| } |
| //----------------------------------------------------------------------------- |
| sal_Int16 OSQLParser::buildStringNodes(OSQLParseNode*& pLiteral) |
| { |
| if(!pLiteral) |
| return 1; |
| |
| if(SQL_ISRULE(pLiteral,set_fct_spec) || SQL_ISRULE(pLiteral,general_set_fct) || SQL_ISRULE(pLiteral,column_ref) |
| || SQL_ISRULE(pLiteral,subquery)) |
| return 1; // here I have a function that I can't transform into a string |
| |
| if(pLiteral->getNodeType() == SQL_NODE_INTNUM || pLiteral->getNodeType() == SQL_NODE_APPROXNUM || pLiteral->getNodeType() == SQL_NODE_ACCESS_DATE) |
| { |
| OSQLParseNode* pParent = pLiteral->getParent(); |
| |
| OSQLParseNode* pNewNode = new OSQLInternalNode(pLiteral->getTokenValue(), SQL_NODE_STRING); |
| pParent->replace(pLiteral, pNewNode); |
| delete pLiteral; |
| pLiteral = NULL; |
| return 1; |
| } |
| |
| for(sal_uInt32 i=0;i<pLiteral->count();++i) |
| { |
| OSQLParseNode* pChild = pLiteral->getChild(i); |
| buildStringNodes(pChild); |
| } |
| if(SQL_ISRULE(pLiteral,term) || SQL_ISRULE(pLiteral,value_exp_primary)) |
| { |
| m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_COMPARE); |
| return 0; |
| } |
| return 1; |
| } |
| //----------------------------------------------------------------------------- |
| sal_Int16 OSQLParser::buildComparsionRule(OSQLParseNode*& pAppend,OSQLParseNode* pLiteral) |
| { |
| OSQLParseNode* pComp = new OSQLInternalNode(::rtl::OUString::createFromAscii("="), SQL_NODE_EQUAL); |
| return buildPredicateRule(pAppend,pLiteral,pComp); |
| } |
| |
| |
| //----------------------------------------------------------------------------- |
| void OSQLParser::reduceLiteral(OSQLParseNode*& pLiteral, sal_Bool bAppendBlank) |
| { |
| OSL_ENSURE(pLiteral->isRule(), "This is no ::com::sun::star::chaos::Rule"); |
| OSL_ENSURE(pLiteral->count() == 2, "OSQLParser::ReduceLiteral() Invalid count"); |
| OSQLParseNode* pTemp = pLiteral; |
| ::rtl::OUStringBuffer aValue(pLiteral->getChild(0)->getTokenValue()); |
| if (bAppendBlank) |
| { |
| aValue.appendAscii(" "); |
| } |
| |
| aValue.append(pLiteral->getChild(1)->getTokenValue()); |
| |
| pLiteral = new OSQLInternalNode(aValue.makeStringAndClear(),SQL_NODE_STRING); |
| delete pTemp; |
| } |
| |
| // ------------------------------------------------------------------------- |
| void OSQLParser::error( const sal_Char* fmt) |
| { |
| if(!m_sErrorMessage.getLength()) |
| { |
| ::rtl::OUString sStr(fmt,strlen(fmt),RTL_TEXTENCODING_UTF8); |
| ::rtl::OUString sSQL_TOKEN(::rtl::OUString::createFromAscii("SQL_TOKEN_")); |
| |
| sal_Int32 nPos1 = sStr.indexOf(sSQL_TOKEN); |
| if(nPos1 != -1) |
| { |
| ::rtl::OUString sFirst = sStr.copy(0,nPos1); |
| sal_Int32 nPos2 = sStr.indexOf(sSQL_TOKEN,nPos1+1); |
| if(nPos2 != -1) |
| { |
| ::rtl::OUString sSecond = sStr.copy(nPos1+sSQL_TOKEN.getLength(),nPos2-nPos1-sSQL_TOKEN.getLength()); |
| sFirst += sSecond; |
| sFirst += sStr.copy(nPos2+sSQL_TOKEN.getLength()); |
| } |
| else |
| sFirst += sStr.copy(nPos1+sSQL_TOKEN.getLength()); |
| |
| m_sErrorMessage = sFirst; |
| } |
| else |
| m_sErrorMessage = sStr; |
| |
| ::rtl::OUString aError = s_pScanner->getErrorMessage(); |
| if(aError.getLength()) |
| { |
| m_sErrorMessage += ::rtl::OUString::createFromAscii(", "); |
| m_sErrorMessage += aError; |
| } |
| } |
| } |
| // ------------------------------------------------------------------------- |
| int OSQLParser::SQLlex() |
| { |
| return s_pScanner->SQLlex(); |
| } |
| |
| #if defined __SUNPRO_CC |
| #pragma enable_warn |
| #elif defined _MSC_VER |
| #pragma warning(pop) |
| #endif |
