?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 4.1.6.2
[LibreOffice.git] / connectivity / source / parse / sqlbison.y
blobc2b02ce32cae1ea5399dbe7b39e1cd51532e8c6e
1 %token-table
2 %{
3 /*
4 * This file is part of the LibreOffice project.
5 *
6 * This Source Code Form is subject to the terms of the Mozilla Public
7 * License, v. 2.0. If a copy of the MPL was not distributed with this
8 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 *
10 * This file incorporates work covered by the following license notice:
11 *
12 * Licensed to the Apache Software Foundation (ASF) under one or more
13 * contributor license agreements. See the NOTICE file distributed
14 * with this work for additional information regarding copyright
15 * ownership. The ASF licenses this file to you under the Apache
16 * License, Version 2.0 (the "License"); you may not use this file
17 * except in compliance with the License. You may obtain a copy of
18 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
19 */
20
21 #include <vector>
22 #include <string.h>
23 #include "parse/sqlbison_exports.hxx"
24
25 #include <connectivity/sqlnode.hxx>
26 #include <connectivity/sqlparse.hxx>
27 #include <internalnode.hxx>
28 #include <com/sun/star/lang/Locale.hpp>
29 #include <com/sun/star/sdbc/DataType.hpp>
30 #include <com/sun/star/util/Date.hpp>
31 #include <com/sun/star/util/DateTime.hpp>
32 #include <com/sun/star/util/Time.hpp>
33 #include <com/sun/star/util/XNumberFormatter.hpp>
34 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
35 #include <com/sun/star/util/XNumberFormats.hpp>
36 #include <com/sun/star/util/NumberFormat.hpp>
37 #include <com/sun/star/util/XNumberFormatTypes.hpp>
38 #include <com/sun/star/beans/XPropertySet.hpp>
39 #include <com/sun/star/i18n/KParseType.hpp>
40 #include <com/sun/star/i18n/KParseTokens.hpp>
41
42 #include "sqlscan.hxx"
43 #include <osl/diagnose.h>
44 #include "connectivity/dbconversion.hxx"
45 #include <rtl/ustrbuf.hxx>
46 #include <sal/macros.h>
47
48 #if defined __SUNPRO_CC
49 #pragma disable_warn
50 #elif defined _MSC_VER
51 #pragma warning(push, 1)
52 #pragma warning(disable:4273 4701 4706)
53 #endif
54
55 static ::rtl::OUString aEmptyString;
56
57 static connectivity::OSQLInternalNode* newNode(const sal_Char* pNewValue,
58 const connectivity::SQLNodeType eNodeType,
59 const sal_uInt32 nNodeID = 0)
60 {
61 return new connectivity::OSQLInternalNode(pNewValue, eNodeType, nNodeID);
62 }
63
64 static connectivity::OSQLInternalNode* newNode(const ::rtl::OString& _NewValue,
65 const connectivity::SQLNodeType eNodeType,
66 const sal_uInt32 nNodeID = 0)
67 {
68 return new connectivity::OSQLInternalNode(_NewValue, eNodeType, nNodeID);
69 }
70
71 static connectivity::OSQLInternalNode* newNode(const ::rtl::OUString& _NewValue,
72 const connectivity::SQLNodeType eNodeType,
73 const sal_uInt32 nNodeID = 0)
74 {
75 return new connectivity::OSQLInternalNode(_NewValue, eNodeType, nNodeID);
76 }
77
78
79 // yyi ist die interne Nr. der Regel, die gerade reduziert wird.
80 // Ueber die Mapping-Tabelle yyrmap wird daraus eine externe Regel-Nr.
81 #define SQL_NEW_RULE newNode(aEmptyString, SQL_NODE_RULE, yyr1[yyn])
82 #define SQL_NEW_LISTRULE newNode(aEmptyString, SQL_NODE_LISTRULE, yyr1[yyn])
83 #define SQL_NEW_COMMALISTRULE newNode(aEmptyString, SQL_NODE_COMMALISTRULE, yyr1[yyn])
84
85
86 connectivity::OSQLParser* xxx_pGLOBAL_SQLPARSER;
87
88 #if !(defined MACOSX && defined PPC)
89 #define YYERROR_VERBOSE
90 #endif
91
92 #define SQLyyerror(s) \
93 { \
94 xxx_pGLOBAL_SQLPARSER->error(s); \
95 }
96
97 using namespace connectivity;
98 #define SQLyylex xxx_pGLOBAL_SQLPARSER->SQLlex
99 %}
100 /* symbolic tokens */
101
102 %union {
103 connectivity::OSQLParseNode * pParseNode;
104 }
105 %type <pParseNode> '(' ')' ',' ':' ';' '?' '[' ']' '{' '}' '.' 'K' 'M' 'G' 'T' 'P'
106
107 %token <pParseNode> SQL_TOKEN_STRING SQL_TOKEN_ACCESS_DATE SQL_TOKEN_INT SQL_TOKEN_REAL_NUM
108 %token <pParseNode> SQL_TOKEN_INTNUM SQL_TOKEN_APPROXNUM SQL_TOKEN_NOT SQL_TOKEN_NAME
109
110
111 %nonassoc <pParseNode> SQL_TOKEN_UMINUS
112
113
114
115 /* literal keyword tokens */
116
117 %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
118
119 %token <pParseNode> SQL_TOKEN_BETWEEN SQL_TOKEN_BIT SQL_TOKEN_BOTH SQL_TOKEN_BY
120
121 %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
122 %token <pParseNode> SQL_TOKEN_CURRENT SQL_TOKEN_CURSOR
123
124 %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
125 %token <pParseNode> SQL_TOKEN_DISTINCT SQL_TOKEN_DOUBLE SQL_TOKEN_DROP
126
127 %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
128
129 %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
130
131 %token <pParseNode> SQL_TOKEN_JOIN SQL_TOKEN_KEY SQL_TOKEN_LEADING SQL_TOKEN_LIKE SQL_TOKEN_LOCAL SQL_TOKEN_LOWER
132 %token <pParseNode> SQL_TOKEN_MAX SQL_TOKEN_MIN SQL_TOKEN_NATURAL SQL_TOKEN_NCHAR SQL_TOKEN_NULL SQL_TOKEN_NUMERIC
133
134 %token <pParseNode> SQL_TOKEN_OCTET_LENGTH SQL_TOKEN_OF SQL_TOKEN_ON SQL_TOKEN_OPTION SQL_TOKEN_ORDER SQL_TOKEN_OUTER
135
136 %token <pParseNode> SQL_TOKEN_PRECISION SQL_TOKEN_PRIMARY SQL_TOKEN_PRIVILEGES SQL_TOKEN_PROCEDURE SQL_TOKEN_PUBLIC
137 %token <pParseNode> SQL_TOKEN_REAL SQL_TOKEN_REFERENCES SQL_TOKEN_ROLLBACK
138
139 %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
140
141 %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
142 %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
143 %token <pParseNode> SQL_TOKEN_WHERE SQL_TOKEN_WITH SQL_TOKEN_WORK SQL_TOKEN_ZONE
144
145 /* ODBC KEYWORDS */
146 %token <pParseNode> SQL_TOKEN_CALL SQL_TOKEN_D SQL_TOKEN_FN SQL_TOKEN_T SQL_TOKEN_TS SQL_TOKEN_OJ
147 /* string functions */
148 %token <pParseNode> SQL_TOKEN_ASCII SQL_TOKEN_BIT_LENGTH SQL_TOKEN_CHAR SQL_TOKEN_CHAR_LENGTH SQL_TOKEN_SQL_TOKEN_INTNUM
149 %token <pParseNode> SQL_TOKEN_CONCAT
150 %token <pParseNode> SQL_TOKEN_DIFFERENCE SQL_TOKEN_INSERT SQL_TOKEN_LCASE SQL_TOKEN_LEFT SQL_TOKEN_LENGTH SQL_TOKEN_LOCATE
151 %token <pParseNode> SQL_TOKEN_LOCATE_2 SQL_TOKEN_LTRIM SQL_TOKEN_POSITION SQL_TOKEN_REPEAT SQL_TOKEN_REPLACE
152 %token <pParseNode> SQL_TOKEN_RIGHT SQL_TOKEN_RTRIM SQL_TOKEN_SOUNDEX SQL_TOKEN_SPACE SQL_TOKEN_SUBSTRING SQL_TOKEN_UCASE
153
154 /* time and date functions */
155 %token <pParseNode> SQL_TOKEN_CURRENT_DATE SQL_TOKEN_CURRENT_TIME SQL_TOKEN_CURRENT_TIMESTAMP SQL_TOKEN_CURDATE SQL_TOKEN_CURTIME
156 %token <pParseNode> SQL_TOKEN_DAYNAME SQL_TOKEN_DAYOFMONTH SQL_TOKEN_DAYOFWEEK SQL_TOKEN_DAYOFYEAR SQL_TOKEN_EXTRACT
157 %token <pParseNode> SQL_TOKEN_HOUR SQL_TOKEN_MINUTE SQL_TOKEN_MONTH SQL_TOKEN_MONTHNAME SQL_TOKEN_NOW SQL_TOKEN_QUARTER SQL_TOKEN_DATEDIFF
158 %token <pParseNode> SQL_TOKEN_SECOND SQL_TOKEN_TIMESTAMPADD SQL_TOKEN_TIMESTAMPDIFF SQL_TOKEN_TIMEVALUE SQL_TOKEN_WEEK SQL_TOKEN_YEAR
159
160 /* numeric functions */
161 %token <pParseNode> SQL_TOKEN_ABS SQL_TOKEN_ACOS SQL_TOKEN_ASIN SQL_TOKEN_ATAN SQL_TOKEN_ATAN2 SQL_TOKEN_CEILING
162 %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
163 %token <pParseNode> SQL_TOKEN_LOG10 SQL_TOKEN_MOD SQL_TOKEN_PI SQL_TOKEN_POWER SQL_TOKEN_RADIANS SQL_TOKEN_RAND SQL_TOKEN_ROUNDMAGIC
164 %token <pParseNode> SQL_TOKEN_ROUND SQL_TOKEN_SIGN SQL_TOKEN_SIN SQL_TOKEN_SQRT SQL_TOKEN_TAN SQL_TOKEN_TRUNCATE
165
166 // computational operation
167 %token <pParseNode> SQL_TOKEN_EVERY SQL_TOKEN_INTERSECTION SQL_TOKEN_FUSION SQL_TOKEN_COLLECT SQL_TOKEN_VAR_POP SQL_TOKEN_VAR_SAMP
168 %token <pParseNode> SQL_TOKEN_STDDEV_SAMP SQL_TOKEN_STDDEV_POP
169
170 %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
171 %token <pParseNode> SQL_TOKEN_CASE SQL_TOKEN_THEN SQL_TOKEN_END SQL_TOKEN_NULLIF SQL_TOKEN_COALESCE SQL_TOKEN_WHEN SQL_TOKEN_ELSE
172 %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
173 %token <pParseNode> SQL_TOKEN_NEW SQL_TOKEN_OLD
174 %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
175 %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
176 %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
177 // window function
178 %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
179 %token <pParseNode> SQL_TOKEN_FIRST_VALUE SQL_TOKEN_LAST_VALUE SQL_TOKEN_NTH_VALUE SQL_TOKEN_FIRST SQL_TOKEN_LAST
180 %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
181 %token <pParseNode> SQL_TOKEN_PARTITION SQL_TOKEN_WINDOW SQL_TOKEN_NO
182 // LIMIT and OFFSEt
183 %token <pParseNode> SQL_TOKEN_LIMIT SQL_TOKEN_OFFSET SQL_TOKEN_NEXT SQL_TOKEN_ONLY
184
185 /* operators */
186 %left SQL_TOKEN_NAME
187 %left <pParseNode> SQL_TOKEN_OR
188 %left <pParseNode> SQL_TOKEN_AND
189
190 %left <pParseNode> SQL_LESSEQ SQL_GREATEQ SQL_NOTEQUAL SQL_LESS SQL_GREAT SQL_EQUAL /* '<' '>' = <> < > <= >= != */
191 %left <pParseNode> '+' '-' SQL_CONCAT
192 %left <pParseNode> '*' '/'
193 %left SQL_TOKEN_NATURAL SQL_TOKEN_CROSS SQL_TOKEN_FULL SQL_TOKEN_LEFT SQL_TOKEN_RIGHT
194 %left ')'
195 %right '='
196 %right '.'
197 %right '('
198
199
200 %token <pParseNode> SQL_TOKEN_INVALIDSYMBOL
201
202 /*%type <pParseNode> sql_single_statement */
203
204 %type <pParseNode> sql /*schema */
205 %type <pParseNode> column_def_opt_list column_def_opt table_constraint_def column_commalist
206 %type <pParseNode> view_def opt_with_check_option opt_column_commalist privilege_def
207 %type <pParseNode> opt_with_grant_option privileges operation_commalist operation
208 %type <pParseNode> grantee_commalist grantee opt_order_by_clause ordering_spec_commalist
209 %type <pParseNode> ordering_spec opt_asc_desc manipulative_statement commit_statement
210 %type <pParseNode> /*delete_statement_positioned*/ delete_statement_searched fetch_statement
211 %type <pParseNode> insert_statement values_or_query_spec
212 %type <pParseNode> rollback_statement select_statement_into opt_all_distinct
213 %type <pParseNode> /*update_statement_positioned*/ assignment_commalist assignment
214 %type <pParseNode> update_statement_searched target_commalist target opt_where_clause
215 %type <pParseNode> select_statement selection table_exp from_clause table_ref_commalist table_ref
216 %type <pParseNode> where_clause opt_group_by_clause column_ref_commalist opt_having_clause
217 %type <pParseNode> search_condition predicate comparison_predicate comparison_predicate_part_2 between_predicate between_predicate_part_2
218 %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
219 %type <pParseNode> all_or_any_predicate any_all_some existence_test subquery quantified_comparison_predicate_part_2
220 %type <pParseNode> scalar_exp_commalist parameter_ref literal parenthesized_boolean_value_expression
221 %type <pParseNode> column_ref data_type column cursor parameter range_variable user /*like_check*/
222 /* neue Regeln bei OJ */
223 %type <pParseNode> derived_column as_clause table_name num_primary term num_value_exp
224 %type <pParseNode> value_exp_primary num_value_fct unsigned_value_spec cast_spec set_fct_spec scalar_subquery
225 %type <pParseNode> position_exp extract_exp length_exp general_value_spec
226 %type <pParseNode> general_set_fct set_fct_type query_exp non_join_query_exp joined_table
227 %type <pParseNode> non_join_query_term non_join_query_primary simple_table
228 %type <pParseNode> table_value_const_list row_value_constructor row_value_const_list row_value_constructor_elem
229 %type <pParseNode> qualified_join value_exp query_term join_type outer_join_type join_condition boolean_term
230 %type <pParseNode> boolean_factor truth_value boolean_test boolean_primary named_columns_join join_spec
231 %type <pParseNode> cast_operand cast_target factor datetime_value_exp /*interval_value_exp*/ datetime_term datetime_factor
232 %type <pParseNode> datetime_primary datetime_value_fct time_zone time_zone_specifier /*interval_term*/ interval_qualifier
233 %type <pParseNode> start_field non_second_datetime_field end_field single_datetime_field extract_field datetime_field time_zone_field
234 %type <pParseNode> extract_source char_length_exp octet_length_exp bit_length_exp select_sublist string_value_exp
235 %type <pParseNode> char_value_exp concatenation char_factor char_primary string_value_fct char_substring_fct fold
236 %type <pParseNode> form_conversion char_translation trim_fct trim_operands trim_spec bit_value_fct bit_substring_fct op_column_commalist
237 %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
238 %type <pParseNode> function_arg_commalist3 string_function_3Argument function_arg_commalist4 string_function_4Argument function_arg_commalist2 string_function_1Argument string_function_2Argument
239 %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
240 %type <pParseNode> all query_primary sql_not for_length upper_lower comparison column_val cross_union /*opt_schema_element_list*/
241 %type <pParseNode> /*op_authorization op_schema*/ nil_fkt schema_element base_table_def base_table_element base_table_element_commalist
242 %type <pParseNode> column_def odbc_fct_spec odbc_call_spec odbc_fct_type op_parameter union_statement
243 %type <pParseNode> op_odbc_call_parameter odbc_parameter_commalist odbc_parameter function_args_commalist function_arg
244 %type <pParseNode> catalog_name schema_name table_node numeric_function string_function function_name date_function table_primary_as_range_column opt_as
245 %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
246 %type <pParseNode> case_expression else_clause result_expression result case_abbreviation case_specification searched_when_clause simple_when_clause searched_case simple_case
247 %type <pParseNode> when_operand_list when_operand case_operand
248 %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
249 %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
250 %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
251 %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
252 %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
253 %type <pParseNode> approximate_numeric_type exact_numeric_type opt_paren_precision_scale
254 /* window function rules */
255 %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
256 %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
257 %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
258 %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
259 %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
260 %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
261 %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
262 /* LIMIT and OFFSET */
263 %type <pParseNode> opt_limit_offset_clause limit_offset_clause opt_fetch_first_clause
264 %%
265
266 /* Parse Tree an OSQLParser zurueckliefern
267 * (der Zugriff ueber yyval nach Aufruf des Parsers scheitert,
268 *
269 */
270 sql_single_statement:
271 sql
272 { xxx_pGLOBAL_SQLPARSER->setParseTree( $1 ); }
273 | sql ';'
274 { xxx_pGLOBAL_SQLPARSER->setParseTree( $1 ); }
275 ;
276
277 /* schema definition language */
278 /* Note: other ``sql:sal_Unicode() rules appear later in the grammar */
279
280 sql:
281 manipulative_statement
282 | schema_element
283 {
284 $$ = SQL_NEW_RULE;
285 $$->append($1);
286 }
287 ;
288
289 /***
290
291 op_authorization:
292 {$$ = SQL_NEW_RULE;}
293 | SQL_TOKEN_AUTHORIZATION user
294 {
295 $$ = SQL_NEW_RULE;
296 $$->append($1);
297 $$->append($2);
298 }
299 ;
300 op_schema:
301 {$$ = SQL_NEW_RULE;}
302 | SQL_TOKEN_NAME
303 | SQL_TOKEN_NAME '.' SQL_TOKEN_NAME
304 {
305 $$ = SQL_NEW_RULE;
306 $$->append($1);
307 $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION));
308 $$->append($3);
309 }
310 ;
311
312 schema:
313 SQL_TOKEN_CREATE SQL_TOKEN_SCHEMA op_schema op_authorization opt_schema_element_list
314 {
315 $$ = SQL_NEW_RULE;
316 $$->append($1);
317 $$->append($2);
318 $$->append($3);
319 $$->append($4);
320 $$->append($5);
321 }
322 ;
323
324 opt_schema_element_list:
325 {$$ = SQL_NEW_RULE;}
326 | schema_glement_list
327 ;
328
329 schema_element_list:
330 schema_element
331 {$$ = SQL_NEW_LISTRULE;
332 $$->append($1);}
333 | schema_element_list schema_element
334 {$1->append($2);
335 $$ = $1;}
336 ;
337 */
338
339 schema_element:
340 base_table_def
341 | view_def
342 | privilege_def
343 | trigger_definition
344 ;
345
346 base_table_def:
347 SQL_TOKEN_CREATE SQL_TOKEN_TABLE table_node '(' base_table_element_commalist ')'
348 {$$ = SQL_NEW_RULE;
349 $$->append($1);
350 $$->append($2);
351 $$->append($3);
352 $$->append($4 = newNode("(", SQL_NODE_PUNCTUATION));
353 $$->append($5);
354 $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION));}
355 ;
356
357 base_table_element_commalist:
358 base_table_element
359 {$$ = SQL_NEW_COMMALISTRULE;
360 $$->append($1);}
361 | base_table_element_commalist ',' base_table_element
362 {$1->append($3);
363 $$ = $1;}
364 ;
365
366 base_table_element:
367 column_def
368 | table_constraint_def
369 ;
370
371 column_def:
372 column data_type column_def_opt_list
373 {$$ = SQL_NEW_RULE;
374 $$->append($1);
375 $$->append($2);
376 $$->append($3);
377 }
378 ;
379
380 column_def_opt_list:
381 /* empty */ {$$ = SQL_NEW_LISTRULE;}
382 | column_def_opt_list column_def_opt
383 {$1->append($2);
384 $$ = $1;}
385 ;
386
387 nil_fkt:
388 datetime_value_fct
389 ;
390 unique_spec:
391 SQL_TOKEN_UNIQUE
392 | SQL_TOKEN_PRIMARY SQL_TOKEN_KEY
393 {
394 $$ = SQL_NEW_RULE;
395 $$->append($1);
396 $$->append($2);
397 }
398 ;
399 column_def_opt:
400 SQL_TOKEN_NOT SQL_TOKEN_NULL
401 {$$ = SQL_NEW_RULE;
402 $$->append($1);
403 $$->append($2);}
404 | unique_spec
405 | SQL_TOKEN_DEFAULT literal
406 {$$ = SQL_NEW_RULE;
407 $$->append($1);
408 $$->append($2);}
409 | SQL_TOKEN_DEFAULT SQL_TOKEN_NULL
410 {$$ = SQL_NEW_RULE;
411 $$->append($1);
412 $$->append($2);}
413 | SQL_TOKEN_DEFAULT SQL_TOKEN_USER
414 {$$ = SQL_NEW_RULE;
415 $$->append($1);
416 $$->append($2);}
417 | SQL_TOKEN_DEFAULT nil_fkt
418 {
419 $$ = SQL_NEW_RULE;
420 $$->append($1);
421 $$->append($2);
422 }
423 | SQL_TOKEN_CHECK
424 | SQL_TOKEN_CHECK '(' search_condition ')'
425 {$$ = SQL_NEW_RULE;
426 $$->append($1);
427 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
428 $$->append($3);
429 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));}
430 | SQL_TOKEN_REFERENCES table_node
431 {$$ = SQL_NEW_RULE;
432 $$->append($1);
433 $$->append($2);}
434 | SQL_TOKEN_REFERENCES table_node '(' column_commalist ')'
435 {$$ = SQL_NEW_RULE;
436 $$->append($1);
437 $$->append($2);
438 $$->append($3 = newNode("(", SQL_NODE_PUNCTUATION));
439 $$->append($4);
440 $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION));}
441 ;
442
443 table_constraint_def:
444 unique_spec '(' column_commalist ')'
445 {$$ = SQL_NEW_RULE;
446 $$->append($1);
447 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
448 $$->append($3);
449 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));}
450 | SQL_TOKEN_FOREIGN SQL_TOKEN_KEY '(' column_commalist ')' SQL_TOKEN_REFERENCES table_node
451 {$$ = SQL_NEW_RULE;
452 $$->append($1);
453 $$->append($2);
454 $$->append($3 = newNode("(", SQL_NODE_PUNCTUATION));
455 $$->append($4);
456 $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION));
457 $$->append($6);
458 $$->append($7);}
459 | SQL_TOKEN_FOREIGN SQL_TOKEN_KEY '(' column_commalist ')' SQL_TOKEN_REFERENCES table_node '(' column_commalist ')'
460 {$$ = SQL_NEW_RULE;
461 $$->append($1);
462 $$->append($2);
463 $$->append($3 = newNode("(", SQL_NODE_PUNCTUATION));
464 $$->append($4);
465 $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION));
466 $$->append($6);
467 $$->append($7);
468 $$->append($8 = newNode("(", SQL_NODE_PUNCTUATION));
469 $$->append($9);
470 $$->append($10 = newNode(")", SQL_NODE_PUNCTUATION));}
471 | SQL_TOKEN_CHECK '(' search_condition ')'
472 {$$ = SQL_NEW_RULE;
473 $$->append($1);
474 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
475 $$->append($3);
476 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));}
477 ;
478 op_column_commalist:
479 /* empty */ {$$ = SQL_NEW_RULE;}
480 | '(' column_commalist ')'
481 {$$ = SQL_NEW_RULE;
482 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
483 $$->append($2);
484 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
485 }
486 ;
487 column_commalist:
488 column_commalist ',' column
489 {$1->append($3);
490 $$ = $1;}
491 | column
492 {$$ = SQL_NEW_COMMALISTRULE;
493 $$->append($1);}
494 ;
495
496 view_def:
497 SQL_TOKEN_CREATE SQL_TOKEN_VIEW table_node opt_column_commalist SQL_TOKEN_AS select_statement opt_with_check_option
498 {$$ = SQL_NEW_RULE;
499 $$->append($1);
500 $$->append($2);
501 $$->append($3);
502 $$->append($4);
503 $$->append($5);
504 $$->append($6);
505 $$->append($7);}
506 ;
507
508 opt_with_check_option:
509 /* empty */ {$$ = SQL_NEW_RULE;}
510 | SQL_TOKEN_WITH SQL_TOKEN_CHECK SQL_TOKEN_OPTION
511 {$$ = SQL_NEW_RULE;
512 $$->append($1);
513 $$->append($2);
514 $$->append($3);}
515 ;
516
517 opt_column_commalist:
518 /* empty */ {$$ = SQL_NEW_RULE;}
519 | '(' column_commalist ')'
520 {$$ = SQL_NEW_RULE;
521 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
522 $$->append($2);
523 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));}
524 ;
525
526 privilege_def:
527 SQL_TOKEN_GRANT privileges SQL_TOKEN_ON table_node SQL_TOKEN_TO grantee_commalist
528 opt_with_grant_option
529 {$$ = SQL_NEW_RULE;
530 $$->append($1);
531 $$->append($2);
532 $$->append($3);
533 $$->append($4);
534 $$->append($5);
535 $$->append($6);
536 $$->append($7);}
537 ;
538
539 opt_with_grant_option:
540 /* empty */ {$$ = SQL_NEW_RULE;}
541 | SQL_TOKEN_WITH SQL_TOKEN_GRANT SQL_TOKEN_OPTION
542 {$$ = SQL_NEW_RULE;
543 $$->append($1);
544 $$->append($2);
545 $$->append($3);}
546 ;
547
548 privileges:
549 SQL_TOKEN_ALL SQL_TOKEN_PRIVILEGES
550 {$$ = SQL_NEW_RULE;
551 $$->append($1);
552 $$->append($2);}
553 | operation_commalist
554 ;
555
556 operation_commalist:
557 operation
558 {$$ = SQL_NEW_COMMALISTRULE;
559 $$->append($1);}
560 | operation_commalist ',' operation
561 {$1->append($3);
562 $$ = $1;}
563 ;
564
565 operation:
566 SQL_TOKEN_SELECT
567 | SQL_TOKEN_INSERT opt_column_commalist
568 {$$ = SQL_NEW_RULE;
569 $$->append($1);
570 $$->append($2);}
571 | SQL_TOKEN_DELETE
572 | SQL_TOKEN_UPDATE opt_column_commalist
573 {$$ = SQL_NEW_RULE;
574 $$->append($1);
575 $$->append($2);}
576 | SQL_TOKEN_REFERENCES opt_column_commalist
577 {$$ = SQL_NEW_RULE;
578 $$->append($1);
579 $$->append($2);}
580 | SQL_TOKEN_USAGE
581 ;
582
583
584 grantee_commalist:
585 grantee
586 {$$ = SQL_NEW_COMMALISTRULE;
587 $$->append($1);}
588 | grantee_commalist ',' grantee
589 {$1->append($3);
590 $$ = $1;}
591 ;
592
593 grantee:
594 SQL_TOKEN_PUBLIC
595 | user
596 ;
597
598 /* module language */
599
600 opt_order_by_clause:
601 /* empty */ {$$ = SQL_NEW_RULE;}
602 | SQL_TOKEN_ORDER SQL_TOKEN_BY ordering_spec_commalist
603 {$$ = SQL_NEW_RULE;
604 $$->append($1);
605 $$->append($2);
606 $$->append($3);}
607 ;
608
609 ordering_spec_commalist:
610 ordering_spec
611 {$$ = SQL_NEW_COMMALISTRULE;
612 $$->append($1);}
613 | ordering_spec_commalist ',' ordering_spec
614 {$1->append($3);
615 $$ = $1;}
616 ;
617
618 ordering_spec:
619 /* SQL_TOKEN_INTNUM opt_asc_desc
620 {$$ = SQL_NEW_RULE;
621 $$->append($1);
622 $$->append($2);}
623 */
624 predicate opt_asc_desc
625 {$$ = SQL_NEW_RULE;
626 $$->append($1);
627 $$->append($2);}
628
629 | row_value_constructor_elem opt_asc_desc
630 {$$ = SQL_NEW_RULE;
631 $$->append($1);
632 $$->append($2);}
633 ;
634
635 opt_asc_desc:
636 {$$ = SQL_NEW_RULE;}
637 | SQL_TOKEN_ASC
638 | SQL_TOKEN_DESC
639 ;
640
641
642 /***
643 manipulative_statement_list:
644 manipulative_statement
645 {$$ = SQL_NEW_LISTRULE;
646 $$->append($1);}
647 | manipulative_statement_list manipulative_statement
648 {$1->append($2);
649 $$ = $1;}
650 ;
651 ***/
652
653 sql_not:
654 {$$ = SQL_NEW_RULE;}
655 | SQL_TOKEN_NOT
656 ;
657
658 /* manipulative statements */
659
660 manipulative_statement:
661 commit_statement
662 /* | delete_statement_positioned*/
663 | delete_statement_searched
664 | fetch_statement
665 | insert_statement
666 | rollback_statement
667 | select_statement_into
668 /* | update_statement_positioned*/
669 | update_statement_searched
670 | union_statement
671 | '{' odbc_call_spec '}'
672 {
673 $$ = SQL_NEW_RULE;
674 $$->append($1 = newNode("{", SQL_NODE_PUNCTUATION));
675 $$->append($2);
676 $$->append($3 = newNode("}", SQL_NODE_PUNCTUATION));
677 }
678 ;
679
680 union_statement:
681 select_statement
682 | union_statement SQL_TOKEN_UNION all select_statement
683 {
684 $$ = SQL_NEW_RULE;
685 $$->append($1);
686 $$->append($2);
687 $$->append($3);
688 $$->append($4);
689 }
690 ;
691 commit_statement:
692 SQL_TOKEN_COMMIT SQL_TOKEN_WORK
693 {$$ = SQL_NEW_RULE;
694 $$->append($1);
695 $$->append($2);}
696 ;
697 /*
698 delete_statement_positioned:
699 SQL_TOKEN_DELETE SQL_TOKEN_FROM table_node SQL_TOKEN_WHERE SQL_TOKEN_CURRENT SQL_TOKEN_OF cursor
700 {$$ = SQL_NEW_RULE;
701 $$->append($1);
702 $$->append($2);
703 $$->append($3);
704 $$->append($4);
705 $$->append($5);
706 $$->append($6);
707 $$->append($7);}
708 ;
709 */
710 delete_statement_searched:
711 SQL_TOKEN_DELETE SQL_TOKEN_FROM table_node opt_where_clause
712 {$$ = SQL_NEW_RULE;
713 $$->append($1);
714 $$->append($2);
715 $$->append($3);
716 $$->append($4);}
717 ;
718
719 fetch_statement:
720 SQL_TOKEN_FETCH cursor SQL_TOKEN_INTO target_commalist
721 {$$ = SQL_NEW_RULE;
722 $$->append($1);
723 $$->append($2);
724 $$->append($3);
725 $$->append($4);}
726 ;
727
728 insert_statement:
729 SQL_TOKEN_INSERT SQL_TOKEN_INTO table_node opt_column_commalist query_exp
730 {$$ = SQL_NEW_RULE;
731 $$->append($1);
732 $$->append($2);
733 $$->append($3);
734 $$->append($4);
735 $$->append($5);}
736 ;
737 values_or_query_spec:
738 SQL_TOKEN_VALUES '(' table_value_const_list ')'
739 {$$ = SQL_NEW_RULE;
740 $$->append($1);
741 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
742 $$->append($3);
743 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
744 }
745 ;
746
747 table_value_const_list:
748 row_value_constructor
749 {$$ = SQL_NEW_COMMALISTRULE;
750 $$->append($1);}
751 | table_value_const_list ',' row_value_constructor
752 {$1->append($3);
753 $$ = $1;}
754 ;
755 row_value_const_list:
756 row_value_constructor_elem
757 {$$ = SQL_NEW_COMMALISTRULE;
758 $$->append($1);}
759 | row_value_const_list ',' row_value_constructor_elem
760 {$1->append($3);
761 $$ = $1;}
762 ;
763 row_value_constructor:
764 row_value_constructor_elem
765 /* | '(' row_value_const_list ')'
766 {
767 $$ = SQL_NEW_RULE;
768 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
769 $$->append($2);
770 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
771 }
772 */
773 ;
774 row_value_constructor_elem:
775 value_exp /*[^')']*/
776 | SQL_TOKEN_DEFAULT
777 ;
778
779
780 rollback_statement:
781 SQL_TOKEN_ROLLBACK SQL_TOKEN_WORK
782 {$$ = SQL_NEW_RULE;
783 $$->append($1);
784 $$->append($2);}
785 ;
786
787
788 /* INTO target_commalist herausgenommen */
789 select_statement_into:
790 SQL_TOKEN_SELECT opt_all_distinct selection SQL_TOKEN_INTO target_commalist table_exp
791 {$$ = SQL_NEW_RULE;
792 $$->append($1);
793 $$->append($2);
794 $$->append($3);
795 $$->append($4);
796 $$->append($5);
797 $$->append($6); }
798 ;
799
800 opt_all_distinct:
801 {$$ = SQL_NEW_RULE;}
802 | SQL_TOKEN_ALL
803 | SQL_TOKEN_DISTINCT
804
805 ;
806 /*
807 update_statement_positioned:
808 SQL_TOKEN_UPDATE table_node SQL_TOKEN_SET assignment_commalist
809 SQL_TOKEN_WHERE SQL_TOKEN_CURRENT SQL_TOKEN_OF cursor
810 {$$ = SQL_NEW_RULE;
811 $$->append($1);
812 $$->append($2);
813 $$->append($3);
814 $$->append($4);
815 $$->append($5);
816 $$->append($6);
817 $$->append($7);
818 $$->append($8);}
819 ;
820 */
821 assignment_commalist:
822 assignment
823 {$$ = SQL_NEW_COMMALISTRULE;
824 $$->append($1);}
825 | assignment_commalist ',' assignment
826 {$1->append($3);
827 $$ = $1;}
828 ;
829
830 assignment:
831 column SQL_EQUAL update_source
832 {$$ = SQL_NEW_RULE;
833 $$->append($1);
834 $$->append($2);
835 $$->append($3);}
836 ;
837 update_source:
838 value_exp
839 | SQL_TOKEN_DEFAULT
840 ;
841 update_statement_searched:
842 SQL_TOKEN_UPDATE table_node SQL_TOKEN_SET assignment_commalist opt_where_clause
843 {$$ = SQL_NEW_RULE;
844 $$->append($1);
845 $$->append($2);
846 $$->append($3);
847 $$->append($4);
848 $$->append($5);}
849 ;
850
851 target_commalist:
852 target
853 {$$ = SQL_NEW_COMMALISTRULE;
854 $$->append($1);}
855 | target_commalist ',' target
856 {$1->append($3);
857 $$ = $1;}
858 ;
859
860 target:
861 parameter_ref
862 ;
863
864 opt_where_clause:
865 /* empty */ {$$ = SQL_NEW_RULE;}
866 | where_clause
867 ;
868
869 /* query expressions */
870
871 query_term:
872 non_join_query_term
873 {
874 $$ = SQL_NEW_RULE;
875 $$->append($1);
876 }
877 ;
878 /* SELECT STATEMENT */
879 select_statement:
880 SQL_TOKEN_SELECT opt_all_distinct selection table_exp
881 {
882 $$ = SQL_NEW_RULE;
883 $$->append($1);
884 $$->append($2);
885 $$->append($3);
886 $$->append($4);
887 }
888 ;
889
890 selection:
891 '*'
892 {
893 $$ = SQL_NEW_RULE;
894 $$->append($1 = newNode("*", SQL_NODE_PUNCTUATION));
895 }
896 | scalar_exp_commalist
897 ;
898 opt_result_offset_clause:
899 /* empty */ {$$ = SQL_NEW_RULE;}
900 | result_offset_clause
901 ;
902 result_offset_clause:
903 SQL_TOKEN_OFFSET offset_row_count row_or_rows
904 {
905 $$ = SQL_NEW_RULE;
906 $$->append($1);
907 $$->append($2);
908 $$->append($3);
909 }
910 ;
911 opt_fetch_first_row_count:
912 /* empty */ {$$ = SQL_NEW_RULE;}
913 | fetch_first_row_count
914 ;
915 first_or_next:
916 SQL_TOKEN_FIRST
917 | SQL_TOKEN_NEXT
918 ;
919 row_or_rows:
920 SQL_TOKEN_ROW
921 | SQL_TOKEN_ROWS
922 ;
923 opt_fetch_first_clause:
924 /* empty */ {$$ = SQL_NEW_RULE;}
925 | fetch_first_clause
926 ;
927 fetch_first_clause:
928 SQL_TOKEN_FETCH first_or_next opt_fetch_first_row_count row_or_rows SQL_TOKEN_ONLY
929 {
930 $$ = SQL_NEW_RULE;
931 $$->append($1);
932 $$->append($2);
933 $$->append($3);
934 $$->append($4);
935 $$->append($5);
936 }
937 ;
938 offset_row_count:
939 literal
940 ;
941 fetch_first_row_count:
942 literal
943 ;
944
945 opt_limit_offset_clause:
946 /* empty */ {$$ = SQL_NEW_RULE;}
947 | limit_offset_clause
948 ;
949 opt_offset:
950 /* empty */ {$$ = SQL_NEW_RULE;}
951 | SQL_TOKEN_OFFSET SQL_TOKEN_INTNUM
952 {
953 $$ = SQL_NEW_RULE;
954 $$->append($1);
955 $$->append($2);
956 }
957 ;
958 limit_offset_clause:
959 SQL_TOKEN_LIMIT SQL_TOKEN_INTNUM opt_offset
960 {
961 $$ = SQL_NEW_RULE;
962 $$->append($1);
963 $$->append($2);
964 $$->append($3);
965 }
966 ;
967 table_exp:
968 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
969 {
970 $$ = SQL_NEW_RULE;
971 $$->append($1);
972 $$->append($2);
973 $$->append($3);
974 $$->append($4);
975 $$->append($5);
976 $$->append($6);
977 $$->append($7);
978 $$->append($8);
979 $$->append($9);
980 }
981 ;
982
983 from_clause:
984 SQL_TOKEN_FROM table_ref_commalist
985 { $$ = SQL_NEW_RULE;
986 $$->append($1);
987 $$->append($2); }
988 ;
989
990 table_ref_commalist:
991
992 table_ref
993 { $$ = SQL_NEW_COMMALISTRULE;
994 $$->append($1); }
995 | table_ref_commalist ',' table_ref
996 { $1->append($3);
997 $$ = $1; }
998 ;
999
1000 opt_as:
1001 /* empty */ {$$ = SQL_NEW_RULE;}
1002 | SQL_TOKEN_AS
1003 ;
1004 opt_row:
1005 /* empty */ {$$ = SQL_NEW_RULE;}
1006 | SQL_TOKEN_ROW
1007 ;
1008 table_primary_as_range_column:
1009 {$$ = SQL_NEW_RULE;}
1010 | opt_as SQL_TOKEN_NAME op_column_commalist
1011 {
1012 $$ = SQL_NEW_RULE;
1013 $$->append($1);
1014 $$->append($2);
1015 $$->append($3);
1016 }
1017 ;
1018 table_ref:
1019 table_node table_primary_as_range_column
1020 {
1021 $$ = SQL_NEW_RULE;
1022 $$->append($1);
1023 $$->append($2);
1024 }
1025 | subquery range_variable op_column_commalist
1026 {
1027 $$ = SQL_NEW_RULE;
1028 $$->append($1);
1029 $$->append($2);
1030 $$->append($3);
1031 }
1032 | joined_table
1033 | '{' SQL_TOKEN_OJ joined_table '}'
1034 {
1035 $$ = SQL_NEW_RULE;
1036 $$->append($1 = newNode("{", SQL_NODE_PUNCTUATION));
1037 $$->append($2);
1038 $$->append($3);
1039 $$->append($4 = newNode("}", SQL_NODE_PUNCTUATION));
1040 }
1041 | '(' joined_table ')'
1042 {
1043 $$ = SQL_NEW_RULE;
1044 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
1045 $$->append($2);
1046 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
1047 }
1048 ;
1049 where_clause:
1050 SQL_TOKEN_WHERE search_condition
1051 {$$ = SQL_NEW_RULE;
1052 $$->append($1);
1053 $$->append($2);}
1054 ;
1055
1056 opt_group_by_clause:
1057 /* empty */ {$$ = SQL_NEW_RULE;}
1058 | SQL_TOKEN_GROUP SQL_TOKEN_BY column_ref_commalist
1059 {$$ = SQL_NEW_RULE;
1060 $$->append($1);
1061 $$->append($2);
1062 $$->append($3);}
1063 ;
1064
1065 column_ref_commalist:
1066 column_ref
1067 {$$ = SQL_NEW_COMMALISTRULE;
1068 $$->append($1);}
1069 | set_fct_spec
1070 {$$ = SQL_NEW_COMMALISTRULE;
1071 $$->append($1);}
1072 | column_ref_commalist ',' column_ref
1073 {$1->append($3);
1074 $$ = $1;}
1075 | column_ref_commalist ',' set_fct_spec
1076 {$1->append($3);
1077 $$ = $1;}
1078 ;
1079
1080 opt_having_clause:
1081 /* empty */ {$$ = SQL_NEW_RULE;}
1082 | SQL_TOKEN_HAVING search_condition
1083 {$$ = SQL_NEW_RULE;
1084 $$->append($1);
1085 $$->append($2);}
1086 ;
1087
1088 /* search conditions */
1089 truth_value:
1090 SQL_TOKEN_TRUE
1091 | SQL_TOKEN_FALSE
1092 | SQL_TOKEN_UNKNOWN
1093 | SQL_TOKEN_NULL
1094 ;
1095 boolean_primary:
1096 predicate
1097 | '(' search_condition ')'
1098 { // boolean_primary: rule 2
1099 $$ = SQL_NEW_RULE;
1100 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
1101 $$->append($2);
1102 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
1103 }
1104 | row_value_constructor_elem /*[^')' ',']*/
1105 {
1106 if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck())// boolean_primary: rule 3
1107 {
1108 $$ = SQL_NEW_RULE;
1109 sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildComparsionRule($$,$1);
1110 if(nErg == 1)
1111 {
1112 OSQLParseNode* pTemp = $$;
1113 $$ = pTemp->removeAt((sal_uInt32)0);
1114 delete pTemp;
1115 }
1116 else
1117 {
1118 delete $$;
1119 if(nErg)
1120 YYERROR;
1121 else
1122 YYABORT;
1123 }
1124 }
1125 else
1126 YYERROR;
1127 }
1128 ;
1129 parenthesized_boolean_value_expression:
1130 '(' search_condition ')'
1131 { // boolean_primary: rule 2
1132 $$ = SQL_NEW_RULE;
1133 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
1134 $$->append($2);
1135 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
1136 }
1137 ;
1138 boolean_test:
1139 boolean_primary
1140 | boolean_primary SQL_TOKEN_IS sql_not truth_value
1141 {
1142 $$ = SQL_NEW_RULE;
1143 $$->append($1);
1144 $$->append($2);
1145 $$->append($3);
1146 $$->append($4);
1147 }
1148 ;
1149 boolean_factor:
1150 boolean_test
1151 | SQL_TOKEN_NOT boolean_test
1152 { // boolean_factor: rule 1
1153 $$ = SQL_NEW_RULE;
1154 $$->append($1);
1155 $$->append($2);
1156 }
1157 ;
1158 boolean_term:
1159 boolean_factor
1160 | boolean_term SQL_TOKEN_AND boolean_factor
1161 {
1162 $$ = SQL_NEW_RULE; // boolean_term: rule 1
1163 $$->append($1);
1164 $$->append($2);
1165 $$->append($3);
1166 }
1167 ;
1168 search_condition:
1169 boolean_term
1170 | search_condition SQL_TOKEN_OR boolean_term
1171 {
1172 $$ = SQL_NEW_RULE; // search_condition
1173 $$->append($1);
1174 $$->append($2);
1175 $$->append($3);
1176 }
1177 ;
1178 predicate:
1179 comparison_predicate
1180 | between_predicate
1181 | all_or_any_predicate
1182 | existence_test
1183 | unique_test
1184 | test_for_null
1185 | in_predicate
1186 | like_predicate
1187 ;
1188 comparison_predicate_part_2:
1189 comparison row_value_constructor
1190 {
1191 $$ = SQL_NEW_RULE; // comparison_predicate: rule 1
1192 $$->append($1);
1193 $$->append($2);
1194 }
1195 comparison_predicate:
1196 row_value_constructor comparison row_value_constructor
1197 {
1198 $$ = SQL_NEW_RULE; // comparison_predicate: rule 1
1199 $$->append($1);
1200 $$->append($2);
1201 $$->append($3);
1202 }
1203 | comparison row_value_constructor
1204 {
1205 if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // comparison_predicate: rule 2
1206 {
1207 $$ = SQL_NEW_RULE;
1208 sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildPredicateRule($$,$2,$1);
1209 if(nErg == 1)
1210 {
1211 OSQLParseNode* pTemp = $$;
1212 $$ = pTemp->removeAt((sal_uInt32)0);
1213 delete pTemp;
1214 }
1215 else
1216 {
1217 delete $$;
1218 YYABORT;
1219 }
1220 }
1221 else
1222 {
1223 YYERROR;
1224 }
1225 }
1226 ;
1227 comparison:
1228 SQL_LESS
1229 | SQL_NOTEQUAL
1230 | SQL_EQUAL
1231 | SQL_GREAT
1232 | SQL_LESSEQ
1233 | SQL_GREATEQ
1234 | SQL_TOKEN_IS sql_not SQL_TOKEN_DISTINCT SQL_TOKEN_FROM
1235 {
1236 $$ = SQL_NEW_RULE;
1237 $$->append($1);
1238 $$->append($2);
1239 $$->append($3);
1240 $$->append($4);
1241 }
1242 | SQL_TOKEN_IS sql_not
1243 {
1244 $$ = SQL_NEW_RULE;
1245 $$->append($1);
1246 $$->append($2);
1247 }
1248 ;
1249 between_predicate_part_2:
1250 sql_not SQL_TOKEN_BETWEEN row_value_constructor SQL_TOKEN_AND row_value_constructor
1251 {
1252 if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // between_predicate: rule 2
1253 {
1254 $$ = SQL_NEW_RULE;
1255
1256 sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildPredicateRule($$,$3,$2,$5);
1257 if(nErg == 1)
1258 {
1259 OSQLParseNode* pTemp = $$;
1260 $$ = pTemp->removeAt((sal_uInt32)0);
1261 OSQLParseNode* pColumnRef = $$->removeAt((sal_uInt32)0);
1262 $$->insert(0,$1);
1263 OSQLParseNode* pBetween_predicate = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::between_predicate));
1264 pBetween_predicate->append(pColumnRef);
1265 pBetween_predicate->append($$);
1266 $$ = pBetween_predicate;
1267
1268 delete pTemp;
1269 delete $4;
1270 }
1271 else
1272 {
1273 delete $$;
1274 YYABORT;
1275 }
1276 }
1277 else
1278 {
1279 $$ = SQL_NEW_RULE; // between_predicate: rule 1
1280 $$->append($1);
1281 $$->append($2);
1282 $$->append($3);
1283 $$->append($4);
1284 $$->append($5);
1285 }
1286 }
1287 between_predicate:
1288 row_value_constructor between_predicate_part_2
1289 {
1290 $$ = SQL_NEW_RULE; // between_predicate: rule 1
1291 $$->append($1);
1292 $$->append($2);
1293 }
1294 | between_predicate_part_2
1295 ;
1296 character_like_predicate_part_2:
1297 sql_not SQL_TOKEN_LIKE string_value_exp opt_escape
1298 {
1299 $$ = SQL_NEW_RULE; // like_predicate: rule 1
1300 $$->append($1);
1301 $$->append($2);
1302 $$->append($3);
1303 $$->append($4);
1304 }
1305 ;
1306 other_like_predicate_part_2:
1307 sql_not SQL_TOKEN_LIKE value_exp_primary opt_escape
1308 {
1309 $$ = SQL_NEW_RULE; // like_predicate: rule 1
1310 $$->append($1);
1311 $$->append($2);
1312 $$->append($3);
1313 $$->append($4);
1314 }
1315 ;
1316 like_predicate:
1317 row_value_constructor character_like_predicate_part_2
1318 {
1319 $$ = SQL_NEW_RULE; // like_predicate: rule 1
1320 $$->append($1);
1321 $$->append($2);
1322 }
1323 | row_value_constructor other_like_predicate_part_2
1324 {
1325 $$ = SQL_NEW_RULE; // like_predicate: rule 3
1326 $$->append($1);
1327 $$->append($2);
1328 }
1329 | character_like_predicate_part_2
1330 {
1331 if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // like_predicate: rule 5
1332 {
1333 OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref));
1334 pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME));
1335
1336 $$ = SQL_NEW_RULE;
1337 $$->append(pColumnRef);
1338 $$->append($1);
1339 OSQLParseNode* p2nd = $1->removeAt(2);
1340 OSQLParseNode* p3rd = $1->removeAt(2);
1341 if ( !xxx_pGLOBAL_SQLPARSER->buildLikeRule($1,p2nd,p3rd) )
1342 {
1343 delete $$;
1344 YYABORT;
1345 }
1346 $1->append(p3rd);
1347 }
1348 else
1349 YYERROR;
1350 }
1351 | other_like_predicate_part_2
1352 {
1353 if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // like_predicate: rule 6
1354 {
1355 OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref));
1356 pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME));
1357
1358 $$ = SQL_NEW_RULE;
1359 $$->append(pColumnRef);
1360 $$->append($1);
1361 OSQLParseNode* p2nd = $1->removeAt(2);
1362 OSQLParseNode* p3rd = $1->removeAt(2);
1363 if ( !xxx_pGLOBAL_SQLPARSER->buildLikeRule($1,p2nd,p3rd) )
1364 {
1365 delete $$;
1366 YYABORT;
1367 }
1368 $1->append(p3rd);
1369 }
1370 else
1371 YYERROR;
1372 }
1373 ;
1374
1375 opt_escape:
1376 /* empty */ {$$ = SQL_NEW_RULE;}
1377 | SQL_TOKEN_ESCAPE string_value_exp
1378 {$$ = SQL_NEW_RULE;
1379 $$->append($1);
1380 $$->append($2);}
1381 | '{' SQL_TOKEN_ESCAPE SQL_TOKEN_STRING '}'
1382 {
1383 $$ = SQL_NEW_RULE;
1384 $$->append($1 = newNode("{", SQL_NODE_PUNCTUATION));
1385 $$->append($2);
1386 $$->append($3);
1387 $$->append($4 = newNode("}", SQL_NODE_PUNCTUATION));
1388 }
1389 ;
1390
1391 null_predicate_part_2:
1392 SQL_TOKEN_IS sql_not SQL_TOKEN_NULL
1393 {
1394 $$ = SQL_NEW_RULE; // test_for_null: rule 1
1395 $$->append($1);
1396 $$->append($2);
1397 $$->append($3);
1398 }
1399 ;
1400 test_for_null:
1401 row_value_constructor null_predicate_part_2
1402 {
1403 $$ = SQL_NEW_RULE; // test_for_null: rule 1
1404 $$->append($1);
1405 $$->append($2);
1406 }
1407 | null_predicate_part_2
1408 {
1409 if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())// test_for_null: rule 2
1410 {
1411 OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref));
1412 pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME));
1413
1414 $$ = SQL_NEW_RULE;
1415 $$->append(pColumnRef);
1416 $$->append($1);
1417 }
1418 else
1419 YYERROR;
1420 }
1421 ;
1422 in_predicate_value:
1423 subquery
1424 {$$ = SQL_NEW_RULE;
1425 $$->append($1);
1426 }
1427 | '(' value_exp_commalist ')'
1428 {$$ = SQL_NEW_RULE;
1429 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
1430 $$->append($2);
1431 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
1432 }
1433 ;
1434 in_predicate_part_2:
1435 sql_not SQL_TOKEN_IN in_predicate_value
1436 {
1437 $$ = SQL_NEW_RULE;// in_predicate: rule 1
1438 $$->append($1);
1439 $$->append($2);
1440 $$->append($3);
1441 }
1442 ;
1443 in_predicate:
1444 row_value_constructor in_predicate_part_2
1445 {
1446 $$ = SQL_NEW_RULE;// in_predicate: rule 1
1447 $$->append($1);
1448 $$->append($2);
1449 }
1450 | in_predicate_part_2
1451 {
1452 if ( xxx_pGLOBAL_SQLPARSER->inPredicateCheck() )// in_predicate: rule 2
1453 {
1454 OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref));
1455 pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME));
1456
1457 $$ = SQL_NEW_RULE;
1458 $$->append(pColumnRef);
1459 $$->append($1);
1460 }
1461 else
1462 YYERROR;
1463 }
1464 ;
1465 quantified_comparison_predicate_part_2:
1466 comparison any_all_some subquery
1467 {
1468 $$ = SQL_NEW_RULE;
1469 $$->append($1);
1470 $$->append($2);
1471 $$->append($3);
1472 }
1473 ;
1474 all_or_any_predicate:
1475 row_value_constructor quantified_comparison_predicate_part_2
1476 {
1477 $$ = SQL_NEW_RULE;
1478 $$->append($1);
1479 $$->append($2);
1480 }
1481 | quantified_comparison_predicate_part_2
1482 {
1483 if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
1484 {
1485 OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref));
1486 pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME));
1487
1488 $$ = SQL_NEW_RULE;
1489 $$->append(pColumnRef);
1490 $$->append($1);
1491 }
1492 else
1493 YYERROR;
1494 }
1495 ;
1496
1497 any_all_some:
1498 SQL_TOKEN_ANY
1499 | SQL_TOKEN_ALL
1500 | SQL_TOKEN_SOME
1501 ;
1502
1503 existence_test:
1504 SQL_TOKEN_EXISTS subquery
1505 {$$ = SQL_NEW_RULE;
1506 $$->append($1);
1507 $$->append($2);}
1508 ;
1509 unique_test:
1510 SQL_TOKEN_UNIQUE subquery
1511 {$$ = SQL_NEW_RULE;
1512 $$->append($1);
1513 $$->append($2);}
1514 ;
1515 subquery:
1516 '(' query_exp ')'
1517 {$$ = SQL_NEW_RULE;
1518 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
1519 $$->append($2);
1520 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));}
1521 ;
1522
1523 /* scalar expressions */
1524 scalar_exp_commalist:
1525 select_sublist
1526 {
1527 $$ = SQL_NEW_COMMALISTRULE;
1528 $$->append($1);
1529 }
1530 | scalar_exp_commalist ',' select_sublist
1531 {
1532 $1->append($3);
1533 $$ = $1;
1534 }
1535 ;
1536 select_sublist:
1537 /* table_node '.' '*'
1538 {
1539 $$ = SQL_NEW_RULE;
1540 $$->append($1);
1541 $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION));
1542 $$->append($3 = newNode("*", SQL_NODE_PUNCTUATION));
1543 }
1544 */
1545 derived_column
1546
1547 ;
1548
1549 parameter_ref:
1550 parameter
1551 ;
1552
1553 /*
1554 op_like:
1555 '*'
1556 {
1557 $$ = newNode("*", SQL_NODE_PUNCTUATION);
1558 }
1559 | '?'
1560 {
1561 $$ = newNode("?", SQL_NODE_PUNCTUATION);
1562 }
1563 | op_like '*'
1564 {
1565 $$ = SQL_NEW_RULE;
1566 $$->append($1);
1567 $$->append($2 = newNode("*", SQL_NODE_PUNCTUATION));
1568 xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_False);
1569 }
1570 | op_like '?'
1571 {
1572 $$ = SQL_NEW_RULE;
1573 $$->append($1);
1574 $$->append($2 = newNode("?", SQL_NODE_PUNCTUATION));
1575 xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_False);
1576 }
1577 ;
1578 */
1579
1580 literal:
1581 /* SQL_TOKEN_STRING
1582 | */SQL_TOKEN_INT
1583 | SQL_TOKEN_REAL_NUM
1584 | SQL_TOKEN_INTNUM
1585 | SQL_TOKEN_APPROXNUM
1586 | SQL_TOKEN_ACCESS_DATE
1587 /* rules for predicate check */
1588 | literal SQL_TOKEN_STRING
1589 {
1590 if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
1591 {
1592 $$ = SQL_NEW_RULE;
1593 $$->append($1);
1594 $$->append($2);
1595 xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_True);
1596 }
1597 else
1598 YYERROR;
1599 }
1600 | literal SQL_TOKEN_INT
1601 {
1602 if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
1603 {
1604 $$ = SQL_NEW_RULE;
1605 $$->append($1);
1606 $$->append($2);
1607 xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_True);
1608 }
1609 else
1610 YYERROR;
1611 }
1612 | literal SQL_TOKEN_REAL_NUM
1613 {
1614 if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
1615 {
1616 $$ = SQL_NEW_RULE;
1617 $$->append($1);
1618 $$->append($2);
1619 xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_True);
1620 }
1621 else
1622 YYERROR;
1623 }
1624 | literal SQL_TOKEN_APPROXNUM
1625 {
1626 if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
1627 {
1628 $$ = SQL_NEW_RULE;
1629 $$->append($1);
1630 $$->append($2);
1631 xxx_pGLOBAL_SQLPARSER->reduceLiteral($$, sal_True);
1632 }
1633 else
1634 YYERROR;
1635 }
1636 ;
1637
1638 /* miscellaneous */
1639 as_clause:
1640 /* empty */ {$$ = SQL_NEW_RULE;}
1641 | SQL_TOKEN_AS column
1642 {
1643 $$ = SQL_NEW_RULE;
1644 $$->append($1);
1645 $$->append($2);
1646 }
1647 | column
1648 ;
1649 position_exp:
1650 SQL_TOKEN_POSITION '(' value_exp SQL_TOKEN_IN value_exp ')'
1651 {
1652 $$ = SQL_NEW_RULE;
1653 $$->append($1);
1654 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1655 $$->append($3);
1656 $$->append($4);
1657 $$->append($5);
1658 $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION));
1659 }
1660 | SQL_TOKEN_POSITION '(' value_exp_commalist ')'
1661 {
1662 $$ = SQL_NEW_RULE;
1663 $$->append($1);
1664 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1665 $$->append($3);
1666 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
1667 }
1668 ;
1669 num_value_fct:
1670 position_exp
1671 | extract_exp
1672 | length_exp
1673 ;
1674 char_length_exp:
1675 SQL_TOKEN_CHAR_LENGTH '(' value_exp ')'
1676 {
1677 $$ = SQL_NEW_RULE;
1678 $$->append($1);
1679 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1680 $$->append($3);
1681 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
1682 }
1683 | SQL_TOKEN_SQL_TOKEN_INTNUM '(' value_exp ')'
1684 {
1685 $$ = SQL_NEW_RULE;
1686 $$->append($1);
1687 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1688 $$->append($3);
1689 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
1690 }
1691
1692 ;
1693 octet_length_exp:
1694 SQL_TOKEN_OCTET_LENGTH '(' value_exp ')'
1695 {
1696 $$ = SQL_NEW_RULE;
1697 $$->append($1);
1698 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1699 $$->append($3);
1700 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
1701 }
1702 ;
1703 bit_length_exp:
1704 SQL_TOKEN_BIT_LENGTH '(' value_exp ')'
1705 {
1706 $$ = SQL_NEW_RULE;
1707 $$->append($1);
1708 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1709 $$->append($3);
1710 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
1711 }
1712 ;
1713 length_exp:
1714 char_length_exp
1715 {
1716 $$ = SQL_NEW_RULE;
1717 $$->append($1);
1718 }
1719 | octet_length_exp
1720 {
1721 $$ = SQL_NEW_RULE;
1722 $$->append($1);
1723 }
1724 | bit_length_exp
1725 {
1726 $$ = SQL_NEW_RULE;
1727 $$->append($1);
1728 }
1729 ;
1730 datetime_field:
1731 non_second_datetime_field
1732 {
1733 $$ = SQL_NEW_RULE;
1734 $$->append($1);
1735 }
1736 | SQL_TOKEN_SECOND
1737 {
1738 $$ = SQL_NEW_RULE;
1739 $$->append($1);
1740 }
1741 ;
1742 extract_field:
1743 time_zone_field
1744 | datetime_field
1745 | value_exp
1746 ;
1747 time_zone_field:
1748 SQL_TOKEN_TIMEZONE_HOUR
1749 {
1750 $$ = SQL_NEW_RULE;
1751 $$->append($1);
1752 }
1753 | SQL_TOKEN_TIMEZONE_MINUTE
1754 {
1755 $$ = SQL_NEW_RULE;
1756 $$->append($1);
1757 }
1758 ;
1759 extract_source:
1760 datetime_value_exp
1761 {
1762 $$ = SQL_NEW_RULE;
1763 $$->append($1);
1764 }
1765 /* | interval_value_exp
1766 {
1767 $$ = SQL_NEW_RULE;
1768 $$->append($1);
1769 } */
1770 ;
1771 extract_exp:
1772 SQL_TOKEN_EXTRACT '(' extract_field SQL_TOKEN_FROM value_exp ')'
1773 {
1774 $$ = SQL_NEW_RULE;
1775 $$->append($1);
1776 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1777 $$->append($3);
1778 $$->append($4);
1779 $$->append($5);
1780 $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION));
1781 }
1782 ;
1783 unsigned_value_spec:
1784 general_value_spec
1785 | literal
1786 ;
1787 general_value_spec:
1788 parameter
1789 | SQL_TOKEN_USER
1790 | SQL_TOKEN_NULL
1791 | SQL_TOKEN_FALSE
1792 | SQL_TOKEN_TRUE
1793 | SQL_TOKEN_VALUE
1794 | SQL_TOKEN_CURRENT_CATALOG
1795 | SQL_TOKEN_CURRENT_DEFAULT_TRANSFORM_GROUP
1796 | SQL_TOKEN_CURRENT_PATH
1797 | SQL_TOKEN_CURRENT_ROLE
1798 | SQL_TOKEN_CURRENT_SCHEMA
1799 | SQL_TOKEN_CURRENT_USER
1800 | SQL_TOKEN_SESSION_USER
1801 | SQL_TOKEN_SYSTEM_USER
1802 ;
1803 set_fct_spec:
1804 general_set_fct
1805 | '{' odbc_fct_spec '}'
1806 {
1807 $$ = SQL_NEW_RULE;
1808 $$->append($1 = newNode("{", SQL_NODE_PUNCTUATION));
1809 $$->append($2);
1810 $$->append($3 = newNode("}", SQL_NODE_PUNCTUATION));
1811 }
1812 | function_name '(' ')'
1813 {
1814 $$ = SQL_NEW_RULE;
1815 $$->append($1);
1816 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1817 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
1818 }
1819 | function_name0 '(' ')'
1820 {
1821 $$ = SQL_NEW_RULE;
1822 $$->append($1);
1823 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1824 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
1825 }
1826 | function_name1 '(' function_arg ')'
1827 {
1828 $$ = SQL_NEW_RULE;
1829 $$->append($1);
1830 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1831 $$->append($3);
1832 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
1833 }
1834 | function_name2 '(' function_arg_commalist2 ')'
1835 {
1836 $$ = SQL_NEW_RULE;
1837 $$->append($1);
1838 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1839 $$->append($3);
1840 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
1841 }
1842 | function_name3 '(' function_arg_commalist3 ')'
1843 {
1844 $$ = SQL_NEW_RULE;
1845 $$->append($1);
1846 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1847 $$->append($3);
1848 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
1849 }
1850 | string_function_4Argument '(' function_arg_commalist4 ')'
1851 {
1852 $$ = SQL_NEW_RULE;
1853 $$->append($1);
1854 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1855 $$->append($3);
1856 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
1857 }
1858 | function_name '(' function_args_commalist ')'
1859 {
1860 $$ = SQL_NEW_RULE;
1861 $$->append($1);
1862 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1863 $$->append($3);
1864 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
1865 }
1866 | function_name12 '(' function_args_commalist ')'
1867 {
1868 if ( $3->count() == 1 || $3->count() == 2 )
1869 {
1870 $$ = SQL_NEW_RULE;
1871 $$->append($1);
1872 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1873 $$->append($3);
1874 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
1875 }
1876 else
1877 YYERROR;
1878 }
1879 | function_name23 '(' function_args_commalist ')'
1880 {
1881 if ( $3->count() == 2 || $3->count() == 3)
1882 {
1883 $$ = SQL_NEW_RULE;
1884 $$->append($1);
1885 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
1886 $$->append($3);
1887 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
1888 }
1889 else
1890 YYERROR;
1891 }
1892 ;
1893 function_name0:
1894 date_function_0Argument
1895 | numeric_function_0Argument
1896 ;
1897 function_name1:
1898 string_function_1Argument
1899 | date_function_1Argument
1900 | numeric_function_1Argument
1901 ;
1902 function_name2:
1903 string_function_2Argument
1904 | numeric_function_2Argument
1905 ;
1906 function_name12:
1907 SQL_TOKEN_ROUND
1908 | SQL_TOKEN_WEEK
1909 | SQL_TOKEN_LOGF
1910 | SQL_TOKEN_LOG
1911 ;
1912 function_name23:
1913 SQL_TOKEN_LOCATE
1914 | SQL_TOKEN_DATEDIFF
1915 ;
1916 function_name3:
1917 string_function_3Argument
1918 ;
1919 function_name:
1920 string_function
1921 | date_function
1922 | numeric_function
1923 | SQL_TOKEN_NAME
1924 ;
1925 string_function_1Argument:
1926 SQL_TOKEN_LENGTH
1927 | SQL_TOKEN_ASCII
1928 | SQL_TOKEN_LCASE
1929 | SQL_TOKEN_LTRIM
1930 | SQL_TOKEN_RTRIM
1931 | SQL_TOKEN_SPACE
1932 | SQL_TOKEN_UCASE
1933 ;
1934
1935 string_function_2Argument:
1936 SQL_TOKEN_REPEAT
1937 | SQL_TOKEN_LEFT
1938 | SQL_TOKEN_RIGHT
1939 ;
1940 string_function_3Argument:
1941 SQL_TOKEN_REPLACE
1942 ;
1943 string_function_4Argument:
1944 SQL_TOKEN_INSERT
1945 ;
1946
1947 string_function:
1948 SQL_TOKEN_CHAR
1949 | SQL_TOKEN_CONCAT
1950 | SQL_TOKEN_DIFFERENCE
1951 | SQL_TOKEN_LOCATE_2
1952 | SQL_TOKEN_SOUNDEX
1953 ;
1954 date_function_0Argument:
1955 SQL_TOKEN_CURDATE
1956 | SQL_TOKEN_CURTIME
1957 | SQL_TOKEN_NOW
1958 ;
1959 date_function_1Argument:
1960 SQL_TOKEN_DAYOFWEEK
1961 | SQL_TOKEN_DAYOFMONTH
1962 | SQL_TOKEN_DAYOFYEAR
1963 | SQL_TOKEN_MONTH
1964 | SQL_TOKEN_DAYNAME
1965 | SQL_TOKEN_MONTHNAME
1966 | SQL_TOKEN_QUARTER
1967 | SQL_TOKEN_HOUR
1968 | SQL_TOKEN_MINUTE
1969 | SQL_TOKEN_SECOND
1970 | SQL_TOKEN_YEAR
1971 | SQL_TOKEN_DAY
1972 | SQL_TOKEN_TIMEVALUE
1973 | SQL_TOKEN_DATEVALUE
1974 ;
1975
1976 date_function:
1977 SQL_TOKEN_TIMESTAMPADD
1978 | SQL_TOKEN_TIMESTAMPDIFF
1979 ;
1980 numeric_function_0Argument:
1981 SQL_TOKEN_PI
1982 ;
1983 numeric_function_1Argument:
1984 SQL_TOKEN_ABS
1985 | SQL_TOKEN_ACOS
1986 | SQL_TOKEN_ASIN
1987 | SQL_TOKEN_ATAN
1988 | SQL_TOKEN_CEILING
1989 | SQL_TOKEN_COS
1990 | SQL_TOKEN_COT
1991 | SQL_TOKEN_DEGREES
1992 | SQL_TOKEN_FLOOR
1993 | SQL_TOKEN_SIGN
1994 | SQL_TOKEN_SIN
1995 | SQL_TOKEN_SQRT
1996 | SQL_TOKEN_TAN
1997 | SQL_TOKEN_EXP
1998 | SQL_TOKEN_LOG10
1999 | SQL_TOKEN_LN
2000 | SQL_TOKEN_RADIANS
2001 | SQL_TOKEN_ROUNDMAGIC
2002 ;
2003 numeric_function_2Argument:
2004 SQL_TOKEN_ATAN2
2005 | SQL_TOKEN_MOD
2006 | SQL_TOKEN_POWER
2007 ;
2008 numeric_function:
2009 SQL_TOKEN_RAND
2010 | SQL_TOKEN_TRUNCATE
2011 ;
2012
2013 window_function:
2014 window_function_type SQL_TOKEN_OVER window_name_or_specification
2015 {
2016 $$ = SQL_NEW_RULE;
2017 $$->append($1);
2018 $$->append($2);
2019 $$->append($3);
2020 }
2021 ;
2022 window_function_type :
2023 rank_function_type '(' ')'
2024 {
2025 $$ = SQL_NEW_RULE;
2026 $$->append($1);
2027 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2028 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
2029 }
2030 | SQL_TOKEN_ROW_NUMBER '(' ')'
2031 {
2032 $$ = SQL_NEW_RULE;
2033 $$->append($1);
2034 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2035 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
2036 }
2037 | general_set_fct
2038 | ntile_function
2039 | lead_or_lag_function
2040 | first_or_last_value_function
2041 | nth_value_function
2042 ;
2043 ntile_function :
2044 SQL_TOKEN_NTILE '(' number_of_tiles ')'
2045 {
2046 $$ = SQL_NEW_RULE;
2047 $$->append($1);
2048 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2049 $$->append($3);
2050 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
2051 }
2052 ;
2053 dynamic_parameter_specification:
2054 parameter
2055 ;
2056 simple_value_specification:
2057 literal
2058 ;
2059 number_of_tiles :
2060 simple_value_specification
2061 | dynamic_parameter_specification
2062 ;
2063 opt_lead_or_lag_function:
2064 /* empty */ {$$ = SQL_NEW_RULE;}
2065 | ',' offset
2066 {
2067 $$ = SQL_NEW_RULE;
2068 $$->append($1 = newNode(",", SQL_NODE_PUNCTUATION));
2069 $$->append($2);
2070 }
2071 | ',' offset ',' default_expression
2072 {
2073 $$ = SQL_NEW_RULE;
2074 $$->append($1 = newNode(",", SQL_NODE_PUNCTUATION));
2075 $$->append($2);
2076 $$->append($3 = newNode(",", SQL_NODE_PUNCTUATION));
2077 $$->append($4);
2078 }
2079 ;
2080 opt_null_treatment:
2081 /* empty */ {$$ = SQL_NEW_RULE;}
2082 | null_treatment
2083 ;
2084
2085 lead_or_lag_function:
2086 lead_or_lag '(' lead_or_lag_extent opt_lead_or_lag_function ')' opt_null_treatment
2087 {
2088 $$ = SQL_NEW_RULE;
2089 $$->append($1);
2090 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2091 $$->append($3);
2092 $$->append($4);
2093 $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION));
2094 $$->append($6);
2095 }
2096 ;
2097 lead_or_lag:
2098 SQL_TOKEN_LEAD
2099 | SQL_TOKEN_LAG
2100 ;
2101 lead_or_lag_extent:
2102 value_exp
2103 ;
2104 offset:
2105 SQL_TOKEN_INTNUM
2106 ;
2107 default_expression:
2108 value_exp
2109 ;
2110 null_treatment:
2111 SQL_TOKEN_RESPECT SQL_TOKEN_NULLS
2112 | SQL_TOKEN_IGNORE SQL_TOKEN_NULLS
2113 ;
2114 first_or_last_value_function:
2115 first_or_last_value '(' value_exp ')' opt_null_treatment
2116 {
2117 $$ = SQL_NEW_RULE;
2118 $$->append($1);
2119 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2120 $$->append($3);
2121 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
2122 $$->append($5);
2123 }
2124 ;
2125 first_or_last_value :
2126 SQL_TOKEN_FIRST_VALUE
2127 | SQL_TOKEN_LAST_VALUE
2128 ;
2129 opt_from_first_or_last:
2130 /* empty */ {$$ = SQL_NEW_RULE;}
2131 | from_first_or_last
2132 ;
2133 nth_value_function:
2134 SQL_TOKEN_NTH_VALUE '(' value_exp ',' nth_row ')' opt_from_first_or_last opt_null_treatment
2135 {
2136 $$ = SQL_NEW_RULE;
2137 $$->append($1);
2138 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2139 $$->append($3);
2140 $$->append($4 = newNode(",", SQL_NODE_PUNCTUATION));
2141 $$->append($5);
2142 $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION));
2143 $$->append($7);
2144 $$->append($8);
2145 }
2146 ;
2147 nth_row:
2148 simple_value_specification
2149 | dynamic_parameter_specification
2150 ;
2151 from_first_or_last:
2152 SQL_TOKEN_FROM SQL_TOKEN_FIRST
2153 {
2154 $$ = SQL_NEW_RULE;
2155 $$->append($1);
2156 $$->append($2);
2157 }
2158 | SQL_TOKEN_FROM SQL_TOKEN_LAST
2159 {
2160 $$ = SQL_NEW_RULE;
2161 $$->append($1);
2162 $$->append($2);
2163 }
2164 ;
2165 window_name:
2166 SQL_TOKEN_NAME
2167 ;
2168 window_name_or_specification:
2169 window_name
2170 | in_line_window_specification
2171 ;
2172 in_line_window_specification:
2173 window_specification
2174 ;
2175 opt_window_clause:
2176 /* empty */ {$$ = SQL_NEW_RULE;}
2177 | window_clause
2178 ;
2179 window_clause:
2180 SQL_TOKEN_WINDOW window_definition_list
2181 {
2182 $$ = SQL_NEW_RULE;
2183 $$->append($1);
2184 $$->append($2);
2185 }
2186 ;
2187 window_definition_list:
2188 window_definition_list ',' window_definition
2189 {$1->append($3);
2190 $$ = $1;}
2191 | window_definition
2192 {$$ = SQL_NEW_COMMALISTRULE;
2193 $$->append($1);}
2194 ;
2195 window_definition:
2196 new_window_name SQL_TOKEN_AS window_specification
2197 {
2198 $$ = SQL_NEW_RULE;
2199 $$->append($1);
2200 $$->append($2);
2201 $$->append($3);
2202 }
2203 ;
2204 new_window_name:
2205 window_name
2206 ;
2207 window_specification:
2208 '(' window_specification_details ')'
2209 {
2210 $$ = SQL_NEW_RULE;
2211 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
2212 $$->append($2);
2213 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
2214 }
2215 ;
2216 opt_existing_window_name:
2217 /* empty */ {$$ = SQL_NEW_RULE;}
2218 | existing_window_name
2219 ;
2220 opt_window_partition_clause:
2221 /* empty */ {$$ = SQL_NEW_RULE;}
2222 | window_partition_clause
2223 ;
2224 opt_window_frame_clause:
2225 /* empty */ {$$ = SQL_NEW_RULE;}
2226 | window_frame_clause
2227 ;
2228 window_specification_details:
2229 opt_existing_window_name
2230 opt_window_partition_clause
2231 opt_order_by_clause
2232 opt_window_frame_clause
2233 ;
2234 existing_window_name:
2235 window_name
2236 ;
2237 window_partition_clause:
2238 SQL_TOKEN_PARTITION SQL_TOKEN_BY window_partition_column_reference_list
2239 {
2240 $$ = SQL_NEW_RULE;
2241 $$->append($1);
2242 $$->append($2);
2243 $$->append($3);
2244 }
2245 ;
2246 window_partition_column_reference_list:
2247 window_partition_column_reference_list ',' window_partition_column_reference
2248 {$1->append($3);
2249 $$ = $1;}
2250 | window_partition_column_reference
2251 {$$ = SQL_NEW_COMMALISTRULE;
2252 $$->append($1);}
2253 ;
2254 window_partition_column_reference:
2255 column_ref opt_collate_clause
2256 {
2257 $$ = SQL_NEW_RULE;
2258 $$->append($1);
2259 $$->append($2);
2260 }
2261 ;
2262 opt_window_frame_exclusion:
2263 /* empty */ {$$ = SQL_NEW_RULE;}
2264 | window_frame_exclusion
2265 ;
2266 window_frame_clause:
2267 window_frame_units window_frame_extent opt_window_frame_exclusion
2268 {
2269 $$ = SQL_NEW_RULE;
2270 $$->append($1);
2271 $$->append($2);
2272 $$->append($3);
2273 }
2274 ;
2275 window_frame_units:
2276 SQL_TOKEN_ROWS
2277 | SQL_TOKEN_RANGE
2278 ;
2279 window_frame_extent:
2280 window_frame_start
2281 | window_frame_between
2282 ;
2283 window_frame_start:
2284 SQL_TOKEN_UNBOUNDED SQL_TOKEN_PRECEDING
2285 {
2286 $$ = SQL_NEW_RULE;
2287 $$->append($1);
2288 $$->append($2);
2289 }
2290 | window_frame_preceding
2291 | SQL_TOKEN_CURRENT SQL_TOKEN_ROW
2292 {
2293 $$ = SQL_NEW_RULE;
2294 $$->append($1);
2295 $$->append($2);
2296 }
2297 ;
2298 window_frame_preceding:
2299 unsigned_value_spec SQL_TOKEN_PRECEDING
2300 {
2301 $$ = SQL_NEW_RULE;
2302 $$->append($1);
2303 $$->append($2);
2304 }
2305 ;
2306 window_frame_between:
2307 SQL_TOKEN_BETWEEN window_frame_bound_1 SQL_TOKEN_AND window_frame_bound_2
2308 {
2309 $$ = SQL_NEW_RULE;
2310 $$->append($1);
2311 $$->append($2);
2312 $$->append($3);
2313 $$->append($4);
2314 }
2315 ;
2316 window_frame_bound_1:
2317 window_frame_bound
2318 ;
2319 window_frame_bound_2:
2320 window_frame_bound
2321 ;
2322 window_frame_bound:
2323 window_frame_start
2324 | SQL_TOKEN_UNBOUNDED SQL_TOKEN_FOLLOWING
2325 {
2326 $$ = SQL_NEW_RULE;
2327 $$->append($1);
2328 $$->append($2);
2329 }
2330 | window_frame_following
2331 ;
2332 window_frame_following:
2333 unsigned_value_spec SQL_TOKEN_FOLLOWING
2334 {
2335 $$ = SQL_NEW_RULE;
2336 $$->append($1);
2337 $$->append($2);
2338 }
2339 ;
2340 window_frame_exclusion:
2341 SQL_TOKEN_EXCLUDE SQL_TOKEN_CURRENT SQL_TOKEN_ROW
2342 {
2343 $$ = SQL_NEW_RULE;
2344 $$->append($1);
2345 $$->append($2);
2346 $$->append($3);
2347 }
2348 | SQL_TOKEN_EXCLUDE SQL_TOKEN_GROUP
2349 {
2350 $$ = SQL_NEW_RULE;
2351 $$->append($1);
2352 $$->append($2);
2353 }
2354 | SQL_TOKEN_EXCLUDE SQL_TOKEN_TIES
2355 {
2356 $$ = SQL_NEW_RULE;
2357 $$->append($1);
2358 $$->append($2);
2359 }
2360 | SQL_TOKEN_EXCLUDE SQL_TOKEN_NO SQL_TOKEN_OTHERS
2361 {
2362 $$ = SQL_NEW_RULE;
2363 $$->append($1);
2364 $$->append($2);
2365 $$->append($3);
2366 }
2367 ;
2368 op_parameter:
2369 {$$ = SQL_NEW_RULE;}
2370 | '?' SQL_EQUAL
2371 {
2372 $$ = SQL_NEW_RULE;
2373 $$->append($1 = newNode("?", SQL_NODE_PUNCTUATION));
2374 $$->append($2);
2375 }
2376 ;
2377 odbc_call_spec:
2378 op_parameter SQL_TOKEN_CALL table_node op_odbc_call_parameter
2379 {
2380 $$ = SQL_NEW_RULE;
2381 $$->append($1);
2382 $$->append($2);
2383 $$->append($3);
2384 $$->append($4);
2385 }
2386 ;
2387
2388 op_odbc_call_parameter:
2389 {$$ = SQL_NEW_RULE;}
2390 | '(' odbc_parameter_commalist ')'
2391 {
2392 $$ = SQL_NEW_RULE;
2393 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
2394 $$->append($2);
2395 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
2396 }
2397 ;
2398
2399 odbc_parameter_commalist:
2400 odbc_parameter
2401 {$$ = SQL_NEW_COMMALISTRULE;
2402 $$->append($1);}
2403 | odbc_parameter_commalist ',' odbc_parameter
2404 {
2405 $1->append($3);
2406 $$ = $1;
2407 }
2408 ;
2409 odbc_parameter:
2410 /* empty */ {$$ = SQL_NEW_RULE;}
2411 | literal
2412 | parameter
2413 ;
2414
2415 odbc_fct_spec:
2416 odbc_fct_type SQL_TOKEN_STRING
2417 {
2418 $$ = SQL_NEW_RULE;
2419 $$->append($1);
2420 $$->append($2);
2421 }
2422 | SQL_TOKEN_FN set_fct_spec
2423 {
2424 $$ = SQL_NEW_RULE;
2425 $$->append($1);
2426 $$->append($2);
2427 }
2428 ;
2429
2430 odbc_fct_type:
2431 SQL_TOKEN_D
2432 | SQL_TOKEN_T
2433 | SQL_TOKEN_TS
2434 ;
2435
2436 general_set_fct:
2437 set_fct_type '(' opt_all_distinct function_arg ')'
2438 {
2439 $$ = SQL_NEW_RULE;
2440 $$->append($1);
2441 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2442 $$->append($3);
2443 $$->append($4);
2444 $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION));
2445 }
2446 | SQL_TOKEN_COUNT '(' '*' ')'
2447 {
2448 $$ = SQL_NEW_RULE;
2449 $$->append($1);
2450 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2451 $$->append($3 = newNode("*", SQL_NODE_PUNCTUATION));
2452 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
2453 }
2454 | SQL_TOKEN_COUNT '(' opt_all_distinct function_arg ')'
2455 {
2456 $$ = SQL_NEW_RULE;
2457 $$->append($1);
2458 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2459 $$->append($3);
2460 $$->append($4);
2461 $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION));
2462 }
2463 | ordered_set_function
2464 | array_aggregate_function
2465 ;
2466 set_fct_type:
2467 SQL_TOKEN_AVG
2468 | SQL_TOKEN_MAX
2469 | SQL_TOKEN_MIN
2470 | SQL_TOKEN_SUM
2471 | SQL_TOKEN_EVERY
2472 | SQL_TOKEN_ANY
2473 | SQL_TOKEN_SOME
2474 | SQL_TOKEN_STDDEV_POP
2475 | SQL_TOKEN_STDDEV_SAMP
2476 | SQL_TOKEN_VAR_SAMP
2477 | SQL_TOKEN_VAR_POP
2478 | SQL_TOKEN_COLLECT
2479 | SQL_TOKEN_FUSION
2480 | SQL_TOKEN_INTERSECTION
2481 ;
2482
2483 ordered_set_function:
2484 hypothetical_set_function
2485 | inverse_distribution_function
2486 ;
2487 hypothetical_set_function:
2488 rank_function_type '(' hypothetical_set_function_value_expression_list ')' within_group_specification
2489 {
2490 $$ = SQL_NEW_RULE;
2491 $$->append($1);
2492 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2493 $$->append($3);
2494 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
2495 $$->append($5);
2496 }
2497 | rank_function_type '(' hypothetical_set_function_value_expression_list SQL_TOKEN_BY value_exp_commalist ')' within_group_specification
2498 {
2499 $$ = SQL_NEW_RULE;
2500 $$->append($1);
2501 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2502 $$->append($3);
2503 $$->append($4);
2504 $$->append($5);
2505 $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION));
2506 $$->append($7);
2507 }
2508 ;
2509
2510 within_group_specification:
2511 {
2512 $$ = SQL_NEW_RULE;
2513 }
2514 | SQL_TOKEN_WITHIN SQL_TOKEN_GROUP '(' opt_order_by_clause ')'
2515 {
2516 $$ = SQL_NEW_RULE;
2517 $$->append($1);
2518 $$->append($2);
2519 $$->append($3 = newNode("(", SQL_NODE_PUNCTUATION));
2520 $$->append($4);
2521 $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION));
2522 }
2523 ;
2524 hypothetical_set_function_value_expression_list:
2525 value_exp_commalist
2526 ;
2527
2528 inverse_distribution_function:
2529 inverse_distribution_function_type '('inverse_distribution_function_argument ')' within_group_specification
2530 {
2531 $$ = SQL_NEW_RULE;
2532 $$->append($1);
2533 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2534 $$->append($3);
2535 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
2536 }
2537 ;
2538 inverse_distribution_function_argument:
2539 num_value_exp
2540 ;
2541 inverse_distribution_function_type:
2542 SQL_TOKEN_PERCENTILE_CONT
2543 | SQL_TOKEN_PERCENTILE_DISC
2544 ;
2545
2546 array_aggregate_function:
2547 SQL_TOKEN_ARRAY_AGG '(' value_exp opt_order_by_clause ')'
2548 {
2549 $$ = SQL_NEW_RULE;
2550 $$->append($1);
2551 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2552 $$->append($3);
2553 $$->append($4);
2554 $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION));
2555 }
2556 ;
2557
2558 rank_function_type:
2559 SQL_TOKEN_RANK
2560 | SQL_TOKEN_DENSE_RANK
2561 | SQL_TOKEN_PERCENT_RANK
2562 | SQL_TOKEN_CUME_DIST
2563 ;
2564 outer_join_type:
2565 SQL_TOKEN_LEFT %prec SQL_TOKEN_LEFT
2566 {
2567 $$ = SQL_NEW_RULE;
2568 $$->append($1);
2569 }
2570 | SQL_TOKEN_RIGHT %prec SQL_TOKEN_RIGHT
2571 {
2572 $$ = SQL_NEW_RULE;
2573 $$->append($1);
2574 }
2575 | SQL_TOKEN_FULL %prec SQL_TOKEN_FULL
2576 {
2577 $$ = SQL_NEW_RULE;
2578 $$->append($1);
2579 }
2580 ;
2581 join_condition:
2582 SQL_TOKEN_ON search_condition
2583 {
2584 $$ = SQL_NEW_RULE;
2585 $$->append($1);
2586 $$->append($2);
2587 }
2588 ;
2589 join_spec:
2590 join_condition
2591 | named_columns_join
2592 ;
2593 join_type:
2594 /* empty */ {$$ = SQL_NEW_RULE;}
2595 | SQL_TOKEN_INNER
2596 {
2597 $$ = SQL_NEW_RULE;
2598 $$->append($1);
2599 }
2600 | outer_join_type
2601 | outer_join_type SQL_TOKEN_OUTER
2602 {
2603 $$ = SQL_NEW_RULE;
2604 $$->append($1);
2605 $$->append($2);
2606 }
2607 ;
2608 cross_union:
2609 table_ref SQL_TOKEN_CROSS SQL_TOKEN_JOIN table_ref
2610 {
2611 $$ = SQL_NEW_RULE;
2612 $$->append($1);
2613 $$->append($2);
2614 $$->append($3);
2615 $$->append($4);
2616 }
2617 ;
2618
2619 qualified_join:
2620 /* wenn SQL_TOKEN_NATURAL, dann keine join_spec */
2621 table_ref SQL_TOKEN_NATURAL join_type SQL_TOKEN_JOIN table_ref
2622 {
2623 $$ = SQL_NEW_RULE;
2624 $$->append($1);
2625 $$->append($2);
2626 $$->append($3);
2627 $$->append($4);
2628 $$->append($5);
2629 }
2630 | table_ref join_type SQL_TOKEN_JOIN table_ref join_spec
2631 {
2632 $$ = SQL_NEW_RULE;
2633 $$->append($1);
2634 $$->append($2);
2635 $$->append($3);
2636 $$->append($4);
2637 $$->append($5);
2638 }
2639 | cross_union
2640 ;
2641 joined_table:
2642 qualified_join
2643 ;
2644 named_columns_join:
2645 SQL_TOKEN_USING '(' column_commalist ')'
2646 {
2647 $$ = SQL_NEW_RULE;
2648 $$->append($1);
2649 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2650 $$->append($3);
2651 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
2652 }
2653 ;
2654 simple_table:
2655 select_statement
2656 | values_or_query_spec
2657 ;
2658
2659 non_join_query_primary:
2660 simple_table
2661 | '(' non_join_query_exp ')'
2662 {
2663 $$ = SQL_NEW_RULE;
2664 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
2665 $$->append($2);
2666 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
2667 }
2668 ;
2669 non_join_query_term:
2670 non_join_query_primary
2671 | query_term SQL_TOKEN_INTERSECT all query_primary
2672 {
2673 $$ = SQL_NEW_RULE;
2674 $$->append($1);
2675 $$->append($2);
2676 $$->append($3);
2677 $$->append($4);
2678 }
2679 ;
2680 query_primary:
2681 non_join_query_primary
2682 ;
2683 non_join_query_exp:
2684 non_join_query_term
2685 | query_exp SQL_TOKEN_UNION all query_term
2686 {
2687 $$ = SQL_NEW_RULE;
2688 $$->append($1);
2689 $$->append($2);
2690 $$->append($3);
2691 $$->append($4);
2692 }
2693 | query_exp SQL_TOKEN_EXCEPT all query_term
2694 {
2695 $$ = SQL_NEW_RULE;
2696 $$->append($1);
2697 $$->append($2);
2698 $$->append($3);
2699 $$->append($4);
2700 }
2701 ;
2702 all:
2703 /* empty*/ {$$ = SQL_NEW_RULE;}
2704 | SQL_TOKEN_ALL
2705 ;
2706 query_exp:
2707 non_join_query_exp /*[^')']*/
2708 ;
2709 scalar_subquery:
2710 subquery
2711 ;
2712 cast_operand:
2713 value_exp
2714 ;
2715 cast_target:
2716 table_node
2717 | data_type
2718 ;
2719 cast_spec:
2720 SQL_TOKEN_CAST '(' cast_operand SQL_TOKEN_AS cast_target ')'
2721 {
2722 $$ = SQL_NEW_RULE;
2723 $$->append($1);
2724 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
2725 $$->append($3);
2726 $$->append($4);
2727 $$->append($5);
2728 $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION));
2729 }
2730 ;
2731 value_exp_primary:
2732 unsigned_value_spec
2733 | column_ref
2734 | set_fct_spec
2735 | scalar_subquery
2736 | case_expression
2737 | window_function
2738 | '(' value_exp ')'
2739 {
2740 $$ = SQL_NEW_RULE;
2741 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
2742 $$->append($2);
2743 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
2744 }
2745 | cast_spec
2746 ;
2747
2748 num_primary:
2749 value_exp_primary
2750 | num_value_fct
2751 ;
2752 factor:
2753 num_primary
2754 | '-' num_primary %prec SQL_TOKEN_UMINUS
2755 {
2756 $$ = SQL_NEW_RULE;
2757 $$->append($1 = newNode("-", SQL_NODE_PUNCTUATION));
2758 $$->append($2);
2759 }
2760 | '+' num_primary %prec SQL_TOKEN_UMINUS
2761 {
2762 $$ = SQL_NEW_RULE;
2763 $$->append($1 = newNode("+", SQL_NODE_PUNCTUATION));
2764 $$->append($2);
2765 }
2766 ;
2767
2768 term:
2769 factor
2770 | term '*' factor
2771 {
2772 $$ = SQL_NEW_RULE;
2773 $$->append($1);
2774 $$->append($2 = newNode("*", SQL_NODE_PUNCTUATION));
2775 $$->append($3);
2776 }
2777 | term '/' factor
2778 {
2779 $$ = SQL_NEW_RULE;
2780 $$->append($1);
2781 $$->append($2 = newNode("/", SQL_NODE_PUNCTUATION));
2782 $$->append($3);
2783 }
2784 ;
2785
2786 num_value_exp:
2787 term
2788 | num_value_exp '+' term
2789 {
2790 $$ = SQL_NEW_RULE;
2791 $$->append($1);
2792 $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION));
2793 $$->append($3);
2794 }
2795 | num_value_exp '-' term
2796 {
2797 $$ = SQL_NEW_RULE;
2798 $$->append($1);
2799 $$->append($2 = newNode("-", SQL_NODE_PUNCTUATION));
2800 $$->append($3);
2801 }
2802 ;
2803 datetime_primary:
2804 /* value_exp_primary
2805 {
2806 $$ = SQL_NEW_RULE;
2807 $$->append($1);
2808 }
2809 |*/ datetime_value_fct
2810 {
2811 $$ = SQL_NEW_RULE;
2812 $$->append($1);
2813 }
2814 ;
2815 datetime_value_fct:
2816 SQL_TOKEN_CURRENT_DATE
2817 {
2818 $$ = SQL_NEW_RULE;
2819 $$->append($1);
2820 }
2821 | SQL_TOKEN_CURRENT_TIME
2822 {
2823 $$ = SQL_NEW_RULE;
2824 $$->append($1);
2825 }
2826 | SQL_TOKEN_CURRENT_TIMESTAMP
2827 {
2828 $$ = SQL_NEW_RULE;
2829 $$->append($1);
2830 }
2831 ;
2832 time_zone:
2833 SQL_TOKEN_AT time_zone_specifier
2834 {
2835 $$ = SQL_NEW_RULE;
2836 $$->append($1);
2837 $$->append($2);
2838 }
2839 ;
2840 time_zone_specifier:
2841 SQL_TOKEN_LOCAL
2842 {
2843 $$ = SQL_NEW_RULE;
2844 $$->append($1);
2845 }
2846 /* | SQL_TOKEN_TIME SQL_TOKEN_ZONE interval_value_exp
2847 {
2848 $$ = SQL_NEW_RULE;
2849 $$->append($1);
2850 $$->append($2);
2851 $$->append($3);
2852 }*/
2853 ;
2854 datetime_factor:
2855 datetime_primary
2856 {
2857 $$ = SQL_NEW_RULE;
2858 $$->append($1);
2859 }
2860 | datetime_primary time_zone
2861 {
2862 $$ = SQL_NEW_RULE;
2863 $$->append($1);
2864 $$->append($2);
2865 }
2866 ;
2867 datetime_term:
2868 datetime_factor
2869 {
2870 $$ = SQL_NEW_RULE;
2871 $$->append($1);
2872 }
2873 ;
2874 /*
2875 interval_term:
2876 literal
2877 | interval_term '*' factor
2878 {
2879 $$ = SQL_NEW_RULE;
2880 $$->append($1);
2881 $$->append($2 = newNode("*", SQL_NODE_PUNCTUATION));
2882 $$->append($3);
2883 }
2884 | interval_term '/' factor
2885 {
2886 $$ = SQL_NEW_RULE;
2887 $$->append($1);
2888 $$->append($2 = newNode("/", SQL_NODE_PUNCTUATION));
2889 $$->append($3);
2890 }
2891 ;
2892 */
2893 datetime_value_exp:
2894 datetime_term
2895 {
2896 $$ = SQL_NEW_RULE;
2897 $$->append($1);
2898 }
2899 /* | interval_value_exp '+' datetime_term
2900 {
2901 $$ = SQL_NEW_RULE;
2902 $$->append($1);
2903 $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION));
2904 $$->append($3);
2905 }
2906 | datetime_value_exp '+' interval_term
2907 {
2908 $$ = SQL_NEW_RULE;
2909 $$->append($1);
2910 $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION));
2911 $$->append($3);
2912 }
2913 | datetime_value_exp '-' interval_term
2914 {
2915 $$ = SQL_NEW_RULE;
2916 $$->append($1);
2917 $$->append($2 = newNode("-", SQL_NODE_PUNCTUATION));
2918 $$->append($3);
2919 }
2920 */ ;
2921 /*
2922 interval_value_exp:
2923 interval_term
2924 {
2925 $$ = SQL_NEW_RULE;
2926 $$->append($1);
2927 }
2928 | interval_value_exp '+' interval_term
2929 {
2930 $$ = SQL_NEW_RULE;
2931 $$->append($1);
2932 $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION));
2933 $$->append($3);
2934 }
2935 | interval_value_exp '-' interval_term
2936 {
2937 $$ = SQL_NEW_RULE;
2938 $$->append($1);
2939 $$->append($2 = newNode("-", SQL_NODE_PUNCTUATION));
2940 $$->append($3);
2941 }
2942 | '(' datetime_value_exp '-' datetime_term ')' interval_qualifier
2943 {
2944 $$ = SQL_NEW_RULE;
2945 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
2946 $$->append($2);
2947 $$->append($3 = newNode("-", SQL_NODE_PUNCTUATION));
2948 $$->append($4);
2949 $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION));
2950 $$->append($6);
2951 }
2952 ;
2953 */
2954 non_second_datetime_field:
2955 SQL_TOKEN_YEAR
2956 | SQL_TOKEN_MONTH
2957 | SQL_TOKEN_DAY
2958 | SQL_TOKEN_HOUR
2959 | SQL_TOKEN_MINUTE
2960 ;
2961 start_field:
2962 non_second_datetime_field opt_paren_precision
2963 {
2964 $$ = SQL_NEW_RULE;
2965 $$->append($1);
2966 $$->append($2);
2967 }
2968 ;
2969 end_field:
2970 non_second_datetime_field
2971 | SQL_TOKEN_SECOND opt_paren_precision
2972 {
2973 $$ = SQL_NEW_RULE;
2974 $$->append($1);
2975 $$->append($2);
2976 }
2977 ;
2978
2979 single_datetime_field:
2980 non_second_datetime_field opt_paren_precision
2981 {
2982 $$ = SQL_NEW_RULE;
2983 $$->append($1);
2984 $$->append($2);
2985 }
2986 | SQL_TOKEN_SECOND opt_paren_precision_scale
2987 {
2988 $$ = SQL_NEW_RULE;
2989 $$->append($1);
2990 $$->append($2);
2991 }
2992 ;
2993
2994 interval_qualifier:
2995 start_field SQL_TOKEN_TO end_field
2996 {
2997 $$ = SQL_NEW_RULE;
2998 $$->append($1);
2999 $$->append($2);
3000 $$->append($3);
3001 }
3002 | single_datetime_field
3003 ;
3004
3005 function_arg_commalist2:
3006 function_arg ',' function_arg
3007 {$$ = SQL_NEW_COMMALISTRULE;
3008 $$->append($1);
3009 $$->append($3);}
3010 ;
3011 function_arg_commalist3:
3012 function_arg ',' function_arg ',' function_arg
3013 {
3014 $$ = SQL_NEW_COMMALISTRULE;
3015 $$->append($1);
3016 $$->append($3);
3017 $$->append($5);
3018 }
3019 ;
3020 function_arg_commalist4:
3021 function_arg ',' function_arg ',' function_arg ',' function_arg
3022 {
3023 $$ = SQL_NEW_COMMALISTRULE;
3024 $$->append($1);
3025 $$->append($3);
3026 $$->append($5);
3027 $$->append($7);
3028 }
3029 ;
3030 value_exp_commalist:
3031 value_exp
3032 {$$ = SQL_NEW_COMMALISTRULE;
3033 $$->append($1);}
3034 | value_exp_commalist ',' value_exp
3035 {$1->append($3);
3036 $$ = $1;}
3037 /* this rule is only valid if we check predicates */
3038 | value_exp_commalist ';' value_exp
3039 {
3040 if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
3041 {
3042 $1->append($3);
3043 $$ = $1;
3044 }
3045 else
3046 YYERROR;
3047 }
3048 ;
3049 function_arg:
3050 result
3051 | value_exp comparison value_exp
3052 {
3053 $$ = SQL_NEW_RULE;
3054 $$->append($1);
3055 $$->append($2);
3056 $$->append($3);
3057 }
3058 | value_exp SQL_TOKEN_USING value_exp comparison value_exp
3059 {
3060 $$ = SQL_NEW_RULE;
3061 $$->append($1);
3062 $$->append($2);
3063 $$->append($3);
3064 $$->append($4);
3065 }
3066 | value_exp SQL_TOKEN_BY value_exp_commalist
3067 {
3068 $$ = SQL_NEW_RULE;
3069 $$->append($1);
3070 $$->append($2);
3071 $$->append($3);
3072 }
3073 ;
3074 function_args_commalist:
3075 function_arg
3076 {$$ = SQL_NEW_COMMALISTRULE;
3077 $$->append($1);}
3078 | function_args_commalist ',' function_arg
3079 {$1->append($3);
3080 $$ = $1;}
3081 /* this rule is only valid if we check predicates */
3082 | function_args_commalist ';' function_arg
3083 {
3084 if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
3085 {
3086 $1->append($3);
3087 $$ = $1;
3088 }
3089 else
3090 YYERROR;
3091 }
3092 ;
3093
3094 value_exp:
3095 num_value_exp /*[^')']*/
3096 | string_value_exp
3097 | datetime_value_exp
3098 {
3099 $$ = SQL_NEW_RULE;
3100 $$->append($1);
3101 }
3102 ;
3103 string_value_exp:
3104 char_value_exp
3105 /* | bit_value_exp
3106 {
3107 $$ = SQL_NEW_RULE;
3108 $$->append($1);
3109 }
3110 */ ;
3111 char_value_exp:
3112 char_factor
3113 | concatenation
3114 ;
3115 concatenation:
3116 char_value_exp '+' char_factor
3117 {
3118 $$ = SQL_NEW_RULE;
3119 $$->append($1);
3120 $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION));
3121 $$->append($3);
3122 }
3123 | value_exp SQL_CONCAT value_exp
3124 {
3125 $$ = SQL_NEW_RULE;
3126 $$->append($1);
3127 $$->append($2);
3128 $$->append($3);
3129 }
3130 ;
3131
3132 char_primary:
3133 SQL_TOKEN_STRING
3134 | string_value_fct
3135 ;
3136 collate_clause:
3137 SQL_TOKEN_COLLATE table_node
3138 {
3139 $$ = SQL_NEW_RULE;
3140 $$->append($1);
3141 $$->append($2);
3142 }
3143 ;
3144 char_factor:
3145 char_primary
3146 | char_primary collate_clause
3147 {
3148 $$ = SQL_NEW_RULE;
3149 $$->append($1);
3150 $$->append($2);
3151 }
3152 ;
3153 string_value_fct:
3154 char_value_fct
3155 | bit_value_fct
3156 ;
3157 bit_value_fct:
3158 bit_substring_fct
3159 {
3160 $$ = SQL_NEW_RULE;
3161 $$->append($1);
3162 }
3163 ;
3164 bit_substring_fct:
3165 SQL_TOKEN_SUBSTRING '(' bit_value_exp SQL_TOKEN_FROM string_value_exp for_length ')'
3166 {
3167 $$ = SQL_NEW_RULE;
3168 $$->append($1);
3169 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
3170 $$->append($3);
3171 $$->append($4);
3172 $$->append($5);
3173 $$->append($6);
3174 $$->append($7 = newNode(")", SQL_NODE_PUNCTUATION));
3175 }
3176 ;
3177 bit_value_exp:
3178 bit_factor
3179 {
3180 $$ = SQL_NEW_RULE;
3181 $$->append($1);
3182 }
3183 ;
3184 /*
3185 bit_concatenation
3186 {
3187 $$ = SQL_NEW_RULE;
3188 $$->append($1);
3189 }
3190 |
3191 bit_concatenation:
3192 bit_value_exp '+' bit_factor
3193 {
3194 $$ = SQL_NEW_RULE;
3195 $$->append($1);
3196 $$->append($2 = newNode("+", SQL_NODE_PUNCTUATION));
3197 $$->append($3);
3198 }
3199 ;
3200 */
3201 bit_factor:
3202 bit_primary
3203 {
3204 $$ = SQL_NEW_RULE;
3205 $$->append($1);
3206 }
3207 ;
3208 bit_primary:
3209 {$$ = SQL_NEW_RULE;}
3210 /* value_exp_primary
3211 {
3212 $$ = SQL_NEW_RULE;
3213 $$->append($1);
3214 }
3215 | string_value_fct
3216 {
3217 $$ = SQL_NEW_RULE;
3218 $$->append($1);
3219 }*/
3220 ;
3221 char_value_fct:
3222 char_substring_fct
3223 | fold
3224 | form_conversion
3225 {
3226 $$ = SQL_NEW_RULE;
3227 $$->append($1);
3228 }
3229 | char_translation
3230 {
3231 $$ = SQL_NEW_RULE;
3232 $$->append($1);
3233 }
3234 | trim_fct
3235 {
3236 $$ = SQL_NEW_RULE;
3237 $$->append($1);
3238 }
3239 ;
3240 for_length:
3241 {$$ = SQL_NEW_RULE;}
3242 | SQL_TOKEN_FOR value_exp
3243 {
3244 $$ = SQL_NEW_RULE;
3245 $$->append($1);
3246 $$->append($2);
3247 }
3248 ;
3249 char_substring_fct:
3250 SQL_TOKEN_SUBSTRING '(' value_exp SQL_TOKEN_FROM value_exp for_length ')'
3251 {
3252 $$ = SQL_NEW_RULE;
3253 $$->append($1);
3254 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
3255 $$->append($3);
3256 $$->append($4);
3257 $$->append($5);
3258 $$->append($6);
3259 $$->append($7 = newNode(")", SQL_NODE_PUNCTUATION));
3260 }
3261 | SQL_TOKEN_SUBSTRING '(' value_exp_commalist ')'
3262 {
3263 $$ = SQL_NEW_RULE;
3264 $$->append($1);
3265 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
3266 $$->append($3);
3267 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
3268 }
3269 ;
3270 upper_lower:
3271 SQL_TOKEN_UPPER
3272 | SQL_TOKEN_LOWER
3273 ;
3274 fold:
3275 upper_lower '(' value_exp ')'
3276 {
3277 $$ = SQL_NEW_RULE;
3278 $$->append($1);
3279 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
3280 $$->append($3);
3281 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
3282 }
3283 ;
3284 form_conversion:
3285 SQL_TOKEN_CONVERT '(' string_value_exp SQL_TOKEN_USING table_node ')'
3286 {
3287 $$ = SQL_NEW_RULE;
3288 $$->append($1);
3289 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
3290 $$->append($3);
3291 $$->append($4);
3292 $$->append($5);
3293 $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION));
3294 }
3295 | SQL_TOKEN_CONVERT '(' cast_operand ',' cast_target ')'
3296 {
3297 $$ = SQL_NEW_RULE;
3298 $$->append($1);
3299 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
3300 $$->append($3);
3301 $$->append($2 = newNode(",", SQL_NODE_PUNCTUATION));
3302 $$->append($5);
3303 $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION));
3304 }
3305 ;
3306 char_translation:
3307 SQL_TOKEN_TRANSLATE '(' string_value_exp SQL_TOKEN_USING table_node ')'
3308 {
3309 $$ = SQL_NEW_RULE;
3310 $$->append($1);
3311 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
3312 $$->append($3);
3313 $$->append($4);
3314 $$->append($5);
3315 $$->append($6 = newNode(")", SQL_NODE_PUNCTUATION));
3316 }
3317 ;
3318 trim_fct:
3319 SQL_TOKEN_TRIM '(' trim_operands ')'
3320 {
3321 $$ = SQL_NEW_RULE;
3322 $$->append($1);
3323 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
3324 $$->append($3);
3325 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
3326 }
3327 ;
3328 trim_operands:
3329 trim_spec value_exp SQL_TOKEN_FROM value_exp
3330 {
3331 $$ = SQL_NEW_RULE;
3332 $$->append($1);
3333 $$->append($2);
3334 $$->append($3);
3335 $$->append($4);
3336 }
3337 | trim_spec SQL_TOKEN_FROM value_exp
3338 {
3339 $$ = SQL_NEW_RULE;
3340 $$->append($1);
3341 $$->append($2);
3342 $$->append($3);
3343 }
3344 | value_exp SQL_TOKEN_FROM value_exp
3345 {
3346 $$ = SQL_NEW_RULE;
3347 $$->append($1);
3348 $$->append($2);
3349 $$->append($3);
3350 }
3351 | SQL_TOKEN_FROM value_exp
3352 {
3353 $$ = SQL_NEW_RULE;
3354 $$->append($1);
3355 $$->append($2);
3356 }
3357 | value_exp
3358 ;
3359
3360 trim_spec:
3361 SQL_TOKEN_BOTH
3362 | SQL_TOKEN_LEADING
3363 | SQL_TOKEN_TRAILING
3364 ;
3365
3366 derived_column:
3367 value_exp as_clause
3368 {
3369 $$ = SQL_NEW_RULE;
3370 $$->append($1);
3371 $$->append($2);
3372 }
3373 ;
3374 /* Tabellenname */
3375 table_node:
3376 table_name
3377 | schema_name
3378 | catalog_name
3379 ;
3380 catalog_name:
3381 SQL_TOKEN_NAME '.' schema_name
3382 {
3383 $$ = SQL_NEW_RULE;
3384 $$->append($1);
3385 $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION));
3386 $$->append($3);
3387 }
3388 | SQL_TOKEN_NAME ':' schema_name
3389 {
3390 $$ = SQL_NEW_RULE;
3391 $$->append($1);
3392 $$->append($2 = newNode(":", SQL_NODE_PUNCTUATION));
3393 $$->append($3);
3394 }
3395 ;
3396 schema_name:
3397 SQL_TOKEN_NAME '.' table_name
3398 {
3399 $$ = SQL_NEW_RULE;
3400 $$->append($1);
3401 $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION));
3402 $$->append($3);
3403 }
3404 ;
3405
3406 table_name:
3407 SQL_TOKEN_NAME
3408 {$$ = SQL_NEW_RULE;
3409 $$->append($1);}
3410 ;
3411 /* Columns */
3412 column_ref:
3413 column
3414 {$$ = SQL_NEW_RULE;
3415 $$->append($1);}
3416 /* | table_node '.' column_val %prec '.'
3417 {$$ = SQL_NEW_RULE;
3418 $$->append($1);
3419 $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION));
3420 $$->append($3);}
3421 */
3422 | SQL_TOKEN_NAME '.' column_val %prec '.'
3423 {$$ = SQL_NEW_RULE;
3424 $$->append($1);
3425 $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION));
3426 $$->append($3);
3427 }
3428 | SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' column_val %prec '.'
3429 {$$ = SQL_NEW_RULE;
3430 $$->append($1);
3431 $$->append($2 = newNode(".", SQL_NODE_PUNCTUATION));
3432 $$->append($3);
3433 $$->append($4 = newNode(".", SQL_NODE_PUNCTUATION));
3434 $$->append($5);}
3435 | SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' column_val %prec '.'
3436 {$$ = SQL_NEW_RULE;
3437 $$->append($1);
3438 $$->append($2= newNode(".", SQL_NODE_PUNCTUATION));
3439 $$->append($3);
3440 $$->append($4 = newNode(".", SQL_NODE_PUNCTUATION));
3441 $$->append($5);
3442 $$->append($6 = newNode(".", SQL_NODE_PUNCTUATION));
3443 $$->append($7);
3444 }
3445 | SQL_TOKEN_NAME ':' SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' column_val %prec '.'
3446 {$$ = SQL_NEW_RULE;
3447 $$->append($1);
3448 $$->append($2= newNode(":", SQL_NODE_PUNCTUATION));
3449 $$->append($3);
3450 $$->append($4 = newNode(".", SQL_NODE_PUNCTUATION));
3451 $$->append($5);
3452 $$->append($6 = newNode(".", SQL_NODE_PUNCTUATION));
3453 $$->append($7);
3454 }
3455 /* | SQL_TOKEN_NAME ';' SQL_TOKEN_NAME '.' SQL_TOKEN_NAME '.' column_val
3456 {$$ = SQL_NEW_RULE;
3457 $$->append($1);
3458 $$->append($2= newNode(";", SQL_NODE_PUNCTUATION));
3459 $$->append($3);
3460 $$->append($4 = newNode(".", SQL_NODE_PUNCTUATION));
3461 $$->append($5);
3462 $$->append($6 = newNode(".", SQL_NODE_PUNCTUATION));
3463 $$->append($7);
3464 }
3465 */ ;
3466
3467 /* data types */
3468 column_val:
3469 column
3470 {$$ = SQL_NEW_RULE;
3471 $$->append($1);}
3472 | '*'
3473 {
3474 $$ = SQL_NEW_RULE;
3475 $$->append($1 = newNode("*", SQL_NODE_PUNCTUATION));
3476 }
3477 ;
3478 data_type:
3479 predefined_type
3480 ;
3481 opt_char_set_spec:
3482 {$$ = SQL_NEW_RULE;}
3483 | SQL_TOKEN_CHARACTER SQL_TOKEN_SET SQL_TOKEN_NAME
3484 {
3485 $$ = SQL_NEW_RULE;
3486 $$->append($1);
3487 $$->append($2);
3488 $$->append($3);
3489 }
3490 ;
3491 opt_collate_clause:
3492 {$$ = SQL_NEW_RULE;}
3493 | collate_clause
3494 ;
3495 predefined_type:
3496 character_string_type opt_char_set_spec opt_collate_clause
3497 {
3498 $$ = SQL_NEW_RULE;
3499 $$->append($1);
3500 $$->append($2);
3501 $$->append($3);
3502 }
3503 | national_character_string_type opt_collate_clause
3504 {
3505 $$ = SQL_NEW_RULE;
3506 $$->append($1);
3507 $$->append($2);
3508 }
3509 | binary_string_type
3510 | numeric_type
3511 | boolean_type
3512 | datetime_type
3513 | interval_type
3514 ;
3515 character_string_type:
3516 SQL_TOKEN_CHARACTER opt_paren_precision
3517 {
3518 $$ = SQL_NEW_RULE;
3519 $$->append($1);
3520 $$->append($2);
3521 }
3522 | SQL_TOKEN_CHAR opt_paren_precision
3523 {
3524 $$ = SQL_NEW_RULE;
3525 $$->append($1);
3526 $$->append($2);
3527 }
3528 | SQL_TOKEN_CHARACTER SQL_TOKEN_VARYING paren_char_length
3529 {
3530 $$ = SQL_NEW_RULE;
3531 $$->append($1);
3532 $$->append($2);
3533 $$->append($3);
3534 }
3535 | SQL_TOKEN_CHAR SQL_TOKEN_VARYING paren_char_length
3536 {
3537 $$ = SQL_NEW_RULE;
3538 $$->append($1);
3539 $$->append($2);
3540 $$->append($3);
3541 }
3542 | SQL_TOKEN_VARCHAR paren_char_length
3543 {
3544 $$ = SQL_NEW_RULE;
3545 $$->append($1);
3546 $$->append($2);
3547 }
3548 | character_large_object_type
3549 ;
3550 opt_paren_precision:
3551 {$$ = SQL_NEW_RULE;}
3552 | paren_char_length
3553 ;
3554 paren_char_length:
3555 '(' SQL_TOKEN_INTNUM ')'
3556 {
3557 $$ = SQL_NEW_RULE;
3558 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
3559 $$->append($2);
3560 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
3561 }
3562 ;
3563 opt_paren_char_large_length:
3564 {$$ = SQL_NEW_RULE;}
3565 | paren_character_large_object_length
3566 ;
3567 paren_character_large_object_length:
3568 '(' large_object_length ')'
3569 {
3570 $$ = SQL_NEW_RULE;
3571 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
3572 $$->append($2);
3573 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
3574 }
3575 ;
3576
3577 large_object_length:
3578 SQL_TOKEN_INTNUM opt_multiplier
3579 {
3580 $$ = SQL_NEW_RULE;
3581 $$->append($1);
3582 $$->append($2);
3583 }
3584 ;
3585 opt_multiplier:
3586 {$$ = SQL_NEW_RULE;}
3587 | 'K'
3588 {
3589 $$ = SQL_NEW_RULE;
3590 $$->append($1 = newNode("K", SQL_NODE_PUNCTUATION));
3591 }
3592 | 'M'
3593 {
3594 $$ = SQL_NEW_RULE;
3595 $$->append($1 = newNode("M", SQL_NODE_PUNCTUATION));
3596 }
3597 | 'G'
3598 {
3599 $$ = SQL_NEW_RULE;
3600 $$->append($1 = newNode("G", SQL_NODE_PUNCTUATION));
3601 }
3602 | 'T'
3603 {
3604 $$ = SQL_NEW_RULE;
3605 $$->append($1 = newNode("T", SQL_NODE_PUNCTUATION));
3606 }
3607 | 'P'
3608 {
3609 $$ = SQL_NEW_RULE;
3610 $$->append($1 = newNode("P", SQL_NODE_PUNCTUATION));
3611 }
3612 ;
3613 character_large_object_type:
3614 SQL_TOKEN_CHARACTER SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length
3615 {
3616 $$ = SQL_NEW_RULE;
3617 $$->append($1);
3618 $$->append($2);
3619 $$->append($3);
3620 $$->append($4);
3621 }
3622 | SQL_TOKEN_CHAR SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length
3623 {
3624 $$ = SQL_NEW_RULE;
3625 $$->append($1);
3626 $$->append($2);
3627 $$->append($3);
3628 $$->append($4);
3629 }
3630 | SQL_TOKEN_CLOB opt_paren_char_large_length
3631 {
3632 $$ = SQL_NEW_RULE;
3633 $$->append($1);
3634 $$->append($2);
3635 }
3636 ;
3637 national_character_string_type:
3638 SQL_TOKEN_NATIONAL SQL_TOKEN_CHARACTER opt_paren_precision
3639 {
3640 $$ = SQL_NEW_RULE;
3641 $$->append($1);
3642 $$->append($2);
3643 $$->append($3);
3644 }
3645 | SQL_TOKEN_NATIONAL SQL_TOKEN_CHAR opt_paren_precision
3646 {
3647 $$ = SQL_NEW_RULE;
3648 $$->append($1);
3649 $$->append($2);
3650 $$->append($3);
3651 }
3652 | SQL_TOKEN_NCHAR opt_paren_precision
3653 {
3654 $$ = SQL_NEW_RULE;
3655 $$->append($1);
3656 $$->append($2);
3657 }
3658 | SQL_TOKEN_NATIONAL SQL_TOKEN_CHARACTER SQL_TOKEN_VARYING paren_char_length
3659 {
3660 $$ = SQL_NEW_RULE;
3661 $$->append($1);
3662 $$->append($2);
3663 $$->append($3);
3664 $$->append($4);
3665 }
3666 | SQL_TOKEN_NATIONAL SQL_TOKEN_CHAR SQL_TOKEN_VARYING paren_char_length
3667 {
3668 $$ = SQL_NEW_RULE;
3669 $$->append($1);
3670 $$->append($2);
3671 $$->append($3);
3672 $$->append($4);
3673 }
3674 | SQL_TOKEN_NCHAR SQL_TOKEN_VARYING paren_char_length
3675 {
3676 $$ = SQL_NEW_RULE;
3677 $$->append($1);
3678 $$->append($2);
3679 $$->append($3);
3680 }
3681 | national_character_large_object_type
3682 ;
3683 national_character_large_object_type:
3684 SQL_TOKEN_NATIONAL SQL_TOKEN_CHARACTER SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length
3685 {
3686 $$ = SQL_NEW_RULE;
3687 $$->append($1);
3688 $$->append($2);
3689 $$->append($3);
3690 $$->append($4);
3691 $$->append($5);
3692 }
3693 | SQL_TOKEN_NCHAR SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length
3694 {
3695 $$ = SQL_NEW_RULE;
3696 $$->append($1);
3697 $$->append($2);
3698 $$->append($3);
3699 $$->append($4);
3700 }
3701 | SQL_TOKEN_NCLOB opt_paren_char_large_length
3702 {
3703 $$ = SQL_NEW_RULE;
3704 $$->append($1);
3705 $$->append($2);
3706 }
3707 ;
3708 binary_string_type:
3709 SQL_TOKEN_BINARY opt_paren_precision
3710 {
3711 $$ = SQL_NEW_RULE;
3712 $$->append($1);
3713 $$->append($2);
3714 }
3715 | SQL_TOKEN_BINARY SQL_TOKEN_VARYING paren_char_length
3716 {
3717 $$ = SQL_NEW_RULE;
3718 $$->append($1);
3719 $$->append($2);
3720 $$->append($3);
3721 }
3722 | SQL_TOKEN_VARBINARY paren_char_length
3723 {
3724 $$ = SQL_NEW_RULE;
3725 $$->append($1);
3726 $$->append($2);
3727 }
3728 | binary_large_object_string_type
3729 ;
3730 binary_large_object_string_type:
3731 SQL_TOKEN_BINARY SQL_TOKEN_LARGE SQL_TOKEN_OBJECT opt_paren_char_large_length
3732 {
3733 $$ = SQL_NEW_RULE;
3734 $$->append($1);
3735 $$->append($2);
3736 $$->append($3);
3737 $$->append($4);
3738 }
3739 | SQL_TOKEN_BLOB opt_paren_char_large_length
3740 {
3741 $$ = SQL_NEW_RULE;
3742 $$->append($1);
3743 $$->append($2);
3744 }
3745 ;
3746 numeric_type:
3747 exact_numeric_type
3748 | approximate_numeric_type
3749 ;
3750 opt_paren_precision_scale:
3751 {$$ = SQL_NEW_RULE;}
3752 | '(' SQL_TOKEN_INTNUM ')'
3753 {
3754 $$ = SQL_NEW_RULE;
3755 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
3756 $$->append($2);
3757 $$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
3758 }
3759 | '(' SQL_TOKEN_INTNUM ',' SQL_TOKEN_INTNUM ')'
3760 {
3761 $$ = SQL_NEW_RULE;
3762 $$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
3763 $$->append($2);
3764 $$->append($3 = newNode(",", SQL_NODE_PUNCTUATION));
3765 $$->append($4);
3766 $$->append($5 = newNode(")", SQL_NODE_PUNCTUATION));
3767 }
3768 ;
3769 exact_numeric_type:
3770 SQL_TOKEN_NUMERIC opt_paren_precision_scale
3771 {
3772 $$ = SQL_NEW_RULE;
3773 $$->append($1);
3774 $$->append($2);
3775 }
3776 | SQL_TOKEN_DECIMAL opt_paren_precision_scale
3777 {
3778 $$ = SQL_NEW_RULE;
3779 $$->append($1);
3780 $$->append($2);
3781 }
3782 | SQL_TOKEN_DEC opt_paren_precision_scale
3783 {
3784 $$ = SQL_NEW_RULE;
3785 $$->append($1);
3786 $$->append($2);
3787 }
3788 | SQL_TOKEN_SMALLINT
3789 | SQL_TOKEN_INTEGER
3790 | SQL_TOKEN_INT
3791 | SQL_TOKEN_BIGINT
3792 ;
3793 approximate_numeric_type:
3794 SQL_TOKEN_FLOAT '(' SQL_TOKEN_INTNUM ')'
3795 {
3796 $$ = SQL_NEW_RULE;
3797 $$->append($1);
3798 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
3799 $$->append($3);
3800 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
3801 }
3802 | SQL_TOKEN_FLOAT
3803 | SQL_TOKEN_REAL
3804 | SQL_TOKEN_DOUBLE
3805 | SQL_TOKEN_DOUBLE SQL_TOKEN_PRECISION
3806 {
3807 $$ = SQL_NEW_RULE;
3808 $$->append($1);
3809 $$->append($2);
3810 }
3811 ;
3812 boolean_type:
3813 SQL_TOKEN_BOOLEAN
3814 ;
3815 datetime_type:
3816 SQL_TOKEN_DATE
3817 | SQL_TOKEN_TIME opt_paren_precision opt_with_or_without_time_zone
3818 {
3819 $$ = SQL_NEW_RULE;
3820 $$->append($1);
3821 $$->append($2);
3822 $$->append($3);
3823 }
3824 | SQL_TOKEN_TIMESTAMP opt_paren_precision opt_with_or_without_time_zone
3825 {
3826 $$ = SQL_NEW_RULE;
3827 $$->append($1);
3828 $$->append($2);
3829 $$->append($3);
3830 }
3831 ;
3832 opt_with_or_without_time_zone:
3833 {$$ = SQL_NEW_RULE;}
3834 | SQL_TOKEN_WITH SQL_TOKEN_TIME SQL_TOKEN_ZONE
3835 {
3836 $$ = SQL_NEW_RULE;
3837 $$->append($1);
3838 $$->append($2);
3839 $$->append($3);
3840 }
3841 | SQL_TOKEN_WITHOUT SQL_TOKEN_TIME SQL_TOKEN_ZONE
3842 {
3843 $$ = SQL_NEW_RULE;
3844 $$->append($1);
3845 $$->append($2);
3846 $$->append($3);
3847 }
3848 ;
3849 interval_type:
3850 SQL_TOKEN_INTERVAL interval_qualifier
3851 {
3852 $$ = SQL_NEW_RULE;
3853 $$->append($1);
3854 $$->append($2);
3855 }
3856 ;
3857 /* the various things you can name */
3858
3859 column:
3860 SQL_TOKEN_NAME
3861 | SQL_TOKEN_POSITION
3862 {
3863 sal_uInt32 nNod = $$->getRuleID();
3864 delete $$;
3865 $$ = newNode(xxx_pGLOBAL_SQLPARSER->TokenIDToStr(nNod), SQL_NODE_NAME);
3866 }
3867 | SQL_TOKEN_CHAR_LENGTH
3868 {
3869 sal_uInt32 nNod = $$->getRuleID();
3870 delete $$;
3871 $$ = newNode(xxx_pGLOBAL_SQLPARSER->TokenIDToStr(nNod), SQL_NODE_NAME);
3872 }
3873 | SQL_TOKEN_EXTRACT
3874 {
3875 sal_uInt32 nNod = $$->getRuleID();
3876 delete $$;
3877 $$ = newNode(xxx_pGLOBAL_SQLPARSER->TokenIDToStr(nNod), SQL_NODE_NAME);
3878 }
3879 ;
3880 case_expression:
3881 case_abbreviation
3882 | case_specification
3883 ;
3884 case_abbreviation:
3885 SQL_TOKEN_NULLIF '(' value_exp_commalist ')'
3886 {
3887 $$ = SQL_NEW_RULE;
3888 $$->append($1);
3889 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
3890 $$->append($3);
3891 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
3892 }
3893 | SQL_TOKEN_COALESCE '(' value_exp ')'
3894 {
3895 $$ = SQL_NEW_RULE;
3896 $$->append($1);
3897 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
3898 $$->append($3);
3899 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
3900 }
3901 | SQL_TOKEN_COALESCE '(' value_exp_commalist ')'
3902 {
3903 $$ = SQL_NEW_RULE;
3904 $$->append($1);
3905 $$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
3906 $$->append($3);
3907 $$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
3908 }
3909 ;
3910 case_specification:
3911 simple_case
3912 | searched_case
3913 ;
3914 simple_case:
3915 SQL_TOKEN_CASE case_operand simple_when_clause_list else_clause SQL_TOKEN_END
3916 {
3917 $$ = SQL_NEW_RULE;
3918 $$->append($1);
3919 $$->append($2);
3920 $$->append($3);
3921 $$->append($4);
3922 $$->append($5);
3923 }
3924 ;
3925 searched_case:
3926 SQL_TOKEN_CASE searched_when_clause_list else_clause SQL_TOKEN_END
3927 {
3928 $$ = SQL_NEW_RULE;
3929 $$->append($1);
3930 $$->append($2);
3931 $$->append($3);
3932 $$->append($4);
3933 }
3934 ;
3935 simple_when_clause_list:
3936 simple_when_clause
3937 {
3938 $$ = SQL_NEW_LISTRULE;
3939 $$->append($1);
3940 }
3941 | searched_when_clause_list simple_when_clause
3942 {
3943 $1->append($2);
3944 $$ = $1;
3945 }
3946 ;
3947 simple_when_clause:
3948 SQL_TOKEN_WHEN when_operand_list SQL_TOKEN_THEN result
3949 {
3950 $$ = SQL_NEW_RULE;
3951 $$->append($1);
3952 $$->append($2);
3953 $$->append($3);
3954 $$->append($4);
3955 }
3956 ;
3957 when_operand_list:
3958 when_operand
3959 {$$ = SQL_NEW_COMMALISTRULE;
3960 $$->append($1);}
3961 | when_operand_list ',' when_operand
3962 {$1->append($3);
3963 $$ = $1;}
3964 ;
3965 when_operand:
3966 row_value_constructor_elem
3967 | comparison_predicate_part_2
3968 | between_predicate_part_2
3969 | in_predicate_part_2
3970 | character_like_predicate_part_2
3971 | null_predicate_part_2
3972 ;
3973 searched_when_clause_list:
3974 searched_when_clause
3975 {
3976 $$ = SQL_NEW_LISTRULE;
3977 $$->append($1);
3978 }
3979 | searched_when_clause_list searched_when_clause
3980 {
3981 $1->append($2);
3982 $$ = $1;
3983 }
3984 ;
3985 searched_when_clause:
3986 SQL_TOKEN_WHEN search_condition SQL_TOKEN_THEN result
3987 {
3988 $$ = SQL_NEW_RULE;
3989 $$->append($1);
3990 $$->append($2);
3991 $$->append($3);
3992 $$->append($4);
3993 }
3994 ;
3995 else_clause:
3996 {$$ = SQL_NEW_RULE;}
3997 | SQL_TOKEN_ELSE result
3998 {
3999 $$ = SQL_NEW_RULE;
4000 $$->append($1);
4001 $$->append($2);
4002 }
4003 ;
4004 result:
4005 result_expression
4006 ;
4007 result_expression:
4008 value_exp
4009 ;
4010 case_operand:
4011 row_value_constructor_elem
4012 ;
4013
4014 cursor: SQL_TOKEN_NAME
4015 {$$ = SQL_NEW_RULE;
4016 $$->append($1);}
4017 ;
4018
4019 /***
4020 module: SQL_TOKEN_NAME
4021 {$$ = SQL_NEW_RULE;
4022 $$->append($1);}
4023 ;
4024 ***/
4025
4026 parameter:
4027 ':' SQL_TOKEN_NAME
4028 {$$ = SQL_NEW_RULE;
4029 $$->append($1 = newNode(":", SQL_NODE_PUNCTUATION));
4030 $$->append($2);}
4031 | '?'
4032 {$$ = SQL_NEW_RULE; // test
4033 $$->append($1 = newNode("?", SQL_NODE_PUNCTUATION));}
4034 | '[' SQL_TOKEN_NAME ']'
4035 {$$ = SQL_NEW_RULE;
4036 $$->append($1 = newNode("[", SQL_NODE_PUNCTUATION));
4037 $$->append($2);
4038 $$->append($3 = newNode("]", SQL_NODE_PUNCTUATION));}
4039 ;
4040
4041 /***
4042 procedure: SQL_TOKEN_NAME
4043 {$$ = SQL_NEW_RULE;
4044 $$->append($1);}
4045 ;
4046 ***/
4047
4048 range_variable:
4049 {$$ = SQL_NEW_RULE;}
4050 | opt_as SQL_TOKEN_NAME
4051 {$$ = SQL_NEW_RULE;
4052 $$->append($1);
4053 $$->append($2);
4054 }
4055 ;
4056
4057 user: SQL_TOKEN_NAME
4058 ;
4059
4060 /* PREDICATECHECK RULES */
4061 sql:
4062 search_condition /* checking predicats */
4063 {
4064 if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // sql: rule 1
4065 {
4066 $$ = $1;
4067 if ( SQL_ISRULE($$,search_condition) )
4068 {
4069 $$->insert(0,newNode("(", SQL_NODE_PUNCTUATION));
4070 $$->append(newNode(")", SQL_NODE_PUNCTUATION));
4071 }
4072 }
4073 else
4074 YYERROR;
4075 }
4076 | '(' sql ')' /* checking predicats */
4077 ;
4078 trigger_definition:
4079 SQL_TOKEN_CREATE SQL_TOKEN_TRIGGER trigger_name trigger_action_time trigger_event SQL_TOKEN_ON table_name op_referencing triggered_action
4080 {
4081 $$ = SQL_NEW_RULE;
4082 $$->append($1);
4083 $$->append($2);
4084 $$->append($3);
4085 $$->append($4);
4086 $$->append($5);
4087 $$->append($6);
4088 $$->append($7);
4089 $$->append($8);
4090 $$->append($9);
4091 }
4092 ;
4093 op_referencing:
4094 {
4095 $$ = SQL_NEW_RULE;
4096 }
4097 | SQL_TOKEN_REFERENCING transition_table_or_variable_list
4098 {
4099 $$ = SQL_NEW_RULE;
4100 $$->append($1);
4101 $$->append($2);
4102 }
4103 ;
4104 trigger_action_time:
4105 SQL_TOKEN_BEFORE
4106 | SQL_TOKEN_AFTER
4107 | SQL_TOKEN_INSTEAD SQL_TOKEN_OF
4108 {
4109 $$ = SQL_NEW_RULE;
4110 $$->append($1);
4111 $$->append($2);
4112 }
4113 ;
4114 trigger_event:
4115 SQL_TOKEN_INSERT
4116 | SQL_TOKEN_DELETE
4117 | SQL_TOKEN_UPDATE op_trigger_columnlist
4118 {
4119 $$ = SQL_NEW_RULE;
4120 $$->append($1);
4121 $$->append($2);
4122 }
4123 ;
4124 op_trigger_columnlist:
4125 {
4126 $$ = SQL_NEW_RULE;
4127 }
4128 | SQL_TOKEN_OF trigger_column_list
4129 {
4130 $$ = SQL_NEW_RULE;
4131 $$->append($1);
4132 $$->append($2);
4133 }
4134 ;
4135 trigger_column_list:
4136 column_commalist
4137 ;
4138 triggered_action:
4139 op_triggered_action_for triggered_when_clause triggered_SQL_statement
4140 {
4141 $$ = SQL_NEW_RULE;
4142 $$->append($1);
4143 $$->append($2);
4144 $$->append($3);
4145 }
4146 ;
4147 op_triggered_action_for:
4148 {
4149 $$ = SQL_NEW_RULE;
4150 }
4151 | SQL_TOKEN_FOR SQL_TOKEN_EACH trigger_for
4152 {
4153 $$ = SQL_NEW_RULE;
4154 $$->append($1);
4155 $$->append($2);
4156 $$->append($3);
4157 }
4158 ;
4159 trigger_for:
4160 SQL_TOKEN_ROW
4161 | SQL_TOKEN_STATEMENT
4162 ;
4163 triggered_when_clause:
4164 {
4165 $$ = SQL_NEW_RULE;
4166 }
4167 | SQL_TOKEN_WHEN parenthesized_boolean_value_expression
4168 {
4169 $$ = SQL_NEW_RULE;
4170 $$->append($1);
4171 $$->append($2);
4172 }
4173 ;
4174 triggered_SQL_statement:
4175 SQL_procedure_statement
4176 | SQL_TOKEN_BEGIN SQL_TOKEN_ATOMIC SQL_procedure_statement_list ';' SQL_TOKEN_END
4177 {
4178 $$ = SQL_NEW_RULE;
4179 $$->append($1);
4180 $$->append($2);
4181 $$->append($3);
4182 $$->append($4 = newNode(";", SQL_NODE_PUNCTUATION));
4183 $$->append($5);
4184 }
4185 ;
4186 SQL_procedure_statement_list:
4187 SQL_procedure_statement
4188 {
4189 $$ = SQL_NEW_LISTRULE;
4190 $$->append($1);
4191 }
4192 | SQL_procedure_statement_list ';' SQL_procedure_statement
4193 {
4194 $1->append($3);
4195 $$ = $1;
4196 }
4197 ;
4198 SQL_procedure_statement:
4199 sql
4200 ;
4201
4202 transition_table_or_variable_list:
4203 transition_table_or_variable
4204 {
4205 $$ = SQL_NEW_LISTRULE;
4206 $$->append($1);
4207 }
4208 | transition_table_or_variable_list transition_table_or_variable
4209 {
4210 $1->append($2);
4211 $$ = $1;
4212 }
4213 ;
4214
4215 transition_table_or_variable:
4216 SQL_TOKEN_OLD opt_row opt_as old_transition_variable_name
4217 {
4218 $$ = SQL_NEW_RULE;
4219 $$->append($1);
4220 $$->append($2);
4221 $$->append($3);
4222 $$->append($4);
4223 }
4224 | SQL_TOKEN_NEW opt_row opt_as new_transition_variable_name
4225 {
4226 $$ = SQL_NEW_RULE;
4227 $$->append($1);
4228 $$->append($2);
4229 $$->append($3);
4230 $$->append($4);
4231 }
4232 | SQL_TOKEN_OLD SQL_TOKEN_TABLE opt_as old_transition_table_name
4233 {
4234 $$ = SQL_NEW_RULE;
4235 $$->append($1);
4236 $$->append($2);
4237 $$->append($3);
4238 $$->append($4);
4239 }
4240 | SQL_TOKEN_NEW SQL_TOKEN_TABLE opt_as new_transition_table_name
4241 {
4242 $$ = SQL_NEW_RULE;
4243 $$->append($1);
4244 $$->append($2);
4245 $$->append($3);
4246 $$->append($4);
4247 }
4248 ;
4249 old_transition_table_name:
4250 transition_table_name
4251 ;
4252 new_transition_table_name:
4253 transition_table_name
4254 ;
4255 transition_table_name:
4256 SQL_TOKEN_NAME
4257 ;
4258 old_transition_variable_name:
4259 SQL_TOKEN_NAME
4260 ;
4261 new_transition_variable_name:
4262 SQL_TOKEN_NAME
4263 ;
4264 trigger_name:
4265 SQL_TOKEN_NAME
4266 ;
4267 %%
4268
4269
4270 using namespace ::com::sun::star::sdbc;
4271 using namespace ::com::sun::star::beans;
4272 using namespace ::com::sun::star::uno;
4273 using namespace ::com::sun::star::i18n;
4274 using namespace ::com::sun::star::lang;
4275 using namespace ::com::sun::star::util;
4276 using namespace ::osl;
4277 using namespace ::dbtools;
4278
4279 //============================================================
4280 //= a helper for static ascii pseudo-unicode strings
4281 //============================================================
4282 // string constants
4283 struct _ConstAsciiString_
4284 {
4285 sal_Int32 length;
4286 sal_Char const* str;
4287
4288 operator rtl::OUString () const { return rtl::OUString(str, length, RTL_TEXTENCODING_ASCII_US); }
4289 operator const sal_Char * () const { return str; }
4290 operator ::rtl::OString() const { return str; }
4291 };
4292
4293 #define IMPLEMENT_CONSTASCII_STRING( name, string ) \
4294 _ConstAsciiString_ const name = { sizeof(string)-1, string }
4295
4296 IMPLEMENT_CONSTASCII_STRING(ERROR_STR_GENERAL, "Syntax error in SQL expression");
4297 IMPLEMENT_CONSTASCII_STRING(ERROR_STR_VALUE_NO_LIKE, "The value #1 can not be used with LIKE.");
4298 IMPLEMENT_CONSTASCII_STRING(ERROR_STR_FIELD_NO_LIKE, "LIKE can not be used with this field.");
4299 IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_COMPARE, "The entered criterion can not be compared with this field.");
4300 IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_DATE_COMPARE, "The field can not be compared with a date.");
4301 IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_REAL_COMPARE, "The field can not be compared with a floating point number.");
4302 IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_INT_COMPARE, "The field can not be compared with a number.");
4303 IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_TABLE, "The database does not contain a table named \"#\".");
4304 IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_TABLE_OR_QUERY, "The database does contain neither a table nor a query named \"#\".");
4305 IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_COLUMN, "The column \"#1\" is unknown in the table \"#2\".");
4306 IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_TABLE_EXIST, "The database already contains a table or view with name \"#\".");
4307 IMPLEMENT_CONSTASCII_STRING(ERROR_STR_INVALID_QUERY_EXIST, "The database already contains a query with name \"#\".");
4308
4309 IMPLEMENT_CONSTASCII_STRING(KEY_STR_LIKE, "LIKE");
4310 IMPLEMENT_CONSTASCII_STRING(KEY_STR_NOT, "NOT");
4311 IMPLEMENT_CONSTASCII_STRING(KEY_STR_NULL, "NULL");
4312 IMPLEMENT_CONSTASCII_STRING(KEY_STR_TRUE, "True");
4313 IMPLEMENT_CONSTASCII_STRING(KEY_STR_FALSE, "False");
4314 IMPLEMENT_CONSTASCII_STRING(KEY_STR_IS, "IS");
4315 IMPLEMENT_CONSTASCII_STRING(KEY_STR_BETWEEN, "BETWEEN");
4316 IMPLEMENT_CONSTASCII_STRING(KEY_STR_OR, "OR");
4317 IMPLEMENT_CONSTASCII_STRING(KEY_STR_AND, "AND");
4318 IMPLEMENT_CONSTASCII_STRING(KEY_STR_AVG, "AVG");
4319 IMPLEMENT_CONSTASCII_STRING(KEY_STR_COUNT, "COUNT");
4320 IMPLEMENT_CONSTASCII_STRING(KEY_STR_MAX, "MAX");
4321 IMPLEMENT_CONSTASCII_STRING(KEY_STR_MIN, "MIN");
4322 IMPLEMENT_CONSTASCII_STRING(KEY_STR_SUM, "SUM");
4323 IMPLEMENT_CONSTASCII_STRING(KEY_STR_EVERY, "EVERY");
4324 IMPLEMENT_CONSTASCII_STRING(KEY_STR_ANY, "ANY");
4325 IMPLEMENT_CONSTASCII_STRING(KEY_STR_SOME, "SOME");
4326 IMPLEMENT_CONSTASCII_STRING(KEY_STR_STDDEV_POP, "STDDEV_POP");
4327 IMPLEMENT_CONSTASCII_STRING(KEY_STR_STDDEV_SAMP, "STDDEV_SAMP");
4328 IMPLEMENT_CONSTASCII_STRING(KEY_STR_VAR_SAMP, "VAR_SAMP");
4329 IMPLEMENT_CONSTASCII_STRING(KEY_STR_VAR_POP, "VAR_POP");
4330 IMPLEMENT_CONSTASCII_STRING(KEY_STR_COLLECT, "COLLECT");
4331 IMPLEMENT_CONSTASCII_STRING(KEY_STR_FUSION, "FUSION");
4332 IMPLEMENT_CONSTASCII_STRING(KEY_STR_INTERSECTION, "INTERSECTION");
4333
4334 IMPLEMENT_CONSTASCII_STRING(FIELD_STR_NULLDATE, "NullDate");
4335
4336 IMPLEMENT_CONSTASCII_STRING(STR_SQL_TOKEN, "SQL_TOKEN_");
4337
4338 //==========================================================================
4339 //= OParseContext
4340 //==========================================================================
4341 //-----------------------------------------------------------------------------
4342 OParseContext::OParseContext()
4343 {
4344 }
4345
4346 //-----------------------------------------------------------------------------
4347 OParseContext::~OParseContext()
4348 {
4349 }
4350
4351 //-----------------------------------------------------------------------------
4352 ::rtl::OUString OParseContext::getErrorMessage(ErrorCode _eCode) const
4353 {
4354 ::rtl::OUString aMsg;
4355 switch (_eCode)
4356 {
4357 case ERROR_GENERAL: aMsg = ERROR_STR_GENERAL; break;
4358 case ERROR_VALUE_NO_LIKE: aMsg = ERROR_STR_VALUE_NO_LIKE; break;
4359 case ERROR_FIELD_NO_LIKE: aMsg = ERROR_STR_FIELD_NO_LIKE; break;
4360 case ERROR_INVALID_COMPARE: aMsg = ERROR_STR_INVALID_COMPARE; break;
4361 case ERROR_INVALID_INT_COMPARE: aMsg = ERROR_STR_INVALID_INT_COMPARE; break;
4362 case ERROR_INVALID_DATE_COMPARE: aMsg = ERROR_STR_INVALID_DATE_COMPARE; break;
4363 case ERROR_INVALID_REAL_COMPARE: aMsg = ERROR_STR_INVALID_REAL_COMPARE; break;
4364 case ERROR_INVALID_TABLE: aMsg = ERROR_STR_INVALID_TABLE; break;
4365 case ERROR_INVALID_TABLE_OR_QUERY: aMsg = ERROR_STR_INVALID_TABLE_OR_QUERY; break;
4366 case ERROR_INVALID_COLUMN: aMsg = ERROR_STR_INVALID_COLUMN; break;
4367 case ERROR_INVALID_TABLE_EXIST: aMsg = ERROR_STR_INVALID_TABLE_EXIST; break;
4368 case ERROR_INVALID_QUERY_EXIST: aMsg = ERROR_STR_INVALID_QUERY_EXIST; break;
4369 default:
4370 OSL_FAIL( "OParseContext::getErrorMessage: unknown error code!" );
4371 break;
4372 }
4373 return aMsg;
4374 }
4375
4376 //-----------------------------------------------------------------------------
4377 ::rtl::OString OParseContext::getIntlKeywordAscii(InternationalKeyCode _eKey) const
4378 {
4379 ::rtl::OString aKeyword;
4380 switch (_eKey)
4381 {
4382 case KEY_LIKE: aKeyword = KEY_STR_LIKE; break;
4383 case KEY_NOT: aKeyword = KEY_STR_NOT; break;
4384 case KEY_NULL: aKeyword = KEY_STR_NULL; break;
4385 case KEY_TRUE: aKeyword = KEY_STR_TRUE; break;
4386 case KEY_FALSE: aKeyword = KEY_STR_FALSE; break;
4387 case KEY_IS: aKeyword = KEY_STR_IS; break;
4388 case KEY_BETWEEN: aKeyword = KEY_STR_BETWEEN; break;
4389 case KEY_OR: aKeyword = KEY_STR_OR; break;
4390 case KEY_AND: aKeyword = KEY_STR_AND; break;
4391 case KEY_AVG: aKeyword = KEY_STR_AVG; break;
4392 case KEY_COUNT: aKeyword = KEY_STR_COUNT; break;
4393 case KEY_MAX: aKeyword = KEY_STR_MAX; break;
4394 case KEY_MIN: aKeyword = KEY_STR_MIN; break;
4395 case KEY_SUM: aKeyword = KEY_STR_SUM; break;
4396 case KEY_EVERY: aKeyword = KEY_STR_EVERY; break;
4397 case KEY_ANY: aKeyword = KEY_STR_ANY; break;
4398 case KEY_SOME: aKeyword = KEY_STR_SOME; break;
4399 case KEY_STDDEV_POP: aKeyword = KEY_STR_STDDEV_POP; break;
4400 case KEY_STDDEV_SAMP: aKeyword = KEY_STR_STDDEV_SAMP; break;
4401 case KEY_VAR_SAMP: aKeyword = KEY_STR_VAR_SAMP; break;
4402 case KEY_VAR_POP: aKeyword = KEY_STR_VAR_POP; break;
4403 case KEY_COLLECT: aKeyword = KEY_STR_COLLECT; break;
4404 case KEY_FUSION: aKeyword = KEY_STR_FUSION; break;
4405 case KEY_INTERSECTION:aKeyword = KEY_STR_INTERSECTION; break;
4406 case KEY_NONE: break;
4407 default:
4408 OSL_FAIL( "OParseContext::getIntlKeywordAscii: unknown key!" );
4409 break;
4410 }
4411 return aKeyword;
4412 }
4413
4414 //-----------------------------------------------------------------------------
4415 IParseContext::InternationalKeyCode OParseContext::getIntlKeyCode(const ::rtl::OString& rToken) const
4416 {
4417 static IParseContext::InternationalKeyCode Intl_TokenID[] =
4418 {
4419 KEY_LIKE, KEY_NOT, KEY_NULL, KEY_TRUE,
4420 KEY_FALSE, KEY_IS, KEY_BETWEEN, KEY_OR,
4421 KEY_AND, KEY_AVG, KEY_COUNT, KEY_MAX,
4422 KEY_MIN, KEY_SUM, KEY_EVERY,KEY_ANY,KEY_SOME,
4423 KEY_STDDEV_POP,KEY_STDDEV_SAMP,KEY_VAR_SAMP,
4424 KEY_VAR_POP,KEY_COLLECT,KEY_FUSION,KEY_INTERSECTION
4425 };
4426
4427 sal_uInt32 nCount = SAL_N_ELEMENTS( Intl_TokenID );
4428 for (sal_uInt32 i = 0; i < nCount; i++)
4429 {
4430 ::rtl::OString aKey = getIntlKeywordAscii(Intl_TokenID[i]);
4431 if (rToken.equalsIgnoreAsciiCase(aKey))
4432 return Intl_TokenID[i];
4433 }
4434
4435 return KEY_NONE;
4436 }
4437
4438 //------------------------------------------------------------------------------
4439 static Locale& impl_getLocaleInstance( )
4440 {
4441 static Locale s_aLocale(
4442 ::rtl::OUString( "en" ),
4443 ::rtl::OUString( "US" ),
4444 ::rtl::OUString( )
4445 );
4446 return s_aLocale;
4447 }
4448
4449 //------------------------------------------------------------------------------
4450 Locale OParseContext::getPreferredLocale( ) const
4451 {
4452 return getDefaultLocale();
4453 }
4454
4455 //------------------------------------------------------------------------------
4456 const Locale& OParseContext::getDefaultLocale()
4457 {
4458 return impl_getLocaleInstance();
4459 }
4460
4461 //==========================================================================
4462 //= misc
4463 //==========================================================================
4464 // Der (leider globale) yylval fuer die Uebergabe von
4465 // Werten vom Scanner an den Parser. Die globale Variable
4466 // wird nur kurzzeitig verwendet, der Parser liest die Variable
4467 // sofort nach dem Scanner-Aufruf in eine gleichnamige eigene
4468 // Member-Variable.
4469
4470 //------------------------------------------------------------------
4471 ::rtl::OUString ConvertLikeToken(const OSQLParseNode* pTokenNode, const OSQLParseNode* pEscapeNode, sal_Bool bInternational)
4472 {
4473 ::rtl::OUStringBuffer aMatchStr(0);
4474 if (pTokenNode->isToken())
4475 {
4476 sal_Unicode cEscape = 0;
4477 if (pEscapeNode->count())
4478 cEscape = pEscapeNode->getChild(1)->getTokenValue().toChar();
4479
4480 // Platzhalter austauschen
4481 aMatchStr = pTokenNode->getTokenValue();
4482 const sal_Int32 nLen = aMatchStr.getLength();
4483 ::rtl::OUStringBuffer sSearch,sReplace;
4484 if ( bInternational )
4485 {
4486 sSearch.appendAscii("%_",2);
4487 sReplace.appendAscii("*?",2);
4488 }
4489 else
4490 {
4491 sSearch.appendAscii("*?",2);
4492 sReplace.appendAscii("%_",2);
4493 }
4494
4495 bool wasEscape = false;
4496 for (sal_Int32 i = 0; i < nLen; i++)
4497 {
4498 const sal_Unicode c = aMatchStr[i];
4499 // SQL standard requires the escape to be followed
4500 // by a meta-character ('%', '_' or itself), else error
4501 // We are more lenient here and let it escape anything.
4502 // Especially since some databases (e.g. Microsoft SQL Server)
4503 // have more meta-characters than the standard, such as e.g. '[' and ']'
4504 if (wasEscape)
4505 {
4506 wasEscape=false;
4507 continue;
4508 }
4509 if (c == cEscape)
4510 {
4511 wasEscape=true;
4512 continue;
4513 }
4514 int match = -1;
4515 if (c == sSearch[0])
4516 match=0;
4517 else if (c == sSearch[1])
4518 match=1;
4519
4520 if (match != -1)
4521 {
4522 aMatchStr[i] = sReplace[match];
4523 }
4524 }
4525 }
4526 return aMatchStr.makeStringAndClear();
4527 }
4528
4529 //==========================================================================
4530 //= OSQLParser
4531 //==========================================================================
4532
4533 sal_uInt32 OSQLParser::s_nRuleIDs[OSQLParseNode::rule_count + 1];
4534 OSQLParser::RuleIDMap OSQLParser::s_aReverseRuleIDLookup;
4535 OParseContext OSQLParser::s_aDefaultContext;
4536
4537 sal_Int32 OSQLParser::s_nRefCount = 0;
4538 // ::osl::Mutex OSQLParser::s_aMutex;
4539 OSQLScanner* OSQLParser::s_pScanner = 0;
4540 OSQLParseNodesGarbageCollector* OSQLParser::s_pGarbageCollector = 0;
4541 ::com::sun::star::uno::Reference< ::com::sun::star::i18n::XLocaleData4> OSQLParser::s_xLocaleData = NULL;
4542 //-----------------------------------------------------------------------------
4543 void setParser(OSQLParser* _pParser)
4544 {
4545 xxx_pGLOBAL_SQLPARSER = _pParser;
4546 }
4547 // -------------------------------------------------------------------------
4548 void OSQLParser::setParseTree(OSQLParseNode * pNewParseTree)
4549 {
4550 ::osl::MutexGuard aGuard(getMutex());
4551 m_pParseTree = pNewParseTree;
4552 }
4553 //-----------------------------------------------------------------------------
4554
4555 /** Delete all comments in a query.
4556
4557 See also getComment()/concatComment() implementation for
4558 OQueryController::translateStatement().
4559 */
4560 static ::rtl::OUString delComment( const ::rtl::OUString& rQuery )
4561 {
4562 // First a quick search if there is any "--" or "//" or "/*", if not then the whole
4563 // copying loop is pointless.
4564 if (rQuery.indexOfAsciiL( "--", 2, 0) < 0 && rQuery.indexOfAsciiL( "//", 2, 0) < 0 &&
4565 rQuery.indexOfAsciiL( "/*", 2, 0) < 0)
4566 return rQuery;
4567
4568 const sal_Unicode* pCopy = rQuery.getStr();
4569 sal_Int32 nQueryLen = rQuery.getLength();
4570 bool bIsText1 = false; // "text"
4571 bool bIsText2 = false; // 'text'
4572 bool bComment2 = false; // /* comment */
4573 bool bComment = false; // -- or // comment
4574 ::rtl::OUStringBuffer aBuf(nQueryLen);
4575 for (sal_Int32 i=0; i < nQueryLen; ++i)
4576 {
4577 if (bComment2)
4578 {
4579 if ((i+1) < nQueryLen)
4580 {
4581 if (pCopy[i]=='*' && pCopy[i+1]=='/')
4582 {
4583 bComment2 = false;
4584 ++i;
4585 }
4586 }
4587 else
4588 {
4589 // comment can't close anymore, actually an error, but..
4590 }
4591 continue;
4592 }
4593 if (pCopy[i] == '\n')
4594 bComment = false;
4595 else if (!bComment)
4596 {
4597 if (pCopy[i] == '\"' && !bIsText2)
4598 bIsText1 = !bIsText1;
4599 else if (pCopy[i] == '\'' && !bIsText1)
4600 bIsText2 = !bIsText2;
4601 if (!bIsText1 && !bIsText2 && (i+1) < nQueryLen)
4602 {
4603 if ((pCopy[i]=='-' && pCopy[i+1]=='-') || (pCopy[i]=='/' && pCopy[i+1]=='/'))
4604 bComment = true;
4605 else if ((pCopy[i]=='/' && pCopy[i+1]=='*'))
4606 bComment2 = true;
4607 }
4608 }
4609 if (!bComment && !bComment2)
4610 aBuf.append( &pCopy[i], 1);
4611 }
4612 return aBuf.makeStringAndClear();
4613 }
4614 //-----------------------------------------------------------------------------
4615 OSQLParseNode* OSQLParser::parseTree(::rtl::OUString& rErrorMessage,
4616 const ::rtl::OUString& rStatement,
4617 sal_Bool bInternational)
4618 {
4619
4620
4621 // Guard the parsing
4622 ::osl::MutexGuard aGuard(getMutex());
4623 // must be reset
4624 setParser(this);
4625
4626 // delete comments before parsing
4627 ::rtl::OUString sTemp = delComment(rStatement);
4628
4629 // defines how to scan
4630 s_pScanner->SetRule(s_pScanner->GetSQLRule()); // initial
4631 s_pScanner->prepareScan(sTemp, m_pContext, bInternational);
4632
4633 SQLyylval.pParseNode = NULL;
4634 // SQLyypvt = NULL;
4635 m_pParseTree = NULL;
4636 m_sErrorMessage = ::rtl::OUString();
4637
4638 // ... und den Parser anwerfen ...
4639 if (SQLyyparse() != 0)
4640 {
4641 // only set the error message, if it's not already set
4642 if (m_sErrorMessage.isEmpty())
4643 m_sErrorMessage = s_pScanner->getErrorMessage();
4644 if (m_sErrorMessage.isEmpty())
4645 m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_GENERAL);
4646
4647 rErrorMessage = m_sErrorMessage;
4648
4649 // clear the garbage collector
4650 (*s_pGarbageCollector)->clearAndDelete();
4651 return NULL;
4652 }
4653 else
4654 {
4655 (*s_pGarbageCollector)->clear();
4656
4657 // Das Ergebnis liefern (den Root Parse Node):
4658
4659 // OSL_ENSURE(Sdbyyval.pParseNode != NULL,"OSQLParser: Parser hat keinen ParseNode geliefert");
4660 // return Sdbyyval.pParseNode;
4661 // geht nicht wegen Bug in MKS YACC-erzeugtem Code (es wird ein falscher ParseNode
4662 // geliefert).
4663
4664 // Stattdessen setzt die Parse-Routine jetzt den Member pParseTree
4665 // - einfach diesen zurueckliefern:
4666 OSL_ENSURE(m_pParseTree != NULL,"OSQLParser: Parser hat keinen ParseTree geliefert");
4667 return m_pParseTree;
4668 }
4669 }
4670 //-----------------------------------------------------------------------------
4671 ::rtl::OString OSQLParser::TokenIDToStr(sal_uInt32 nTokenID, const IParseContext* pContext)
4672 {
4673 ::rtl::OString aStr;
4674 if (pContext)
4675 {
4676 IParseContext::InternationalKeyCode eKeyCode = IParseContext::KEY_NONE;
4677 switch( nTokenID )
4678 {
4679 case SQL_TOKEN_LIKE: eKeyCode = IParseContext::KEY_LIKE; break;
4680 case SQL_TOKEN_NOT: eKeyCode = IParseContext::KEY_NOT; break;
4681 case SQL_TOKEN_NULL: eKeyCode = IParseContext::KEY_NULL; break;
4682 case SQL_TOKEN_TRUE: eKeyCode = IParseContext::KEY_TRUE; break;
4683 case SQL_TOKEN_FALSE: eKeyCode = IParseContext::KEY_FALSE; break;
4684 case SQL_TOKEN_IS: eKeyCode = IParseContext::KEY_IS; break;
4685 case SQL_TOKEN_BETWEEN: eKeyCode = IParseContext::KEY_BETWEEN; break;
4686 case SQL_TOKEN_OR: eKeyCode = IParseContext::KEY_OR; break;
4687 case SQL_TOKEN_AND: eKeyCode = IParseContext::KEY_AND; break;
4688 case SQL_TOKEN_AVG: eKeyCode = IParseContext::KEY_AVG; break;
4689 case SQL_TOKEN_COUNT: eKeyCode = IParseContext::KEY_COUNT; break;
4690 case SQL_TOKEN_MAX: eKeyCode = IParseContext::KEY_MAX; break;
4691 case SQL_TOKEN_MIN: eKeyCode = IParseContext::KEY_MIN; break;
4692 case SQL_TOKEN_SUM: eKeyCode = IParseContext::KEY_SUM; break;
4693 }
4694 if ( eKeyCode != IParseContext::KEY_NONE )
4695 aStr = pContext->getIntlKeywordAscii(eKeyCode);
4696 }
4697
4698 if (aStr.isEmpty())
4699 {
4700 aStr = yytname[YYTRANSLATE(nTokenID)];
4701 if(aStr.startsWith("SQL_TOKEN_"))
4702 aStr = aStr.copy(10);
4703 }
4704 return aStr;
4705 }
4706
4707 #if OSL_DEBUG_LEVEL > 1
4708 ::rtl::OUString OSQLParser::RuleIDToStr(sal_uInt32 nRuleID)
4709 {
4710 OSL_ENSURE(nRuleID < SAL_N_ELEMENTS(yytname), "OSQLParser::RuleIDToStr: Invalid nRuleId!");
4711 return ::rtl::OUString::createFromAscii(yytname[nRuleID]);
4712 }
4713 #endif
4714
4715 //-----------------------------------------------------------------------------
4716 sal_uInt32 OSQLParser::StrToRuleID(const ::rtl::OString & rValue)
4717 {
4718 // Search for the given name in yytname and return the index
4719 // (or UNKNOWN_RULE, if not found)
4720 static sal_uInt32 nLen = SAL_N_ELEMENTS(yytname);
4721 for (sal_uInt32 i = YYTRANSLATE(SQL_TOKEN_INVALIDSYMBOL); i < (nLen-1); i++)
4722 {
4723 if (rValue == yytname[i])
4724 return i;
4725 }
4726
4727 // Not found
4728 return OSQLParseNode::UNKNOWN_RULE;
4729 }
4730
4731 //-----------------------------------------------------------------------------
4732 OSQLParseNode::Rule OSQLParser::RuleIDToRule( sal_uInt32 _nRule )
4733 {
4734 OSQLParser::RuleIDMap::const_iterator i (s_aReverseRuleIDLookup.find(_nRule));
4735 if (i == s_aReverseRuleIDLookup.end())
4736 {
4737 SAL_INFO("connectivity.parse",
4738 "connectivity::OSQLParser::RuleIDToRule cannot reverse-lookup rule. "
4739 "Reverse mapping incomplete? "
4740 "_nRule='" << _nRule << "' "
4741 "yytname[_nRule]='" << yytname[_nRule] << "'");
4742 return OSQLParseNode::UNKNOWN_RULE;
4743 }
4744 else
4745 return i->second;
4746 }
4747
4748 //-----------------------------------------------------------------------------
4749 sal_uInt32 OSQLParser::RuleID(OSQLParseNode::Rule eRule)
4750 {
4751 return s_nRuleIDs[(sal_uInt16)eRule];
4752 }
4753 // -------------------------------------------------------------------------
4754 sal_Int16 OSQLParser::buildNode(OSQLParseNode*& pAppend,OSQLParseNode* pCompare,OSQLParseNode* pLiteral,OSQLParseNode* pLiteral2)
4755 {
4756 OSQLParseNode* pColumnRef = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref));
4757 pColumnRef->append(new OSQLInternalNode(m_sFieldName,SQL_NODE_NAME));
4758 OSQLParseNode* pComp = NULL;
4759 if ( SQL_ISTOKEN( pCompare, BETWEEN) && pLiteral2 )
4760 pComp = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::between_predicate_part_2));
4761 else
4762 pComp = new OSQLInternalNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::comparison_predicate));
4763
4764 pComp->append(pColumnRef);
4765 pComp->append(pCompare);
4766 pComp->append(pLiteral);
4767 if ( pLiteral2 )
4768 {
4769 pComp->append(new OSQLInternalNode(aEmptyString, SQL_NODE_KEYWORD,SQL_TOKEN_AND));
4770 pComp->append(pLiteral2);
4771 }
4772 pAppend->append(pComp);
4773 return 1;
4774 }
4775 //-----------------------------------------------------------------------------
4776 sal_Int16 OSQLParser::buildStringNodes(OSQLParseNode*& pLiteral)
4777 {
4778 if(!pLiteral)
4779 return 1;
4780
4781 if(SQL_ISRULE(pLiteral,set_fct_spec) || SQL_ISRULE(pLiteral,general_set_fct) || SQL_ISRULE(pLiteral,column_ref)
4782 || SQL_ISRULE(pLiteral,subquery))
4783 return 1; // here I have a function that I can't transform into a string
4784
4785 if(pLiteral->getNodeType() == SQL_NODE_INTNUM || pLiteral->getNodeType() == SQL_NODE_APPROXNUM || pLiteral->getNodeType() == SQL_NODE_ACCESS_DATE)
4786 {
4787 OSQLParseNode* pParent = pLiteral->getParent();
4788
4789 OSQLParseNode* pNewNode = new OSQLInternalNode(pLiteral->getTokenValue(), SQL_NODE_STRING);
4790 pParent->replace(pLiteral, pNewNode);
4791 delete pLiteral;
4792 pLiteral = NULL;
4793 return 1;
4794 }
4795
4796 for(sal_uInt32 i=0;i<pLiteral->count();++i)
4797 {
4798 OSQLParseNode* pChild = pLiteral->getChild(i);
4799 buildStringNodes(pChild);
4800 }
4801 if(SQL_ISRULE(pLiteral,term) || SQL_ISRULE(pLiteral,value_exp_primary))
4802 {
4803 m_sErrorMessage = m_pContext->getErrorMessage(IParseContext::ERROR_INVALID_COMPARE);
4804 return 0;
4805 }
4806 return 1;
4807 }
4808 //-----------------------------------------------------------------------------
4809 sal_Int16 OSQLParser::buildComparsionRule(OSQLParseNode*& pAppend,OSQLParseNode* pLiteral)
4810 {
4811 OSQLParseNode* pComp = new OSQLInternalNode(::rtl::OUString("="), SQL_NODE_EQUAL);
4812 return buildPredicateRule(pAppend,pLiteral,pComp);
4813 }
4814
4815
4816 //-----------------------------------------------------------------------------
4817 void OSQLParser::reduceLiteral(OSQLParseNode*& pLiteral, sal_Bool bAppendBlank)
4818 {
4819 OSL_ENSURE(pLiteral->isRule(), "This is no ::com::sun::star::chaos::Rule");
4820 OSL_ENSURE(pLiteral->count() == 2, "OSQLParser::ReduceLiteral() Invalid count");
4821 OSQLParseNode* pTemp = pLiteral;
4822 ::rtl::OUStringBuffer aValue(pLiteral->getChild(0)->getTokenValue());
4823 if (bAppendBlank)
4824 {
4825 aValue.appendAscii(" ");
4826 }
4827
4828 aValue.append(pLiteral->getChild(1)->getTokenValue());
4829
4830 pLiteral = new OSQLInternalNode(aValue.makeStringAndClear(),SQL_NODE_STRING);
4831 delete pTemp;
4832 }
4833
4834 // -------------------------------------------------------------------------
4835 void OSQLParser::error(const sal_Char *fmt)
4836 {
4837 if(m_sErrorMessage.isEmpty())
4838 {
4839 ::rtl::OUString sStr(fmt,strlen(fmt),RTL_TEXTENCODING_UTF8);
4840 ::rtl::OUString sSQL_TOKEN("SQL_TOKEN_");
4841
4842 sal_Int32 nPos1 = sStr.indexOf(sSQL_TOKEN);
4843 if(nPos1 != -1)
4844 {
4845 ::rtl::OUString sFirst = sStr.copy(0,nPos1);
4846 sal_Int32 nPos2 = sStr.indexOf(sSQL_TOKEN,nPos1+1);
4847 if(nPos2 != -1)
4848 {
4849 ::rtl::OUString sSecond = sStr.copy(nPos1+sSQL_TOKEN.getLength(),nPos2-nPos1-sSQL_TOKEN.getLength());
4850 sFirst += sSecond;
4851 sFirst += sStr.copy(nPos2+sSQL_TOKEN.getLength());
4852 }
4853 else
4854 sFirst += sStr.copy(nPos1+sSQL_TOKEN.getLength());
4855
4856 m_sErrorMessage = sFirst;
4857 }
4858 else
4859 m_sErrorMessage = sStr;
4860
4861 ::rtl::OUString aError = s_pScanner->getErrorMessage();
4862 if(!aError.isEmpty())
4863 {
4864 m_sErrorMessage += ::rtl::OUString(", ");
4865 m_sErrorMessage += aError;
4866 }
4867 }
4868 }
4869 // -------------------------------------------------------------------------
4870 int OSQLParser::SQLlex()
4871 {
4872 return s_pScanner->SQLlex();
4873 }
4874
4875 #if defined __SUNPRO_CC
4876 #pragma enable_warn
4877 #elif defined _MSC_VER
4878 #pragma warning(pop)
4879 #endif
FREE OFFICE SUITE