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