[antlr-interest] Again help with pl/sql grammar

lorena varela lorenavare at yahoo.com
Wed Apr 21 09:53:35 PDT 2004


Hi list.

Still I have a problem with the  pl/sql grammar. I'm
working with the plugin ANTLR Version 2.7.2 for
eclipse. The problem is that when inserted the grammar
generates this error:

TokenStreamException: expecting '(', found 'e'

I  review the metalanguage section of the docs, and I
made the changes, but still generate the error when I
compile t.g, and this is necessary for generate the
lexical analyzer and the parser in ANTLR.




I send the t.g that is the file where is the grammar.



_________________________________________________________
Do You Yahoo!?
Información de Estados Unidos y América Latina, en Yahoo! Noticias.
Visítanos en http://noticias.espanol.yahoo.com

 
Yahoo! Groups Links

<*> To visit your group on the web, go to:
     http://groups.yahoo.com/group/antlr-interest/

<*> To unsubscribe from this group, send an email to:
     antlr-interest-unsubscribe at yahoogroups.com

<*> Your use of Yahoo! Groups is subject to:
     http://docs.yahoo.com/info/terms/
 
-------------- next part --------------
class MyParser extends Parser; // definición de un analizador sintáctico



start_rule: (statement)* ;
statement :	
	(label_name)?
	( assignment_statement
	| close_statement
	| execute_immediate_statement
	| execute_statement
	| explain_plan_statement
	| exit_statement
	| fetch_statement
	| forall_statement
	| goto_statement
	| if_statement
	| loop_statement
	| null_statement
	| open_for_statement
	| open_statement
	| function_declaration
	| procedure_declaration
	| plsql_block
	| rename_statement
	| raise_statement
	| return_statement
	| call_statement
	| noaudit_statement
	| associate_statistics
	| create_type
	| create_type_body
	| create_operator
	| create_table
	| create_tablespace
	| create_temporary_tablespace
	| create_trigger
	| create_cluster
	| create_context
	| create_controlfile
	| create_index
	| create_indextype
	| create_database_link
	| create_database
	| create_dimension
	| create_directory
	| create_library
	| create_outline
	| create_pfile
	| create_synonym
	| create_package
	| create_package_body
	| create_procedure
	| create_profile
	| create_role
	| create_user
	| create_rollback_segment
	| create_schema
	| create_view
	| create_materialized_view_log
	| create_materialized_view
	| grant_statement
	| set_transaction_statement	
	| revoke_statement
	| create_snapshot
	| create_function
	| drop_cluster
	| drop_database_link
	| drop_directory
	| drop_dimension
	| drop_function
	| drop_index
	| drop_indextype
	| drop_context
	| drop_library
	| drop_operator
	| drop_package
	| drop_procedure
	| drop_profile
	| drop_role
	| drop_rollback_segment
	| drop_sequence
	| drop_snapshot
	| drop_synonym
	| drop_table
	| drop_tablespace
	| drop_trigger
	| drop_type
	| drop_type_body
	| drop_user
	| drop_view
	| drop_materialized_view
	| drop_materialized_view_log
	| drop_outline
	| disassociate_statistics
	| case_statement
	| commit_statement
	| delete_statement
	| insert_statement
	| lock_table_statement
	| rollback_statement
	| savepoint_statement
	| select_statement
	| truncate_statement
	| update_statement
	| alter_database_statement
	| alter_cluster_statement
	| alter_dimension_statement
	| alter_function_statement
	| alter_procedure_statement	
	| alter_profile_statement	
	| alter_index_statement
	| alter_indextype_statement
	| alter_operator_statement
	| alter_outline_statement
	| alter_package_statement
	| alter_resource_statement
	| alter_role_statement
	| alter_rollback_statement
	| alter_sequence_statement
	| alter_session_statement
	| alter_snapshot_statement
	| alter_system_statement
	| alter_table_statement
	| alter_tablespace_statement
	| alter_trigger_statement
	| alter_type_statement
	| alter_user_statement
	| alter_view_statement
	| alter_materialized_view_log
	| alter_materialized_view_statement
	| analyze_statement
	| audit_statement
	| comment_statement
	| merge_statement
	| set_role
	| set_constraints
	
	// java
	| create_java
	| alter_java_statement
	| drop_java_statement
	
	| expression
	| ";"
	| "/"
	) (";")?
	| label_name ;

select_statement : 
	(subquery | select_into_statement)
	(for_update_clause)?;

subquery :
	(subquery_factoring_clause)?  
	"SELECT" (hint)? 
	(distinct_all_or_unique)? select_list
	from_clause
	(where_clause)?
	(hierarchical_query_clause)?
	(group_by_clause)?
	(having_clause)?
	(subquery_clause)?
	(order_by_clause)?
	;
	
select_into_statement :
	"SELECT" 
	(distinct_or_all)? select_list
	select_into_clause 
	from_clause
	(where_clause)?
	(hierarchical_query_clause)?
	(group_by_clause)?
	(having_clause)?  
	(subquery_clause)?
	(order_by_clause)? ;

from_clause :
	"FROM" 
	( table_reference  | ("THE")? "(" subquery ")" (alias)? )+ ;

having_clause :
	"HAVING" condition ;

subquery_clause :
	subquery_operator
	( "(" subquery ")"   | subquery );
	
subquery_operator :	
	  "UNION" ("ALL")?
	| "INTERSECT" 
	| "MINUS" 
	;

select_item :
	(
	  null_tag
	| numeric_literal
	| qualified_name ("." "*" | "." ("CURRVAL" | "NEXTVAL"))?
	| function_name ("(" (parameter_name)+ "," ")")?
	| squotedstring
	(("AS")? alias)?
	) ;
	
subquery_factoring_clause :
	"WITH" 
	(query_name "AS" "(" subquery ")" )+ ;

select_list :
	"*"
	| (   query_name "." "*"
	    | (schema ".")? (table | view) ".*" 
	    | expression (("AS")? c_alias)?
	   )+;

table_reference :
	(	
	  only_reference_clause
	| "(" table_reference ")"
	| table column_list
	| "TABLE" "(" expression ")" (t_alias)?
	| query_table_expression (flashback_clause)? (t_alias)?
	)
	(joined_table_clause)? ;
	
joined_table_clause :	
	  join_on_condition_clause 
	| cross_join_clause
	| natural_join_clause
	;

join_on_condition_clause :
	(join_type)? "JOIN" table_reference 
	("ON" condition | "USING" column_list) ;

cross_join_clause :
	"CROSS" "JOIN" ;

natural_join_clause :
	"NATURAL" (join_type)? 
	"JOIN" table_reference ;

join_type :
	  "INNER" 
	  | ( "LEFT" 
	  | "RIGHT" 
	  | "FULL") ("OUTER")?;

flashback_clause :
	"AS" "OF" scn_or_timestamp
	expression ;
	
scn_or_timestamp :	
	"SCN" | "TIMESTAMP" ;
	
only_reference_clause :	
	"ONLY" query_table_expression 
	(flashback_clause)? ;
	
query_table_expression :	
	(schema ".")? 
	  ( table ( (  "PARTITION" "(" partition ")"  | "SUBPARTITION" "(" subpartition ")" ) 
			(sample_clause)?
	            | "@" dblink
        	      | sample_clause
        	    )?
	   | ( view )+ ("@" dblink)?
	  )
	  | "(" subquery (subquery_restriction_clause)? ")"
	  | query_name
	  ;

sample_clause :
	"SAMPLE" (block_tag)? "(" sample_percent ")" ;
	
block_tag : 
	"BLOCK" ;
	
subquery_restriction_clause :
	"WITH" ("READ" "ONLY"  | "CHECK" "OPTION" ("CONSTRAINT" constraint)?) ;

table_collection_expression :
	"TABLE" "(" collection_expression ")" ( "(" "+" ")" )? ;

hierarchical_query_clause :
	("START" "WITH" start_with_expression)?
	"CONNECT" "BY" connect_by_expression ;
	
start_with_expression :
	expression ;	
	
connect_by_expression :
	expression ;	

group_by_clause :
	"GROUP" "BY"
	(  rollup_cube_clause | grouping_sets_clause | expression )+
	(having_clause)?;

rollup_cube_clause :
	("ROLLUP" | "CUBE") 
	"(" grouping_expression_list ")";

grouping_sets_clause :
	"GROUPING" "SETS" 
	"(" (rollup_cube_clause | grouping_expression_list) ")";

grouping_expression_list:
	(expression_list)+ ;

order_by_clause :
	"ORDER" ("SIBLINGS")? "BY" 
	((expression | position | c_alias) 
	 (ascending_or_descending)? 
	 ("NULLS" "FIRST" | "NULLS" "LAST")? 
      )+ ;
	 
for_update_clause :
	"FOR" "UPDATE"
	("OF" (qualified_name )+ )? 
	( "NOWAIT" | "WAIT" integer )?;

select_into_clause :
	"INTO" 
	((variable_name ("(" expression ")")? 
       )+ | record_name
      );

merge_statement :
	"MERGE" (hint)? "INTO" 
	(schema ".")? table (t_alias)? 
	"USING" (schema ".")? 
	(table | view | "(" subquery ")" )
	(t_alias)? "ON" "(" condition ")" 
	"WHEN" "MATCHED" 
		"THEN" merge_update_clause 
	"WHEN" "NOT" "MATCHED" 
		"THEN" merge_insert_clause ;

merge_update_clause :
	"UPDATE" "SET" 
	(column "=" (expression | default_tag) )+;

merge_insert_clause :
	"INSERT" column_list 
	"VALUES" "(" (expression ",")+ ")" ;

set_role :
	"SET" "ROLE"
	(   "ALL" ("EXCEPT" (role)+ )?
	  | "NONE"
	  | (role ("IDENTIFIED" "BY" password)? ",")+
	)
	;

set_constraints :
	"SET" ("CONSTRAINT" | "CONSTRAINTS") 
	("ALL" | (constraint ",")+ )

	("IMMEDIATE" | "DEFERRED");

rollback:
	"ROLLBACK" ("WORK")? 
	( "TO" ("SAVEPOINT")? savepoint | "FORCE" string )?;

truncate_statement :
	"TRUNCATE" 
	("TABLE" qualified_name 
		(("PRESERVE" | "PURGE") "MATERIALIZED" "VIEW" "LOG")?
	| "CLUSTER" qualified_name
	)
	(reuse_or_drop_storage)? ;

update_statement :
	"UPDATE" (hint)?
	(  dml_table_expression_clause | "ONLY" "(" dml_table_expression_clause ")" )
	(t_alias)? 
	update_set_clause 
	(where_clause)? 
	(returning_clause)?;


update_set_clause :
	"SET"
	(
	 (  column_list "=" "(" subquery ")" | column "=" ( expression | "(" subquery ")" | default_tag )  )+
	 | "VALUE" "(" t_alias ")" "=" (expression | "(" subquery ")" )
	)
	;	
	
where_clause :
	"WHERE" condition ;
	
variance:
	"VARIANCE" "(" (distinct_or_all)? expression ")" 
	("OVER" "(" analytic_clause ")")? ;
	
var_pop:
	"VAR_POP" "(" expression ")" 
	("OVER" "(" analytic_clause ")")? ;
	
var_samp:
	"VAR_SAMP" "(" expression ")" 
	("OVER" "(" analytic_clause ")")? ;

vsize:
	"VSIZE" "(" expression ")" ;
	
width_bucket:
	"WIDTH_BUCKET" 
	"(" expression "," min_value "," 
		max_value "," num_buckets ")" ;


exception_declaration :
	exception_name "EXCEPTION" ;

exception_handler :
	"WHEN" 
	( (exception_name "OR")+ | "OTHERS" ) 
	"THEN" (statement)+ ;

delete_statement :
	 "DELETE" ("FROM")? (table_reference | ("THE")? "(" subquery ")" ) 
	 (alias)?
	 ("WHERE" (search_condition  | "CURRENT_OF" cursor_name))? 
	 (returning_clause)?;
	 
returning_clause :
	 ("RETURNING")?
	 ((single_row_expression)+   "INTO" (bind_argument)+
	 |(multiple_row_expression)+ "INTO" (bind_argument )+ )?;
	
bind_argument : 
	  variable_name 
	| ":" host_variable_name
	| number
	;
 
hint :	// hints are contained in comments
	  ("/*+") *("*/") "*/"
	| ("--+") *(#eol) ;

insert_statement :
	"INSERT" (hint)? 
	(single_table_insert | multi_table_insert);
	
single_table_insert :
	insert_into_clause 
	(values_clause (insert_returning_clause)? 
		| subquery | "(" subquery ")") ;

insert_into_clause :
	"INTO" dml_table_expression_clause (t_alias)? 
	(column_list)? ;

values_clause :
	"VALUES" "(" ( default_tag | expression )+ ")" ;

insert_returning_clause :
	"RETURNING" (expression)+
	"INTO" (bind_argument)+; 
	
multi_table_insert :	
	("ALL" (insert_into_clause (values_clause)? )+
	  | conditional_insert_clause
	)
	(subquery | "(" subquery ")") ;
	
conditional_insert_clause :	
	("ALL" | "FIRST" )? 
	("WHEN" condition "THEN" (insert_into_clause (values_clause)? )+ )+
	("ELSE" (insert_into_clause (values_clause)? )+ )? ;
	
commit_statement :
	"COMMIT" ("WORK")? 
	("COMMENT" squotedstring)? ;

rollback_statement :
	"ROLLBACK" ("WORK")? 
	("TO" ("SAVEPOINT")? savepoint_name)?;

savepoint_statement :
	"SAVEPOINT" savepoint_name;

lock_table_statement :
	"LOCK" "TABLE" (table_reference ",")+
	"IN" lock_mode "MODE" ("NOWAIT")?;

lock_mode :
	  "ROW" ("SHARE" | "EXCLUSIVE")
	| "SHARE" ("UPDATE" | "ROW" "EXCLUSIVE")?
	| "EXCLUSIVE"
	;
	
noaudit_statement :
	"NOAUDIT" 
	((sql_statement_clause)+  | (schema_object_clause)+ )
	("WHENEVER" (not_tag)? "SUCCESSFUL")?;

associate_statistics :
	"ASSOCIATE" "STATISTICS" "WITH"
	(column_association | function_association) ;
	
column_association :	
	"COLUMNS" (qualified_name)+
	using_statistics_type ;
	
function_association :
	associated_item (qualified_name)+
	( using_statistics_type | ( (default_cost_clause)+ | (default_selectivity_clause )+ )
	);
	
using_statistics_type :	
	"USING" (qualified_name | "NULL") ;
	
default_cost_clause :
	"DEFAULT" "COST" 
	"(" cpu_cost "," io_cost "," network_cost ")" ;
	
	cpu_cost : numeric ;
	io_cost : numeric ;
	network_cost : numeric ;
	
default_selectivity_clause :	
	"DEFAULT" "SELECTIVITY" default_selectivity ;

	default_selectivity : numeric;

create_table :
	  relational_table 
	| object_table 
	| XMLType_table
	;

relational_table :
	"CREATE" (global_temporary)? "TABLE" 
	(schema ".")? table ^"OF"
	("(" relational_properties ")")? 
	(on_commit_clause)?
	(physical_properties | table_properties)*;
	
object_table :
	"CREATE" (global_temporary)? "TABLE" 
	(schema ".")? table 
	"OF" (schema ".")? object_type 
	(object_table_substitution)?
	("(" object_properties ")" )? 
	(on_commit_clause)?
	(OID_clause)?
      (OID_index_clause)? 
	(physical_properties)? 
	(table_properties)?;

global_temporary :	
	"GLOBAL" "TEMPORARY" ;

on_commit_clause :
	"ON" "COMMIT" delete_or_preserve "ROWS" ;
	
delete_or_preserve :	
	  "DELETE" 
	| "PRESERVE" ;
	
relational_properties :
	  (   column (datatype)? (default_tag expression)? 
	      ((inline_constraint | inline_ref_constraint)+ )?
	    | out_of_line_constraint 
	    | out_of_line_ref_constraint 
	    | supplemental_logging_props
	   (",")? )+;

object_properties :
	(
		(column | attribute) (default_tag expression)? 
		  ((inline_constraint)+ | inline_ref_constraint)?
		| out_of_line_constraint 
		| out_of_line_ref_constraint 
		| supplemental_logging_props
	 (",")? )+;

object_table_substitution :
	substitutable_clause ;

OID_clause :
	"OBJECT" plsql_identifier "IS" 
	("SYSTEM" "GENERATED" | "PRIMARY" "KEY");

OID_index_clause :
	"OIDINDEX" (index)? 
	"(" (physical_attributes_clause | tablespace_spec)+ ")" ;

tablespace_spec :
	"TABLESPACE" tablespace ;

physical_properties :
	(
	  segment_attributes_clause (data_segment_compression)?
	| organization_heap_clause
	| organization_index_clause
	| organization_external_clause
	| "CLUSTER" cluster column_list
	)+;

organization_heap_clause :
	"ORGANIZATION" "HEAP" 
	(segment_attributes_clause)? 
	(data_segment_compression)? ;

organization_index_clause :
	"ORGANIZATION" "INDEX" 
	(segment_attributes_clause)? 
	(index_org_table_clause)? ;

organization_external_clause :
	"ORGANIZATION" "EXTERNAL" 
	external_table_clause ;

segment_attributes_clause :
	(  physical_attributes_clause
	 | tablespace_spec
	 | logging_clause
	)+ ;

physical_attributes_clause :
	(   pctfree_spec
	  | pctused_spec
	  | inittrans_spec
	  | maxtrans_spec
	  | storage_clause
	)+ ;

pctfree_spec : 
	"PCTFREE" integer ;
	
pctused_spec :
	"PCTUSED" integer	;

inittrans_spec :
	"INITRANS" integer ;

maxtrans_spec :
	"MAXTRANS" integer ;

storage_clause :	
	"STORAGE"
	("(")?
	 (  storage_initial_spec
	  | storage_next_spec 
	  | minextents_spec
	  | maxextents_spec
	  | pctincrease_spec
	  | freelists_spec
	  | freelist_groups_spec
	  | storage_optimal_spec
	  | buffer_pool_spec 
	  )+
	(")")?;

storage_initial_spec :
	"INITIAL" integer (K_or_M)? ;

storage_next_spec :
	"NEXT" integer (K_or_M)? ;

minextents_spec :
	"MINEXTENTS" integer ;

maxextents_spec :
	"MAXEXTENTS" (integer | "UNLIMITED"); 
	
pctincrease_spec : 
	"PCTINCREASE" integer ;

freelists_spec :
	"FREELISTS" integer ;

freelist_groups_spec :
	"FREELIST" "GROUPS" integer ;

storage_optimal_spec :
	"OPTIMAL" (integer (K_or_M)? | null_tag)? ;

buffer_pool_spec :
	"BUFFER_POOL" buffer_pool_option ;
	
buffer_pool_option :	
	  "KEEP" 
	| "RECYCLE" 
	| "DEFAULT" ;
	
data_segment_compression :
	  "COMPRESS" 
	| "NOCOMPRESS" ;
	
table_properties :
	(column_properties)? 
	(table_partitioning_clauses)? 
	(row_movement_clause)?
	(cache_clause)? 
	(rowdependencies_spec)?
	(monitoring_spec)?
	(parallel_clause)? 
	(enable_disable_clause)*
	("AS" subquery)? ;

column_properties :
	(column_property)+ ;
	
column_property :	
	  object_type_col_properties
	| nested_table_col_properties
	| (varray_col_properties | LOB_storage_clause) 
	  (LOB_partition_storage)?
	| XMLType_column_properties
	;

object_type_col_properties :
	"COLUMN" column 
	substitutable_column_clause ;

substitutable_column_clause :
	  ("ELEMENT")? "IS" "OF" ("TYPE")? 
	  "(" ("ONLY")? type ")"
	| substitutable_clause ;
	
nested_table_col_properties :
	"NESTED" "TABLE" 
	(nested_item | "COLUMN_VALUE")
	(substitutable_column_clause)? 
	store_as_table_clause
	("(" ("(" object_properties ")" )? 
	(physical_properties)? (column_properties)? ")" )?
	("RETURN" "AS" ("LOCATOR" | "VALUE") )?;

store_as_table_clause : 
	"STORE" "AS" storage_table ;

varray_col_properties :
	"VARRAY" varray_item 
	(   substitutable_column_clause | "STORE" "AS" "LOB"
	    (LOB_segname ("(" LOB_parameters ")" )? 
	      | "(" LOB_parameters ")")
	);

LOB_storage_clause :
	"LOB"
	(  "(" (LOB_item)+ ")" 	"STORE" "AS" "(" LOB_parameters ")"
	 | "(" LOB_item ")"  "STORE" "AS" 
	    (LOB_segname ("(" LOB_parameters ")" )? 
		    	| "(" LOB_parameters ")")
	);
	
LOB_parameters :
	( tablespace_spec
	| storage_in_row_clause 
	| storage_clause
	| chunk_clause
	| pctversion_clause
	| retention_tag 
	| freepools_clause
	| cache_clause
	)+;
	
storage_in_row_clause :		
	enable_or_disable "STORAGE" "IN" "ROW" ;
		
logging_clause :
	  "LOGGING" 
	| "NOLOGGING" ;
	
pctversion_clause :
	"PCTVERSION" integer ;
	
retention_tag :
	"RETENTION"	;

freepools_clause :
	"FREEPOOLS" integer ;
	
chunk_clause :
	"CHUNK" integer ;
	
LOB_partition_storage :
	"PARTITION" partition 
	(LOB_storage_clause | varray_col_properties)+
	("(" "SUBPARTITION" subpartition 
	   (LOB_storage_clause | varray_col_properties)+
	 ")"
	)?;

row_movement_clause :
	enable_or_disable "ROW" "MOVEMENT" ;

index_org_table_clause :
	( mapping_table_clauses
	 | pctthreshold_clause
	 | key_compression
	 | index_org_overflow_clause
	)+
	;

index_org_overflow_clause :
	("INCLUDING" column)? 
	(segment_attributes_clause | pctthreshold_clause)*
	"OVERFLOW"
	(segment_attributes_clause)?;
	
mapping_table_clause :
	  "MAPPING" "TABLE"
	| "NOMAPPING" ;

pctthreshold_clause :
	"PCTTHRESHOLD" integer ;

key_compression :
	  "COMPRESS" (integer)? 
	| "NOCOMPRESS" ;

supplemental_logging_props :
	"SUPPLEMENTAL" "LOG" "GROUP" 
	log_group column_list
	("ALWAYS")? ;

external_table_clause :	
	"(" ("TYPE" access_driver_type)? 
		external_data_properties ")" 
	("REJECT" "LIMIT" (integer | "UNLIMITED"))? ;

external_data_properties :
	"DEFAULT" "DIRECTORY" directory
	("ACCESS" "PARAMETERS" 
		("(" opaque_format_spec ")" | "USING" "CLOB" subquery) )?
	"LOCATION" "(" ((directory ":")? 
		location_specifier)+ ")" ;

opaque_format_spec : 
	  record_format_info
	| fields_clause ;

record_format_info : 
	"RECORDS" record_size_spec
  	(record_format_option)*
   	(fields_clause)?;
   	
record_size_spec :
	  fixed_record_size
	| variable_record_size
	| delimited_record_size ;
	
fixed_record_size :	
	"FIXED" integer ;
	
variable_record_size :	
	"VARIABLE" integer ;
	
delimited_record_size :
	"DELIMITED" "BY" delimited_by_spec ;
	
delimited_by_spec :	
	  "NEWLINE" 
	| string ;

record_format_option :
	  record_format_characterset
	| record_format_endian
	| record_format_BOM
	| record_format_string_sizes
	| record_format_load_when
	| record_format_badfile 
	| record_format_discardfile
	| record_format_logfile
	| record_format_readsize
	| record_format_date_cache
	| record_format_skip
   	;

record_format_characterset :
	"CHARACTERSET" string ;
	
record_format_endian :
	"DATA" "IS" little_or_big "ENDIAN" ;
	
little_or_big :	
	  "LITTLE" 
	| "BIG" ;
	
record_format_BOM :
	"BYTE" "ORDER" "MARK" 
	check_or_nocheck ;
	
check_or_nocheck :	
	  "CHECK" 
	| "NOCHECK" ;
	
record_format_string_sizes :
	"STRING" "SIZES" "ARE" "IN" 
	bytes_or_characters ;
	
bytes_or_characters :	
	  "BYTES" 
	| "CHARACTERS" ;
	
record_format_load_when :
	"LOAD" "WHEN" condition_spec ;
	
record_format_badfile :
	  "NOBADFILE" 
	| "BADFILE" 
		(directory_object_name ":")? filename ;

record_format_discardfile :
	  "NODISCARDFILE" 
	| "DISCARDFILE" 
		(directory_object_name ":")? filename ;

record_format_logfile :
	  "NOLOGFILE" 
	| "LOGFILE" 
		(directory_object_name ":")? filename ;

record_format_readsize :
	"READSIZE" integer ;

record_format_date_cache :
	"DATE_CACHE" integer ;
	
record_format_skip :
	"SKIP" integer ;
	
fields_clause : 
	"FIELDS" (delim_spec)? (trim_spec)? 
	(missing_field_values_are_null)? 
	(reject_rows_with_all_null_fields)? 
	(field_list)? ;

missing_field_values_are_null :
	"MISSING" "FIELD" "VALUES" "ARE" "NULL" ;

reject_rows_with_all_null_fields :
	"REJECT" "ROWS" "WITH" "ALL" "NULL" "FIELDS" ;

position_spec :
	("POSITION")? 
	"(" (pos_start | "*")
	    (("+" | "-") pos_increment)?
	    ":"
	    (pos_end | pos_length) ")" ;
	
	pos_start 	  : number;
	pos_increment : number;
	pos_end 	  : number;
	pos_length 	  : number;

delim_spec :
	  "ENCLOSED" "BY" string ("AND" string)? 
	| "TERMINATED" "BY" (string | "WHITESPACE") 
	  (("OPTIONALLY")? "ENCLOSED" "BY" string ("AND" string)? )? ;

trim_spec : 
	  "LRTRIM" 
	| "NOTRIM" 
	| "LTRIM" 
	| "RTRIM" 
	| "LDRTRIM"
	;

field_list : 
	"(" (field_name (position_spec)? 
	(datatype)? (init_spec)? )+ ")";


location_specifier : squotedstring ;

init_spec :
	("DEFAULTIF" | "NULLIF") 
	condition;

table_partitioning_clauses :
	  range_partitioning
	| hash_partitioning 
	| list_partitioning
	| composite_partitioning
	;

range_partitioning :
	"PARTITION" "BY" "RANGE" column_list
	  "(" ("PARTITION" (partition)? range_values_clause 
	    table_partition_description)+ ")" ;
	
hash_partitioning  :
	"PARTITION" "BY" "HASH" column_list
	(individual_hash_partitions | hash_partitions_by_quantity);

list_partitioning :
	"PARTITION" "BY" "LIST" "(" column ")"
	"(" ("PARTITION" (partition)? list_values_clause 
		table_partition_description)+ ")" ;

composite_partitioning :
	"PARTITION" "BY" "RANGE" column_list
	(subpartition_by_list | subpartition_by_hash)? 
	  "(" ("PARTITION" (partition)? range_values_clause 
	  	table_partition_description ",")+ ")" ;

subpartition_by_hash :
	"SUBPARTITION" "BY" "HASH" column_list
	("SUBPARTITIONS" quantity (store_in_clause)? | subpartition_template)?;

individual_hash_partitions :		
	"(" ("PARTITION" (partition partitioning_storage_clause)? )+ ")" ;

hash_partitions_by_quantity :
	"PARTITIONS" hash_partition_quantity 
	(store_in_clause)?
	("OVERFLOW" store_in_clause)? ;

subpartition_by_list :
	"SUBPARTITION" "BY" "LIST" "(" column ")" 
	(subpartition_template)? ;
	
subpartition_template :
	"SUBPARTITION" "TEMPLATE"
	"(" (SUBPARTITION subpartition 
		(list_values_clause)? 
		(partitioning_storage_clause)? )+ ")" 
	| hash_subpartition_quantity ;
	
range_values_clause :
	"VALUES" "LESS" "THAN"
	  "(" (value | "MAXVALUE")+ ")" ;
	  
list_values_clause :
	"VALUES" "(" 
	(value 
	| null_tag 
	| default_tag)+ 
	")" ;

table_partition_description :
	(segment_attributes_clause)? 
	(data_segment_compression)? 
	(key_compression)?
	(table_partition_overflow_clause)?
	(LOB_storage_clause | varray_col_properties)*
	(partition_level_subpartition)? ;
	
table_partition_overflow_clause :	
	"OVERFLOW" (segment_attributes_clause)? ;
	
partition_level_subpartition :	
	  "SUBPARTITIONS" hash_subpartition_quantity 
	  (store_in_clause)?
	| "(" (subpartition_spec)+ ")" ;
	
subpartition_spec :	
	"SUBPARTITION" (subpartition)? 
	(list_values_clause)? 
	(partitioning_storage_clause)? ;

partitioning_storage_clause :
	( (tablespace_spec
	  | partitioning_storage_overflow_clause
	  | partitioning_storage_lob_clause 
	  | partitioning_storage_varray_clause
	  )+
	)? ;

partitioning_storage_overflow_clause :
	"OVERFLOW" (tablespace_spec)? ;

partitioning_storage_lob_clause  :
	"LOB" "(" LOB_item ")" "STORE" "AS"
	(LOB_segname ( "(" tablespace_spec ")" )? 
		| "(" tablespace_spec ")" );
		
partitioning_storage_varray_clause :
	"VARRAY" varray_item 
	"STORE" "AS" "LOB" LOB_segname ;
	
parallel_clause :
	  "NOPARALLEL" 
	| "PARALLEL" 
		(integer
		| "(" (plsql_identifier numeric)* ")" )? ;	

enable_disable_clause :
	enable_or_disable 
	(validate_or_novalidate)?
	( unique_columns_spec
	| primary_key_spec 
	| "CONSTRAINT" constraint
	)
	(using_index_clause)? 
	(exceptions_clause)? 
	(cascade_tag)? 
	(keep_or_drop_index)? ;

unique_columns_spec :
	"UNIQUE" column_list ;

keep_or_drop_index :
	keep_or_drop "INDEX" ;
	
keep_or_drop :	
	  "KEEP" 
	| "DROP" ;

primary_key_spec :
	"PRIMARY" "KEY" ;

using_index_clause :
	"USING" "INDEX"
	( (schema ".")? index
		| "(" create_index ")"
		| "LOCAL" 
		| global_partitioned_index 
		| ( pctfree_spec
		  | inittrans_spec
		  | maxtrans_spec
		  | tablespace_spec
		  | storage_clause
		  | "NOSORT"
		  | logging_clause 
		  )+ 
	)?;

global_partitioned_index :	
	"GLOBAL" "PARTITION" 
	"BY" "RANGE" column_list
	"(" (global_partitioning_clause)+ ")" ;

global_partitioning_clause :
	"PARTITION" (partition)? 
	"VALUES" "LESS" "THAN" "(" (value)+ ")"
	  (segment_attributes_clause)?;
	  
create_tablespace : 
	"CREATE" ("UNDO")? tablespace_spec
	(datafile_tempfile_clause)?
	(( minimum_extent_clause
	 | blocksize_clause
	 | logging_clause  
	 | force_logging_spec
	 | default_storage_clause
	 | online_or_offline
	 | permanent_or_temporary
	 | extent_management_clause
	 | segment_management_clause
	 )+ )? ;

permanent_or_temporary :
	  "PERMANENT" 
	| "TEMPORARY" ;

extent_management_clause : 
	"EXTENT" "MANAGEMENT" 
	("DICTIONARY" | "LOCAL" 
		("AUTOALLOCATE" | "UNIFORM" (size_spec)? )?);

segment_management_clause :
	"SEGMENT" "SPACE" "MANAGEMENT" ("MANUAL" | "AUTO");

minimum_extent_clause :
	"MINIMUM" "EXTENT" integer ( K_or_M )? ;
	
blocksize_clause :
	"BLOCKSIZE" integer ("K")? ;

create_temporary_tablespace :
	"CREATE" "TEMPORARY" tablespace_spec
	("TEMPFILE" datafile_tempfile_spec)? 
	temp_tablespace_extent ;
	
temp_tablespace_extent :	
	("EXTENT" "MANAGEMENT" "LOCAL")? 
	("UNIFORM" ("SIZE" integer (K_or_M)? )? )? ;

create_trigger :
	"CREATE" ("OR" "REPLACE")? 
	"TRIGGER" qualified_name
	("BEFORE" | "AFTER" | "INSTEAD" "OF")
	( dml_event_clause 
	| (ddl_event "OR")+
	| (database_event "OR")+
	) ("ON" ((schema ".")? "SCHEMA" | "DATABASE"))?
	("WHEN" "(" condition ")")? 
	(call_statement | plsql_block) ;
	
dml_event_clause :
	("DELETE" | "INSERT" | "UPDATE" ("OF" (column ",")+ )? "OR")+
	"ON" (qualified_name | 
		("NESTED" "TABLE" nested_table_column "OF")? qualified_name)
	(referencing_clause)? ("FOR" "EACH" "ROW")? ;
	
ddl_event : 
 	  "ALTER"   | "ANALYZE" | "ASSOCIATE" "STATISTICS"    | "AUDIT"
	| "COMMENT" | "CREATE"  | "DISASSOCIATE" "STATISTICS" | "DROP"
	| "GRANT"   | "NOAUDIT" | "RENAME" | "REVOKE" | "TRUNCATE"
	| "DDL" ;

database_event : 
	  "SERVERERROR" | "LOGON" | "LOGOFF" | "STARTUP"
	| "SHUTDOWN" | "SUSPEND" ;

nested_table_column : plsql_identifier;

referencing_clause : 
	"REFERENCING"
	( "OLD" ("AS")? old 
	| "NEW" ("AS")? new 
	| "PARENT" ("AS")? parent )+ ;

	old 	 : plsql_identifier;
	new 	 : plsql_identifier;
	parent : plsql_identifier;




call_statement :
	"CALL" 
	(object_access_expression 
		| qualified_name ("@" dblink)?
	)
	"(" (expression )+ ")"
	("." simple_expression)?
	("INTO" ":" host_variable 
		(("INDICATOR")? ":" indicator_variable)? )?;

create_cluster :
	"CREATE" "CLUSTER" cluster_name
	"(" (column datatype)+ ")"
	(( physical_attributes_clause
	 | size_spec
	 | tablespace_spec
	 | ("INDEX" | ("SINGLE" "TABLE")? 
	 	"HASHKEYS" integer ("HASH" "IS" expression)?)
	 )+ )?
	(parallel_clause)? 
	(rowdependencies_spec)? 
	(cache_clause)?;

cluster_name :
	qualified_name ;
	
create_type :
	"CREATE" ("OR" "REPLACE")? "TYPE" 
	(schema ".")? type_name		// incomplete type stops here...
	(  create_varray_type
	 | create_nested_table_type 
	 | create_object_type
	)?;
	
create_varray_type :
	("IS" | "AS") 
	("VARRAY" | "VARYING" "ARRAY")
	"(" limit ")" "OF" datatype ;

create_nested_table_type :
	("IS" | "AS") 
	"TABLE" "OF" datatype ;
	
create_object_type :
	(invoker_rights_clause)?
	(("IS" | "AS") "OBJECT"
		| "UNDER" (schema ".")? supertype)
	(sqlj_object_type)?
	("(" (attribute_spec | element_spec )+ ")" )?
	((not_tag)? final_tag)? 
	((not_tag)? instantiable_tag)? ;

invoker_rights_clause :
	"AUTHID" ("CURRENT_USER" | "DEFINER");

attribute_spec :
	attribute 
	datatype 
	(sqlj_object_type_attr)? ;
	
SQLData : 
	"SQLData" "(" ((sql_data_item )+ )? ")"
	((not_tag)? final_tag)? ;

sql_data_item :
	(parameter datatype | subprogram_clauses)
	(sqlj_object_type_sig)?
      ;
	
element_spec :
	(inheritance_clauses)? 
	(  subprogram_clauses 
 	 | constructor_spec 
	 | map_order_function_spec )+
	( (pragma_clause )+ )? ;

inheritance_clauses :
	(not_tag)?
	( overriding_tag
	| final_tag
	| instantiable_tag );
	
subprogram_clauses :	
	member_or_static
	(procedure_spec | function_spec);

member_or_static :
	  "MEMBER" 
	| "STATIC" ;
	
procedure_spec :	
	"PROCEDURE" name 
	("(" arguments ")")?
	( ("IS" | "AS") call_spec )? ;
	
function_spec :	
	"FUNCTION" name 
	("(" arguments ")")?
	return_clause 
	("DETERMINISTIC")? ;
	
	
	
constructor_spec :	
	(final_tag)? (instantiable_tag)? 
	"CONSTRUCTOR" "FUNCTION" datatype 
	( ("SELF" "IN" "OUT" datatype ",")? 
		parameter_list)?
	return_clause ;
	
map_order_function_spec :
	map_or_order
	"MEMBER" function_spec ;
	
map_or_order :	
	  "MAP" 
	| "ORDER" ;
	
return_clause :
	  "RETURN" (self_as_result | datatype)
	  ( ("IS" | "AS") call_spec )?
	  (sqlj_object_type_sig)? ;

self_as_result :
	"SELF" "AS" "RESULT" ;

pragma_clause :
	"PRAGMA" pragma_name 
	("(" (method_name | default_tag) ","
	    (pragma_arg)+
	")" )? ;
	
pragma_arg :
	  "RNDS" 
	| "WNDS" 
	| "RNPS" 
	| "WNPS" 
	| "TRUST" 
	| number
	;

pragma_name : identifier;

call_spec :
	"LANGUAGE" (Java_declaration | C_declaration);
	
Java_declaration :	
	"JAVA" "NAME" squotedstring ;
	
C_declaration :	
	"C" ("NAME" name)? 
	"LIBRARY" lib_name 
	("AGENT" "IN" "(" argument ")" )?
	("WITH" "CONTEXT")? 
	("PARAMETERS" "(" parameters ")" )? ;
	

create_type_body :
	"CREATE" ("OR" "REPLACE")? 
	"TYPE" "BODY" (schema ".")? type_name 
	("IS" | "AS") 
	((
		member_or_static
	      (  procedure_declaration 
	       | function_declaration 
	       | constructor_declaration)
	   |  map_or_order "MEMBER" function_declaration
	)+ )?
	"END" ;
	
procedure_declaration :	
	"PROCEDURE" name 
	( "(" (arguments)? ")" )?
	("IS" | "AS") 
	(plsql_block | call_spec) 
	(";")?; 

function_declaration :
	"FUNCTION" name 
	("(" (arguments)? ")")?
	"RETURN" datatype
	("IS" | "AS") 
	(plsql_block | call_spec) 
	(";")?; 

constructor_declaration :
	(final_tag)? (instantiable_tag)? 
	"CONSTRUCTOR" "FUNCTION" datatype 
	( ("SELF" "IN" "OUT" datatype ",")? 
	parameter_list)?
	"RETURN" self_as_result
	("IS" | "AS") (plsql_block | call_spec)
	(";")?; 

parameter_list :
	(parameter datatype)+ ;

create_package :
	"CREATE" ("OR" "REPLACE")? 
	"PACKAGE" (schema ".")? package
	(invoker_rights_clause)? ("IS" | "AS") 
	plsql_package_spec
	"END" (label_name)? ;
	
plsql_package_spec : 
	(  procedure_spec (";")?
	 | function_spec (";")? 
	 | type_definition (";")?
	 | item_definition (";")?
	 | exception_declaration (";")? 
	 | pragma_clause (";")?
	)+ ;

create_package_body :
	"CREATE" ("OR" "REPLACE")? 
	"PACKAGE" "BODY" (schema ".")? package
	("IS" | "AS") 
	plsql_package_body;

plsql_package_body : 
	(label_name)?
	("DECLARE")? 	
	(type_definition | item_definition)*
	(function_declaration | procedure_declaration)*
	("BEGIN" (statement)* )?
	"END" (label_name)? (";")? ;

create_procedure :
	"CREATE" ("OR" "REPLACE")? 
	"PROCEDURE" (schema ".")? procedure
	("(" arguments ")" )? 
	(invoker_rights_clause)? 
	("IS" | "AS") 
	(plsql_subprogram_body | call_spec) ;
	
create_profile :
	"CREATE" "PROFILE" profile_name "LIMIT" 
	(resource_parameter | password_parameter)+
       ;

create_role :
	"CREATE" "ROLE" role
	(role_identity_clause)? ;

create_user :
	"CREATE" "USER" user_name
	(create_user_option)* ;
	
create_user_option :
	  user_identified_by_clause
	| default_tablespace_clause
	| temporary_tablespace_clause
	| quota_clause
	| profile_clause
	| default_role_clause 
	| password_expire_clause
	| account_lock_clause
	| proxy_clause
	;

user_identified_by_clause :
	"IDENTIFIED"
	( "BY" password ("REPLACE" old_password)?
	| externally_or_globally
	) ;

default_tablespace_clause : 
	"DEFAULT" tablespace_spec ;

temporary_tablespace_clause :
	"TEMPORARY" tablespace_spec ;

profile_clause :
	"PROFILE" profile_name ;
	
default_role_clause :
	"DEFAULT" "ROLE" 
	( (role )+
		| "ALL" ( "EXCEPT" (role)+ )?
	      | "NONE"
	) ;

password_expire_clause :
	"PASSWORD" "EXPIRE" ;
	
account_lock_clause :
	"ACCOUNT" lock_or_unlock ;
	
lock_or_unlock : 
	"LOCK" | "UNLOCK" ;

quota_clause :
	"QUOTA" 
	(integer ( K_or_M )? | "UNLIMITED")
	"ON" tablespace ;
		
create_rollback_segment :
	"CREATE" ("PUBLIC")? 
	"ROLLBACK" "SEGMENT" rollback_segment
	( tablespace_spec | storage_clause )*;

create_schema :
	"CREATE" "SCHEMA" "AUTHORIZATION" schema
	( create_table | create_view | grant_statement )+;

create_view : 
	"CREATE" ("OR" "REPLACE")? 
	(("NO")? "FORCE")? "VIEW" (schema ".")? view
	(view_clause)?
	"AS" subquery (subquery_restriction_clause)?;
	
view_clause :	
	"(" (view_alias (inline_constraint)* 
		| out_of_line_constraint)+ ")"
	| object_view_clause
	| XMLType_view_clause
	;
	
view_alias :
	identifier (? #value !: "CONSTRAINT" );
	
object_view_clause :
	"OF" qualified_name
	(with_object_id_clause
	 | "UNDER" qualified_name)
	("(" (out_of_line_constraint 
		| attribute (inline_constraint)+  )+ ")" )?
	;
	
with_object_id_clause :
	"WITH" "OBJECT" ("IDENTIFIER" | "ID")
	(default_tag | "(" (attribute)+  ")" ) ;
	
create_materialized_view :
	"CREATE" "MATERIALIZED" "VIEW" 
	(schema ".")? materialized_view
	("OF" (schema ".")? object_type)? 
  	("(" scoped_table_ref_constraint ")" )?
  	(("ON" "PREBUILT" "TABLE" 
  		(("WITH" | "WITHOUT") "REDUCED" "PRECISION")?
	 | physical_properties 
	 | materialized_view_props )+ )?
	("USING" "INDEX"
	    ((physical_attributes_clause | tablespace_spec)+ )?
  	 | "USING" "NO" "INDEX")?
  	(mv_refresh)?
  	("FOR" "UPDATE")? 
  	(("DISABLE" | "ENABLE") "QUERY" "REWRITE")? 
  	"AS" subquery;

ref_column 		: plsql_identifier;
ref_attribute 	: plsql_identifier;
scope_table_name 	: plsql_identifier;

scoped_table_ref_constraint :
	("SCOPE" "FOR" "(" (ref_column | ref_attribute) ")" 
	  "IS" (schema ".")? scope_table_name )+ ;
	  
materialized_view_props :
  	( column_properties
	| table_partitioning_clauses
	| cache_or_nocache
	| parallel_clause
	| build_clause
	)+;
	  
cache_or_nocache :	  
	  "CACHE" 
	| "NOCACHE" ;

build_clause :	  
	"BUILD" ("IMMEDIATE" | "DEFERRED");
	  
mv_refresh :
	"REFRESH"
	( ("FAST" | "COMPLETE" | "FORCE")	| "ON" ("DEMAND" | "COMMIT") 
	  | ("START" "WITH" | "NEXT") date 	| "WITH" (primary_key_spec | "ROWID")
	  | "USING" ("DEFAULT" ("MASTER" | "LOCAL")? "ROLLBACK" "SEGMENT"
	  | ("MASTER" | "LOCAL")? "ROLLBACK" "SEGMENT" rollback_segment
	    ) 
	    (("DEFAULT" ("MASTER" | "LOCAL")? "ROLLBACK" "SEGMENT"
	    	| ("MASTER" | "LOCAL")? "ROLLBACK" "SEGMENT" rollback_segment
	    )+ )?
	)+
	| "NEVER" "REFRESH"
	;
	
create_materialized_view_log :
	"CREATE" "MATERIALIZED" "VIEW" "LOG" "ON" (schema ".")? table
	(( physical_attributes_clause
	 | tablespace_spec
	 | logging_clause
	 | cache_or_nocache
	)+ )?
	(parallel_clause)? 
	(table_partitioning_clauses)?
	("WITH" 
	 ( "OBJECT" "ID" 
	  | primary_key_spec
	  | "ROWID" 
	  | "SEQUENCE" 
	  | column_list
	  (",")? )+ 
	 ( new_values_clause )?
	)?;
	
new_values_clause :	
	("INCLUDING" | "EXCLUDING") "NEW" "VALUES" ;
	
grant_statement : 
	"GRANT" 
	( grant_system_privileges 
	| grant_object_privileges
	)+ ;

grant_system_privileges :
	(system_privilege | role | "ALL" "PRIVILEGES" )+
	"TO" grantee_clause ("IDENTIFIED" "BY" password)? 
	("WITH" "ADMIN" "OPTION")? ;

grant_object_privileges :
	((object_privilege | "ALL" ("PRIVILEGES")?)
		(column_list)? )+
	"ON" on_object_clause 
	"TO" grantee_clause 
	("WITH" "GRANT" "OPTION")? 
	("WITH" "HIERARCHY" "OPTION")? ;
	
grantee_clause :
	(user_name | role | "PUBLIC")+ ;

object_privilege : 
	  sql_verb
	| "REFERENCES"
	;

on_object_clause :
	  "DIRECTORY" directory_name
	| "JAVA" ("SOURCE" | "RESOURCE") qualified_name
	| (schema ".")? object_name
	;

set_transaction_statement :
	"SET" "TRANSACTION"
	( (read_write_clause
	  | "ISOLATION" "LEVEL" 
		  ("SERIALIZABLE" | "READ" "COMMITTED")
	  | "USE" "ROLLBACK" "SEGMENT" rollback_segment
	  )
	  ("NAME" string)?
	| "NAME" string
	) ;

revoke_statement :
	"REVOKE" 
	( revoke_system_privileges 
	| revoke_object_privileges )+ 
	;

revoke_system_privileges :
	(  system_privilege 
	 | role 
	 | "ALL" "PRIVILEGES" )+ 
	"FROM" grantee_clause ;

revoke_object_privileges :
	((  object_privilege 
	  | "ALL" ("PRIVILEGES")?) 
	  (column_list)? )+
	"ON" on_object_clause 
	"FROM" grantee_clause 
	(cascade_constraints_tag)? 
	(force_tag)?;

create_snapshot :
	"CREATE" "SNAPSHOT" ("LOG" "ON")? snapshot_name
	(( pctfree_spec
  	 | pctused_spec
  	 | tablespace_spec
  	 | "WITH" ("ROWID" | primary_key_spec | "(" column ")" )+
  	 | refresh_clause
  	 | storage_clause
  	 | using_index_clause
  	)+ )?  	 
  	("AS" subquery)? ;

refresh_clause :
	"REFRESH" 
	(( "FAST" 
	 | "NEXT" expression 
	 | "COMPLETE"
	 | "WITH" "PRIMARY" "KEY"
	 | ("USING")? ("DEFAULT")? ("MASTER" | "LOCAL")? 
	   "ROLLBACK" "SEGMENT" (segment_name)?
	 | "START" "WITH" expression "NEXT" expression
	)+ )?
	;

create_function :
	"CREATE" ("OR" "REPLACE")? 
	"FUNCTION" function_name
	("(" arguments ")")?
	"RETURN" datatype 

	((  invoker_rights_clause 
	 | "DETERMINISTIC" 
	 | parallel_enable_clause )+ )? 
	( ("AGGREGATE" | "PIPELINED") 
	   "USING" implementation_type
	  | ("PIPELINED")? ("IS" | "AS") 
	   (plsql_function_body | call_spec)
	)
	;

parallel_enable_clause :
	"PARALLEL_ENABLE"
	("(" "PARTITION" argument "BY" 
	   ("ANY" | ("HASH" | "RANGE") column_list)
	 ")"
	 (streaming_clause)?
	)?;

streaming_clause :
	("ORDER" | "CLUSTER") "BY" column_list ;

arguments : 
	(argument)+;

argument :
	plsql_identifier 
	(in_out_spec)?
	(nocopy_spec)?
	datatype 
	(argument_default_clause)? ;
	
in_out_spec :
	  "IN" "OUT" 
	| "IN" 
	| "OUT" ;
	
nocopy_spec :	
	"NOCOPY" ;
	
argument_default_clause :
	"DEFAULT"
	expression ;	

plsql_block :
	(label_name )?
	("DECLARE")?
	(( type_definition 
	 | item_definition 
	 | pragma_clause (";")? )+ )?
	((function_declaration | procedure_declaration)+ )?
	"BEGIN" 
		(statement)*
		("EXCEPTION" (exception_handler)+ )?
	"END" (label_name)? (";")?

	;
	
item_definition : 
	item_declaration (";")? ;

ref_cursor_type_definition : 
	"TYPE" identifier "IS" "REF" 

	cursor_declaration ; 
type_definition :
	(
	  record_type_definition
	| ref_cursor_type_definition
	| table_type_definition
	| subtype_definition
	| varray_type_definition
	) ";"
	;

subtype_definition :
	"SUBTYPE" subtype_name "IS" base_type
	("(" constraint ")")? (not_null_spec)?;

constant_declaration :
	constant_name "CONSTANT" datatype 
	(initializer)? ;
	
initializer :	
	(not_null_spec)? 
	(":=" | "=" | default_tag) expression ;

not_null_spec :
	  "NOT_NULL" 
	| "NOT" "NULL" ;
	
item_declaration :
	  variable_declaration		// subsumes object_declaration
	| collection_declaration
	| constant_declaration
	| cursor_declaration
	| exception_declaration
	| record_declaration
	;

table_type_definition :
	"TYPE" type_name "IS" 
	"TABLE" "OF" element_type 
	(not_null_spec)? 
	("INDEX" "BY" "BINARY_INTEGER")?;

varray_type_definition :
	"TYPE" type_name "IS" 
	("VARRAY" | "VARRYING ARRAY") "(" size_limit ")"
	"OF" element_type 
	(not_null_spec)? ;

collection_declaration :
   collection_name type_name ;

element_type :
	  datatype
	| cursor_name "%ROWTYPE"
	| db_table_name ( "%ROWTYPE" | "." column "%TYPE")
	| object_name "%TYPE"
	| ("REF")? object_type_name
	| record_name ("." field_name)? "%TYPE"
	| record_type_name
	| scalar_datatype_name
	| variable_name "%TYPE"
	;

object_type_declaration : 
	"CREATE" ("OR_REPLACE")? 
	"TYPE" (schema_name ".")? type_name
	 ("AUTHID" ("CURRENT_USER" | "DEFINER"))? 
	 ("IS" | "AS") "OBJECT" "(" member_list ")" ;
	 
member_list :
	(attribute_name attribute_type)+ ;

object_type_body :
	"CREATE" ("OR_REPLACE")? 
	"TYPE_BODY" (schema_name ".")? type_name
	("IS" | "AS")
	(member_or_static (subprogram_body | call_spec) ";" )+
	(map_or_order "MEMBER" function_body ";" )? 
	"END" ;

record_type_definition :
	"TYPE" type_name "IS RECORD" 
	"(" (field_declaration )+ ")" ;
	
field_declaration :
	field_name datatype 
	(initializer)? ;
	
record_declaration :
	record_name type_name;

variable_declaration :
	(variable_name )+ datatype 
	(initializer)? ;

cursor_declaration :
	"CURSOR" (cursor_name)?
	("(" (cursor_parameter_declaration)+ ")" )?
	("RETURN" rowtype)? 
	("IS" select_statement)?;

cursor_body :
	"CURSOR" cursor_name 
	("(" (cursor_parameter_declaration )+ ")" )?
	"RETURN" rowtype "IS" select_statement;

cursor_parameter_declaration :
	parameter_name ("IN")? datatype 
	(initializer)? ;
   
rowtype :
	((  db_table_name 
	  | cursor_name 
	  | cursor_variable_name ) "%" "ROWTYPE"
	 | record_name "%" "TYPE"
	 | record_type_name) ;
 
column_list :
	"(" (column )+ ")" ;
	
condition : expression ;

rename_statement : 
	"RENAME" old_name "TO" new_name;
	
create_operator :
	"CREATE" ("OR" "REPLACE")? "OPERATOR"
	qualified_name binding_clause;
	
binding_clause :
	"BINDING" 
	("(" (parameter_type )+ ")" 
		"RETURN" return_type  implementation_clause )+ ;
		
	parameter_type : datatype;
	return_type : datatype;
	
implementation_clause :
	("ANCILLARY" "TO"
	  (primary_operator "(" (parameter_type )+ ")" )+
	| context_clause ("COMPUTE" "ANCILLARY" "DATA")?
	)?
	using_function_clause ;

	primary_operator : plsql_identifier;
	
context_clause :	
	"WITH" "INDEX" "CONTEXT" "," 
	"SCAN" "CONTEXT" implementation_type ;
	
using_function_clause :
	"USING" qualified_name ;

create_context :
	"CREATE" ("OR" "REPLACE")? "CONTEXT" 
	namespace "USING" qualified_name
	("INITIALIZED" externally_or_globally
	| "ACCESSED" "GLOBALLY")?
	;

	namespace : identifier;

create_controlfile :
	"CREATE" "CONTROLFILE" (reuse_tag)?
	("SET")? "DATABASE" database
	(( 
	   logfile_clause
	 | resetlogs_spec
	 | datafile_tempfile_clause
	 | maxlogfiles_spec
	 | maxlogmembers_spec
	 | maxloghistory_spec
	 | maxdatafiles_spec
	 | maxinstances_spec
	 | archivelog_spec
	 | force_logging_spec
	 )+ )?
	(character_set_clause)?;

maxlogfiles_spec :
	"MAXLOGFILES" integer ;

maxlogmembers_spec :
	"MAXLOGMEMBERS" integer ;
	
maxloghistory_spec :	
	"MAXLOGHISTORY" integer ;
	
maxdatafiles_spec :
	"MAXDATAFILES" integer ;
	
maxinstances_spec :
	"MAXINSTANCES" integer ;
	
logfile_clause :
	"LOGFILE" ((logfile_group_spec)? redo_log_file_spec )+ ;
	
logfile_group_spec :
	"GROUP" integer ;
	
force_logging_spec :
	("NO")? "FORCE" "LOGGING" ;
	
character_set_clause :	
	("NATIONAL")? "CHARACTER" "SET" character_set ;

create_index :
	"CREATE" ("UNIQUE" | "BITMAP")? "INDEX"
	(schema ".")? index "ON"
	(  cluster_index_clause 
	 | table_index_clause 
	 | bitmap_join_index_clause);

cluster_index_clause :
	"CLUSTER" (schema ".")? cluster index_attributes ;

table_index_clause :
	(schema ".")? table (t_alias)? 
	"(" (index_expr (ascending_or_descending)? )+ ")"
	((   global_partitioned_index 
	  | local_partitioned_index
	  | index_attributes 
	  | domain_index_clause
	)+ )?;

bitmap_join_index_clause :
	(schema ".")? table 
	"(" ((schema ".")? (table)? 
		column (ascending_or_descending)? )+ ")"
	from_clause
	where_clause
	(local_partitioned_index)? 
	index_attributes ;
	
index_expr :
	expression ;

index_attributes :
	(( physical_attributes_clause
	 | logging_clause
	 | online_tag
	 | compute_statistics_tag
	 | "TABLESPACE" (tablespace | default_tag)
	 | key_compression
	 | "NOSORT" 
	 | "REVERSE"
	 | parallel_clause
	 )+ )?;

local_partitioned_index :
	"LOCAL"
	( 
	  on_comp_partitioned_table
	| on_range_partitioned_table
	| on_list_partitioned_table
	| on_hash_partitioned_table
	)?;

domain_index_clause :
	"INDEXTYPE" "IS" indextype 
	(parallel_clause)? 
	("PARAMETERS" "(" squotedstring ")" )? ;
	
on_range_partitioned_table :
	"(" (
		"PARTITION" (partition 
			((segment_attributes_clause)+ )? )? 
	     )+ 
	")" ;
	
on_list_partitioned_table :
	"(" (
		"PARTITION" (partition 
			((segment_attributes_clause)+ )? )? 
	     )+ 
	")" ;
	
on_hash_partitioned_table : 
	  store_in_clause
	| "(" ("PARTITION" (partition 
		(tablespace_spec)? )? )+ ")"
	;
	
on_comp_partitioned_table :
	(store_in_clause)?
	"(" ("PARTITION" 
	   (partition (segment_attribute_clause)*
	   (index_subpartition_clause)? )? )+
	 ")";
	
index_subpartition_clause :
	  store_in_clause
	| "(" ("SUBPARTITION" (subpartition (tablespace_spec)? )? )+ ")" ;

store_in_clause :
	"STORE" "IN" "(" ((tablespace)+ | default_tag) ")" ;

create_indextype :
	"CREATE" ("OR" "REPLACE")? "INDEXTYPE"
	indextype_name "FOR"
	((schema ".")? operator_name "(" (paramater_type)+ ")" )+
	"USING" implementation_type;

	indextype_name : qualified_name ;
	paramater_type : datatype;


create_database :
	"CREATE" "DATABASE" (database)?
	(( "USER" ("SYS" | "SYSTEM") 
		"IDENTIFIED" "BY" password
	| "CONTROLFILE" "REUSE"
	| "LOGFILE" ((logfile_group_spec)? redo_log_file_spec)+
	| maxlogfiles_spec
	| maxlogmembers_spec
	| maxloghistory_spec
	| maxdatafiles_spec
	| maxinstances_spec
	| archivelog_spec
	| force_logging_spec
	| character_set_clause
	| datafile_tempfile_clause
	| extent_management_local_spec
	| default_temp_tablespace
	| undo_tablespace_clause
	| set_time_zone_clause
	)+ )? ;

default_temp_tablespace :
	"DEFAULT" "TEMPORARY" 
	tablespace_spec
	("TEMPFILE" datafile_tempfile_spec)? 
	temp_tablespace_extent_clause ;
	
temp_tablespace_extent_clause :	
	(extent_management_local_spec)?
	("UNIFORM" (size_spec)? )? ;
	
extent_management_local_spec :
	"EXTENT" "MANAGEMENT" "LOCAL"	;
	
undo_tablespace_clause :	
	"UNDO" tablespace_spec
	(datafile_tempfile_clause)? ;

create_database_link :
	"CREATE" ("SHARED")? ("PUBLIC")? 
	"DATABASE" "LINK" dblink
	("CONNECT" "TO" 
		( "CURRENT_USER" 
		| user_name "IDENTIFIED" 
		  "BY" password (authenticated_clause)? )
	| authenticated_clause
	)? 
	("USING" connect_string)?;

connect_string : string;

authenticated_clause :
	"AUTHENTICATED" "BY" user_name
	"IDENTIFIED" "BY" password ;
	
create_dimension :
	"CREATE" "DIMENSION" qualified_name  	(level_clause)+
	(hierarchy_clause | attribute_clause)+ ;

create_directory :
	"CREATE" ("OR" "REPLACE")? "DIRECTORY"
	 directory "AS" path_name;
	 
	 path_name : string;

create_library :
	"CREATE" ("OR" "REPLACE")? 
	"LIBRARY" qualified_name
	("IS" | "AS") filename 
	("AGENT" agent_dblink)?;

create_outline :
	"CREATE" ("OR" "REPLACE")? 
	("PUBLIC" | "PRIVATE")? 
	"OUTLINE" (outline)?
	("FROM" ("PUBLIC" | "PRIVATE" )? source_outline)?
	("FOR" "CATEGORY" category)?
	("ON" statement)? ;
	
	source_outline : plsql_identifier;
	category : plsql_identifier;

agent_dblink : string;

create_synonym :
	"CREATE" ("OR" "REPLACE")? ("PUBLIC")? 
	"SYNONYM" synonym_name
	"FOR" qualified_name ("@" dblink)?;

synonym_name : qualified_name ;

create_pfile :
	"CREATE" "PFILE" ("=" pfile_name)? 
	"FROM" "SPFILE" ("=" spfile_name)?;
	
	pfile_name : string;
	spfile_name : string;

alter_database_statement :
	"ALTER" "DATABASE" (database)?
	( startup_clauses
	| recovery_clauses 
	| database_file_clauses
	| logfile_clauses
	| controlfile_clauses
	| standby_database_clauses
	| default_settings_clauses
	| conversion_clauses
	| redo_thread_clauses
	| security_clause
	) ;

startup_clauses :
	  startup_mount_clause
	| startup_open_clause 
	;
	
startup_mount_clause :		   
	"MOUNT" (startup_mount_option "DATABASE")? ;
	
startup_mount_option :
	  "STANDBY"
	| "CLONE" ;

startup_open_clause :	
	"OPEN" 
	read_write_clause
	(resetlogs_spec)?
	(migrate_clause)? ;

migrate_clause :
	"MIGRATE" ;

recovery_clauses :
	  general_recovery
	| managed_standby_recovery
	| end_backup_tag
	;

general_recovery :
	"RECOVER" ("AUTOMATIC")? ("FROM" location)?
	(( full_database_recovery
	  | partial_database_recovery
	  | "LOGFILE" filename
	  )
	  (( "TEST" 
	   | "ALLOW" integer "CORRUPTION" 
	   | parallel_clause)+ )?
	| "CONTINUE" (default_tag)?
	| "CANCEL"
	);

location : string;

full_database_recovery :
	((("STANDBY")? "DATABASE")?
	(("UNTIL" 
		(  "CANCEL" 
		 | "TIME" date 
		 | "CHANGE" integer )
	 | "USING" "BACKUP" "CONTROLFILE" 
	)+ )? ) <1,> ;

	date 	     : expression;
	filenumber : numeric;
	
datafile_tempfile_clause :
	"DATAFILE" (datafile_tempfile_spec)+ ;
	
datafile_tempfile_spec :
	string 
	((  size_spec
	  | reuse_tag
	  | autoextend_clause
	)+ )?
	| autoextend_clause ;

redo_log_file_spec : 
	( log_file_name | "(" (log_file_name )+ ")")
	(size_spec)? ;

log_file_name :
	string ;
	
partial_database_recovery :
	  "TABLESPACE" (tablespace )+
	| datafile_filename_number_clause
	| "STANDBY" 
		("TABLESPACE" (tablespace )+
		| datafile_filename_number_clause
		"UNTIL" ("CONSISTENT" "WITH")? "CONTROLFILE")
	;
	
datafile_filename_number_clause :	
	"DATAFILE" ((filename )+ | (filenumber )+) ;

managed_standby_recovery :
	"RECOVER" "MANAGED" "STANDBY" "DATABASE"
	  (recover_clause | cancel_clause | finish_clause)?;

recover_clause :
	( 
	  recover_disconnect_clause
	| recover_timeout_clause
	| recover_delay_clause
	| recover_expire_clause
	| recover_next_clause 
	| recover_through_clause 
	| parallel_clause
	)+ ;

recover_disconnect_clause : 
	"DISCONNECT" (from_session)? ;

recover_delay_clause :
	  "NODELAY" 
	| "DEFAULT" "DELAY" 
	| "DELAY" integer ;
	
recover_timeout_clause :	
	  "TIMEOUT" integer 
	| "NOTIMEOUT" ;

recover_expire_clause :
	  "EXPIRE" integer 
	| "NO" "EXPIRE" ;
	
recover_next_clause : 
	"NEXT" integer ;

recover_through_clause :
	"THROUGH" 
	(( "THREAD" integer )? "SEQUENCE" integer
	  | "ALL" "ARCHIVELOG"
	  | ("ALL" | "LAST" | "NEXT") "SWITCHOVER"
	);
	
cancel_clause :
	"CANCEL" ("IMMEDIATE")? ("NOWAIT")?;

finish_clause :
	("DISCONNECT" (from_session)?)? 
	(parallel_clause)? 
	"FINISH" ("SKIP" ("STANDBY" "LOGFILE")?)? 
	("WAIT" | "NOWAIT")? ;
	
database_file_clauses :
	  "CREATE" "DATAFILE" 
	  ((filename)+ | (filenumber)+ ) 	  ("AS" ((datafile_tempfile_spec)+ |"NEW"))?
	| datafile_filename_number_clause
	  ( online_or_offline
	  | resize_clause
	  | autoextend_clause
	  | end_backup_tag
	  )
	| "TEMPFILE" ((filename)+ | (filenumber)+ )
	  ( resize_clause
	  | autoextend_clause
	  | "DROP" ("INCLUDING" "DATAFILES")?
	  | online_or_offline
	  )
	| "RENAME" "FILE" (filename)+ "TO" filename
	;

resize_clause :
	"RESIZE" integer (K_or_M)? ;
	
autoextend_clause :
	"AUTOEXTEND" ("OFF" | "ON" 
		("NEXT" integer (K_or_M)?)? 
	(maxsize_clause)?);
	
maxsize_clause :
	"MAXSIZE" ("UNLIMITED" | integer (K_or_M)?);
	
logfile_clauses :
    	  archivelog_spec
	| force_logging_spec
	| "ADD" ("STANDBY")? "LOGFILE" ("THREAD" integer)?
	  ((logfile_group_spec)? redo_log_file_spec )+
	  (size_spec)?
	| "DROP" ("STANDBY")? "LOGFILE" (logfile_descriptor)+
	| "ADD" ("STANDBY")? "LOGFILE" "MEMBER" (filename (reuse_tag)? )+
	  "TO" (logfile_descriptor)+
	| "DROP" ("STANDBY")? "LOGFILE" "MEMBER" (filename )+
	| "ADD" "SUPPLEMENTAL" "LOG" "DATA" 
	   ( "(" (primary_key_spec | "UNIQUE" "INDEX" )+ ")" "COLUMNS" )?
	| "DROP" "SUPPLEMENTAL" "LOG" "DATA"
	| "RENAME" "FILE" (filename )+ "TO" filename
	| "CLEAR" ("UNARCHIVED")? "LOGFILE"
	  (logfile_descriptor)+ ("UNRECOVERABLE" "DATAFILE")?
	;

logfile_descriptor :	
	  logfile_group_spec
	| "(" (filename )+ ")"
	| filename
	;

controlfile_clauses :
	  "CREATE" "STANDBY" "CONTROLFILE" "AS" filename (reuse_tag)?
	| "BACKUP" "CONTROLFILE" "TO" 
	  (filename (reuse_tag)? | trace_file_clause)
	;
	
trace_file_clause :
	"TRACE" (resetlogs_spec)? ;
	
standby_database_clauses :
	( "ACTIVATE" ("PHYSICAL" | "LOGICAL")? 
	  "STANDBY" "DATABASE" ("SKIP" ("STANDBY" "LOGFILE")?)?
	| "SET" "STANDBY" "DATABASE" "TO" "MAXIMIZE"
	    ("PROTECTION" | "AVAILABILITY" | "PERFORMANCE")
	| "REGISTER" ("OR" "REPLACE")? ("PHYSICAL" | "LOGICAL")? "LOGFILE"
	                    ((redo_log_file_spec )+ )?
	| commit_switchover_clause
	| "START" "LOGICAL" "STANDBY" "APPLY"
	     ("NEW" "PRIMARY" dblink | "INITIAL" (scn_value)?)
	| ("STOP" | "ABORT") "LOGICAL" "STANDBY" "APPLY"
	)
	(parallel_clause)? ;

	scn_value 	  : expression;
	character_set : plsql_identifier;

commit_switchover_clause :
	"COMMIT" "TO" "SWITCHOVER" "TO"
	("PHYSICAL" | "LOGICAL") ("PRIMARY" | "STANDBY")
	(("WITH" | "WITHOUT") "SESSION" "SHUTDOWN")?

	("WAIT" | "NOWAIT")? ;

default_settings_clauses :	
	  character_set_clause
	| set_time_zone_clause
	| "DEFAULT" "TEMPORARY" tablespace_spec
	| "RENAME" "GLOBAL_NAME" "TO" database "." (domain".")+
	;

set_time_zone_clause :
	"SET" "TIME_ZONE" "=" string ;	
	// ' ( ( + | - )+ hh : mi | time_zone_region )+ '

conversion_clauses :	
	  "RESET" "COMPATIBILITY" 
	| "CONVERT" 
	;

redo_thread_clauses :
	  "ENABLE" ("PUBLIC")? "THREAD" integer 
	| "DISABLE" "THREAD" integer
	;

security_clause :	
	"GUARD" ("ALL" | "STANDBY" | "NONE");

alter_cluster_statement :
	"ALTER" "CLUSTER" (schema ".")? cluster
	( physical_attributes_clause
	| size_spec
	| allocate_extent_clause
	| deallocate_unused_clause
	| cache_clause
	)+
	(parallel_clause)?
	;

allocate_extent_clause :
	"ALLOCATE" "EXTENT"
	("(" (size_spec
	   | "DATAFILE" filename
	   | "INSTANCE" integer )+
	 ")"
	)?;
	
deallocate_unused_clause :
	"DEALLOCATE" "UNUSED"
	("KEEP" integer ( K_or_M )? )? ;

alter_dimension_statement :
	"ALTER" "DIMENSION" qualified_name
	( "ADD"
	      ( level_clause
	      | hierarchy_clause
	      | attribute_clause
	      )
	| "DROP"
	      ("LEVEL" level ("RESTRICT" | cascade_tag)?
	      | "HIERARCHY" hierarchy
	      | "ATTRIBUTE" level
	      )
	| compile_clause
	)+;
	
level_clause :	
	"LEVEL" level "IS" 
	( table "." column 
	| "(" (table "." column )+ ")"
	);
	
hierarchy_clause :
	"HIERARCHY" hierarchy 
	"(" child_level ("CHILD" "OF" parent_level)+
	    (join_clause)? ")";
	
join_clause :
	("JOIN" "KEY" 
	(child_key_column | "(" (child_key_column )+ ")")
		"REFERENCES" parent_level )+ ;

attribute_clause :		
	"ATTRIBUTE" level "DETERMINES"
	(dependent_column | "(" (dependent_column "," )+ ")" ) ;

level : identifier;
child_level : level;
parent_level : level;
hierarchy : identifier;
child_key_column : column;
dependent_column : column;

alter_function_statement : 
	"ALTER" "FUNCTION" (schema ".")? function_name
	compile_clause (reuse_settings)?;

alter_procedure_statement : 
	"ALTER" "PROCEDURE" (schema ".")? procedure_name 
	compile_clause (reuse_settings)?;

alter_profile_statement :
	"ALTER" "PROFILE" profile_name "LIMIT" 
	(resource_parameter | password_parameter)+ ;
	
resource_parameter :	
	  resource_parameter_name 
	  resource_parameter_value ;
	
resource_parameter_name :
	  "SESSIONS_PER_USER"
	| "CPU_PER_SESSION"
	| "CPU_PER_CALL"
	| "CONNECT_TIME"
	| "IDLE_TIME"
	| "LOGICAL_READS_PER_SESSION"
	| "LOGICAL_READS_PER_CALL"
	| "COMPOSITE_LIMIT"
	| "PRIVATE_SGA"
	;

resource_parameter_value :
	  integer (K_or_M)?
	| "UNLIMITED" 
	| default_tag ;

password_parameter :
	password_parameter_name
	password_parameter_value ;

password_parameter_name :
	  "FAILED_LOGIN_ATTEMPTS"
	| "PASSWORD_LIFE_TIME"
	| "PASSWORD_REUSE_TIME"
	| "PASSWORD_REUSE_MAX"
	| "PASSWORD_LOCK_TIME"
	| "PASSWORD_GRACE_TIME"
	| "PASSWORD_VERIFY_FUNCTION"
	;

password_parameter_value :
	  "UNLIMITED" 
	| default_tag 
	| expression
	| function
	| null_tag
	; 
	
alter_index_statement :
	"ALTER" "INDEX" (schema ".")? index
	(( deallocate_unused_clause 
	| allocate_extent_clause
	| parallel_clause
	| physical_attributes_clause
	| logging_clause
	| rebuild_clause
	| "PARAMETERS" "(" alter_index_params ")"
	| enable_or_disable
	| unusable_tag
	| rename_partition_clause
	| coalesce_tag
	| monitoring_spec "USAGE"
	| update_block_references_tag
	| alter_index_partitioning
	)+ )? 
	;
	
rename_partition_clause :
	"RENAME" ("PARTITION" partition)? "TO" new_name ;

	alter_index_params : string;	
	new_name : identifier;

rebuild_clause :
	"REBUILD"
	(   "PARTITION" partition 
	  | "SUBPARTITION" subpartition
	  | rebuild_reverse_clause
	)?
	((  parallel_clause
	  | tablespace_spec
	  | "PARAMETERS" "(" rebuild_paramaters ")"
	  | online_tag
	  | compute_statistics_tag
	  | physical_attributes_clause
	  | key_compression
	  | logging_clause
	)+ )? ;
	
	rebuild_paramaters : string;
	
	rebuild_reverse_clause :
	    "REVERSE" 
	  | "NOREVERSE" ;
	
alter_index_partitioning :
	  modify_index_default_attrs
	| modify_index_partition
	| rename_index_partition
	| drop_index_partition
	| split_index_partition
	| modify_index_subpartition
	;

modify_index_default_attrs :
	"MODIFY" "DEFAULT" "ATTRIBUTES" ("FOR" "PARTITION" partition)?
	( physical_attributes_clause
	| "TABLESPACE" (tablespace | default_tag)
	| logging_clause
	)+ ;

modify_index_partition :
	"MODIFY" "PARTITION" partition
	( ( physical_attributes_clause
	  | logging_clause
	  | deallocate_unused_clause
	  | allocate_extent_clause
	  )+ 
	| "PARAMETERS" "(" alter_partition_params ")"
	| coalesce_tag
	| update_block_references_tag
	| unusable_tag
	);

	alter_partition_params : string;
	partition_name : identifier;
	partition_name_old : identifier;

rename_index_partition :
	"RENAME" 
	(  "PARTITION" partition 
	 | "SUBPARTITION" subpartition) 
	"TO" new_name ;
	
drop_index_partition :	
	"DROP" "PARTITION" partition_name ;

	
split_index_partition :	
	"SPLIT" "PARTITION" partition_name_old 
	"AT" "(" (value )+ ")"
	("INTO" "(" (index_partition_description )+ ")")? 
	(parallel_clause)?;
	
index_partition_description :
	"PARTITION" 
	(partition (( segment_attributes_clause 
			| key_compression )+ )? )? ;

modify_index_subpartition :
	"MODIFY" "SUBPARTITION" subpartition 
	( unusable_tag
	| allocate_extent_clause
	| deallocate_unused_clause
	);

alter_indextype_statement :
	"ALTER" "INDEXTYPE" qualified_name
	( (("ADD" | "DROP") (schema ".")? operator_name 
	"(" parameter_types ")" )+
	  (using_type_clause)?
	| compile_clause
	)+ ;
	

	operator_name : plsql_identifier;
	parameter_types : (identifier)+;

using_type_clause :
	"USING" qualified_name;
	
alter_operator_statement :
	"ALTER" "OPERATOR" 
	(schema ".")? operator_name "COMPILE";
	
alter_outline_statement :
	"ALTER" "OUTLINE" ("PUBLIC" | "PRIVATE")? outline
	  ( rebuild_tag
	  | "RENAME" "TO" new_outline_name
	  | "CHANGE" "CATEGORY" "TO"  new_category_name
	  )+ ;
	
	outline : plsql_identifier;
	new_outline_name : plsql_identifier;
	new_category_name : plsql_identifier;
	
alter_package_statement :
	"ALTER" "PACKAGE" (schema ".")? package 
	compile_clause
	("PACKAGE" | "SPECIFICATION" | "BODY")? 
	(reuse_settings)? ;

alter_resource_statement :
	"ALTER" "RESOURCE" "COST"
	(alter_resource_clause)+ ;
	
alter_resource_clause :	
	resource_name resource_value ;
	
resource_name :
	  "CPU_PER_SESSION"
	| "CONNECT_TIME"
	| "LOGICAL_READS_PER_SESSION"
	| "PRIVATE_SGA" ;

resource_value :
	integer ;	
	
alter_role_statement :
	"ALTER" "ROLE" role 
	role_identity_clause ;
	
role_identity_clause :
	  not_identified_spec 
	| "IDENTIFIED" 
		("BY" password 
		 | using_package_clause 
		 | externally_or_globally) ;

externally_or_globally :
	  "EXTERNALLY" 
	| "GLOBALLY" ("AS" external_name)? ;
		 
not_identified_spec :		 
	"NOT" "IDENTIFIED" ;

using_package_clause :
	"USING" qualified_name ;

alter_rollback_statement :
	"ALTER" "ROLLBACK" "SEGMENT" rollback_segment
	( online_or_offline 
	| storage_clause
	| shrink_clause
	)
	;
	
shrink_clause :	
	"SHRINK" ("TO" integer ( K_or_M )? )?	;

alter_sequence_statement :
	"ALTER" "SEQUENCE" (schema ".")? sequence
	( increment_by_clause 
	| maxvalue_clause 
	| minvalue_clause 
	| cycle_or_nocycle
	| cache_clause
	| order_or_noorder
	)+ 
	;

increment_by_clause :
	"INCREMENT" "BY" integer ;

maxvalue_clause :
	  "MAXVALUE" integer 
	| "NOMAXVALUE" ;
	
minvalue_clause :
	  "MINVALUE" integer 

	| "NOMINVALUE" ;
	
cycle_or_nocycle :
	  "CYCLE" 
	| "NOCYCLE" ;

order_or_noorder :
	  "ORDER" 
	| "NOORDER" ;
	
alter_session_statement :
	"ALTER" "SESSION"
	("ADVISE" ("COMMIT" | "ROLLBACK" | "NOTHING") 
	| "CLOSE" "DATABASE" "LINK" dblink 
	| enable_or_disable "COMMIT" "IN" "PROCEDURE" 
	| ("ENABLE" | "DISABLE" | "FORCE") 
	   "PARALLEL" ("DML" | "DDL" | "QUERY") 
	   ("PARALLEL" integer)?
	| ("ENABLE" "RESUMABLE" ("TIMEOUT" integer)? ("NAME" string)? 
	   | "DISABLE" "RESUMABLE")
	| alter_session_set_clause
	)
	;

alter_session_set_clause :
	"SET" (parameter_name ("=")? parameter_value)+ 
	("COMMENT" "=" string)? ;

alter_snapshot_statement :
	"ALTER" "SNAPSHOT" 
	("LOG" "ON")?
	snapshot_name
	(refresh_clause)?
	("ADD" "PRIMARY" "KEY")?
	(storage_clause)? ;

alter_system_statement :
	"ALTER" "SYSTEM"
	( archive_log_clause 
	| "CHECKPOINT" ( "GLOBAL" | "LOCAL" )?
	| "CHECK" "DATAFILES" ( "GLOBAL" | "LOCAL" )?  
	| enable_or_disable "DISTRIBUTED" "RECOVERY" 
	| enable_or_disable "RESTRICTED" "SESSION" 
	| "FLUSH" "SHARED_POOL" 
	| end_session_clauses 
	| "SWITCH" "LOGFILE"
	| ("SUSPEND" | "RESUME")
	| ("QUIESCE" "RESTRICTED" | "UNQUIESCE")
	| "SHUTDOWN" ("IMMEDIATE")? dispatcher_name
	| "REGISTER"
	| "SET" (alter_system_set_clause (",")? )+
	| "RESET" (alter_system_set_clause (",")? )+
	)
	;
	
end_session_clauses :
	("DISCONNECT" "SESSION" string  ("POST_TRANSACTION")?
	| "KILL" "SESSION" string
	)
	("IMMEDIATE")?;
	
archive_log_clause :
	"ARCHIVE" "LOG" ("THREAD" integer)?
	( ( "SEQUENCE" integer
	  | "CHANGE" integer
	  | "CURRENT" ("NOSWITCH")? 
	  | logfile_group_spec
	  | "LOGFILE" filename ("USING" "BACKUP" "CONTROLFILE")?
	  | "NEXT" 
	  | "ALL"
	  | "START"

	  )
	  ("TO" location)?
	| "STOP"
	);

	dispatcher_name : identifier;

alter_system_set_clause :
	parameter_name ("=")? (parameter_value )+
	("COMMENT" string)? ("DEFERRED")?
	("SCOPE" "=" ("MEMORY" | "SPFILE" | "BOTH"))? 
	("SID" "=" (string | "*") )?;


alter_table_statement :
	"ALTER" "TABLE" (schema ".")? table
	( alter_table_properties
	| column_clauses
	| constraint_clauses
	| alter_table_partitioning

	| alter_external_table_clauses
	| move_table_clause
	)?
	(( enable_disable_clause 
	 | enable_or_disable ("TABLE" "LOCK" | "ALL" "TRIGGERS")
	 )+ )?
	;

alter_table_properties :
	((
	  ( physical_attributes_clause
	  | logging_clause
	  | data_segment_compression
	  | supplemental_lg_grp_clauses
	  | allocate_extent_clause
	  | deallocate_unused_clause
	  | cache_clause
	  | monitoring_spec
	  | upgrade_table_clause
	  | records_per_block_clause
	  | parallel_clause
	  | row_movement_clause
	  )+
	| "RENAME" "TO" new_table_name
	)? 
	(alter_iot_clauses)?) <1,> ;
	
column_clauses :
	(   add_column_clause
	  | modify_column_clause
	  | drop_column_clause
	)+
	| rename_column_clause
	| (modify_collection_retrieval)+
	| modify_LOB_storage_clause
	| alter_varray_col_properties 
	;

add_column_clause :
	"ADD" 
	(
		"(" (  column datatype (default_tag expression)? 
		      ((inline_constraint)+ )?
		      (inline_ref_constraint)? 
			 "," )+  
		")"
	|
		column datatype (default_tag expression)? 
	      ((inline_constraint)+)?
	      (inline_ref_constraint)? 	
	)
	(column_properties)? ;
	
modify_column_clause :	
	"MODIFY" 
	( modify_col_properties 
	| substitutable_clause );
	
modify_col_properties :	
	"(" 
		(column (datatype)? (default_tag expression)? 
			((inline_constraint )+ )? )+
	")"
	( modify_LOB_storage_clause )? ;

substitutable_clause :
	(not_tag)? "SUBSTITUTABLE" 
	"AT" "ALL" "LEVELS" (force_tag)? ;

drop_column_clause :
	 "SET" "UNUSED" ("COLUMN" column | column_list)
	  ((cascade_constraints_tag | "INVALIDATE")+ )?
	| "DROP" ("COLUMN" column | column_list)
	  ((cascade_constraints_tag | "INVALIDATE")+ )?
	  ("CHECKPOINT" integer)?
	| "DROP" ("UNUSED" "COLUMNS" | "COLUMNS" "CONTINUE")
	  ("CHECKPOINT" integer)?
	;
	
rename_column_clause :
	"RENAME" "COLUMN" old_name "TO" new_name ;

modify_collection_retrieval :
	"MODIFY" "NESTED" "TABLE" collection_item 
	"RETURN" "AS" ("LOCATOR" | "VALUE");
	
constraint_clauses :
	 "ADD" 
	 ( (out_of_line_constraint)+
	   | out_of_line_REF_constraint
	   | "(" (out_of_line_constraint)+ ")"
	   | "(" out_of_line_REF_constraint ")"
	 )
	| "MODIFY" "CONSTRAINT" constraint constraint_state
	| "RENAME" "CONSTRAINT" old_name "TO" new_name
	| drop_constraint_clause
	;

drop_constraint_clause :
	"DROP"
	( (primary_key_spec | unique_columns_spec)
	  (cascade_tag)? (keep_or_drop_index)?
	| "CONSTRAINT" constraint (cascade_tag)?
	);
	
alter_table_partitioning :
	  modify_table_default_attrs
	| set_subpartition_template
	| modify_table_partition
	| modify_table_subpartition
	| move_table_partition
	| move_table_subpartition
	| add_table_partition
	| coalesce_table_partition
	| drop_table_partition
	| drop_table_subpartition
	| rename_partition_subpart
	| truncate_partition_subpart
	| split_table_partition
	| split_table_subpartition
	| merge_table_partitions
	| merge_table_subpartitions
	| exchange_partition_subpart
	;

modify_table_default_attrs :
	"MODIFY" "DEFAULT" "ATTRIBUTES" 
	("FOR" "PARTITION" partition)? 
	(segment_attributes_clause)? 
	(data_segment_compression)?
	(pctthreshold_clause)?
	(key_compression)? 
	(alter_overflow_clause)? 
	((("LOB" "(" LOB_item ")" | "VARRAY" varray) 
		"(" LOB_parameters ")")+ )?;

alter_overflow_clause :
	"OVERFLOW"
	(  allocate_extent_clause 
	 | deallocate_unused_clause)+
	| add_overflow_clause ;
	
add_overflow_clause :
	"ADD" "OVERFLOW" (segment_attributes_clause)?
	("(" ("PARTITION" (segment_attributes_clause)? )+ ")" )? ;
	
set_subpartition_template :
	"SET" "SUBPARTITION" "TEMPLATE"
	(
		"(" ( "SUBPARTITION" subpartition 
			(list_values_clause)? 
			(partitioning_storage_clause)?
			
		    )+
		")"
	| hash_subpartition_quantity
	);

modify_table_partition :
	  modify_range_partition 
	| modify_hash_partition 
	| modify_list_partition 
	;

modify_range_partition :

	"MODIFY" "PARTITION" partition
	  ( partition_attributes
	  | add_hash_subpartition 
	  | add_list_subpartition
	  | "COALESCE" "SUBPARTITION" 
	    (update_global_index_clause)?
	    (parallel_clause)?
	  | alter_mapping_table_clause
	  | unusable_local_indexes_clause
	  );
	  
partition_attributes :
	((( physical_attributes_clause
	 | logging_clause
	 | allocate_extent_clause 
	 | deallocate_unused_clause
	 )+ )? 
	("OVERFLOW"
	 ( physical_attributes_clause
	 | logging_clause
	 | allocate_extent_clause
	 | deallocate_unused_clause 
	 )+ )? 
	( data_segment_compression )?
	(( ("LOB" LOB_item | "VARRAY" varray) 
		modify_LOB_parameters )+ )? ) <1,> ;
	  
add_hash_subpartition :
	"ADD" subpartition_spec
	(update_global_index_clause)? 
	(parallel_clause)?;

add_list_subpartition :
	"ADD" subpartition_spec ;


update_global_index_clause :
	("UPDATE" | "INVALIDATE") "GLOBAL" "INDEXES" ;

alter_mapping_table_clause :
	"MAPPING" "TABLE"
	( update_block_references_tag
	| allocate_extent_clause
	| deallocate_unused_clause
	);

modify_hash_partition :	  
	"MODIFY" "PARTITION" partition
	  ( partition_attributes
	  | alter_mapping_table_clause
	  | unusable_local_indexes_clause
	  );

modify_list_partition :
	"MODIFY" "PARTITION" partition
	  ( partition_attributes
	  | ("ADD" | "DROP") "VALUES" "(" (partition_value)+ ")"
	  | unusable_local_indexes_clause
	  );

modify_table_subpartition :
	"MODIFY" "SUBPARTITION" subpartition 
	( modify_hash_subpartition 
	| modify_list_subpartition );
	
modify_hash_subpartition :
	( ( (allocate_extent_clause | deallocate_unused_clause)
	  | (("LOB" LOB_item | "VARRAY" varray) modify_LOB_parameters)+
	  )
	| unusable_local_indexes_clause
	);
	
modify_list_subpartition :
	(allocate_extent_clause | deallocate_unused_clause)
	| (("LOB" LOB_item | "VARRAY" varray) modify_LOB_parameters)+
	| unusable_local_indexes_clause
	| ("ADD" | "DROP") "VALUES" (value)+
	;	
	
move_table_partition :
	"MOVE" "PARTITION" partition 
	("MAPPING" "TABLE")? 
	(table_partition_description)? 
	(update_global_index_clause)? 
	(parallel_clause)? ;
	
move_table_subpartition :
	"MOVE" "SUBPARTITION" subpartition 
//	subpartition_attributes
	(update_global_index_clause)? 
	(parallel_clause)?;

partition_spec :
	"PARTITION" partition 
	(tablespace_spec)?
	(( LOB_storage_clause 
	 | "(" minextents_spec ")" )+ )? ;

add_table_partition :
	  add_range_partition_clause
	| add_hash_partition_clause
	| add_list_partition_clause
	;

add_range_partition_clause :
	"ADD" "PARTITION" (partition)? 
	range_values_clause 
	(table_partition_description)?;

add_hash_partition_clause :
	"ADD" "PARTITION" (partition)? 
	partitioning_storage_clause
	(update_global_index_clause)? 
	(parallel_clause)? ;

add_list_partition_clause :
	"ADD" "PARTITION" (partition)? 
	list_values_clause 
	(table_partition_description)? ;

coalesce_table_partition :
	"COALESCE" "PARTITION" 
	(update_global_index_clause)? 
	(parallel_clause)? ;

drop_table_partition :
	"DROP" "PARTITION" partition 
	(update_global_index_clause 
	(parallel_clause)? )? ;

drop_table_subpartition :
	"DROP" "SUBPARTITION" subpartition 
	(update_global_index_clause 
	(parallel_clause)? )? ;

rename_partition_subpart :
	"RENAME" ("PARTITION" | "SUBPARTITION")
	current_name "TO" new_name ;

	current_name : identifier;
	current_partition : identifier;
	partition_1 : identifier;
	partition_2 : identifier;
	subpart_1 : identifier;
	subpart_2 : identifier;

truncate_partition_subpart :
	"TRUNCATE" ("PARTITION" partition 
		| "SUBPARTITION" subpartition)
	(reuse_or_drop_storage)? 
	(update_global_index_clause (parallel_clause)? )? ;

split_table_partition :
	"SPLIT" "PARTITION" current_partition 
	("AT" | "VALUES") "(" (value)+ ")"
	("INTO" "(" partition_spec "," partition_spec ")" )? 
	(update_global_index_clause)? 
	(parallel_clause)? ;

split_table_subpartition :
	"PARTITION" (partition)? 
	(table_partition_description)? ;

merge_table_partitions :
	"MERGE" "PARTITIONS" partition_1 "," partition_2 
	("INTO" partition_spec)? 
	(update_global_index_clause)? 
	(parallel_clause)? ;
	
merge_table_subpartitions :
	"MERGE" "SUBPARTITIONS" subpart_1 "," subpart_2
	("INTO" subpartition_spec)?
	(update_global_index_clause)?
	(parallel_clause)? ;

exchange_partition_subpart :
	"EXCHANGE" ("PARTITION" partition | "SUBPARTITION" subpartition)
	"WITH" "TABLE" table (("INCLUDING" | "EXCLUDING") "INDEXES")?
	(("WITH" | "WITHOUT") "VALIDATION")?
	(exceptions_clause)? 
	(update_global_index_clause 
		(parallel_clause)?)?;
	  
exceptions_clause :	  
	"EXCEPTIONS" "INTO" (schema ".")? table ;

alter_external_table_clauses :
	( add_column_clause
	| modify_column_clause
	| drop_column_clause
	| parallel_clause
	| external_data_properties 
	| "REJECT" "LIMIT" (integer | "UNLIMITED")
	)+;

move_table_clause :
	"MOVE" (online_tag)? 
	(segment_attributes_clause)? 
	(data_segment_compression)?
	(index_org_table_clause)?
	((LOB_storage_clause | varray_col_properties)+)?
	(parallel_clause)? ;

supplemental_lg_grp_clauses :
	  "ADD" "SUPPLEMENTAL" "LOG" "GROUP" log_group 
	  column_list ("ALWAYS")? 
	| "DROP" "SUPPLEMENTAL" "LOG" "GROUP" log_group
	;

upgrade_table_clause :
	"UPGRADE" ((not_tag)? "INCLUDING" "DATA")? 
	(column_properties)?;
	
records_per_block_clause :
	("MINIMIZE" | "NOMINIMIZE") "RECORDS_PER_BLOCK" ;

new_table_name : identifier;

alter_iot_clauses :
	  index_org_table_clause 
	| alter_overflow_clause 
	| alter_mapping_table_clauses 
	| coalesce_tag ;

modify_LOB_storage_clause :
	"MODIFY" "LOB" "(" LOB_item ")" 
	"(" modify_LOB_parameters ")" ;

modify_LOB_parameters :
	( storage_clause
	| pctversion_clause
	| retention_tag
	| freepools_clause
	| "REBUILD" "FREEPOOLS"
	| cache_clause
	| ( allocate_extent_clause | deallocate_unused_clause ) 
	)+;

alter_varray_col_properties :
	"MODIFY" "VARRAY" varray_item 
	"(" modify_LOB_storage_parameters ")" ;

alter_tablespace_statement : 
	"ALTER" tablespace_spec
	( datafile_tempfile_clauses
	| default_storage_clause
	| minimum_extent_clause
	| online_tag
	| offline_clause
	| ("BEGIN" | "END") "BACKUP"
	| read_write_clause
	| permanent_or_temporary
	| coalesce_tag
	| logging_clause
	| force_logging_spec
	| autoextend_clause
	| size_spec
	)+
	;

read_write_clause :
	  "READ" "ONLY" 
	| "READ" "WRITE" ;

offline_clause :
	"OFFLINE" (offline_attribute)? ;
	
offline_attribute :	
	"NORMAL" | "TEMPORARY" | "IMMEDIATE" ;

default_storage_clause :
	"DEFAULT" (data_segment_compression)? 
	storage_clause ;

datafile_tempfile_clauses :
	( "ADD" ("DATAFILE" | "TEMPFILE") 
	      ((datafile_tempfile_spec )+ )?
	| "RENAME" "DATAFILE" (filename ",")+
		"TO" (filename "," )+
	| ("DATAFILE" | "TEMPFILE") online_or_offline
	) ;

alter_trigger_statement :
	"ALTER" "TRIGGER" ( schema "." )?trigger_name
	  ( enable_or_disable
	  | "RENAME" "TO" new_name
	  | compile_clause (reuse_settings)?
	  )+ ;

alter_type_statement :
	"ALTER" "TYPE" ( schema "." )? type
	  ( compile_type_clause
	  | replace_type_clause
	  | ( alter_method_spec
	    | alter_attribute_definition
	    | (not_tag)? (instantiable_tag | final_tag)
	    )
	    ( dependent_handling_clause )?
	  ) ;
	  
compile_type_clause :
	compile_clause 
	("SPECIFICATION "| "BODY")? 
	(reuse_settings)? ;
	
replace_type_clause :
	"REPLACE" (invoker_rights_clause)? "AS" "OBJECT"
	"(" (attribute datatype)+
	  ("," (element_spec )+  )? ")" ;
	
alter_method_spec :
	("ADD" | "DROP")
	(map_order_function_spec | subprogram_clauses )+;


alter_attribute_definition :
	  ("ADD" | "MODIFY") "ATTRIBUTE"
	  (attribute (datatype)? | "(" (attribute datatype)+ ")" )
	| "DROP" "ATTRIBUTE" (attribute | "(" (attribute)+ ")" ) ;

dependent_handling_clause :
	  "INVALIDATE"
	| "CASCADE" ( ((not_tag)? "INCLUDING" "TABLE" "DATA"
	            | "CONVERT" "TO" "SUBSTITUTABLE"
	            ))? ((force_tag)? exceptions_clause)?
	;

alter_user_statement :
	"ALTER" "USER" (user_name)+
	(create_user_option)* ;
	
proxy_clause :
	("GRANT" | "REVOKE") "CONNECT" "THROUGH" proxy 
	("WITH" 
	  (ROLE ( (role)+ | "ALL" "EXCEPT" (role)+ )
	 | "NO" "ROLES" )
	)?
	("AUTHENTICATED" "USING"
	 ( "PASSWORD"
	 | "DISTINGUISHED" "NAME"
	 | "CERTIFICATE" ("TYPE" string)? ("VERSION" string)?
	 )
	)?;

alter_view_statement :
	"ALTER" "VIEW" ( schema "." )? view
	(  "ADD" out_of_line_constraint
	 | "MODIFY" "CONSTRAINT" constraint ("RELY" | "NORELY")
	 | "DROP" 
	   ( "CONSTRAINT" constraint 
	   | primary_key_spec 
	   | unique_columns_spec )
	 | compile_clause
	) ;

alter_materialized_view_statement :
	"ALTER" "MATERIALIZED" "VIEW"
	(schema ".")? materialized_view
	( physical_attributes_clause 
	  | data_segment_compression
	  | (LOB_storage_clause)+
	  | (modify_LOB_storage_clause)+
	  | alter_table_partitioning
	  | parallel_clause 
	  | logging_clause
	  | allocate_extent_clause
	  | cache_or_nocache
	)? 
	(alter_iot_clauses)?
	("USING" "INDEX" physical_attributes_clause)?
	(   "MODIFY" scoped_table_ref_constraint 
	  | rebuild_tag
	  | mv_refresh 
	)?
	( ("ENABLE" | "DISABLE") "QUERY" "REWRITE"
	  | "COMPILE"
	  | "CONSIDER" "FRESH"
	)? ;

alter_materialized_view_log :
	"ALTER" "MATERIALIZED" "VIEW" "LOG" "ON" 
	(schema ".")? table
	(   physical_attributes_clause
	  | alter_table_partitioning
	  | parallel_clause
	  | logging_clause
	  | allocate_extent_clause
	  | cache_or_nocache
	)?
	("ADD"
	      ( ("OBJECT" "ID" | primary_key_spec | "ROWID")
	        (column_list)?
	      | column_list
	      )+
	      ( new_values_clause )?
	)?;
	
analyze_statement :
	"ANALYZE"
	(   "TABLE" ( schema "." )? table
	      ( "PARTITION" "(" partition ")" 
	      | "SUBPARTITION" "(" subpartition ")" )?
	  | "INDEX" ( schema "." )? index
	      ( "PARTITION" "(" partition ")" 
	      | "SUBPARTITION" "(" subpartition ")" )?
	  | "CLUSTER" ( schema "." )? cluster
	)
	(   compute_statistics_clause
	  | estimate_statistics_clause
	  | validation_clauses
	  | list_chained_rows_clause 
	  | delete_statistics_clause 
	)+ ;

compute_statistics_clause :
	"COMPUTE" ( "SYSTEM" )? 
	"STATISTICS" (for_clause)? ;

estimate_statistics_clause :
	"ESTIMATE" ( "SYSTEM" )? 
	"STATISTICS" (for_clause)?
	("SAMPLE" integer ("ROWS" | "PERCENT"))? ;

delete_statistics_clause :
	"DELETE" ( "SYSTEM" )? "STATISTICS" ;

list_chained_rows_clause :
	"LIST" "CHAINED" "ROWS" (into_clause)? ;

validation_clauses :
	  "VALIDATE" "REF" "UPDATE" 
	  ("SET" "DANGLING" "TO" "NULL")?
	| "VALIDATE" "STRUCTURE" 
	  (cascade_tag)? (into_clause)? 
	  (online_or_offline)?
	;

for_clause :
	("FOR"
	( "TABLE"
	| "ALL" ("INDEXED")? "COLUMNS" (size_spec)?
	| "COLUMNS" (size_spec)? 
	  ((column | attribute) (size_spec)? )+
	| "ALL" ("LOCAL")? "INDEXES"
	))+ ;

into_clause :
	"INTO" (schema ".")? table ;

audit_statement :
	"AUDIT" (sql_statement_clause | schema_object_clause)
	("BY" ("SESSION" | "ACCESS"))?
	("WHENEVER" (not_tag)? "SUCCESSFUL")?;

sql_statement_clause :
	( (statement_option | "ALL" ",")+
	| (system_privilege | "ALL" "PRIVILEGES" ",")+
	)
	(auditing_by_clause | auditing_on_clause)? ;

auditing_by_clause :
	"BY"
	( (proxy)+ ("ON" "BEHALF" "OF" (user_name)+ | "ANY")?
	| (user_name)+
	) ;

schema_object_clause :
	((object_option)+ | "ALL") 
	auditing_on_clause ;

auditing_on_clause :
	  "ON" 
	  (  (schema ".")? object_name 
	   | "DIRECTORY" directory 
	   | default_tag ) ;

statement_option : 
	(sql_verb)? ("ANY" | "PUBLIC")? sql_item ;
	
system_privilege  : 
	  sql_verb ("ANY" | "PUBLIC")? sql_item
	| ("GLOBAL")? "QUERY" "REWRITE"
	| "ON" "COMMIT" "REFRESH"
	| "RESTRICTED" "SESSION"
	| "UNLIMITED" "TABLESPACE"
	| "ANALYZE" "ANY"
	| "AUDIT" "ANY"
	| "COMMENT" "ANY" "TABLE"
	| "EXEMPT" "ACCESS" "POLICY"
	| "FORCE" ("ANY")? "TRANSACTION"
	| "RESUMABLE"
	| "SYSDBA"
	| "SYSOPER" 
	;

sql_verb : 
	  "BACKUP" | "CREATE" | "ALTER" | "DROP" | "AUDIT" | "DEBUG" | "EXECUTE" 
	| "GRANT" | "SELECT" | "DELETE" | "INSERT" | "LOCK" | "FLASHBACK"
	| "UPDATE" | "MANAGE" | "ADMINISTER" | "BECOME" | "UNDER" | "READ" ;

sql_item : 
	  "CLUSTER" | "CONTEXT" | "DATABASE" "LINK" | "SYSTEM" 
	| "CONNECT" "SESSION" | "DIMENSION" | "DIRECTORY"
	| "INDEXTYPE" | "INDEX" | "LIBRARY" | "MATERIALIZED" "VIEW"
	| "OPERATOR" | "OUTLINE" | "PROCEDURE" | "PROFILE" | "ROLE"
	| "ROLLBACK" "SEGMENT" | "SEQUENCE" | "SESSION"
	| "RESOURCE" "COST" | "SYNONYM" | "TABLE" | "TABLESPACE"
	| ("DATABASE")? "TRIGGER" | "TYPE" | "USER" | "VIEW"
	| ("OBJECT")? "PRIVILEGE" | "DICTIONARY"
	;
	
object_option  : 
	"ALTER" | "AUDIT" | "COMMENT" | "DELETE" | "EXECUTE"
	| "GRANT" | "INDEX" | "INSERT" | "LOCK" | "READ" | "RENAME"
	| "SELECT" | "UPDATE"
	;

comment_statement :
	"COMMENT" "ON" 
	( "TABLE" qualified_name
	| "COLUMN" qualified_name
	| "OPERATOR" qualified_name
	| "INDEXTYPE" qualified_name
	)
	"IS" string;

expression : 	
	(
	  not_tag expression
	| exists_condition
	| under_path_condition
 	| "(" expression ")" 
 	| "(" expression_list ")"
 	| interval_expression
	| (("+" | "-" | "PRIOR")+ )?
 	( 
		  simple_expression
		| case_expression
		| cursor_expression
		| object_access_expression
		| scalar_subquery_expression
		| type_constructor_expression
		| variable_expression
	)
	)
	(  
	   interval_specifier
	 | datetime_specifier
	 | null_condition 
	 | like_condition 
	 | membership_condition
	 | range_condition
	 | is_of_type_condition 
	 | equals_path 
	)?
	(operator expression)?
	;
	
datetime_specifier :
	"AT"
	( "LOCAL"
	  | "TIME" "ZONE" 
	  	(   string
	  	  | "DBTIMEZONE"
        	  | "SESSIONTIMEZONE"
	        | expression
            )
	) ;

interval_expression :
	"INTERVAL" squotedstring "DAY" ;

interval_specifier :
	  "DAY" "TO" "SECOND" 
	| "YEAR" "TO" "MONTH" ;
	
exists_condition :
	"EXISTS" "(" subquery ")" ;

under_path_condition : 
	"UNDER_PATH" 
	"(" column ("," levels)? "," 
		path_string ("," correlation_integer)? ")" ;

null_condition :
	"IS" (not_tag)? null_tag ;

like_condition :
	(not_tag)? ("LIKE" | "LIKEC" | "LIKE2" | "LIKE4") 
	expression ("ESCAPE" expression)? ;

membership_condition :
	(not_tag)? "IN" "(" (expression_list | subquery) ")" ;
	
range_condition :
	(not_tag)? "BETWEEN" 
	simple_expression "AND" simple_expression ;

is_of_type_condition : 
	"IS" (not_tag)? "OF" ("TYPE")? 
	"(" (("ONLY")? (schema ".")? type ")" )+ ;

equals_path :
	"EQUALS_PATH" 
	"(" column "," path_string ("," correlation_integer)? ")" ;
	
operator :
	  "*"  | "/" | "+" | "-"  | "AND" | "OR"
	| "<"  | ">" | "=" | "<=" | ">="  | "!=" 
	| "^=" | "<>" | "||" | "**"
	| "=>"
	| ":="
	;

simple_expression :
	  "ROWNUM"
	| null_tag
	| "USER"
	| function ("." simple_expression)?
	| ("DISTINCT")?
	  qualified_name (  "(" ((expression )+ )? ")" 
				| "(" "+" ")"
				| "." ("CURRVAL" | "NEXTVAL") 
				| "%" ("FOUND" | "NOTFOUND")
				)?
				("." simple_expression
				| "@" simple_expression)?
	| number
	| hex_number
	| squotedstring
	| quotedstring
	;

case_expression :
	"CASE" 
	( simple_case_expression 
	| searched_case_expression )
	(else_clause)? "END" ;
	
simple_case_expression :
	expression 
	("WHEN" comparison_expr "THEN" return_expr)+ ; 
	
searched_case_expression :
	("WHEN" condition "THEN" return_expr)+ ;

else_clause :
	"ELSE" else_expr ;
	
cursor_expression :
	"CURSOR" "(" subquery ")" ;
	
function :
	  single_row_function
	| aggregate_function
	| object_reference_function
	| value_function
	| analytic_function
	| xml_function
	;
	
single_row_function :
	  character_function
	| conversion_function
	| treat_function
	| miscellaneous_single_row_function
	;

aggregate_function :
	(
	aggregate_function_name
	"(" ("*" | ( (distinct_or_all)? expression )+ )? ")" 
	( "OVER" "(" 
		( analytic_clause 
		| (query_partition_clause)? order_by_clause) ")"
	| "WITHIN" "GROUP"
		"(" "ORDER" "BY" 
		  (expression (ascending_or_descending)? ("NULLS" ("FIRST" | "LAST"))? )+
		 ")"
		("OVER" "(" query_partition_clause ")" )?
	)?
	)
	(
		"KEEP" 
		"(" "DENSE_RANK" ("FIRST" | "LAST") "ORDER" "BY"
		(expression (ascending_or_descending)? 
			("NULLS" ("FIRST" | "LAST"))? )+
		")"
		("OVER" "(" query_partition_clause ")" )?
	)?;

aggregate_function_name :
	  "AVG" 
	| "COUNT" 
	| "CORR"
	| "COVAR_POP"
	| "COVAR_SAMP"
	| "CUME_DIST"
	| "DENSE_RANK"
	| "GROUP_ID"
	| "GROUPING"
	| "GROUPING_ID"
	| "MAX"
	| "MIN"
	| "PERCENTILE_CONT"
	| "PERCENTILE_DISC"
	| "PERCENT_RANK"
	| "RANK"
	| "REGR_SLOPE"
	| "REGR_INTERCEPT"
	| "REGR_COUNT" 
	| "REGR_R2" 
	| "REGR_AVGX" 
	| "REGR_AVGY" 
	| "REGR_SXX" 
	| "REGR_SYY" 
	| "REGR_SXY"
	| "STDDEV"
	| "STDDEV_POP"
	| "STDDEV_SAMP"
	| "SUM"
	| "VAR_POP"
	| "VAR_SAMP"
	| "VARIANCE"
	; 

character_function :
	  trim_function 
	| character_function_name "(" ((expression)+ )? ")" ;
	
character_function_name :
	  "CHR"
	| "CONCAT"
	| "INITCAP"
	| "LOWER"
	| "LPAD" 
	| "LTRIM" 
	| "NLS_INITCAP"
	| "NLS_LOWER" 
	| "NLSSORT" 
	| "NLS_UPPER" 
	| "REPLACE" 
	| "RPAD" 
	| "RTRIM" 
	| "SOUNDEX"
	| "SUBSTR" 
	| "TRANSLATE" 
	| "TREAT" 
	| "TRIM" 
	| "UPPER"
 	;

trim_function :
	"TRIM" 
	"(" ("LEADING" | "TRAILING" | "BOTH")?
	    (trim_character)?
	    ("FROM")?
	    trim_source
	")";
	
	trim_character : numeric | string;
	trim_source : numeric | string;
	
conversion_function :
	  cast_function
	| conversion_function_name
		"(" ((expression ("USING" ("CHAR_CS" | "NCHAR_CS" ) )? )+ )? ")" 
		// NOTE: "using" clause only for TRANSLATE function
	;
	
cast_function :
	"CAST" "("
		( 
		  "(" subquery ")" 
		| "MULTISET" "(" subquery ")"
		| expression 
		) 
		"AS" type_name 
		")" ;
	
conversion_function_name :
	  "ASCIISTR"
	| "BIN_TO_NUM"
	| "CHARTOROWID"
	| "COMPOSE"
	| "CONVERT"
	| "DECOMPOSE"
	| "HEXTORAW"
	| "NUMTODSINTERVAL"
	| "NUMTOYMINTERVAL"
	| "RAWTOHEX"
	| "RAWTONHEX"
	| "ROWIDTOCHAR"
	| "ROWIDTONCHAR"
	| "TO_CHAR"
	| "TO_CLOB"
	| "TO_DATE"
	| "TO_DSINTERVAL"
	| "TO_LOB"
	| "TO_MULTI_BYTE"
	| "TO_NCHAR"
	| "TO_NCLOB"
	| "TO_NUMBER"
	| "TO_SINGLE_BYTE"
	| "TO_YMINTERVAL"
	| "TRANSLATE"
	| "UNISTR"
	;

treat_function :
	"TREAT" "(" expression "AS" ("REF")? 
		(schema ".")? type ")" ;

	
value_function :
	"VALUE" "(" correlation_variable ")" ;
	
miscellaneous_single_row_function :
	  miscellaneous_function_name
	"(" (expression )* ")" 
	;
	
miscellaneous_function_name :
	  "BFILENAME"
	| "COALESCE"
	| "DECODE" 
	| "DEPTH" 
	| "DUMP" 
	| "EMPTY_BLOB" 
	| "EMPTY_CLOB"
	| "EXISTSNODE" 
	| "EXTRACT"
	| "EXTRACTVALUE" 
	| "GREATEST" 
	| "LEAST" 
	| "NLS_CHARSET_DECL_LEN"
	| "NLS_CHARSET_ID" 
	| "NLS_CHARSET_NAME" 
	| "NULLIF" 
	| "NVL" 
	| "NVL2" 
	| "PATH" 
	| "SYS_CONNECT_BY_PATH" 
	| "SYS_CONTEXT" 
	| "SYS_DBURIGEN" 
	| "SYS_EXTRACT_UTC" 
	| "SYS_GUID" 
	| "SYS_TYPEID" 
	| "SYS_XMLAGG"
	| "SYS_XMLGEN" 
	| "UID" 
	| "UPDATEXML" 
	| "USER" 
	| "USERENV" 
	| "VSIZE" 
	;

analytic_function :
	analytic_function_name
	"(" (arguments)? ")" 
	"OVER" "(" analytic_clause ")" ;
	
analytic_function_name : plsql_identifier;

analytic_clause :
	(query_partition_clause)? 
	(order_by_clause (windowing_clause)? )? ;

query_partition_clause :
	"PARTITION" "BY" (value_expr ",")+ ;
	
windowing_clause :
	("ROWS" | "RANGE")
	( "BETWEEN"
	  ( "UNBOUNDED" "PRECEDING"
	  | "CURRENT" "ROW"
	  | value_expr ( "PRECEDING" | "FOLLOWING" )
	
	  ) 
	  "AND"
	  ( "UNBOUNDED" "FOLLOWING"
	  | "CURRENT" "ROW"
	  | value_expr ( "PRECEDING" | "FOLLOWING" )
	  ) 
	| ( "UNBOUNDED" "PRECEDING"
	  | "CURRENT" "ROW"
	  | value_expr "PRECEDING"  
	  )
	) ;

object_access_expression :
	(   table_alias "." column "." 
	  | object_table_alias "." 
	  | "(" expression ")" "." )
	( (attribute ".")+ ("." method "(" ((argument ",")+ )? ")" )?
	| method "(" ((argument ",")+ )? ")"
	);
	
type_constructor_expression :
	("NEW")? (schema".")? 
	type_name "(" (expression)+ ")" ;
	
variable_expression :
	":" host_variable 
	(("INDICATOR")? ":" indicator_variable)? ;

object_reference_function :
	object_reference_function_name 
	"(" ((expression )+ )? ")" ;
	
object_reference_function_name :
	  "DEREF" 
	| "REF" 
	| "VALUE" 
	| "MAKE_REF" 
	| "REFTOHEX" ;

user_defined_function :
	(schema ".")? 
	(   (package ".")? function 
	  | user_defined_operator )
	("@" dblink ".")? 
	("(" (distinct_or_all)? (expression)+ ")" )? ;

datatype :
	  Oracle_built_in_datatypes 
	| ANSI_supported_datatypes 
	| user_defined_types 
	| "XMLTYPE"
	;
	
Oracle_built_in_datatypes :
	  character_datatypes
	| number_datatypes
	| long_and_raw_datatypes
	| datetime_datatypes
	| large_object_datatypes
	| rowid_datatypes
	;

character_datatypes :
	character_datatype_name
  	("(" size ("BYTE" | "CHAR")? ")" )? ;
	
character_datatype_name :
	  "CHAR"
	| "VARCHAR2"
	| "VARCHARC"
	| "NCHAR"
	| "NVARCHAR2"
	;

number_datatypes :
	"NUMBER" 
	("(" precision ("," scale)? ")" )? ;

long_and_raw_datatypes :
	"LONG" ("RAW" ("(" size ")")? )?
	| ("RAW" | "VARRAW" | "VARRAWC") ("(" size ")")?
	;

datetime_datatypes :
	  "DATE"
	| "TIMESTAMP" 
		("(" fractional_seconds_precision ")")? 
		("WITH" ("LOCAL")? "TIME" "ZONE")? 
	| "INTERVAL" "YEAR" 
		("(" year_precision ")")? "TO" "MONTH"
	| "INTERVAL" "DAY" 
		("(" day_precision ")")? "TO" "SECOND" 
		("(" fractional_seconds_precision ")")?
	;
	
large_object_datatypes :
	  "BLOB" 
	| "CLOB" 
	| "NCLOB" 
	| "BFILE"
	;

rowid_datatypes :
	  "ROWID" 

	| "UROWID" ("(" size ")")?
	;

ANSI_supported_datatypes :
	(
	  "CHARACTER" ("VARYING")? 
	| ("CHAR" | "NCHAR") "VARYING"
	| "VARCHAR"
	| "NATIONAL" ("CHARACTER" | "CHAR") ("VARYING")?
	| "NUMERIC" | "DECIMAL" | "DEC"
	| "INTEGER" | "INT" | "SMALLINT"

	| "FLOAT"
	| "DOUBLE" "PRECISION"
	| "REAL")
	("EXTERNAL" ^("NAME" | "VARIABLE"))?
	("(" size ")" )?
	;

user_defined_types : 
	("REF")? qualified_name 
	("%" ("TYPE" | "ROWTYPE"))? 
	("(" size ")")?;

	size 			: numeric ("," numeric)?;
	precision 		: numeric;
	day_precision 	: numeric;
	scale 		: numeric;
	fractional_seconds_precision : numeric;
	year_precision 	: numeric;

inline_constraint :
	("CONSTRAINT" constraint_name)?
	((not_tag)? null_tag
	| "UNIQUE" ^"("
	| "PRIMARY KEY"
	| references_clause
	| "CHECK" "(" condition ")"
	) (constraint_state)? ;

out_of_line_constraint : 
	("CONSTRAINT" constraint_name)?
	( unique_columns_spec
	| "PRIMARY" "KEY" column_list
	| "FOREIGN" "KEY" column_list references_clause
	| "CHECK" "(" condition ")"
	) (constraint_state)? ;

inline_ref_constraint : 
	  "SCOPE" "IS" (schema "." )? scope_table
	| "WITH" "ROWID"
	| ("CONSTRAINT" constraint_name)? 
	  references_clause (constraint_state)?
	;

out_of_line_ref_constraint : 
	  "SCOPE" "FOR" "(" (ref_col | ref_attr) ")" 
	  "IS" ( schema "." )? scope_table
	| "REF" "(" (ref_col | ref_attr) ")" "WITH" "ROWID"
	| ( "CONSTRAINT" constraint_name )? 
	      "FOREIGN" "KEY" "(" (ref_col | ref_attr) ")" 
	      references_clause ( constraint_state )?
	;
	
references_clause :
	"REFERENCES" qualified_name (column_list)? 
	(on_delete_clause)?
	(constraint_state)? ;	
	
on_delete_clause :
	"ON" "DELETE" (cascade_tag | set_null_tag) ;
	
	set_null_tag : "SET" "NULL";
	
constraint_state :
	( 
		((not_tag)? "DEFERRABLE")? 
		("INITIALLY" ("IMMEDIATE" | "DEFERRED"))?
		((not_tag)? "DEFERRABLE")?
	)?
	("RELY" | "NORELY")? 
	(using_index_clause)?
	(enable_or_disable ^"CONSTRAINT")? 
	( "VALIDATE" | "NOVALIDATE" )? 
	(exceptions_clause)? ;
	
drop_cluster :
	"DROP" "CLUSTER" qualified_name 
	("INCLUDING" "TABLES" (cascade_constraints_tag)? )?;

drop_database_link :
	"DROP" ("PUBLIC")? "DATABASE" "LINK" dblink;

drop_directory :
	"DROP" "DIRECTORY" directory_name;

drop_dimension :
	"DROP" "DIMENSION" qualified_name ;

drop_function :	
	"DROP" "FUNCTION" qualified_name;

drop_index :	
	"DROP" "INDEX" qualified_name (force_tag)?;

drop_indextype :
	"DROP" "INDEXTYPE" qualified_name (force_tag)?;

drop_context :
	"DROP" "CONTEXT" namespace;

drop_library :	
	"DROP" "LIBRARY" library_name;

drop_operator : 
	"DROP" "OPERATOR" qualified_name (force_tag)?;

drop_package :
	"DROP" "PACKAGE" ("BODY")? qualified_name ;
	
drop_procedure :
	"DROP" "PROCEDURE" qualified_name ;
	
drop_profile :
	"DROP" "PROFILE" profile_name (cascade_tag)?;

drop_role :
	"DROP" "ROLE" role ;

drop_rollback_segment :
	"DROP" "ROLLBACK" "SEGMENT" rollback_segment;

drop_sequence :
	"DROP" "SEQUENCE" qualified_name;

drop_snapshot :
	"DROP" "SNAPSHOT" ("LOG" "ON")? qualified_name;
	
drop_synonym :
	"DROP" ("PUBLIC")? "SYNONYM" 
	synonym_name (force_tag)?;

drop_table :
	"DROP" "TABLE" qualified_name 
	(cascade_constraints_tag)?;

drop_tablespace :
	"DROP" tablespace_spec
	("INCLUDING" "CONTENTS" ("AND" "DATAFILES")? 
	(cascade_constraints_tag)? )?;

drop_trigger :
	"DROP" "TRIGGER" qualified_name ;

drop_type :
	"DROP" "TYPE" qualified_name 
	("FORCE" | "VALIDATE")?;

drop_type_body :
	"DROP" "TYPE" "BODY" qualified_name;

drop_user :
	"DROP" "USER" user_name 
	(cascade_tag)?;

drop_view :
	"DROP" "VIEW" qualified_name 
	(cascade_constraints_tag)?;
	
drop_materialized_view :
	"DROP" "MATERIALIZED" "VIEW"
	(schema ".")? ^"LOG" materialized_view;

drop_materialized_view_log :
	"DROP" "MATERIALIZED" "VIEW" "LOG" "ON" 
	(schema ".")? table ;

drop_outline :
	"DROP" "OUTLINE" outline ;

raise_statement :
	"RAISE" (exception_name)?;

return_statement :
	"RETURN" ("(" expression ")" | expression )?;

goto_statement :
	"GOTO" label_name;
	
if_statement : 
	"IF" expression "THEN" (statement)*
	("ELSIF" expression "THEN" (statement)* )*
	("ELSE" (statement)* )? 
	("ENDIF" | "END" "IF") ;

	
loop_statement :
	  basic_loop_statement
	| while_loop_statement
	| for_loop_statement
	;

basic_loop_statement :
	(label_name)? 
	"LOOP" (statement)*
	"END" "LOOP" (label_name)?;
 
while_loop_statement :
	(label_name )? 
	"WHILE" expression
	"LOOP" (statement)*
	"END" "LOOP" (label_name)?;

for_loop_statement :
	(label_name)? 
	"FOR" index_name "IN"
	("REVERSE")? lower_bound (".." upper_bound)?
	"LOOP" (statement)*
	"END" "LOOP" (label_name)?;

null_statement :
	"NULL" ;
	
assignment_statement :
	plsql_identifier ":=" expression ;
	
forall_statement :
	"FORALL" index_name 
	"IN" lower_bound ".." upper_bound
	statement;

	index_name : plsql_identifier;
	lower_bound : expression;
	upper_bound : expression;

disassociate_statistics :
	"DISASSOCIATE" "STATISTICS" "FROM"
	(associated_item (qualified_name)+ )+
	(force_tag)? ;
	
associated_item :
	  "COLUMNS"
	| "FUNCTIONS"
	| "PACKAGES"
	| "TYPES"
	| "INDEXES"
	| "INDEXTYPES"
	;
	
force_tag : "FORCE" ;

case_statement :
	( label_name )?
	"CASE" (case_operand)?
	("WHEN" expression "THEN" (statement (";")? )+ )+
	("ELSE" (statement (";")? )+ )?
	"END" "CASE" (label_name)?;

case_operand : expression;

close_statement :
	"CLOSE" (":")? name ;

fetch_statement : 
	"FETCH" (":")? name 
	("INTO" ((variable_name)+ | record_name)
	| "BULK" "COLLECT" "INTO" 
	  (collection_name | ":" host_array_name)+
	  ("LIMIT" expression)? )
	;
	
exit_statement : 
	"EXIT" (label_name)? 
	("WHEN" expression)?;

execute_statement :
	"EXECUTE" statement ;

execute_immediate_statement :
	"EXECUTE" "IMMEDIATE" dynamic_string
	("INTO" ((define_variable)+ | record_name))?
	("USING" (("IN" | "OUT" | "IN" "OUT")? bind_argument)+ )?
	(("RETURNING" | "RETURN") "INTO" (bind_argument)+ )? ;

	dynamic_string : expression ;
	define_variable : plsql_identifier;
	
explain_plan_statement :
	"EXPLAIN" "PLAN" 
	("SET" "STATEMENT_ID" "=" string)?
	("INTO" qualified_name ("@" dblink)? )? 
	"FOR" statement;

open_statement :
	"OPEN" cursor_name 
	("(" (cursor_parameter_name)+ ")" )?;
	
open_for_statement : 
	"OPEN" (":")? name
	"FOR" select_statement;
	
///////////////////////////////////////////////////////////////////////

keywords :
	(
	  "ADD"
	| "ALTER"
	| "AUDIT"
	| "AUTOMATIC"
	| "BEGIN"
	| "BODY"
	| "BY"
	| "CALL"
	| "CASE"
	| "CAST"
	| "CHARACTER"
	| "CHECK"
	| "CLEAR"
	| "CLOB"
	| "COMMENT"
	| "COMMIT"
	| "COMPUTE"
	| "CONNECT"
	| "CONSTANT"
	| "CONSTRAINT"
	| "CREATE"
	| "CUBE"
	| "CURSOR"
	| "DATABASE"
	| "DATAFILE"
	| "DECLARE"
	| "DEFAULT"
	| "DELETE"
	| "DISABLE"
	| "DROP"
	| "ELSE"
	| "ELSIF"
	| "ENABLE"
	| "END"
	| "ENDIF"
	| "ESTIMATE"
	| "EXCEPTION"
	| "FETCH"
	| "FOR"
	| "FORALL"
	| "FROM"
	| "FUNCTION"
	| "GLOBAL_NAME"
	| "GRANT"
	| "GROUP"
	| "IF"
	| "IN"
	| "INDEX"
	| "INITIAL"
	| "INITRANS"
	| "INSERT"
	| "INTO"
	| "KEY"
	| "LINK"
	| "LOB"
	| "LOCAL" 
	| "LOGFILE"
	| "LOOP"
	| "MAXTRANS"
	| "MEMBER"
	| "MERGE"
	| "MODIFY"
	| "NEXT"
	| "NOAUDIT"
	| "NOSORT"
	| "OPEN"
	| "OPERATOR"
	| "ORDER"
	| "OVER"
	| "PACKAGE"
	| "PARTITION"
	| "PCTFREE"
	| "PRAGMA"
	| "PRIMARY"
	| "PROCEDURE"
	| "PROFILE"
	| "REBUILD"
	| "RECOVER"
	| "REF"
	| "RENAME"
	| "RETURN"
	| "RETURNING"
	| "REVOKE"
	| "ROLLBACK"
	| "ROLLUP"
	| "ROLE"
	| "SCOPE"
	| "SELECT"
	| "SEQUENCE"
	| "SESSION"
	| "SET"
	| "SETS"
	| "START"
	| "STORAGE"
	| "SYNONYM"
	| "TABLE"
	| "TABLESPACE"
	| "THE"
	| "THEN"
	| "TRIGGER"
	| "TYPE"
	| "UNIQUE"
	| "UNTIL"
	| "USER"
	| "UPDATE"
	| "VALUE"
	| "VALUES"
	| "WHEN"
	| "WHERE"
	| "WHILE"
	| "WITH"
	// xml keywords
	| "XMLELEMENT"
	| "XMLTYPE" 
	
	)
	| conversion_function_name
	| miscellaneous_function_name
	;

dblink :
	link_database ("." (domain ".")+ )? 
	("@" connect_descriptor)? ; 

	
	link_database : identifier ;
	
expression_list :
	  (expression ",")+
	| "(" (expression "," )+ ")" ;

ascending_or_descending :
	  "ASC" 
	| "DESC"
	;

size_spec :
	"SIZE" integer (K_or_M)? ;

K_or_M : 
	"K" | "M" ;

reuse_tag :
	"REUSE" ;
	
reuse_or_drop_storage :
	("REUSE" | "DROP") "STORAGE" ;
	
reuse_settings :
	"REUSE" "SETTINGS" ;

compile_clause :
	"COMPILE" (debug_tag)? ;
	
debug_tag :	
	"DEBUG" ;
	
unusable_tag :
	"UNUSABLE" ;

coalesce_tag :	
	"COALESCE" ;
	
cascade_tag :
	"CASCADE" ;

cascade_constraints_tag :
	"CASCADE" "CONSTRAINTS" ;
			
enable_or_disable : 
	  "ENABLE" 
	| "DISABLE" ;

validate_or_novalidate :	
	  "VALIDATE" 
	| "NOVALIDATE" ;
	
distinct_or_all :
	  "DISTINCT"
	| "ALL" ;	
	
distinct_all_or_unique :
	  "DISTINCT"
	| "ALL" 
	| "UNIQUE" ;

online_or_offline :
	  "ONLINE"
	| "OFFLINE" ;

online_tag :
	"ONLINE" ;
	
rowdependencies_spec :	
	  "NOROWDEPENDENCIES" 
	| "ROWDEPENDENCIES" ;
	
monitoring_spec :
	  "MONITORING" 
	| "NOMONITORING" ;

archivelog_spec :
	  "ARCHIVELOG" 
	| "NOARCHIVELOG" ;
	
resetlogs_spec :
	  "RESETLOGS" 
	| "NORESETLOGS" ;
	
from_session :
	"FROM" "SESSION" ;

cache_clause :
	("CACHE" (integer | "READS")?
	 | "NOCACHE")
	(logging_clause)? ;

unusable_local_indexes_clause :
	(rebuild_tag)? "UNUSABLE" "LOCAL" "INDEXES" ;

end_backup_tag :
	"END" "BACKUP" ;

qualified_name : 
	plsql_identifier
	("." (identifier ".")+ )?
	("." string)?
	("#")? ;
	
identifier :
	"(a-zA-Z_)?(a-zA-Z0-9#_)?*";

not_tag : "NOT";

null_tag :
	"NULL";

compute_statistics_tag : 
	"COMPUTE" "STATISTICS" ;

update_block_references_tag :
	"UPDATE" "BLOCK" "REFERENCES" ;

rebuild_tag :
	"REBUILD" ;
	
overriding_tag : 
	"OVERRIDING" ;
	
final_tag : 
	"FINAL" ;
	
instantiable_tag : 
	"INSTANTIABLE" ;
	
default_tag	:
	"DEFAULT" ;

number : 
	("+" | "-")?
	(
	  (numeric ".")? numeric
	  | "." numeric 
	  | numeric )
	("E" numeric)? ;
	
hex_number :
	"x" "(0-9A-F)?+";

string : 
	  quotedstring 
	| squotedstring;

squotedstring : 
	"'" ( *("''" | "'") "''" 0 )+ "'" ;

name : 
	identifier | string;

plsql_identifier : 
	"(a-zA-Z_)?(a-zA-Z0-9_$#)?*" (? #VALUE !: keywords";" );

sort_list : (plsql_identifier ",")+;

parameters : (parameter",")+;

parameter : expression ("BY" "REFERENCE")?;

sqlj_object_type_attr : 
	  squotedstring 
	| plsql_identifier;

OraData	: 
	  squotedstring 
	| plsql_identifier;

CustomDatum	: 
	  squotedstring 
	| plsql_identifier;

column : 
	qualified_name ;

function_name
	: qualified_name;

savepoint_name	: plsql_identifier;
directory_object_name : plsql_identifier;
filename		: squotedstring;
field_name		: plsql_identifier;
external_name		: string;
directory_name	: identifier;
segment_name		: identifier;
subtype_name 		: plsql_identifier;
base_type  		: plsql_identifier;
constant_name		: plsql_identifier;
record_name		: plsql_identifier;
record_type_name	: plsql_identifier;
cursor_variable_name: plsql_identifier;
db_table_name		: plsql_identifier;
parameter_name	: identifier;
schema_name		: plsql_identifier;
attribute_name	: plsql_identifier;
scalar_datatype_name: plsql_identifier;
object_type_name	: plsql_identifier;
object_name		: identifier | string;
collection_name	: plsql_identifier;
procedure_name	: identifier;
profile_name		: identifier;
snapshot_name		: identifier;
old_name		: identifier;
cursor_name : expression;
variable_name			: qualified_name;
host_variable_name 	: plsql_identifier;
host_array_name	: plsql_identifier;
exception_name			: qualified_name;
method_name		: squotedstring | plsql_identifier;
lib_name		: squotedstring | plsql_identifier;
constraint_name	: plsql_identifier;
library_name		: identifier;
user_name		: plsql_identifier;
trigger_name		: plsql_identifier;
label_name		: identifier;
query_name  		: plsql_identifier;
type_name		: plsql_identifier;
procedure		: plsql_identifier;
implementation_type 		: qualified_name;
role			: identifier | string ;
password		: identifier | string ;
old_password 		: identifier | string ;
rollback_segment	: identifier;
sequence		: identifier;
collection_item	: identifier;
varray 			: identifier;
proxy 			: identifier | string;
scope_table		: plsql_identifier;
ref_col			: plsql_identifier;
ref_attr		: plsql_identifier;
savepoint		: name;
schema			: plsql_identifier;
table			: plsql_identifier;
view			: plsql_identifier;
materialized_view	: plsql_identifier;
c_alias			: quotedstring | plsql_identifier;
t_alias			: plsql_identifier;
partition		: plsql_identifier;
subpartition		: plsql_identifier;
constraint				: qualified_name ("@" dblink)?;
type			: plsql_identifier;
host_variable 			: qualified_name;
indicator_variable 	: plsql_identifier;
domain 			: plsql_identifier;
connect_descriptor 	: plsql_identifier;
table_alias 		: plsql_identifier;
object_table_alias 	: plsql_identifier;
method 			: plsql_identifier;
database		: plsql_identifier | string;
tablespace 		: plsql_identifier;
LOB_segname 		: plsql_identifier;
correlation_variable: plsql_identifier;
alias 			: plsql_identifier;
object_type 		: plsql_identifier;
index			: plsql_identifier;
cluster 		: identifier;
storage_table 	: plsql_identifier;
varray_item 		: plsql_identifier;
LOB_item 		: plsql_identifier;
log_group 		: plsql_identifier;
access_driver_type 	: plsql_identifier;
directory 		: plsql_identifier;
nested_item 		: plsql_identifier;
package 		: plsql_identifier;
indextype 		: plsql_identifier;
supertype 		: plsql_identifier;
cursor_parameter_name 	: plsql_identifier;	

attribute  			: expression;
value 			: expression;
value_expr 			: expression;
single_row_expression 	: expression;
multiple_row_expression : expression;
condition_spec 		: expression;
column_expression 	: expression;
parameter_value 		: expression;
partition_value 		: expression;
comparison_expr 		: expression;
return_expr 		: expression;
else_expr 			: expression;
collection_expression 	: expression;

scalar_subquery_expression : subquery;

plsql_subprogram_body 	: plsql_block;
plsql_function_body 	: plsql_block;
subprogram_body 		: plsql_block;
function_body 		: plsql_block;

alter_mapping_table_clauses 	: "TODO:";
modify_LOB_storage_parameters : "TODO:";
mapping_table_clauses 		: "TODO: mapping_table_clauses";
segment_attribute_clause 	: "TODO: segment_attribute_clause"; 
user_defined_operator 		: "TODO: user_defined_operator";
sys_refcursor_instance 		: "TODO: sys_refcursor_instance";

fmt 				: squotedstring;
search_condition 		: condition;
attribute_type 		: datatype;
path_string 		: string ;
element 			: string;
size_limit 			: numeric;
numeric_literal 		: numeric;

integer		: numeric;
correlation_integer 	: numeric;
sample_percent 		: numeric;
position 			: numeric;
levels 			: numeric;
min_value 			: numeric;
max_value 			: numeric;
num_buckets 		: numeric;
quantity 			: numeric;
limit 			: numeric;
hash_partition_quantity : numeric;
hash_subpartition_quantity : numeric;

///////////////////////////////////////////////////////////////////

space_symbol  : 
		( ("\32" | "\r" |"\n"|"\t") | "--" *("\n")
   		  |  "/*" *("*/") "*/" 0 )+
   		  ;
   		  
   		  
   		  
sqlj_object_type :
	"EXTERNAL" "NAME" java_ext_name 
	"LANGUAGE" "JAVA" "USING" 
	(SQLData | CustomDatum | OraData)
	;

sqlj_object_type_sig :
	"EXTERNAL" ("VARIABLE" "NAME" java_static_field_name
         	| "NAME" java_method_sig ) ;


	java_static_field_name : squotedstring ;
	java_method_sig 	     : squotedstring ;


java_ext_name		: squotedstring | plsql_identifier;



///////////////////////////
// xml

xml_function :
	  XMLAgg
	| XMLColAttVal
	| XMLConcat
	| XMLElement
	| XMLForest
	| XMLSequence
	| XMLTransform
	| "XMLTYPE" ("." identifier)? 
	  "(" ((expression ",")+ )? ")"
	;

XMLType_table :
	"CREATE" "TABLE" 
	(schema ".")? table 
	"OF" "XMLTYPE"
	(XMLType_storage)? 
	(XMLSchema_spec)?;

XMLType_column_properties :
	"XMLTYPE" ("COLUMN")? column 
	(XMLType_storage)? (XMLSchema_spec)?;
	
XMLType_storage :
	  "STORE" "AS" 
	( "OBJECT" "RELATIONAL"
	| "CLOB" 
	    (LOB_segname ("(" LOB_parameters ")" )? 
	    	| "(" LOB_parameters ")" )? );
	
XMLSchema_spec :
	("XMLSCHEMA" XMLSchema_URL)? 
	"ELEMENT" (element 
		| XMLSchema_URL "#" element) 
	(with_object_id_clause)?
	;

XMLType_view_clause :
	"OF" "XMLTYPE"
	(XMLType_storage)? 
	(XMLSchema_spec)?;

XMLAgg:
	"XMLAGG" "(" XMLType_instance 
		("ORDER" "BY" sort_list)? ")" ;

XMLElement :
	"XMLELEMENT" 
	"(" ("NAME")? expression ("," XML_attributes_clause)? 
		("," (value_expr",")+ )? ")" ;
		

XML_attributes_clause:
	"XMLATTRIBUTES"
	  "(" (value_expr ("AS" c_alias)? ",")+ ")" ;
	  
XMLColAttVal:
	"XMLCOLATTVAL" "(" (value_expr 
		("AS" plsql_identifier)? ",")+ ")" ;


XMLConcat:
	"XMLCONCAT" "(" (XMLType_instance ",")+ ")" ;

XMLForest:
	"XMLFOREST"
	  "(" (value_expr ("AS" c_alias)? ",")+ ")" ;

XMLSequence:
	"XMLSEQUENCE" "(" 
	(XMLType_instance | sys_refcursor_instance ("," fmt)? )
      ")" ;
        
XMLTransform:
	"XMLTRANSFORM" "(" XMLType_instance 
		"," XMLType_instance ")" ;

XMLType_instance : 
	  "XMLTYPE" "(" expression ")"
	| expression ;

XMLSchema_URL : string;


///////////////////////////////////////////////
// java

alter_java_statement :
	"ALTER" "JAVA" source_or_class
	(schema ".")? object_name 
	("RESOLVER"
	  "(" ("(" match_string (",")? (schema_name | "-") ")" )+ ")"
	)?
	(   compile_or_resolve
	  | invoker_rights_clause
	) ;

create_java :
	"CREATE" ("OR" "REPLACE")? 
	("AND" ("RESOLVE" | "COMPILE"))? ("NOFORCE")? "JAVA"
	(("SOURCE" | "RESOURCE") "NAMED" (schema ".")? primary_name 
	| "CLASS" ("SCHEMA" schema)?
	)
	(invoker_rights_clause)? 
	("RESOLVER"
	 "(" ("(" match_string (",")? (schema_name | "-") ")"
	")")+
	)?
	("USING"
	  ("BFILE" "(" directory_object_name "," server_file_name ")"
	  | ("CLOB" | "BLOB" | "BFILE") subquery
	  | key_for_BLOB
	  )
	| "AS" java_source_text
	)
	;

drop_java_statement :
	"DROP" "JAVA" ("SOURCE" | "CLASS" | "RESOURCE")
	(schema ".")? object_name;

source_or_class :
	  "SOURCE" 
	| "CLASS" ;
	
compile_or_resolve :
	  "COMPILE" 
	| "RESOLVE" ;
	
match_string :
	string | "*";	
	
java_source_text : 
	(*("{" | ";") java_code_block)+ *(";");
	
	java_code_block : "{" ((*("{" | "}") (java_code_block)? )+)? "}";
	
key_for_BLOB : string;
primary_name : plsql_identifier | string;
server_file_name : string;

class MyLexer extends Lexer;

DML_table_expression_clause :
	( (schema ".")?
	  ( table 
	    ( ("PARTITION" "(" partition ")" 
	    | "SUBPARTITION" "(" subpartition ")" )
	    | "@" dblink
	    )?
	  | view ("@" dblink)?
	  ) 
	| ("THE")? "(" subquery (subquery_restriction_clause)? ")"
	| table_collection_expression
	) ;



More information about the antlr-interest mailing list