bc0a497f08
The SQL parser implementation does not handle comments.
Temporarily remove "-- ..." and "// ..." end-of-line comments and "/* ... */"
inline comments of a query and append comments after recomposition of the
query.
NOTE: The original comment positions are not preserved, all comments are
appended to the query!
Based on the original patch further development was done for inline comments
and preserving comments' line order.
4887 lines
120 KiB
Plaintext
Executable File
4887 lines
120 KiB
Plaintext
Executable File
%{
|
|
//--------------------------------------------------------------------------
|
|
//
|
|
// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
//
|
|
// Copyright 2000, 2010 Oracle and/or its affiliates.
|
|
//
|
|
// OpenOffice.org - a multi-platform office productivity suite
|
|
//
|
|
// This file is part of OpenOffice.org.
|
|
//
|
|
// OpenOffice.org is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License version 3
|
|
// only, as published by the Free Software Foundation.
|
|
//
|
|
// OpenOffice.org is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License version 3 for more details
|
|
// (a copy is included in the LICENSE file that accompanied this code).
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// version 3 along with OpenOffice.org. If not, see
|
|
// <http://www.openoffice.org/license.html>
|
|
// for a copy of the LGPLv3 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>
|
|
#include <sal/macros.h>
|
|
|
|
#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;
|
|
|
|
//============================================================
|
|
//= 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 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_FAIL( "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_FAIL( "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 = SAL_N_ELEMENTS( Intl_TokenID );
|
|
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;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
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;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/** Delete all comments in a query.
|
|
|
|
See also getComment()/concatComment() implementation for
|
|
OQueryController::translateStatement().
|
|
*/
|
|
static ::rtl::OUString delComment( const ::rtl::OUString& rQuery )
|
|
{
|
|
// First a quick search if there is any "--" or "//" or "/*", if not then the whole
|
|
// copying loop is pointless.
|
|
if (rQuery.indexOfAsciiL( "--", 2, 0) < 0 && rQuery.indexOfAsciiL( "//", 2, 0) < 0 &&
|
|
rQuery.indexOfAsciiL( "/*", 2, 0) < 0)
|
|
return rQuery;
|
|
|
|
const sal_Unicode* pCopy = rQuery.getStr();
|
|
sal_Int32 nQueryLen = rQuery.getLength();
|
|
bool bIsText1 = false; // "text"
|
|
bool bIsText2 = false; // 'text'
|
|
bool bComment2 = false; // /* comment */
|
|
bool bComment = false; // -- or // comment
|
|
::rtl::OUStringBuffer aBuf(nQueryLen);
|
|
for (size_t i=0; i < nQueryLen; ++i)
|
|
{
|
|
if (bComment2)
|
|
{
|
|
if ((i+1) < nQueryLen)
|
|
{
|
|
if (pCopy[i]=='*' && pCopy[i+1]=='/')
|
|
{
|
|
bComment2 = false;
|
|
++i;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// comment can't close anymore, actually an error, but..
|
|
}
|
|
continue;
|
|
}
|
|
if (pCopy[i] == '\n')
|
|
bComment = false;
|
|
else if (!bComment)
|
|
{
|
|
if (pCopy[i] == '\"' && !bIsText2)
|
|
bIsText1 = !bIsText1;
|
|
else if (pCopy[i] == '\'' && !bIsText1)
|
|
bIsText2 = !bIsText2;
|
|
if (!bIsText1 && !bIsText2 && (i+1) < nQueryLen)
|
|
{
|
|
if ((pCopy[i]=='-' && pCopy[i+1]=='-') || (pCopy[i]=='/' && pCopy[i+1]=='/'))
|
|
bComment = true;
|
|
else if ((pCopy[i]=='/' && pCopy[i+1]=='*'))
|
|
bComment2 = true;
|
|
}
|
|
}
|
|
if (!bComment && !bComment2)
|
|
aBuf.append( &pCopy[i], 1);
|
|
}
|
|
return aBuf.makeStringAndClear();
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
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);
|
|
|
|
// delete comments before parsing
|
|
::rtl::OUString sTemp = delComment(rStatement);
|
|
|
|
// defines how to scan
|
|
s_pScanner->SetRule(s_pScanner->GetSQLRule()); // initial
|
|
s_pScanner->prepareScan(sTemp, 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 < SAL_N_ELEMENTS(yytname), "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 = SAL_N_ELEMENTS(yytname);
|
|
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(RTL_CONSTASCII_USTRINGPARAM("=")), 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_CONSTASCII_USTRINGPARAM("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(RTL_CONSTASCII_USTRINGPARAM(", "));
|
|
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
|