You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by ch...@apache.org on 2026/08/13 11:27:12 UTC

(shardingsphere) branch master updated: Refactor oracle database object parse logic (#39440)

This is an automated email from the ASF dual-hosted git repository.

FlyingZC pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git


The following commit(s) were added to refs/heads/master by this push:
     new 3b9a9fe6712 Refactor oracle database object parse logic (#39440)
3b9a9fe6712 is described below

commit 3b9a9fe671201d356306e8fadf490845c5623127
Author: Zhengqiang Duan <du...@apache.org>
AuthorDate: Thu Aug 13 19:27:06 2026 +0800

    Refactor oracle database object parse logic (#39440)
    
    * Refactor oracle database object parse logic
    
    * Add Oracle package end name parser assertions
    
    * Fix Oracle DDL visitor test assertion
    
    * Fix Oracle parser IT procedure call expectations
---
 .../ddl/CreateDatabaseObjectStatementContext.java  |  25 +-
 .../CreateDatabaseObjectStatementContextTest.java  | 102 ++++++
 .../src/main/antlr4/imports/oracle/BaseRule.g4     |   2 +-
 .../visitor/statement/OracleStatementVisitor.java  |  81 ++++-
 .../statement/type/OracleDDLStatementVisitor.java  | 368 +++++++++++++++++++--
 .../type/OracleDDLStatementVisitorTest.java        | 277 +++++++++++++++-
 .../ProcedureCallNamesSQLStatementAttribute.java}  |  20 +-
 .../type/ddl/function/AlterFunctionStatement.java  |  16 +
 .../type/ddl/function/CreateFunctionStatement.java |  16 +-
 .../type/ddl/function/DropFunctionStatement.java   |  16 +
 .../type/ddl/pkg/AlterPackageStatement.java        |  16 +
 .../type/ddl/pkg/CreatePackageStatement.java       |  82 +++++
 .../type/ddl/pkg/DropPackageStatement.java         |  20 ++
 .../ddl/procedure/CreateProcedureStatement.java    |  13 +
 .../type/ddl/trigger/AlterTriggerStatement.java    |  16 +
 .../type/ddl/trigger/CreateTriggerStatement.java   |  13 +-
 .../type/ddl/trigger/DropTriggerStatement.java     |  16 +
 .../oracle/ddl/OraclePLSQLBlockStatement.java      |  15 +-
 .../ddl/pkg/OracleCreatePackageStatement.java      |  27 +-
 .../type/OracleCreatePackageStatementAssert.java   |   8 +
 .../OracleCreatePackageStatementTestCase.java      |   3 +
 .../src/main/resources/case/ddl/create-package.xml |   3 +
 .../main/resources/case/plsql/create-procedure.xml |  32 ++
 23 files changed, 1113 insertions(+), 74 deletions(-)

diff --git a/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/context/statement/type/ddl/CreateDatabaseObjectStatementContext.java b/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/context/statement/type/ddl/CreateDatabaseObjectStatementContext.java
index a4f7cb9a6bb..b5c98189008 100644
--- a/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/context/statement/type/ddl/CreateDatabaseObjectStatementContext.java
+++ b/infra/binder/core/src/main/java/org/apache/shardingsphere/infra/binder/context/statement/type/ddl/CreateDatabaseObjectStatementContext.java
@@ -21,16 +21,16 @@ import lombok.Getter;
 import org.apache.shardingsphere.infra.binder.context.SQLStatementContextFactory;
 import org.apache.shardingsphere.infra.binder.context.segment.table.TablesContext;
 import org.apache.shardingsphere.infra.binder.context.statement.SQLStatementContext;
-import org.apache.shardingsphere.infra.binder.engine.SQLBindEngine;
-import org.apache.shardingsphere.infra.hint.HintValueContext;
 import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
 import org.apache.shardingsphere.sql.parser.statement.core.extractor.TableExtractor;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.RoutineBodySegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.SQLStatementSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.SQLStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.SQLStatementAttributes;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.TableSQLStatementAttribute;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.function.CreateFunctionStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.pkg.CreatePackageStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.procedure.CreateProcedureStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.trigger.CreateTriggerStatement;
 
@@ -59,6 +59,10 @@ public final class CreateDatabaseObjectStatementContext implements SQLStatementC
         this(sqlStatement, sqlStatement.getSqlStatements(), currentDatabaseName, metaData);
     }
     
+    public CreateDatabaseObjectStatementContext(final CreatePackageStatement sqlStatement, final String currentDatabaseName, final ShardingSphereMetaData metaData) {
+        this((SQLStatement) sqlStatement, sqlStatement.getSqlStatements(), currentDatabaseName, metaData);
+    }
+    
     public CreateDatabaseObjectStatementContext(final CreateProcedureStatement sqlStatement, final String currentDatabaseName, final ShardingSphereMetaData metaData) {
         this(sqlStatement, sqlStatement.getSqlStatements(), currentDatabaseName, metaData);
     }
@@ -67,27 +71,22 @@ public final class CreateDatabaseObjectStatementContext implements SQLStatementC
                                                  final String currentDatabaseName, final ShardingSphereMetaData metaData) {
         this.sqlStatement = sqlStatement;
         Collection<SimpleTableSegment> tables = new LinkedList<>(extractTables(sqlStatement));
-        SQLBindEngine sqlBindEngine = new SQLBindEngine(metaData, currentDatabaseName, new HintValueContext());
         for (SQLStatementSegment each : internalSqlStatements) {
-            SQLStatementContext sqlStatementContext = createInternalSQLStatementContext(sqlBindEngine, sqlStatement, each, currentDatabaseName, metaData);
+            SQLStatementContext sqlStatementContext = SQLStatementContextFactory.newInstance(metaData, each.getSqlStatement(), currentDatabaseName);
             sqlStatementContexts.add(sqlStatementContext);
             tables.addAll(sqlStatementContext.getTablesContext().getSimpleTables());
         }
         tablesContext = new TablesContext(tables);
     }
     
-    private SQLStatementContext createInternalSQLStatementContext(final SQLBindEngine sqlBindEngine, final SQLStatement sqlStatement, final SQLStatementSegment segment,
-                                                                  final String currentDatabaseName, final ShardingSphereMetaData metaData) {
-        return sqlStatement instanceof CreateProcedureStatement
-                ? SQLStatementContextFactory.newInstance(metaData, segment.getSqlStatement(), currentDatabaseName)
-                : sqlBindEngine.bind(segment.getSqlStatement());
-    }
-    
     private Collection<SimpleTableSegment> extractTables(final SQLStatement sqlStatement) {
+        SQLStatementAttributes attributes = sqlStatement.getAttributes();
+        Optional<TableSQLStatementAttribute> tableAttribute = null == attributes ? Optional.empty() : attributes.findAttribute(TableSQLStatementAttribute.class);
+        Collection<SimpleTableSegment> result = new LinkedList<>(tableAttribute.map(TableSQLStatementAttribute::getTables).orElseGet(Collections::emptyList));
         if (sqlStatement instanceof CreateProcedureStatement) {
             Optional<RoutineBodySegment> routineBody = ((CreateProcedureStatement) sqlStatement).getRoutineBody();
-            return routineBody.map(optional -> new TableExtractor().extractExistTableFromRoutineBody(optional)).orElseGet(Collections::emptyList);
+            routineBody.ifPresent(optional -> result.addAll(new TableExtractor().extractExistTableFromRoutineBody(optional)));
         }
-        return sqlStatement.getAttributes().findAttribute(TableSQLStatementAttribute.class).map(TableSQLStatementAttribute::getTables).orElseGet(Collections::emptyList);
+        return result;
     }
 }
diff --git a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/context/statement/type/ddl/CreateDatabaseObjectStatementContextTest.java b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/context/statement/type/ddl/CreateDatabaseObjectStatementContextTest.java
index 21442077880..e7ce28778f1 100644
--- a/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/context/statement/type/ddl/CreateDatabaseObjectStatementContextTest.java
+++ b/infra/binder/core/src/test/java/org/apache/shardingsphere/infra/binder/context/statement/type/ddl/CreateDatabaseObjectStatementContextTest.java
@@ -20,21 +20,33 @@ package org.apache.shardingsphere.infra.binder.context.statement.type.ddl;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
 import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
 import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.packages.PackageSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.RoutineBodySegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.ValidStatementSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.TableNameSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.ProcedureCallNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.SQLStatementSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.SQLStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.SQLStatementAttributes;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.TableSQLStatementAttribute;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.pkg.CreatePackageStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.procedure.CreateProcedureStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.trigger.CreateTriggerStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.value.identifier.IdentifierValue;
 import org.junit.jupiter.api.Test;
 
+import java.util.Collection;
 import java.util.Collections;
+import java.util.LinkedList;
+import java.util.Optional;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
 
 class CreateDatabaseObjectStatementContextTest {
@@ -65,6 +77,39 @@ class CreateDatabaseObjectStatementContextTest {
         assertThat(actual.getTablesContext().getTableNames(), is(Collections.singleton("t_encrypt")));
     }
     
+    @Test
+    void assertNewInstanceWithProcedureRoutineBodyTablesContext() {
+        CreateProcedureStatement sqlStatement = new CreateProcedureStatement(databaseType);
+        RoutineBodySegment routineBody = new RoutineBodySegment(0, 50);
+        ValidStatementSegment validStatement = new ValidStatementSegment(10, 45);
+        validStatement.setSqlStatement(InsertStatement.builder().databaseType(databaseType)
+                .table(new SimpleTableSegment(new TableNameSegment(22, 30, new IdentifierValue("t_encrypt")))).build());
+        routineBody.getValidStatements().add(validStatement);
+        sqlStatement.setRoutineBody(routineBody);
+        CreateDatabaseObjectStatementContext actual = new CreateDatabaseObjectStatementContext(sqlStatement, "foo_db", mock(ShardingSphereMetaData.class));
+        assertThat(actual.getTablesContext().getTableNames(), is(Collections.singleton("t_encrypt")));
+    }
+    
+    @Test
+    void assertNewInstanceWithPackageInternalSQLTablesContext() {
+        PackageSQLStatement sqlStatement = new PackageSQLStatement(databaseType);
+        sqlStatement.getSqlStatements().add(new SQLStatementSegment(0, 0, new TableAwareSQLStatement("t_encrypt")));
+        CreateDatabaseObjectStatementContext actual = new CreateDatabaseObjectStatementContext(sqlStatement, "foo_db", mock(ShardingSphereMetaData.class));
+        assertThat(actual.getSqlStatement(), is(sqlStatement));
+        assertThat(actual.getTablesContext().getTableNames(), is(Collections.singleton("t_encrypt")));
+    }
+    
+    @Test
+    void assertNewInstanceWithPackageTypeAttributeTablesContext() {
+        PackageSQLStatement sqlStatement = new PackageSQLStatement(databaseType, new TableSQLStatementAttribute(
+                new SimpleTableSegment(new TableNameSegment(40, 45, new IdentifierValue("t_type")))));
+        sqlStatement.getSqlStatements().add(new SQLStatementSegment(0, 0, new TableAwareSQLStatement("t_encrypt")));
+        CreateDatabaseObjectStatementContext actual = new CreateDatabaseObjectStatementContext(sqlStatement, "foo_db", mock(ShardingSphereMetaData.class));
+        assertThat(actual.getTablesContext().getSimpleTables().size(), is(2));
+        assertTrue(actual.getTablesContext().getTableNames().contains("t_type"));
+        assertTrue(actual.getTablesContext().getTableNames().contains("t_encrypt"));
+    }
+    
     private static final class TableAwareSQLStatement extends SQLStatement {
         
         private final SQLStatementAttributes attributes;
@@ -79,4 +124,61 @@ class CreateDatabaseObjectStatementContextTest {
             return attributes;
         }
     }
+    
+    private static final class PackageSQLStatement extends SQLStatement implements CreatePackageStatement {
+        
+        private final Collection<SQLStatementSegment> sqlStatements = new LinkedList<>();
+        
+        private final SQLStatementAttributes attributes;
+        
+        private PackageSQLStatement(final DatabaseType databaseType) {
+            super(databaseType);
+            attributes = new SQLStatementAttributes();
+        }
+        
+        private PackageSQLStatement(final DatabaseType databaseType, final TableSQLStatementAttribute tableSQLStatementAttribute) {
+            super(databaseType);
+            attributes = new SQLStatementAttributes(tableSQLStatementAttribute);
+        }
+        
+        @Override
+        public SQLStatementAttributes getAttributes() {
+            return attributes;
+        }
+        
+        @Override
+        public PackageSegment getPackageName() {
+            return new PackageSegment(0, 6, new IdentifierValue("foo_pkg"));
+        }
+        
+        @Override
+        public boolean isBody() {
+            return true;
+        }
+        
+        @Override
+        public Optional<PackageSegment> getPackageEndName() {
+            return Optional.empty();
+        }
+        
+        @Override
+        public Collection<SQLStatementSegment> getSqlStatements() {
+            return sqlStatements;
+        }
+        
+        @Override
+        public Collection<ColumnSegment> getColumns() {
+            return Collections.emptyList();
+        }
+        
+        @Override
+        public Collection<ProcedureCallNameSegment> getProcedureCallNames() {
+            return Collections.emptyList();
+        }
+        
+        @Override
+        public Collection<ExpressionSegment> getDynamicSqlStatementExpressions() {
+            return Collections.emptyList();
+        }
+    }
 }
diff --git a/parser/sql/engine/dialect/oracle/src/main/antlr4/imports/oracle/BaseRule.g4 b/parser/sql/engine/dialect/oracle/src/main/antlr4/imports/oracle/BaseRule.g4
index 6409b91e107..0a008e3b204 100644
--- a/parser/sql/engine/dialect/oracle/src/main/antlr4/imports/oracle/BaseRule.g4
+++ b/parser/sql/engine/dialect/oracle/src/main/antlr4/imports/oracle/BaseRule.g4
@@ -671,7 +671,7 @@ extractFunction
     ;
 
 regularFunction
-    : (owner DOT_)? regularFunctionName LP_ (expr (COMMA_ expr)* | ASTERISK_)? RP_
+    : (owner DOT_)* regularFunctionName LP_ (expr (COMMA_ expr)* | ASTERISK_)? RP_
     ;
 
 regularFunctionName
diff --git a/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/OracleStatementVisitor.java b/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/OracleStatementVisitor.java
index 6155e385ca4..eb51aee61cf 100644
--- a/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/OracleStatementVisitor.java
+++ b/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/OracleStatementVisitor.java
@@ -49,6 +49,7 @@ import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.DataTy
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.DataTypeNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.DateTimeLiteralsContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.DatetimeExprContext;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.DefaultStringContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.ExprContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.ExprListContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.ExtractFunctionContext;
@@ -80,6 +81,7 @@ import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.Parame
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.PredicateContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.PredictionCostFunctionContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.PrivateExprOfDbContext;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.PseudorecordContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.QueryPartitionClauseContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.RegularFunctionContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.SchemaNameContext;
@@ -502,6 +504,11 @@ public abstract class OracleStatementVisitor extends OracleStatementBaseVisitor<
         if (SequenceFunction.valueFrom(ctx.name().getText()).isPresent()) {
             return createSequenceFunction(ctx);
         }
+        if (null != ctx.nestedItem() && !ctx.nestedItem().isEmpty()) {
+            if (SequenceFunction.valueFrom(ctx.nestedItem().get(0).getText()).isPresent()) {
+                return createSequenceFunction(ctx);
+            }
+        }
         ColumnSegment result = new ColumnSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (IdentifierValue) visit(ctx.name()));
         OwnerContext owner = ctx.owner();
         if (null != owner) {
@@ -816,6 +823,9 @@ public abstract class OracleStatementVisitor extends OracleStatementBaseVisitor<
         if (null != ctx.subquery()) {
             return new SubquerySegment(startIndex, stopIndex, (SelectStatement) visit(ctx.subquery()), getOriginalText(ctx.subquery()));
         }
+        if (null != ctx.pseudorecord()) {
+            return visit(ctx.pseudorecord());
+        }
         if (null != ctx.parameterMarker()) {
             return createParameterMarkerExpressionSegment(ctx.parameterMarker());
         }
@@ -846,6 +856,18 @@ public abstract class OracleStatementVisitor extends OracleStatementBaseVisitor<
         return visitRemainSimpleExpr(ctx, startIndex, stopIndex);
     }
     
+    @Override
+    public ASTNode visitPseudorecord(final PseudorecordContext ctx) {
+        if (null == ctx.NEW() && null == ctx.OLD()) {
+            return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), getOriginalText(ctx));
+        }
+        ColumnSegment result = new ColumnSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (IdentifierValue) visit(ctx.identifier()));
+        int ownerStartIndex = null == ctx.NEW() ? ctx.OLD().getSymbol().getStartIndex() : ctx.NEW().getSymbol().getStartIndex();
+        int ownerStopIndex = null == ctx.NEW() ? ctx.OLD().getSymbol().getStopIndex() : ctx.NEW().getSymbol().getStopIndex();
+        result.setOwner(new OwnerSegment(ownerStartIndex, ownerStopIndex, new IdentifierValue(null == ctx.NEW() ? "OLD" : "NEW")));
+        return result;
+    }
+    
     protected ParameterMarkerExpressionSegment createParameterMarkerExpressionSegment(final ParameterMarkerContext ctx) {
         return createParameterMarkerExpressionSegment((ParameterMarkerValue) visit(ctx), ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex());
     }
@@ -1267,7 +1289,7 @@ public abstract class OracleStatementVisitor extends OracleStatementBaseVisitor<
     @Override
     public ASTNode visitXmlNamespacesClause(final XmlNamespacesClauseContext ctx) {
         // TODO : throw exception if more than one defaultString exists in a xml name space clause
-        String defaultString = null == ctx.defaultString() ? null : ctx.defaultString(0).STRING_().getText();
+        String defaultString = getDefaultXmlNamespaceString(ctx);
         Collection<XmlNamespaceStringAsIdentifierSegment> xmlNamespaceStringAsIdentifierSegments = null == ctx.xmlNamespaceStringAsIdentifier() ? Collections.emptyList()
                 : ctx.xmlNamespaceStringAsIdentifier().stream().map(each -> (XmlNamespaceStringAsIdentifierSegment) visit(each)).collect(Collectors.toList());
         XmlNamespacesClauseSegment result = new XmlNamespacesClauseSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), defaultString, getOriginalText(ctx));
@@ -1275,6 +1297,15 @@ public abstract class OracleStatementVisitor extends OracleStatementBaseVisitor<
         return result;
     }
     
+    private String getDefaultXmlNamespaceString(final XmlNamespacesClauseContext ctx) {
+        for (DefaultStringContext each : ctx.defaultString()) {
+            if (null != each && null != each.STRING_()) {
+                return each.STRING_().getText();
+            }
+        }
+        return null;
+    }
+    
     @Override
     public ASTNode visitXmlNamespaceStringAsIdentifier(final XmlNamespaceStringAsIdentifierContext ctx) {
         return new XmlNamespaceStringAsIdentifierSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.STRING_().getText(), ctx.identifier().getText(), getOriginalText(ctx));
@@ -1283,7 +1314,8 @@ public abstract class OracleStatementVisitor extends OracleStatementBaseVisitor<
     @Override
     public ASTNode visitXmlTableOptions(final XmlTableOptionsContext ctx) {
         XmlTableOptionsSegment result = new XmlTableOptionsSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx));
-        Collection<ExpressionSegment> expressionSegments = null == ctx.xmlPassingClause().expr() ? Collections.emptyList()
+        Collection<ExpressionSegment> expressionSegments = null == ctx.xmlPassingClause()
+                ? Collections.emptyList()
                 : ctx.xmlPassingClause().expr().stream().map(each -> (ExpressionSegment) visit(each)).collect(Collectors.toList());
         Collection<XmlTableColumnSegment> xmlTableColumnSegments = null == ctx.xmlTableColumn() ? Collections.emptyList()
                 : ctx.xmlTableColumn().stream().map(each -> (XmlTableColumnSegment) visit(each)).collect(Collectors.toList());
@@ -1510,14 +1542,51 @@ public abstract class OracleStatementVisitor extends OracleStatementBaseVisitor<
     @Override
     public final ASTNode visitRegularFunction(final RegularFunctionContext ctx) {
         FunctionSegment result = new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.regularFunctionName().getText(), getOriginalText(ctx));
-        if (null != ctx.owner()) {
-            OwnerContext owner = ctx.owner();
-            result.setOwner(new OwnerSegment(owner.getStart().getStartIndex(), owner.getStop().getStopIndex(), (IdentifierValue) visit(owner.identifier())));
+        if (!ctx.owner().isEmpty()) {
+            result.setOwner(createOwnerSegment(ctx.owner()));
         }
-        result.getParameters().addAll(getExpressions(ctx.expr()));
+        if (!isRefFunction(ctx)) {
+            getProcedureCallNames().add(createRegularFunctionCallNameSegment(ctx));
+            result.getParameters().addAll(getExpressions(ctx.expr()));
+        }
+        return result;
+    }
+    
+    private ProcedureCallNameSegment createRegularFunctionCallNameSegment(final RegularFunctionContext ctx) {
+        PackageSegment packageSegment = createRegularFunctionPackageSegment(ctx.owner());
+        ProcedureCallNameSegment result = new ProcedureCallNameSegment(
+                null == packageSegment ? ctx.regularFunctionName().start.getStartIndex() : packageSegment.getStartIndex(),
+                ctx.regularFunctionName().stop.getStopIndex(), new IdentifierValue(ctx.regularFunctionName().getText()));
+        result.setPackageSegment(packageSegment);
         return result;
     }
     
+    private PackageSegment createRegularFunctionPackageSegment(final List<OwnerContext> ownerContexts) {
+        if (ownerContexts.isEmpty()) {
+            return null;
+        }
+        OwnerContext packageContext = ownerContexts.get(ownerContexts.size() - 1);
+        PackageSegment result = new PackageSegment(packageContext.getStart().getStartIndex(), packageContext.getStop().getStopIndex(), (IdentifierValue) visit(packageContext.identifier()));
+        if (ownerContexts.size() > 1) {
+            result.setOwner(createOwnerSegment(ownerContexts.subList(0, ownerContexts.size() - 1)));
+        }
+        return result;
+    }
+    
+    private OwnerSegment createOwnerSegment(final List<OwnerContext> ownerContexts) {
+        OwnerSegment result = null;
+        for (OwnerContext each : ownerContexts) {
+            OwnerSegment current = new OwnerSegment(each.getStart().getStartIndex(), each.getStop().getStopIndex(), (IdentifierValue) visit(each.identifier()));
+            current.setOwner(result);
+            result = current;
+        }
+        return result;
+    }
+    
+    private boolean isRefFunction(final RegularFunctionContext ctx) {
+        return ctx.owner().isEmpty() && "REF".equalsIgnoreCase(ctx.regularFunctionName().getText());
+    }
+    
     @Override
     public final ASTNode visitBuiltinFunctionsExpr(final BuiltinFunctionsExprContext ctx) {
         FunctionSegment result = new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.builtinFunction().getText(), getOriginalText(ctx));
diff --git a/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/type/OracleDDLStatementVisitor.java b/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/type/OracleDDLStatementVisitor.java
index c95c680e3b4..38fd9ee18cf 100644
--- a/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/type/OracleDDLStatementVisitor.java
+++ b/parser/sql/engine/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/type/OracleDDLStatementVisitor.java
@@ -23,6 +23,7 @@ import org.antlr.v4.runtime.tree.ParseTree;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
 import org.apache.shardingsphere.sql.parser.api.ASTNode;
 import org.apache.shardingsphere.sql.parser.api.visitor.statement.type.DDLStatementVisitor;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementBaseVisitor;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.AddColumnSpecificationContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.AddConstraintSpecificationContext;
@@ -77,6 +78,7 @@ import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.Column
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.ColumnNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.ColumnOrVirtualDefinitionContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.CommentContext;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.CompoundDmlTriggerContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.ConstraintClausesContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.CreateClusterContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.CreateContextContext;
@@ -117,7 +119,6 @@ import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.Create
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.CursorDefinitionContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.CursorForLoopStatementContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.CursorParameterDecContext;
-import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.DataTypeContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.DataTypeDefinitionContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.DisassociateStatisticsContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.DmlStatementContext;
@@ -195,15 +196,22 @@ import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.PlsqlP
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.PlsqlProcedureSourceContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.PlsqlStatementsContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.PlsqlTriggerSourceContext;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.PlaceholderContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.ProcedureCallContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.ProcedureNameContext;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.PseudorecordContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.PurgeContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.RelationalPropertyContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.RenameContext;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.RecordVariableDeclarationContext;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.RefCursorTypeDefinitionContext;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.RowtypeAttributeContext;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.RowtypeContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.SchemaNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.SelectContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.SelectIntoStatementContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.SelectSubqueryContext;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.SimpleDmlTriggerContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.SqlStatementInPlsqlContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.StatementContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.SwitchContext;
@@ -211,7 +219,9 @@ import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.System
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.TableNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.TriggerBodyContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.TriggerNameContext;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.TriggerWhenClauseContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.TruncateTableContext;
+import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.TypeAttributeContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.TypeNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.VariableNameContext;
 import org.apache.shardingsphere.sql.parser.autogen.OracleStatementParser.VarrayTypeSpecContext;
@@ -235,6 +245,7 @@ import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.index.Ind
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.packages.PackageSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.FunctionNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.RoutineBodySegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.ValidStatementSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.tablespace.TablespaceSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.type.TypeDefinitionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.type.TypeSegment;
@@ -854,7 +865,10 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
     
     @Override
     public ASTNode visitDropPackage(final DropPackageContext ctx) {
-        return new DropPackageStatement(getDatabaseType());
+        DropPackageStatement result = new DropPackageStatement(getDatabaseType());
+        result.setPackageName(createPackageNameSegment(ctx.packageName()));
+        result.setBody(null != ctx.BODY());
+        return result;
     }
     
     @Override
@@ -875,20 +889,32 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
         getSqlStatementsInPlsql().sort(Comparator.comparingInt(SQLStatementSegment::getStartIndex));
         getProcedureCallNames().sort(Comparator.comparingInt(ProcedureCallNameSegment::getStartIndex));
         getDynamicSqlStatementExpressions().sort(Comparator.comparingInt(ExpressionSegment::getStartIndex));
+        getSqlStatementsInPlsql().forEach(each -> each.getSqlStatement().getVariableNames().addAll(getVariableNames()));
         PlsqlPackageSourceContext specification = ctx.plsqlPackageSource();
         PackageSegment packageName = null == specification
                 ? createPackageNameSegment(body.schemaName(), body.packageName(0))
                 : createPackageNameSegment(specification.schemaName(), specification.packageName(0));
+        PackageSegment packageEndName = null == specification ? createPackageEndNameSegment(body.packageName()) : createPackageEndNameSegment(specification.packageName());
+        TypeAttributeSegments typeAttributeSegments = extractTypeAttributeSegments(specification);
+        if (null != body) {
+            typeAttributeSegments.addAll(extractTypeAttributeSegments(body.declareItem()));
+        }
         OracleCreatePackageStatement result = new OracleCreatePackageStatement(
-                getDatabaseType(), packageName, null != body, null != ctx.REPLACE(),
+                getDatabaseType(), packageName, packageEndName, null != body, null != ctx.REPLACE(),
                 null == specification ? null != body.packageIfNotExists() : null != specification.packageIfNotExists(),
-                getEdition(ctx), getAuthorization(specification), initialization);
+                getEdition(ctx), getAuthorization(specification), initialization, typeAttributeSegments.getTables());
+        result.getColumns().addAll(typeAttributeSegments.getColumns());
         result.getSqlStatements().addAll(getSqlStatementsInPlsql());
         result.getProcedureCallNames().addAll(getProcedureCallNames());
         result.getDynamicSqlStatementExpressions().addAll(getDynamicSqlStatementExpressions());
+        result.getCursorForLoopStatements().addAll(getCursorForLoopStatementSegments());
         return result;
     }
     
+    private PackageSegment createPackageEndNameSegment(final List<PackageNameContext> packageNames) {
+        return packageNames.size() < 2 ? null : (PackageSegment) visit(packageNames.get(packageNames.size() - 1));
+    }
+    
     private PackageSegment createPackageNameSegment(final SchemaNameContext schemaName, final PackageNameContext packageName) {
         PackageSegment result = (PackageSegment) visit(packageName);
         if (null != schemaName) {
@@ -897,6 +923,74 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
         return result;
     }
     
+    private PackageSegment createPackageNameSegment(final PackageNameContext packageName) {
+        PackageSegment result = (PackageSegment) visit(packageName);
+        if (null != packageName.owner()) {
+            result.setOwner(new OwnerSegment(packageName.owner().start.getStartIndex(), packageName.owner().stop.getStopIndex(),
+                    (IdentifierValue) visit(packageName.owner().identifier())));
+        }
+        return result;
+    }
+    
+    private TypeAttributeSegments extractTypeAttributeSegments(final ParseTree ctx) {
+        if (null == ctx) {
+            return new TypeAttributeSegments();
+        }
+        TypeAttributeExtractor extractor = new TypeAttributeExtractor();
+        extractor.visit(ctx);
+        return extractor.getResult();
+    }
+    
+    private TypeAttributeSegments extractTypeAttributeSegments(final Collection<? extends ParseTree> contexts) {
+        TypeAttributeSegments result = new TypeAttributeSegments();
+        for (ParseTree each : contexts) {
+            result.addAll(extractTypeAttributeSegments(each));
+        }
+        return result;
+    }
+    
+    private SimpleTableSegment createTypeAttributeTable(final ObjectNameContext ctx) {
+        OwnerContext tableName = ctx.owner();
+        return new SimpleTableSegment(new TableNameSegment(tableName.start.getStartIndex(), tableName.stop.getStopIndex(), (IdentifierValue) visit(tableName.identifier())));
+    }
+    
+    private SimpleTableSegment createTypeAttributeTable(final TypeNameContext ctx) {
+        OwnerContext tableName = ctx.owner();
+        return new SimpleTableSegment(new TableNameSegment(tableName.start.getStartIndex(), tableName.stop.getStopIndex(), (IdentifierValue) visit(tableName.identifier())));
+    }
+    
+    private ColumnSegment createTypeAttributeColumn(final ObjectNameContext ctx) {
+        ColumnSegment result = new ColumnSegment(ctx.name().start.getStartIndex(), ctx.name().stop.getStopIndex(), (IdentifierValue) visit(ctx.name()));
+        result.setOwner(createOwner(ctx.owner()));
+        return result;
+    }
+    
+    private ColumnSegment createTypeAttributeColumn(final TypeNameContext ctx) {
+        ColumnSegment result = new ColumnSegment(ctx.name().start.getStartIndex(), ctx.name().stop.getStopIndex(), (IdentifierValue) visit(ctx.name()));
+        result.setOwner(createOwner(ctx.owner()));
+        return result;
+    }
+    
+    private SimpleTableSegment createRowtypeTable(final ObjectNameContext ctx) {
+        SimpleTableSegment result = new SimpleTableSegment(new TableNameSegment(ctx.name().start.getStartIndex(), ctx.name().stop.getStopIndex(), (IdentifierValue) visit(ctx.name())));
+        if (null != ctx.owner()) {
+            result.setOwner(createOwner(ctx.owner()));
+        }
+        return result;
+    }
+    
+    private SimpleTableSegment createRowtypeTable(final TypeNameContext ctx) {
+        SimpleTableSegment result = new SimpleTableSegment(new TableNameSegment(ctx.name().start.getStartIndex(), ctx.name().stop.getStopIndex(), (IdentifierValue) visit(ctx.name())));
+        if (null != ctx.owner()) {
+            result.setOwner(createOwner(ctx.owner()));
+        }
+        return result;
+    }
+    
+    private OwnerSegment createOwner(final OwnerContext ctx) {
+        return new OwnerSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (IdentifierValue) visit(ctx.identifier()));
+    }
+    
     private Edition getEdition(final CreatePackageContext ctx) {
         if (null != ctx.EDITIONABLE()) {
             return Edition.EDITIONABLE;
@@ -913,7 +1007,9 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
     
     @Override
     public ASTNode visitAlterPackage(final AlterPackageContext ctx) {
-        return new AlterPackageStatement(getDatabaseType());
+        AlterPackageStatement result = new AlterPackageStatement(getDatabaseType());
+        result.setPackageName(createPackageNameSegment(ctx.packageName()));
+        return result;
     }
     
     @Override
@@ -943,7 +1039,9 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
     
     @Override
     public ASTNode visitDropTrigger(final DropTriggerContext ctx) {
-        return new DropTriggerStatement(getDatabaseType());
+        DropTriggerStatement result = new DropTriggerStatement(getDatabaseType());
+        result.setTriggerName(createTriggerNameSegment(ctx.triggerName()));
+        return result;
     }
     
     @Override
@@ -953,13 +1051,20 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
         getSqlStatementsInPlsql().sort(Comparator.comparingInt(SQLStatementSegment::getStartIndex));
         getProcedureCallNames().sort(Comparator.comparingInt(ProcedureCallNameSegment::getStartIndex));
         getDynamicSqlStatementExpressions().sort(Comparator.comparingInt(ExpressionSegment::getStartIndex));
+        getSqlStatementsInPlsql().forEach(each -> each.getSqlStatement().getVariableNames().addAll(getVariableNames()));
         CreateTriggerStatement result = new CreateTriggerStatement(getDatabaseType());
         result.setTriggerName(visitTriggerName(ctx.plsqlTriggerSource()));
         findTriggerTable(ctx.plsqlTriggerSource()).ifPresent(result::setTable);
+        TypeAttributeSegments typeAttributeSegments = extractTypeAttributeSegments(ctx.plsqlTriggerSource());
+        result.getTables().addAll(typeAttributeSegments.getTables());
+        result.getColumns().addAll(typeAttributeSegments.getColumns());
+        result.getTriggerPseudoColumns().addAll(extractTriggerPseudoColumns(ctx.plsqlTriggerSource()));
+        result.setDisableClauseStartIndex(findDisableClauseStartIndex(ctx.plsqlTriggerSource()));
         result.getSqlStatements().addAll(getSqlStatementsInPlsql());
         result.getProcedureCallNames().addAll(getProcedureCallNames());
         result.getTriggerBodyEndNameSegments().addAll(getProcedureBodyEndNameSegments());
         result.getDynamicSqlStatementExpressions().addAll(getDynamicSqlStatementExpressions());
+        result.getCursorForLoopStatements().addAll(getCursorForLoopStatementSegments());
         return result;
     }
     
@@ -973,6 +1078,35 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
         return null == ctx.systemTrigger().tableName() ? Optional.empty() : Optional.of((SimpleTableSegment) visit(ctx.systemTrigger().tableName()));
     }
     
+    private Collection<ColumnSegment> extractTriggerPseudoColumns(final PlsqlTriggerSourceContext ctx) {
+        TriggerPseudoColumnExtractor extractor = new TriggerPseudoColumnExtractor();
+        extractor.visit(ctx);
+        return extractor.getResult();
+    }
+    
+    private int findDisableClauseStartIndex(final PlsqlTriggerSourceContext ctx) {
+        if (null != ctx.simpleDmlTrigger()) {
+            return findDisableClauseStartIndex(ctx.simpleDmlTrigger());
+        }
+        return null == ctx.compoundDmlTrigger() ? -1 : findDisableClauseStartIndex(ctx.compoundDmlTrigger());
+    }
+    
+    private int findDisableClauseStartIndex(final SimpleDmlTriggerContext ctx) {
+        if (null != ctx.ENABLE() || null != ctx.DISABLE()) {
+            return -1;
+        }
+        TriggerWhenClauseContext triggerWhenClause = ctx.triggerWhenClause();
+        return null == triggerWhenClause ? ctx.triggerBody().start.getStartIndex() : triggerWhenClause.start.getStartIndex();
+    }
+    
+    private int findDisableClauseStartIndex(final CompoundDmlTriggerContext ctx) {
+        if (null != ctx.ENABLE() || null != ctx.DISABLE()) {
+            return -1;
+        }
+        TriggerWhenClauseContext triggerWhenClause = ctx.triggerWhenClause();
+        return null == triggerWhenClause ? ctx.compoundTriggerBlock().start.getStartIndex() : triggerWhenClause.start.getStartIndex();
+    }
+    
     private void addTriggerBodyEndName(final PlsqlTriggerSourceContext ctx) {
         if (null != ctx.compoundDmlTrigger()) {
             TriggerNameContext triggerName = ctx.compoundDmlTrigger().compoundTriggerBlock().triggerName();
@@ -1005,6 +1139,17 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
         return result;
     }
     
+    private FunctionNameSegment createTriggerNameSegment(final TriggerNameContext ctx) {
+        IdentifierValue triggerName = (IdentifierValue) visit(ctx.name().identifier());
+        if (null == ctx.owner()) {
+            return new FunctionNameSegment(ctx.name().start.getStartIndex(), ctx.name().stop.getStopIndex(), triggerName);
+        }
+        OwnerSegment owner = new OwnerSegment(ctx.owner().start.getStartIndex(), ctx.owner().stop.getStopIndex(), (IdentifierValue) visit(ctx.owner().identifier()));
+        FunctionNameSegment result = new FunctionNameSegment(ctx.owner().start.getStartIndex(), ctx.name().stop.getStopIndex(), triggerName);
+        result.setOwner(owner);
+        return result;
+    }
+    
     private OwnerSegment getTriggerOwner(final PlsqlTriggerSourceContext ctx, final TriggerNameContext triggerNameContext) {
         if (null != ctx.schemaName()) {
             return new OwnerSegment(ctx.schemaName().start.getStartIndex(), ctx.schemaName().stop.getStopIndex(), (IdentifierValue) visit(ctx.schemaName().identifier()));
@@ -1017,7 +1162,9 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
     
     @Override
     public ASTNode visitAlterTrigger(final AlterTriggerContext ctx) {
-        return new AlterTriggerStatement(getDatabaseType());
+        AlterTriggerStatement result = new AlterTriggerStatement(getDatabaseType());
+        result.setTriggerName(createTriggerNameSegment(ctx.triggerName()));
+        return result;
     }
     
     @Override
@@ -1288,36 +1435,15 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
         getProcedureBodyEndNameSegments().sort(Comparator.comparingInt(ProcedureBodyEndNameSegment::getStartIndex));
         getDynamicSqlStatementExpressions().sort(Comparator.comparingInt(ExpressionSegment::getStartIndex));
         getSqlStatementsInPlsql().forEach(each -> each.getSqlStatement().getVariableNames().addAll(getVariableNames()));
-        return new OracleCreateFunctionStatement(
+        TypeAttributeSegments typeAttributeSegments = extractTypeAttributeSegments(ctx.plsqlFunctionSource());
+        OracleCreateFunctionStatement result = new OracleCreateFunctionStatement(
                 getDatabaseType(), getSqlStatementsInPlsql(), getProcedureCallNames(), getProcedureBodyEndNameSegments(), visitFunctionName(ctx.plsqlFunctionSource()),
-                extractTypeAttributeTables(ctx.plsqlFunctionSource()), getDynamicSqlStatementExpressions());
-    }
-    
-    private Collection<SimpleTableSegment> extractTypeAttributeTables(final PlsqlFunctionSourceContext ctx) {
-        Collection<SimpleTableSegment> result = new LinkedList<>();
-        for (ParameterDeclarationContext each : ctx.parameterDeclaration()) {
-            result.addAll(extractTypeAttributeTables(each.dataType()));
-        }
-        if (null != ctx.returnDateType()) {
-            result.addAll(extractTypeAttributeTables(ctx.returnDateType().dataType()));
-        }
+                typeAttributeSegments.getTables(), getDynamicSqlStatementExpressions());
+        result.getColumns().addAll(typeAttributeSegments.getColumns());
+        result.getCursorForLoopStatements().addAll(getCursorForLoopStatementSegments());
         return result;
     }
     
-    private Collection<SimpleTableSegment> extractTypeAttributeTables(final DataTypeContext ctx) {
-        ObjectNameContext objectName = null == ctx || null == ctx.typeAttribute() ? null : ctx.typeAttribute().objectName();
-        if (null == objectName || null == objectName.owner()) {
-            return Collections.emptyList();
-        }
-        return Collections.singleton(createTypeAttributeTable(objectName));
-    }
-    
-    private SimpleTableSegment createTypeAttributeTable(final ObjectNameContext ctx) {
-        OwnerContext tableName = ctx.owner();
-        return new SimpleTableSegment(new TableNameSegment(tableName.getStart().getStartIndex(), tableName.getStop().getStopIndex(),
-                (IdentifierValue) visit(tableName.identifier())));
-    }
-    
     private FunctionNameSegment visitFunctionName(final PlsqlFunctionSourceContext ctx) {
         OwnerContext schema = ctx.function().owner();
         IdentifierValue functionName = (IdentifierValue) visit(ctx.function().name().identifier());
@@ -1330,6 +1456,28 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
         return result;
     }
     
+    private FunctionNameSegment createFunctionNameSegment(final FunctionContext ctx) {
+        IdentifierValue functionName = (IdentifierValue) visit(ctx.name().identifier());
+        if (null == ctx.owner()) {
+            return new FunctionNameSegment(ctx.name().start.getStartIndex(), ctx.name().stop.getStopIndex(), functionName);
+        }
+        OwnerSegment owner = new OwnerSegment(ctx.owner().start.getStartIndex(), ctx.owner().stop.getStopIndex(), (IdentifierValue) visit(ctx.owner().identifier()));
+        FunctionNameSegment result = new FunctionNameSegment(ctx.owner().start.getStartIndex(), ctx.name().stop.getStopIndex(), functionName);
+        result.setOwner(owner);
+        return result;
+    }
+    
+    private FunctionNameSegment createFunctionNameSegment(final SchemaNameContext schemaName, final FunctionContext function) {
+        FunctionNameSegment result = createFunctionNameSegment(function);
+        if (null == schemaName) {
+            return result;
+        }
+        OwnerSegment owner = new OwnerSegment(schemaName.start.getStartIndex(), schemaName.stop.getStopIndex(), (IdentifierValue) visit(schemaName.identifier()));
+        FunctionNameSegment schemaQualifiedResult = new FunctionNameSegment(owner.getStartIndex(), result.getStopIndex(), result.getIdentifier());
+        schemaQualifiedResult.setOwner(owner);
+        return schemaQualifiedResult;
+    }
+    
     @Override
     public ASTNode visitDropEdition(final DropEditionContext ctx) {
         return new OracleDropEditionStatement(getDatabaseType());
@@ -1542,7 +1690,9 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
     
     @Override
     public ASTNode visitAlterFunction(final AlterFunctionContext ctx) {
-        return new AlterFunctionStatement(getDatabaseType());
+        AlterFunctionStatement result = new AlterFunctionStatement(getDatabaseType());
+        result.setFunctionName(createFunctionNameSegment(ctx.function()));
+        return result;
     }
     
     @Override
@@ -1584,7 +1734,11 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
         result.getProcedureCallNames().addAll(getProcedureCallNames());
         result.getProcedureBodyEndNameSegments().addAll(getProcedureBodyEndNameSegments());
         result.getDynamicSqlStatementExpressions().addAll(getDynamicSqlStatementExpressions());
+        TypeAttributeSegments typeAttributeSegments = extractTypeAttributeSegments(ctx.plsqlProcedureSource());
+        result.getTables().addAll(typeAttributeSegments.getTables());
+        result.getColumns().addAll(typeAttributeSegments.getColumns());
         result.setProcedureName(visitProcedureName(ctx.plsqlProcedureSource()));
+        result.setRoutineBody(createRoutineBodySegment(ctx.plsqlProcedureSource().body(), getSqlStatementsInPlsql()));
         result.getSqlStatements().addAll(getSqlStatementsInPlsql());
         result.getVariableNames().addAll(getVariableNames());
         getSqlStatementsInPlsql().forEach(each -> each.getSqlStatement().getVariableNames().addAll(getVariableNames()));
@@ -1592,6 +1746,19 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
         return result;
     }
     
+    private RoutineBodySegment createRoutineBodySegment(final BodyContext body, final Collection<SQLStatementSegment> sqlStatements) {
+        if (null == body) {
+            return null;
+        }
+        RoutineBodySegment result = new RoutineBodySegment(body.start.getStartIndex(), body.stop.getStopIndex());
+        for (SQLStatementSegment each : sqlStatements) {
+            ValidStatementSegment validStatement = new ValidStatementSegment(each.getStartIndex(), each.getStopIndex());
+            validStatement.setSqlStatement(each.getSqlStatement());
+            result.getValidStatements().add(validStatement);
+        }
+        return result;
+    }
+    
     @Override
     public ASTNode visitParameterDeclaration(final ParameterDeclarationContext ctx) {
         if (null != ctx.parameterName()) {
@@ -1927,7 +2094,8 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
                 visitPlsqlStatementList(each.plsqlStatements());
             }
         }
-        return new OraclePLSQLBlockStatement(getDatabaseType());
+        getProcedureCallNames().sort(Comparator.comparingInt(ProcedureCallNameSegment::getStartIndex));
+        return new OraclePLSQLBlockStatement(getDatabaseType(), getProcedureCallNames());
     }
     
     @Override
@@ -1966,7 +2134,9 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
     
     @Override
     public ASTNode visitDropFunction(final DropFunctionContext ctx) {
-        return new DropFunctionStatement(getDatabaseType());
+        DropFunctionStatement result = new DropFunctionStatement(getDatabaseType());
+        result.setFunctionName(createFunctionNameSegment(ctx.schemaName(), ctx.function()));
+        return result;
     }
     
     @Override
@@ -2066,4 +2236,130 @@ public final class OracleDDLStatementVisitor extends OracleStatementVisitor impl
     public ASTNode visitCreateOutline(final CreateOutlineContext ctx) {
         return new OracleCreateOutlineStatement(getDatabaseType());
     }
+    
+    private final class TypeAttributeExtractor extends OracleStatementBaseVisitor<Void> {
+        
+        private final TypeAttributeSegments result = new TypeAttributeSegments();
+        
+        @Override
+        public Void visitTypeAttribute(final TypeAttributeContext ctx) {
+            if (null != ctx.objectName() && null != ctx.objectName().owner()) {
+                result.getTables().add(createTypeAttributeTable(ctx.objectName()));
+                result.getColumns().add(createTypeAttributeColumn(ctx.objectName()));
+            }
+            return null;
+        }
+        
+        @Override
+        public Void visitRowtypeAttribute(final RowtypeAttributeContext ctx) {
+            if (null != ctx.objectName()) {
+                result.getTables().add(createRowtypeTable(ctx.objectName()));
+            }
+            return null;
+        }
+        
+        @Override
+        public Void visitRowtype(final RowtypeContext ctx) {
+            if (null != ctx.ROWTYPE()) {
+                result.getTables().add(createRowtypeTable(ctx.typeName()));
+            } else if (null != ctx.TYPE() && null != ctx.MOD_() && null != ctx.typeName().owner()) {
+                result.getTables().add(createTypeAttributeTable(ctx.typeName()));
+                result.getColumns().add(createTypeAttributeColumn(ctx.typeName()));
+            }
+            return null;
+        }
+        
+        @Override
+        public Void visitCollectionVariableDecl(final CollectionVariableDeclContext ctx) {
+            if (null != ctx.TYPE() && null != ctx.MOD_() && null != ctx.typeName().owner()) {
+                result.getTables().add(createTypeAttributeTable(ctx.typeName()));
+                result.getColumns().add(createTypeAttributeColumn(ctx.typeName()));
+            }
+            return super.visitCollectionVariableDecl(ctx);
+        }
+        
+        @Override
+        public Void visitRecordVariableDeclaration(final RecordVariableDeclarationContext ctx) {
+            if (null != ctx.TYPE() && null != ctx.MOD_() && null != ctx.typeName().owner()) {
+                result.getTables().add(createTypeAttributeTable(ctx.typeName()));
+                result.getColumns().add(createTypeAttributeColumn(ctx.typeName()));
+            }
+            return super.visitRecordVariableDeclaration(ctx);
+        }
+        
+        @Override
+        public Void visitRefCursorTypeDefinition(final RefCursorTypeDefinitionContext ctx) {
+            if (null != ctx.RETURN() && ctx.typeName().size() > 1) {
+                TypeNameContext returnTypeName = ctx.typeName(1);
+                if (null != ctx.ROWTYPE()) {
+                    result.getTables().add(createRowtypeTable(returnTypeName));
+                } else if (null != ctx.MOD_() && ctx.TYPE().size() > 1 && null != returnTypeName.owner()) {
+                    result.getTables().add(createTypeAttributeTable(returnTypeName));
+                    result.getColumns().add(createTypeAttributeColumn(returnTypeName));
+                }
+            }
+            return null;
+        }
+        
+        private TypeAttributeSegments getResult() {
+            return result;
+        }
+    }
+    
+    private final class TriggerPseudoColumnExtractor extends OracleStatementBaseVisitor<Void> {
+        
+        private final Collection<ColumnSegment> result = new LinkedList<>();
+        
+        @Override
+        public Void visitPseudorecord(final PseudorecordContext ctx) {
+            ASTNode astNode = OracleDDLStatementVisitor.this.visitPseudorecord(ctx);
+            if (astNode instanceof ColumnSegment) {
+                result.add((ColumnSegment) astNode);
+            }
+            return null;
+        }
+        
+        @Override
+        public Void visitPlaceholder(final PlaceholderContext ctx) {
+            if (isTriggerPseudoPlaceholder(ctx)) {
+                ColumnSegment columnSegment =
+                        new ColumnSegment(ctx.start.getStartIndex(), ctx.columnName().stop.getStopIndex(), (IdentifierValue) OracleDDLStatementVisitor.this.visit(ctx.columnName().name()));
+                columnSegment.setOwner(new OwnerSegment(ctx.hostVariable.start.getStartIndex(), ctx.hostVariable.stop.getStopIndex(), new IdentifierValue(ctx.hostVariable.getText())));
+                result.add(columnSegment);
+            }
+            return null;
+        }
+        
+        private boolean isTriggerPseudoPlaceholder(final PlaceholderContext ctx) {
+            if (null == ctx.columnName()) {
+                return false;
+            }
+            IdentifierValue hostVariable = new IdentifierValue(ctx.hostVariable.getText());
+            return "NEW".equalsIgnoreCase(hostVariable.getValue()) || "OLD".equalsIgnoreCase(hostVariable.getValue());
+        }
+        
+        private Collection<ColumnSegment> getResult() {
+            return result;
+        }
+    }
+    
+    private static final class TypeAttributeSegments {
+        
+        private final Collection<SimpleTableSegment> tables = new LinkedList<>();
+        
+        private final Collection<ColumnSegment> columns = new LinkedList<>();
+        
+        private void addAll(final TypeAttributeSegments segments) {
+            tables.addAll(segments.tables);
+            columns.addAll(segments.columns);
+        }
+        
+        private Collection<SimpleTableSegment> getTables() {
+            return tables;
+        }
+        
+        private Collection<ColumnSegment> getColumns() {
+            return columns;
+        }
+    }
 }
diff --git a/parser/sql/engine/dialect/oracle/src/test/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/type/OracleDDLStatementVisitorTest.java b/parser/sql/engine/dialect/oracle/src/test/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/type/OracleDDLStatementVisitorTest.java
index 226af9e7209..4262dee694a 100644
--- a/parser/sql/engine/dialect/oracle/src/test/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/type/OracleDDLStatementVisitorTest.java
+++ b/parser/sql/engine/dialect/oracle/src/test/java/org/apache/shardingsphere/sql/parser/engine/oracle/visitor/statement/type/OracleDDLStatementVisitorTest.java
@@ -20,12 +20,34 @@ package org.apache.shardingsphere.sql.parser.engine.oracle.visitor.statement.typ
 import org.apache.shardingsphere.sql.parser.engine.api.CacheOption;
 import org.apache.shardingsphere.sql.parser.engine.api.SQLParserEngine;
 import org.apache.shardingsphere.sql.parser.engine.api.SQLStatementVisitorEngine;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.ValidStatementSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.FunctionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.item.ExpressionProjectionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.ProcedureCallNameSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.TableSQLStatementAttribute;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.function.AlterFunctionStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.function.DropFunctionStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.pkg.AlterPackageStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.pkg.DropPackageStatement;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.table.CreateTableStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.trigger.AlterTriggerStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.trigger.CreateTriggerStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.trigger.DropTriggerStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.view.CreateViewStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.dml.InsertStatement;
+import org.apache.shardingsphere.sql.parser.statement.oracle.ddl.OraclePLSQLBlockStatement;
 import org.apache.shardingsphere.sql.parser.statement.oracle.ddl.pkg.OracleCreatePackageStatement;
 import org.apache.shardingsphere.sql.parser.statement.oracle.ddl.pkg.OracleCreatePackageStatement.Authorization;
 import org.apache.shardingsphere.sql.parser.statement.oracle.ddl.pkg.OracleCreatePackageStatement.Edition;
+import org.apache.shardingsphere.sql.parser.statement.oracle.ddl.procedure.OracleCreateProcedureStatement;
 import org.junit.jupiter.api.Test;
 
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -72,27 +94,50 @@ class OracleDDLStatementVisitorTest {
         assertTrue(actual.getSelectStatement().isPresent());
     }
     
+    @Test
+    void assertVisitCreateViewWithSchemaQualifiedPackageFunction() {
+        CreateViewStatement actual = (CreateViewStatement) parseStatement(
+                "CREATE OR REPLACE VIEW V_USER AS SELECT SYS.UTL_I18N.RAW_TO_CHAR(PASSWORD, 'AL32UTF8') AS PASSWORD FROM T_USER");
+        ExpressionProjectionSegment projection = (ExpressionProjectionSegment) actual.getSelect().getProjections().getProjections().iterator().next();
+        FunctionSegment function = (FunctionSegment) projection.getExpr();
+        assertThat(function.getFunctionName(), is("RAW_TO_CHAR"));
+        assertThat(function.getOwner().getIdentifier().getValue(), is("UTL_I18N"));
+        assertThat(function.getOwner().getOwner().get().getIdentifier().getValue(), is("SYS"));
+        assertThat(function.getParameters().size(), is(2));
+    }
+    
     @Test
     void assertVisitCreatePackage() {
         OracleCreatePackageStatement actual = parseCreatePackage(
-                "CREATE OR REPLACE EDITIONABLE PACKAGE IF NOT EXISTS foo_schema.foo_pkg AUTHID CURRENT_USER AS g_public NUMBER := 1; PROCEDURE set_value(p_value IN NUMBER); END foo_pkg;");
+                "CREATE OR REPLACE EDITIONABLE PACKAGE IF NOT EXISTS foo_schema.foo_pkg AUTHID CURRENT_USER AS g_public NUMBER := 1;"
+                        + " PROCEDURE set_value(p_value IN T_USER.USER_ID%TYPE); FUNCTION get_value RETURN T_USER.PASSWORD%TYPE; END foo_pkg;");
         assertThat(actual.getPackageName().getIdentifier().getValue(), is("foo_pkg"));
         assertThat(actual.getPackageName().getOwner().get().getIdentifier().getValue(), is("foo_schema"));
+        assertTrue(actual.getPackageEndName().isPresent());
+        assertThat(actual.getPackageEndName().get().getIdentifier().getValue(), is("foo_pkg"));
         assertFalse(actual.isBody());
         assertTrue(actual.isReplace());
         assertTrue(actual.isIfNotExists());
         assertThat(actual.getEdition().get(), is(Edition.EDITIONABLE));
         assertThat(actual.getAuthorization().get(), is(Authorization.CURRENT_USER));
         assertFalse(actual.getInitialization().isPresent());
+        Collection<SimpleTableSegment> tables = actual.getAttributes().getAttribute(TableSQLStatementAttribute.class).getTables();
+        assertThat(tables.size(), is(2));
+        Iterator<SimpleTableSegment> iterator = tables.iterator();
+        assertThat(iterator.next().getTableName().getIdentifier().getValue(), is("T_USER"));
+        assertThat(iterator.next().getTableName().getIdentifier().getValue(), is("T_USER"));
     }
     
     @Test
     void assertVisitCreatePackageBody() {
         OracleCreatePackageStatement actual = parseCreatePackage("CREATE OR REPLACE NONEDITIONABLE PACKAGE BODY foo_schema.foo_pkg AS"
-                + " PROCEDURE set_value(p_value IN NUMBER) AS BEGIN INSERT INTO t_order VALUES (p_value); END;"
+                + " PROCEDURE set_value(p_value IN T_USER.USER_ID%TYPE) AS BEGIN INSERT INTO t_order VALUES (p_value); END;"
+                + " FUNCTION read_value RETURN T_USER.PASSWORD%TYPE AS BEGIN RETURN NULL; END;"
                 + " BEGIN UPDATE t_order SET order_id = 1; END foo_pkg;");
         assertThat(actual.getPackageName().getIdentifier().getValue(), is("foo_pkg"));
         assertThat(actual.getPackageName().getOwner().get().getIdentifier().getValue(), is("foo_schema"));
+        assertTrue(actual.getPackageEndName().isPresent());
+        assertThat(actual.getPackageEndName().get().getIdentifier().getValue(), is("foo_pkg"));
         assertTrue(actual.isBody());
         assertTrue(actual.isReplace());
         assertFalse(actual.isIfNotExists());
@@ -100,6 +145,226 @@ class OracleDDLStatementVisitorTest {
         assertFalse(actual.getAuthorization().isPresent());
         assertTrue(actual.getInitialization().isPresent());
         assertThat(actual.getSqlStatements().size(), is(2));
+        Collection<SimpleTableSegment> tables = actual.getAttributes().getAttribute(TableSQLStatementAttribute.class).getTables();
+        assertThat(tables.size(), is(2));
+        Iterator<SimpleTableSegment> iterator = tables.iterator();
+        assertThat(iterator.next().getTableName().getIdentifier().getValue(), is("T_USER"));
+        assertThat(iterator.next().getTableName().getIdentifier().getValue(), is("T_USER"));
+    }
+    
+    @Test
+    void assertVisitAlterPackageWithOwner() {
+        AlterPackageStatement actual = (AlterPackageStatement) parseStatement("ALTER PACKAGE foo_schema.foo_pkg COMPILE");
+        assertTrue(actual.getPackageName().isPresent());
+        assertThat(actual.getPackageName().get().getIdentifier().getValue(), is("foo_pkg"));
+        assertThat(actual.getPackageName().get().getOwner().get().getIdentifier().getValue(), is("foo_schema"));
+    }
+    
+    @Test
+    void assertVisitDropPackageBodyWithOwner() {
+        DropPackageStatement actual = (DropPackageStatement) parseStatement("DROP PACKAGE BODY foo_schema.foo_pkg");
+        assertTrue(actual.getPackageName().isPresent());
+        assertThat(actual.getPackageName().get().getIdentifier().getValue(), is("foo_pkg"));
+        assertThat(actual.getPackageName().get().getOwner().get().getIdentifier().getValue(), is("foo_schema"));
+        assertTrue(actual.isBody());
+    }
+    
+    @Test
+    void assertVisitAlterFunctionWithOwner() {
+        AlterFunctionStatement actual = (AlterFunctionStatement) parseStatement("ALTER FUNCTION foo_schema.foo_func COMPILE");
+        assertTrue(actual.getFunctionName().isPresent());
+        assertThat(actual.getFunctionName().get().getIdentifier().getValue(), is("foo_func"));
+        assertThat(actual.getFunctionName().get().getOwner().get().getIdentifier().getValue(), is("foo_schema"));
+    }
+    
+    @Test
+    void assertVisitDropFunctionWithOwner() {
+        DropFunctionStatement actual = (DropFunctionStatement) parseStatement("DROP FUNCTION foo_schema.foo_func");
+        assertTrue(actual.getFunctionName().isPresent());
+        assertThat(actual.getFunctionName().get().getIdentifier().getValue(), is("foo_func"));
+        assertThat(actual.getFunctionName().get().getOwner().get().getIdentifier().getValue(), is("foo_schema"));
+    }
+    
+    @Test
+    void assertVisitAlterTriggerWithOwner() {
+        AlterTriggerStatement actual = (AlterTriggerStatement) parseStatement("ALTER TRIGGER foo_schema.foo_trigger DISABLE");
+        assertTrue(actual.getTriggerName().isPresent());
+        assertThat(actual.getTriggerName().get().getIdentifier().getValue(), is("foo_trigger"));
+        assertThat(actual.getTriggerName().get().getOwner().get().getIdentifier().getValue(), is("foo_schema"));
+    }
+    
+    @Test
+    void assertVisitDropTriggerWithOwner() {
+        DropTriggerStatement actual = (DropTriggerStatement) parseStatement("DROP TRIGGER foo_schema.foo_trigger");
+        assertTrue(actual.getTriggerName().isPresent());
+        assertThat(actual.getTriggerName().get().getIdentifier().getValue(), is("foo_trigger"));
+        assertThat(actual.getTriggerName().get().getOwner().get().getIdentifier().getValue(), is("foo_schema"));
+    }
+    
+    @Test
+    void assertVisitCreatePackageBodyWithProcedureTypeAttributes() {
+        String packagePrefix = "CREATE OR REPLACE PACKAGE BODY PKG_E2E_RDL_CONVERT AS";
+        String procedurePrefix = " PROCEDURE INSERT_ROW(P_ID IN ";
+        String idTypeAttribute = "T_E2E_RDL_CONVERT.ID%TYPE";
+        String statusPrefix = ", P_PASSWORD IN VARCHAR2, P_STATUS IN ";
+        String statusTypeAttribute = "T_E2E_RDL_CONVERT.STATUS%TYPE";
+        String procedureBody = ") IS BEGIN INSERT INTO T_E2E_RDL_CONVERT (ID, PASSWORD, STATUS) VALUES (P_ID, P_PASSWORD, P_STATUS); END INSERT_ROW;";
+        String functionPrefix = " FUNCTION READ_PASSWORD(P_ID IN ";
+        String functionBody = ") RETURN VARCHAR2 IS V_PASSWORD VARCHAR2(50);"
+                + " BEGIN SELECT PASSWORD INTO V_PASSWORD FROM T_E2E_RDL_CONVERT WHERE ID = P_ID; RETURN V_PASSWORD; END READ_PASSWORD; END PKG_E2E_RDL_CONVERT;";
+        String sql = packagePrefix + procedurePrefix + idTypeAttribute + statusPrefix + statusTypeAttribute + procedureBody + functionPrefix + idTypeAttribute + functionBody;
+        OracleCreatePackageStatement actual = parseCreatePackage(sql);
+        assertTrue(actual.isBody());
+        Collection<SimpleTableSegment> tables = actual.getAttributes().getAttribute(TableSQLStatementAttribute.class).getTables();
+        assertThat(tables.size(), is(3));
+        Iterator<SimpleTableSegment> iterator = tables.iterator();
+        int procedureIdTypeStartIndex = packagePrefix.length() + procedurePrefix.length();
+        assertTypeAttributeTable(iterator.next(), procedureIdTypeStartIndex);
+        int procedureStatusTypeStartIndex = procedureIdTypeStartIndex + idTypeAttribute.length() + statusPrefix.length();
+        assertTypeAttributeTable(iterator.next(), procedureStatusTypeStartIndex);
+        int functionIdTypeStartIndex = procedureStatusTypeStartIndex + statusTypeAttribute.length() + procedureBody.length() + functionPrefix.length();
+        assertTypeAttributeTable(iterator.next(), functionIdTypeStartIndex);
+        Collection<ColumnSegment> columns = actual.getColumns();
+        assertThat(columns.size(), is(3));
+        Iterator<ColumnSegment> columnIterator = columns.iterator();
+        procedureIdTypeStartIndex = packagePrefix.length() + procedurePrefix.length();
+        assertTypeAttributeColumn(columnIterator.next(), "ID", procedureIdTypeStartIndex);
+        procedureStatusTypeStartIndex = procedureIdTypeStartIndex + idTypeAttribute.length() + statusPrefix.length();
+        assertTypeAttributeColumn(columnIterator.next(), "STATUS", procedureStatusTypeStartIndex);
+        functionIdTypeStartIndex = procedureStatusTypeStartIndex + statusTypeAttribute.length() + procedureBody.length() + functionPrefix.length();
+        assertTypeAttributeColumn(columnIterator.next(), "ID", functionIdTypeStartIndex);
+    }
+    
+    @Test
+    void assertVisitCreateProcedureWithTypeAttributes() {
+        String procedurePrefix = "CREATE OR REPLACE PROCEDURE INSERT_ROW(P_ID IN ";
+        String idTypeAttribute = "T_E2E_RDL_CONVERT.ID%TYPE";
+        String statusPrefix = ", P_STATUS IN ";
+        String statusTypeAttribute = "T_E2E_RDL_CONVERT.STATUS%TYPE";
+        String sql = procedurePrefix + idTypeAttribute + statusPrefix + statusTypeAttribute
+                + ") IS BEGIN INSERT INTO T_E2E_RDL_CONVERT (ID, STATUS) VALUES (P_ID, P_STATUS); END INSERT_ROW;";
+        int idTypeStartIndex = procedurePrefix.length();
+        int statusTypeStartIndex = idTypeStartIndex + idTypeAttribute.length() + statusPrefix.length();
+        OracleCreateProcedureStatement actual = (OracleCreateProcedureStatement) parseStatement(sql);
+        Collection<SimpleTableSegment> tables = actual.getAttributes().getAttribute(TableSQLStatementAttribute.class).getTables();
+        assertThat(tables.size(), is(2));
+        Iterator<SimpleTableSegment> iterator = tables.iterator();
+        assertTypeAttributeTable(iterator.next(), idTypeStartIndex);
+        assertTypeAttributeTable(iterator.next(), statusTypeStartIndex);
+        Collection<ColumnSegment> columns = actual.getColumns();
+        assertThat(columns.size(), is(2));
+        Iterator<ColumnSegment> columnIterator = columns.iterator();
+        assertTypeAttributeColumn(columnIterator.next(), "ID", idTypeStartIndex);
+        assertTypeAttributeColumn(columnIterator.next(), "STATUS", statusTypeStartIndex);
+        assertTrue(actual.getRoutineBody().isPresent());
+        assertThat(actual.getRoutineBody().get().getValidStatements().size(), is(1));
+    }
+    
+    @Test
+    void assertVisitCreateProcedureWithDMLRoutineBodyTable() {
+        String sql = "CREATE OR REPLACE PROCEDURE P_E2E_RDL_SHOW_OBJECT(P_ID IN NUMBER, P_PASSWORD IN VARCHAR2) IS"
+                + " BEGIN INSERT INTO T_E2E_RDL_SHOW_OBJECT (ID, PASSWORD) VALUES (P_ID, P_PASSWORD); END;";
+        OracleCreateProcedureStatement actual = (OracleCreateProcedureStatement) parseStatement(sql);
+        assertTrue(actual.getRoutineBody().isPresent());
+        assertThat(actual.getRoutineBody().get().getValidStatements().size(), is(1));
+        SimpleTableSegment table = actual.getRoutineBody().get().getValidStatements().iterator().next().getInsert().get().getTable().get();
+        assertThat(table.getTableName().getIdentifier().getValue(), is("T_E2E_RDL_SHOW_OBJECT"));
+    }
+    
+    @Test
+    void assertVisitCreateProcedureWithInsertSelectRoutineBodyTable() {
+        String sql = "CREATE OR REPLACE PROCEDURE std_view_select_insert_user(var_user_id IN NUMBER, var_password IN VARCHAR2) IS"
+                + " BEGIN"
+                + " EXECUTE IMMEDIATE 'ALTER SESSION SET NLS_DATE_FORMAT = ''YYYY-MM-DD''';"
+                + " DELETE FROM t_user;"
+                + " INSERT INTO t_user (user_id, user_name, password, email, telephone, creation_date)"
+                + " VALUES (100, 'zhangsan', var_password, 'zhangsan@gmail.com', '12345678900', DATE '2017-08-08');"
+                + " INSERT INTO t_user (user_id, user_name, password, email, telephone, creation_date)"
+                + " SELECT var_user_id, user_name, password, email, telephone, creation_date FROM v_std_user_source WHERE user_id = 100;"
+                + " DELETE FROM t_user WHERE user_id = 100;"
+                + " END;";
+        OracleCreateProcedureStatement actual = (OracleCreateProcedureStatement) parseStatement(sql);
+        assertTrue(actual.getRoutineBody().isPresent());
+        assertThat(actual.getRoutineBody().get().getValidStatements().size(), is(4));
+        Iterator<ValidStatementSegment> statements = actual.getRoutineBody().get().getValidStatements().iterator();
+        assertThat(((SimpleTableSegment) statements.next().getDelete().get().getTable()).getTableName().getIdentifier().getValue(), is("t_user"));
+        assertThat(statements.next().getInsert().get().getTable().get().getTableName().getIdentifier().getValue(), is("t_user"));
+        InsertStatement insertSelectStatement = statements.next().getInsert().get();
+        assertThat(insertSelectStatement.getTable().get().getTableName().getIdentifier().getValue(), is("t_user"));
+        assertThat(((SimpleTableSegment) insertSelectStatement.getInsertSelect().get().getSelect().getFrom().get()).getTableName().getIdentifier().getValue(), is("v_std_user_source"));
+        assertThat(((SimpleTableSegment) statements.next().getDelete().get().getTable()).getTableName().getIdentifier().getValue(), is("t_user"));
+    }
+    
+    private void assertTypeAttributeTable(final SimpleTableSegment actual, final int expectedStartIndex) {
+        assertThat(actual.getTableName().getIdentifier().getValue(), is("T_E2E_RDL_CONVERT"));
+        assertThat(actual.getTableName().getStartIndex(), is(expectedStartIndex));
+        assertThat(actual.getTableName().getStopIndex(), is(expectedStartIndex + "T_E2E_RDL_CONVERT".length() - 1));
+    }
+    
+    private void assertTypeAttributeColumn(final ColumnSegment actual, final String expectedColumnName, final int expectedStartIndex) {
+        assertThat(actual.getIdentifier().getValue(), is(expectedColumnName));
+        assertThat(actual.getOwner().get().getIdentifier().getValue(), is("T_E2E_RDL_CONVERT"));
+        int expectedColumnStartIndex = expectedStartIndex + "T_E2E_RDL_CONVERT.".length();
+        assertThat(actual.getStartIndex(), is(expectedColumnStartIndex));
+        assertThat(actual.getStopIndex(), is(expectedColumnStartIndex + expectedColumnName.length() - 1));
+    }
+    
+    @Test
+    void assertVisitPLSQLBlockWithProcedureAndFunctionCalls() {
+        OraclePLSQLBlockStatement actual = parsePLSQLBlock("BEGIN simple_insert_data(1, 123); ignored := function_insert_data(1, 123); END;");
+        List<ProcedureCallNameSegment> procedureCallNames = actual.getProcedureCallNames();
+        assertThat(procedureCallNames.size(), is(2));
+        assertThat(procedureCallNames.get(0).getIdentifier().getValue(), is("simple_insert_data"));
+        assertThat(procedureCallNames.get(1).getIdentifier().getValue(), is("function_insert_data"));
+    }
+    
+    @Test
+    void assertVisitCreateTriggerWithDeclarationAndNewReferences() {
+        CreateTriggerStatement actual = parseCreateTrigger("/* SHARDINGSPHERE_HINT: TEST=TEST1 */ CREATE OR REPLACE TRIGGER trg_proc_trigger_data\n"
+                + "AFTER INSERT ON t_proc_trigger_source\n"
+                + "FOR EACH ROW\n"
+                + "DECLARE\n"
+                + "    new_sensitive INT;\n"
+                + "BEGIN\n"
+                + "    new_sensitive := :NEW.sensitive;\n"
+                + "    DELETE FROM t_proc_trigger_target WHERE id = :NEW.id;\n"
+                + "    INSERT INTO t_proc_trigger_target (id, sensitive) VALUES (:NEW.id, new_sensitive);\n"
+                + "END;");
+        assertThat(actual.getTriggerName().get().getIdentifier().getValue(), is("trg_proc_trigger_data"));
+        assertThat(actual.getTables().size(), is(1));
+        assertThat(actual.getTables().iterator().next().getTableName().getIdentifier().getValue(), is("t_proc_trigger_source"));
+        assertThat(actual.getSqlStatements().size(), is(2));
+    }
+    
+    @Test
+    void assertVisitCreateTriggerWithDisableClauseStartIndexAndPseudoColumns() {
+        String prefix = "CREATE OR REPLACE TRIGGER trg_proc_trigger_data AFTER INSERT ON t_proc_trigger_source FOR EACH ROW ";
+        String whenClause = "WHEN (:NEW.sensitive IS NOT NULL) ";
+        String bodyPrefix = "BEGIN ";
+        String assignment = ":NEW.sensitive := :OLD.sensitive; END;";
+        String sql = prefix + whenClause + bodyPrefix + assignment;
+        CreateTriggerStatement actual = parseCreateTrigger(sql);
+        assertThat(actual.getDisableClauseStartIndex(), is(prefix.length()));
+        assertThat(actual.getTriggerPseudoColumns().size(), is(3));
+        Iterator<ColumnSegment> iterator = actual.getTriggerPseudoColumns().iterator();
+        int firstNewStartIndex = prefix.length() + "WHEN (".length();
+        int secondNewStartIndex = prefix.length() + whenClause.length() + bodyPrefix.length();
+        assertTriggerPseudoColumn(iterator.next(), "NEW", "sensitive", firstNewStartIndex);
+        assertTriggerPseudoColumn(iterator.next(), "NEW", "sensitive", secondNewStartIndex);
+        assertTriggerPseudoColumn(iterator.next(), "OLD", "sensitive", secondNewStartIndex + ":NEW.sensitive := ".length());
+    }
+    
+    @Test
+    void assertVisitCreateTriggerWithoutDisableClauseStartIndexForExplicitState() {
+        CreateTriggerStatement actual = parseCreateTrigger("CREATE OR REPLACE TRIGGER trg_proc_trigger_data AFTER INSERT ON t_proc_trigger_source FOR EACH ROW DISABLE BEGIN NULL; END;");
+        assertThat(actual.getDisableClauseStartIndex(), is(-1));
+    }
+    
+    private void assertTriggerPseudoColumn(final ColumnSegment actual, final String expectedOwner, final String expectedColumn, final int expectedStartIndex) {
+        assertThat(actual.getOwner().get().getIdentifier().getValue(), is(expectedOwner));
+        assertThat(actual.getIdentifier().getValue(), is(expectedColumn));
+        assertThat(actual.getStartIndex(), is(expectedStartIndex));
+        assertThat(actual.getStopIndex(), is(expectedStartIndex + String.format(":%s.%s", expectedOwner, expectedColumn).length() - 1));
     }
     
     private CreateTableStatement parse(final String sql) {
@@ -110,6 +375,14 @@ class OracleDDLStatementVisitorTest {
         return (OracleCreatePackageStatement) parseStatement(sql);
     }
     
+    private OraclePLSQLBlockStatement parsePLSQLBlock(final String sql) {
+        return (OraclePLSQLBlockStatement) parseStatement(sql);
+    }
+    
+    private CreateTriggerStatement parseCreateTrigger(final String sql) {
+        return (CreateTriggerStatement) parseStatement(sql);
+    }
+    
     private Object parseStatement(final String sql) {
         return new SQLStatementVisitorEngine("Oracle").visit(new SQLParserEngine("Oracle", CACHE_OPTION).parse(sql, false));
     }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/AlterFunctionStatement.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/attribute/type/ProcedureCallNamesSQLStatementAttribute.java
similarity index 65%
copy from parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/AlterFunctionStatement.java
copy to parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/attribute/type/ProcedureCallNamesSQLStatementAttribute.java
index 505e3cbcc82..a782d75a7a4 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/AlterFunctionStatement.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/attribute/type/ProcedureCallNamesSQLStatementAttribute.java
@@ -15,17 +15,21 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.function;
+package org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type;
 
-import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
-import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.ProcedureCallNameSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.SQLStatementAttribute;
+
+import java.util.Collection;
 
 /**
- * Alter function statement.
+ * Procedure call names SQL statement attribute.
  */
-public final class AlterFunctionStatement extends DDLStatement {
+@RequiredArgsConstructor
+@Getter
+public final class ProcedureCallNamesSQLStatementAttribute implements SQLStatementAttribute {
     
-    public AlterFunctionStatement(final DatabaseType databaseType) {
-        super(databaseType);
-    }
+    private final Collection<ProcedureCallNameSegment> procedureCallNames;
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/AlterFunctionStatement.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/AlterFunctionStatement.java
index 505e3cbcc82..161a86fdd48 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/AlterFunctionStatement.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/AlterFunctionStatement.java
@@ -17,15 +17,31 @@
 
 package org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.function;
 
+import lombok.Setter;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.FunctionNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
+import java.util.Optional;
+
 /**
  * Alter function statement.
  */
+@Setter
 public final class AlterFunctionStatement extends DDLStatement {
     
+    private FunctionNameSegment functionName;
+    
     public AlterFunctionStatement(final DatabaseType databaseType) {
         super(databaseType);
     }
+    
+    /**
+     * Get function name segment.
+     *
+     * @return function name segment
+     */
+    public Optional<FunctionNameSegment> getFunctionName() {
+        return Optional.ofNullable(functionName);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/CreateFunctionStatement.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/CreateFunctionStatement.java
index fe8888e9f20..7e90d36ee60 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/CreateFunctionStatement.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/CreateFunctionStatement.java
@@ -22,15 +22,19 @@ import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
 import org.apache.shardingsphere.sql.parser.statement.core.extractor.TableExtractor;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.FunctionNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.RoutineBodySegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.CursorForLoopStatementSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.ProcedureBodyEndNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.ProcedureCallNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.SQLStatementSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.SQLStatementAttributes;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.ProcedureCallNamesSQLStatementAttribute;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.TableSQLStatementAttribute;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.LinkedList;
@@ -55,6 +59,10 @@ public class CreateFunctionStatement extends DDLStatement {
     
     private final List<ExpressionSegment> dynamicSqlStatementExpressions;
     
+    private final List<CursorForLoopStatementSegment> cursorForLoopStatements = new ArrayList<>();
+    
+    private final Collection<ColumnSegment> columns = new LinkedList<>();
+    
     private final SQLStatementAttributes attributes;
     
     public CreateFunctionStatement(final DatabaseType databaseType,
@@ -66,7 +74,8 @@ public class CreateFunctionStatement extends DDLStatement {
         procedureCallNames = Collections.emptyList();
         functionBodyEndNameSegments = Collections.emptyList();
         this.dynamicSqlStatementExpressions = dynamicSqlStatementExpressions;
-        attributes = new SQLStatementAttributes(new TableSQLStatementAttribute(getTables(routineBody, Collections.emptyList())));
+        attributes = new SQLStatementAttributes(new TableSQLStatementAttribute(getTables(routineBody, Collections.emptyList())),
+                new ProcedureCallNamesSQLStatementAttribute(procedureCallNames));
     }
     
     public CreateFunctionStatement(final DatabaseType databaseType, final FunctionNameSegment functionName, final RoutineBodySegment routineBody,
@@ -79,7 +88,8 @@ public class CreateFunctionStatement extends DDLStatement {
         this.procedureCallNames = procedureCallNames;
         this.functionBodyEndNameSegments = functionBodyEndNameSegments;
         this.dynamicSqlStatementExpressions = dynamicSqlStatementExpressions;
-        attributes = new SQLStatementAttributes(new TableSQLStatementAttribute(getTables(routineBody, Collections.emptyList())));
+        attributes = new SQLStatementAttributes(new TableSQLStatementAttribute(getTables(routineBody, Collections.emptyList())),
+                new ProcedureCallNamesSQLStatementAttribute(procedureCallNames));
     }
     
     public CreateFunctionStatement(final DatabaseType databaseType, final FunctionNameSegment functionName, final RoutineBodySegment routineBody,
@@ -93,7 +103,7 @@ public class CreateFunctionStatement extends DDLStatement {
         this.procedureCallNames = procedureCallNames;
         this.functionBodyEndNameSegments = functionBodyEndNameSegments;
         this.dynamicSqlStatementExpressions = dynamicSqlStatementExpressions;
-        attributes = new SQLStatementAttributes(new TableSQLStatementAttribute(getTables(routineBody, tables)));
+        attributes = new SQLStatementAttributes(new TableSQLStatementAttribute(getTables(routineBody, tables)), new ProcedureCallNamesSQLStatementAttribute(procedureCallNames));
     }
     
     private Collection<SimpleTableSegment> getTables(final RoutineBodySegment routineBody, final Collection<SimpleTableSegment> tables) {
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/DropFunctionStatement.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/DropFunctionStatement.java
index 52e0b592b2a..83cb9212b79 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/DropFunctionStatement.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/function/DropFunctionStatement.java
@@ -17,15 +17,31 @@
 
 package org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.function;
 
+import lombok.Setter;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.FunctionNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
+import java.util.Optional;
+
 /**
  * Drop function statement.
  */
+@Setter
 public final class DropFunctionStatement extends DDLStatement {
     
+    private FunctionNameSegment functionName;
+    
     public DropFunctionStatement(final DatabaseType databaseType) {
         super(databaseType);
     }
+    
+    /**
+     * Get function name segment.
+     *
+     * @return function name segment
+     */
+    public Optional<FunctionNameSegment> getFunctionName() {
+        return Optional.ofNullable(functionName);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/pkg/AlterPackageStatement.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/pkg/AlterPackageStatement.java
index 56e3236bf21..a0136ffbf79 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/pkg/AlterPackageStatement.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/pkg/AlterPackageStatement.java
@@ -17,15 +17,31 @@
 
 package org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.pkg;
 
+import lombok.Setter;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.packages.PackageSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
+import java.util.Optional;
+
 /**
  * Alter package statement.
  */
+@Setter
 public final class AlterPackageStatement extends DDLStatement {
     
+    private PackageSegment packageName;
+    
     public AlterPackageStatement(final DatabaseType databaseType) {
         super(databaseType);
     }
+    
+    /**
+     * Get package name segment.
+     *
+     * @return package name segment
+     */
+    public Optional<PackageSegment> getPackageName() {
+        return Optional.ofNullable(packageName);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/pkg/CreatePackageStatement.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/pkg/CreatePackageStatement.java
new file mode 100644
index 00000000000..faf0230f156
--- /dev/null
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/pkg/CreatePackageStatement.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.pkg;
+
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.packages.PackageSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.ProcedureCallNameSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.SQLStatementSegment;
+
+import java.util.Collection;
+import java.util.Optional;
+
+/**
+ * Create package statement.
+ */
+public interface CreatePackageStatement {
+    
+    /**
+     * Get package name segment.
+     *
+     * @return package name segment
+     */
+    PackageSegment getPackageName();
+    
+    /**
+     * Judge whether package body is created.
+     *
+     * @return package body or not
+     */
+    boolean isBody();
+    
+    /**
+     * Get package end name segment.
+     *
+     * @return package end name segment
+     */
+    Optional<PackageSegment> getPackageEndName();
+    
+    /**
+     * Get SQL statements in package body.
+     *
+     * @return SQL statements in package body
+     */
+    Collection<SQLStatementSegment> getSqlStatements();
+    
+    /**
+     * Get columns referenced by package declaration types.
+     *
+     * @return columns referenced by package declaration types
+     */
+    Collection<ColumnSegment> getColumns();
+    
+    /**
+     * Get procedure call names.
+     *
+     * @return procedure call names
+     */
+    Collection<ProcedureCallNameSegment> getProcedureCallNames();
+    
+    /**
+     * Get dynamic SQL statement expressions.
+     *
+     * @return dynamic SQL statement expressions
+     */
+    Collection<ExpressionSegment> getDynamicSqlStatementExpressions();
+}
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/pkg/DropPackageStatement.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/pkg/DropPackageStatement.java
index 8024e57483b..15f793146ec 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/pkg/DropPackageStatement.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/pkg/DropPackageStatement.java
@@ -17,15 +17,35 @@
 
 package org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.pkg;
 
+import lombok.Getter;
+import lombok.Setter;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.packages.PackageSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
+import java.util.Optional;
+
 /**
  * Drop package statement.
  */
+@Setter
 public final class DropPackageStatement extends DDLStatement {
     
+    private PackageSegment packageName;
+    
+    @Getter
+    private boolean body;
+    
     public DropPackageStatement(final DatabaseType databaseType) {
         super(databaseType);
     }
+    
+    /**
+     * Get package name segment.
+     *
+     * @return package name segment
+     */
+    public Optional<PackageSegment> getPackageName() {
+        return Optional.ofNullable(packageName);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/procedure/CreateProcedureStatement.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/procedure/CreateProcedureStatement.java
index a82eff39818..bd3d21f5be4 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/procedure/CreateProcedureStatement.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/procedure/CreateProcedureStatement.java
@@ -22,13 +22,20 @@ import lombok.Setter;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.FunctionNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.RoutineBodySegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.ProcedureBodyEndNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.ProcedureCallNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.SQLStatementSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.SQLStatementAttributes;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.ProcedureCallNamesSQLStatementAttribute;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.TableSQLStatementAttribute;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Optional;
 
@@ -51,6 +58,12 @@ public class CreateProcedureStatement extends DDLStatement {
     
     private final List<ExpressionSegment> dynamicSqlStatementExpressions = new ArrayList<>();
     
+    private final Collection<SimpleTableSegment> tables = new LinkedList<>();
+    
+    private final Collection<ColumnSegment> columns = new LinkedList<>();
+    
+    private final SQLStatementAttributes attributes = new SQLStatementAttributes(new TableSQLStatementAttribute(tables), new ProcedureCallNamesSQLStatementAttribute(procedureCallNames));
+    
     public CreateProcedureStatement(final DatabaseType databaseType) {
         super(databaseType);
     }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/trigger/AlterTriggerStatement.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/trigger/AlterTriggerStatement.java
index 85f882fec37..1ecd527f79d 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/trigger/AlterTriggerStatement.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/trigger/AlterTriggerStatement.java
@@ -17,15 +17,31 @@
 
 package org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.trigger;
 
+import lombok.Setter;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.FunctionNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
+import java.util.Optional;
+
 /**
  * Alter trigger statement.
  */
+@Setter
 public final class AlterTriggerStatement extends DDLStatement {
     
+    private FunctionNameSegment triggerName;
+    
     public AlterTriggerStatement(final DatabaseType databaseType) {
         super(databaseType);
     }
+    
+    /**
+     * Get trigger name segment.
+     *
+     * @return trigger name segment
+     */
+    public Optional<FunctionNameSegment> getTriggerName() {
+        return Optional.ofNullable(triggerName);
+    }
 }
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/trigger/CreateTriggerStatement.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/trigger/CreateTriggerStatement.java
index 7b1a8dabe6c..4a3b6a5f132 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/trigger/CreateTriggerStatement.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/trigger/CreateTriggerStatement.java
@@ -21,12 +21,15 @@ import lombok.Getter;
 import lombok.Setter;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.FunctionNameSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.CursorForLoopStatementSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.ProcedureBodyEndNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.ProcedureCallNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.SQLStatementSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.SQLStatementAttributes;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.ProcedureCallNamesSQLStatementAttribute;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.TableSQLStatementAttribute;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
@@ -53,9 +56,17 @@ public final class CreateTriggerStatement extends DDLStatement {
     
     private final List<ExpressionSegment> dynamicSqlStatementExpressions = new ArrayList<>();
     
+    private final List<CursorForLoopStatementSegment> cursorForLoopStatements = new ArrayList<>();
+    
     private final Collection<SimpleTableSegment> tables = new LinkedList<>();
     
-    private final SQLStatementAttributes attributes = new SQLStatementAttributes(new TableSQLStatementAttribute(tables));
+    private final Collection<ColumnSegment> columns = new LinkedList<>();
+    
+    private final Collection<ColumnSegment> triggerPseudoColumns = new LinkedList<>();
+    
+    private int disableClauseStartIndex = -1;
+    
+    private final SQLStatementAttributes attributes = new SQLStatementAttributes(new TableSQLStatementAttribute(tables), new ProcedureCallNamesSQLStatementAttribute(procedureCallNames));
     
     public CreateTriggerStatement(final DatabaseType databaseType) {
         super(databaseType);
diff --git a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/trigger/DropTriggerStatement.java b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/trigger/DropTriggerStatement.java
index 5c7261a269e..164e3d01d6c 100644
--- a/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/trigger/DropTriggerStatement.java
+++ b/parser/sql/statement/core/src/main/java/org/apache/shardingsphere/sql/parser/statement/core/statement/type/ddl/trigger/DropTriggerStatement.java
@@ -17,15 +17,31 @@
 
 package org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.trigger;
 
+import lombok.Setter;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.FunctionNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
+import java.util.Optional;
+
 /**
  * Drop trigger statement.
  */
+@Setter
 public final class DropTriggerStatement extends DDLStatement {
     
+    private FunctionNameSegment triggerName;
+    
     public DropTriggerStatement(final DatabaseType databaseType) {
         super(databaseType);
     }
+    
+    /**
+     * Get trigger name segment.
+     *
+     * @return trigger name segment
+     */
+    public Optional<FunctionNameSegment> getTriggerName() {
+        return Optional.ofNullable(triggerName);
+    }
 }
diff --git a/parser/sql/statement/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/statement/oracle/ddl/OraclePLSQLBlockStatement.java b/parser/sql/statement/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/statement/oracle/ddl/OraclePLSQLBlockStatement.java
index 2ce3fb9793b..922a4cfc7b3 100644
--- a/parser/sql/statement/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/statement/oracle/ddl/OraclePLSQLBlockStatement.java
+++ b/parser/sql/statement/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/statement/oracle/ddl/OraclePLSQLBlockStatement.java
@@ -17,15 +17,28 @@
 
 package org.apache.shardingsphere.sql.parser.statement.oracle.ddl;
 
+import lombok.Getter;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.ProcedureCallNameSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.SQLStatementAttributes;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.ProcedureCallNamesSQLStatementAttribute;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
 
+import java.util.List;
+
 /**
  * PLSQL block statement for Oracle.
  */
+@Getter
 public final class OraclePLSQLBlockStatement extends DDLStatement {
     
-    public OraclePLSQLBlockStatement(final DatabaseType databaseType) {
+    private final List<ProcedureCallNameSegment> procedureCallNames;
+    
+    private final SQLStatementAttributes attributes;
+    
+    public OraclePLSQLBlockStatement(final DatabaseType databaseType, final List<ProcedureCallNameSegment> procedureCallNames) {
         super(databaseType);
+        this.procedureCallNames = procedureCallNames;
+        attributes = new SQLStatementAttributes(new ProcedureCallNamesSQLStatementAttribute(procedureCallNames));
     }
 }
diff --git a/parser/sql/statement/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/statement/oracle/ddl/pkg/OracleCreatePackageStatement.java b/parser/sql/statement/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/statement/oracle/ddl/pkg/OracleCreatePackageStatement.java
index 7ce313184fc..b41548bae29 100644
--- a/parser/sql/statement/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/statement/oracle/ddl/pkg/OracleCreatePackageStatement.java
+++ b/parser/sql/statement/dialect/oracle/src/main/java/org/apache/shardingsphere/sql/parser/statement/oracle/ddl/pkg/OracleCreatePackageStatement.java
@@ -21,12 +21,20 @@ import lombok.Getter;
 import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.packages.PackageSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.ddl.routine.RoutineBodySegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExpressionSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.table.SimpleTableSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.CursorForLoopStatementSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.ProcedureCallNameSegment;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.procedure.SQLStatementSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.SQLStatementAttributes;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.ProcedureCallNamesSQLStatementAttribute;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.attribute.type.TableSQLStatementAttribute;
 import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.DDLStatement;
+import org.apache.shardingsphere.sql.parser.statement.core.statement.type.ddl.pkg.CreatePackageStatement;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Optional;
 
@@ -34,10 +42,12 @@ import java.util.Optional;
  * Create package statement for Oracle.
  */
 @Getter
-public final class OracleCreatePackageStatement extends DDLStatement {
+public final class OracleCreatePackageStatement extends DDLStatement implements CreatePackageStatement {
     
     private final PackageSegment packageName;
     
+    private final Optional<PackageSegment> packageEndName;
+    
     private final boolean body;
     
     private final boolean replace;
@@ -56,28 +66,39 @@ public final class OracleCreatePackageStatement extends DDLStatement {
     
     private final List<ExpressionSegment> dynamicSqlStatementExpressions = new ArrayList<>();
     
+    private final List<CursorForLoopStatementSegment> cursorForLoopStatements = new ArrayList<>();
+    
+    private final Collection<ColumnSegment> columns = new ArrayList<>();
+    
+    private final SQLStatementAttributes attributes;
+    
     /**
      * Construct an Oracle create package statement.
      *
      * @param databaseType database type
      * @param packageName package name
+     * @param packageEndName package end name, or {@code null} when absent
      * @param body whether this statement creates a package body
      * @param replace whether existing package should be replaced
      * @param ifNotExists whether creation should be skipped when the package exists
      * @param edition edition mode, or {@code null} when unspecified
      * @param authorization authorization mode, or {@code null} when unspecified
      * @param initialization package initialization body, or {@code null} when absent
+     * @param tables tables referenced by package declaration types
      */
-    public OracleCreatePackageStatement(final DatabaseType databaseType, final PackageSegment packageName, final boolean body, final boolean replace,
-                                        final boolean ifNotExists, final Edition edition, final Authorization authorization, final RoutineBodySegment initialization) {
+    public OracleCreatePackageStatement(final DatabaseType databaseType, final PackageSegment packageName, final PackageSegment packageEndName,
+                                        final boolean body, final boolean replace, final boolean ifNotExists, final Edition edition, final Authorization authorization,
+                                        final RoutineBodySegment initialization, final Collection<SimpleTableSegment> tables) {
         super(databaseType);
         this.packageName = packageName;
+        this.packageEndName = Optional.ofNullable(packageEndName);
         this.body = body;
         this.replace = replace;
         this.ifNotExists = ifNotExists;
         this.edition = Optional.ofNullable(edition);
         this.authorization = Optional.ofNullable(authorization);
         this.initialization = Optional.ofNullable(initialization);
+        attributes = new SQLStatementAttributes(new TableSQLStatementAttribute(tables), new ProcedureCallNamesSQLStatementAttribute(procedureCallNames));
     }
     
     /**
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/ddl/dialect/oracle/type/OracleCreatePackageStatementAssert.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/ddl/dialect/oracle/type/OracleCreatePackageStatementAssert.java
index 76bdd1892a0..f1f84e4a260 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/ddl/dialect/oracle/type/OracleCreatePackageStatementAssert.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/asserts/statement/ddl/dialect/oracle/type/OracleCreatePackageStatementAssert.java
@@ -26,6 +26,8 @@ import org.apache.shardingsphere.test.it.sql.parser.internal.cases.parser.jaxb.s
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Create package statement assert for Oracle.
@@ -42,6 +44,12 @@ public final class OracleCreatePackageStatementAssert {
      */
     public static void assertIs(final SQLCaseAssertContext assertContext, final OracleCreatePackageStatement actual, final OracleCreatePackageStatementTestCase expected) {
         PackageAssert.assertIs(assertContext, actual.getPackageName(), expected.getPackageName());
+        if (null == expected.getPackageEndName()) {
+            assertFalse(actual.getPackageEndName().isPresent(), assertContext.getText("Actual package end name should not exist."));
+        } else {
+            assertTrue(actual.getPackageEndName().isPresent(), assertContext.getText("Actual package end name should exist."));
+            PackageAssert.assertIs(assertContext, actual.getPackageEndName().get(), expected.getPackageEndName());
+        }
         assertThat(assertContext.getText("Package body assertion error: "), actual.isBody(), is(expected.isBody()));
         assertThat(assertContext.getText("Package replacement assertion error: "), actual.isReplace(), is(expected.isReplace()));
         assertThat(assertContext.getText("Package IF NOT EXISTS assertion error: "), actual.isIfNotExists(), is(expected.isIfNotExists()));
diff --git a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/oracle/OracleCreatePackageStatementTestCase.java b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/oracle/OracleCreatePackageStatementTestCase.java
index 187056b29eb..3613133e6fe 100644
--- a/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/oracle/OracleCreatePackageStatementTestCase.java
+++ b/test/it/parser/src/main/java/org/apache/shardingsphere/test/it/sql/parser/internal/cases/parser/jaxb/statement/ddl/dialect/oracle/OracleCreatePackageStatementTestCase.java
@@ -35,6 +35,9 @@ public final class OracleCreatePackageStatementTestCase extends SQLParserTestCas
     @XmlElement(name = "package")
     private ExpectedPackage packageName;
     
+    @XmlElement(name = "package-end-name")
+    private ExpectedPackage packageEndName;
+    
     @XmlAttribute
     private boolean body;
     
diff --git a/test/it/parser/src/main/resources/case/ddl/create-package.xml b/test/it/parser/src/main/resources/case/ddl/create-package.xml
index b2832f53512..228cdd24534 100644
--- a/test/it/parser/src/main/resources/case/ddl/create-package.xml
+++ b/test/it/parser/src/main/resources/case/ddl/create-package.xml
@@ -21,15 +21,18 @@
         <package name="foo_pkg" start-index="49" stop-index="55">
             <owner name="foo_schema" start-index="38" stop-index="47" />
         </package>
+        <package-end-name name="foo_pkg" start-index="180" stop-index="186" />
     </create-package>
     
     <create-package sql-case-id="create_or_replace_noneditionable_package_body" body="true" replace="true" edition="NONEDITIONABLE" has-initialization="true">
         <package name="foo_pkg" start-index="57" stop-index="63">
             <owner name="foo_schema" start-index="46" stop-index="55" />
         </package>
+        <package-end-name name="foo_pkg" start-index="257" stop-index="263" />
     </create-package>
     
     <create-package sql-case-id="create_package_body_if_not_exists" body="true" if-not-exists="true">
         <package name="foo_pkg" start-index="34" stop-index="40" />
+        <package-end-name name="foo_pkg" start-index="81" stop-index="87" />
     </create-package>
 </sql-parser-test-cases>
diff --git a/test/it/parser/src/main/resources/case/plsql/create-procedure.xml b/test/it/parser/src/main/resources/case/plsql/create-procedure.xml
index 22c26866062..841ddc38f9c 100644
--- a/test/it/parser/src/main/resources/case/plsql/create-procedure.xml
+++ b/test/it/parser/src/main/resources/case/plsql/create-procedure.xml
@@ -27,6 +27,22 @@
             <sql-statement start-index="1403" stop-index="1445" statement-class-simple-name="RollbackStatement" />
         </sql-statements>
         <procedure-calls>
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
             <procedure-call name="DBMS_OUTPUT.PUT_LINE" />
             <procedure-call name="DBMS_OUTPUT.PUT_LINE" />
         </procedure-calls>
@@ -44,6 +60,22 @@
             <sql-statement start-index="1403" stop-index="1445" statement-class-simple-name="RollbackStatement" />
         </sql-statements>
         <procedure-calls>
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
+            <procedure-call name="TRUNC" />
             <procedure-call name="DBMS_OUTPUT.PUT_LINE" />
             <procedure-call name="DBMS_OUTPUT.PUT_LINE" />
         </procedure-calls>