add oracle ddl rules

sharding-jdbc-ddl-parser/src/main/antlr4/imports/OracleBase.g4

+grammar OracleBase;
+
+import OracleKeyword,Keyword,Symbol,BaseRule,DataType;
+
+
+attributeName: ID;
+segName: ID;
+
+objectName:ID;
+elementName: ID;
+archiveName: ID;
+indexTypeName: ID;
+clusterName: ID;
+varrayItemName: ID;
+
+simpleExprsWithParen:
+	LEFT_PAREN simpleExprs RIGHT_PAREN 
+	;
+	
+simpleExprs:
+	simpleExpr ( COMMA simpleExpr)* 
+	;
+
+lobItem:
+	attributeName
+	|columnName
+	;
+	
+lobItems:
+	lobItem (COMMA lobItem)*
+	;
+
+lobItemList:
+	LEFT_PAREN lobItems RIGHT_PAREN
+	;
+
+dataType: 
+	(typeName(LEFT_PAREN NUMBER ( COMMA NUMBER )? RIGHT_PAREN)?) 
+  	|specialDatatype
+  	|datetimeDatatype
+	;
+
+specialDatatype:
+	(typeName (LEFT_PAREN NUMBER ID  RIGHT_PAREN))
+	| (DOUBLE PRECISION)
+	| (NATIONAL typeName (VARYING)? LEFT_PAREN NUMBER RIGHT_PAREN) 
+	|(REF LEFT_PAREN? columnName  RIGHT_PAREN?)
+	;
+
+datetimeDatatype:
+( DATE
+| (TIMESTAMP ( LEFT_PAREN NUMBER RIGHT_PAREN )?
+     ( WITH ( LOCAL )? TIME ZONE )?)
+| (INTERVAL YEAR ( LEFT_PAREN NUMBER RIGHT_PAREN )? TO MONTH)
+| (INTERVAL DAY ( LEFT_PAREN NUMBER RIGHT_PAREN )? TO SECOND
+     ( LEFT_PAREN NUMBER RIGHT_PAREN )?)
+)
+;
+
+columnSortClause:
+	tableAndAlias columnName
+    (ASC | DESC)?
+    ;
+  
+ tableAndAlias:
+	tableName alias?
+	;
+ 
+ privateExprOfDb:
+	treatFunction
+	|caseExpr
+	|compoundExpr
+	|intervalExpression
+	|objectAccessExpression
+	|constructorExpr
+	;
+
+treatFunction:
+	TREAT LEFT_PAREN expr AS REF? typeName RIGHT_PAREN
+	;
+
+caseExpr:
+	CASE ( simpleCaseExpr
+     | searchedCaseExpr
+     )
+     elseClause?
+     END
+	;
+	
+simpleCaseExpr:
+	expr
+	searchedCaseExpr+
+	;
+	
+searchedCaseExpr:
+	WHEN expr THEN simpleExpr
+	;
+	
+elseClause:
+	ELSE expr
+	;
+
+dateTimeExpr:
+	expr AT (
+		LOCAL
+		|(TIME ZONE ( 
+				STRING
+               | DBTIMEZONE
+               | expr
+               ))
+	)
+	;
+	
+compoundExpr:
+	(PRIOR expr)
+	//|(expr OR_SYM expr)
+	;
+
+intervalExpression:
+	LEFT_PAREN expr MINUS expr RIGHT_PAREN 
+   	( (DAY ( LEFT_PAREN NUMBER RIGHT_PAREN )? TO
+     SECOND ( LEFT_PAREN NUMBER RIGHT_PAREN )?)
+   	| (YEAR ( LEFT_PAREN NUMBER RIGHT_PAREN )? TO
+     MONTH)
+   	)
+	;
+
+objectAccessExpression:
+	( 
+		columnName
+		| tableName
+		| (LEFT_PAREN simpleExpr RIGHT_PAREN)
+	)
+	( 
+		(attributeName (attributeName )*functionCall)
+		| functionCall
+	)
+	;
+	
+constructorExpr:
+	NEW typeName exprsWithParen
+   ;
\ No newline at end of file

sharding-jdbc-ddl-parser/src/main/antlr4/imports/OracleIndexBase.g4

+grammar OracleIndexBase;
+
+import OracleKeyword, DataType, Keyword,OracleBase,BaseRule,Symbol;
+
+createIndex:
+	CREATE ( UNIQUE | BITMAP )? INDEX  indexName
+  	ON ( clusterIndexClause
+     | tableIndexClause
+     | bitmapJoinIndexClause
+     )
+	UNUSABLE? 
+	;
+clusterIndexClause:
+	CLUSTER  clusterName 
+	;
+tableIndexClause:
+ tableName alias?
+ LEFT_PAREN indexExprSort
+  (COMMA indexExprSort)* RIGHT_PAREN 
+  indexProperties?
+;
+
+indexExprSort:
+	indexExpr ( ASC | DESC )?
+	;
+	
+indexExpr:
+	columnName 
+	| expr 
+	;
+	
+indexProperties:
+	(globalPartitionedIndex
+    | localPartitionedIndex
+  	| indexAttribute)+
+	| (INDEXTYPE IS  domainIndexClause)
+	;
+	
+globalPartitionedIndex:
+	GLOBAL PARTITION BY
+	   ( (RANGE columnList 
+	        LEFT_PAREN indexPartitioningClause (COMMA indexPartitioningClause)* RIGHT_PAREN)
+	   | (HASH columnList 
+	        ( individualHashPartitions
+	        | hashPartitionsByQuantity
+	        ))
+	   )
+	;
+	
+indexPartitioningClause:
+	PARTITION partitionName?
+	   VALUES LESS THAN simpleExprsWithParen 
+	   segmentAttributesClause?
+	;
+
+individualHashPartitions:
+	LEFT_PAREN partitioningStorageClause
+	  (COMMA partitioningStorageClause)* RIGHT_PAREN 
+	;
+	
+partitioningStorageClause:
+ 	PARTITION partitionName? partitioningStorage?
+	;
+	
+partitioningStorage:
+	(TABLESPACE tablespaceName)
+  	| (OVERFLOW (TABLESPACE tablespaceName)?)
+  	| tableCompression
+  	| keyCompression
+  	| lobPartitioningStorage
+  	| (VARRAY varrayItemName STORE AS (SECUREFILE | BASICFILE)? LOB segName)
+  	;
+ 
+tableCompression:
+ 	(COMPRESS(BASIC 
+           | FOR ( OLTP
+                 |((QUERY | ARCHIVE) ( LOW | HIGH )?) 
+                 )
+           )?)
+	| NOCOMPRESS 
+	;
+
+hashPartitionsByQuantity:
+	PARTITIONS NUMBER
+	( STORE IN LEFT_PAREN tablespaceName ( COMMA tablespaceName )* RIGHT_PAREN )?
+	( tableCompression | keyCompression )?
+	( OVERFLOW STORE IN LEFT_PAREN tablespaceName ( COMMA tablespaceName )* RIGHT_PAREN )?
+	;
+
+keyCompression:
+	(COMPRESS NUMBER?)
+	| NOCOMPRESS
+	;
+
+lobPartitioningStorage:
+	LOB LEFT_PAREN lobItems RIGHT_PAREN STORE AS (BASICFILE | SECUREFILE)?
+  	((segName tablespaceClauseWithParen?)
+  	| tablespaceClauseWithParen
+  	)?
+	;
+
+segmentAttributesClause:
+	 (physicalAttributesClause
+	| (TABLESPACE tablespaceName)
+	| loggingClause)+
+	;
+tablespaceClauseWithParen:
+	LEFT_PAREN tablespaceClause RIGHT_PAREN
+	;
+		
+tablespaceClause:
+	TABLESPACE tablespaceName
+	;
+	
+physicalAttributesClause:
+	storageClause
+	|((PCTFREE 
+	  | PCTUSED 
+	  | INITRANS) NUMBER)
+	;
+
+loggingClause:
+	LOGGING 
+	| NOLOGGING 
+	| FILESYSTEM_LIKE_LOGGING
+	;
+
+storageClause:
+	STORAGE LEFT_PAREN storageOption(COMMA storageOption)* RIGHT_PAREN
+	;
+
+storageOption:
+	(INITIAL sizeClause)
+ | (NEXT sizeClause)
+ | (MINEXTENTS NUMBER)
+ | (MAXEXTENTS ( NUMBER | UNLIMITED ))
+ | maxsizeClause
+ | (PCTINCREASE NUMBER)
+ | (FREELISTS NUMBER)
+ | (FREELIST GROUPS NUMBER)
+ | (OPTIMAL (sizeClause | NULL )?)
+ | (BUFFER_POOL ( KEEP | RECYCLE | DEFAULT ))
+ | (FLASH_CACHE ( KEEP | NONE | DEFAULT ))
+ | ENCRYPT
+ ;
+ 
+sizeClause:
+	NUMBER ID?
+	;
+	
+maxsizeClause:
+	MAXSIZE ( UNLIMITED | sizeClause )
+	;
+
+localPartitionedIndex:
+	LOCAL
+	(storeInClause
+	| onCompPartitionedTable
+	| onPartitionedTable
+	)?
+	;
+	
+storeInClause:
+	STORE IN LEFT_PAREN tablespaceName( COMMA tablespaceName )* RIGHT_PAREN
+	;
+	
+onPartitionedTable:
+	LEFT_PAREN
+	(
+		onRangePartitionedTable
+		|onHashPartitionedTable
+		|indexSubpartitionClause
+	)
+	RIGHT_PAREN
+;
+onRangePartitionedTable:
+	onRangePartitionedItem (COMMA onRangePartitionedItem)*
+	;
+onRangePartitionedItem:
+	PARTITION
+    partitionName?
+    ( segmentAttributesClause
+      | keyCompression
+    )*
+    UNUSABLE?
+    ;
+
+onHashPartitionedTable:
+	onHashPartitionedItem (COMMA onHashPartitionedItem)* 
+	;
+
+onHashPartitionedItem:
+	PARTITION partitionName? ( TABLESPACE tablespaceName )? keyCompression? UNUSABLE?
+	;
+	
+onCompPartitionedTable:
+	storeInClause?
+	LEFT_PAREN 
+	onCompPartitionedItem (COMMA onCompPartitionedItem)*
+	RIGHT_PAREN 
+	;
+	
+onCompPartitionedItem:
+	 PARTITION partitionName?
+	 ( segmentAttributesClause
+       | keyCompression
+      )*
+      UNUSABLE? indexSubpartitionClause?
+	;
+
+indexSubpartitionClause:
+	storeInClause
+	|(LEFT_PAREN indexSubpartitionItem(COMMA indexSubpartitionItem)* RIGHT_PAREN)
+	;
+	
+indexSubpartitionItem:
+	SUBPARTITION partitionName?
+    (TABLESPACE tablespaceName )? ( keyCompression )? UNUSABLE?
+    ;
+    
+indexAttribute:
+	physicalAttributesClause
+ 	| loggingClause
+	| ONLINE
+	| (TABLESPACE ( tablespaceName | DEFAULT))
+	| keyCompression
+	| SORT 
+	| NOSORT
+	| REVERSE
+	| VISIBLE 
+	| INVISIBLE
+	| parallelClause
+	;
+
+parallelClause:
+	NOPARALLEL 
+	| (PARALLEL ( NUMBER )? )
+	;
+	
+domainIndexClause:
+	indexTypeName
+   	localDomainIndexClause?
+   	parallelClause?
+   	odciParameter?
+	;
+	
+localDomainIndexClause:
+	LOCAL
+  	( 
+  		LEFT_PAREN 
+	  		partionWithOdciParameter (COMMA  partionWithOdciParameter)*
+    	RIGHT_PAREN 
+  	)?
+	;
+
+partionWithOdciParameter:
+	PARTITION partitionName odciParameter?
+	;
+
+odciParameter:
+	PARAMETERS LEFT_PAREN STRING RIGHT_PAREN 
+	;
+
+bitmapJoinIndexClause:
+	tableName
+   	LEFT_PAREN 
+    	columnSortClause( COMMA columnSortClause)*
+   	RIGHT_PAREN 
+   	FROM tableAndAlias (COMMA tableAndAlias)*
+   	WHERE expr
+   	localPartitionedIndex? 
+	;
\ No newline at end of file

sharding-jdbc-ddl-parser/src/main/antlr4/imports/OracleKeyword.g4

+lexer grammar OracleKeyword;
+
+import Symbol;
+   
+ACCESS: A C C E S S;
+ADD: A D D;
+ADMIN: A D M I N;
+AFTER: A F T E R;
+ALL: A L L;
+ALLOCATE: A L L O C A T E;
+ALTER: A L T E R;
+ANALYZE: A N A L Y Z E;
+AND: A N D;
+ANY: A N Y;
+ARCHIVE: A R C H I V E;
+ARCHIVELOG: A R C H I V E L O G;
+ARRAYLEN: A R R A Y L E N;
+AS: A S;
+ASC: A S C;
+AUDIT: A U D I T;
+AUTHORIZATION: A U T H O R I Z A T I O N;
+AVG: A V G;
+BACKUP: B A C K U P;
+BECOME: B E C O M E;
+BEFORE: B E F O R E;
+BEGIN: B E G I N;
+BETWEEN: B E T W E E N;
+BLOCK: B L O C K;
+BODY: B O D Y;
+BY: B Y;
+CACHE: C A C H E;
+CANCEL: C A N C E L;
+CASCADE: C A S C A D E;
+CHANGE: C H A N G E;
+CHAR: C H A R;
+CHARACTER: C H A R A C T E R;
+CHECK: C H E C K;
+CHECKPOINT: C H E C K P O I N T;
+CLOSE: C L O S E;
+CLUSTER: C L U S T E R;
+COBOL: C O B O L;
+COLUMN: C O L U M N;
+COMMENT: C O M M E N T;
+COMMIT: C O M M I T;
+COMPILE: C O M P I L E;
+COMPRESS: C O M P R E S S;
+CONNECT: C O N N E C T;
+CONSTRAINT: C O N S T R A I N T;
+CONSTRAINTS: C O N S T R A I N T S;
+CONTENTS: C O N T E N T S;
+CONTINUE: C O N T I N U E;
+CONTROLFILE: C O N T R O L F I L E;
+COUNT: C O U N T;
+CREATE: C R E A T E;
+CURRENT: C U R R E N T;
+CURSOR: C U R S O R;
+CYCLE: C Y C L E;
+DATABASE: D A T A B A S E;
+DATAFILE: D A T A F I L E;
+DATE: D A T E;
+DBA: D B A;
+DEC: D E C;
+DECIMAL: D E C I M A L;
+DECLARE: D E C L A R E;
+DEFAULT: D E F A U L T;
+DELETE: D E L E T E;
+DESC: D E S C;
+DISABLE: D I S A B L E;
+DISMOUNT: D I S M O U N T;
+DISTINCT: D I S T I N C T;
+DOUBLE: D O U B L E;
+DROP: D R O P;
+DUMP: D U M P;
+EACH: E A C H;
+ELSE: E L S E;
+ENABLE: E N A B L E;
+END: E N D;
+ESCAPE: E S C A P E;
+EVENTS: E V E N T S;
+EXCEPT: E X C E P T;
+EXCEPTIONS: E X C E P T I O N S;
+EXCLUSIVE: E X C L U S I V E;
+EXEC: E X E C;
+EXECUTE: E X E C U T E;
+EXISTS: E X I S T S;
+EXPLAIN: E X P L A I N;
+EXTENT: E X T E N T;
+EXTERNALLY: E X T E R N A L L Y;
+FETCH: F E T C H;
+FILE: F I L E;
+FLOAT: F L O A T;
+FLUSH: F L U S H;
+FOR: F O R;
+FORCE: F O R C E;
+FOREIGN: F O R E I G N;
+FORTRAN: F O R T R A N;
+FOUND: F O U N D;
+FREELIST: F R E E L I S T;
+FREELISTS: F R E E L I S T S;
+FROM: F R O M;
+FUNCTION: F U N C T I O N;
+GO: G O;
+GOTO: G O T O;
+GRANT: G R A N T;
+GROUP: G R O U P;
+GROUPS: G R O U P S;
+HAVING: H A V I N G;
+IDENTIFIED: I D E N T I F I E D;
+IMMEDIATE: I M M E D I A T E;
+IN: I N;
+INCLUDING: I N C L U D I N G;
+INCREMENT: I N C R E M E N T;
+INDEX: I N D E X;
+INDICATOR: I N D I C A T O R;
+INITIAL: I N I T I A L;
+INITRANS: I N I T R A N S;
+INSERT: I N S E R T;
+INSTANCE: I N S T A N C E;
+INT: I N T;
+INTEGER: I N T E G E R;
+INTERSECT: I N T E R S E C T;
+INTO: I N T O;
+IS: I S;
+KEY: K E Y;
+LANGUAGE: L A N G U A G E;
+LAYER: L A Y E R;
+LEVEL: L E V E L;
+LIKE: L I K E;
+LINK: L I N K;
+LISTS: L I S T S;
+LOCK: L O C K;
+LOGFILE: L O G F I L E;
+LONG: L O N G;
+MANAGE: M A N A G E;
+MANUAL: M A N U A L;
+MAX: M A X;
+MAXDATAFILES: M A X D A T A F I L E S;
+MAXEXTENTS: M A X E X T E N T S;
+MAXINSTANCES: M A X I N S T A N C E S;
+MAXLOGFILES: M A X L O G F I L E S;
+MAXLOGHISTORY: M A X L O G H I S T O R Y;
+MAXLOGMEMBERS: M A X L O G M E M B E R S;
+MAXTRANS: M A X T R A N S;
+MAXVALUE: M A X V A L U E;
+MIN: M I N;
+MINEXTENTS: M I N E X T E N T S;
+MINUS: M I N U S;
+MINVALUE: M I N V A L U E;
+MODE: M O D E;
+MODIFY: M O D I F Y;
+MODULE: M O D U L E;
+MOUNT: M O U N T;
+NEW: N E W;
+NEXT: N E X T;
+NOARCHIVELOG: N O A R C H I V E L O G;
+NOAUDIT: N O A U D I T;
+NOCACHE: N O C A C H E;
+NOCOMPRESS: N O C O M P R E S S;
+NOCYCLE: N O C Y C L E;
+NOMAXVALUE: N O M A X V A L U E;
+NOMINVALUE: N O M I N V A L U E;
+NONE: N O N E;
+NOORDER: N O O R D E R;
+NORESETLOGS: N O R E S E T L O G S;
+NORMAL: N O R M A L;
+NOSORT: N O S O R T;
+NOT: N O T;
+NOTFOUND: N O T F O U N D;
+NOWAIT: N O W A I T;
+NULL: N U L L;
+NUMBER_: N U M B E R;
+NUMERIC: N U M E R I C;
+OF: O F;
+OFF: O F F;
+OFFLINE: O F F L I N E;
+OLD: O L D;
+ON: O N;
+ONLINE: O N L I N E;
+ONLY: O N L Y;
+OPEN: O P E N;
+OPTIMAL: O P T I M A L;
+OPTION: O P T I O N;
+OR: O R;
+ORDER: O R D E R;
+OWLABEL: O W L A B E L;
+OWN: O W N;
+PACKAGE: P A C K A G E;
+PARALLEL: P A R A L L E L;
+PCTFREE: P C T F R E E;
+PCTINCREASE: P C T I N C R E A S E;
+PCTUSED: P C T U S E D;
+PLAN: P L A N;
+PLI: P L I;
+PRECISION: P R E C I S I O N;
+PRIMARY: P R I M A R Y;
+PRIOR: P R I O R;
+PRIVATE: P R I V A T E;
+PRIVILEGES: P R I V I L E G E S;
+PROCEDURE: P R O C E D U R E;
+PROFILE: P R O F I L E;
+PUBLIC: P U B L I C;
+QUOTA: Q U O T A;
+RAW: R A W;
+READ: R E A D;
+REAL: R E A L;
+RECOVER: R E C O V E R;
+REFERENCES: R E F E R E N C E S;
+REFERENCING: R E F E R E N C I N G;
+RENAME: R E N A M E;
+RESETLOGS: R E S E T L O G S;
+RESOURCE: R E S O U R C E;
+RESTRICTED: R E S T R I C T E D;
+REUSE: R E U S E;
+REVOKE: R E V O K E;
+ROLE: R O L E;
+ROLES: R O L E S;
+ROLLBACK: R O L L B A C K;
+ROW: R O W;
+ROWID: R O W I D;
+ROWNUM: R O W N U M;
+ROWS: R O W S;
+SAVEPOINT: S A V E P O I N T;
+SCHEMA: S C H E M A;
+SCN: S C N;
+SECTION: S E C T I O N;
+SEGMENT: S E G M E N T;
+SELECT: S E L E C T;
+SEQUENCE: S E Q U E N C E;
+SESSION: S E S S I O N;
+SET: S E T;
+SHARE: S H A R E;
+SHARED: S H A R E D;
+SIZE: S I Z E;
+SMALLINT: S M A L L I N T;
+SNAPSHOT: S N A P S H O T;
+SOME: S O M E;
+SORT: S O R T;
+SQL: S Q L;
+SQLBUF: S Q L B U F;
+SQLCODE: S Q L C O D E;
+SQLERROR: S Q L E R R O R;
+SQLSTATE: S Q L S T A T E;
+START: S T A R T;
+STATEMENT_ID: S T A T E M E N T UL_ I D;
+STATISTICS: S T A T I S T I C S;
+STOP: S T O P;
+STORAGE: S T O R A G E;
+SUCCESSFUL: S U C C E S S F U L;
+SUM: S U M;
+SWITCH: S W I T C H;
+SYNONYM: S Y N O N Y M;
+SYSDATE: S Y S D A T E;
+SYSTEM: S Y S T E M;
+TABLE: T A B L E;
+TABLES: T A B L E S;
+TABLESPACE: T A B L E S P A C E;
+TEMPORARY: T E M P O R A R Y;
+THEN: T H E N;
+THREAD: T H R E A D;
+TIME: T I M E;
+TION: T I O N;
+TO: T O;
+TRACING: T R A C I N G;
+TRANSAC: T R A N S A C;
+TRIGGER: T R I G G E R;
+TRIGGERS: T R I G G E R S;
+TRUNCATE: T R U N C A T E;
+UID: U I D;
+UNDER: U N D E R;
+UNION: U N I O N;
+UNIQUE: U N I Q U E;
+UNLIMITED: U N L I M I T E D;
+UNTIL: U N T I L;
+UPDATE: U P D A T E;
+USE: U S E;
+USER: U S E R;
+USING: U S I N G;
+VALIDATE: V A L I D A T E;
+VALUES: V A L U E S;
+VARCHAR: V A R C H A R;
+VIEW: V I E W;
+WHEN: W H E N;
+WHENEVER: W H E N E V E R;
+WHERE: W H E R E;
+WITH: W I T H;
+WORK: W O R K;
+WRITE: W R I T E;
+
+
+GLOBAL: G L O B A L;
+
+
+ALLOW: A L L O W;
+ALWAYS: A L W A Y S;
+ANYSCH: A N Y S C H;
+AT: A T;
+AUTO: A U T O;
+BASIC: B A S I C;
+BASICFILE: B A S I C F I L E;
+BINARY: B I N A R Y;
+BUFFER_POOL: B U F F E R UL_ P O O L;
+CHUNK: C H U N K;
+CLOB: C L O B;
+COLUMNS: C O L U M N S;
+COLUMN_VALUE: C O L U M N UL_ V A L U E;
+CREATION: C R E A T I O N;
+DATA: D A T A;
+DECRYPT: D E C R Y P T;
+DEDUPLICATE: D E D U P L I C A T E;
+DEFERRABLE: D E F E R R A B L E;
+DEFERRED: D E F E R R E D;
+DIRECTORY: D I R E C T O R Y;
+DISALLOW: D I S A L L O W;
+ELEMENT: E L E M E N T;
+EMA: E M A;
+ENCRYPT: E N C R Y P T;
+EXTERNAL: E X T E R N A L;
+FILESYSTEM_LIKE_LOGGING: F I L E S Y S T E M UL_ L I K E UL_ L O G G I N G;
+FLASHBACK: F L A S H B A C K;
+FLASH_CACHE: F L A S H UL_ C A C H E;
+FREEPOOLS: F R E E P O O L S;
+GENERATED: G E N E R A T E D;
+HASH: H A S H;
+HEAP: H E A P;
+HIGH: H I G H;
+IDENTIFIER: I D E N T I F I E R;
+INDEXTYPE: I N D E X T Y P E;
+INITIALLY: I N I T I A L L Y;
+INTERVAL: I N T E R V A L;
+INVISIBLE: I N V I S I B L E;
+KEEP: K E E P;
+KEEP_DUPLICATES: K E E P UL_ D U P L I C A T E S;
+LESS: L E S S;
+LEVELS: L E V E L S;
+LIMIT: L I M I T;
+LIST: L I S T;
+LOB: L O B;
+LOBS: L O B S;
+LOB_: L O B UL_;
+LOCAL: L O C A L;
+LOCATION: L O C A T I O N;
+LOCATOR: L O C A T O R;
+LOG: L O G;
+LOGGING: L O G G I N G;
+LOW: L O W;
+MAXSIZE: M A X S I Z E;
+MEDIUM: M E D I U M;
+MOVEMENT: M O V E M E N T;
+NESTED: N E S T E D;
+NO: N O;
+NOLOGGING: N O L O G G I N G;
+NONSCHEMA: N O N S C H E M A;
+NOPARALLEL: N O P A R A L L E L;
+NORELY: N O R E L Y;
+NOROWDEPENDENCIES: N O R O W D E P E N D E N C I E S;
+NOVALIDATE: N O V A L I D A T E;
+OBJECT: O B J E C T;
+ODCI_: O D C I UL_;
+OIDINDEX: O I D I N D E X;
+OID_: O I D UL_;
+OLTP: O L T P;
+ORGANIZATION: O R G A N I Z A T I O N;
+OVERFLOW: O V E R F L O W;
+PAR: P A R;
+PARAMETERS: P A R A M E T E R S;
+PARTITION: P A R T I T I O N;
+PARTITIONS: P A R T I T I O N S;
+PCTTHRESHOLD: P C T T H R E S H O L D;
+PCTVERSION: P C T V E R S I O N;
+PRESERVE: P R E S E R V E;
+QUERY: Q U E R Y;
+RANGE: R A N G E;
+READS: R E A D S;
+RECYCLE: R E C Y C L E;
+REF: R E F;
+REFERENCE: R E F E R E N C E;
+REJECT: R E J E C T;
+RELATIONAL: R E L A T I O N A L;
+RELY: R E L Y;
+RESULT_CACHE: R E S U L T UL_ C A C H E;
+RETENTION: R E T E N T I O N;
+RETURN: R E T U R N;
+REVERSE: R E V E R S E;
+ROWDEPENDENCIES: R O W D E P E N D E N C I E S;
+SALT: S A L T;
+SCOPE: S C O P E;
+SECUREFILE: S E C U R E F I L E;
+STORE: S T O R E;
+SUBPARTITION: S U B P A R T I T I O N;
+SUBPARTITIONS: S U B P A R T I T I O N S;
+SUBSTITUTABLE: S U B S T I T U T A B L E;
+SUPPLEMENTAL: S U P P L E M E N T A L;
+TEMPLATE: T E M P L A T E;
+THAN: T H A N;
+TITION: T I T I O N;
+TYPE: T Y P E;
+UNUSABLE: U N U S A B L E;
+URL: U R L;
+VALUE: V A L U E;
+VARRAY: V A R R A Y;
+VARRAYS: V A R R A Y S;
+VIRTUAL: V I R T U A L;
+VISIBLE: V I S I B L E;
+XDB: X D B;
+XML: X M L;
+XMLI: X M L I;
+XMLINDEX: X M L I N D E X;
+XMLS: X M L S;
+XMLSCHEMA: X M L S C H E M A;
+XMLT: X M L T;
+XMLTYPE: X M L T Y P E;
+NATIONAL: N A T I O N A L;
+VARYING: V A R Y I N G;
+ZONE: Z O N E;
+MONTH: M O N T H;
+DAY: D A Y;
+SECOND: S E C O N D;
+MAPPING: M A P P I N G;
+NOMAPPING: N O M A P P I N G;
+ANYSCHEMA: A N Y S C H E M A;
+BITMAP: B I T M A P;
+
+REKEY: R E K E Y;
+DEALLOCATE: D E A L L O C A T E;
+UNUSED: U N U S E D;
+MINIMIZE: M I N I M I Z E;
+NOMINIMIZE: N O M I N I M I Z E;
+SHRINK: S H R I N K;
+SPACE: S P A C E;
+COMPACT: C O M P A C T;
+INVALIDATE: I N V A L I D A T E;
+ATTRIBUTES: A T T R I B U T E S;
+DEPENDENT: D E P E N D E N T;
+INDEXES: I N D E X E S;
+MOVE: M O V E;
+SPLIT: S P L I T;
+MERGE: M E R G E;
+EXCHANGE: E X C H A N G E;
+EXCLUDING: E X C L U D I N G;
+PROJECT: P R O J E C T;
+REFERENCED: R E F E R E N C E D;
+TREAT: T R E A T;
+DBTIMEZONE: D B T I M E Z O N E;
+
+NOREVERSE: N O R E V E R S E;
+MONITORING: M O N I T O R I N G;
+NOMONITORING: N O M O N I T O R I N G;
+USAGE: U S A G E;
+PURGE: P U R G E;
+MATERIALIZED: M A T E R I A L I Z E D;
+

sharding-jdbc-ddl-parser/src/main/antlr4/imports/OracleTableBase.g4

+grammar OracleTableBase;
+
+import OracleKeyword,Keyword,Symbol,OracleBase,BaseRule,DataType;
+
+columnDefinition:
+	columnName dataType ( SORT )?
+	( DEFAULT expr )?
+  	( ENCRYPT encryptionSpec )?
+  	( inlineConstraint+ 
+  	| inlineRefConstraint
+  	)?
+	;
+	
+virtualColumnDefinition:
+	columnName dataType? (GENERATED ALWAYS)? AS LEFT_PAREN expr RIGHT_PAREN 
+   (VIRTUAL)?
+   	inlineConstraint*
+	;
+	
+
+inlineConstraint:
+	( CONSTRAINT constraintName )?
+	( (NOT? NULL)
+	| UNIQUE
+	| (PRIMARY KEY)
+	| referencesClause
+	| (CHECK LEFT_PAREN expr RIGHT_PAREN)
+	)
+	constraintState?
+	;
+	
+referencesClause:
+	REFERENCES  objectName columnList?
+	  (ON DELETE ( CASCADE | (SET NULL)) )?
+	;
+	
+constraintState:
+	(notDeferrable
+	|initiallyClause
+	|( RELY | NORELY )
+	|( usingIndexClause )
+	|( ENABLE | DISABLE )
+	|( VALIDATE | NOVALIDATE )
+	|exceptionsClause
+	)+
+	;
+
+notDeferrable:
+	NOT? DEFERRABLE
+	;
+	
+initiallyClause:
+	INITIALLY ( IMMEDIATE | DEFERRED )
+	;
+
+individualHashPartitions:
+	LEFT_PAREN partitioningStorageClause
+	  (COMMA partitioningStorageClause)* RIGHT_PAREN 
+	;
+	
+partitioningStorageClause:
+ 	PARTITION partitionName? partitioningStorage?
+	;
+	
+partitioningStorage:
+	(TABLESPACE tablespaceName)
+  	| (OVERFLOW (TABLESPACE tablespaceName)?)
+  	| tableCompression
+  	| keyCompression
+  	| lobPartitioningStorage
+  	| (VARRAY varrayItemName STORE AS (SECUREFILE | BASICFILE)? LOB segName)
+  	;
+ 
+tableCompression:
+ 	(COMPRESS(BASIC 
+           | FOR ( OLTP
+                 |((QUERY | ARCHIVE) ( LOW | HIGH )?) 
+                 )
+           )?)
+	| NOCOMPRESS 
+	;
+
+usingIndexClause:
+	USING INDEX
+	(  indexName
+	| (LEFT_PAREN createIndex RIGHT_PAREN) 
+	| indexProperties
+	)?
+	;
+	
+createIndex:
+	matchNone
+	;
+
+indexProperties:
+	matchNone
+	;
+	
+segmentAttributesClause:
+	 (physicalAttributesClause
+	| (TABLESPACE tablespaceName)
+	| loggingClause)+
+	;
+
+physicalAttributesClause:
+	storageClause
+	|((PCTFREE 
+	  | PCTUSED 
+	  | INITRANS) NUMBER)
+	;
+
+loggingClause:
+	LOGGING 
+	| NOLOGGING 
+	| FILESYSTEM_LIKE_LOGGING
+	;
+
+keyCompression:
+	(COMPRESS NUMBER?)
+	| NOCOMPRESS
+	;
+	
+lobPartitioningStorage:
+	LOB LEFT_PAREN lobItems RIGHT_PAREN STORE AS (BASICFILE | SECUREFILE)?
+  	((segName tablespaceClauseWithParen?)
+  	| tablespaceClauseWithParen
+  	)?
+	;
+
+tablespaceClauseWithParen:
+	LEFT_PAREN tablespaceClause RIGHT_PAREN
+	;
+		
+tablespaceClause:
+	TABLESPACE tablespaceName
+	;
+
+hashPartitionsByQuantity:
+	PARTITIONS NUMBER
+	( STORE IN LEFT_PAREN tablespaceName ( COMMA tablespaceName )* RIGHT_PAREN )?
+	( tableCompression | keyCompression )?
+	( OVERFLOW STORE IN LEFT_PAREN tablespaceName ( COMMA tablespaceName )* RIGHT_PAREN )?
+	;
+
+
+exceptionsClause:
+	EXCEPTIONS INTO  
+	;
+	
+inlineRefConstraint:
+	 (SCOPE  IS  tableName)
+	| (WITH ROWID)
+	| (( CONSTRAINT constraintName )?
+	  referencesClause
+	  constraintState?)
+	;
+
+outOfLineConstraint:
+  	(CONSTRAINT constraintName )?
+	( (UNIQUE columnList )
+	| (PRIMARY KEY columnList) 
+	| (FOREIGN KEY columnList referencesClause)
+	| (CHECK LEFT_PAREN expr RIGHT_PAREN )
+	) 
+	constraintState?
+	;
+	
+outOfLineRefConstraint:
+	( SCOPE FOR LEFT_PAREN lobItem RIGHT_PAREN 
+	    IS  tableName)
+	| (REF LEFT_PAREN lobItem RIGHT_PAREN WITH ROWID)
+	| ((CONSTRAINT constraintName)? FOREIGN KEY
+	    lobItemList referencesClause
+	    constraintState?)
+	;
+	
+supplementalLoggingProps:
+	SUPPLEMENTAL LOG 
+	(supplementalLogGrpClause
+	| supplementalIdKeyClause
+	)
+	;
+
+supplementalLogGrpClause:
+	GROUP groupName
+	LEFT_PAREN columnName (NO LOG)?
+	( COMMA columnName (NO LOG)? )* RIGHT_PAREN 
+	( ALWAYS )?
+	;
+
+supplementalIdKeyClause:
+	DATA
+	 LEFT_PAREN ( ALL | PRIMARY KEY | UNIQUE | FOREIGN KEY )
+	    ( COMMA ( ALL | PRIMARY KEY | UNIQUE | FOREIGN KEY ) )*
+	 RIGHT_PAREN 
+	;
+	
+
+physicalProperties:
+	( (deferredSegmentCreation? segmentAttributesClause tableCompression?)
+	| (deferredSegmentCreation? ORGANIZATION
+	  ( (HEAP ( segmentAttributesClause )? tableCompression?)
+	  | (INDEX ( segmentAttributesClause )? indexOrgTableClause)
+	  | (EXTERNAL externalTableClause)
+	  ))
+	| (CLUSTER clusterName columnList )
+	)
+	;
+	
+deferredSegmentCreation:
+	SEGMENT CREATION ( IMMEDIATE | DEFERRED )
+	;
+	
+indexOrgTableClause:
+	 ( mappingTableClause
+	  | PCTTHRESHOLD NUMBER
+	  | keyCompression
+	  |indexOrgOverflowClause
+	)+
+	;
+	
+mappingTableClause:
+	(MAPPING TABLE) 
+	| NOMAPPING
+	;
+	
+indexOrgOverflowClause:
+  	( INCLUDING columnName )
+	|OVERFLOW 
+	|segmentAttributesClause 
+	;
+	
+externalTableClause:
+	matchNone
+	;
+
+varrayColProperties:
+	VARRAY varrayItemName 
+	( (substitutableColumnClause? varrayStorageClause)
+	| substitutableColumnClause
+	)
+	;
+
+substitutableColumnClause:
+	( ELEMENT? IS OF TYPE? LEFT_PAREN ONLY? typeName RIGHT_PAREN) 
+	| (NOT? SUBSTITUTABLE AT ALL LEVELS)
+	;
+
+varrayStorageClause:
+	STORE AS (SECUREFILE | BASICFILE)? LOB
+	( (segName? LEFT_PAREN lobStorageParameters RIGHT_PAREN)
+	| segName
+	)
+	;
+	
+lobStorageParameters:
+ 	((TABLESPACE tablespaceName)
+  	| (lobParameters storageClause?)
+	| storageClause
+	)+ 
+	;
+	
+storageClause:
+	STORAGE LEFT_PAREN storageOption(COMMA storageOption)* RIGHT_PAREN
+	;
+	
+storageOption:
+	(INITIAL sizeClause)
+ | (NEXT sizeClause)
+ | (MINEXTENTS NUMBER)
+ | (MAXEXTENTS ( NUMBER | UNLIMITED ))
+ | maxsizeClause
+ | (PCTINCREASE NUMBER)
+ | (FREELISTS NUMBER)
+ | (FREELIST GROUPS NUMBER)
+ | (OPTIMAL (sizeClause | NULL )?)
+ | (BUFFER_POOL ( KEEP | RECYCLE | DEFAULT ))
+ | (FLASH_CACHE ( KEEP | NONE | DEFAULT ))
+ | ENCRYPT
+ ;
+ 
+sizeClause:
+	NUMBER ID?
+	;
+	
+maxsizeClause:
+	MAXSIZE ( UNLIMITED | sizeClause )
+	;
+
+lobParameters:
+	lobParameter+
+	;
+
+lobParameter:
+	((ENABLE | DISABLE) STORAGE IN ROW)
+	|lobCommonParameter
+	;
+	
+lobCommonParameter:
+	(CHUNK NUMBER)
+	| (PCTVERSION NUMBER)
+	| (FREEPOOLS NUMBER)
+	| lobRetentionClause
+	| lobDeduplicateClause
+	| lobCompressionClause
+	| ((ENCRYPT encryptionSpec) | DECRYPT )
+	| (( CACHE | NOCACHE | (CACHE READS))loggingClause?) 
+	;
+	
+encryptionSpec:
+	( USING STRING )?
+	( IDENTIFIED BY STRING )?
+	 ( STRING )?
+	 ( ( NO )? SALT )?
+	;
+
+lobRetentionClause:
+	RETENTION ( MAX | MIN NUMBER | AUTO | NONE )?
+	;
+	
+lobDeduplicateClause:
+	( DEDUPLICATE  
+	| KEEP_DUPLICATES
+	)
+	;
+	
+lobCompressionClause:
+	( COMPRESS (HIGH | MEDIUM | LOW )?)
+	| NOCOMPRESS
+	;
+	
+lobStorageClause:
+	LOB
+	( lobItemList 
+	     STORE AS ( SECUREFILE 
+	     			| BASICFILE
+	              	| (LEFT_PAREN lobStorageParameters RIGHT_PAREN) 
+	              )+
+	    )
+	| (LEFT_PAREN lobItem RIGHT_PAREN 
+	     STORE AS  (SECUREFILE 
+	     			| BASICFILE
+	              	| segName 
+	              	| (LEFT_PAREN lobStorageParameters RIGHT_PAREN)
+	              	)+
+	)
+	;	
+	
+lobPartitionStorage:
+	PARTITION partitionName
+	( lobStorageClause | varrayColProperties )*
+	  ( LEFT_PAREN SUBPARTITION partitionName
+	     ( lobPartitioningStorage | varrayColProperties )*
+	    RIGHT_PAREN 
+	)?
+	;
+	
+xmltypeColumnProperties:
+	XMLTYPE ( COLUMN )? columnName
+   	( xmltypeStorage )?
+    ( xmlschemaSpec )?
+	;
+	
+xmltypeStorage:
+	STORE
+	storeAsClause
+	|( ALL VARRAYS AS ( LOBS | TABLES ))
+	;
+
+storeAsClause:
+	AS
+	(
+		( OBJECT RELATIONAL)
+		|((SECUREFILE | BASICFILE)?
+		  ( CLOB | (BINARY XML))
+		   ( (segName lobStorageParametersWithParen?)
+      		| lobStorageParametersWithParen 
+      		)?
+		)
+	)
+	;
+
+lobStorageParametersWithParen:
+	LEFT_PAREN lobStorageParameters RIGHT_PAREN 
+	;
+	
+xmlschemaSpec:
+  	( XMLSCHEMA xmlschemaUrl )?
+	ELEMENT ( elementName | xmlschemaUrl POUND_ elementName )
+  	( ( ALLOW | DISALLOW ) NONSCHEMA )?
+  	( ( ALLOW | DISALLOW ) ANYSCHEMA )?
+	;
+
+xmlschemaUrl:
+	STRING;
+
+flashbackArchiveClause:
+	(FLASHBACK ARCHIVE (archiveName)?)
+	| (NO FLASHBACK) 
+	;
+	
+rangeValuesClause:
+	VALUES LESS THAN
+  	LEFT_PAREN  
+     	simpleExpr(COMMA simpleExpr)*
+  	RIGHT_PAREN 
+	;
+
+tablePartitionDescription:
+ 	deferredSegmentCreation?
+ 	segmentAttributesClause?
+	( tableCompression | keyCompression )?
+	(OVERFLOW ( segmentAttributesClause )?)?
+	( lobStorageClause
+  	| varrayColProperties
+  	| nestedTableColProperties
+  	)*
+	;
+
+nestedTableColProperties:
+	NESTED TABLE
+	(columnName | COLUMN_VALUE)
+	substitutableColumnClause?
+	( LOCAL | GLOBAL )?
+	STORE AS tableName
+	( LEFT_PAREN ( 
+		(LEFT_PAREN objectProperties RIGHT_PAREN)
+	    | physicalProperties
+	    | columnProperties 
+	    )+
+	  RIGHT_PAREN 
+	)?
+	(RETURN AS? (LOCATOR | VALUE))?
+	;
+
+objectProperties:
+	objectProperty (COMMA objectProperty)*
+	;
+
+objectProperty:
+	(( ( columnName | attributeName )
+    (DEFAULT expr)?
+    (inlineConstraint*  | inlineRefConstraint?))
+	| ( outOfLineConstraint
+	  | outOfLineRefConstraint
+	  | supplementalLoggingProps
+	  )
+	)
+	;
+
+columnProperties:
+	columnProperty+
+	;
+
+columnProperty:
+	objectTypeColProperties
+	| nestedTableColProperties
+	| (( varrayColProperties | lobStorageClause )
+	    ( LEFT_PAREN lobPartitionStorage ( COMMA lobPartitionStorage )* RIGHT_PAREN )?)
+	| xmltypeColumnProperties
+	;
+	
+objectTypeColProperties:
+	COLUMN columnName substitutableColumnClause
+	;
+
+rangePartitionDesc:
+	PARTITION partitionName
+	rangeValuesClause
+	tablePartitionDescription
+	( 
+		(
+			LEFT_PAREN 
+			( 
+				rangeSubpartitionDescs
+		    	| listSubpartitionDescs
+		    	| individualHashSubpartses
+	    	)
+    	RIGHT_PAREN
+    	)
+  	 	| hashSubpartsByQuantity 
+  	 )?
+	;
+
+rangeSubpartitionDescs:
+	rangeSubpartitionDesc ( COMMA rangeSubpartitionDesc)* 
+	;
+
+rangeSubpartitionDesc:
+	SUBPARTITION partitionName 
+	rangeValuesClause?
+  	partitioningStorageClause?
+	;
+
+listSubpartitionDescs:
+	listSubpartitionDesc ( COMMA listSubpartitionDesc)* 
+	;
+
+listSubpartitionDesc:
+	SUBPARTITION partitionName
+  	listValuesClause?
+  	partitioningStorageClause?
+	;
+	
+individualHashSubpartses:
+	individualHashSubparts ( COMMA individualHashSubparts)* 
+	;
+	
+listValuesClause:
+	VALUES 
+	LEFT_PAREN
+		listValues
+    RIGHT_PAREN 
+	;
+
+listValues:
+	(listValueItem (COMMA listValueItem)*)
+	|DEFAULT
+	;
+	
+listValueItem:
+	liter 
+	| NULL
+	;
+
+individualHashSubparts:
+	SUBPARTITION partitionName partitioningStorageClause?
+	;
+	
+hashSubpartsByQuantity:
+	SUBPARTITIONS NUMBER (STORE IN LEFT_PAREN tablespaceName ( COMMA tablespaceName)* RIGHT_PAREN )?
+	;
+
+enableDisableClause:
+	( ENABLE | DISABLE )
+	( VALIDATE | NOVALIDATE )?
+	( UNIQUE columnList 
+	| PRIMARY KEY
+	| CONSTRAINT constraintName
+	)
+	( usingIndexClause )?
+	( exceptionsClause )?
+	( CASCADE )?
+	( ( KEEP | DROP ) INDEX )?
+	;
+
+rowMovementClause:
+	( ENABLE | DISABLE ) ROW 
+	;
\ No newline at end of file

sharding-jdbc-ddl-parser/src/main/antlr4/io/shardingsphere/parser/antlr/oracle/OracleAlterIndex.g4

+grammar OracleAlterIndex;
+
+import OracleKeyword, DataType, Keyword,OracleIndexBase,OracleBase,BaseRule,Symbol;
+
+alterIndex:
+	ALTER INDEX indexName
+	( ( deallocateUnusedClause
+	| allocateExtentClause
+	| shrinkClause
+	| parallelClause
+	| physicalAttributesClause
+	| loggingClause
+	) *
+	| rebuildClause
+	| PARAMETERS LEFT_PAREN STRING RIGHT_PAREN 
+	         RIGHT_PAREN 
+	| COMPILE
+	| ( ENABLE | DISABLE )
+	| UNUSABLE
+	| VISIBLE | INVISIBLE
+	| RENAME TO indexName
+	| COALESCE
+	| ( MONITORING | NOMONITORING ) USAGE
+	| UPDATE BLOCK REFERENCES
+	| alterIndexPartitioning
+	)
+	;
+	
+deallocateUnusedClause:
+	DEALLOCATE UNUSED ( KEEP sizeClause )?
+	;
+
+allocateExtentClause:
+	ALLOCATE EXTENT
+  	( LEFT_PAREN ( SIZE sizeClause
+      | DATAFILE STRING
+      | INSTANCE NUMBER
+      ) *
+    RIGHT_PAREN 
+  	)?
+	;
+	
+shrinkClause:
+	SHRINK SPACE ( COMPACT )? ( CASCADE )?
+	;
+
+rebuildClause:
+	REBUILD
+	( ( PARTITION partitionName
+	| SUBPARTITION partitionName
+	)
+	| ( REVERSE | NOREVERSE )
+	)?
+	( parallelClause
+	| TABLESPACE tablespaceName
+	| PARAMETERS LEFT_PAREN STRING RIGHT_PAREN 
+	//| xmlindexParametersClause
+	| ONLINE
+	| physicalAttributesClause
+	| keyCompression
+	| loggingClause
+	)*
+	;
+
+alterIndexPartitioning:
+	 modifyIndexDefaultAttrs
+	| addHashIndexPartition
+	| modifyIndexPartition
+	| renameIndexPartition
+	| dropIndexPartition
+	| splitIndexPartition
+	| coalesceIndexPartition
+	| modifyIndexSubpartition
+	;
+	
+modifyIndexDefaultAttrs:
+	MODIFY DEFAULT ATTRIBUTES
+	   ( FOR PARTITION partitionName )?
+	   ( physicalAttributesClause
+	   | TABLESPACE ( tablespaceName | DEFAULT )
+	   | loggingClause
+	   )*
+	;
+	
+addHashIndexPartition:
+	ADD PARTITION
+   	( partitionName )?
+   	( TABLESPACE tablespaceName )?
+   	( keyCompression )?
+   	( parallelClause )?
+	;
+	
+modifyIndexPartition:
+	MODIFY PARTITION partitionName
+	( ( deallocateUnusedClause
+	  | allocateExtentClause
+	  | physicalAttributesClause
+	  | loggingClause
+	  | keyCompression
+	  )*
+	| PARAMETERS LEFT_PAREN STRING RIGHT_PAREN 
+	| COALESCE
+	| UPDATE BLOCK REFERENCES
+	| UNUSABLE
+	)
+	;
+	
+renameIndexPartition:
+	RENAME
+	  ( PARTITION partitionName | SUBPARTITION partitionName )
+	TO 
+	;
+	
+dropIndexPartition:
+	DROP PARTITION 
+	;
+	
+splitIndexPartition:
+	SPLIT PARTITION partitionName
+  	AT simpleExprsWithParen 
+	( INTO LEFT_PAREN indexPartitionDescription COMMA 
+	indexPartitionDescription
+	RIGHT_PAREN 
+	)?
+	( parallelClause )?
+	;
+
+indexPartitionDescription:
+	PARTITION
+	(	 partitionName
+   		( (segmentAttributesClause| keyCompression)+
+   		| (PARAMETERS LEFT_PAREN STRING RIGHT_PAREN)
+   		)?
+   		UNUSABLE?
+	)?
+	;
+	
+coalesceIndexPartition:
+	COALESCE PARTITION ( parallelClause )?
+	;
+	
+modifyIndexSubpartition:
+	MODIFY SUBPARTITION partitionName
+	( UNUSABLE
+	| allocateExtentClause
+	| deallocateUnusedClause
+	)
+	;

sharding-jdbc-ddl-parser/src/main/antlr4/io/shardingsphere/parser/antlr/oracle/OracleAlterTable.g4

+grammar OracleAlterTable;
+
+import OracleKeyword, DataType, Keyword,OracleIndexBase, OracleTableBase,OracleBase,BaseRule,Symbol;
+
+alterTable:
+	ALTER TABLE tableName
+ 	( alterTableProperties
+		| columnClauses
+		| constraintClauses
+		| alterTablePartitioning
+		| alterExternalTable
+		| moveTableClause
+	)?
+	( enableDisableClause
+	|((ENABLE | DISABLE) ( (TABLE LOCK) | (ALL TRIGGERS))) 
+	)* 
+	;
+	
+alterTableProperties:
+ 	alterIotOrXml
+	| shrinkClause 
+  	| (READ (ONLY|WRITE))  
+  	| (REKEY encryptionSpec )
+	;
+
+alterIotOrXml:
+	(
+	alterIotOrXmlRepeatHeader+
+  	| (RENAME TO tableName)
+  	)*
+  	alterIotClauses? alterXmlschemaClause?
+	;
+
+alterIotOrXmlRepeatHeader:
+	physicalAttributesClause
+	| loggingClause
+	| tableCompression
+	| supplementalTableLogging
+	| allocateExtentClause
+	| deallocateUnusedClause
+	| ( CACHE | NOCACHE )
+	| (RESULT_CACHE LEFT_PAREN MODE (DEFAULT | FORCE) RIGHT_PAREN )
+	| upgradeTableClause
+	| recordsPerBlockClause
+	| parallelClause
+	| rowMovementClause
+	| flashbackArchiveClause
+	;	
+	 
+supplementalTableLogging:
+	addSupplementalLogClause
+	| dropSupplementalLogClause
+	;
+
+addSupplementalLogClause:
+	ADD addSupplementalLogItem (COMMA addSupplementalLogItem)*
+    ;
+    
+addSupplementalLogItem:
+	SUPPLEMENTAL LOG
+  	(supplementalLogGrpClause | supplementalIdKeyClause)
+  	;
+
+dropSupplementalLogClause:
+	DROP addSupplementalLogItem (COMMA addSupplementalLogItem)*
+    ;
+    
+dropSupplementalLogItem:
+	SUPPLEMENTAL LOG
+    (supplementalIdKeyClause | (GROUP groupName))
+  	;
+
+allocateExtentClause:
+	ALLOCATE EXTENT
+  	( LEFT_PAREN ( SIZE sizeClause
+      | DATAFILE 'filename'
+      | INSTANCE NUMBER
+      ) *
+    RIGHT_PAREN 
+  	)?
+	;
+
+deallocateUnusedClause:
+	DEALLOCATE UNUSED ( KEEP sizeClause )?
+	;
+	
+upgradeTableClause:
+	UPGRADE ( NOT? INCLUDING DATA )?
+   	columnProperties?
+	;
+
+recordsPerBlockClause:
+	MINIMIZE 
+	| NOMINIMIZE
+	;
+
+alterIotClauses:
+	 indexOrgTableClause
+	| alterOverflowClause
+	| alterMappingTableClauses
+	| COALESCE
+	;
+
+alterOverflowClause:
+	addOverflowClause
+	| overflowClause
+	;
+
+addOverflowClause:
+	ADD OVERFLOW segmentAttributesClause?
+	partitionSegmentAttributesWithParen?
+	;
+
+partitionSegmentAttributesWithParen:
+	LEFT_PAREN 
+    	partitionSegmentAttributes (COMMA partitionSegmentAttributes)*
+    RIGHT_PAREN 
+    ;
+     
+partitionSegmentAttributes:
+	PARTITION segmentAttributesClause?
+	;
+
+overflowClause:
+	OVERFLOW
+     ( segmentAttributesClause
+     | allocateExtentClause
+     | shrinkClause
+     | deallocateUnusedClause
+     )+
+     ;
+	
+shrinkClause:
+	SHRINK SPACE COMPACT? CASCADE?
+	;
+	
+alterMappingTableClauses:
+	MAPPING TABLE
+	( allocateExtentClause
+	| deallocateUnusedClause
+	)
+	;
+	
+alterXmlschemaClause:
+ 	(ALLOW ANYSCHEMA)
+ 	| (ALLOW NONSCHEMA)
+ 	| (DISALLOW NONSCHEMA)
+  	;
+  
+columnClauses:
+	opColumnClause+
+	| renameColumnClause
+	| modifyCollectionRetrieval+
+	| modifyLobStorageClause+
+	| alterVarrayColProperties+
+	;
+
+opColumnClause:
+	addColumnClause
+	| modifyColumnClauses
+	| dropColumnClause
+	;
+	
+addColumnClause:
+	ADD
+   	columnOrVirtualDefinitions 
+   	columnProperties?
+   	outOfLinePartStorages?
+	;
+
+columnOrVirtualDefinitions:
+	columnOrVirtualDefinition
+	(COMMA columnOrVirtualDefinition)*
+	;
+		
+columnOrVirtualDefinition:
+	columnDefinition 
+	| virtualColumnDefinition
+	;
+		
+outOfLinePartStorages:
+	outOfLinePartStorage ( COMMA outOfLinePartStorage)*
+	;
+	
+outOfLinePartStorage:
+	PARTITION partitionName
+	outOfLinePartBody+
+	(LEFT_PAREN SUBPARTITION partitionName
+		outOfLinePartBody+
+	  RIGHT_PAREN 
+	)?	
+	;
+	
+outOfLinePartBody:
+	nestedTableColProperties 
+	| lobStorageClause 
+	| varrayColProperties
+	;
+	
+modifyColumnClauses:
+	MODIFY 
+	( 
+		(LEFT_PAREN modifyColProperties ( COMMA modifyColProperties)*  RIGHT_PAREN) 
+       | modifyColSubstitutable
+    )
+	;
+	
+modifyColProperties:
+	columnName 
+	( dataType )?
+    ( DEFAULT expr )?
+    ( ( ENCRYPT encryptionSpec ) | DECRYPT )?
+    inlineConstraint * 
+    ( lobStorageClause )?
+    ( alterXmlschemaClause )?
+	;
+	
+modifyColSubstitutable:
+	COLUMN columnName
+	( NOT )? SUBSTITUTABLE AT ALL LEVELS
+	( FORCE )?
+	;
+	
+dropColumnClause:
+	( SET UNUSED columnOrColumnList cascadeOrInvalidate*)
+	| (DROP columnOrColumnList cascadeOrInvalidate* checkpointNumber?)
+	| (DROP ( (UNUSED COLUMNS)| (COLUMNS CONTINUE) )checkpointNumber?)
+	;
+
+columnOrColumnList:
+	(COLUMN columnName)
+    | (LEFT_PAREN columnName ( COMMA columnName )* RIGHT_PAREN) 
+	;
+
+cascadeOrInvalidate:
+	(CASCADE CONSTRAINTS )
+	| INVALIDATE
+	;
+
+checkpointNumber:
+	CHECKPOINT NUMBER
+	;
+	
+renameColumnClause:
+	RENAME COLUMN columnName TO 
+	;
+	
+modifyCollectionRetrieval:
+	MODIFY NESTED TABLE varrayItemName
+	RETURN AS ( LOCATOR | VALUE )
+	;
+	
+modifyLobStorageClause:
+	MODIFY LOB LEFT_PAREN lobItems RIGHT_PAREN 
+   	LEFT_PAREN modifyLobParameters RIGHT_PAREN 
+	;
+	
+modifyLobParameters:
+	( storageClause
+	|lobCommonParameter
+	)+
+	;
+
+alterVarrayColProperties:
+	MODIFY VARRAY varrayItemName
+   	LEFT_PAREN modifyLobParameters RIGHT_PAREN 
+	;
+	
+constraintClauses:
+	addConstraintClause
+	| modifyConstraintClause
+	| renameConstraintClause
+	| dropConstraintClause+
+	;
+	
+addConstraintClause:
+	ADD 
+	( outOfLineConstraint+
+     |outOfLineRefConstraint
+    )
+    ;
+
+modifyConstraintClause:
+	MODIFY constraintOption constraintState CASCADE?
+	;
+
+constraintWithName:
+	CONSTRAINT constraintName
+	;	
+	
+constraintOption:
+	 constraintWithName
+     | constraintPrimaryOrUnique
+     ;
+ 
+ constraintPrimaryOrUnique:
+ 	 (PRIMARY KEY)
+     | (UNIQUE columnList)
+     ;
+        
+renameConstraintClause:
+   RENAME constraintWithName TO constraintName
+   ;
+   
+dropConstraintClause:
+	DROP
+   	(
+   	 (constraintPrimaryOrUnique CASCADE? (( KEEP | DROP) INDEX)?)
+   	| (CONSTRAINT constraintName ( CASCADE )?)
+  	) 
+	;
+
+alterTablePartitioning:
+	 modifyTableDefaultAttrs
+	| alterIntervalPartitioning
+	| setSubpartitionTemplate
+	| modifyTablePartition
+	| modifyTableSubpartition
+	| moveTablePartition
+	| moveTableSubpartition
+	| addTablePartition
+	| coalesceTablePartition
+	| coalesceTableSubpartition
+	| dropTablePartition
+	| dropTableSubpartition
+	| renamePartitionSubpart
+	| truncatePartitionSubpart
+	| splitTablePartition
+	| splitTableSubpartition
+	| mergeTablePartitions
+	| mergeTableSubpartitions
+	| exchangePartitionSubpart
+	;
+	
+modifyTableDefaultAttrs:
+	MODIFY DEFAULT ATTRIBUTES
+	(FOR partitionExtendedName)?
+	deferredSegmentCreation?
+	segmentAttributesClause?
+	tableCompression?
+	( PCTTHRESHOLD NUMBER )?
+	( keyCompression )?
+	( alterOverflowClause )?
+	modifyTableLobOrArray*
+	;
+
+modifyTableLobOrArray:
+	((LOB lobItemList )| (VARRAY varrayItemName)) LEFT_PAREN lobParameters RIGHT_PAREN
+	;
+		
+partitionExtendedName:
+	PARTITION 
+	(
+		partitionName
+		|(FOR LEFT_PAREN partitionKeyValue ( COMMA partitionKeyValue)* RIGHT_PAREN)
+	)
+	;
+	
+alterIntervalPartitioning:
+	SET(
+		(INTERVAL LEFT_PAREN (expr)? RIGHT_PAREN)
+		|(STORE IN LEFT_PAREN tablespaceName ( COMMA tablespaceName)* RIGHT_PAREN )
+	)
+	;
+	
+setSubpartitionTemplate:
+	SET SUBPARTITION TEMPLATE
+   	(LEFT_PAREN subpartitionDescs? RIGHT_PAREN )
+   	| hashSubpartitionQuantity
+	;
+
+subpartitionDescs:
+	rangeSubpartitionDescs
+	|listSubpartitionDescs
+	|individualHashSubpartses
+	;
+
+rangeSubpartitionDescs:
+	rangeSubpartitionDesc ( COMMA rangeSubpartitionDesc)*
+	;
+
+listSubpartitionDescs:
+	listSubpartitionDesc ( COMMA listSubpartitionDesc)*
+	;	
+
+individualHashSubpartses:
+	individualHashSubparts ( COMMA individualHashSubparts)*
+	;	
+
+hashSubpartitionQuantity:
+	matchNone
+	;
+	
+modifyTablePartition:
+	 modifyRangePartition
+	| modifyHashPartition
+	| modifyListPartition
+	;
+	
+modifyRangePartition:
+	MODIFY partitionExtendedName
+   	(modifyPartitionCommonOp
+   	| alterMappingTableClause
+   	)
+	;
+	
+modifyPartitionCommonOp:
+	partitionAttributes
+   	| addRangeSubpartition
+	| addHashSubpartition
+    | addListSubpartition
+   	| (COALESCE SUBPARTITION updateIndexClauses? parallelClause?)
+   	| (REBUILD? UNUSABLE LOCAL INDEXES)
+	;
+	
+alterMappingTableClause:
+	matchNone
+	;
+		
+partitionAttributes:
+	(commonPartitionAttributes| shrinkClause)*
+	( OVERFLOW commonPartitionAttributes*)?
+	tableCompression?
+	modifyTableLobOrArray*
+	;
+
+addRangeSubpartition:
+	ADD rangeSubpartitionDesc dependentTablesClause? ( updateIndexClauses )? 
+	;
+
+commonPartitionAttributes:
+	 physicalAttributesClause
+	| loggingClause
+	| allocateExtentClause
+  	| deallocateUnusedClause
+  	;
+  	
+dependentTablesClause:
+	DEPENDENT TABLES
+ 	LEFT_PAREN 
+     	tableNameAndPartitionSpecs (COMMA tableNameAndPartitionSpecs)*
+ 	RIGHT_PAREN 
+	;
+	
+tableNameAndPartitionSpecs:
+	tableName LEFT_PAREN partitionSpecs RIGHT_PAREN
+	;
+	
+partitionSpecs:
+	partitionSpec (COMMA partitionSpec)*
+	;
+	
+partitionSpec:
+	PARTITION partitionName? tablePartitionDescription
+	;
+	
+tablePartitionDescription:
+	deferredSegmentCreation?
+	segmentAttributesClause?
+	(tableCompression | keyCompression)?
+	( OVERFLOW segmentAttributesClause? )?
+	( lobStorageClause
+	  | varrayColProperties
+	  | nestedTableColProperties
+	 )*
+	;
+	
+updateIndexClauses:
+	updateGlobalIndexClause
+	| updateAllIndexesClause
+	;
+	
+updateGlobalIndexClause:
+	( UPDATE | INVALIDATE ) GLOBAL 
+	;
+	
+updateAllIndexesClause:
+	UPDATE INDEXES
+   	( LEFT_PAREN 
+        indexNameWithUpdateIndexPartition ( COMMA indexNameWithUpdateIndexPartition)*
+      RIGHT_PAREN 
+   	)?
+	;
+
+indexNameWithUpdateIndexPartition:
+	indexName 
+	LEFT_PAREN 
+		(
+			updateIndexPartition
+            | updateIndexSubpartition
+        )
+    RIGHT_PAREN 
+    ;
+    
+updateIndexPartition:
+	indexOrSubpartition(COMMA indexOrSubpartition)*
+	;
+
+indexOrSubpartition:
+	indexPartitionDescription indexSubpartitionClause?
+	;
+	
+indexPartitionDescription:
+	PARTITION
+	(	 partitionName
+   		( (segmentAttributesClause| keyCompression)+
+   		| (PARAMETERS LEFT_PAREN STRING RIGHT_PAREN)
+   		)?
+   		UNUSABLE?
+	)?
+	;
+	
+updateIndexSubpartition:
+	subpartionWithTablespace (COMMA subpartionWithTablespace)*
+	;
+	
+subpartionWithTablespace:
+	SUBPARTITION partitionName? (TABLESPACE tablespaceName )?
+   	;
+   	
+addHashSubpartition:
+	ADD 
+	individualHashSubparts
+   dependentTablesClause?
+   ( updateIndexClauses )?
+   ( parallelClause )?
+	;
+	
+addListSubpartition:
+	ADD listSubpartitionDesc dependentTablesClause? ( updateIndexClauses )?
+	;
+	
+modifyHashPartition:
+	MODIFY partitionExtendedName
+  	( partitionAttributes
+  	| alterMappingTableClause
+  	| (( REBUILD )? UNUSABLE LOCAL INDEXES)
+  	)
+	;
+	
+modifyListPartition:
+	MODIFY partitionExtendedName
+  	( modifyPartitionCommonOp
+  	| addOrDropPartition
+  	)
+	;
+
+addOrDropPartition:
+	( ADD | DROP ) VALUES LEFT_PAREN simpleExpr( COMMA simpleExpr)* RIGHT_PAREN
+	;
+
+modifyTableSubpartition:
+	MODIFY subpartitionExtendedName
+	( allocateExtentClause
+	| deallocateUnusedCluse
+	| shrinkClause
+	| ( ( LOB lobItems | VARRAY varrayItemName ) LEFT_PAREN modifyLobParameters RIGHT_PAREN )*
+	| (( REBUILD )? UNUSABLE LOCAL INDEXES)
+	| addOrDropPartition
+	)
+	;
+	
+subpartitionExtendedName:
+	(SUBPARTITION partitionName	)
+	| (SUBPARTITION FOR LEFT_PAREN partitionKeyValue ( COMMA partitionKeyValue)* RIGHT_PAREN )
+	;
+
+deallocateUnusedCluse:
+	matchNone;
+	
+moveTablePartition:
+	MOVE partitionExtendedName
+   ( MAPPING TABLE )?
+   tablePartitionDescription
+   ( updateIndexClauses )?
+   ( parallelClause )?
+	;
+	
+moveTableSubpartition:
+MOVE subpartitionExtendedName ( partitioningStorageClause )?
+     ( updateIndexClauses )? ( parallelClause )?
+;
+addTablePartition:
+	ADD PARTITION partitionName?
+	( addRangePartitionClause
+	| addHashPartitionClause
+	| addListPartitionClause
+	) 
+	dependentTablesClause?
+	;
+	
+addRangePartitionClause:
+	rangeValuesClause
+	tablePartitionDescription
+	subpartsDescsOrByQuantity?
+	( updateIndexClauses )?
+	;
+	
+subpartsDescsOrByQuantity:
+	(LEFT_PAREN subpartitionDescs RIGHT_PAREN)
+  	| hashSubpartsByQuantity
+  	;
+	
+hashSubpartsByQuantity:
+	SUBPARTITIONS NUMBER (STORE IN LEFT_PAREN tablespaceName ( COMMA tablespaceName)* RIGHT_PAREN )?
+	;
+	
+	
+addHashPartitionClause:
+	partitioningStorageClause
+	( updateIndexClauses )?
+	( parallelClause )?
+	;
+addListPartitionClause:
+	listValuesClause
+	tablePartitionDescription
+	subpartsDescsOrByQuantity?
+	( updateIndexClauses )?
+	;
+coalesceTablePartition:
+	COALESCE PARTITION ( updateIndexClauses )? ( parallelClause )?
+	;
+coalesceTableSubpartition:
+	COALESCE SUBPARTITION partitionName (updateIndexClauses)? (parallelClause)?
+	;
+	
+dropTablePartition:
+	DROP partitionExtendedName
+	   ( updateIndexClauses ( parallelClause )? )?
+	;
+dropTableSubpartition:
+	DROP subpartitionExtendedName
+	   ( updateIndexClauses ( parallelClause )? )?
+	;
+	
+renamePartitionSubpart:
+	RENAME 
+	( 
+		partitionExtendedName
+	    | subpartitionExtendedName
+	) TO 
+	;
+	
+truncatePartitionSubpart:
+	TRUNCATE 
+	( partitionExtendedName
+     | subpartitionExtendedName
+    )
+   	(((DROP ( ALL )?) | REUSE ) STORAGE )?
+   	(updateIndexClauses ( parallelClause )?)?
+	;
+	
+splitTablePartition:
+	SPLIT partitionExtendedName
+ 	(
+		(
+			AT simpleExprsWithParen ( INTO LEFT_PAREN rangePartitionDescs RIGHT_PAREN )?
+		)
+  		| (VALUES simpleExprsWithParen  ( INTO LEFT_PAREN listPartitionDescs RIGHT_PAREN )?)
+  	) 
+  	( splitNestedTablePart )?
+    dependentTablesClause?
+    ( updateIndexClauses )?
+    ( parallelClause )?
+	;
+
+partitionWithNames:
+	partitionWithName (COMMA partitionWithName)*
+	;
+	
+partitionWithName:
+	PARTITION partitionName
+	;
+	
+rangePartitionDescs:
+	rangePartitionDesc COMMA rangePartitionDesc
+	;
+	
+listPartitionDescs:
+	listPartitionDesc COMMA listPartitionDesc
+	;
+	
+
+rangePartitionDesc:
+	PARTITION partitionName?
+	rangeValuesClause?
+	tablePartitionDescription
+	subpartsDescsOrByQuantity?
+	;
+	
+listPartitionDesc:
+	PARTITION partitionName?
+	listValuesClause?
+	tablePartitionDescription
+ 	subpartsDescsOrByQuantity?
+	;
+	
+splitNestedTablePart:
+	NESTED TABLE columnName INTO
+  	LEFT_PAREN partitionSegmentAttribute COMMA 
+    partitionSegmentAttribute (splitNestedTablePart)?
+  	RIGHT_PAREN 
+  	( splitNestedTablePart )?
+	;
+	
+partitionSegmentAttribute:
+	PARTITION partitionName (segmentAttributesClause)?
+	;
+	
+splitTableSubpartition:
+	SPLIT subpartitionExtendedName
+  	(
+		(
+			AT simpleExprsWithParen ( INTO LEFT_PAREN (rangeSubpartitionDescs) RIGHT_PAREN )?
+		)
+  		| (VALUES simpleExprsWithParen  ( INTO LEFT_PAREN listSubpartitionDescs RIGHT_PAREN )?)
+  	) 
+  	dependentTablesClause?
+    ( updateIndexClauses )?
+    ( parallelClause )?
+	;
+	
+mergeTablePartitions:
+	MERGE PARTITIONS
+	partitionNameOrForKeyValue
+    COMMA 
+   	partitionNameOrForKeyValue
+   ( INTO partitionSpec )?
+   dependentTablesClause?
+   ( updateIndexClauses )?
+   ( parallelClause )?
+	;
+
+partitionNameOrForKeyValue:
+	partitionName 
+	| ( FOR LEFT_PAREN partitionKeyValue ( COMMA partitionKeyValue )* RIGHT_PAREN )
+	;
+
+partitionKeyValue:
+	simpleExpr
+	;
+	
+mergeTableSubpartitions:
+	MERGE SUBPARTITIONS
+   partitionNameOrForKeyValue
+    COMMA 
+   	partitionNameOrForKeyValue
+   	( INTO 
+   		( rangeSubpartitionDesc 
+          | listSubpartitionDesc
+    	)
+   	)?
+   	dependentTablesClause?
+   	( updateIndexClauses )?
+   	( parallelClause )?
+	;
+	
+exchangePartitionSubpart:
+	EXCHANGE 
+	(
+		partitionExtendedName
+        | subpartitionExtendedName
+    )
+   	WITH TABLE  tableName
+   	( ( INCLUDING | EXCLUDING ) INDEXES )?
+   	( ( WITH | WITHOUT ) VALIDATION )?
+   	( exceptionsClause )?
+   	( updateIndexClauses ( parallelClause )? )?
+	;
+
+alterExternalTable:
+	( addColumnClause
+	| modifyColumnClauses
+	| dropColumnClause
+	| parallelClause
+	| externalDataProperties
+	| (REJECT LIMIT ( NUMBER | UNLIMITED ))
+	| (PROJECT COLUMN ( ALL | REFERENCED ))
+	)+
+	;
+	
+externalDataProperties:
+	matchNone
+	;
+	
+moveTableClause:
+	MOVE ( ONLINE )?
+   	segmentAttributesClause?
+   	tableCompression?
+   	( indexOrgTableClause )?
+   	( lobStorageClause | varrayColProperties )*
+   	( parallelClause )?
+	;
+
+

sharding-jdbc-ddl-parser/src/main/antlr4/io/shardingsphere/parser/antlr/oracle/OracleCreateIndex.g4

+grammar OracleCreateIndex;
+
+import OracleIndexBase;
+
+matchNone:
+	'Default does not match anything'
+	;
\ No newline at end of file

sharding-jdbc-ddl-parser/src/main/antlr4/io/shardingsphere/parser/antlr/oracle/OracleCreateTable.g4

+grammar OracleCreateTable;
+
+import OracleKeyword, DataType, Keyword, OracleIndexBase,OracleTableBase,OracleBase,BaseRule,Symbol;
+
+createTable:
+	CREATE ( GLOBAL TEMPORARY )? TABLE  tableName
+	( relationalTable | objectTable | xmltypeTable )
+	;
+	
+relationalTable:
+	( LEFT_PAREN relationalProperties RIGHT_PAREN )
+	( ON COMMIT ( DELETE | PRESERVE ) ROWS )?
+	physicalProperties?
+	tableProperties
+	;
+	
+relationalProperties:
+	relationalProperty (COMMA relationalProperty)*
+	;
+		
+relationalProperty:
+	 columnDefinition
+	| virtualColumnDefinition
+	| outOfLineConstraint
+  	| outOfLineRefConstraint
+  	| supplementalLoggingProps
+	;
+	
+tableProperties:
+	columnProperties?
+	tablePartitioningClauses?
+	( CACHE | NOCACHE )?
+	( RESULT_CACHE LEFT_PAREN MODE (DEFAULT | FORCE ) RIGHT_PAREN )? 
+	parallelClause?
+	( ROWDEPENDENCIES | NOROWDEPENDENCIES )?
+	( enableDisableClause )*
+	( rowMovementClause )?
+	( flashbackArchiveClause )?
+	( AS subquery )?
+	;
+	
+tablePartitioningClauses:
+	 rangePartitions
+	| listPartitions
+	| hashPartitions
+	| compositeRangePartitions
+	| compositeListPartitions
+	| compositeHashPartitions
+	| referencePartitioning
+	| systemPartitioning
+	;
+	
+rangePartitions:
+	PARTITION BY RANGE columnList 
+  	(INTERVAL LEFT_PAREN expr RIGHT_PAREN (STORE IN LEFT_PAREN tablespaceName (COMMA tablespaceName)* RIGHT_PAREN )?)?
+ 	LEFT_PAREN rangePartitionItem(COMMA rangePartitionItem)*
+ 	RIGHT_PAREN 
+ 	;
+ 	
+rangePartitionItem:
+	PARTITION partitionName? rangeValuesClause tablePartitionDescription
+	;
+	
+listPartitions:
+	PARTITION BY LIST LEFT_PAREN columnName RIGHT_PAREN 
+	LEFT_PAREN listPartitionValue(COMMA listPartitionValue)*
+	RIGHT_PAREN 
+	;
+
+listPartitionValue:
+	PARTITION partitionName? listValuesClause tablePartitionDescription
+	;
+	
+hashPartitions:
+	PARTITION BY HASH columnList 
+	( individualHashPartitions
+	| hashPartitionsByQuantity
+	)
+	;
+	
+compositeRangePartitions:
+	PARTITION BY RANGE columnList 
+  	( INTERVAL LEFT_PAREN expr RIGHT_PAREN ( STORE IN LEFT_PAREN tablespaceName ( COMMA tablespaceName)* RIGHT_PAREN )?)?
+  	( 	
+  		subpartitionByRange
+  		| subpartitionByList
+  		| subpartitionByHash
+  	)
+ 	LEFT_PAREN rangePartitionDesc ( COMMA rangePartitionDesc )* RIGHT_PAREN 
+	;
+	
+subpartitionByRange:
+	SUBPARTITION BY RANGE columnList (subpartitionTemplate)?
+	;
+	
+subpartitionTemplate:
+	SUBPARTITION TEMPLATE
+	(subpartitionListItem
+	|hashSubpartsByQuantity
+	) 
+	;
+	
+subpartitionListItem:
+	LEFT_PAREN ( 
+  	(rangeSubpartitionDesc ( COMMA rangeSubpartitionDesc)*)
+    | (listSubpartitionDesc ( COMMA listSubpartitionDesc)*)
+    | (individualHashSubparts ( COMMA individualHashSubparts)*)
+    )
+  	RIGHT_PAREN
+  	;
+
+subpartitionByList:
+	SUBPARTITION BY LIST LEFT_PAREN columnName RIGHT_PAREN subpartitionTemplate?
+	;
+	
+subpartitionByHash:
+	SUBPARTITION BY HASH columnList 
+   	( SUBPARTITIONS NUMBER
+   	    ( STORE IN LEFT_PAREN tablespaceName ( COMMA tablespaceName)* RIGHT_PAREN )?
+   	| subpartitionTemplate
+   	)?
+	;
+
+compositeListPartitions:
+	PARTITION BY LIST LEFT_PAREN columnName RIGHT_PAREN 
+  	( subpartitionByRange
+  	| subpartitionByList
+  	| subpartitionByHash
+  	)
+ 	LEFT_PAREN listPartitionDesc ( COMMA listPartitionDesc)* RIGHT_PAREN 
+	;
+	
+listPartitionDesc:
+PARTITION partitionName
+listValuesClause
+tablePartitionDescription
+  ( LEFT_PAREN rangeSubpartitionDesc ( COMMA rangeSubpartitionDesc)*
+      | listSubpartitionDesc COMMA ( COMMA listSubpartitionDesc)*
+      | individualHashSubparts ( COMMA individualHashSubparts)*
+    RIGHT_PAREN 
+    | hashSubpartsByQuantity
+  )?
+;
+
+compositeHashPartitions:
+	PARTITION BY HASH columnList 
+  ( 
+	  	subpartitionByRange
+	  | subpartitionByList
+	  | subpartitionByHash
+  )
+  (
+	  	individualHashPartitions
+	  | hashPartitionsByQuantity
+  )
+	;
+
+referencePartitioning:
+	PARTITION BY REFERENCE LEFT_PAREN constraintName RIGHT_PAREN 
+  	( LEFT_PAREN referencePartitionDesc* RIGHT_PAREN )?
+	;
+	
+referencePartitionDesc:
+	PARTITION partitionName? tablePartitionDescription RIGHT_PAREN 
+	;
+	
+systemPartitioning:
+	PARTITION BY SYSTEM 
+	( (PARTITIONS NUMBER)
+    | (referencePartitionDesc
+       ( COMMA referencePartitionDesc *)?)
+    )?
+	;
+
+objectTable:
+	OF
+    typeName
+   ( objectTableSubstitution )?
+   ( LEFT_PAREN objectProperties RIGHT_PAREN )?
+   ( ON COMMIT ( DELETE | PRESERVE ) ROWS )?
+   ( oidClause )?
+   ( oidIndexClause )?
+   ( physicalProperties )?
+   tableProperties
+	;
+	
+objectTableSubstitution:
+	( NOT )? SUBSTITUTABLE AT ALL 
+	;
+	
+oidClause:
+	OBJECT IDENTIFIER IS
+	( SYSTEM GENERATED | PRIMARY KEY )
+	;
+	
+oidIndexClause:
+	OIDINDEX ( indexName )?
+	LEFT_PAREN ( physicalAttributesClause
+	| TABLESPACE tablespaceName
+	)*
+	RIGHT_PAREN 
+	;
+	
+xmltypeTable:
+	OF XMLTYPE
+  	( LEFT_PAREN objectProperties RIGHT_PAREN )?
+  	( XMLTYPE xmltypeStorage )?
+  	( xmlschemaSpec )?
+  	( xmltypeVirtualColumns )?
+  	( ON COMMIT ( DELETE | PRESERVE ) ROWS )?
+ 	( oidClause )?
+  	( oidIndexClause )?
+  	( physicalProperties )?
+  	tableProperties 
+	;
+	
+xmltypeVirtualColumns:
+	VIRTUAL COLUMNS 
+	LEFT_PAREN 
+		xmltypeVirtualColumn(COMMA xmltypeVirtualColumn)* 
+	RIGHT_PAREN 
+	;
+	
+xmltypeVirtualColumn:
+	columnName AS LEFT_PAREN expr RIGHT_PAREN
+	;
\ No newline at end of file

sharding-jdbc-ddl-parser/src/main/antlr4/io/shardingsphere/parser/antlr/oracle/OracleDropTable.g4

+grammar OracleDropTable;
+
+import OracleKeyword, DataType, Keyword,BaseRule,Symbol;
+
+dropTable:
+	DROP TABLE tableName
+  	(CASCADE CONSTRAINTS)?  PURGE? 
+  	;
\ No newline at end of file

sharding-jdbc-ddl-parser/src/main/antlr4/io/shardingsphere/parser/antlr/oracle/OracleTruncateTable.g4

+grammar OracleTruncateTable;
+
+import OracleKeyword, DataType, Keyword,BaseRule,Symbol;
+
+truncateTable:
+	TRUNCATE TABLE  tableName
+  	((PRESERVE | PURGE) MATERIALIZED VIEW LOG)?
+  	((DROP  ALL ? | REUSE) STORAGE)? 
+	;
\ No newline at end of file