3
* PROGRAM: Dynamic SQL runtime support
5
* DESCRIPTION: Dynamic SQL parser
7
* The contents of this file are subject to the Interbase Public
8
* License Version 1.0 (the "License"); you may not use this file
9
* except in compliance with the License. You may obtain a copy
10
* of the License at http://www.Inprise.com/IPL.html
12
* Software distributed under the License is distributed on an
13
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
14
* or implied. See the License for the specific language governing
15
* rights and limitations under the License.
17
* The Original Code was created by Inprise Corporation
18
* and its predecessors. Portions created by Inprise Corporation are
19
* Copyright (C) Inprise Corporation.
21
* All Rights Reserved.
22
* Contributor(s): ______________________________________.
24
* 2002-02-24 Sean Leyne - Code Cleanup of old Win 3.1 port (WINDOWS_ONLY)
25
* 2001.05.20 Neil McCalden: Allow a udf to be used in a 'group by' clause.
26
* 2001.05.30 Claudio Valderrama: DROP TABLE and DROP VIEW lead now to two
27
* different node types so DDL can tell which is which.
28
* 2001.06.13 Claudio Valderrama: SUBSTRING is being surfaced.
29
* 2001.06.30 Claudio valderrama: Feed (line,column) for each node. See node.h.
30
* 2001.07.10 Claudio Valderrama: Better (line,column) report and "--" for comments.
31
* 2001.07.28 John Bellardo: Changes to support parsing LIMIT and FIRST
32
* 2001.08.03 John Bellardo: Finalized syntax for LIMIT, change LIMIT to SKIP
33
* 2001.08.05 Claudio Valderrama: closed Bug #448062 and other spaces that appear
34
* in rdb$*_source fields when altering domains plus one unexpected null pointer.
35
* 2001.08.12 Claudio Valderrama: adjust SUBSTRING's starting pos argument here
36
* and not in gen.c; this closes Bug #450301.
37
* 2001.10.01 Claudio Valderrama: enable explicit GRANT...to ROLE role_name.
38
* 2001.10.06 Claudio Valderrama: Honor explicit USER keyword in GRANTs and REVOKEs.
39
* 2002.07.05 Mark O'Donohue: change keyword DEBUG to KW_DEBUG to avoid
40
* clashes with normal DEBUG macro.
41
* 2002.07.30 Arno Brinkman:
42
* 2002.07.30 Let IN predicate handle value_expressions
43
* 2002.07.30 tokens CASE, NULLIF, COALESCE added
44
* 2002.07.30 See block < CASE expression > what is added to value as case_expression
45
* 2002.07.30 function is split up into aggregate_function, numeric_value_function, string_value_function, generate_value_function
46
* 2002.07.30 new group_by_function and added to grp_column_elem
47
* 2002.07.30 cast removed from function and added as cast_specification to value
48
* 2002.08.04 Claudio Valderrama: allow declaring and defining variables at the same time
49
* 2002.08.04 Dmitry Yemanov: ALTER VIEW
50
* 2002.08.06 Arno Brinkman: ordinal added to grp_column_elem for using positions in group by
51
* 2002.08.07 Dmitry Yemanov: INT64/LARGEINT are replaced with BIGINT and available in dialect 3 only
52
* 2002.08.31 Dmitry Yemanov: allowed user-defined index names for PK/FK/UK constraints
53
* 2002.09.01 Dmitry Yemanov: RECREATE VIEW
54
* 2002.09.28 Dmitry Yemanov: Reworked internal_info stuff, enhanced
55
* exception handling in SPs/triggers,
56
* implemented ROWS_AFFECTED system variable
57
* 2002.10.21 Nickolay Samofatov: Added support for explicit pessimistic locks
58
* 2002.10.29 Nickolay Samofatov: Added support for savepoints
59
* 2002.12.03 Dmitry Yemanov: Implemented ORDER BY clause in subqueries.
60
* 2002.12.18 Dmitry Yemanov: Added support for SQL-compliant labels and LEAVE statement
61
* 2002.12.28 Dmitry Yemanov: Added support for parametrized events.
62
* 2003.01.14 Dmitry Yemanov: Fixed bug with cursors in triggers.
63
* 2003.01.15 Dmitry Yemanov: Added support for runtime trigger action checks.
64
* 2003.02.10 Mike Nordell : Undefined Microsoft introduced macros to get a clean compile.
65
* 2003.05.24 Nickolay Samofatov: Make SKIP and FIRST non-reserved keywords
66
* 2003.06.13 Nickolay Samofatov: Make INSERTING/UPDATING/DELETING non-reserved keywords
67
* 2003.07.01 Blas Rodriguez Somoza: Change DEBUG and IN to avoid conflicts in win32 build/bison
68
* 2003.08.11 Arno Brinkman: Changed GROUP BY to support all expressions and added "AS" support
69
* with table alias. Also removed group_by_function and ordinal.
70
* 2003.08.14 Arno Brinkman: Added support for derived tables.
71
* 2003.10.05 Dmitry Yemanov: Added support for explicit cursors in PSQL.
72
* 2004.01.16 Vlad Horsun: added support for default parameters and
73
* EXECUTE BLOCK statement
74
* Adriano dos Santos Fernandes
81
#include "../jrd/common.h"
84
#include "gen/iberror.h"
85
#include "../dsql/dsql.h"
86
#include "../jrd/ibase.h"
87
#include "../jrd/flags.h"
88
#include "../dsql/errd_proto.h"
89
#include "../dsql/hsh_proto.h"
90
#include "../dsql/make_proto.h"
91
#include "../dsql/keywords.h"
92
#include "../dsql/misc_func.h"
93
#include "../jrd/gds_proto.h"
94
#include "../jrd/thd.h"
95
#include "../jrd/err_proto.h"
96
#include "../jrd/intlobj_new.h"
98
/* since UNIX isn't standard, we have to define
99
stuff which is in <limits.h> (which isn't available
102
const long SHRT_POS_MAX = 32767;
103
const long SHRT_UNSIGNED_MAX = 65535;
104
const long SHRT_NEG_MAX = 32768;
105
const long LONG_POS_MAX = 2147483647;
106
const int POSITIVE = 0;
107
const int NEGATIVE = 1;
108
const int UNSIGNED = 2;
110
//const int MIN_CACHE_BUFFERS = 250;
111
//const int DEF_CACHE_BUFFERS = 1000;
113
/* Fix 69th procedure problem - solution from Oleg Loa */
114
#define YYSTACKSIZE 2048
115
#define YYMAXDEPTH 2048
117
/* Make bison allocate static stack */
118
#define YYINITDEPTH 2048
120
// Using this option causes build problems on Win32 with bison 1.28
121
//#define YYSTACK_USE_ALLOCA 1
123
typedef dsql_nod* YYSTYPE;
124
#define YYSTYPE YYSTYPE
125
#if defined(DEBUG) || defined(DEV_BUILD)
129
#define YYMALLOC gds__alloc
130
#define YYFREE gds__free
132
static const char INTERNAL_FIELD_NAME[] = "DSQL internal"; /* NTX: placeholder */
134
inline SLONG trigger_type_suffix(const int slot1, const int slot2, const int slot3)
136
return ((slot1 << 1) | (slot2 << 3) | (slot3 << 5));
140
dsql_nod* DSQL_parse;
143
#define YYPARSE_PARAM_TYPE
144
#define YYPARSE_PARAM USHORT client_dialect, USHORT db_dialect, USHORT parser_version, bool* stmt_ambiguous
146
#include "../dsql/chars.h"
148
const int MAX_TOKEN_LEN = 256;
150
static const TEXT* lex_position();
151
#ifdef NOT_USED_OR_REPLACED
152
static bool long_int(dsql_nod*, SLONG*);
154
static dsql_fld* make_field (dsql_nod*);
155
static dsql_fil* make_file();
156
static dsql_nod* make_list (dsql_nod*);
157
static dsql_nod* make_node (NOD_TYPE, int, ...);
158
static dsql_nod* make_parameter (void);
159
static dsql_nod* make_flag_node (NOD_TYPE, SSHORT, int, ...);
160
static void prepare_console_debug (int, int *);
161
#ifdef NOT_USED_OR_REPLACED
162
static bool short_int(dsql_nod*, SLONG*, SSHORT);
164
static void stack_nodes (dsql_nod*, DsqlNodStack&);
165
inline static int yylex (USHORT, USHORT, USHORT, bool*);
167
static void yyerror(const TEXT*);
168
static void yyabandon (SLONG, ISC_STATUS);
170
inline void check_bound(const char* const to, const char* const string)
172
if ((to - string) >= MAX_TOKEN_LEN)
173
yyabandon (-104, isc_token_too_long);
176
inline void check_copy_incr(char*& to, const char ch, const char* const string)
178
check_bound(to, string);
183
/* This is, in fact, parser state. Not used in lexer itself */
186
dsql_nod* g_field_name;
189
/* Actual lexer state begins from here */
190
const TEXT* beginning;
193
const TEXT* last_token;
194
const TEXT* line_start;
195
const TEXT* last_token_bk;
196
const TEXT* line_start_bk;
197
SSHORT lines, att_charset;
203
USHORT client_dialect,
205
USHORT parser_version,
206
bool* stmt_ambiguous);
209
/* Get ready for thread-safety. Move this to BISON object pointer when we
210
switch to generating "pure" reenterant parser. */
211
static LexerState lex;
216
/* token declarations */
218
/* Tokens are organized chronologically by date added.
219
See dsql/keywords.cpp for a list organized alphabetically */
221
/* Tokens in v4.0 -- not separated into v3 and v4 tokens */
367
%token RETURNING_VALUES
415
%token FLOAT_NUMBER NUMBER NUMERIC SYMBOL STRING INTRODUCER
417
/* New tokens added v5.0 */
422
%token FREE_IT /* ISC SQL extension */
426
/* New tokens added v6.0 */
437
%token WEEKDAY /* ISC SQL extension */
438
%token YEARDAY /* ISC SQL extension */
443
%token CURRENT_TIMESTAMP
445
/* special aggregate token types returned by lex in v6.0 */
447
%token NUMBER64BIT SCALEDINT
449
/* CVC: Special Firebird additions. */
460
/* tokens added for Firebird 1.5 */
462
%token CURRENT_CONNECTION
463
%token CURRENT_TRANSACTION
481
/* tokens added for Firebird 2.0 */
501
%token CHARACTER_LENGTH
514
/* tokens added for Firebird 2.1 */
582
/* precedence declarations for expression evaluation */
587
%left '=' '<' '>' LIKE EQL NEQ GTR LSS GEQ LEQ NOT_GTR NOT_LSS
593
/* Fix the dangling IF-THEN-ELSE problem */
597
/* The same issue exists with ALTER COLUMN now that keywords can be used
598
in order to change their names. The syntax which shows the issue is:
599
ALTER COLUMN where column is part of the alter statement
601
ALTER COLUMN where column is the name of the column in the relation
608
/* list of possible statements */
638
| KW_DEBUG signed_short_integer
639
{ prepare_console_debug ((IPTR) $2, &yydebug);
640
$$ = make_node (nod_null, (int) 0, NULL); }
644
/* GRANT statement */
646
grant : GRANT privileges ON table_noise simple_table_name
647
TO non_role_grantee_list grant_option
648
{ $$ = make_node (nod_grant, (int) e_grant_count,
649
$2, $5, make_list($7), $8); }
650
| GRANT proc_privileges ON PROCEDURE simple_proc_name
651
TO non_role_grantee_list grant_option
652
{ $$ = make_node (nod_grant, (int) e_grant_count,
653
$2, $5, make_list($7), $8); }
654
| GRANT role_name_list TO role_grantee_list role_admin_option
655
{ $$ = make_node (nod_grant, (int) e_grant_count,
656
make_list($2), make_list($4), NULL, $5); }
664
{ $$ = make_node (nod_all, (int) 0, NULL); }
666
{ $$ = make_node (nod_all, (int) 0, NULL); }
668
{ $$ = make_list ($1); }
671
privilege_list : privilege
672
| privilege_list ',' privilege
673
{ $$ = make_node (nod_list, (int) 2, $1, $3); }
676
proc_privileges : EXECUTE
677
{ $$ = make_list (make_node (nod_execute, (int) 0, NULL)); }
681
{ $$ = make_node (nod_select, (int) 0, NULL); }
683
{ $$ = make_node (nod_insert, (int) 0, NULL); }
685
{ $$ = make_node (nod_delete, (int) 0, NULL); }
686
| UPDATE column_parens_opt
687
{ $$ = make_node (nod_update, (int) 1, $2); }
688
| REFERENCES column_parens_opt
689
{ $$ = make_node (nod_references, (int) 1, $2); }
692
grant_option : WITH GRANT OPTION
693
{ $$ = make_node (nod_grant, (int) 0, NULL); }
698
role_admin_option : WITH ADMIN OPTION
699
{ $$ = make_node (nod_grant_admin, (int) 0, NULL); }
704
simple_proc_name: symbol_procedure_name
705
{ $$ = make_node (nod_procedure_name, (int) 1, $1); }
709
/* REVOKE statement */
711
revoke : REVOKE rev_grant_option privileges ON table_noise simple_table_name
712
FROM non_role_grantee_list
713
{ $$ = make_node (nod_revoke, (int) e_grant_count,
714
$3, $6, make_list($8), $2); }
715
| REVOKE rev_grant_option proc_privileges ON PROCEDURE simple_proc_name
716
FROM non_role_grantee_list
717
{ $$ = make_node (nod_revoke, (int) e_grant_count,
718
$3, $6, make_list($8), $2); }
719
| REVOKE rev_admin_option role_name_list FROM role_grantee_list
720
{ $$ = make_node (nod_revoke, (int) e_grant_count,
721
make_list($3), make_list($5), NULL, $2); }
724
rev_grant_option : GRANT OPTION FOR
725
{ $$ = make_node (nod_grant, (int) 0, NULL); }
730
rev_admin_option : ADMIN OPTION FOR
731
{ $$ = make_node (nod_grant_admin, (int) 0, NULL); }
736
non_role_grantee_list : grantee_list
740
grantee_list : grantee
741
| grantee_list ',' grantee
742
{ $$ = make_node (nod_list, (int) 2, $1, $3); }
743
| grantee_list ',' user_grantee
744
{ $$ = make_node (nod_list, (int) 2, $1, $3); }
745
| user_grantee_list ',' grantee
746
{ $$ = make_node (nod_list, (int) 2, $1, $3); }
749
grantee : PROCEDURE symbol_procedure_name
750
{ $$ = make_node (nod_proc_obj, (int) 1, $2); }
751
| TRIGGER symbol_trigger_name
752
{ $$ = make_node (nod_trig_obj, (int) 1, $2); }
753
| VIEW symbol_view_name
754
{ $$ = make_node (nod_view_obj, (int) 1, $2); }
755
| ROLE symbol_role_name
756
{ $$ = make_node (nod_role_name, (int) 1, $2); }
759
user_grantee_list : user_grantee
760
| user_grantee_list ',' user_grantee
761
{ $$ = make_node (nod_list, (int) 2, $1, $3); }
764
/* CVC: In the future we can deprecate the first implicit form since we'll support
765
explicit grant/revoke for both USER and ROLE keywords & object types. */
767
user_grantee : symbol_user_name
768
{ $$ = make_node (nod_user_name, (int) 1, $1); }
769
| USER symbol_user_name
770
{ $$ = make_node (nod_user_name, (int) 2, $2, NULL); }
771
| GROUP symbol_user_name
772
{ $$ = make_node (nod_user_group, (int) 1, $2); }
775
role_name_list : role_name
776
| role_name_list ',' role_name
777
{ $$ = make_node (nod_list, (int) 2, $1, $3); }
780
role_name : symbol_role_name
781
{ $$ = make_node (nod_role_name, (int) 1, $1); }
784
role_grantee_list : role_grantee
785
| role_grantee_list ',' role_grantee
786
{ $$ = make_node (nod_list, (int) 2, $1, $3); }
789
role_grantee : symbol_user_name
790
{ $$ = make_node (nod_user_name, (int) 1, $1); }
791
| USER symbol_user_name
792
{ $$ = make_node (nod_user_name, (int) 1, $2); }
796
/* DECLARE operations */
798
declare : DECLARE declare_clause
802
declare_clause : FILTER filter_decl_clause
804
| EXTERNAL FUNCTION udf_decl_clause
809
udf_decl_clause : symbol_UDF_name arg_desc_list1 RETURNS return_value1
810
ENTRY_POINT sql_string MODULE_NAME sql_string
811
{ $$ = make_node (nod_def_udf, (int) e_udf_count,
812
$1, $6, $8, make_list ($2), $4); }
815
udf_data_type : simple_type
817
{ lex.g_field->fld_dtype = dtype_blob; }
818
| CSTRING '(' pos_short_integer ')' charset_clause
820
lex.g_field->fld_dtype = dtype_cstring;
821
lex.g_field->fld_character_length = (USHORT)(IPTR) $3; }
827
| '(' arg_desc_list ')'
831
arg_desc_list : arg_desc
832
| arg_desc_list ',' arg_desc
833
{ $$ = make_node (nod_list, (int) 2, $1, $3); }
836
/*arg_desc : init_data_type udf_data_type
838
arg_desc : init_data_type udf_data_type param_mechanism
839
{ $$ = make_node (nod_udf_param, (int) e_udf_param_count,
844
{ $$ = NULL; } /* Beware: ddl.cpp converts this to mean FUN_reference. */
846
{ $$ = MAKE_const_slong (Jrd::FUN_descriptor); }
848
{ $$ = MAKE_const_slong (Jrd::FUN_scalar_array); }
850
{ $$ = MAKE_const_slong (Jrd::FUN_ref_with_null); }
853
return_value1 : return_value
854
| '(' return_value ')'
858
return_value : init_data_type udf_data_type return_mechanism
859
{ $$ = make_node (nod_udf_return_value, (int) e_udf_param_count,
861
| PARAMETER pos_short_integer
862
{ $$ = make_node (nod_udf_return_value, (int) e_udf_param_count,
863
NULL, MAKE_const_slong ((IPTR) $2));}
867
{ $$ = MAKE_const_slong (Jrd::FUN_reference); }
869
{ $$ = MAKE_const_slong (Jrd::FUN_value); }
871
{ $$ = MAKE_const_slong (Jrd::FUN_descriptor); }
873
{ $$ = MAKE_const_slong (-1 * Jrd::FUN_reference); }
874
/* FUN_refrence with FREE_IT is -ve */
875
| BY KW_DESCRIPTOR FREE_IT
876
{ $$ = MAKE_const_slong (-1 * Jrd::FUN_descriptor); }
880
filter_decl_clause : symbol_filter_name INPUT_TYPE blob_filter_subtype OUTPUT_TYPE blob_filter_subtype
881
ENTRY_POINT sql_string MODULE_NAME sql_string
882
{ $$ = make_node (nod_def_filter, (int) e_filter_count,
883
$1, $3, $5, $7, $9); }
886
blob_filter_subtype : symbol_blob_subtype_name
887
{ $$ = MAKE_constant ((dsql_str*) $1, CONSTANT_STRING); }
890
{ $$ = MAKE_const_slong ((IPTR) $1); }
893
/* CREATE metadata operations */
895
create : CREATE create_clause
899
create_clause : EXCEPTION exception_clause
901
| unique_opt order_direction INDEX symbol_index_name ON simple_table_name index_definition
902
{ $$ = make_node (nod_def_index, (int) e_idx_count,
903
$1, $2, $4, $6, $7); }
904
| PROCEDURE procedure_clause
908
| GLOBAL TEMPORARY TABLE gtt_table_clause
910
| TRIGGER trigger_clause
914
| GENERATOR generator_clause
916
| SEQUENCE generator_clause
920
| DOMAIN domain_clause
922
| SHADOW shadow_clause
926
| COLLATION collation_clause
931
recreate : RECREATE recreate_clause
935
recreate_clause : PROCEDURE rprocedure_clause
937
| TABLE rtable_clause
939
| GLOBAL TEMPORARY TABLE gtt_recreate_clause
943
| TRIGGER rtrigger_clause
946
| DOMAIN rdomain_clause
949
| EXCEPTION rexception_clause
953
create_or_alter : CREATE OR ALTER replace_clause
957
replace_clause : PROCEDURE replace_procedure_clause
959
| TRIGGER replace_trigger_clause
962
| VIEW replace_view_clause
965
| EXCEPTION replace_exception_clause
970
/* CREATE EXCEPTION */
972
exception_clause : symbol_exception_name sql_string
973
{ $$ = make_node (nod_def_exception, (int) e_xcp_count,
977
rexception_clause : symbol_exception_name sql_string
978
{ $$ = make_node (nod_redef_exception, (int) e_xcp_count,
982
replace_exception_clause : symbol_exception_name sql_string
983
{ $$ = make_node (nod_replace_exception, (int) e_xcp_count,
987
alter_exception_clause : symbol_exception_name sql_string
988
{ $$ = make_node (nod_mod_exception, (int) e_xcp_count,
996
{ $$ = make_node (nod_unique, 0, NULL); }
1001
index_definition : column_list
1002
{ $$ = make_list ($1); }
1004
| computed_by '(' begin_trigger value end_trigger ')'
1005
{ $$ = make_node (nod_def_computed, 2, $4, $5); }
1010
shadow_clause : pos_short_integer manual_auto conditional sql_string
1011
first_file_length sec_shadow_files
1012
{ $$ = make_node (nod_def_shadow, (int) e_shadow_count,
1013
$1, $2, $3, $4, $5, make_list ($6)); }
1016
manual_auto : MANUAL
1017
{ $$ = MAKE_const_slong (1); }
1019
{ $$ = MAKE_const_slong (0); }
1021
{ $$ = MAKE_const_slong (0); }
1025
{ $$ = MAKE_const_slong (0); }
1027
{ $$ = MAKE_const_slong (1); }
1031
{ $$ = (dsql_nod*) 0;}
1032
| LENGTH equals long_integer page_noise
1041
db_file_list : db_file
1042
| db_file_list db_file
1043
{ $$ = make_node (nod_list, (int) 2, $1, $2); }
1049
domain_clause : column_def_name
1055
domain_constraint_clause
1057
{ $$ = make_node (nod_def_domain, (int) e_dom_count,
1058
$1, $5, $6, make_list ($7), $8); }
1062
rdomain_clause : DOMAIN alter_column_name alter_domain_ops
1063
{ $$ = make_node (nod_mod_domain, (int) e_alt_count,
1064
$2, make_list ($3)); }
1073
domain_default : DEFAULT begin_trigger default_value
1077
domain_default_opt : domain_default
1082
domain_constraint_clause : domain_constraint_list
1087
domain_constraint_list : domain_constraint_def
1088
| domain_constraint_list domain_constraint_def
1089
{ $$ = make_node (nod_list, (int) 2, $1, $2); }
1092
domain_constraint_def : domain_constraint
1093
{ $$ = make_node (nod_rel_constraint, (int) 2, NULL, $1);}
1096
domain_constraint : null_constraint
1100
null_constraint : NOT KW_NULL
1101
{ $$ = make_node (nod_null, (int) 0, NULL); }
1104
check_constraint : CHECK begin_trigger '(' search_condition ')' end_trigger
1105
{ $$ = make_node (nod_def_constraint, (int) e_cnstr_count,
1106
NULL, NULL, $4, NULL, $6); }
1110
/* CREATE SEQUENCE/GENERATOR */
1112
generator_clause : symbol_generator_name
1113
{ $$ = make_node (nod_def_generator, (int) e_gen_count, $1); }
1119
role_clause : symbol_role_name
1120
{ $$ = make_node (nod_def_role, (int) 1, $1); }
1124
/* CREATE COLLATION */
1126
collation_clause : symbol_collation_name FOR symbol_character_set_name
1127
collation_sequence_definition
1128
collation_attribute_list_opt collation_specific_attribute_opt
1129
{ $$ = make_node (nod_def_collation,
1130
(int) e_def_coll_count, $1, $3, $4, make_list($5), $6); }
1133
collation_sequence_definition :
1134
FROM symbol_collation_name
1135
{ $$ = make_node(nod_collation_from, 1, $2); }
1136
| FROM EXTERNAL '(' sql_string ')'
1137
{ $$ = make_node(nod_collation_from_external, 1, $4); }
1142
collation_attribute_list_opt :
1144
| collation_attribute_list
1147
collation_attribute_list : collation_attribute
1148
| collation_attribute_list collation_attribute
1149
{ $$ = make_node(nod_list, 2, $1, $2); }
1152
collation_attribute :
1153
collation_pad_attribute
1154
| collation_case_attribute
1155
| collation_accent_attribute
1158
collation_pad_attribute : NO PAD
1159
{ $$ = make_node(nod_collation_attr, 1, -TEXTTYPE_ATTR_PAD_SPACE); }
1161
{ $$ = make_node(nod_collation_attr, 1, TEXTTYPE_ATTR_PAD_SPACE); }
1164
collation_case_attribute : CASE SENSITIVE
1165
{ $$ = make_node(nod_collation_attr, 1, -TEXTTYPE_ATTR_CASE_INSENSITIVE); }
1167
{ $$ = make_node(nod_collation_attr, 1, TEXTTYPE_ATTR_CASE_INSENSITIVE); }
1170
collation_accent_attribute : ACCENT SENSITIVE
1171
{ $$ = make_node(nod_collation_attr, 1, -TEXTTYPE_ATTR_ACCENT_INSENSITIVE); }
1172
| ACCENT INSENSITIVE
1173
{ $$ = make_node(nod_collation_attr, 1, TEXTTYPE_ATTR_ACCENT_INSENSITIVE); }
1176
collation_specific_attribute_opt :
1179
{ $$ = make_node(nod_collation_specific_attr, 1,
1180
MAKE_constant((dsql_str*)$1, CONSTANT_STRING)); }
1184
/* CREATE DATABASE */
1186
db_clause : db_name db_initial_desc1 db_rem_desc1
1187
{ $$ = make_node (nod_def_database, (int) e_cdb_count,
1188
$1, make_list($2), make_list ($3));}
1195
db_name : sql_string
1196
{ $$ = (dsql_nod*) $1; }
1204
db_initial_desc : db_initial_option
1205
| db_initial_desc db_initial_option
1206
{ $$ = make_node (nod_list, 2, $1, $2); }
1209
db_initial_option: KW_PAGE_SIZE equals pos_short_integer
1210
{ $$ = make_node (nod_page_size, 1, $3);}
1211
| LENGTH equals long_integer page_noise
1212
{ $$ = make_node (nod_file_length, 1, $3);}
1214
{ $$ = make_node (nod_user_name, 1, $2);}
1215
| PASSWORD sql_string
1216
{ $$ = make_node (nod_password, 1, $2);}
1217
| SET NAMES sql_string
1218
{ $$ = make_node (nod_lc_ctype, 1, $3);}
1226
db_rem_desc : db_rem_option
1227
| db_rem_desc db_rem_option
1228
{ $$ = make_node (nod_list, 2, $1, $2); }
1231
db_rem_option : db_file
1232
| DEFAULT CHARACTER SET symbol_character_set_name
1233
{ $$ = make_node (nod_dfl_charset, 1, $4);}
1234
| KW_DIFFERENCE KW_FILE sql_string
1235
{ $$ = make_node (nod_difference_file, 1, $3); }
1238
db_file : file1 sql_string file_desc1
1239
{ lex.g_file->fil_name = (dsql_str*) $2;
1240
$$ = (dsql_nod*) make_node (nod_file_desc, (int) 1,
1241
(dsql_nod*) lex.g_file); }
1245
{ lex.g_file = make_file();}
1252
file_desc : file_clause
1253
| file_desc file_clause
1256
file_clause : STARTING file_clause_noise long_integer
1257
{ lex.g_file->fil_start = (IPTR) $3;}
1258
| LENGTH equals long_integer page_noise
1259
{ lex.g_file->fil_length = (IPTR) $3;}
1275
table_clause : simple_table_name external_file '(' table_elements ')'
1276
{ $$ = make_flag_node (nod_def_relation, NOD_PERMANENT_TABLE,
1277
(int) e_drl_count, $1, make_list ($4), $2); }
1280
rtable_clause : simple_table_name external_file '(' table_elements ')'
1281
{ $$ = make_flag_node (nod_redef_relation, NOD_PERMANENT_TABLE,
1282
(int) e_drl_count, $1, make_list ($4), $2); }
1285
gtt_table_clause : simple_table_name '(' table_elements ')' gtt_scope
1286
{ $$ = make_flag_node (nod_def_relation, (SSHORT) (IPTR) ($5),
1287
(int) e_drl_count, $1, make_list ($3), NULL); }
1290
gtt_recreate_clause : simple_table_name '(' table_elements ')' gtt_scope
1291
{ $$ = make_flag_node (nod_redef_relation, (SSHORT) (IPTR) ($5),
1292
(int) e_drl_count, $1, make_list ($3), NULL); }
1295
gtt_scope : ON COMMIT PRESERVE ROWS
1296
{ $$ = (dsql_nod*) NOD_GLOBAL_TEMP_TABLE_PRESERVE_ROWS; }
1297
| ON COMMIT KW_DELETE ROWS
1298
{ $$ = (dsql_nod*) NOD_GLOBAL_TEMP_TABLE_DELETE_ROWS; }
1300
{ $$ = (dsql_nod*) NOD_GLOBAL_TEMP_TABLE_DELETE_ROWS; }
1303
external_file : EXTERNAL KW_FILE sql_string
1305
| EXTERNAL sql_string
1311
table_elements : table_element
1312
| table_elements ',' table_element
1313
{ $$ = make_node (nod_list, 2, $1, $3); }
1316
table_element : column_def
1317
| table_constraint_definition
1322
/* column definition */
1324
column_def : column_def_name data_type_or_domain domain_default_opt
1325
end_default_opt column_constraint_clause collate_clause
1326
{ $$ = make_node (nod_def_field, (int) e_dfl_count,
1327
$1, $3, $4, make_list ($5), $6, $2, NULL); }
1328
| column_def_name non_array_type def_computed
1329
{ $$ = make_node (nod_def_field, (int) e_dfl_count,
1330
$1, NULL, NULL, NULL, NULL, NULL, $3); }
1331
| column_def_name def_computed
1332
{ $$ = make_node (nod_def_field, (int) e_dfl_count,
1333
$1, NULL, NULL, NULL, NULL, NULL, $2); }
1336
/* value does allow parens around it, but there is a problem getting the
1340
def_computed : computed_clause '(' begin_trigger value end_trigger ')'
1342
lex.g_field->fld_flags |= FLD_computed;
1343
$$ = make_node (nod_def_computed, 2, $4, $5); }
1346
computed_clause : computed_by
1347
| GENERATED ALWAYS AS
1350
computed_by : COMPUTED BY
1354
data_type_or_domain : data_type begin_trigger
1356
| simple_column_name begin_string
1357
{ $$ = make_node (nod_def_domain, (int) e_dom_count,
1358
$1, NULL, NULL, NULL, NULL); }
1361
collate_clause : COLLATE symbol_collation_name
1368
column_def_name : simple_column_name
1369
{ lex.g_field_name = $1;
1370
lex.g_field = make_field ($1);
1371
$$ = (dsql_nod*) lex.g_field; }
1374
simple_column_def_name : simple_column_name
1375
{ lex.g_field = make_field ($1);
1376
$$ = (dsql_nod*) lex.g_field; }
1380
data_type_descriptor : init_data_type data_type
1382
| TYPE OF column_def_name
1384
((dsql_fld*) $3)->fld_type_of_name = ((dsql_fld*) $3)->fld_name;
1389
((dsql_fld*) $1)->fld_type_of_name = ((dsql_fld*) $1)->fld_name;
1390
((dsql_fld*) $1)->fld_full_domain = true;
1396
{ lex.g_field = make_field (NULL);
1397
$$ = (dsql_nod*) lex.g_field; }
1401
default_value : constant
1406
| datetime_value_expression
1409
column_constraint_clause :
1411
| column_constraint_list
1414
column_constraint_list : column_constraint_def
1415
| column_constraint_list column_constraint_def
1416
{ $$ = make_node (nod_list, (int) 2, $1, $2); }
1419
column_constraint_def : constraint_name_opt column_constraint
1420
{ $$ = make_node (nod_rel_constraint, (int) 2, $1, $2);}
1424
column_constraint : null_constraint
1426
| REFERENCES simple_table_name column_parens_opt
1427
referential_trigger_action constraint_index_opt
1428
{ $$ = make_node (nod_foreign, (int) e_for_count,
1429
make_node (nod_list, (int) 1, lex.g_field_name), $2, $3, $4, $5); }
1431
| UNIQUE constraint_index_opt
1432
{ $$ = make_node (nod_unique, 2, NULL, $2); }
1433
| PRIMARY KEY constraint_index_opt
1434
{ $$ = make_node (nod_primary, (int) e_pri_count, NULL, $3); }
1439
/* table constraints */
1441
table_constraint_definition : constraint_name_opt table_constraint
1442
{ $$ = make_node (nod_rel_constraint, (int) 2, $1, $2);}
1445
constraint_name_opt : CONSTRAINT symbol_constraint_name
1451
table_constraint : unique_constraint
1452
| primary_constraint
1453
| referential_constraint
1457
unique_constraint : UNIQUE column_parens constraint_index_opt
1458
{ $$ = make_node (nod_unique, 2, $2, $3); }
1461
primary_constraint : PRIMARY KEY column_parens constraint_index_opt
1462
{ $$ = make_node (nod_primary, (int) e_pri_count, $3, $4); }
1465
referential_constraint : FOREIGN KEY column_parens REFERENCES
1466
simple_table_name column_parens_opt
1467
referential_trigger_action constraint_index_opt
1468
{ $$ = make_node (nod_foreign, (int) e_for_count, $3, $5,
1472
constraint_index_opt : USING order_direction INDEX symbol_index_name
1473
{ $$ = make_node (nod_def_index, (int) e_idx_count,
1474
NULL, $2, $4, NULL, NULL); }
1480
{ $$ = make_node (nod_def_index, (int) e_idx_count,
1481
NULL, NULL, NULL, NULL, NULL); }
1484
referential_trigger_action:
1486
{ $$ = make_node (nod_ref_upd_del, (int) e_ref_upd_del_count, $1, NULL);}
1488
{ $$ = make_node (nod_ref_upd_del, (int) e_ref_upd_del_count, NULL, $1);}
1489
| delete_rule update_rule
1490
{ $$ = make_node (nod_ref_upd_del, (int) e_ref_upd_del_count, $2, $1); }
1491
| update_rule delete_rule
1492
{ $$ = make_node (nod_ref_upd_del, (int) e_ref_upd_del_count, $1, $2);}
1497
update_rule : ON UPDATE referential_action
1500
delete_rule : ON KW_DELETE referential_action
1504
referential_action: CASCADE
1505
{ $$ = make_flag_node (nod_ref_trig_action,
1506
REF_ACTION_CASCADE, (int) e_ref_trig_action_count, NULL);}
1508
{ $$ = make_flag_node (nod_ref_trig_action,
1509
REF_ACTION_SET_DEFAULT, (int) e_ref_trig_action_count, NULL);}
1511
{ $$ = make_flag_node (nod_ref_trig_action,
1512
REF_ACTION_SET_NULL, (int) e_ref_trig_action_count, NULL);}
1514
{ $$ = make_flag_node (nod_ref_trig_action,
1515
REF_ACTION_NONE, (int) e_ref_trig_action_count, NULL);}
1522
procedure_clause : symbol_procedure_name input_parameters
1525
local_declaration_list
1528
{ $$ = make_node (nod_def_procedure,
1529
(int) e_prc_count, $1, $2, $3, $6, $7, $8); }
1533
rprocedure_clause : symbol_procedure_name input_parameters
1536
local_declaration_list
1539
{ $$ = make_node (nod_redef_procedure,
1540
(int) e_prc_count, $1, $2, $3, $6, $7, $8); }
1543
replace_procedure_clause : symbol_procedure_name input_parameters
1546
local_declaration_list
1549
{ $$ = make_node (nod_replace_procedure,
1550
(int) e_prc_count, $1, $2, $3, $6, $7, $8); }
1553
alter_procedure_clause : symbol_procedure_name input_parameters
1556
local_declaration_list
1559
{ $$ = make_node (nod_mod_procedure,
1560
(int) e_prc_count, $1, $2, $3, $6, $7, $8); }
1563
input_parameters : '(' input_proc_parameters ')'
1564
{ $$ = make_list ($2); }
1569
output_parameters : RETURNS '(' output_proc_parameters ')'
1570
{ $$ = make_list ($3); }
1575
input_proc_parameters : input_proc_parameter
1576
| input_proc_parameters ',' input_proc_parameter
1577
{ $$ = make_node (nod_list, 2, $1, $3); }
1580
input_proc_parameter : simple_column_def_name domain_or_non_array_type collate_clause
1581
begin_trigger default_par_opt end_default_opt
1582
{ $$ = make_node (nod_def_field, (int) e_dfl_count,
1583
$1, $5, $6, NULL, $3, NULL, NULL); }
1586
output_proc_parameters : proc_parameter
1587
| output_proc_parameters ',' proc_parameter
1588
{ $$ = make_node (nod_list, 2, $1, $3); }
1591
proc_parameter : simple_column_def_name domain_or_non_array_type collate_clause
1592
{ $$ = make_node (nod_def_field, (int) e_dfl_count,
1593
$1, NULL, NULL, NULL, $3, NULL, NULL); }
1596
default_par_opt : DEFAULT begin_trigger default_value
1598
| '=' begin_trigger default_value
1604
local_declaration_list : local_declarations
1605
{ $$ = make_list ($1); }
1610
local_declarations : local_declaration
1611
| local_declarations local_declaration
1612
{ $$ = make_node (nod_list, 2, $1, $2); }
1615
local_declaration : stmt_start_line stmt_start_column DECLARE var_decl_opt local_declaration_item ';'
1618
$$->nod_line = (IPTR) $1;
1619
$$->nod_column = (IPTR) $2;
1623
local_declaration_item : var_declaration_item
1624
| cursor_declaration_item
1627
var_declaration_item : column_def_name domain_or_non_array_type collate_clause var_init_opt
1628
{ $$ = make_node (nod_def_field, (int) e_dfl_count,
1629
$1, $4, NULL, NULL, $3, NULL, NULL); }
1632
var_decl_opt : VARIABLE
1638
var_init_opt : DEFAULT default_value
1646
cursor_declaration_item : symbol_cursor_name CURSOR FOR '(' select ')'
1647
{ $$ = make_flag_node (nod_cursor, NOD_CURSOR_EXPLICIT,
1648
(int) e_cur_count, $1, $5, NULL, NULL); }
1651
proc_block : proc_statement
1655
full_proc_block : stmt_start_line stmt_start_column BEGIN full_proc_block_body END
1657
$$ = make_node (nod_src_info, e_src_info_count, $1, $2, $4);
1661
full_proc_block_body : proc_statements
1662
{ $$ = make_node (nod_block, (int) e_blk_count, make_list ($1), NULL); }
1663
| proc_statements excp_hndl_statements
1664
{ $$ = make_node (nod_block, (int) e_blk_count, make_list ($1), make_list ($2)); }
1666
{ $$ = make_node (nod_block, (int) e_blk_count, NULL, NULL);}
1669
proc_statements : proc_block
1670
| proc_statements proc_block
1671
{ $$ = make_node (nod_list, 2, $1, $2); }
1674
proc_statement : stmt_start_line stmt_start_column simple_proc_statement ';'
1676
$$ = make_node (nod_src_info, e_src_info_count, $1, $2, $3);
1678
| stmt_start_line stmt_start_column complex_proc_statement
1680
$$ = make_node (nod_src_info, e_src_info_count, $1, $2, $3);
1685
{ $$ = (dsql_nod*) (IPTR) lex.lines_bk; }
1689
const USHORT column = (lex.last_token_bk - lex.line_start_bk + 1);
1690
$$ = (dsql_nod*) (IPTR) column;
1693
simple_proc_statement : assignment
1710
{ $$ = make_node (nod_return, (int) e_rtn_count, NULL); }
1712
{ $$ = make_node (nod_exit, 0, NULL); }
1715
complex_proc_statement : if_then_else
1721
excp_statement : EXCEPTION symbol_exception_name
1722
{ $$ = make_node (nod_exception_stmt, (int) e_xcp_count, $2, NULL); }
1723
| EXCEPTION symbol_exception_name value
1724
{ $$ = make_node (nod_exception_stmt, (int) e_xcp_count, $2, $3); }
1727
raise_statement : EXCEPTION
1728
{ $$ = make_node (nod_exception_stmt, (int) e_xcp_count, NULL, NULL); }
1731
exec_sql : EXECUTE STATEMENT value
1732
{ $$ = make_node (nod_exec_sql, (int) e_exec_sql_count, $3); }
1735
for_select : label_opt FOR select INTO variable_list cursor_def DO proc_block
1736
{ $$ = make_node (nod_for_select, (int) e_flp_count, $3,
1737
make_list ($5), $6, $8, $1); }
1740
for_exec_into : label_opt FOR EXECUTE STATEMENT value INTO variable_list DO proc_block
1741
{ $$ = make_node (nod_exec_into, (int) e_exec_into_count, $5, $9, make_list ($7), $1); }
1744
exec_into : EXECUTE STATEMENT value INTO variable_list
1745
{ $$ = make_node (nod_exec_into, (int) e_exec_into_count, $3, 0, make_list ($5)); }
1748
if_then_else : IF '(' search_condition ')' THEN proc_block ELSE proc_block
1749
{ $$ = make_node (nod_if, (int) e_if_count, $3, $6, $8); }
1750
| IF '(' search_condition ')' THEN proc_block
1751
{ $$ = make_node (nod_if, (int) e_if_count, $3, $6, NULL); }
1754
post_event : POST_EVENT value event_argument_opt
1755
{ $$ = make_node (nod_post, (int) e_pst_count, $2, $3); }
1758
event_argument_opt : /*',' value
1764
singleton_select : select INTO variable_list
1765
{ $$ = make_node (nod_for_select, (int) e_flp_count, $1,
1766
make_list ($3), NULL, NULL, NULL); }
1769
variable : ':' symbol_variable_name
1770
{ $$ = make_node (nod_var_name, (int) e_vrn_count,
1774
variable_list : variable
1776
| variable_list ',' column_name
1777
{ $$ = make_node (nod_list, 2, $1, $3); }
1778
| variable_list ',' variable
1779
{ $$ = make_node (nod_list, 2, $1, $3); }
1782
while : label_opt WHILE '(' search_condition ')' DO proc_block
1783
{ $$ = make_node (nod_while, (int) e_while_count, $4, $7, $1); }
1786
label_opt : symbol_label_name ':'
1787
{ $$ = make_node (nod_label, (int) e_label_count, $1, NULL); }
1792
breakleave : KW_BREAK
1793
{ $$ = make_node (nod_breakleave, (int) e_breakleave_count, NULL); }
1795
{ $$ = make_node (nod_breakleave, (int) e_breakleave_count, NULL); }
1796
| LEAVE symbol_label_name
1797
{ $$ = make_node (nod_breakleave, (int) e_breakleave_count,
1798
make_node (nod_label, (int) e_label_count, $2, NULL)); }
1801
cursor_def : AS CURSOR symbol_cursor_name
1802
{ $$ = make_flag_node (nod_cursor, NOD_CURSOR_FOR,
1803
(int) e_cur_count, $3, NULL, NULL, NULL); }
1808
excp_hndl_statements : excp_hndl_statement
1809
| excp_hndl_statements excp_hndl_statement
1810
{ $$ = make_node (nod_list, 2, $1, $2); }
1813
excp_hndl_statement : WHEN errors DO proc_block
1814
{ $$ = make_node (nod_on_error, (int) e_err_count,
1815
make_list ($2), $4); }
1820
{ $$ = make_node (nod_list, 2, $1, $3); }
1823
err : SQLCODE signed_short_integer
1824
{ $$ = make_node (nod_sqlcode, 1, $2); }
1825
| GDSCODE symbol_gdscode_name
1826
{ $$ = make_node (nod_gdscode, 1, $2); }
1827
| EXCEPTION symbol_exception_name
1828
{ $$ = make_node (nod_exception, 1, $2); }
1830
{ $$ = make_node (nod_default, 1, NULL); }
1833
cursor_statement : open_cursor
1838
open_cursor : OPEN symbol_cursor_name
1839
{ $$ = make_node (nod_cursor_open, (int) e_cur_stmt_count, $2, NULL, NULL); }
1842
close_cursor : CLOSE symbol_cursor_name
1843
{ $$ = make_node (nod_cursor_close, (int) e_cur_stmt_count, $2, NULL, NULL); }
1846
fetch_cursor : FETCH fetch_opt symbol_cursor_name INTO variable_list
1847
{ $$ = make_node (nod_cursor_fetch, (int) e_cur_stmt_count, $3, $2, make_list ($5)); }
1854
fetch_opt : fetch_seek_opt FROM
1859
{ $$ = make_node (nod_fetch_seek, 2,
1860
// corresponds to (blr_bof_forward, 0)
1861
MAKE_const_slong (3),
1862
MAKE_const_slong (0)); }
1864
{ $$ = make_node (nod_fetch_seek, 2,
1865
// corresponds to (blr_eof_backward, 0)
1866
MAKE_const_slong (4),
1867
MAKE_const_slong (0)); }
1869
{ $$ = make_node (nod_fetch_seek, 2,
1870
// corresponds to (blr_backward, 1)
1871
MAKE_const_slong (2),
1872
MAKE_const_slong (1)); }
1874
{ $$ = make_node (nod_fetch_seek, 2,
1875
// corresponds to (blr_forward, 1)
1876
MAKE_const_slong (1),
1877
MAKE_const_slong (1)); }
1879
{ $$ = make_node (nod_fetch_seek, 2,
1880
// corresponds to (blr_bof_forward, value)
1881
MAKE_const_slong (3),
1884
{ $$ = make_node (nod_fetch_seek, 2,
1885
// corresponds to (blr_forward, value)
1886
MAKE_const_slong (1),
1891
/* EXECUTE PROCEDURE */
1893
exec_procedure : EXECUTE PROCEDURE symbol_procedure_name proc_inputs proc_outputs_opt
1894
{ $$ = make_node (nod_exec_procedure, (int) e_exe_count,
1898
proc_inputs : value_list
1899
{ $$ = make_list ($1); }
1900
| '(' value_list ')'
1901
{ $$ = make_list ($2); }
1906
proc_outputs_opt : RETURNING_VALUES variable_list
1907
{ $$ = make_list ($2); }
1908
| RETURNING_VALUES '(' variable_list ')'
1909
{ $$ = make_list ($3); }
1916
exec_block : EXECUTE BLOCK block_input_params output_parameters AS
1917
local_declaration_list
1919
{ $$ = make_node (nod_exec_block,
1920
(int) e_exe_blk_count,
1921
$3, $4, $6, $7, make_node (nod_all, (int) 0, NULL)); }
1924
block_input_params : '(' block_parameters ')'
1925
{ $$ = make_list ($2); }
1930
block_parameters : block_parameter
1931
| block_parameters ',' block_parameter
1932
{ $$ = make_node (nod_list, 2, $1, $3); }
1935
block_parameter : proc_parameter '=' parameter
1936
{ $$ = make_node (nod_param_val, e_prm_val_count, $1, $3); }
1941
view_clause : symbol_view_name column_parens_opt AS begin_string select_expr
1942
check_opt end_trigger
1943
{ $$ = make_node (nod_def_view, (int) e_view_count,
1944
$1, $2, $5, $6, $7); }
1948
rview_clause : symbol_view_name column_parens_opt AS begin_string select_expr
1949
check_opt end_trigger
1950
{ $$ = make_node (nod_redef_view, (int) e_view_count,
1951
$1, $2, $5, $6, $7); }
1955
replace_view_clause : symbol_view_name column_parens_opt AS begin_string select_expr
1956
check_opt end_trigger
1957
{ $$ = make_node (nod_replace_view, (int) e_view_count,
1958
$1, $2, $5, $6, $7); }
1961
alter_view_clause : symbol_view_name column_parens_opt AS begin_string select_expr
1962
check_opt end_trigger
1963
{ $$ = make_node (nod_mod_view, (int) e_view_count,
1964
$1, $2, $5, $6, $7); }
1969
/* these rules will capture the input string for storage in metadata */
1972
{ lex.beginning = lex_position(); }
1976
{ $$ = (dsql_nod*) MAKE_string(lex.beginning,
1977
(lex_position() == lex.end) ?
1978
lex_position() - lex.beginning : lex.last_token - lex.beginning);}
1982
{ lex.beginning = lex.last_token; }
1986
{ $$ = (dsql_nod*) MAKE_string(lex.beginning,
1987
lex_position() - lex.beginning); }
1991
{ $$ = (dsql_nod*) MAKE_string(lex.beginning,
1992
(yychar <= 0 ? lex_position() : lex.last_token) - lex.beginning);
1997
check_opt : WITH CHECK OPTION
1998
{ $$ = make_node (nod_def_constraint, (int) e_cnstr_count,
1999
NULL, NULL, NULL, NULL, NULL); }
2006
/* CREATE TRIGGER */
2009
: symbol_trigger_name
2016
$$ = make_node (nod_def_trigger, (int) e_trg_count,
2017
$1, NULL, $2, $3, $4, $5, $6);
2019
| symbol_trigger_name FOR simple_table_name
2026
$$ = make_node (nod_def_trigger, (int) e_trg_count,
2027
$1, $3, $4, $5, $6, $7, $8);
2029
| symbol_trigger_name
2033
ON simple_table_name
2037
$$ = make_node (nod_def_trigger, (int) e_trg_count,
2038
$1, $6, $2, $3, $4, $7, $8);
2043
: symbol_trigger_name
2050
$$ = make_node (nod_redef_trigger, (int) e_trg_count,
2051
$1, NULL, $2, $3, $4, $5, $6);
2053
| symbol_trigger_name FOR simple_table_name
2060
$$ = make_node (nod_redef_trigger, (int) e_trg_count,
2061
$1, $3, $4, $5, $6, $7, $8);
2063
| symbol_trigger_name
2067
ON simple_table_name
2071
$$ = make_node (nod_redef_trigger, (int) e_trg_count,
2072
$1, $6, $2, $3, $4, $7, $8);
2076
replace_trigger_clause
2077
: symbol_trigger_name
2084
$$ = make_node (nod_replace_trigger, (int) e_trg_count,
2085
$1, NULL, $2, $3, $4, $5, $6);
2087
| symbol_trigger_name FOR simple_table_name
2094
$$ = make_node (nod_replace_trigger, (int) e_trg_count,
2095
$1, $3, $4, $5, $6, $7, $8);
2097
| symbol_trigger_name
2101
ON simple_table_name
2105
$$ = make_node (nod_replace_trigger, (int) e_trg_count,
2106
$1, $6, $2, $3, $4, $7, $8);
2110
trigger_active : ACTIVE
2111
{ $$ = MAKE_const_slong (0); }
2113
{ $$ = MAKE_const_slong (1); }
2119
: trigger_type_prefix trigger_type_suffix
2120
{ $$ = MAKE_trigger_type ($1, $2); }
2121
| ON trigger_db_type
2127
{ $$ = MAKE_const_slong (TRIGGER_TYPE_DB | DB_TRIGGER_CONNECT); }
2129
{ $$ = MAKE_const_slong (TRIGGER_TYPE_DB | DB_TRIGGER_DISCONNECT); }
2131
{ $$ = MAKE_const_slong (TRIGGER_TYPE_DB | DB_TRIGGER_TRANS_START); }
2132
| TRANSACTION COMMIT
2133
{ $$ = MAKE_const_slong (TRIGGER_TYPE_DB | DB_TRIGGER_TRANS_COMMIT); }
2134
| TRANSACTION ROLLBACK
2135
{ $$ = MAKE_const_slong (TRIGGER_TYPE_DB | DB_TRIGGER_TRANS_ROLLBACK); }
2138
trigger_type_prefix : BEFORE
2139
{ $$ = MAKE_const_slong (0); }
2141
{ $$ = MAKE_const_slong (1); }
2144
trigger_type_suffix : INSERT
2145
{ $$ = MAKE_const_slong (trigger_type_suffix (1, 0, 0)); }
2147
{ $$ = MAKE_const_slong (trigger_type_suffix (2, 0, 0)); }
2149
{ $$ = MAKE_const_slong (trigger_type_suffix (3, 0, 0)); }
2151
{ $$ = MAKE_const_slong (trigger_type_suffix (1, 2, 0)); }
2152
| INSERT OR KW_DELETE
2153
{ $$ = MAKE_const_slong (trigger_type_suffix (1, 3, 0)); }
2155
{ $$ = MAKE_const_slong (trigger_type_suffix (2, 1, 0)); }
2156
| UPDATE OR KW_DELETE
2157
{ $$ = MAKE_const_slong (trigger_type_suffix (2, 3, 0)); }
2158
| KW_DELETE OR INSERT
2159
{ $$ = MAKE_const_slong (trigger_type_suffix (3, 1, 0)); }
2160
| KW_DELETE OR UPDATE
2161
{ $$ = MAKE_const_slong (trigger_type_suffix (3, 2, 0)); }
2162
| INSERT OR UPDATE OR KW_DELETE
2163
{ $$ = MAKE_const_slong (trigger_type_suffix (1, 2, 3)); }
2164
| INSERT OR KW_DELETE OR UPDATE
2165
{ $$ = MAKE_const_slong (trigger_type_suffix (1, 3, 2)); }
2166
| UPDATE OR INSERT OR KW_DELETE
2167
{ $$ = MAKE_const_slong (trigger_type_suffix (2, 1, 3)); }
2168
| UPDATE OR KW_DELETE OR INSERT
2169
{ $$ = MAKE_const_slong (trigger_type_suffix (2, 3, 1)); }
2170
| KW_DELETE OR INSERT OR UPDATE
2171
{ $$ = MAKE_const_slong (trigger_type_suffix (3, 1, 2)); }
2172
| KW_DELETE OR UPDATE OR INSERT
2173
{ $$ = MAKE_const_slong (trigger_type_suffix (3, 2, 1)); }
2176
trigger_position : POSITION nonneg_short_integer
2177
{ $$ = MAKE_const_slong ((IPTR) $2); }
2182
trigger_action : AS begin_trigger local_declaration_list full_proc_block
2183
{ $$ = make_node (nod_list, (int) e_trg_act_count, $3, $4); }
2186
/* ALTER statement */
2188
alter : ALTER alter_clause
2192
alter_clause : EXCEPTION alter_exception_clause
2194
| TABLE simple_table_name alter_ops
2195
{ $$ = make_node (nod_mod_relation, (int) e_alt_count,
2196
$2, make_list ($3)); }
2198
| VIEW alter_view_clause
2201
| TRIGGER alter_trigger_clause
2203
| PROCEDURE alter_procedure_clause
2205
| DATABASE init_alter_db alter_db
2206
{ $$ = make_node (nod_mod_database, (int) e_adb_count,
2208
| DOMAIN alter_column_name alter_domain_ops
2209
{ $$ = make_node (nod_mod_domain, (int) e_alt_count,
2210
$2, make_list ($3)); }
2211
| INDEX alter_index_clause
2212
{ $$ = make_node (nod_mod_index, (int) e_mod_idx_count, $2); }
2213
| SEQUENCE alter_sequence_clause
2215
| EXTERNAL FUNCTION alter_udf_clause
2219
alter_domain_ops : alter_domain_op
2220
| alter_domain_ops alter_domain_op
2221
{ $$ = make_node (nod_list, 2, $1, $2); }
2224
alter_domain_op : SET domain_default end_trigger
2225
{ $$ = make_node (nod_def_default, (int) e_dft_count, $2, $3); }
2226
| ADD CONSTRAINT check_constraint
2228
| ADD check_constraint
2231
{$$ = make_node (nod_del_default, (int) 0, NULL); }
2233
{ $$ = make_node (nod_delete_rel_constraint, (int) 1, NULL); }
2234
| TO simple_column_name
2236
| TYPE init_data_type non_array_type
2237
{ $$ = make_node (nod_mod_domain_type, 2, $2); }
2240
alter_ops : alter_op
2241
| alter_ops ',' alter_op
2242
{ $$ = make_node (nod_list, 2, $1, $3); }
2245
alter_op : DROP simple_column_name drop_behaviour
2246
{ $$ = make_node (nod_del_field, 2, $2, $3); }
2247
| DROP CONSTRAINT symbol_constraint_name
2248
{ $$ = make_node (nod_delete_rel_constraint, (int) 1, $3);}
2251
| ADD table_constraint_definition
2253
/* CVC: From SQL, field positions start at 1, not zero. Think in ORDER BY, for example.
2254
| col_opt simple_column_name POSITION nonneg_short_integer
2255
{ $$ = make_node (nod_mod_field_pos, 2, $2,
2256
MAKE_const_slong ((IPTR) $4)); } */
2257
| col_opt simple_column_name POSITION pos_short_integer
2258
{ $$ = make_node(nod_mod_field_pos, 2, $2,
2259
MAKE_const_slong((IPTR) $4)); }
2260
| col_opt alter_column_name TO simple_column_name
2261
{ $$ = make_node(nod_mod_field_name, 2, $2, $4); }
2262
| col_opt alter_col_name TYPE alter_data_type_or_domain
2263
{ $$ = make_node(nod_mod_field_type, e_mod_fld_type_count, $2, $4, NULL); }
2264
| col_opt alter_col_name SET domain_default end_trigger
2265
{ $$ = make_node(nod_mod_field_type, e_mod_fld_type_count, $2, NULL,
2266
make_node(nod_def_default, (int) e_dft_count, $4, $5)); }
2267
| col_opt alter_col_name DROP DEFAULT
2268
{ $$ = make_node(nod_mod_field_type, e_mod_fld_type_count, $2, NULL,
2269
make_node(nod_del_default, (int) 0, NULL)); }
2272
alter_column_name : keyword_or_column
2273
{ $$ = make_node (nod_field_name, (int) e_fln_count,
2277
/* below are reserved words that could be used as column identifiers
2278
in the previous versions */
2280
keyword_or_column : valid_symbol_name
2281
| ADMIN /* added in IB 5.0 */
2282
| COLUMN /* added in IB 6.0 */
2295
| CURRENT_USER /* added in FB 1.0 */
2298
| CURRENT_CONNECTION /* added in FB 1.5 */
2299
| CURRENT_TRANSACTION
2305
| OPEN /* added in FB 2.0 */
2321
| CONNECT /* added in FB 2.1 */
2336
alter_data_type_or_domain : non_array_type
2338
| simple_column_name
2339
{ $$ = make_node (nod_def_domain, (int) e_dom_count,
2340
$1, NULL, NULL, NULL, NULL); }
2343
alter_col_name : simple_column_name
2344
{ lex.g_field_name = $1;
2345
lex.g_field = make_field ($1);
2346
$$ = (dsql_nod*) lex.g_field; }
2349
drop_behaviour : RESTRICT
2350
{ $$ = make_node (nod_restrict, 0, NULL); }
2352
{ $$ = make_node (nod_cascade, 0, NULL); }
2354
{ $$ = make_node (nod_restrict, 0, NULL); }
2357
alter_index_clause : symbol_index_name ACTIVE
2358
{ $$ = make_node (nod_idx_active, 1, $1); }
2359
| symbol_index_name INACTIVE
2360
{ $$ = make_node (nod_idx_inactive, 1, $1); }
2363
alter_sequence_clause : symbol_generator_name RESTART WITH signed_long_integer
2364
{ $$ = make_node (nod_set_generator2, e_gen_id_count, $1,
2365
MAKE_const_slong ((IPTR) $4)); }
2366
| symbol_generator_name RESTART WITH NUMBER64BIT
2367
{ $$ = make_node (nod_set_generator2, e_gen_id_count, $1,
2368
MAKE_constant((dsql_str*) $4, CONSTANT_SINT64)); }
2369
| symbol_generator_name RESTART WITH '-' NUMBER64BIT
2370
{ $$ = make_node (nod_set_generator2, e_gen_id_count, $1,
2371
make_node(nod_negate, 1, MAKE_constant((dsql_str*) $5, CONSTANT_SINT64))); }
2374
alter_udf_clause : symbol_UDF_name entry_op module_op
2375
{ $$ = make_node(nod_mod_udf, e_mod_udf_count, $1, $2, $3); }
2378
entry_op : ENTRY_POINT sql_string
2384
module_op : MODULE_NAME sql_string
2391
/* ALTER DATABASE */
2397
alter_db : db_alter_clause
2398
| alter_db db_alter_clause
2399
{ $$ = make_node (nod_list, (int) 2, $1, $2); }
2402
db_alter_clause : ADD db_file_list
2404
| ADD KW_DIFFERENCE KW_FILE sql_string
2405
{ $$ = make_node (nod_difference_file, (int) 1, $4); }
2406
| DROP KW_DIFFERENCE KW_FILE
2407
{ $$ = make_node (nod_drop_difference, (int) 0, NULL); }
2409
{ $$ = make_node (nod_begin_backup, (int) 0, NULL); }
2411
{ $$ = make_node (nod_end_backup, (int) 0, NULL); }
2417
alter_trigger_clause : symbol_trigger_name trigger_active
2423
{ $$ = make_node (nod_mod_trigger, (int) e_trg_count,
2424
$1, NULL, $2, $3, $4, $6, $7); }
2427
new_trigger_type : trigger_type
2432
new_trigger_action : trigger_action
2437
/* DROP metadata operations */
2439
drop : DROP drop_clause
2443
drop_clause : EXCEPTION symbol_exception_name
2444
{ $$ = make_node (nod_del_exception, 1, $2); }
2445
| INDEX symbol_index_name
2446
{ $$ = make_node (nod_del_index, (int) 1, $2); }
2447
| PROCEDURE symbol_procedure_name
2448
{ $$ = make_node (nod_del_procedure, (int) 1, $2); }
2449
| TABLE symbol_table_name
2450
{ $$ = make_node (nod_del_relation, (int) 1, $2); }
2451
| TRIGGER symbol_trigger_name
2452
{ $$ = make_node (nod_del_trigger, (int) 1, $2); }
2453
| VIEW symbol_view_name
2454
{ $$ = make_node (nod_del_view, (int) 1, $2); }
2455
| FILTER symbol_filter_name
2456
{ $$ = make_node (nod_del_filter, (int) 1, $2); }
2457
| DOMAIN symbol_domain_name
2458
{ $$ = make_node (nod_del_domain, (int) 1, $2); }
2459
| EXTERNAL FUNCTION symbol_UDF_name
2460
{ $$ = make_node (nod_del_udf, (int) 1, $3); }
2461
| SHADOW pos_short_integer
2462
{ $$ = make_node (nod_del_shadow, (int) 1, $2); }
2463
| ROLE symbol_role_name
2464
{ $$ = make_node (nod_del_role, (int) 1, $2); }
2465
| GENERATOR symbol_generator_name
2466
{ $$ = make_node (nod_del_generator, (int) 1, $2); }
2467
| SEQUENCE symbol_generator_name
2468
{ $$ = make_node (nod_del_generator, (int) 1, $2); }
2469
| COLLATION symbol_collation_name
2470
{ $$ = make_node (nod_del_collation, (int) 1, $2); }
2474
/* these are the allowable datatypes */
2476
data_type : non_array_type
2480
domain_or_non_array_type
2481
: domain_or_non_array_type_name
2482
| domain_or_non_array_type_name NOT KW_NULL
2483
{ lex.g_field->fld_not_nullable = true; }
2486
domain_or_non_array_type_name
2492
: TYPE OF symbol_column_name
2493
{ lex.g_field->fld_type_of_name = ((dsql_str*) $3)->str_data; }
2494
| symbol_column_name
2496
lex.g_field->fld_type_of_name = ((dsql_str*) $1)->str_data;
2497
lex.g_field->fld_full_domain = true;
2502
non_array_type : simple_type
2506
array_type : non_charset_simple_type '[' array_spec ']'
2507
{ lex.g_field->fld_ranges = make_list ($3);
2508
lex.g_field->fld_dimensions = lex.g_field->fld_ranges->nod_count / 2;
2509
lex.g_field->fld_element_dtype = lex.g_field->fld_dtype;
2511
| character_type '[' array_spec ']' charset_clause
2512
{ lex.g_field->fld_ranges = make_list ($3);
2513
lex.g_field->fld_dimensions = lex.g_field->fld_ranges->nod_count / 2;
2514
lex.g_field->fld_element_dtype = lex.g_field->fld_dtype;
2518
array_spec : array_range
2519
| array_spec ',' array_range
2520
{ $$ = make_node (nod_list, (int) 2, $1, $3); }
2523
array_range : signed_long_integer
2524
{ if ((IPTR) $1 < 1)
2525
$$ = make_node (nod_list, (int) 2,
2526
MAKE_const_slong ((IPTR) $1),
2527
MAKE_const_slong (1));
2529
$$ = make_node (nod_list, (int) 2,
2530
MAKE_const_slong (1),
2531
MAKE_const_slong ((IPTR) $1) ); }
2532
| signed_long_integer ':' signed_long_integer
2533
{ $$ = make_node (nod_list, (int) 2,
2534
MAKE_const_slong ((IPTR) $1),
2535
MAKE_const_slong ((IPTR) $3)); }
2538
simple_type : non_charset_simple_type
2539
| character_type charset_clause
2542
non_charset_simple_type : national_character_type
2547
if (client_dialect < SQL_DIALECT_V6_TRANSITION)
2548
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
2549
isc_arg_gds, isc_sql_dialect_datatype_unsupport,
2550
isc_arg_number, (SLONG) client_dialect,
2551
isc_arg_string, "BIGINT",
2553
if (db_dialect < SQL_DIALECT_V6_TRANSITION)
2554
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
2555
isc_arg_gds, isc_sql_db_dialect_dtype_unsupport,
2556
isc_arg_number, (SLONG) db_dialect,
2557
isc_arg_string, "BIGINT",
2559
lex.g_field->fld_dtype = dtype_int64;
2560
lex.g_field->fld_length = sizeof (SINT64);
2564
lex.g_field->fld_dtype = dtype_long;
2565
lex.g_field->fld_length = sizeof (SLONG);
2569
lex.g_field->fld_dtype = dtype_short;
2570
lex.g_field->fld_length = sizeof (SSHORT);
2574
*stmt_ambiguous = true;
2575
if (client_dialect <= SQL_DIALECT_V5)
2577
/* Post warning saying that DATE is equivalent to TIMESTAMP */
2578
ERRD_post_warning (isc_sqlwarn, isc_arg_number, (SLONG) 301,
2579
isc_arg_warning, isc_dtype_renamed, 0);
2580
lex.g_field->fld_dtype = dtype_timestamp;
2581
lex.g_field->fld_length = sizeof (GDS_TIMESTAMP);
2583
else if (client_dialect == SQL_DIALECT_V6_TRANSITION)
2584
yyabandon (-104, isc_transitional_date);
2587
lex.g_field->fld_dtype = dtype_sql_date;
2588
lex.g_field->fld_length = sizeof (ULONG);
2593
if (client_dialect < SQL_DIALECT_V6_TRANSITION)
2594
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
2595
isc_arg_gds, isc_sql_dialect_datatype_unsupport,
2596
isc_arg_number, (SLONG) client_dialect,
2597
isc_arg_string, "TIME",
2599
if (db_dialect < SQL_DIALECT_V6_TRANSITION)
2600
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
2601
isc_arg_gds, isc_sql_db_dialect_dtype_unsupport,
2602
isc_arg_number, (SLONG) db_dialect,
2603
isc_arg_string, "TIME",
2605
lex.g_field->fld_dtype = dtype_sql_time;
2606
lex.g_field->fld_length = sizeof (SLONG);
2610
lex.g_field->fld_dtype = dtype_timestamp;
2611
lex.g_field->fld_length = sizeof (GDS_TIMESTAMP);
2615
integer_keyword : INTEGER
2620
/* allow a blob to be specified with any combination of
2621
segment length and subtype */
2623
blob_type : BLOB blob_subtype blob_segsize charset_clause
2625
lex.g_field->fld_dtype = dtype_blob;
2626
lex.g_field->fld_length = sizeof(ISC_QUAD);
2628
| BLOB '(' unsigned_short_integer ')'
2630
lex.g_field->fld_dtype = dtype_blob;
2631
lex.g_field->fld_length = sizeof(ISC_QUAD);
2632
lex.g_field->fld_seg_length = (USHORT)(IPTR) $3;
2633
lex.g_field->fld_sub_type = 0;
2635
| BLOB '(' unsigned_short_integer ',' signed_short_integer ')'
2637
lex.g_field->fld_dtype = dtype_blob;
2638
lex.g_field->fld_length = sizeof(ISC_QUAD);
2639
lex.g_field->fld_seg_length = (USHORT)(IPTR) $3;
2640
lex.g_field->fld_sub_type = (USHORT)(IPTR) $5;
2642
| BLOB '(' ',' signed_short_integer ')'
2644
lex.g_field->fld_dtype = dtype_blob;
2645
lex.g_field->fld_length = sizeof(ISC_QUAD);
2646
lex.g_field->fld_seg_length = 80;
2647
lex.g_field->fld_sub_type = (USHORT)(IPTR) $4;
2651
blob_segsize : SEGMENT KW_SIZE unsigned_short_integer
2653
lex.g_field->fld_seg_length = (USHORT)(IPTR) $3;
2657
lex.g_field->fld_seg_length = (USHORT) 80;
2661
blob_subtype : SUB_TYPE signed_short_integer
2663
lex.g_field->fld_sub_type = (USHORT)(IPTR) $2;
2665
| SUB_TYPE symbol_blob_subtype_name
2667
lex.g_field->fld_sub_type_name = $2;
2671
lex.g_field->fld_sub_type = (USHORT) 0;
2675
charset_clause : CHARACTER SET symbol_character_set_name
2677
lex.g_field->fld_character_set = $3;
2683
/* character type */
2686
national_character_type : national_character_keyword '(' pos_short_integer ')'
2688
lex.g_field->fld_dtype = dtype_text;
2689
lex.g_field->fld_character_length = (USHORT)(IPTR) $3;
2690
lex.g_field->fld_flags |= FLD_national;
2692
| national_character_keyword
2694
lex.g_field->fld_dtype = dtype_text;
2695
lex.g_field->fld_character_length = 1;
2696
lex.g_field->fld_flags |= FLD_national;
2698
| national_character_keyword VARYING '(' pos_short_integer ')'
2700
lex.g_field->fld_dtype = dtype_varying;
2701
lex.g_field->fld_character_length = (USHORT)(IPTR) $4;
2702
lex.g_field->fld_flags |= FLD_national;
2706
character_type : character_keyword '(' pos_short_integer ')'
2708
lex.g_field->fld_dtype = dtype_text;
2709
lex.g_field->fld_character_length = (USHORT)(IPTR) $3;
2713
lex.g_field->fld_dtype = dtype_text;
2714
lex.g_field->fld_character_length = 1;
2716
| varying_keyword '(' pos_short_integer ')'
2718
lex.g_field->fld_dtype = dtype_varying;
2719
lex.g_field->fld_character_length = (USHORT)(IPTR) $3;
2723
varying_keyword : VARCHAR
2728
character_keyword : CHARACTER
2732
national_character_keyword : NCHAR
2733
| NATIONAL CHARACTER
2741
numeric_type : KW_NUMERIC prec_scale
2743
lex.g_field->fld_sub_type = dsc_num_type_numeric;
2745
| decimal_keyword prec_scale
2747
lex.g_field->fld_sub_type = dsc_num_type_decimal;
2748
if (lex.g_field->fld_dtype == dtype_short)
2750
lex.g_field->fld_dtype = dtype_long;
2751
lex.g_field->fld_length = sizeof (SLONG);
2758
lex.g_field->fld_dtype = dtype_long;
2759
lex.g_field->fld_length = sizeof (SLONG);
2760
lex.g_field->fld_precision = 9;
2762
| '(' signed_long_integer ')'
2764
if ( ((IPTR) $2 < 1) || ((IPTR) $2 > 18) )
2765
yyabandon (-842, isc_precision_err);
2766
/* Precision most be between 1 and 18. */
2769
if ( ( (client_dialect <= SQL_DIALECT_V5) &&
2770
(db_dialect > SQL_DIALECT_V5) ) ||
2771
( (client_dialect > SQL_DIALECT_V5) &&
2772
(db_dialect <= SQL_DIALECT_V5) ) )
2773
ERRD_post (isc_sqlerr,
2774
isc_arg_number, (SLONG) -817,
2776
isc_ddl_not_allowed_by_db_sql_dial,
2777
isc_arg_number, (SLONG) db_dialect,
2779
if (client_dialect <= SQL_DIALECT_V5)
2781
lex.g_field->fld_dtype = dtype_double;
2782
lex.g_field->fld_length = sizeof (double);
2786
if (client_dialect == SQL_DIALECT_V6_TRANSITION)
2789
isc_dsql_warn_precision_ambiguous,
2792
isc_dsql_warn_precision_ambiguous1,
2795
isc_dsql_warn_precision_ambiguous2,
2799
lex.g_field->fld_dtype = dtype_int64;
2800
lex.g_field->fld_length = sizeof (SINT64);
2806
lex.g_field->fld_dtype = dtype_short;
2807
lex.g_field->fld_length = sizeof (SSHORT);
2811
lex.g_field->fld_dtype = dtype_long;
2812
lex.g_field->fld_length = sizeof (SLONG);
2814
lex.g_field->fld_precision = (USHORT)(IPTR) $2;
2816
| '(' signed_long_integer ',' signed_long_integer ')'
2818
if ( ((IPTR) $2 < 1) || ((IPTR) $2 > 18) )
2819
yyabandon (-842, isc_precision_err);
2820
/* Precision should be between 1 and 18 */
2821
if (((IPTR) $4 > (IPTR) $2) || ((IPTR) $4 < 0))
2822
yyabandon (-842, isc_scale_nogt);
2823
/* Scale must be between 0 and precision */
2826
if ( ( (client_dialect <= SQL_DIALECT_V5) &&
2827
(db_dialect > SQL_DIALECT_V5) ) ||
2828
( (client_dialect > SQL_DIALECT_V5) &&
2829
(db_dialect <= SQL_DIALECT_V5) ) )
2830
ERRD_post (isc_sqlerr,
2831
isc_arg_number, (SLONG) -817,
2833
isc_ddl_not_allowed_by_db_sql_dial,
2834
isc_arg_number, (SLONG) db_dialect,
2836
if (client_dialect <= SQL_DIALECT_V5)
2838
lex.g_field->fld_dtype = dtype_double;
2839
lex.g_field->fld_length = sizeof (double);
2843
if (client_dialect == SQL_DIALECT_V6_TRANSITION)
2846
isc_dsql_warn_precision_ambiguous,
2849
isc_dsql_warn_precision_ambiguous1,
2852
isc_dsql_warn_precision_ambiguous2,
2855
/* client_dialect >= SQL_DIALECT_V6 */
2856
lex.g_field->fld_dtype = dtype_int64;
2857
lex.g_field->fld_length = sizeof (SINT64);
2864
lex.g_field->fld_dtype = dtype_short;
2865
lex.g_field->fld_length = sizeof (SSHORT);
2869
lex.g_field->fld_dtype = dtype_long;
2870
lex.g_field->fld_length = sizeof (SLONG);
2873
lex.g_field->fld_precision = (USHORT)(IPTR) $2;
2874
lex.g_field->fld_scale = - (SSHORT)(IPTR) $4;
2878
decimal_keyword : DECIMAL
2884
/* floating point type */
2886
float_type : KW_FLOAT precision_opt
2890
lex.g_field->fld_dtype = dtype_double;
2891
lex.g_field->fld_length = sizeof (double);
2895
lex.g_field->fld_dtype = dtype_real;
2896
lex.g_field->fld_length = sizeof (float);
2899
| KW_LONG KW_FLOAT precision_opt
2901
lex.g_field->fld_dtype = dtype_double;
2902
lex.g_field->fld_length = sizeof (double);
2906
lex.g_field->fld_dtype = dtype_real;
2907
lex.g_field->fld_length = sizeof (float);
2909
| KW_DOUBLE PRECISION
2911
lex.g_field->fld_dtype = dtype_double;
2912
lex.g_field->fld_length = sizeof (double);
2916
precision_opt : '(' nonneg_short_integer ')'
2924
/* SET statements */
2925
set : set_transaction
2931
set_generator : SET GENERATOR symbol_generator_name TO signed_long_integer
2932
{ $$ = make_node (nod_set_generator2, e_gen_id_count, $3,
2933
MAKE_const_slong ((IPTR) $5)); }
2934
| SET GENERATOR symbol_generator_name TO NUMBER64BIT
2935
{ $$ = make_node (nod_set_generator2, e_gen_id_count, $3,
2936
MAKE_constant((dsql_str*) $5, CONSTANT_SINT64)); }
2937
| SET GENERATOR symbol_generator_name TO '-' NUMBER64BIT
2938
{ $$ = make_node (nod_set_generator2, e_gen_id_count, $3,
2939
make_node(nod_negate, 1, MAKE_constant((dsql_str*) $6, CONSTANT_SINT64))); }
2943
/* transaction statements */
2945
savepoint : set_savepoint
2950
set_savepoint : SAVEPOINT symbol_savepoint_name
2951
{ $$ = make_node (nod_user_savepoint, 1, $2); }
2954
release_savepoint : RELEASE SAVEPOINT symbol_savepoint_name release_only_opt
2955
{ $$ = make_node (nod_release_savepoint, 2, $3, $4); }
2958
release_only_opt : ONLY
2959
{ $$ = make_node (nod_flag, 0, NULL); }
2964
undo_savepoint : ROLLBACK optional_work TO optional_savepoint symbol_savepoint_name
2965
{ $$ = make_node (nod_undo_savepoint, 1, $5); }
2968
optional_savepoint : SAVEPOINT
2972
commit : COMMIT optional_work optional_retain
2973
{ $$ = make_node (nod_commit, e_commit_count, $3); }
2976
rollback : ROLLBACK optional_work optional_retain
2977
{ $$ = make_node (nod_rollback, e_rollback_count, $3); }
2980
optional_work : WORK
2984
optional_retain : RETAIN opt_snapshot
2985
{ $$ = make_node (nod_retain, 0, NULL); }
2990
opt_snapshot : SNAPSHOT
2995
set_transaction : SET TRANSACTION tran_opt_list_m
2996
{$$ = make_node (nod_trans, 1, make_list ($3)); }
2999
tran_opt_list_m : tran_opt_list
3004
tran_opt_list : tran_opt
3005
| tran_opt_list tran_opt
3006
{ $$ = make_node (nod_list, (int) 2, $1, $2); }
3009
tran_opt : access_mode
3014
| tbl_reserve_options
3017
access_mode : READ ONLY
3018
{ $$ = make_flag_node (nod_access, NOD_READ_ONLY, (int) 0, NULL); }
3020
{ $$ = make_flag_node (nod_access, NOD_READ_WRITE, (int) 0, NULL); }
3024
{ $$ = make_flag_node (nod_wait, NOD_WAIT, (int) 0, NULL); }
3026
{ $$ = make_flag_node (nod_wait, NOD_NO_WAIT, (int) 0, NULL); }
3029
isolation_mode : ISOLATION LEVEL iso_mode
3034
iso_mode : snap_shot
3036
| READ UNCOMMITTED version_mode
3037
{ $$ = make_flag_node (nod_isolation, NOD_READ_COMMITTED, 1, $3); }
3038
| READ COMMITTED version_mode
3039
{ $$ = make_flag_node (nod_isolation, NOD_READ_COMMITTED, 1, $3); }
3042
snap_shot : SNAPSHOT
3043
{ $$ = make_flag_node (nod_isolation, NOD_CONCURRENCY, 0, NULL); }
3045
{ $$ = make_flag_node (nod_isolation, NOD_CONSISTENCY, 0, NULL); }
3046
| SNAPSHOT TABLE STABILITY
3047
{ $$ = make_flag_node (nod_isolation, NOD_CONSISTENCY, 0, NULL); }
3050
version_mode : VERSION
3051
{ $$ = make_flag_node (nod_version, NOD_VERSION, 0, NULL); }
3053
{ $$ = make_flag_node (nod_version, NOD_NO_VERSION, 0, NULL); }
3058
tra_misc_options: NO AUTO UNDO
3059
{ $$ = make_flag_node(nod_tra_misc, NOD_NO_AUTO_UNDO, 0, NULL); }
3061
{ $$ = make_flag_node(nod_tra_misc, NOD_IGNORE_LIMBO, 0, NULL); }
3063
{ $$ = make_flag_node(nod_tra_misc, NOD_RESTART_REQUESTS, 0, NULL); }
3066
tra_timeout: LOCK TIMEOUT nonneg_short_integer
3067
{ $$ = make_node(nod_lock_timeout, 1, MAKE_const_slong ((IPTR) $3)); }
3070
tbl_reserve_options: RESERVING restr_list
3071
{ $$ = make_node (nod_reserve, 1, make_list ($2)); }
3074
lock_type : KW_SHARED
3075
{ $$ = (dsql_nod*) NOD_SHARED; }
3077
{ $$ = (dsql_nod*) NOD_PROTECTED ; }
3079
{ $$ = (dsql_nod*) 0; }
3083
{ $$ = (dsql_nod*) NOD_READ; }
3085
{ $$ = (dsql_nod*) NOD_WRITE; }
3088
restr_list : restr_option
3089
| restr_list ',' restr_option
3090
{ $$ = make_node (nod_list, (int) 2, $1, $3); }
3093
restr_option : table_list table_lock
3094
{ $$ = make_node (nod_table_lock, (int) 2, make_list ($1), $2); }
3097
table_lock : FOR lock_type lock_mode
3098
{ $$ = make_flag_node (nod_lock_mode, (SSHORT) ((SSHORT)(IPTR) $2 | (SSHORT)(IPTR) $3), (SSHORT) 0, NULL); }
3103
table_list : simple_table_name
3104
| table_list ',' simple_table_name
3105
{ $$ = make_node (nod_list, (int) 2, $1, $3); }
3109
set_statistics : SET STATISTICS INDEX symbol_index_name
3110
{ $$ = make_node (nod_set_statistics, (int) e_stat_count, $4); }
3113
comment : COMMENT ON ddl_type0 IS ddl_desc
3114
{ $$ = make_node(nod_comment, e_comment_count, $3, NULL, NULL, $5); }
3115
| COMMENT ON ddl_type1 symbol_ddl_name IS ddl_desc
3116
{ $$ = make_node(nod_comment, e_comment_count, $3, $4, NULL, $6); }
3117
| COMMENT ON ddl_type2 symbol_ddl_name ddl_subname IS ddl_desc
3118
{ $$ = make_node(nod_comment, e_comment_count, $3, $4, $5, $7); }
3121
ddl_type0 : DATABASE
3122
{ $$ = MAKE_const_slong(ddl_database); }
3126
{ $$ = MAKE_const_slong(ddl_domain); }
3128
{ $$ = MAKE_const_slong(ddl_relation); }
3130
{ $$ = MAKE_const_slong(ddl_view); }
3132
{ $$ = MAKE_const_slong(ddl_procedure); }
3134
{ $$ = MAKE_const_slong(ddl_trigger); }
3136
{ $$ = MAKE_const_slong(ddl_udf); }
3138
{ $$ = MAKE_const_slong(ddl_blob_filter); }
3140
{ $$ = MAKE_const_slong(ddl_exception); }
3142
{ $$ = MAKE_const_slong(ddl_generator); }
3144
{ $$ = MAKE_const_slong(ddl_generator); }
3146
{ $$ = MAKE_const_slong(ddl_index); }
3148
{ $$ = MAKE_const_slong(ddl_role); }
3150
{ $$ = MAKE_const_slong(ddl_charset); }
3152
{ $$ = MAKE_const_slong(ddl_collation); }
3155
{ $$ = MAKE_const_slong(ddl_sec_class); }
3160
{ $$ = MAKE_const_slong(ddl_relation); }
3162
{ $$ = MAKE_const_slong(ddl_procedure); }
3165
ddl_subname : '.' symbol_ddl_name
3169
ddl_desc : sql_string
3175
/* SELECT statement */
3177
select : select_expr for_update_clause lock_clause
3178
{ $$ = make_node (nod_select, (int) e_select_count, $1, $2, $3); }
3181
for_update_clause : FOR UPDATE for_update_list
3182
{ $$ = make_node (nod_for_update, (int) e_fpd_count, $3); }
3187
for_update_list : OF column_list
3190
{ $$ = make_node (nod_flag, 0, NULL); }
3193
lock_clause : WITH LOCK
3194
{ $$ = make_node (nod_flag, 0, NULL); }
3200
/* SELECT expression */
3202
select_expr : with_clause select_expr_body order_clause rows_clause
3203
{ $$ = make_node (nod_select_expr, (int) e_sel_count, $2, $3, $4, $1); }
3206
with_clause : WITH RECURSIVE with_list
3207
{ $$ = make_flag_node (nod_with, NOD_UNION_RECURSIVE, 1, make_list($3)); }
3209
{ $$ = make_node (nod_with, 1, make_list($2)); }
3214
with_list : with_item
3215
| with_item ',' with_list
3216
{ $$ = make_node (nod_list, 2, $1, $3); }
3219
with_item : symbol_table_alias_name derived_column_list AS '(' select_expr ')'
3220
{ $$ = make_node (nod_derived_table, (int) e_derived_table_count, $5, $1, $2, NULL); }
3223
column_select : with_clause select_expr_body order_clause rows_clause
3224
{ $$ = make_flag_node (nod_select_expr, NOD_SELECT_EXPR_VALUE,
3225
(int) e_sel_count, $2, $3, $4, $1); }
3228
column_singleton : with_clause select_expr_body order_clause rows_clause
3229
{ $$ = make_flag_node (nod_select_expr, NOD_SELECT_EXPR_VALUE | NOD_SELECT_EXPR_SINGLETON,
3230
(int) e_sel_count, $2, $3, $4, $1); }
3233
select_expr_body : query_term
3234
| select_expr_body UNION distinct_noise query_term
3235
{ $$ = make_node (nod_list, 2, $1, $4); }
3236
| select_expr_body UNION ALL query_term
3237
{ $$ = make_flag_node (nod_list, NOD_UNION_ALL, 2, $1, $4); }
3240
query_term : query_spec
3243
query_spec : SELECT limit_clause
3251
{ $$ = make_node (nod_query_spec, (int) e_qry_count,
3252
$2, $3, $4, $5, $6, $7, $8, $9); }
3255
limit_clause : first_clause skip_clause
3256
{ $$ = make_node (nod_limit, (int) e_limit_count, $2, $1); }
3258
{ $$ = make_node (nod_limit, (int) e_limit_count, NULL, $1); }
3260
{ $$ = make_node (nod_limit, (int) e_limit_count, $1, NULL); }
3265
first_clause : FIRST long_integer
3266
{ $$ = MAKE_const_slong ((IPTR) $2); }
3267
| FIRST '(' value ')'
3273
skip_clause : SKIP long_integer
3274
{ $$ = MAKE_const_slong ((IPTR) $2); }
3275
| SKIP '(' value ')'
3281
distinct_clause : DISTINCT
3282
{ $$ = make_node (nod_flag, 0, NULL); }
3287
select_list : select_items
3288
{ $$ = make_list ($1); }
3293
select_items : select_item
3294
| select_items ',' select_item
3295
{ $$ = make_node (nod_list, 2, $1, $3); }
3299
| value as_noise symbol_item_alias_name
3300
{ $$ = make_node (nod_alias, 2, $1, $3); }
3309
from_clause : FROM from_list
3310
{ $$ = make_list ($2); }
3313
from_list : table_reference
3314
| from_list ',' table_reference
3315
{ $$ = make_node (nod_list, 2, $1, $3); }
3318
table_reference : joined_table
3322
table_primary : table_proc
3324
| '(' joined_table ')'
3328
// AB: derived table support
3329
// ASF: create derived table with nested union to fix CORE-1246
3331
'(' select_expr ')' as_noise correlation_name derived_column_list
3332
{ $$ = make_node(nod_derived_table, (int) e_derived_table_count, $2, $5, $6, NULL); }
3335
correlation_name : symbol_table_alias_name
3340
derived_column_list : '(' alias_list ')'
3341
{ $$ = make_list ($2); }
3346
alias_list : symbol_item_alias_name
3347
| alias_list ',' symbol_item_alias_name
3348
{ $$ = make_node (nod_list, 2, $1, $3); }
3351
joined_table : cross_join
3356
cross_join : table_reference CROSS JOIN table_primary
3357
{ $$ = make_node (nod_join, (int) e_join_count, $1,
3358
make_node (nod_join_inner, (int) 0, NULL), $4, NULL); }
3361
natural_join : table_reference NATURAL join_type JOIN table_primary
3362
{ $$ = make_node (nod_join, (int) e_join_count, $1, $3, $5,
3363
make_node (nod_flag, 0, NULL)); }
3366
qualified_join : table_reference join_type JOIN table_reference join_specification
3367
{ $$ = make_node (nod_join, (int) e_join_count, $1, $2, $4, $5); }
3370
join_specification : join_condition
3371
| named_columns_join
3374
join_condition : ON search_condition
3378
named_columns_join : USING '(' column_list ')'
3379
{ $$ = make_list ($3); }
3382
table_proc : symbol_procedure_name table_proc_inputs as_noise symbol_table_alias_name
3383
{ $$ = make_node (nod_rel_proc_name,
3384
(int) e_rpn_count, $1, $4, $2); }
3385
| symbol_procedure_name table_proc_inputs
3386
{ $$ = make_node (nod_rel_proc_name,
3387
(int) e_rpn_count, $1, NULL, $2); }
3390
table_proc_inputs : '(' value_list ')'
3391
{ $$ = make_list ($2); }
3396
table_name : simple_table_name
3397
| symbol_table_name as_noise symbol_table_alias_name
3398
{ $$ = make_node (nod_relation_name,
3399
(int) e_rln_count, $1, $3); }
3402
simple_table_name: symbol_table_name
3403
{ $$ = make_node (nod_relation_name,
3404
(int) e_rln_count, $1, NULL); }
3408
{ $$ = make_node (nod_join_inner, (int) 0, NULL); }
3410
{ $$ = make_node (nod_join_left, (int) 0, NULL); }
3412
{ $$ = make_node (nod_join_right, (int) 0, NULL); }
3414
{ $$ = make_node (nod_join_full, (int) 0, NULL); }
3416
{ $$ = make_node (nod_join_inner, (int) 0, NULL); }
3424
/* other clauses in the select expression */
3426
group_clause : GROUP BY group_by_list
3427
{ $$ = make_list ($3); }
3432
group_by_list : group_by_item
3433
| group_by_list ',' group_by_item
3434
{ $$ = make_node (nod_list, 2, $1, $3); }
3437
/* Except aggregate-functions are all expressions supported in group_by_item,
3438
they are caught inside pass1.cpp */
3439
group_by_item : value
3442
having_clause : HAVING search_condition
3448
where_clause : WHERE search_condition
3455
/* PLAN clause to specify an access plan for a query */
3457
plan_clause : PLAN plan_expression
3463
plan_expression : plan_type '(' plan_item_list ')'
3464
{ $$ = make_node (nod_plan_expr, 2, $1, make_list ($3)); }
3470
{ $$ = make_node (nod_merge_plan, (int) 0, NULL); }
3472
{ $$ = make_node (nod_merge_plan, (int) 0, NULL); }
3474
/* for now the SORT operator is a no-op; it does not
3475
change the place where a sort happens, but is just intended
3476
to read the output from a SET PLAN */
3483
plan_item_list : plan_item
3484
| plan_item ',' plan_item_list
3485
{ $$ = make_node (nod_list, 2, $1, $3); }
3488
plan_item : table_or_alias_list access_type
3489
{ $$ = make_node (nod_plan_item, 2, make_list ($1), $2); }
3493
table_or_alias_list : symbol_table_name
3494
| symbol_table_name table_or_alias_list
3495
{ $$ = make_node (nod_list, 2, $1, $2); }
3498
access_type : NATURAL
3499
{ $$ = make_node (nod_natural, (int) 0, NULL); }
3500
| INDEX '(' index_list ')'
3501
{ $$ = make_node (nod_index, 1, make_list ($3)); }
3502
| ORDER symbol_index_name extra_indices_opt
3503
{ $$ = make_node (nod_index_order, 2, $2, $3); }
3506
index_list : symbol_index_name
3507
| symbol_index_name ',' index_list
3508
{ $$ = make_node (nod_list, 2, $1, $3); }
3511
extra_indices_opt : INDEX '(' index_list ')'
3512
{ $$ = make_list ($3); }
3517
/* ORDER BY clause */
3519
order_clause : ORDER BY order_list
3520
{ $$ = make_list ($3); }
3525
order_list : order_item
3526
| order_list ',' order_item
3527
{ $$ = make_node (nod_list, 2, $1, $3); }
3530
order_item : value order_direction nulls_clause
3531
{ $$ = make_node (nod_order, (int) e_order_count, $1, $2, $3); }
3534
order_direction : ASC
3537
{ $$ = make_node (nod_flag, 0, NULL); }
3542
nulls_clause : NULLS nulls_placement
3548
nulls_placement : FIRST
3549
{ $$ = MAKE_const_slong(NOD_NULLS_FIRST); }
3551
{ $$ = MAKE_const_slong(NOD_NULLS_LAST); }
3556
rows_clause : ROWS value
3557
/* equivalent to FIRST value */
3558
{ $$ = make_node (nod_rows, (int) e_rows_count, NULL, $2); }
3559
| ROWS value TO value
3560
/* equivalent to FIRST (upper_value - lower_value + 1) SKIP (lower_value - 1) */
3561
{ $$ = make_node (nod_rows, (int) e_rows_count,
3562
make_node (nod_subtract, 2, $2,
3563
MAKE_const_slong (1)),
3564
make_node (nod_add, 2,
3565
make_node (nod_subtract, 2, $4, $2),
3566
MAKE_const_slong (1))); }
3572
/* INSERT statement */
3573
/* IBO hack: replace column_parens_opt by ins_column_parens_opt. */
3574
insert : INSERT INTO simple_table_name ins_column_parens_opt
3575
VALUES '(' value_list ')' returning_clause
3576
{ $$ = make_node (nod_insert, (int) e_ins_count,
3577
$3, $4, make_list ($7), NULL, $9); }
3578
| INSERT INTO simple_table_name ins_column_parens_opt select_expr returning_clause
3579
{ $$ = make_node (nod_insert, (int) e_ins_count,
3580
$3, $4, NULL, $5, $6); }
3581
| INSERT INTO simple_table_name DEFAULT VALUES returning_clause
3582
{ $$ = make_node (nod_insert, (int) e_ins_count,
3583
$3, NULL, NULL, NULL, $6); }
3587
/* MERGE statement */
3589
: MERGE INTO table_name USING table_reference ON search_condition
3592
$$ = make_node(nod_merge, e_mrg_count, $3, $5, $7, $8);
3597
: merge_when_matched_clause merge_when_not_matched_clause
3598
{ $$ = make_node(nod_merge_when, e_mrg_when_count, $1, $2); }
3599
| merge_when_not_matched_clause merge_when_matched_clause
3600
{ $$ = make_node(nod_merge_when, e_mrg_when_count, $2, $1); }
3601
| merge_when_matched_clause
3602
{ $$ = make_node(nod_merge_when, e_mrg_when_count, $1, NULL); }
3603
| merge_when_not_matched_clause
3604
{ $$ = make_node(nod_merge_when, e_mrg_when_count, NULL, $1); }
3607
merge_when_matched_clause
3608
: WHEN MATCHED THEN merge_update_specification
3612
merge_when_not_matched_clause
3613
: WHEN NOT MATCHED THEN merge_insert_specification
3617
merge_update_specification
3618
: UPDATE SET assignments
3619
{ $$ = make_node(nod_merge_update, e_mrg_update_count, make_list($3)); }
3622
merge_insert_specification
3623
: INSERT ins_column_parens_opt VALUES '(' value_list ')'
3624
{ $$ = make_node(nod_merge_insert, e_mrg_insert_count, make_list($2), make_list($5)); }
3628
/* DELETE statement */
3630
delete : delete_searched
3634
delete_searched : KW_DELETE FROM table_name where_clause
3635
plan_clause order_clause rows_clause returning_clause
3636
{ $$ = make_node (nod_delete, (int) e_del_count,
3637
$3, $4, $5, $6, $7, NULL, $8); }
3640
delete_positioned : KW_DELETE FROM table_name cursor_clause
3641
{ $$ = make_node (nod_delete, (int) e_del_count,
3642
$3, NULL, NULL, NULL, NULL, $4, NULL); }
3646
/* UPDATE statement */
3648
update : update_searched
3652
update_searched : UPDATE table_name SET assignments where_clause
3653
plan_clause order_clause rows_clause returning_clause
3654
{ $$ = make_node (nod_update, (int) e_upd_count,
3655
$2, make_list ($4), $5, $6, $7, $8, NULL, $9, NULL); }
3658
update_positioned : UPDATE table_name SET assignments cursor_clause
3659
{ $$ = make_node (nod_update, (int) e_upd_count,
3660
$2, make_list ($4), NULL, NULL, NULL, NULL, $5, NULL, NULL); }
3664
/* UPDATE OR INSERT statement */
3667
: UPDATE OR INSERT INTO simple_table_name ins_column_parens_opt
3668
VALUES '(' value_list ')'
3669
update_or_insert_matching_opt
3672
$$ = make_node (nod_update_or_insert, (int) e_upi_count,
3673
$5, make_list ($6), make_list ($9), $11, $12);
3677
update_or_insert_matching_opt
3678
: MATCHING ins_column_parens
3685
returning_clause : RETURNING value_list
3686
{ $$ = make_node (nod_returning, (int) e_ret_count,
3687
make_list ($2), NULL); }
3688
| RETURNING value_list INTO variable_list
3689
{ $$ = make_node (nod_returning, (int) e_ret_count,
3690
make_list ($2), make_list ($4)); }
3695
cursor_clause : WHERE CURRENT OF symbol_cursor_name
3696
{ $$ = make_node (nod_cursor, (int) e_cur_count, $4, NULL, NULL, NULL); }
3702
assignments : assignment
3703
| assignments ',' assignment
3704
{ $$ = make_node (nod_list, 2, $1, $3); }
3707
assignment : update_column_name '=' value
3708
{ $$ = make_node (nod_assign, e_asgn_count, $3, $1); }
3713
{ $$ = make_node (nod_assign, e_asgn_count, $1, make_node (nod_null, 0, NULL)); }
3714
| non_aggregate_function
3715
{ $$ = make_node (nod_assign, e_asgn_count, $1, make_node (nod_null, 0, NULL)); }
3719
/* BLOB get and put */
3721
blob_io : READ BLOB simple_column_name FROM simple_table_name filter_clause_io segment_clause_io
3722
{ $$ = make_node (nod_get_segment, (int) e_blb_count, $3, $5, $6, $7); }
3723
| INSERT BLOB simple_column_name INTO simple_table_name filter_clause_io segment_clause_io
3724
{ $$ = make_node (nod_put_segment, (int) e_blb_count, $3, $5, $6, $7); }
3727
filter_clause_io : FILTER FROM blob_subtype_value_io TO blob_subtype_value_io
3728
{ $$ = make_node (nod_list, 2, $3, $5); }
3729
| FILTER TO blob_subtype_value_io
3730
{ $$ = make_node (nod_list, 2, NULL, $3); }
3735
blob_subtype_value_io : blob_subtype_io
3739
blob_subtype_io : signed_short_integer
3740
{ $$ = MAKE_const_slong ((IPTR) $1); }
3743
segment_clause_io : MAX_SEGMENT segment_length_io
3749
segment_length_io : unsigned_short_integer
3750
{ $$ = MAKE_const_slong ((IPTR) $1); }
3755
/* column specifications */
3757
column_parens_opt : column_parens
3762
column_parens : '(' column_list ')'
3763
{ $$ = make_list ($2); }
3766
column_list : simple_column_name
3767
| column_list ',' simple_column_name
3768
{ $$ = make_node (nod_list, 2, $1, $3); }
3771
/* begin IBO hack */
3772
ins_column_parens_opt : ins_column_parens
3777
ins_column_parens : '(' ins_column_list ')'
3778
{ $$ = make_list ($2); }
3781
ins_column_list : update_column_name
3782
| ins_column_list ',' update_column_name
3783
{ $$ = make_node (nod_list, 2, $1, $3); }
3787
column_name : simple_column_name
3788
| symbol_table_alias_name '.' symbol_column_name
3789
{ $$ = make_node (nod_field_name, (int) e_fln_count,
3791
| symbol_table_alias_name '.' '*'
3792
{ $$ = make_node (nod_field_name, (int) e_fln_count,
3796
simple_column_name : symbol_column_name
3797
{ $$ = make_node (nod_field_name, (int) e_fln_count,
3801
update_column_name : simple_column_name
3802
/* CVC: This option should be deprecated! The only allowed syntax should be
3803
Update...set column = expr, without qualifier for the column. */
3804
| symbol_table_alias_name '.' symbol_column_name
3805
{ $$ = make_node (nod_field_name, (int) e_fln_count,
3809
/* boolean expressions */
3811
search_condition : predicate
3812
| search_condition OR search_condition
3813
{ $$ = make_node (nod_or, 2, $1, $3); }
3814
| search_condition AND search_condition
3815
{ $$ = make_node (nod_and, 2, $1, $3); }
3816
| NOT search_condition
3817
{ $$ = make_node (nod_not, 1, $2); }
3820
predicate : comparison_predicate
3821
| distinct_predicate
3826
| quantified_predicate
3828
| containing_predicate
3829
| starting_predicate
3830
| singular_predicate
3831
| trigger_action_predicate
3832
| '(' search_condition ')'
3839
comparison_predicate : value '=' value
3840
{ $$ = make_node (nod_eql, 2, $1, $3); }
3842
{ $$ = make_node (nod_lss, 2, $1, $3); }
3844
{ $$ = make_node (nod_gtr, 2, $1, $3); }
3846
{ $$ = make_node (nod_geq, 2, $1, $3); }
3848
{ $$ = make_node (nod_leq, 2, $1, $3); }
3849
| value NOT_GTR value
3850
{ $$ = make_node (nod_leq, 2, $1, $3); }
3851
| value NOT_LSS value
3852
{ $$ = make_node (nod_geq, 2, $1, $3); }
3854
{ $$ = make_node (nod_neq, 2, $1, $3); }
3857
/* quantified comparisons */
3859
quantified_predicate : value '=' ALL '(' column_select ')'
3860
{ $$ = make_node (nod_eql_all, 2, $1, $5); }
3861
| value '<' ALL '(' column_select ')'
3862
{ $$ = make_node (nod_lss_all, 2, $1, $5); }
3863
| value '>' ALL '(' column_select ')'
3864
{ $$ = make_node (nod_gtr_all, 2, $1, $5); }
3865
| value GEQ ALL '(' column_select ')'
3866
{ $$ = make_node (nod_geq_all, 2, $1, $5); }
3867
| value LEQ ALL '(' column_select ')'
3868
{ $$ = make_node (nod_leq_all, 2, $1, $5); }
3869
| value NOT_GTR ALL '(' column_select ')'
3870
{ $$ = make_node (nod_leq_all, 2, $1, $5); }
3871
| value NOT_LSS ALL '(' column_select ')'
3872
{ $$ = make_node (nod_geq_all, 2, $1, $5); }
3873
| value NEQ ALL '(' column_select ')'
3874
{ $$ = make_node (nod_neq_all, 2, $1, $5); }
3875
| value '=' some '(' column_select ')'
3876
{ $$ = make_node (nod_eql_any, 2, $1, $5); }
3877
| value '<' some '(' column_select ')'
3878
{ $$ = make_node (nod_lss_any, 2, $1, $5); }
3879
| value '>' some '(' column_select ')'
3880
{ $$ = make_node (nod_gtr_any, 2, $1, $5); }
3881
| value GEQ some '(' column_select ')'
3882
{ $$ = make_node (nod_geq_any, 2, $1, $5); }
3883
| value LEQ some '(' column_select ')'
3884
{ $$ = make_node (nod_leq_any, 2, $1, $5); }
3885
| value NOT_GTR some '(' column_select ')'
3886
{ $$ = make_node (nod_leq_any, 2, $1, $5); }
3887
| value NOT_LSS some '(' column_select ')'
3888
{ $$ = make_node (nod_geq_any, 2, $1, $5); }
3889
| value NEQ some '(' column_select ')'
3890
{ $$ = make_node (nod_neq_any, 2, $1, $5); }
3898
/* other predicates */
3900
distinct_predicate : value IS DISTINCT FROM value
3901
{ $$ = make_node (nod_not, 1, make_node (nod_equiv, 2, $1, $5)); }
3902
| value IS NOT DISTINCT FROM value
3903
{ $$ = make_node (nod_equiv, 2, $1, $6); }
3906
between_predicate : value BETWEEN value AND value
3907
{ $$ = make_node (nod_between, 3, $1, $3, $5); }
3908
| value NOT BETWEEN value AND value
3909
{ $$ = make_node (nod_not, 1, make_node (nod_between,
3913
like_predicate : value LIKE value
3914
{ $$ = make_node (nod_like, 2, $1, $3); }
3915
| value NOT LIKE value
3916
{ $$ = make_node (nod_not, 1, make_node (nod_like, 2, $1, $4)); }
3917
| value LIKE value ESCAPE value
3918
{ $$ = make_node (nod_like, 3, $1, $3, $5); }
3919
| value NOT LIKE value ESCAPE value
3920
{ $$ = make_node (nod_not, 1, make_node (nod_like,
3924
in_predicate : value KW_IN in_predicate_value
3925
{ $$ = make_node (nod_eql_any, 2, $1, $3); }
3926
| value NOT KW_IN in_predicate_value
3927
{ $$ = make_node (nod_not, 1, make_node (nod_eql_any, 2, $1, $4)); }
3930
containing_predicate : value CONTAINING value
3931
{ $$ = make_node (nod_containing, 2, $1, $3); }
3932
| value NOT CONTAINING value
3933
{ $$ = make_node (nod_not, 1, make_node (nod_containing, 2, $1, $4)); }
3936
starting_predicate : value STARTING value
3937
{ $$ = make_node (nod_starting, 2, $1, $3); }
3938
| value NOT STARTING value
3939
{ $$ = make_node (nod_not, 1, make_node (nod_starting, 2, $1, $4)); }
3940
| value STARTING WITH value
3941
{ $$ = make_node (nod_starting, 2, $1, $4); }
3942
| value NOT STARTING WITH value
3943
{ $$ = make_node (nod_not, 1, make_node (nod_starting, 2, $1, $5)); }
3946
exists_predicate : EXISTS '(' select_expr ')'
3947
{ $$ = make_node (nod_exists, 1, $3); }
3950
singular_predicate : SINGULAR '(' select_expr ')'
3951
{ $$ = make_node (nod_singular, 1, $3); }
3954
null_predicate : value IS KW_NULL
3955
{ $$ = make_node (nod_missing, 1, $1); }
3956
| value IS NOT KW_NULL
3957
{ $$ = make_node (nod_not, 1, make_node (nod_missing, 1, $1)); }
3960
trigger_action_predicate : INSERTING
3961
{ $$ = make_node (nod_eql, 2,
3962
make_node (nod_internal_info, (int) e_internal_info_count,
3963
MAKE_const_slong (internal_trigger_action)),
3964
MAKE_const_slong (1)); }
3966
{ $$ = make_node (nod_eql, 2,
3967
make_node (nod_internal_info, (int) e_internal_info_count,
3968
MAKE_const_slong (internal_trigger_action)),
3969
MAKE_const_slong (2)); }
3971
{ $$ = make_node (nod_eql, 2,
3972
make_node (nod_internal_info, (int) e_internal_info_count,
3973
MAKE_const_slong (internal_trigger_action)),
3974
MAKE_const_slong (3)); }
3979
in_predicate_value : table_subquery
3980
| '(' value_list ')'
3981
{ $$ = make_list ($2); }
3984
table_subquery : '(' column_select ')'
3997
| cast_specification
3999
| next_value_expression
4002
{ $$ = make_node (nod_negate, 1, $2); }
4007
if (client_dialect >= SQL_DIALECT_V6_TRANSITION)
4008
$$ = make_node (nod_add2, 2, $1, $3);
4010
$$ = make_node (nod_add, 2, $1, $3);
4012
| value CONCATENATE value
4013
{ $$ = make_node (nod_concatenate, 2, $1, $3); }
4014
| value COLLATE symbol_collation_name
4015
{ $$ = make_node (nod_collate, (int) e_coll_count, (dsql_nod*) $3, $1); }
4018
if (client_dialect >= SQL_DIALECT_V6_TRANSITION)
4019
$$ = make_node (nod_subtract2, 2, $1, $3);
4021
$$ = make_node (nod_subtract, 2, $1, $3);
4025
if (client_dialect >= SQL_DIALECT_V6_TRANSITION)
4026
$$ = make_node (nod_multiply2, 2, $1, $3);
4028
$$ = make_node (nod_multiply, 2, $1, $3);
4032
if (client_dialect >= SQL_DIALECT_V6_TRANSITION)
4033
$$ = make_node (nod_divide2, 2, $1, $3);
4035
$$ = make_node (nod_divide, 2, $1, $3);
4039
| '(' column_singleton ')'
4045
{ $$ = make_node (nod_dbkey, 1, NULL); }
4046
| symbol_table_alias_name '.' DB_KEY
4047
{ $$ = make_node (nod_dbkey, 1, $1); }
4050
$$ = make_node (nod_dom_value, 0, NULL);
4052
| datetime_value_expression
4056
datetime_value_expression : CURRENT_DATE
4058
if (client_dialect < SQL_DIALECT_V6_TRANSITION)
4059
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
4060
isc_arg_gds, isc_sql_dialect_datatype_unsupport,
4061
isc_arg_number, (SLONG) client_dialect,
4062
isc_arg_string, "DATE",
4064
if (db_dialect < SQL_DIALECT_V6_TRANSITION)
4065
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
4066
isc_arg_gds, isc_sql_db_dialect_dtype_unsupport,
4067
isc_arg_number, (SLONG) db_dialect,
4068
isc_arg_string, "DATE",
4070
$$ = make_node (nod_current_date, 0, NULL);
4072
| CURRENT_TIME sec_precision_opt
4074
if (client_dialect < SQL_DIALECT_V6_TRANSITION)
4075
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
4076
isc_arg_gds, isc_sql_dialect_datatype_unsupport,
4077
isc_arg_number, (SLONG) client_dialect,
4078
isc_arg_string, "TIME",
4080
if (db_dialect < SQL_DIALECT_V6_TRANSITION)
4081
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
4082
isc_arg_gds, isc_sql_db_dialect_dtype_unsupport,
4083
isc_arg_number, (SLONG) db_dialect,
4084
isc_arg_string, "TIME",
4086
$$ = make_node (nod_current_time, 1, $2);
4088
| CURRENT_TIMESTAMP sec_precision_opt
4089
{ $$ = make_node (nod_current_timestamp, 1, $2); }
4092
sec_precision_opt : '(' nonneg_short_integer ')'
4093
{ $$ = MAKE_const_slong ((IPTR) $2); }
4098
array_element : column_name '[' value_list ']'
4099
{ $$ = make_node (nod_array, (int) e_ary_count, $1, make_list ($3)); }
4109
| value_list ',' value
4110
{ $$ = make_node (nod_list, 2, $1, $3); }
4113
constant : u_constant
4114
| '-' u_numeric_constant
4115
{ $$ = make_node (nod_negate, 1, $2); }
4118
u_numeric_constant : NUMERIC
4119
{ $$ = MAKE_constant ((dsql_str*) $1, CONSTANT_STRING); }
4121
{ $$ = MAKE_const_slong ((IPTR) $1); }
4123
{ $$ = MAKE_constant ((dsql_str*) $1, CONSTANT_DOUBLE); }
4125
{ $$ = MAKE_constant ((dsql_str*) $1, CONSTANT_SINT64); }
4127
{ $$ = MAKE_constant ((dsql_str*) $1, CONSTANT_SINT64); }
4130
u_constant : u_numeric_constant
4132
{ $$ = MAKE_str_constant ((dsql_str*) $1, lex.att_charset); }
4135
if (client_dialect < SQL_DIALECT_V6_TRANSITION)
4136
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
4137
isc_arg_gds, isc_sql_dialect_datatype_unsupport,
4138
isc_arg_number, (SLONG) client_dialect,
4139
isc_arg_string, "DATE",
4141
if (db_dialect < SQL_DIALECT_V6_TRANSITION)
4142
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
4143
isc_arg_gds, isc_sql_db_dialect_dtype_unsupport,
4144
isc_arg_number, (SLONG) db_dialect,
4145
isc_arg_string, "DATE",
4147
$$ = MAKE_constant ((dsql_str*) $2, CONSTANT_DATE);
4151
if (client_dialect < SQL_DIALECT_V6_TRANSITION)
4152
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
4153
isc_arg_gds, isc_sql_dialect_datatype_unsupport,
4154
isc_arg_number, (SLONG) client_dialect,
4155
isc_arg_string, "TIME",
4157
if (db_dialect < SQL_DIALECT_V6_TRANSITION)
4158
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
4159
isc_arg_gds, isc_sql_db_dialect_dtype_unsupport,
4160
isc_arg_number, (SLONG) db_dialect,
4161
isc_arg_string, "TIME",
4163
$$ = MAKE_constant ((dsql_str*) $2, CONSTANT_TIME);
4166
{ $$ = MAKE_constant ((dsql_str*) $2, CONSTANT_TIMESTAMP); }
4170
{ $$ = make_parameter (); }
4174
{ $$ = make_node (nod_user_name, 0, NULL); }
4176
{ $$ = make_node (nod_user_name, 0, NULL); }
4179
current_role : CURRENT_ROLE
4180
{ $$ = make_node (nod_current_role, 0, NULL); }
4183
internal_info : CURRENT_CONNECTION
4184
{ $$ = make_node (nod_internal_info, (int) e_internal_info_count,
4185
MAKE_const_slong (internal_connection_id)); }
4186
| CURRENT_TRANSACTION
4187
{ $$ = make_node (nod_internal_info, (int) e_internal_info_count,
4188
MAKE_const_slong (internal_transaction_id)); }
4190
{ $$ = make_node (nod_internal_info, (int) e_internal_info_count,
4191
MAKE_const_slong (internal_gdscode)); }
4193
{ $$ = make_node (nod_internal_info, (int) e_internal_info_count,
4194
MAKE_const_slong (internal_sqlcode)); }
4196
{ $$ = make_node (nod_internal_info, (int) e_internal_info_count,
4197
MAKE_const_slong (internal_rows_affected)); }
4200
sql_string : STRING /* string in current charset */
4202
| INTRODUCER STRING /* string in specific charset */
4203
{ ((dsql_str*) $2)->str_charset = (TEXT *) $1;
4207
signed_short_integer : nonneg_short_integer
4208
| '-' neg_short_integer
4209
{ $$ = (dsql_nod*) - (IPTR) $2; }
4212
nonneg_short_integer : NUMBER
4213
{ if ((IPTR) $1 > SHRT_POS_MAX)
4214
yyabandon (-842, isc_expec_short);
4215
/* Short integer expected */
4219
neg_short_integer : NUMBER
4220
{ if ((IPTR) $1 > SHRT_NEG_MAX)
4221
yyabandon (-842, isc_expec_short);
4222
/* Short integer expected */
4226
pos_short_integer : nonneg_short_integer
4227
{ if ((IPTR) $1 == 0)
4228
yyabandon (-842, isc_expec_positive);
4229
/* Positive number expected */
4233
unsigned_short_integer : NUMBER
4234
{ if ((IPTR) $1 > SHRT_UNSIGNED_MAX)
4235
yyabandon (-842, isc_expec_ushort);
4236
/* Unsigned short integer expected */
4240
signed_long_integer : long_integer
4242
{ $$ = (dsql_nod*) - (IPTR) $2; }
4245
long_integer : NUMBER
4253
: aggregate_function
4254
| non_aggregate_function
4257
non_aggregate_function
4258
: numeric_value_function
4259
| string_value_function
4260
| system_function_expression
4263
aggregate_function : COUNT '(' '*' ')'
4264
{ $$ = make_node (nod_agg_count, 0, NULL); }
4265
| COUNT '(' all_noise value ')'
4266
{ $$ = make_node (nod_agg_count, 1, $4); }
4267
| COUNT '(' DISTINCT value ')'
4268
{ $$ = make_flag_node (nod_agg_count,
4269
NOD_AGG_DISTINCT, 1, $4); }
4270
| SUM '(' all_noise value ')'
4272
if (client_dialect >= SQL_DIALECT_V6_TRANSITION)
4273
$$ = make_node (nod_agg_total2, 1, $4);
4275
$$ = make_node (nod_agg_total, 1, $4);
4277
| SUM '(' DISTINCT value ')'
4279
if (client_dialect >= SQL_DIALECT_V6_TRANSITION)
4280
$$ = make_flag_node (nod_agg_total2,
4281
NOD_AGG_DISTINCT, 1, $4);
4283
$$ = make_flag_node (nod_agg_total,
4284
NOD_AGG_DISTINCT, 1, $4);
4286
| AVG '(' all_noise value ')'
4288
if (client_dialect >= SQL_DIALECT_V6_TRANSITION)
4289
$$ = make_node (nod_agg_average2, 1, $4);
4291
$$ = make_node (nod_agg_average, 1, $4);
4293
| AVG '(' DISTINCT value ')'
4295
if (client_dialect >= SQL_DIALECT_V6_TRANSITION)
4296
$$ = make_flag_node (nod_agg_average2,
4297
NOD_AGG_DISTINCT, 1, $4);
4299
$$ = make_flag_node (nod_agg_average,
4300
NOD_AGG_DISTINCT, 1, $4);
4302
| MINIMUM '(' all_noise value ')'
4303
{ $$ = make_node (nod_agg_min, 1, $4); }
4304
| MINIMUM '(' DISTINCT value ')'
4305
{ $$ = make_node (nod_agg_min, 1, $4); }
4306
| MAXIMUM '(' all_noise value ')'
4307
{ $$ = make_node (nod_agg_max, 1, $4); }
4308
| MAXIMUM '(' DISTINCT value ')'
4309
{ $$ = make_node (nod_agg_max, 1, $4); }
4310
| LIST '(' all_noise value delimiter_opt ')'
4311
{ $$ = make_node (nod_agg_list, 2, $4, $5); }
4312
| LIST '(' DISTINCT value delimiter_opt ')'
4313
{ $$ = make_flag_node (nod_agg_list, NOD_AGG_DISTINCT, 2, $4, $5); }
4316
delimiter_opt : ',' delimiter_value
4319
{ $$ = MAKE_str_constant (MAKE_cstring(","), lex.att_charset); }
4322
delimiter_value : sql_string
4323
{ $$ = MAKE_str_constant ((dsql_str*) $1, lex.att_charset); }
4328
numeric_value_function
4329
: extract_expression
4333
extract_expression : EXTRACT '(' timestamp_part FROM value ')'
4334
{ $$ = make_node (nod_extract, (int) e_extract_count, $3, $5); }
4337
length_expression : bit_length_expression
4338
| char_length_expression
4339
| octet_length_expression
4342
bit_length_expression : BIT_LENGTH '(' value ')'
4343
{ $$ = make_node(nod_strlen, (int) e_strlen_count,
4344
MAKE_const_slong(blr_strlen_bit), $3); }
4347
char_length_expression : CHAR_LENGTH '(' value ')'
4348
{ $$ = make_node(nod_strlen, (int) e_strlen_count,
4349
MAKE_const_slong(blr_strlen_char), $3); }
4350
| CHARACTER_LENGTH '(' value ')'
4351
{ $$ = make_node(nod_strlen, (int) e_strlen_count,
4352
MAKE_const_slong(blr_strlen_char), $3); }
4355
octet_length_expression : OCTET_LENGTH '(' value ')'
4356
{ $$ = make_node(nod_strlen, (int) e_strlen_count,
4357
MAKE_const_slong(blr_strlen_octet), $3); }
4360
system_function_expression
4361
: system_function_std_syntax '(' value_list_opt ')'
4362
{ $$ = make_node(nod_sys_function, e_sysfunc_count, $1, make_list($3)); }
4363
| system_function_special_syntax
4366
system_function_std_syntax
4413
system_function_special_syntax
4414
: DATEADD '(' value timestamp_part TO value ')'
4416
$$ = make_flag_node(nod_sys_function, NOD_SPECIAL_SYNTAX, e_sysfunc_count,
4417
$1, make_node(nod_list, 3, $3, $4, $6));
4419
| DATEADD '(' timestamp_part ',' value ',' value ')'
4421
$$ = make_flag_node(nod_sys_function, NOD_SPECIAL_SYNTAX, e_sysfunc_count,
4422
$1, make_node(nod_list, 3, $5, $3, $7));
4424
| DATEDIFF '(' timestamp_part FROM value TO value ')'
4426
$$ = make_flag_node(nod_sys_function, NOD_SPECIAL_SYNTAX, e_sysfunc_count,
4427
$1, make_node(nod_list, 3, $3, $5, $7));
4429
| DATEDIFF '(' timestamp_part ',' value ',' value ')'
4431
$$ = make_flag_node(nod_sys_function, NOD_SPECIAL_SYNTAX, e_sysfunc_count,
4432
$1, make_node(nod_list, 3, $3, $5, $7));
4434
| OVERLAY '(' value PLACING value FROM value FOR value ')'
4436
$$ = make_flag_node(nod_sys_function, NOD_SPECIAL_SYNTAX, e_sysfunc_count,
4437
$1, make_node(nod_list, 4, $3, $5, $7, $9));
4439
| OVERLAY '(' value PLACING value FROM value ')'
4441
$$ = make_flag_node(nod_sys_function, NOD_SPECIAL_SYNTAX, e_sysfunc_count,
4442
$1, make_node(nod_list, 3, $3, $5, $7));
4444
| POSITION '(' value KW_IN value ')'
4446
$$ = make_flag_node(nod_sys_function, NOD_SPECIAL_SYNTAX, e_sysfunc_count,
4447
$1, make_node(nod_list, 2, $3, $5));
4451
string_value_function : substring_function
4453
| KW_UPPER '(' value ')'
4454
{ $$ = make_node (nod_upcase, 1, $3); }
4455
| KW_LOWER '(' value ')'
4456
{ $$ = make_node (nod_lowcase, 1, $3); }
4459
substring_function : SUBSTRING '(' value FROM value string_length_opt ')'
4460
/* SQL spec requires numbering to start with 1,
4461
hence we decrement the first parameter to make it
4462
compatible with the engine's implementation */
4463
{ $$ = make_node (nod_substr, (int) e_substr_count, $3,
4464
make_node (nod_subtract, 2, $5,
4465
MAKE_const_slong (1)), $6); }
4468
string_length_opt : FOR value
4471
{ $$ = MAKE_const_slong (SHRT_POS_MAX); }
4474
trim_function : TRIM '(' trim_specification value FROM value ')'
4475
{ $$ = make_node (nod_trim, (int) e_trim_count, $3, $4, $6); }
4476
| TRIM '(' value FROM value ')'
4477
{ $$ = make_node (nod_trim, (int) e_trim_count,
4478
MAKE_const_slong (blr_trim_both), $3, $5); }
4479
| TRIM '(' trim_specification FROM value ')'
4480
{ $$ = make_node (nod_trim, (int) e_trim_count, $3, NULL, $5); }
4481
| TRIM '(' value ')'
4482
{ $$ = make_node (nod_trim, (int) e_trim_count,
4483
MAKE_const_slong (blr_trim_both), NULL, $3); }
4486
trim_specification : BOTH
4487
{ $$ = MAKE_const_slong (blr_trim_both); }
4489
{ $$ = MAKE_const_slong (blr_trim_trailing); }
4491
{ $$ = MAKE_const_slong (blr_trim_leading); }
4494
udf : symbol_UDF_name '(' value_list ')'
4495
{ $$ = make_node (nod_udf, 2, $1, $3); }
4496
| symbol_UDF_name '(' ')'
4497
{ $$ = make_node (nod_udf, 1, $1); }
4500
cast_specification : CAST '(' value AS data_type_descriptor ')'
4501
{ $$ = make_node (nod_cast, (int) e_cast_count, $5, $3); }
4504
/* case expressions */
4506
case_expression : case_abbreviation
4507
| case_specification
4510
case_abbreviation : NULLIF '(' value ',' value ')'
4511
{ $$ = make_node (nod_searched_case, 2,
4512
make_node (nod_list, 2, make_node (nod_eql, 2, $3, $5),
4513
make_node (nod_null, 0, NULL)), $3); }
4514
| IIF '(' search_condition ',' value ',' value ')'
4515
{ $$ = make_node (nod_searched_case, 2,
4516
make_node (nod_list, 2, $3, $5), $7); }
4517
| COALESCE '(' value ',' value_list ')'
4518
{ $$ = make_node (nod_coalesce, 2, $3, $5); }
4519
| DECODE '(' value ',' decode_pairs ')'
4520
{ $$ = make_node(nod_simple_case, 3, $3, make_list($5), make_node(nod_null, 0, NULL)); }
4521
| DECODE '(' value ',' decode_pairs ',' value ')'
4522
{ $$ = make_node(nod_simple_case, 3, $3, make_list($5), $7); }
4525
case_specification : simple_case
4529
simple_case : CASE case_operand simple_when_clause END
4530
{ $$ = make_node (nod_simple_case, 3, $2, make_list($3), make_node (nod_null, 0, NULL)); }
4531
| CASE case_operand simple_when_clause ELSE case_result END
4532
{ $$ = make_node (nod_simple_case, 3, $2, make_list($3), $5); }
4535
simple_when_clause : WHEN when_operand THEN case_result
4536
{ $$ = make_node (nod_list, 2, $2, $4); }
4537
| simple_when_clause WHEN when_operand THEN case_result
4538
{ $$ = make_node (nod_list, 2, $1, make_node (nod_list, 2, $3, $5)); }
4541
searched_case : CASE searched_when_clause END
4542
{ $$ = make_node (nod_searched_case, 2, make_list($2), make_node (nod_null, 0, NULL)); }
4543
| CASE searched_when_clause ELSE case_result END
4544
{ $$ = make_node (nod_searched_case, 2, make_list($2), $4); }
4547
searched_when_clause : WHEN search_condition THEN case_result
4548
{ $$ = make_node (nod_list, 2, $2, $4); }
4549
| searched_when_clause WHEN search_condition THEN case_result
4550
{ $$ = make_node (nod_list, 2, $1, make_node (nod_list, 2, $3, $5)); }
4553
when_operand : value
4556
case_operand : value
4564
{ $$ = make_node(nod_list, 2, $1, $3); }
4565
| decode_pairs ',' value ',' value
4566
{ $$ = make_node(nod_list, 2, $1, make_node(nod_list, 2, $3, $5)); }
4569
/* next value expression */
4571
next_value_expression : NEXT KW_VALUE FOR symbol_generator_name
4573
if (client_dialect >= SQL_DIALECT_V6_TRANSITION)
4574
$$ = make_node (nod_gen_id2, 2, $4,
4575
MAKE_const_slong(1));
4577
$$ = make_node (nod_gen_id, 2, $4,
4578
MAKE_const_slong(1));
4580
| GEN_ID '(' symbol_generator_name ',' value ')'
4582
if (client_dialect >= SQL_DIALECT_V6_TRANSITION)
4583
$$ = make_node (nod_gen_id2, 2, $3, $5);
4585
$$ = make_node (nod_gen_id, 2, $3, $5);
4590
timestamp_part : YEAR
4591
{ $$ = MAKE_const_slong (blr_extract_year); }
4593
{ $$ = MAKE_const_slong (blr_extract_month); }
4595
{ $$ = MAKE_const_slong (blr_extract_day); }
4597
{ $$ = MAKE_const_slong (blr_extract_hour); }
4599
{ $$ = MAKE_const_slong (blr_extract_minute); }
4601
{ $$ = MAKE_const_slong (blr_extract_second); }
4603
{ $$ = MAKE_const_slong (blr_extract_millisecond); }
4605
{ $$ = MAKE_const_slong (blr_extract_week); }
4607
{ $$ = MAKE_const_slong (blr_extract_weekday); }
4609
{ $$ = MAKE_const_slong (blr_extract_yearday); }
4616
distinct_noise : DISTINCT
4620
null_value : KW_NULL
4621
{ $$ = make_node (nod_null, 0, NULL); }
4626
/* Performs special mapping of keywords into symbols */
4628
symbol_UDF_name : SYMBOL
4631
symbol_blob_subtype_name : valid_symbol_name
4634
symbol_character_set_name : valid_symbol_name
4637
symbol_collation_name : valid_symbol_name
4640
symbol_column_name : valid_symbol_name
4643
symbol_constraint_name : valid_symbol_name
4646
symbol_cursor_name : valid_symbol_name
4649
symbol_domain_name : valid_symbol_name
4652
symbol_exception_name : valid_symbol_name
4655
symbol_filter_name : valid_symbol_name
4658
symbol_gdscode_name : valid_symbol_name
4661
symbol_generator_name : valid_symbol_name
4664
symbol_index_name : valid_symbol_name
4667
symbol_item_alias_name : valid_symbol_name
4670
symbol_label_name : valid_symbol_name
4673
symbol_ddl_name : valid_symbol_name
4676
symbol_procedure_name : valid_symbol_name
4679
symbol_role_name : valid_symbol_name
4682
symbol_table_alias_name : valid_symbol_name
4685
symbol_table_name : valid_symbol_name
4688
symbol_trigger_name : valid_symbol_name
4691
symbol_user_name : valid_symbol_name
4694
symbol_variable_name : valid_symbol_name
4697
symbol_view_name : valid_symbol_name
4700
symbol_savepoint_name : valid_symbol_name
4705
valid_symbol_name : SYMBOL
4709
/* list of non-reserved words */
4712
ACTION /* added in IB 5.0 */
4717
| TYPE /* added in IB 6.0 */
4718
| KW_BREAK /* added in FB 1.0 */
4721
| COALESCE /* added in FB 1.5 */
4733
| BLOCK /* added in FB 2.0 */
4750
| ABS /* added in FB 2.1 */
4814
* PROGRAM: Dynamic SQL runtime support
4816
* DESCRIPTION: Lexical routine
4821
void LEX_dsql_init (void)
4823
/**************************************
4825
* L E X _ d s q l _ i n i t
4827
**************************************
4829
* Functional description
4830
* Initialize LEX for processing. This is called only once
4833
**************************************/
4834
for (const TOK* token = KEYWORD_getTokens(); token->tok_string; ++token)
4836
DSQL_SYM symbol = FB_NEW_RPT(*DSQL_permanent_pool, 0) dsql_sym;
4837
symbol->sym_string = (TEXT *) token->tok_string;
4838
symbol->sym_length = strlen(token->tok_string);
4839
symbol->sym_type = SYM_keyword;
4840
symbol->sym_keyword = token->tok_ident;
4841
symbol->sym_version = token->tok_version;
4842
dsql_str* str = FB_NEW_RPT(*DSQL_permanent_pool, symbol->sym_length) dsql_str;
4843
str->str_length = symbol->sym_length;
4844
strncpy((char*)str->str_data, (char*)symbol->sym_string, symbol->sym_length);
4845
symbol->sym_object = (void *) str;
4846
HSHD_insert(symbol);
4854
SSHORT character_set)
4856
/**************************************
4858
* L E X _ s t r i n g
4860
**************************************
4862
* Functional description
4863
* Initialize LEX to process a string.
4865
**************************************/
4867
lex.line_start = lex.ptr = string;
4868
lex.end = string + length;
4870
lex.att_charset = character_set;
4871
lex.line_start_bk = lex.line_start;
4872
lex.lines_bk = lex.lines;
4873
lex.param_number = 1;
4874
lex.prev_keyword = -1;
4876
if (DSQL_debug & 32)
4877
dsql_trace("Source DSQL string:\n%.*s", (int)length, string);
4882
static const TEXT* lex_position (void)
4884
/**************************************
4886
* l e x _ p o s i t i o n
4888
**************************************
4890
* Functional description
4891
* Return the current position of LEX
4892
* in the input string.
4894
**************************************/
4900
#ifdef NOT_USED_OR_REPLACED
4901
static bool long_int(dsql_nod* string,
4904
/*************************************
4908
*************************************
4910
* Functional description
4911
* checks for all digits in the
4912
* number and return an atol().
4914
*************************************/
4916
for (const UCHAR* p = (UCHAR*)((dsql_str*) string)->str_data;
4917
classes(*p) & CHR_DIGIT; p++)
4919
if (!(classes(*p) & CHR_DIGIT)) {
4924
*long_value = atol(((dsql_str*) string)->str_data);
4930
static dsql_fld* make_field (dsql_nod* field_name)
4932
/**************************************
4934
* m a k e _ f i e l d
4936
**************************************
4938
* Functional description
4939
* Make a field block of given name.
4941
**************************************/
4942
tsql* tdsql = DSQL_get_thread_data();
4944
if (field_name == NULL)
4947
FB_NEW_RPT(*tdsql->getDefaultPool(), sizeof (INTERNAL_FIELD_NAME)) dsql_fld;
4948
strcpy (field->fld_name, INTERNAL_FIELD_NAME);
4951
const dsql_str* string = (dsql_str*) field_name->nod_arg[1];
4953
FB_NEW_RPT(*tdsql->getDefaultPool(), strlen ((SCHAR*) string->str_data)) dsql_fld;
4954
strcpy (field->fld_name, (TEXT*) string->str_data);
4955
field->fld_type_of_name = NULL;
4956
field->fld_explicit_collation = false;
4957
field->fld_not_nullable = false;
4958
field->fld_full_domain = false;
4964
static dsql_fil* make_file()
4966
/**************************************
4970
**************************************
4972
* Functional description
4975
**************************************/
4976
tsql* tdsql = DSQL_get_thread_data();
4978
dsql_fil* temp_file = FB_NEW(*tdsql->getDefaultPool()) dsql_fil;
4984
static dsql_nod* make_list (dsql_nod* node)
4986
/**************************************
4990
**************************************
4992
* Functional description
4993
* Collapse nested list nodes into single list.
4995
**************************************/
4996
tsql* tdsql = DSQL_get_thread_data();
5001
stack_nodes(node, stack);
5002
USHORT l = stack.getCount();
5004
const dsql_nod* old = node;
5005
node = FB_NEW_RPT(*tdsql->getDefaultPool(), l) dsql_nod;
5006
node->nod_count = l;
5007
node->nod_type = nod_list;
5008
node->nod_line = (USHORT) lex.lines_bk;
5009
node->nod_column = (USHORT) (lex.last_token_bk - lex.line_start_bk + 1);
5010
if (MemoryPool::blk_type(old) == dsql_type_nod)
5012
node->nod_flags = old->nod_flags;
5014
dsql_nod** ptr = node->nod_arg + node->nod_count;
5016
while (stack.hasData())
5017
*--ptr = stack.pop();
5024
static dsql_nod* make_parameter (void)
5026
/**************************************
5028
* m a k e _ p a r a m e t e r
5030
**************************************
5032
* Functional description
5033
* Make parameter node
5034
* Any change should also be made to function below
5036
**************************************/
5037
tsql* tdsql = DSQL_get_thread_data();
5039
dsql_nod* node = FB_NEW_RPT(*tdsql->getDefaultPool(), e_par_count) dsql_nod;
5040
node->nod_type = nod_parameter;
5041
node->nod_line = (USHORT) lex.lines_bk;
5042
node->nod_column = (USHORT) (lex.last_token_bk - lex.line_start_bk + 1);
5043
node->nod_count = e_par_count;
5044
node->nod_arg[e_par_index] = (dsql_nod*)(IPTR) lex.param_number++;
5050
static dsql_nod* make_node (NOD_TYPE type,
5054
/**************************************
5058
**************************************
5060
* Functional description
5061
* Make a node of given type.
5062
* Any change should also be made to function below
5064
**************************************/
5065
tsql* tdsql = DSQL_get_thread_data();
5067
dsql_nod* node = FB_NEW_RPT(*tdsql->getDefaultPool(), count) dsql_nod;
5068
node->nod_type = type;
5069
node->nod_line = (USHORT) lex.lines_bk;
5070
node->nod_column = (USHORT) (lex.last_token_bk - lex.line_start_bk + 1);
5071
node->nod_count = count;
5072
dsql_nod** p = node->nod_arg;
5074
va_start (ptr, count);
5076
while (--count >= 0)
5077
*p++ = va_arg (ptr, dsql_nod*);
5084
static dsql_nod* make_flag_node (NOD_TYPE type,
5089
/**************************************
5091
* m a k e _ f l a g _ n o d e
5093
**************************************
5095
* Functional description
5096
* Make a node of given type. Set flag field
5098
**************************************/
5099
tsql* tdsql = DSQL_get_thread_data();
5101
dsql_nod* node = FB_NEW_RPT(*tdsql->getDefaultPool(), count) dsql_nod;
5102
node->nod_type = type;
5103
node->nod_flags = flag;
5104
node->nod_line = (USHORT) lex.lines_bk;
5105
node->nod_column = (USHORT) (lex.last_token_bk - lex.line_start_bk + 1);
5106
node->nod_count = count;
5107
dsql_nod** p = node->nod_arg;
5109
va_start (ptr, count);
5111
while (--count >= 0)
5112
*p++ = va_arg (ptr, dsql_nod*);
5119
static void prepare_console_debug (int level, int *yydeb)
5121
/*************************************
5123
* p r e p a r e _ c o n s o l e _ d e b u g
5125
*************************************
5127
* Functional description
5128
* Activate debug info. In WinNT, redirect the standard
5129
* output so one can see the generated information.
5130
* Feel free to add your platform specific code.
5132
*************************************/
5137
*yydeb = level >> 8;
5140
#ifdef NOT_USED_OR_REPLACED
5141
static bool short_int(dsql_nod* string,
5145
/*************************************
5149
*************************************
5151
* Functional description
5152
* is the string a valid representation
5153
* of a positive short int?
5155
*************************************/
5157
if (((dsql_str*) string)->str_length > 5) {
5161
for (UCHAR* p = (UCHAR*)((dsql_str*) string)->str_data;
5162
classes(*p) & CHR_DIGIT; p++)
5164
if (!(classes(*p) & CHR_DIGIT)) {
5169
/* there are 5 or fewer digits, it's value may still be greater
5173
buf[0] = ((dsql_str*) string)->str_data[0];
5174
buf[1] = ((dsql_str*) string)->str_data[1];
5175
buf[2] = ((dsql_str*) string)->str_data[2];
5176
buf[3] = ((dsql_str*) string)->str_data[3];
5177
buf[4] = ((dsql_str*) string)->str_data[4];
5180
*long_value = atoi (buf);
5187
return_value = *long_value > SHRT_POS_MAX;
5190
return_value = *long_value > SHRT_NEG_MAX;
5193
return_value = *long_value > SHRT_UNSIGNED_MAX;
5196
return !return_value;
5200
static void stack_nodes (dsql_nod* node,
5201
DsqlNodStack& stack)
5203
/**************************************
5205
* s t a c k _ n o d e s
5207
**************************************
5209
* Functional description
5210
* Assist in turning a tree of misc nodes into a clean list.
5212
**************************************/
5213
if (node->nod_type != nod_list)
5219
/* To take care of cases where long lists of nodes are in a chain
5220
of list nodes with exactly one entry, this algorithm will look
5221
for a pattern of repeated list nodes with two entries, the first
5222
being a list node and the second being a non-list node. Such
5223
a list will be reverse linked, and then re-reversed, stacking the
5224
non-list nodes in the process. The purpose of this is to avoid
5225
massive recursion of this function. */
5227
dsql_nod* start_chain = node;
5228
dsql_nod* end_chain = NULL;
5229
dsql_nod* curr_node = node;
5230
dsql_nod* next_node = node->nod_arg[0];
5231
while ( curr_node->nod_count == 2 &&
5232
curr_node->nod_arg[0]->nod_type == nod_list &&
5233
curr_node->nod_arg[1]->nod_type != nod_list &&
5234
next_node->nod_arg[0]->nod_type == nod_list &&
5235
next_node->nod_arg[1]->nod_type != nod_list)
5238
/* pattern was found so reverse the links and go to next node */
5240
dsql_nod* save_link = next_node->nod_arg[0];
5241
next_node->nod_arg[0] = curr_node;
5242
curr_node = next_node;
5243
next_node = save_link;
5244
end_chain = curr_node;
5247
/* see if any chain was found */
5252
/* first, handle the rest of the nodes */
5253
/* note that next_node still points to the first non-pattern node */
5255
stack_nodes (next_node, stack);
5257
/* stack the non-list nodes and reverse the chain on the way back */
5259
curr_node = end_chain;
5262
stack.push(curr_node->nod_arg[1]);
5263
if ( curr_node == start_chain)
5265
dsql_nod* save_link = curr_node->nod_arg[0];
5266
curr_node->nod_arg[0] = next_node;
5267
next_node = curr_node;
5268
curr_node = save_link;
5273
dsql_nod** ptr = node->nod_arg;
5274
for (const dsql_nod* const* const end = ptr + node->nod_count; ptr < end; ptr++)
5275
stack_nodes (*ptr, stack);
5278
inline static int yylex (
5279
USHORT client_dialect,
5281
USHORT parser_version,
5282
bool* stmt_ambiguous)
5285
lex.yylex(client_dialect, db_dialect, parser_version, stmt_ambiguous);
5286
return lex.prev_keyword;
5289
int LexerState::yylex (
5290
USHORT client_dialect,
5292
USHORT parser_version,
5293
bool* stmt_ambiguous)
5295
/**************************************
5299
**************************************
5301
* Functional description: lexer.
5303
**************************************/
5305
char string[MAX_TOKEN_LEN];
5308
/* Find end of white space and skip comments */
5317
/* Process comments */
5325
if ((c == '-') && (*ptr == '-'))
5332
if ((c = *ptr++) == '\n') {
5334
line_start = ptr /* + 1*/; /* CVC: +1 left out. */
5342
else if ((c == '/') && (*ptr == '*'))
5347
const TEXT& start_block = ptr[-1];
5350
if ((c = *ptr++) == '*') {
5356
line_start = ptr /* + 1*/; /* CVC: +1 left out. */
5362
// I need this to report the correct beginning of the block,
5363
// since it's not a token really.
5364
last_token = &start_block;
5365
yyerror("unterminated block comment");
5372
tok_class = classes(c);
5374
if (!(tok_class & CHR_WHITE))
5378
/* Depending on tok_class of token, parse token */
5380
last_token = ptr - 1;
5382
if (tok_class & CHR_INTRODUCER)
5384
/* The Introducer (_) is skipped, all other idents are copied
5385
* to become the name of the character set
5388
for (; ptr < end && classes(*ptr) & CHR_IDENT; ptr++)
5392
check_copy_incr(p, UPPER7(*ptr), string);
5395
check_bound(p, string);
5398
/* make a string value to hold the name, the name
5399
* is resolved in pass1_constant */
5401
yylval = (dsql_nod*) (MAKE_string(string, p - string))->str_data;
5406
/* parse a quoted string, being sure to look for double quotes */
5408
if (tok_class & CHR_QUOTE)
5410
char* buffer = string;
5411
size_t buffer_len = sizeof (string);
5412
const char* buffer_end = buffer + buffer_len - 1;
5414
for (p = buffer; ; ++p)
5418
if (buffer != string)
5420
yyerror("unterminated string");
5423
// Care about multi-line constants and identifiers
5426
line_start = ptr + 1;
5428
/* *ptr is quote - if next != quote we're at the end */
5429
if ((*ptr == c) && ((++ptr == end) || (*ptr != c)))
5433
char* const new_buffer = (char*) gds__alloc (2 * buffer_len);
5434
/* FREE: at outer block */
5435
if (!new_buffer) /* NOMEM: */
5437
if (buffer != string)
5441
memcpy (new_buffer, buffer, buffer_len);
5442
if (buffer != string)
5444
buffer = new_buffer;
5445
p = buffer + buffer_len;
5446
buffer_len = 2 * buffer_len;
5447
buffer_end = buffer + buffer_len - 1;
5453
*stmt_ambiguous = true; /* string delimited by double quotes could be
5454
** either a string constant or a SQL delimited
5455
** identifier, therefore marks the SQL
5456
** statement as ambiguous */
5457
if (client_dialect == SQL_DIALECT_V6_TRANSITION)
5459
if (buffer != string)
5461
yyabandon (-104, isc_invalid_string_constant);
5463
else if (client_dialect >= SQL_DIALECT_V6)
5465
if ((p - buffer) >= MAX_TOKEN_LEN)
5467
if (buffer != string)
5469
yyabandon (-104, isc_token_too_long);
5471
yylval = (dsql_nod*) MAKE_string(buffer, p - buffer);
5472
dsql_str* delimited_id_str = (dsql_str*) yylval;
5473
delimited_id_str->str_flags |= STR_delimited_id;
5474
if (buffer != string)
5479
yylval = (dsql_nod*) MAKE_string(buffer, p - buffer);
5480
if (buffer != string)
5486
* Check for a numeric constant, which starts either with a digit or with
5487
* a decimal point followed by a digit.
5489
* This code recognizes the following token types:
5491
* NUMBER: string of digits which fits into a 32-bit integer
5493
* NUMBER64BIT: string of digits whose value might fit into an SINT64,
5494
* depending on whether or not there is a preceding '-', which is to
5495
* say that "9223372036854775808" is accepted here.
5497
* SCALEDINT: string of digits and a single '.', where the digits
5498
* represent a value which might fit into an SINT64, depending on
5499
* whether or not there is a preceding '-'.
5501
* FLOAT: string of digits with an optional '.', and followed by an "e"
5502
* or "E" and an optionally-signed exponent.
5504
* NOTE: we swallow leading or trailing blanks, but we do NOT accept
5507
* Another note: c is the first character which need to be considered,
5508
* ptr points to the next character.
5511
fb_assert(ptr <= end);
5513
if ((tok_class & CHR_DIGIT) ||
5514
((c == '.') && (ptr < end) && (classes(*ptr) & CHR_DIGIT)))
5516
/* The following variables are used to recognize kinds of numbers. */
5518
bool have_error = false; /* syntax error or value too large */
5519
bool have_digit = false; /* we've seen a digit */
5520
bool have_decimal = false; /* we've seen a '.' */
5521
bool have_exp = false; /* digit ... [eE] */
5522
bool have_exp_sign = false; /* digit ... [eE] {+-] */
5523
bool have_exp_digit = false; /* digit ... [eE] ... digit */
5524
FB_UINT64 number = 0;
5525
FB_UINT64 limit_by_10 = MAX_SINT64 / 10;
5527
for (--ptr ; ptr < end ; ptr++)
5530
if (have_exp_digit && (! (classes(c) & CHR_DIGIT)))
5531
/* First non-digit after exponent and digit terminates
5534
else if (have_exp_sign && (! (classes(c) & CHR_DIGIT)))
5536
/* only digits can be accepted after "1E-" */
5542
/* We've seen e or E, but nothing beyond that. */
5543
if ( ('-' == c) || ('+' == c) )
5544
have_exp_sign = true;
5545
else if ( classes(c) & CHR_DIGIT )
5546
/* We have a digit: we haven't seen a sign yet,
5547
but it's too late now. */
5548
have_exp_digit = have_exp_sign = true;
5551
/* end of the token */
5559
have_decimal = true;
5566
else if (classes(c) & CHR_DIGIT)
5568
/* Before computing the next value, make sure there will be
5573
if (number >= limit_by_10)
5575
/* possibility of an overflow */
5576
if ((number > limit_by_10) || (c > '8'))
5582
number = number * 10 + (c - '0');
5584
else if ( (('E' == c) || ('e' == c)) && have_digit )
5587
/* Unexpected character: this is the end of the number. */
5591
/* We're done scanning the characters: now return the right kind
5592
of number token, if any fits the bill. */
5596
fb_assert(have_digit);
5600
yylval = (dsql_nod*) MAKE_string(last_token, ptr - last_token);
5601
last_token_bk = last_token;
5602
line_start_bk = line_start;
5605
return FLOAT_NUMBER;
5610
/* We should return some kind (scaled-) integer type
5611
except perhaps in dialect 1. */
5613
if (!have_decimal && (number <= MAX_SLONG))
5615
yylval = (dsql_nod*) (IPTR) number;
5616
//printf ("parse.y %p %d\n", yylval, number);
5621
/* We have either a decimal point with no exponent
5622
or a string of digits whose value exceeds MAX_SLONG:
5623
the returned type depends on the client dialect,
5624
so warn of the difference if the client dialect is
5625
SQL_DIALECT_V6_TRANSITION.
5628
if (SQL_DIALECT_V6_TRANSITION == client_dialect)
5630
/* Issue a warning about the ambiguity of the numeric
5631
* numeric literal. There are multiple calls because
5632
* the message text exceeds the 119-character limit
5633
* of our message database.
5635
ERRD_post_warning( isc_dsql_warning_number_ambiguous,
5637
ERR_string( last_token, ptr - last_token ),
5639
ERRD_post_warning( isc_dsql_warning_number_ambiguous1,
5643
yylval = (dsql_nod*) MAKE_string(last_token, ptr - last_token);
5645
last_token_bk = last_token;
5646
line_start_bk = line_start;
5649
if (client_dialect < SQL_DIALECT_V6_TRANSITION)
5650
return FLOAT_NUMBER;
5651
else if (have_decimal)
5656
} /* else if (!have_exp) */
5657
} /* if (!have_error) */
5659
/* we got some kind of error or overflow, so don't recognize this
5660
* as a number: just pass it through to the next part of the lexer.
5664
/* Restore the status quo ante, before we started our unsuccessful
5665
attempt to recognize a number. */
5668
/* We never touched tok_class, so it doesn't need to be restored. */
5670
/* end of number-recognition code */
5673
if (tok_class & CHR_LETTER)
5676
check_copy_incr(p, UPPER (c), string);
5677
for (; ptr < end && classes(*ptr) & CHR_IDENT; ptr++)
5681
check_copy_incr(p, UPPER (*ptr), string);
5684
check_bound(p, string);
5687
HSHD_lookup (NULL, (TEXT *) string, (SSHORT)(p - string), SYM_keyword, parser_version);
5688
if (sym && (sym->sym_keyword != COMMENT || prev_keyword == -1))
5690
yylval = (dsql_nod*) sym->sym_object;
5691
last_token_bk = last_token;
5692
line_start_bk = line_start;
5694
return sym->sym_keyword;
5696
yylval = (dsql_nod*) MAKE_string(string, p - string);
5697
last_token_bk = last_token;
5698
line_start_bk = line_start;
5703
/* Must be punctuation -- test for double character punctuation */
5705
if (last_token + 1 < end)
5708
HSHD_lookup (NULL, last_token, (SSHORT) 2, SYM_keyword, (USHORT) parser_version);
5712
return sym->sym_keyword;
5716
/* Single character punctuation are simply passed on */
5722
static void yyerror_detailed(const TEXT* error_string, int yychar, YYSTYPE&, YYPOSN&)
5724
/**************************************
5726
* y y e r r o r _ d e t a i l e d
5728
**************************************
5730
* Functional description
5731
* Print a syntax error.
5733
**************************************/
5734
const TEXT* line_start = lex.line_start;
5735
SLONG lines = lex.lines;
5736
if (lex.last_token < lex.line_start)
5738
line_start = lex.line_start_bk;
5743
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
5744
isc_arg_gds, isc_command_end_err2, /* Unexpected end of command */
5745
isc_arg_number, lines,
5746
isc_arg_number, (SLONG) (lex.last_token - line_start + 1),
5750
ERRD_post (isc_sqlerr, isc_arg_number, (SLONG) -104,
5751
/* Token unknown - line %d, column %d */
5752
isc_arg_gds, isc_dsql_token_unk_err,
5753
isc_arg_number, (SLONG) lines,
5754
isc_arg_number, (SLONG) (lex.last_token - line_start + 1), /*CVC: +1*/
5755
/* Show the token */
5756
isc_arg_gds, isc_random,
5757
isc_arg_cstring, (int) (lex.ptr - lex.last_token), lex.last_token,
5763
// The argument passed to this function is ignored. Therefore, messages like
5764
// "syntax error" and "yacc stack overflow" are never seen.
5765
static void yyerror(const TEXT* error_string)
5767
YYSTYPE errt_value = 0;
5768
YYPOSN errt_posn = -1;
5769
yyerror_detailed(error_string, -1, errt_value, errt_posn);
5773
static void yyabandon (SLONG sql_code,
5774
ISC_STATUS error_symbol)
5776
/**************************************
5780
**************************************
5782
* Functional description
5783
* Abandon the parsing outputting the supplied string
5785
**************************************/
5787
ERRD_post (isc_sqlerr, isc_arg_number, sql_code,
5788
isc_arg_gds, error_symbol, 0);
added
removed
src/dsql/parse.y
