From 6bb8c299971ae45ba492dd5bb1cad5a717b79251 Mon Sep 17 00:00:00 2001 From: wenshao Date: Tue, 21 Jun 2011 15:53:20 +0000 Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0SQL=E7=BB=9F=E8=AE=A1?= =?UTF-8?q?=E5=8A=9F=E8=83=BD=EF=BC=8C=E7=BB=9F=E8=AE=A1SQL=E4=B8=AD?= =?UTF-8?q?=E6=89=80=E4=BD=BF=E7=94=A8=E7=9A=84=E8=A1=A8=E5=92=8C=E5=AD=97?= =?UTF-8?q?=E6=AE=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit git-svn-id: http://code.alibabatech.com/svn/druid/trunk@270 b9813039-fb51-4c41-a8b9-e21c2acb5095 --- .../ast/stmt/OracleInsertStatement.java | 24 - .../ast/visitor/OracleASTVIsitorAdapter.java | 871 ++++++++++++++++++ .../ast/visitor/OracleSchemaStatVisitor.java | 272 ++++++ 3 files changed, 1143 insertions(+), 24 deletions(-) delete mode 100644 src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/stmt/OracleInsertStatement.java create mode 100644 src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/visitor/OracleASTVIsitorAdapter.java create mode 100644 src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/visitor/OracleSchemaStatVisitor.java diff --git a/src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/stmt/OracleInsertStatement.java b/src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/stmt/OracleInsertStatement.java deleted file mode 100644 index 649c8991c7..0000000000 --- a/src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/stmt/OracleInsertStatement.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright 1999-2011 Alibaba Group Holding Ltd. - * - * Licensed 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 com.alibaba.druid.sql.dialect.oracle.ast.stmt; - -import com.alibaba.druid.sql.ast.statement.SQLInsertStatement; - -public class OracleInsertStatement extends SQLInsertStatement { - private static final long serialVersionUID = 1L; - - -} diff --git a/src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/visitor/OracleASTVIsitorAdapter.java b/src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/visitor/OracleASTVIsitorAdapter.java new file mode 100644 index 0000000000..f87bc1e6ea --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/visitor/OracleASTVIsitorAdapter.java @@ -0,0 +1,871 @@ +package com.alibaba.druid.sql.dialect.oracle.ast.visitor; + +import com.alibaba.druid.sql.ast.expr.SQLObjectCreateExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.OracleDataTypeInterval; +import com.alibaba.druid.sql.dialect.oracle.ast.OracleHint; +import com.alibaba.druid.sql.dialect.oracle.ast.OracleOrderBy; +import com.alibaba.druid.sql.dialect.oracle.ast.clause.CycleClause; +import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.AsOfFlashbackQueryClause; +import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.VersionsFlashbackQueryClause; +import com.alibaba.druid.sql.dialect.oracle.ast.clause.GroupingSetExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.clause.PartitionExtensionClause; +import com.alibaba.druid.sql.dialect.oracle.ast.clause.SampleClause; +import com.alibaba.druid.sql.dialect.oracle.ast.clause.SearchClause; +import com.alibaba.druid.sql.dialect.oracle.ast.clause.SubqueryFactoringClause; +import com.alibaba.druid.sql.dialect.oracle.ast.clause.SubqueryFactoringClause.Entry; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAggregateExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAnalytic; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAnalyticWindowing; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleArrayAccessExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleBinaryDoubleExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleBinaryFloatExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDateExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDbLinkExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleExtractExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleGroupComparisonCondition; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleGroupingSetsExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleIntervalExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleOuterExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OraclePriorExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleTableCollectionExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleTimestampExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.AddColumnClause; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.AddConstraint; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.DeallocateClause; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.DropColumn; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.EnableClause; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.EnableTrigger; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.ModifyCollectionRetrieval; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.ModifyColumnClause; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.ModifyConstaint; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.NoParallelClause; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.ParallelClause; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.RenameColumn; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement.RenameConstaint; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCheck; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintNull; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateViewStatement; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleForeignKey; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleOrderByItem; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OraclePLSQLCommitStatement; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OraclePrimaryKey; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleRefDataType; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleReferencesConstaint; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectForUpdate; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectHierachicalQueryClause; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectJoin; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectPivot; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectPivot.Item; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectRestriction.CheckOption; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectRestriction.ReadOnly; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectSubqueryTableSource; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectTableReference; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectUnPivot; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleTableColumn; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleTableExpr; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleTableTypeDef; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleUpdateSetListClause; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleUpdateSetListMultiColumnItem; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleUpdateSetListSingleColumnItem; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleUpdateSetValueClause; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleUpdateStatement; +import com.alibaba.druid.sql.visitor.SQLASTVisitorAdapter; + +public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements OracleASTVisitor { + + @Override + public void endVisit(OracleAggregateExpr astNode) { + + } + + @Override + public void endVisit(ModifyColumnClause astNode) { + + } + + @Override + public void endVisit(DropColumn astNode) { + + } + + @Override + public void endVisit(RenameColumn astNode) { + + } + + @Override + public void endVisit(DeallocateClause astNode) { + + } + + @Override + public void endVisit(EnableTrigger astNode) { + + } + + @Override + public void endVisit(RenameConstaint astNode) { + + } + + @Override + public void endVisit(AddConstraint astNode) { + + } + + @Override + public void endVisit(ModifyConstaint astNode) { + + } + + @Override + public void endVisit(OracleConstraintState astNode) { + + } + + @Override + public void endVisit(OracleAlterTableStatement astNode) { + + } + + @Override + public void endVisit(EnableClause astNode) { + + } + + @Override + public void endVisit(ParallelClause astNode) { + + } + + @Override + public void endVisit(NoParallelClause astNode) { + + } + + @Override + public void endVisit(ModifyCollectionRetrieval astNode) { + + } + + @Override + public void endVisit(AddColumnClause astNode) { + + } + + @Override + public void endVisit(OracleForeignKey astNode) { + + } + + @Override + public void endVisit(OraclePLSQLCommitStatement astNode) { + + } + + @Override + public void endVisit(OracleReferencesConstaint astNode) { + + } + + @Override + public void endVisit(OracleConstraintNull astNode) { + + } + + @Override + public void endVisit(OracleCheck astNode) { + + } + + @Override + public void endVisit(OraclePrimaryKey astNode) { + + } + + @Override + public void endVisit(OracleAnalytic x) { + + } + + @Override + public void endVisit(OracleAnalyticWindowing x) { + + } + + @Override + public void endVisit(OracleArrayAccessExpr x) { + + } + + @Override + public void endVisit(OracleCreateViewStatement x) { + + } + + @Override + public void endVisit(OracleDataTypeInterval x) { + + } + + @Override + public void endVisit(OracleRefDataType x) { + + } + + @Override + public void endVisit(OracleDateExpr x) { + + } + + @Override + public void endVisit(OracleDbLinkExpr x) { + + } + + @Override + public void endVisit(OracleDeleteStatement x) { + + } + + @Override + public void endVisit(OracleExtractExpr x) { + + } + + @Override + public void endVisit(OracleGroupComparisonCondition x) { + + } + + @Override + public void endVisit(OracleGroupingSetsExpr x) { + + } + + @Override + public void endVisit(OracleHint x) { + + } + + @Override + public void endVisit(OracleIntervalExpr x) { + + } + + @Override + public void endVisit(SQLObjectCreateExpr x) { + + } + + @Override + public void endVisit(OracleOrderBy x) { + + } + + @Override + public void endVisit(OracleOuterExpr x) { + + } + + @Override + public void endVisit(OracleSelectForUpdate x) { + + } + + @Override + public void endVisit(OracleSelectHierachicalQueryClause x) { + + } + + @Override + public void endVisit(OracleSelectJoin x) { + + } + + @Override + public void endVisit(OracleOrderByItem x) { + + } + + @Override + public void endVisit(OracleSelectPivot x) { + + } + + @Override + public void endVisit(Item x) { + + } + + @Override + public void endVisit(CheckOption x) { + + } + + @Override + public void endVisit(ReadOnly x) { + + } + + @Override + public void endVisit(OracleSelectSubqueryTableSource x) { + + } + + @Override + public void endVisit(OracleSelectUnPivot x) { + + } + + @Override + public void endVisit(OracleTableCollectionExpr x) { + + } + + @Override + public void endVisit(OracleTableColumn x) { + + } + + @Override + public void endVisit(OracleTableExpr x) { + + } + + @Override + public void endVisit(OracleTableTypeDef x) { + + } + + @Override + public void endVisit(OracleTimestampExpr x) { + + } + + @Override + public void endVisit(OracleUpdateSetListClause x) { + + } + + @Override + public void endVisit(OracleUpdateSetListMultiColumnItem x) { + + } + + @Override + public void endVisit(OracleUpdateSetListSingleColumnItem x) { + + } + + @Override + public void endVisit(OracleUpdateSetValueClause x) { + + } + + @Override + public void endVisit(OracleUpdateStatement x) { + + } + + @Override + public boolean visit(OracleAggregateExpr astNode) { + + return true; + } + + @Override + public boolean visit(ModifyColumnClause astNode) { + + return true; + } + + @Override + public boolean visit(DropColumn astNode) { + + return true; + } + + @Override + public boolean visit(RenameColumn astNode) { + + return true; + } + + @Override + public boolean visit(DeallocateClause astNode) { + + return true; + } + + @Override + public boolean visit(EnableTrigger astNode) { + + return true; + } + + @Override + public boolean visit(RenameConstaint astNode) { + + return true; + } + + @Override + public boolean visit(AddConstraint astNode) { + + return true; + } + + @Override + public boolean visit(ModifyConstaint astNode) { + + return true; + } + + @Override + public boolean visit(OracleConstraintState astNode) { + + return true; + } + + @Override + public boolean visit(OracleAlterTableStatement astNode) { + + return true; + } + + @Override + public boolean visit(EnableClause astNode) { + + return true; + } + + @Override + public boolean visit(ParallelClause astNode) { + + return true; + } + + @Override + public boolean visit(NoParallelClause astNode) { + + return true; + } + + @Override + public boolean visit(ModifyCollectionRetrieval astNode) { + + return true; + } + + @Override + public boolean visit(AddColumnClause astNode) { + + return true; + } + + @Override + public boolean visit(OracleForeignKey astNode) { + + return true; + } + + @Override + public boolean visit(OraclePLSQLCommitStatement astNode) { + + return true; + } + + @Override + public boolean visit(OracleReferencesConstaint astNode) { + + return true; + } + + @Override + public boolean visit(OracleConstraintNull astNode) { + + return true; + } + + @Override + public boolean visit(OracleCheck astNode) { + + return true; + } + + @Override + public boolean visit(OraclePrimaryKey astNode) { + + return true; + } + + @Override + public boolean visit(OracleAnalytic x) { + + return true; + } + + @Override + public boolean visit(OracleAnalyticWindowing x) { + + return true; + } + + @Override + public boolean visit(OracleArrayAccessExpr x) { + + return true; + } + + @Override + public boolean visit(OracleCreateViewStatement x) { + + return true; + } + + @Override + public boolean visit(OracleDataTypeInterval x) { + + return true; + } + + @Override + public boolean visit(OracleRefDataType x) { + + return true; + } + + @Override + public boolean visit(OracleDateExpr x) { + + return true; + } + + @Override + public boolean visit(OracleDbLinkExpr x) { + + return true; + } + + @Override + public boolean visit(OracleDeleteStatement x) { + + return true; + } + + @Override + public boolean visit(OracleExtractExpr x) { + + return true; + } + + @Override + public boolean visit(OracleGroupComparisonCondition x) { + + return true; + } + + @Override + public boolean visit(OracleGroupingSetsExpr x) { + + return true; + } + + @Override + public boolean visit(OracleHint x) { + + return true; + } + + @Override + public boolean visit(OracleIntervalExpr x) { + + return true; + } + + @Override + public boolean visit(SQLObjectCreateExpr x) { + + return true; + } + + @Override + public boolean visit(OracleOrderBy x) { + + return true; + } + + @Override + public boolean visit(OracleOuterExpr x) { + + return true; + } + + @Override + public boolean visit(OracleSelectForUpdate x) { + + return true; + } + + @Override + public boolean visit(OracleSelectHierachicalQueryClause x) { + + return true; + } + + @Override + public boolean visit(OracleSelectJoin x) { + + return true; + } + + @Override + public boolean visit(OracleOrderByItem x) { + + return true; + } + + @Override + public boolean visit(OracleSelectPivot x) { + + return true; + } + + @Override + public boolean visit(Item x) { + + return true; + } + + @Override + public boolean visit(CheckOption x) { + + return true; + } + + @Override + public boolean visit(ReadOnly x) { + + return true; + } + + @Override + public boolean visit(OracleSelectSubqueryTableSource x) { + + return true; + } + + @Override + public boolean visit(OracleSelectUnPivot x) { + + return true; + } + + @Override + public boolean visit(OracleTableCollectionExpr x) { + + return true; + } + + @Override + public boolean visit(OracleTableColumn x) { + + return true; + } + + @Override + public boolean visit(OracleTableExpr x) { + + return true; + } + + @Override + public boolean visit(OracleTableTypeDef x) { + + return true; + } + + @Override + public boolean visit(OracleTimestampExpr x) { + + return true; + } + + @Override + public boolean visit(OracleUpdateSetListClause x) { + + return true; + } + + @Override + public boolean visit(OracleUpdateSetListMultiColumnItem x) { + + return true; + } + + @Override + public boolean visit(OracleUpdateSetListSingleColumnItem x) { + + return true; + } + + @Override + public boolean visit(OracleUpdateSetValueClause x) { + + return true; + } + + @Override + public boolean visit(OracleUpdateStatement x) { + + return true; + } + + @Override + public boolean visit(SampleClause x) { + + return true; + } + + @Override + public void endVisit(SampleClause x) { + + } + + @Override + public boolean visit(OracleSelectTableReference x) { + + return true; + } + + @Override + public void endVisit(OracleSelectTableReference x) { + + } + + @Override + public boolean visit(PartitionExtensionClause x) { + + return true; + } + + @Override + public void endVisit(PartitionExtensionClause x) { + + } + + @Override + public boolean visit(VersionsFlashbackQueryClause x) { + + return true; + } + + @Override + public void endVisit(VersionsFlashbackQueryClause x) { + + } + + @Override + public boolean visit(AsOfFlashbackQueryClause x) { + + return true; + } + + @Override + public void endVisit(AsOfFlashbackQueryClause x) { + + } + + @Override + public boolean visit(GroupingSetExpr x) { + + return true; + } + + @Override + public void endVisit(GroupingSetExpr x) { + + } + + @Override + public boolean visit(OraclePriorExpr x) { + + return true; + } + + @Override + public void endVisit(OraclePriorExpr x) { + + } + + @Override + public boolean visit(SubqueryFactoringClause x) { + + return true; + } + + @Override + public void endVisit(SubqueryFactoringClause x) { + + } + + @Override + public boolean visit(Entry x) { + + return true; + } + + @Override + public void endVisit(Entry x) { + + } + + @Override + public boolean visit(SearchClause x) { + + return true; + } + + @Override + public void endVisit(SearchClause x) { + + } + + @Override + public boolean visit(CycleClause x) { + + return true; + } + + @Override + public void endVisit(CycleClause x) { + + } + + @Override + public boolean visit(OracleBinaryFloatExpr x) { + + return true; + } + + @Override + public void endVisit(OracleBinaryFloatExpr x) { + + } + + @Override + public boolean visit(OracleBinaryDoubleExpr x) { + + return true; + } + + @Override + public void endVisit(OracleBinaryDoubleExpr x) { + + } + +} diff --git a/src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/visitor/OracleSchemaStatVisitor.java b/src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/visitor/OracleSchemaStatVisitor.java new file mode 100644 index 0000000000..ae02a2d54f --- /dev/null +++ b/src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/visitor/OracleSchemaStatVisitor.java @@ -0,0 +1,272 @@ +package com.alibaba.druid.sql.dialect.oracle.ast.visitor; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import com.alibaba.druid.sql.ast.SQLObject; +import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr; +import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr; +import com.alibaba.druid.sql.ast.statement.SQLExprTableSource; +import com.alibaba.druid.sql.ast.statement.SQLInsertStatement; +import com.alibaba.druid.sql.ast.statement.SQLJoinTableSource; +import com.alibaba.druid.sql.ast.statement.SQLSelect; +import com.alibaba.druid.sql.ast.statement.SQLSelectQueryBlock; +import com.alibaba.druid.sql.ast.statement.SQLSelectStatement; +import com.alibaba.druid.sql.ast.statement.SQLSubqueryTableSource; +import com.alibaba.druid.sql.ast.statement.SQLUpdateStatement; +import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement; +import com.alibaba.druid.stat.TableStat; +import com.alibaba.druid.stat.TableStat.Column; +import com.alibaba.druid.stat.TableStat.Mode; + +public class OracleSchemaStatVisitor extends OracleASTVIsitorAdapter { + + private HashMap tableStats = new HashMap(); + private Set fields = new HashSet(); + + private final static ThreadLocal> aliasLocal = new ThreadLocal>(); + private final static ThreadLocal currentTableLocal = new ThreadLocal(); + private final static ThreadLocal modeLocal = new ThreadLocal(); + + public boolean visit(SQLSubqueryTableSource x) { + Map aliasMap = aliasLocal.get(); + if (aliasMap != null) { + if (x.getAlias() != null) { + aliasMap.put(x.getAlias(), null); + } + } + return true; + } + + public boolean visit(SQLExprTableSource x) { + if (x.getExpr() instanceof SQLIdentifierExpr) { + String ident = ((SQLIdentifierExpr) x.getExpr()).getName(); + TableStat stat = tableStats.get(ident); + if (stat == null) { + stat = new TableStat(); + tableStats.put(ident, stat); + } + + Mode mode = modeLocal.get(); + switch (mode) { + case Delete: + stat.incrementDeleteCount(); + break; + case Insert: + stat.incrementInsertCount(); + break; + case Update: + stat.incrementUpdateCount(); + break; + case Select: + stat.incrementSelectCount(); + break; + default: + break; + } + + Map aliasMap = aliasLocal.get(); + if (aliasMap != null) { + if (x.getAlias() != null) { + aliasMap.put(x.getAlias(), ident); + } + aliasMap.put(ident, ident); + } + } + + return false; + } + + public boolean visit(SQLSelect x) { + return true; + } + + public void endVisit(SQLSelect x) { + } + + public boolean visit(SQLUpdateStatement x) { + aliasLocal.set(new HashMap()); + + String ident = x.getTableName().toString(); + currentTableLocal.set(ident); + + TableStat stat = tableStats.get(ident); + if (stat == null) { + stat = new TableStat(); + tableStats.put(ident, stat); + } + stat.incrementUpdateCount(); + + Map aliasMap = aliasLocal.get(); + aliasMap.put(ident, ident); + + accept(x.getItems()); + accept(x.getWhere()); + + return false; + } + + public void endVisit(SQLUpdateStatement x) { + aliasLocal.set(null); + } + + public boolean visit(OracleDeleteStatement x) { + aliasLocal.set(new HashMap()); + + x.putAttribute("_original_use_mode", modeLocal.get()); + modeLocal.set(Mode.Delete); + + aliasLocal.set(new HashMap()); + + String ident = ((SQLIdentifierExpr) x.getTableName()).getName(); + currentTableLocal.set(ident); + + accept(x.getWhere()); + + return false; + } + + public void endVisit(OracleDeleteStatement x) { + aliasLocal.set(null); + } + + public boolean visit(SQLSelectStatement x) { + aliasLocal.set(new HashMap()); + return true; + } + + public void endVisit(SQLSelectStatement x) { + aliasLocal.set(null); + } + + public void endVisit(SQLInsertStatement x) { + Mode originalMode = (Mode) x.getAttribute("_original_use_mode"); + modeLocal.set(originalMode); + } + + public boolean visit(SQLInsertStatement x) { + x.putAttribute("_original_use_mode", modeLocal.get()); + modeLocal.set(Mode.Insert); + + aliasLocal.set(new HashMap()); + + String originalTable = currentTableLocal.get(); + + if (x.getTableName() instanceof SQLIdentifierExpr) { + String ident = ((SQLIdentifierExpr) x.getTableName()).getName(); + currentTableLocal.set(ident); + x.putAttribute("_old_local_", originalTable); + + TableStat stat = tableStats.get(ident); + if (stat == null) { + stat = new TableStat(); + tableStats.put(ident, stat); + } + stat.incrementInsertCount(); + + Map aliasMap = aliasLocal.get(); + if (aliasMap != null) { + if (x.getAlias() != null) { + aliasMap.put(x.getAlias(), ident); + } + aliasMap.put(ident, ident); + } + } + + accept(x.getColumns()); + accept(x.getValues()); + accept(x.getQuery()); + + return false; + } + + protected void accept(SQLObject x) { + if (x != null) { + x.accept(this); + } + } + + protected void accept(List nodes) { + for (int i = 0, size = nodes.size(); i < size; ++i) { + accept(nodes.get(i)); + } + } + + public boolean visit(SQLSelectQueryBlock x) { + + if (x.getFrom() instanceof SQLSubqueryTableSource) { + x.getFrom().accept(this); + return false; + } + + x.putAttribute("_original_use_mode", modeLocal.get()); + modeLocal.set(Mode.Select); + + String originalTable = currentTableLocal.get(); + + if (x.getFrom() instanceof SQLExprTableSource) { + SQLExprTableSource tableSource = (SQLExprTableSource) x.getFrom(); + if (tableSource.getExpr() instanceof SQLIdentifierExpr) { + String ident = ((SQLIdentifierExpr) tableSource.getExpr()).getName(); + currentTableLocal.set(ident); + x.putAttribute("_old_local_", originalTable); + } + } + + x.getFrom().accept(this); // 提前执行，获得aliasMap + + return true; + } + + public void endVisit(SQLSelectQueryBlock x) { + String originalTable = (String) x.getAttribute("_old_local_"); + currentTableLocal.set(originalTable); + + Mode originalMode = (Mode) x.getAttribute("_original_use_mode"); + modeLocal.set(originalMode); + } + + public boolean visit(SQLJoinTableSource x) { + return true; + } + + public boolean visit(SQLPropertyExpr x) { + if (x.getOwner() instanceof SQLIdentifierExpr) { + String owner = ((SQLIdentifierExpr) x.getOwner()).getName(); + + if (owner != null) { + Map aliasMap = aliasLocal.get(); + if (aliasMap != null) { + String table = aliasMap.get(owner); + + // table == null时是SubQuery + if (table != null) { + fields.add(new Column(table, x.getName())); + } + } + } + } + return false; + } + + public boolean visit(SQLIdentifierExpr x) { + String currentTable = currentTableLocal.get(); + + if (currentTable != null) { + fields.add(new Column(currentTable, x.getName())); + } + return false; + } + + public Map getTables() { + return tableStats; + } + + public Set getFields() { + return fields; + } + +}