package util.sqlparse.visitor.dm.visitor;

import com.alibaba.druid.sql.ast.SQLStatement;
import com.alibaba.druid.sql.dialect.dm.ast.clause.DmPartitionExtensionClause;
import com.alibaba.druid.sql.dialect.dm.ast.clause.DmReturningClause;
import com.alibaba.druid.sql.dialect.dm.ast.clause.DmSampleClause;
import com.alibaba.druid.sql.dialect.dm.ast.clause.DmStorageClause;
import com.alibaba.druid.sql.dialect.dm.ast.expr.DMIntervalExpr;
import com.alibaba.druid.sql.dialect.dm.ast.expr.DmAnalytic;
import com.alibaba.druid.sql.dialect.dm.ast.expr.DmAnalyticWindowing;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DMIndexTablespacleConstraint;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DMSQLAlterTableRebuildColumns;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterDatabaseAddLogfile;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterDatabaseArchivelog;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterDatabaseMoveDatafile;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterDatabaseRenameLogfile;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterDatabaseResizeLogfile;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterDatabaseStatus;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterIndexStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterPackageCompile;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableAddConstraint;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableAddIdentity;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableAddPartition;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableAlterColumn;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableCounter;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableDefaultDirectory;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableDropIdentity;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableDropPartition;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableEnableUsingLongRow;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableExchangePartition;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableLocation;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableMergePartition;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableModify;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableModifyConstraint;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableModifyDiskspace;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableModifyPartition;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableMovePartition;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableRenamePartition;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableRowMovement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableSetPartitionTemplate;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableSplitPartition;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTableTruncateSubpartition;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterTriggerStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmAlterViewStatment;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmConstraint;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmContinueStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmCreateIndexStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmCreatePackageStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmCreateSchemaStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmCreateSynonymStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmCreateTableStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmCreateTriggerStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmDataTypeIntervalYear;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmDropUserStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmExceptionStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmExecuteImmediateStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmExitStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmForeignKeyImpl;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmGotoStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmInsertStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmLabelStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmLockTableStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmLogfile;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmMultiInsertStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmPrintStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmRaiseStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmSQLColumnPrimaryKey;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmSQLColumnReference;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmSQLPrimaryKey;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmSQLTruncateStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmSQLUniqueKey;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmSelectPivot;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmSelectQueryBlock;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmSelectSubqueryTableSource;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmSelectTableReference;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmSelectUnPivot;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmSetTransactionStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.DmUpdateStatement;
import com.alibaba.druid.sql.dialect.dm.ast.stmt.SQLNotVisibleConstraint;
import com.alibaba.druid.sql.dialect.dm.visitor.DmASTVisitor;
import com.alibaba.druid.sql.dialect.oracle.ast.clause.PartitionExtensionClause;
import java.util.List;
import util.sqlparse.visitor.Formater;

public class FormatVisitor extends Formater implements DmASTVisitor {
   private boolean debug = false;

   public void perform(List<SQLStatement> statements) {
      if (statements != null && statements.size() != 0) {
         for(SQLStatement statement : statements) {
            statement.accept(this);
         }

      }
   }

   public boolean visit(DmSelectQueryBlock x) {
      return false;
   }

   public void endVisit(DmSelectQueryBlock x) {
   }

   public boolean visit(DmSelectPivot x) {
      return false;
   }

   public void endVisit(DmSelectPivot x) {
   }

   public boolean visit(DmSelectUnPivot x) {
      return false;
   }

   public void endVisit(DmSelectUnPivot x) {
   }

   public boolean visit(DmSelectPivot.Item x) {
      return false;
   }

   public boolean visit(DMIntervalExpr x) {
      return false;
   }

   public boolean visit(DmReturningClause x) {
      return false;
   }

   public boolean visit(DmMultiInsertStatement x) {
      return false;
   }

   public boolean visit(DmInsertStatement x) {
      return false;
   }

   public boolean visit(DmMultiInsertStatement.ConditionalInsertClause x) {
      return false;
   }

   public boolean visit(DmMultiInsertStatement.ConditionalInsertClauseItem x) {
      return false;
   }

   public boolean visit(DmMultiInsertStatement.InsertIntoClause x) {
      return false;
   }

   public boolean visit(DmSelectSubqueryTableSource x) {
      return false;
   }

   public boolean visit(DmSelectTableReference x) {
      return false;
   }

   public boolean visit(PartitionExtensionClause x) {
      return false;
   }

   public boolean visit(DmUpdateStatement x) {
      return false;
   }

   public boolean visit(DmAnalytic x) {
      return false;
   }

   public boolean visit(DmAnalyticWindowing x) {
      return false;
   }

   public boolean visit(DmPartitionExtensionClause x) {
      return false;
   }

   public boolean visit(DmSampleClause x) {
      return false;
   }

   public void endVisit(DmSelectPivot.Item x) {
   }

   public boolean visit(DmContinueStatement x) {
      return false;
   }

   public void endVisit(DmContinueStatement x) {
   }

   public void endVisit(DMIntervalExpr x) {
   }

   public void endVisit(DmReturningClause x) {
   }

   public void endVisit(DmMultiInsertStatement x) {
   }

   public void endVisit(DmInsertStatement x) {
   }

   public void endVisit(DmMultiInsertStatement.ConditionalInsertClause x) {
   }

   public void endVisit(DmMultiInsertStatement.ConditionalInsertClauseItem x) {
   }

   public void endVisit(DmMultiInsertStatement.InsertIntoClause x) {
   }

   public void endVisit(DmSelectSubqueryTableSource x) {
   }

   public void endVisit(DmSelectTableReference x) {
   }

   public void endVisit(DmPartitionExtensionClause x) {
   }

   public void endVisit(DmUpdateStatement x) {
   }

   public void endVisit(DmAnalytic x) {
   }

   public void endVisit(DmAnalyticWindowing x) {
   }

   public void endVisit(DmSampleClause x) {
   }

   public boolean visit(DmCreateTableStatement.OIDIndex x) {
      return false;
   }

   public void endVisit(DmCreateTableStatement.OIDIndex x) {
   }

   public boolean visit(DmCreateTableStatement.Organization x) {
      return false;
   }

   public void endVisit(DmCreateTableStatement.Organization x) {
   }

   public boolean visit(DmCreateTableStatement x) {
      return false;
   }

   public void endVisit(DmCreateTableStatement x) {
   }

   public boolean visit(DmSQLColumnPrimaryKey x) {
      return false;
   }

   public void endVisit(DmSQLColumnPrimaryKey x) {
   }

   public boolean visit(DmStorageClause x) {
      return false;
   }

   public void endVisit(DmStorageClause x) {
   }

   public boolean visit(DMIndexTablespacleConstraint x) {
      return false;
   }

   public void endVisit(DMIndexTablespacleConstraint x) {
   }

   public boolean visit(SQLNotVisibleConstraint x) {
      return false;
   }

   public void endVisit(SQLNotVisibleConstraint x) {
   }

   public boolean visit(DmSQLColumnReference x) {
      return false;
   }

   public void endVisit(DmSQLColumnReference x) {
   }

   public boolean visit(DmSQLPrimaryKey x) {
      return false;
   }

   public void endVisit(DmSQLPrimaryKey x) {
   }

   public boolean visit(DmSQLUniqueKey x) {
      return false;
   }

   public void endVisit(DmSQLUniqueKey x) {
   }

   public boolean visit(DmForeignKeyImpl x) {
      return false;
   }

   public void endVisit(DmForeignKeyImpl x) {
   }

   public boolean visit(DMSQLAlterTableRebuildColumns x) {
      return false;
   }

   public void endVisit(DMSQLAlterTableRebuildColumns x) {
   }

   public boolean visit(DmAlterTableAlterColumn x) {
      return false;
   }

   public void endVisit(DmAlterTableAlterColumn x) {
   }

   public boolean visit(DmAlterTableModifyDiskspace x) {
      return false;
   }

   public void endVisit(DmAlterTableModifyDiskspace x) {
   }

   public boolean visit(DmAlterTableModifyConstraint x) {
      return false;
   }

   public void endVisit(DmAlterTableModifyConstraint x) {
   }

   public boolean visit(DmConstraint x) {
      return false;
   }

   public void endVisit(DmConstraint x) {
   }

   public boolean visit(DmAlterTableCounter x) {
      return false;
   }

   public void endVisit(DmAlterTableCounter x) {
   }

   public boolean visit(DmAlterTableAddIdentity x) {
      return false;
   }

   public void endVisit(DmAlterTableAddIdentity x) {
   }

   public boolean visit(DmAlterTableDropIdentity x) {
      return false;
   }

   public void endVisit(DmAlterTableDropIdentity x) {
   }

   public boolean visit(DmAlterTableTruncateSubpartition x) {
      return false;
   }

   public void endVisit(DmAlterTableTruncateSubpartition x) {
   }

   public boolean visit(DmAlterTableRowMovement x) {
      return false;
   }

   public void endVisit(DmAlterTableRowMovement x) {
   }

   public boolean visit(DmAlterTableEnableUsingLongRow x) {
      return false;
   }

   public void endVisit(DmAlterTableEnableUsingLongRow x) {
   }

   public boolean visit(DmAlterTableModifyPartition x) {
      return false;
   }

   public void endVisit(DmAlterTableModifyPartition x) {
   }

   public boolean visit(DmAlterTableDropPartition x) {
      return false;
   }

   public void endVisit(DmAlterTableDropPartition x) {
   }

   public boolean visit(DmAlterTableAddPartition x) {
      return false;
   }

   public void endVisit(DmAlterTableAddPartition x) {
   }

   public boolean visit(DmAlterTableExchangePartition x) {
      return false;
   }

   public void endVisit(DmAlterTableExchangePartition x) {
   }

   public boolean visit(DmAlterTableSplitPartition x) {
      return false;
   }

   public void endVisit(DmAlterTableSplitPartition x) {
   }

   public boolean visit(DmAlterTableMergePartition x) {
      return false;
   }

   public void endVisit(DmAlterTableMergePartition x) {
   }

   public boolean visit(DmAlterTableSetPartitionTemplate x) {
      return false;
   }

   public void endVisit(DmAlterTableSetPartitionTemplate x) {
   }

   public boolean visit(DmAlterTableRenamePartition x) {
      return false;
   }

   public void endVisit(DmAlterTableRenamePartition x) {
   }

   public boolean visit(DmAlterTableMovePartition x) {
      return false;
   }

   public void endVisit(DmAlterTableMovePartition x) {
   }

   public boolean visit(DmAlterTableModify x) {
      return false;
   }

   public void endVisit(DmAlterTableModify x) {
   }

   public boolean visit(DmAlterTableAddConstraint x) {
      return false;
   }

   public void endVisit(DmAlterTableAddConstraint x) {
   }

   public boolean visit(DmAlterDatabaseStatus x) {
      return false;
   }

   public void endVisit(DmAlterDatabaseStatus x) {
   }

   public boolean visit(DmAlterDatabaseResizeLogfile x) {
      return false;
   }

   public void endVisit(DmAlterDatabaseResizeLogfile x) {
   }

   public boolean visit(DmAlterDatabaseAddLogfile x) {
      return false;
   }

   public void endVisit(DmAlterDatabaseAddLogfile x) {
   }

   public boolean visit(DmLogfile x) {
      return false;
   }

   public void endVisit(DmLogfile x) {
   }

   public boolean visit(DmAlterDatabaseRenameLogfile x) {
      return false;
   }

   public void endVisit(DmAlterDatabaseRenameLogfile x) {
   }

   public boolean visit(DmAlterDatabaseMoveDatafile x) {
      return false;
   }

   public void endVisit(DmAlterDatabaseMoveDatafile x) {
   }

   public boolean visit(DmAlterDatabaseArchivelog x) {
      return false;
   }

   public void endVisit(DmAlterDatabaseArchivelog x) {
   }

   public boolean visit(DmDropUserStatement x) {
      return false;
   }

   public void endVisit(DmDropUserStatement x) {
   }

   public boolean visit(DmCreateSchemaStatement x) {
      return false;
   }

   public void endVisit(DmCreateSchemaStatement x) {
   }

   public boolean visit(DmSQLTruncateStatement x) {
      return false;
   }

   public void endVisit(DmSQLTruncateStatement x) {
   }

   public boolean visit(DmCreateIndexStatement x) {
      return false;
   }

   public void endVisit(DmCreateIndexStatement x) {
   }

   public boolean visit(DmAlterIndexStatement x) {
      return false;
   }

   public void endVisit(DmAlterIndexStatement x) {
   }

   public boolean visit(DmAlterViewStatment x) {
      return false;
   }

   public void endVisit(DmAlterViewStatment x) {
   }

   public boolean visit(DmSetTransactionStatement x) {
      return false;
   }

   public void endVisit(DmSetTransactionStatement x) {
   }

   public boolean visit(DmLockTableStatement x) {
      return false;
   }

   public void endVisit(DmLockTableStatement x) {
   }

   public boolean visit(DmCreateSynonymStatement x) {
      return false;
   }

   public void endVisit(DmCreateSynonymStatement x) {
   }

   public boolean visit(DmCreateTriggerStatement x) {
      return false;
   }

   public void endVisit(DmCreateTriggerStatement x) {
   }

   public boolean visit(DmAlterTriggerStatement x) {
      return false;
   }

   public void endVisit(DmAlterTriggerStatement x) {
   }

   public boolean visit(DmPrintStatement x) {
      return false;
   }

   public void endVisit(DmPrintStatement x) {
   }

   public boolean visit(DmExecuteImmediateStatement x) {
      return false;
   }

   public void endVisit(DmExecuteImmediateStatement x) {
   }

   public boolean visit(DmRaiseStatement x) {
      return false;
   }

   public void endVisit(DmRaiseStatement x) {
   }

   public boolean visit(DmExitStatement x) {
      return false;
   }

   public void endVisit(DmExitStatement x) {
   }

   public boolean visit(DmExceptionStatement x) {
      return false;
   }

   public void endVisit(DmExceptionStatement x) {
   }

   public boolean visit(DmExceptionStatement.Item x) {
      return false;
   }

   public void endVisit(DmExceptionStatement.Item x) {
   }

   public boolean visit(DmGotoStatement x) {
      return false;
   }

   public void endVisit(DmGotoStatement x) {
   }

   public boolean visit(DmLabelStatement x) {
      return false;
   }

   public void endVisit(DmLabelStatement x) {
   }

   public boolean visit(DmDataTypeIntervalYear x) {
      return false;
   }

   public void endVisit(DmDataTypeIntervalYear x) {
   }

   public boolean visit(DmCreateTableStatement.PARMS x) {
      return false;
   }

   public void endVisit(DmCreateTableStatement.PARMS x) {
   }

   public boolean visit(DmAlterTableDefaultDirectory x) {
      return false;
   }

   public void endVisit(DmAlterTableDefaultDirectory x) {
   }

   public boolean visit(DmAlterTableLocation x) {
      return false;
   }

   public void endVisit(DmAlterTableLocation x) {
   }

   public boolean visit(DmCreatePackageStatement x) {
      return false;
   }

   public void endVisit(DmCreatePackageStatement x) {
   }

   public boolean visit(DmAlterPackageCompile x) {
      return false;
   }

   public void endVisit(DmAlterPackageCompile x) {
   }

   public boolean visit(DmCreateTriggerStatement.Timer x) {
      return false;
   }

   public void endVisit(DmCreateTriggerStatement.Timer x) {
   }

   public boolean visit(DmCreateTriggerStatement.Timer.DayInMonthWeek x) {
      return false;
   }

   public void endVisit(DmCreateTriggerStatement.Timer.DayInMonthWeek x) {
   }

   public boolean visit(DmCreateTriggerStatement.Timer.DuaringTime x) {
      return false;
   }

   public void endVisit(DmCreateTriggerStatement.Timer.DuaringTime x) {
   }

   public boolean visit(DmCreateTriggerStatement.Timer.DuaringDate x) {
      return false;
   }

   public void endVisit(DmCreateTriggerStatement.Timer.DuaringDate x) {
   }
}
