parse.y

firebird源代码

		| varying_keyword '(' pos_short_integer ')'
			{ 
			field->fld_dtype = dtype_varying; 
			field->fld_character_length = (SLONG) $3; 
			}
		;

varying_keyword 	   : VARCHAR
			   | CHARACTER VARYING
			   | KW_CHAR VARYING
			   ;

character_keyword 	   : CHARACTER
			   | KW_CHAR
			   ;

national_character_keyword : NCHAR
			   | NATIONAL CHARACTER
		           | NATIONAL KW_CHAR
		           ;


/* numeric type */

numeric_type	: KW_NUMERIC prec_scale
                        { 
			  field->fld_sub_type = dsc_num_type_numeric;
			}
		| decimal_keyword prec_scale
			{  
			   field->fld_sub_type = dsc_num_type_decimal;
			   if (field->fld_dtype == dtype_short)
				{
				field->fld_dtype = dtype_long;
				field->fld_length = sizeof (SLONG);
				}
			}
		;

ordinal		: pos_short_integer
			{ $$ = make_node (nod_position, 1, $1); }
		;



prec_scale	: 
			{
			field->fld_dtype = dtype_long; 
		    	field->fld_length = sizeof (SLONG); 
			field->fld_precision = 9;
		    	}
		| '(' signed_long_integer ')'
			{         
			if ( ((SLONG) $2 < 1) || ((SLONG) $2 > 18) )
			    yyabandon (-842, isc_precision_err);
				/* Precision most be between 1 and 18. */ 
			if ((SLONG) $2 > 9)
			    {
			    if ( ( (client_dialect <= SQL_DIALECT_V5) &&
				   (db_dialect     >  SQL_DIALECT_V5) ) ||
				 ( (client_dialect >  SQL_DIALECT_V5) &&
				   (db_dialect     <= SQL_DIALECT_V5) ) )
			        ERRD_post (gds__sqlerr,
					   gds_arg_number, (SLONG) -817,
					   gds_arg_gds,
					   isc_ddl_not_allowed_by_db_sql_dial,
					   gds_arg_number, (SLONG) db_dialect,
					   0);
			    if (client_dialect <= SQL_DIALECT_V5)
			        {
				field->fld_dtype = dtype_double;
				field->fld_length = sizeof (double);
			        }
			    else
			        {
				if (client_dialect == SQL_DIALECT_V6_TRANSITION)
				    {
				    ERRD_post_warning (
					isc_dsql_warn_precision_ambiguous,
					gds_arg_end );
				    ERRD_post_warning (
					isc_dsql_warn_precision_ambiguous1,
					gds_arg_end );
				    ERRD_post_warning (
					isc_dsql_warn_precision_ambiguous2,
					gds_arg_end );

				    }
				field->fld_dtype = dtype_int64;
				field->fld_length = sizeof (SINT64);
			        }
			    }
			else 
			    if ((SLONG) $2 < 5)
			    	{
			    	field->fld_dtype = dtype_short; 
			    	field->fld_length = sizeof (SSHORT); 
			    	}
			    else
			    	{
			    	field->fld_dtype = dtype_long; 
			    	field->fld_length = sizeof (SLONG); 
			    	}
			field->fld_precision = (SLONG) $2;
			}
		| '(' signed_long_integer ',' signed_long_integer ')'
			{ 
			if ( ((SLONG) $2 < 1) || ((SLONG) $2 > 18) )
			    yyabandon (-842, isc_precision_err);
				/* Precision should be between 1 and 18 */ 
			if (((SLONG) $4 > (SLONG) $2) || ((SLONG) $4 < 0))
			    yyabandon (-842, isc_scale_nogt);
				/* Scale must be between 0 and precision */
			if ((SLONG) $2 > 9)
			    {
			    if ( ( (client_dialect <= SQL_DIALECT_V5) &&
				   (db_dialect     >  SQL_DIALECT_V5) ) ||
				 ( (client_dialect >  SQL_DIALECT_V5) &&
				   (db_dialect     <= SQL_DIALECT_V5) ) )
			        ERRD_post (gds__sqlerr,
					   gds_arg_number, (SLONG) -817,
					   gds_arg_gds,
					   isc_ddl_not_allowed_by_db_sql_dial,
					   gds_arg_number, (SLONG) db_dialect,
					   0);
			    if (client_dialect <= SQL_DIALECT_V5)
			        {
				field->fld_dtype = dtype_double;
				field->fld_length = sizeof (double); 
			        }
			    else
			        {
				if (client_dialect == SQL_DIALECT_V6_TRANSITION)
				  {
				    ERRD_post_warning (
					isc_dsql_warn_precision_ambiguous,
					gds_arg_end );
				    ERRD_post_warning (
					isc_dsql_warn_precision_ambiguous1,
					gds_arg_end );
				    ERRD_post_warning (
					isc_dsql_warn_precision_ambiguous2,
					gds_arg_end );
				  }
				  /* client_dialect >= SQL_DIALECT_V6 */
				field->fld_dtype = dtype_int64;
				field->fld_length = sizeof (SINT64);
			        }
			    }
			else
			    {
			    if ((SLONG) $2 < 5)
			    	{
			    	field->fld_dtype = dtype_short; 
			    	field->fld_length = sizeof (SSHORT); 
			    	}
			    else
			    	{
			    	field->fld_dtype = dtype_long; 
			    	field->fld_length = sizeof (SLONG); 
			    	}
			    }
			field->fld_precision = (SLONG) $2;
			field->fld_scale = - (SLONG) $4;
			}
		;

decimal_keyword	: DECIMAL	
		| KW_DEC
		;


/* floating point type */

float_type	: KW_FLOAT precision_opt
			{ 
			if ((SLONG) $2 > 7)
			    {
			    field->fld_dtype = dtype_double;
			    field->fld_length = sizeof (double); 
			    }
			else
			    {
			    field->fld_dtype = dtype_real; 
			    field->fld_length = sizeof (float);
			    }
			}
		| KW_LONG KW_FLOAT precision_opt
			{ 
			field->fld_dtype = dtype_double; 
			field->fld_length = sizeof (double); 
			}
		| REAL
			{ 
			field->fld_dtype = dtype_real; 
			field->fld_length = sizeof (float); 
			}
		| KW_DOUBLE PRECISION
			{ 
			field->fld_dtype = dtype_double; 
			field->fld_length = sizeof (double); 
			}
		;

precision_opt	: '(' nonneg_short_integer ')'
			{ $$ = $2; }
		|
			{ $$ = 0; }
		;


/* SET statements */
set		: set_transaction
		| set_generator
		| set_statistics
		;

set_generator	: SET GENERATOR symbol_generator_name TO signed_long_integer
			{ 
			  $$ = make_node (nod_set_generator2,e_gen_id_count,$3,
						MAKE_constant ((STR) $5, CONSTANT_SLONG));
			}
                | SET GENERATOR symbol_generator_name TO NUMBER64BIT
                        {
			  $$ = make_node (nod_set_generator2,e_gen_id_count,$3,
				       MAKE_constant((STR)$5, CONSTANT_SINT64));
			}
                | SET GENERATOR symbol_generator_name TO '-' NUMBER64BIT
                        {
			  $$ = make_node (nod_set_generator2, e_gen_id_count, $3,
					  make_node(nod_negate, 1,
						    MAKE_constant((STR)$6, CONSTANT_SINT64)));
			}
		;

/* transaction statements */

commit		: COMMIT optional_work optional_retain
			{ $$ = make_node (nod_commit, 1, $3); }
		;

rollback	: ROLLBACK optional_work
			{ $$ = make_node (nod_rollback, 0, NULL); }
		;

optional_work	: WORK
		|
		;

optional_retain	: RETAIN opt_snapshot
			{ $$ = make_node (nod_commit_retain, 0, NULL); }
		|
		 	{ $$ = (NOD) NULL; }
		;

opt_snapshot	: SNAPSHOT
		|
		 	{ $$ = (NOD) NULL; }
		;

set_transaction	: SET TRANSACTION tran_opt_list_m
			{$$ = make_node (nod_trans, 1, make_list ($3)); }
		;

tran_opt_list_m	: tran_opt_list	
		|
		 	{ $$ = (NOD) NULL; }
		;

tran_opt_list	: tran_opt
		| tran_opt_list tran_opt
		    { $$ = make_node (nod_list, (int) 2, $1, $2); }
		;

tran_opt	: access_mode 
		| lock_wait 
		| isolation_mode 
		| tbl_reserve_options 
		;

access_mode	: READ ONLY
			{ $$ = make_flag_node (nod_access, NOD_READ_ONLY, (int) 0, NULL); }
		| READ WRITE
			{ $$ = make_flag_node (nod_access, NOD_READ_WRITE, (int) 0, NULL); }
		;

lock_wait	: WAIT
			{ $$ = make_flag_node (nod_wait, NOD_WAIT, (int) 0, NULL); }
		| NO WAIT
			{ $$ = make_flag_node (nod_wait, NOD_NO_WAIT, (int) 0, NULL); }
		;

isolation_mode	: ISOLATION LEVEL iso_mode
			{ $$ = $3;}
		| iso_mode
		;

iso_mode	: snap_shot
			{ $$ = $1;}
		| READ UNCOMMITTED version_mode 
			{ $$ = make_flag_node (nod_isolation, NOD_READ_COMMITTED, 1, $3); }
		| READ COMMITTED version_mode 
			{ $$ = make_flag_node (nod_isolation, NOD_READ_COMMITTED, 1, $3); }
		;

snap_shot	: SNAPSHOT
			{ $$ = make_flag_node (nod_isolation, NOD_CONCURRENCY, 0, NULL); }
		| SNAPSHOT TABLE 
			{ $$ = make_flag_node (nod_isolation, NOD_CONSISTENCY, 0, NULL); }
		| SNAPSHOT TABLE STABILITY
			{ $$ = make_flag_node (nod_isolation, NOD_CONSISTENCY, 0, NULL); }
		;

version_mode	: VERSION
			{ $$ = make_flag_node (nod_version, NOD_VERSION, 0, NULL); }
		| NO VERSION
			{ $$ = make_flag_node (nod_version, NOD_NO_VERSION, 0, NULL); }
		|
			{ $$ = 0; }
		;

tbl_reserve_options: RESERVING restr_list
			{ $$ = make_node (nod_reserve, 1, make_list ($2)); }
		;

lock_type	: SHARED
			{ $$ = (NOD) NOD_SHARED; }
		| PROTECTED
			{ $$ = (NOD) NOD_PROTECTED ; }
		|
			{ $$ = (NOD) 0; }
		;

lock_mode	: READ
			{ $$ = (NOD) NOD_READ; }
		| WRITE
			{ $$ = (NOD) NOD_WRITE; }
		;

restr_list	: restr_option
		| restr_list ',' restr_option
		    { $$ = make_node (nod_list, (int) 2, $1, $3); }
		;

restr_option	: table_list table_lock
			{ $$ = make_node (nod_table_lock, (int) 2, make_list ($1), $2); }
		;

table_lock	: FOR lock_type lock_mode
			{ $$ = make_flag_node (nod_lock_mode, ((SSHORT) $2 | (SSHORT) $3), 0, NULL); }
		|
			{ $$ = 0; }
		;

table_list	: simple_table_name
		| table_list ',' simple_table_name
		    { $$ = make_node (nod_list, (int) 2, $1, $3); }
		;

set_statistics	: SET STATISTICS INDEX symbol_index_name
			{$$ = make_node (nod_set_statistics, 
				(int)e_stat_count, $4); }

/* SELECT statement */

select		: union_expr order_clause for_update_clause
			{ $$ = make_node (nod_select, 3, $1, $2, $3); }
		;

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

order_clause	: ORDER BY order_list
			{ $$ = make_list ($3); }
		|
			{ $$ = 0; }
		;

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

order_item	: column_name collate_clause order_direction
			{ $$ = make_node (nod_order, e_order_count, $1, $3, $2); }
		| ordinal collate_clause order_direction
			{ $$ = make_node (nod_order, e_order_count, $1, $3, $2); }
		;

order_direction	: ASC
			{ $$ = 0; }
		| DESC
			{ $$ = make_node (nod_flag, 0, NULL); }
		|
			{ $$ = 0; }
		;
for_update_clause : FOR UPDATE for_update_list
			{ $$ = $3; }
		|
			{ $$ = 0; }
		;

for_update_list	: OF column_list
			{ $$ = $2; }
		|
			{ $$ = make_node (nod_flag, 0, NULL); }
		;

/* SELECT expression */

select_expr	: SELECT limit_clause
			 distinct_clause
			 select_list 
			 from_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); }
		;                                               


distinct_clause	: DISTINCT
			{ $$ = make_node (nod_flag, 0, NULL); }
		| all_noise 
			{ $$ = 0; }
		;

select_list	: select_items
			{ $$ = make_list ($1); }
		| '*'
			{ $$ = 0; }
		;

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

select_item	: rhs
		| rhs symbol_item_alias_name
			{ $$ = make_node (nod_alias, 2, $1, $2); }
		| rhs AS symbol_item_alias_name
			{ $$ = make_node (nod_alias, 2, $1, $3); }
		;

/* FROM clause */

from_clause	: FROM from_list
		 	{ $$ = make_list ($2); }
/*		| FROM '(' select_expr ')'
			/*{ $$ = make_list ($3); }*./
			{ $$ = make_node (nod_list, 1, $3); }*/
		;

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

table_reference	: joined_table
		| table_proc
		;

joined_table	: table_reference join_type JOIN table_reference ON search_condition
			{ $$ = make_node (nod_join, (int) e_join_count, $1, $2, $4, $6); }
		| '(' joined_table ')'
			{ $$ = $2; }
		;

table_proc	: symbol_procedure_name proc_table_inputs symbol_table_alias_name
			{ $$ = make_node (nod_rel_proc_name, 
					(int) e_rpn_count, $1, $3, $2); }
		| symbol_procedure_name proc_table_inputs
			{ $$ = make_node (nod_rel_proc_name, 
					(int) e_rpn_count, $1, NULL, $2); }
		;

proc_table_inputs	: '(' null_or_value_list ')'
				{ $$ = make_list ($2); }
			|
				{ $$ = NULL; }
			;

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

null_or_value : null_value 
              | value
              ;

table_name	: simple_table_name
		| symbol_table_name symbol_table_alias_name
			{ $$ = make_node (nod_relation_name, 
						(int) e_rln_count, $1, $2); }
		;                         

simple_table_name: symbol_table_name
			{ $$ = make_node (nod_relation_name, 
						(int) e_rln_count, $1, NULL); }
		;

join_type	: INNER
			{ $$ = make_node (nod_join_inner, (int) 0, NULL); }
		| LEFT
			{ $$ = make_node (nod_join_left, (int) 0, NULL); }
		| LEFT OUTER
			{ $$ = make_node (nod_join_left, (int) 0, NULL); }
		| RIGHT
			{ $$ = make_node (nod_join_right, (int) 0, NULL); }
		| RIGH