parse.y

firebird源代码

/* CREATE TABLE */

table_clause	: simple_table_name external_file '(' table_elements ')'
			{ $$ = make_node (nod_def_relation, 
				(int) e_drl_count, $1, make_list ($4), $2); }
		;

rtable_clause	: simple_table_name external_file '(' table_elements ')'
			{ $$ = make_node (nod_redef_relation, 
				(int) e_drl_count, $1, make_list ($4), $2); }
		;

external_file	: EXTERNAL KW_FILE sql_string
			{ $$ = $3; }
		| EXTERNAL sql_string
			{ $$ = $2; }
		|
			{ $$ = (NOD) NULL; }
		;

table_elements	: table_element
		| table_elements ',' table_element
			{ $$ = make_node (nod_list, 2, $1, $3); }
		;

table_element	: column_def
		| table_constraint_definition
		;


/* column definition */

column_def	: column_def_name data_type_or_domain default_opt 
			end_trigger column_constraint_clause collate_clause
			{ $$ = make_node (nod_def_field, (int) e_dfl_count, 
					$1, $3, $4, make_list ($5), $6, $2, NULL); }   
		| column_def_name non_array_type def_computed
			{ $$ = make_node (nod_def_field, (int) e_dfl_count, 
				    $1, NULL, NULL, NULL, NULL, NULL, $3); }   

		| column_def_name def_computed
			{ $$ = make_node (nod_def_field, (int) e_dfl_count, 
				    $1, NULL, NULL, NULL, NULL, NULL, $2); }   
		;
                                 
/* value does allow parens around it, but there is a problem getting the
 * source text
 */

def_computed	: computed_by '(' begin_trigger value end_trigger ')'
			{ 
			field->fld_flags |= FLD_computed;
			$$ = make_node (nod_def_computed, 2, $4, $5); }
		;

computed_by	: COMPUTED BY
		| COMPUTED
		;

data_type_or_domain	: data_type begin_trigger
                          { $$ = NULL; }
			| simple_column_name begin_string
                          { $$ = make_node (nod_def_domain, (int) e_dom_count,
                                            $1, NULL, NULL, NULL, NULL); }
                        ;

collate_clause	: COLLATE symbol_collation_name
			{ $$ = $2; }
		|
			{ $$ = (NOD) NULL; }
		;

column_def_name	: column_name
			{ field_name = $1;
			  field = make_field ($1);
			  $$ = (NOD) field; }
		;

simple_column_def_name  : simple_column_name
				{ field = make_field ($1);
				  $$ = (NOD) field; }
			;


data_type_descriptor :	init_data_type data_type
			{ $$ = $1; }

init_data_type :
			{ field = make_field (NULL);
			  $$ = (NOD) field; }


default_opt	: DEFAULT default_value
			{ $$ = $2; }
		|
			{ $$ = (NOD) NULL; }
		;

default_value	: constant
			{ $$ = $1; }
/*		| USER
			{ $$ = make_node (nod_user_name, (int) 0, NULL); }
		| CURRENT_USER
			{ $$ = make_node (nod_user_name, (int) 0, NULL); }*/
		| current_user
		| current_role
		| null_value
			{ $$ = $1; }
		| datetime_value_expression
			{ $$ = $1; }
		;

column_constraint_clause : 
				{ $$ = (NOD) NULL; }
			| column_constraint_list
			;

column_constraint_list	: column_constraint_def
		        | column_constraint_list column_constraint_def
			{ $$ = make_node (nod_list, (int) 2, $1, $2); }
		        ;

column_constraint_def : constraint_name_opt column_constraint
            { $$ = make_node (nod_rel_constraint, (int) 2, $1, $2);}


column_constraint : NOT KW_NULL 
                        { $$ = make_node (nod_null, (int) 1, NULL); }
                  | REFERENCES simple_table_name column_parens_opt
			referential_trigger_action
                        { $$ = make_node (nod_foreign, e_for_count,
                        make_node (nod_list, (int) 1, field_name), $2, $3, $4); }

                  | check_constraint

                  | UNIQUE
                        { $$ = make_node (nod_unique, (int) 0, NULL); }
                  | PRIMARY KEY
                        { $$ = make_node (nod_primary, (int) 0, NULL); }
		;
                    

/* table constraints */

table_constraint_definition : constraint_name_opt table_constraint
           { $$ = make_node (nod_rel_constraint, (int) 2, $1, $2);}
                      ;

constraint_name_opt : CONSTRAINT symbol_constraint_name
                      { $$ = $2; }
                    | { $$ = NULL ;}
                    ;

table_constraint : unique_constraint
		 | primary_constraint
		 | referential_constraint
		 | check_constraint
		 ;

unique_constraint : UNIQUE column_parens
                    { $$ = make_node (nod_unique, 1, $2); }
                  ;

primary_constraint : PRIMARY KEY column_parens
			{ $$ = make_node (nod_primary, e_pri_count, $3); }
		;

referential_constraint 	: FOREIGN KEY column_parens REFERENCES 
			  simple_table_name column_parens_opt 
			  referential_trigger_action
			{ $$ = make_node (nod_foreign, e_for_count, $3, $5, 
			         $6, $7); }
		;

check_constraint : begin_trigger CHECK '(' search_condition ')' end_trigger
			{ $$ = make_node (nod_def_constraint, 
				(int) e_cnstr_count, MAKE_string (NULL_STRING, 0), NULL, 
				NULL, NULL, $4, NULL, $6, NULL, NULL); }
		;

referential_trigger_action:	
		  update_rule
		  { $$ = make_node (nod_ref_upd_del, e_ref_upd_del_count, $1, NULL);} 
		| delete_rule
		  { $$ = make_node (nod_ref_upd_del, e_ref_upd_del_count, NULL, $1);}
		| delete_rule update_rule
		  { $$ = make_node (nod_ref_upd_del, e_ref_upd_del_count, $2, $1); }
		| update_rule delete_rule
		  { $$ = make_node (nod_ref_upd_del, e_ref_upd_del_count, $1, $2);}
		| /* empty */
		  { $$ = NULL;}
		;

update_rule	: ON UPDATE referential_action
		  { $$ = $3;}
		;
delete_rule	: ON DELETE referential_action
		  { $$ = $3;}
		;

referential_action: CASCADE
		  { $$ = make_flag_node (nod_ref_trig_action, 
			 REF_ACTION_CASCADE, e_ref_trig_action_count, NULL);}
                | SET DEFAULT
		  { $$ = make_flag_node (nod_ref_trig_action, 
			 REF_ACTION_SET_DEFAULT, e_ref_trig_action_count, NULL);}
		| SET KW_NULL
		  { $$ = make_flag_node (nod_ref_trig_action, 
			 REF_ACTION_SET_NULL, e_ref_trig_action_count, NULL);}
		| NO ACTION
		  { $$ = make_flag_node (nod_ref_trig_action, 
			 REF_ACTION_NONE, e_ref_trig_action_count, NULL);}
		;

/* PROCEDURE */


procedure_clause	: symbol_procedure_name input_parameters
		     	  output_parameters
		    	  AS begin_string
			  var_declaration_list
			  full_proc_block
			  end_trigger
				{ $$ = make_node (nod_def_procedure,
						  (int) e_prc_count, 
					          $1, $2, $3, $6, $7, $8, NULL); } 
		;        

rprocedure_clause	: symbol_procedure_name input_parameters
		     	  output_parameters
		    	  AS begin_string
			  var_declaration_list
			  full_proc_block
			  end_trigger
				{ $$ = make_node (nod_redef_procedure,
						  (int) e_prc_count, 
					          $1, $2, $3, $6, $7, $8, NULL); } 
		;        

alter_procedure_clause	: symbol_procedure_name input_parameters
		     	  output_parameters
		    	  AS begin_string
			  var_declaration_list
			  full_proc_block
			  end_trigger
				{ $$ = make_node (nod_mod_procedure,
						  (int) e_prc_count, 
					          $1, $2, $3, $6, $7, $8, NULL); } 
		;        

input_parameters :	'(' proc_parameters ')'
				{ $$ = make_list ($2); }
			|
				{ $$ = NULL; }
			;

output_parameters :	RETURNS input_parameters
				{ $$ = $2; }
			|
				{ $$ = NULL; }
			;

proc_parameters	: proc_parameter
		| proc_parameters ',' proc_parameter
			{ $$ = make_node (nod_list, 2, $1, $3); }
		;

proc_parameter	: simple_column_def_name non_array_type
			{ $$ = make_node (nod_def_field, (int) e_dfl_count, 
				$1, NULL, NULL, NULL, NULL, NULL, NULL); }   
		;


var_declaration_list	: var_declarations
				{ $$ = make_list ($1); }
			|
				{ $$ = NULL; }
			;

var_declarations	: var_declaration
			| var_declarations var_declaration
			{ $$ = make_node (nod_list, 2, $1, $2); }
		;

var_declaration : DECLARE VARIABLE column_def_name non_array_type ';'
			{ $$ = make_node (nod_def_field, (int) e_dfl_count, 
				$3, NULL, NULL, NULL, NULL, NULL, NULL); }   
		;

proc_block	: proc_statement
		| full_proc_block
		;

full_proc_block	: BEGIN
		  proc_statements
		  END
			{ $$ = make_node (nod_block, e_blk_count,
					make_list ($2), NULL);}
		| BEGIN
		  proc_statements
		  excp_statements
		  END
			{ $$ = make_node (nod_block, e_blk_count,
					make_list ($2), make_list ($3));}
		;

proc_statements	: proc_block
		| proc_statements proc_block
			{ $$ = make_node (nod_list, 2, $1, $2); }
		;

proc_statement	: assignment ';'
		| delete ';'
		| EXCEPTION symbol_exception_name ';'
			{ $$ = make_node (nod_exception_stmt, 1, $2); }
		| exec_procedure
		| exec_sql
		| for_select
		| if_then_else
		| insert ';'
		| POST_EVENT value ';'
			{ $$ = make_node (nod_post, e_pst_count, $2); }
		| singleton_select
		| update ';'
		| while
		| SUSPEND ';'
			{ $$ = make_node (nod_return, e_rtn_count, NULL); }
		| EXIT ';'
			{ $$ = make_node (nod_exit, 0, NULL); }
		| KW_BREAK ';'
			{ $$ = make_node (nod_breakleave, e_break_count, NULL); }
		;

exec_procedure	: EXECUTE PROCEDURE symbol_procedure_name proc_inputs proc_outputs ';'
			{ $$ = make_node (nod_exec_procedure, e_exe_count, $3,
					  $4, $5); }
		;

exec_sql	: EXECUTE VARCHAR value ';'
			{ $$ = make_node (nod_exec_sql, e_exec_vc_count, $3); }
		;
		
for_select	: FOR select INTO variable_list cursor_def DO proc_block
			{ $$ = make_node (nod_for_select, e_flp_count, $2,
					  make_list ($4), $5, $7, NULL); }
		;

if_then_else	: IF '(' search_condition ')' THEN proc_block ELSE proc_block
			{ $$ = make_node (nod_if, e_if_count, $3, $6, $8); }
		| IF '(' search_condition ')' THEN proc_block 
			{ $$ = make_node (nod_if, e_if_count, $3, $6, NULL); }
		;

singleton_select	: select INTO variable_list ';'
			{ $$ = make_node (nod_for_select, e_flp_count, $1,
					  make_list ($3), NULL, NULL); }
		;

variable	: ':' symbol_variable_name
			{ $$ = make_node (nod_var_name, (int) e_vrn_count, 
							$2); }
		;


proc_inputs	: var_const_list
			{ $$ = make_list ($1); }
		| '(' var_const_list ')'
			{ $$ = make_list ($2); }
		|
			{ $$ = NULL; }
		;

proc_outputs	: RETURNING_VALUES variable_list
			{ $$ = make_list ($2); }
		| RETURNING_VALUES '(' variable_list ')'
			{ $$ = make_list ($3); }
		|
			{ $$ = NULL; }
		;

var_const_list	: variable
		| constant
 		| column_name
 		| null_value
		| var_const_list ',' variable
			{ $$ = make_node (nod_list, 2, $1, $3); }
		| var_const_list ',' constant
			{ $$ = make_node (nod_list, 2, $1, $3); }
		| var_const_list ',' column_name
			{ $$ = make_node (nod_list, 2, $1, $3); }
		| var_const_list ',' null_value
			{ $$ = make_node (nod_list, 2, $1, $3); }
		;

variable_list	: variable
 		| column_name
		| variable_list ',' column_name
			{ $$ = make_node (nod_list, 2, $1, $3); }
		| variable_list ',' variable
			{ $$ = make_node (nod_list, 2, $1, $3); }
		;

while		: WHILE '(' search_condition ')' DO proc_block
			{ $$ = make_node (nod_while, e_while_count,
					  $3, $6, NULL); }
		;

cursor_def	: AS CURSOR symbol_cursor_name
			{ $$ = make_node (nod_cursor, e_cur_count, $3, NULL, NULL); }
		|
			{ $$ = NULL; }
		;

excp_statements	: excp_statement
		| excp_statements excp_statement
			{ $$ = make_node (nod_list, 2, $1, $2); }
		;

excp_statement	: WHEN errors DO proc_block
			{ $$ = make_node (nod_on_error, e_err_count,
					make_list ($2), $4); }
		;

errors	: err
	| errors ',' err
		{ $$ = make_node (nod_list, 2, $1, $3); }
	;

err	: SQLCODE signed_short_integer
		{ $$ = make_node (nod_sqlcode, 1, $2); }
	| GDSCODE symbol_gdscode_name
		{ $$ = make_node (nod_gdscode, 1, $2); }
	| EXCEPTION symbol_exception_name
		{ $$ = make_node (nod_exception, 1, $2); }
	| ANY
		{ $$ = make_node (nod_default, 1, NULL); }
	;

/* Direct EXECUTE PROCEDURE */

invoke_procedure : EXECUTE PROCEDURE symbol_procedure_name prc_inputs
			{ $$ = make_node (nod_exec_procedure, e_exe_count, $3,
				  $4, make_node (nod_all, (int) 0, NULL)); }
		;

prc_inputs	: prm_const_list
			{ $$ = make_list ($1); }
		| '(' prm_const_list ')'
			{ $$ = make_list ($2); }
		|
			{ $$ = NULL; }
		;

prm_const_list	: parameter
		| constant
		| null_value
		| prm_const_list ',' parameter
			{ $$ = make_node (nod_list, 2, $1, $3); }
		| prm_const_list ',' constant
			{ $$ = make_node (nod_list, 2, $1, $3); }
		| prm_const_list ',' null_value
			{ $$ = make_node (nod_list, 2, $1, $3); }
		;

/* CREATE VIEW */

view_clause	: symbol_view_name column_parens_opt AS begin_string union_view 
                                                            check_opt end_string
			{ $$ = make_node (nod_def_view, (int) e_view_count, 
					  $1, $2, $5, $6, $7); }   
		;        

/*
rview_clause	: symbol_view_name column_parens_opt AS begin_string union_view 
                                                            check_opt end_string
			{ $$ = make_node (nod_redef_view, (int) e_view_count, 
					  $1, $2, $5, $6, $7); }   
		;        
*/

union_view      : union_view_expr
			{ $$ = make_node (nod_select, (int) 2, $1, NULL); }
		;

union_view_expr	: select_view_expr
			{ $$ = make_node (nod_list, (int) 1, $1); }
		| union_view_expr UNION select_view_expr
			{ $$ = make_node (nod_list, 2, $1, $3); }
                | union_view_expr UNION ALL select_view_expr
                        { $$ = make_flag_node (nod_list, NOD_UNION_ALL, 2, $1, $4); }
		;

select_view_expr: SELECT limit_clause
			 distinct_clause
			 select_list 
			 from_view_clause 
			 where_clause 
			 group_clause 
			 having_clause
			 plan_clause
			{ $$ = make_node (nod_select_expr, e_sel_count, 
					$2, $3, $4, $5, $6, $7, $8, $9, NULL); }
		;                                               

from_view_clause : FROM from_view_list
		 	{ $$ = make_list ($2); }
		;

from_view_list	: view_table
		| from_view_list ',' view_table
			{ $$ = make_node (nod_list, 2, $1, $3); }
		;

view_table      : joined_view_table
                | table_name
                ;

joined_view_table	: view_table join_type JOIN view_table ON search_condition
				{ $$ = make_node (nod_join, (int) e_join_count,