package com.alibaba.druid.wall.spi;

import com.alibaba.druid.DbType;
import com.alibaba.druid.sql.ast.SQLAdhocTableSource;
import com.alibaba.druid.sql.ast.SQLAnnIndex;
import com.alibaba.druid.sql.ast.SQLArgument;
import com.alibaba.druid.sql.ast.SQLArrayDataType;
import com.alibaba.druid.sql.ast.SQLCommentHint;
import com.alibaba.druid.sql.ast.SQLCurrentTimeExpr;
import com.alibaba.druid.sql.ast.SQLCurrentUserExpr;
import com.alibaba.druid.sql.ast.SQLDataType;
import com.alibaba.druid.sql.ast.SQLDataTypeRefExpr;
import com.alibaba.druid.sql.ast.SQLDeclareItem;
import com.alibaba.druid.sql.ast.SQLIndexDefinition;
import com.alibaba.druid.sql.ast.SQLIndexOptions;
import com.alibaba.druid.sql.ast.SQLKeep;
import com.alibaba.druid.sql.ast.SQLLimit;
import com.alibaba.druid.sql.ast.SQLMapDataType;
import com.alibaba.druid.sql.ast.SQLObject;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOver;
import com.alibaba.druid.sql.ast.SQLParameter;
import com.alibaba.druid.sql.ast.SQLPartition;
import com.alibaba.druid.sql.ast.SQLPartitionByHash;
import com.alibaba.druid.sql.ast.SQLPartitionByList;
import com.alibaba.druid.sql.ast.SQLPartitionByRange;
import com.alibaba.druid.sql.ast.SQLPartitionByValue;
import com.alibaba.druid.sql.ast.SQLPartitionSpec;
import com.alibaba.druid.sql.ast.SQLPartitionValue;
import com.alibaba.druid.sql.ast.SQLRecordDataType;
import com.alibaba.druid.sql.ast.SQLRowDataType;
import com.alibaba.druid.sql.ast.SQLStructDataType;
import com.alibaba.druid.sql.ast.SQLSubPartition;
import com.alibaba.druid.sql.ast.SQLSubPartitionByHash;
import com.alibaba.druid.sql.ast.SQLSubPartitionByList;
import com.alibaba.druid.sql.ast.SQLSubPartitionByRange;
import com.alibaba.druid.sql.ast.SQLUnionDataType;
import com.alibaba.druid.sql.ast.SQLWindow;
import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr;
import com.alibaba.druid.sql.ast.expr.SQLAllColumnExpr;
import com.alibaba.druid.sql.ast.expr.SQLAllExpr;
import com.alibaba.druid.sql.ast.expr.SQLAnyExpr;
import com.alibaba.druid.sql.ast.expr.SQLArrayExpr;
import com.alibaba.druid.sql.ast.expr.SQLBetweenExpr;
import com.alibaba.druid.sql.ast.expr.SQLBigIntExpr;
import com.alibaba.druid.sql.ast.expr.SQLBinaryExpr;
import com.alibaba.druid.sql.ast.expr.SQLBinaryOpExpr;
import com.alibaba.druid.sql.ast.expr.SQLBinaryOpExprGroup;
import com.alibaba.druid.sql.ast.expr.SQLBooleanExpr;
import com.alibaba.druid.sql.ast.expr.SQLCaseExpr;
import com.alibaba.druid.sql.ast.expr.SQLCaseStatement;
import com.alibaba.druid.sql.ast.expr.SQLCastExpr;
import com.alibaba.druid.sql.ast.expr.SQLCharExpr;
import com.alibaba.druid.sql.ast.expr.SQLContainsExpr;
import com.alibaba.druid.sql.ast.expr.SQLCurrentOfCursorExpr;
import com.alibaba.druid.sql.ast.expr.SQLDateExpr;
import com.alibaba.druid.sql.ast.expr.SQLDateTimeExpr;
import com.alibaba.druid.sql.ast.expr.SQLDbLinkExpr;
import com.alibaba.druid.sql.ast.expr.SQLDecimalExpr;
import com.alibaba.druid.sql.ast.expr.SQLDefaultExpr;
import com.alibaba.druid.sql.ast.expr.SQLDoubleExpr;
import com.alibaba.druid.sql.ast.expr.SQLExistsExpr;
import com.alibaba.druid.sql.ast.expr.SQLExtractExpr;
import com.alibaba.druid.sql.ast.expr.SQLFlashbackExpr;
import com.alibaba.druid.sql.ast.expr.SQLFloatExpr;
import com.alibaba.druid.sql.ast.expr.SQLGroupingSetExpr;
import com.alibaba.druid.sql.ast.expr.SQLHexExpr;
import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr;
import com.alibaba.druid.sql.ast.expr.SQLInListExpr;
import com.alibaba.druid.sql.ast.expr.SQLInSubQueryExpr;
import com.alibaba.druid.sql.ast.expr.SQLIntegerExpr;
import com.alibaba.druid.sql.ast.expr.SQLIntervalExpr;
import com.alibaba.druid.sql.ast.expr.SQLJSONExpr;
import com.alibaba.druid.sql.ast.expr.SQLListExpr;
import com.alibaba.druid.sql.ast.expr.SQLMatchAgainstExpr;
import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
import com.alibaba.druid.sql.ast.expr.SQLNCharExpr;
import com.alibaba.druid.sql.ast.expr.SQLNotExpr;
import com.alibaba.druid.sql.ast.expr.SQLNullExpr;
import com.alibaba.druid.sql.ast.expr.SQLNumberExpr;
import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
import com.alibaba.druid.sql.ast.expr.SQLRealExpr;
import com.alibaba.druid.sql.ast.expr.SQLSequenceExpr;
import com.alibaba.druid.sql.ast.expr.SQLSizeExpr;
import com.alibaba.druid.sql.ast.expr.SQLSmallIntExpr;
import com.alibaba.druid.sql.ast.expr.SQLSomeExpr;
import com.alibaba.druid.sql.ast.expr.SQLTimeExpr;
import com.alibaba.druid.sql.ast.expr.SQLTimestampExpr;
import com.alibaba.druid.sql.ast.expr.SQLTinyIntExpr;
import com.alibaba.druid.sql.ast.expr.SQLUnaryExpr;
import com.alibaba.druid.sql.ast.expr.SQLValuesExpr;
import com.alibaba.druid.sql.ast.expr.SQLVariantRefExpr;
import com.alibaba.druid.sql.ast.statement.SQLAlterCharacter;
import com.alibaba.druid.sql.ast.statement.SQLAlterDatabaseStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterFunctionStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterIndexStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterMaterializedViewStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterOutlineStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterProcedureStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterSequenceStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterSetDateFormatStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterSetNlsDateLanguageStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterSystemGetConfigStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterSystemSetConfigStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterSystemStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableAddClusteringKey;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableAddColumn;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableAddConstraint;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableAddExtPartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableAddIndex;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableAddPartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableAddSupplemental;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableAlterColumn;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableAnalyzePartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableArchivePartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableBlockSize;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableCheckPartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableCoalescePartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableCompression;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableConvertCharSet;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDeleteByCondition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDisableConstraint;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDisableKeys;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDisableLifecycle;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDisableTriggers;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDiscardPartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDropCheck;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDropClusteringKey;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDropColumnItem;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDropConstraint;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDropExtPartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDropForeignKey;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDropIndex;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDropKey;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDropPartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDropPrimaryKey;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableDropSubpartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableEnableConstraint;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableEnableKeys;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableEnableLifecycle;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableEnableTriggers;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableExchangePartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableGroupStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableImportPartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableMergePartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableModifyClusteredBy;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableOptimizePartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTablePartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTablePartitionCount;
import com.alibaba.druid.sql.ast.statement.SQLAlterTablePartitionLifecycle;
import com.alibaba.druid.sql.ast.statement.SQLAlterTablePartitionSetProperties;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableReOrganizePartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableRebuildPartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableRecoverPartitions;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableRename;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableRenameColumn;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableRenameIndex;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableRenamePartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableRepairPartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableReplaceColumn;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableSetComment;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableSetLifecycle;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableSetLocation;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableSetOption;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableSubpartitionAvailablePartitionNum;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableSubpartitionLifecycle;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableTouch;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableTruncatePartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTableUnarchivePartition;
import com.alibaba.druid.sql.ast.statement.SQLAlterTablespaceAddDatafile;
import com.alibaba.druid.sql.ast.statement.SQLAlterTablespaceCache;
import com.alibaba.druid.sql.ast.statement.SQLAlterTablespaceDatafile;
import com.alibaba.druid.sql.ast.statement.SQLAlterTablespaceRename;
import com.alibaba.druid.sql.ast.statement.SQLAlterTablespaceRenameDatafile;
import com.alibaba.druid.sql.ast.statement.SQLAlterTablespaceResizeDatafile;
import com.alibaba.druid.sql.ast.statement.SQLAlterTablespaceStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterTypeStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterUserStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterViewRenameStatement;
import com.alibaba.druid.sql.ast.statement.SQLAlterViewStatement;
import com.alibaba.druid.sql.ast.statement.SQLAnalyzeTableStatement;
import com.alibaba.druid.sql.ast.statement.SQLArchiveTableStatement;
import com.alibaba.druid.sql.ast.statement.SQLAssignItem;
import com.alibaba.druid.sql.ast.statement.SQLBackupStatement;
import com.alibaba.druid.sql.ast.statement.SQLBlockStatement;
import com.alibaba.druid.sql.ast.statement.SQLBuildTableStatement;
import com.alibaba.druid.sql.ast.statement.SQLCallStatement;
import com.alibaba.druid.sql.ast.statement.SQLCancelJobStatement;
import com.alibaba.druid.sql.ast.statement.SQLCharacterDataType;
import com.alibaba.druid.sql.ast.statement.SQLCheck;
import com.alibaba.druid.sql.ast.statement.SQLCloseStatement;
import com.alibaba.druid.sql.ast.statement.SQLColumnCheck;
import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
import com.alibaba.druid.sql.ast.statement.SQLColumnPrimaryKey;
import com.alibaba.druid.sql.ast.statement.SQLColumnReference;
import com.alibaba.druid.sql.ast.statement.SQLColumnUniqueKey;
import com.alibaba.druid.sql.ast.statement.SQLCommentStatement;
import com.alibaba.druid.sql.ast.statement.SQLCommitStatement;
import com.alibaba.druid.sql.ast.statement.SQLCopyFromStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateContextStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateDatabaseStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateDirectoryStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateDomainStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateFunctionStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateIndexStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateMaterializedViewStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateOutlineStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateProcedureStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateRoleStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateSequenceStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateTableGroupStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateTablespaceStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateTriggerStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateUserStatement;
import com.alibaba.druid.sql.ast.statement.SQLCreateViewStatement;
import com.alibaba.druid.sql.ast.statement.SQLDeclareStatement;
import com.alibaba.druid.sql.ast.statement.SQLDefault;
import com.alibaba.druid.sql.ast.statement.SQLDeleteStatement;
import com.alibaba.druid.sql.ast.statement.SQLDescribeStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropCatalogStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropContextStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropDatabaseStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropDirectoryStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropDomainStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropEventStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropFunctionStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropIndexStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropLogFileGroupStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropMaterializedViewStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropOutlineStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropPackageStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropProcedureStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropResourceGroupStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropResourceStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropRoleStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropSequenceStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropServerStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropSynonymStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropTableGroupStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropTableSpaceStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropTableStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropTriggerStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropTypeStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropUserStatement;
import com.alibaba.druid.sql.ast.statement.SQLDropViewStatement;
import com.alibaba.druid.sql.ast.statement.SQLDumpStatement;
import com.alibaba.druid.sql.ast.statement.SQLErrorLoggingClause;
import com.alibaba.druid.sql.ast.statement.SQLExplainAnalyzeStatement;
import com.alibaba.druid.sql.ast.statement.SQLExplainStatement;
import com.alibaba.druid.sql.ast.statement.SQLExportDatabaseStatement;
import com.alibaba.druid.sql.ast.statement.SQLExportTableStatement;
import com.alibaba.druid.sql.ast.statement.SQLExprHint;
import com.alibaba.druid.sql.ast.statement.SQLExprStatement;
import com.alibaba.druid.sql.ast.statement.SQLExprTableSource;
import com.alibaba.druid.sql.ast.statement.SQLExternalRecordFormat;
import com.alibaba.druid.sql.ast.statement.SQLFetchStatement;
import com.alibaba.druid.sql.ast.statement.SQLForStatement;
import com.alibaba.druid.sql.ast.statement.SQLForeignKeyImpl;
import com.alibaba.druid.sql.ast.statement.SQLGrantStatement;
import com.alibaba.druid.sql.ast.statement.SQLIfStatement;
import com.alibaba.druid.sql.ast.statement.SQLImportDatabaseStatement;
import com.alibaba.druid.sql.ast.statement.SQLImportTableStatement;
import com.alibaba.druid.sql.ast.statement.SQLInsertStatement;
import com.alibaba.druid.sql.ast.statement.SQLJoinTableSource;
import com.alibaba.druid.sql.ast.statement.SQLLateralViewTableSource;
import com.alibaba.druid.sql.ast.statement.SQLLoadIndexIntoCacheStatement;
import com.alibaba.druid.sql.ast.statement.SQLLoopStatement;
import com.alibaba.druid.sql.ast.statement.SQLMergeStatement;
import com.alibaba.druid.sql.ast.statement.SQLNotNullConstraint;
import com.alibaba.druid.sql.ast.statement.SQLNullConstraint;
import com.alibaba.druid.sql.ast.statement.SQLOpenStatement;
import com.alibaba.druid.sql.ast.statement.SQLPartitionRef;
import com.alibaba.druid.sql.ast.statement.SQLPrimaryKeyImpl;
import com.alibaba.druid.sql.ast.statement.SQLPrivilegeItem;
import com.alibaba.druid.sql.ast.statement.SQLPurgeLogsStatement;
import com.alibaba.druid.sql.ast.statement.SQLPurgeRecyclebinStatement;
import com.alibaba.druid.sql.ast.statement.SQLPurgeTableStatement;
import com.alibaba.druid.sql.ast.statement.SQLRefreshMaterializedViewStatement;
import com.alibaba.druid.sql.ast.statement.SQLReleaseSavePointStatement;
import com.alibaba.druid.sql.ast.statement.SQLRenameUserStatement;
import com.alibaba.druid.sql.ast.statement.SQLReplaceStatement;
import com.alibaba.druid.sql.ast.statement.SQLRestoreStatement;
import com.alibaba.druid.sql.ast.statement.SQLReturnStatement;
import com.alibaba.druid.sql.ast.statement.SQLRevokeStatement;
import com.alibaba.druid.sql.ast.statement.SQLRollbackStatement;
import com.alibaba.druid.sql.ast.statement.SQLSavePointStatement;
import com.alibaba.druid.sql.ast.statement.SQLScriptCommitStatement;
import com.alibaba.druid.sql.ast.statement.SQLSelect;
import com.alibaba.druid.sql.ast.statement.SQLSelectGroupByClause;
import com.alibaba.druid.sql.ast.statement.SQLSelectItem;
import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem;
import com.alibaba.druid.sql.ast.statement.SQLSelectQueryBlock;
import com.alibaba.druid.sql.ast.statement.SQLSelectStatement;
import com.alibaba.druid.sql.ast.statement.SQLSetSchemaStatement;
import com.alibaba.druid.sql.ast.statement.SQLSetStatement;
import com.alibaba.druid.sql.ast.statement.SQLSetTimeZoneStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowCatalogsStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowColumnsStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowCreateMaterializedViewStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowCreateTableStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowCreateViewStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowDatabasesStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowErrorsStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowFunctionsStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowGrantsStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowIndexesStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowMaterializedViewStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowOutlinesStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowPackagesStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowPartitionsStmt;
import com.alibaba.druid.sql.ast.statement.SQLShowProcessListStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowQueryTaskStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowRecylebinStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowSessionStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowStatisticListStmt;
import com.alibaba.druid.sql.ast.statement.SQLShowStatisticStmt;
import com.alibaba.druid.sql.ast.statement.SQLShowTableGroupsStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowTablesStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowUsersStatement;
import com.alibaba.druid.sql.ast.statement.SQLShowViewsStatement;
import com.alibaba.druid.sql.ast.statement.SQLStartTransactionStatement;
import com.alibaba.druid.sql.ast.statement.SQLSubmitJobStatement;
import com.alibaba.druid.sql.ast.statement.SQLSubqueryTableSource;
import com.alibaba.druid.sql.ast.statement.SQLSyncMetaStatement;
import com.alibaba.druid.sql.ast.statement.SQLTableLike;
import com.alibaba.druid.sql.ast.statement.SQLTableSampling;
import com.alibaba.druid.sql.ast.statement.SQLTruncateStatement;
import com.alibaba.druid.sql.ast.statement.SQLUnionQuery;
import com.alibaba.druid.sql.ast.statement.SQLUnionQueryTableSource;
import com.alibaba.druid.sql.ast.statement.SQLUnique;
import com.alibaba.druid.sql.ast.statement.SQLUnnestTableSource;
import com.alibaba.druid.sql.ast.statement.SQLUpdateSetItem;
import com.alibaba.druid.sql.ast.statement.SQLUpdateStatement;
import com.alibaba.druid.sql.ast.statement.SQLUseStatement;
import com.alibaba.druid.sql.ast.statement.SQLValuesQuery;
import com.alibaba.druid.sql.ast.statement.SQLValuesTableSource;
import com.alibaba.druid.sql.ast.statement.SQLWhileStatement;
import com.alibaba.druid.sql.ast.statement.SQLWhoamiStatement;
import com.alibaba.druid.sql.ast.statement.SQLWithSubqueryClause;
import com.alibaba.druid.sql.dialect.db2.ast.DB2SQLIndexSpec;
import com.alibaba.druid.sql.dialect.db2.ast.DB2SQLPartition;
import com.alibaba.druid.sql.dialect.db2.ast.DB2SQLPartitionBy;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2BoxExpr;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2CidrExpr;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2CircleExpr;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2ColumnSimpleDefinitionExpr;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2CurrentTimeExpr;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2ExtractExpr;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2InetExpr;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2LineSegmentsExpr;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2MacAddrExpr;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2OptionValue;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2PointExpr;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2PolygonExpr;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2SQLObjectCollection;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2SchemaTables;
import com.alibaba.druid.sql.dialect.db2.ast.expr.DB2TypeCastExpr;
import com.alibaba.druid.sql.dialect.db2.ast.expr.constraint.DB2Constraint;
import com.alibaba.druid.sql.dialect.db2.ast.expr.constraint.DB2StorageParameter;
import com.alibaba.druid.sql.dialect.db2.ast.expr.tablesource.DB2ExprTableSource;
import com.alibaba.druid.sql.dialect.db2.ast.expr.tablesource.DB2FunctionTableSource;
import com.alibaba.druid.sql.dialect.db2.ast.expr.tablesource.DB2MethodInvokeTableSource;
import com.alibaba.druid.sql.dialect.db2.ast.expr.tablesource.DB2RowsFromTableSource;
import com.alibaba.druid.sql.dialect.db2.ast.expr.tablesource.DB2SubqueryTableSource;
import com.alibaba.druid.sql.dialect.db2.ast.expr.tablesource.DB2ValuesTableSource;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterDatabaseStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterGroupStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterIndexStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterRoleStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterSchemaStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterSequenceStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterSessionStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterSynonymStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterSystemKillSessionStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterTableSpaceStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterTableStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterTriggerStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2AlterViewStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CommonStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2ConnectToStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateDatabaseStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateGroupStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateIndexStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateMaterializedViewStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateRoleStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateSchemaStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateSeqenceStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateSynonymStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateTableAsStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateTableSpaceStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateTableStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateTriggerStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2CreateViewStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2DeleteStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2DropConnectionStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2DropSchemaStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2DropSequenceStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2DropSessionStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2DropTriggerStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2GrantStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2InsertStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2LockTableStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2RevokeStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2SelectQueryBlock;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2SelectStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2SetConnectionStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2SetSessionStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2SetTransactionStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2ShowStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2StartTransactionStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.DB2UpdateStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableAddColumn;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableAddConstraint;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableAlterColumn;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableAlterColumnOptions;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableCluster;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableDisableEnabelTrigger;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableDropColumn;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableDropConstraint;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableInheriteOrNotParentTable;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableModify;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableOf;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableRenameColumn;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableRenameConstraint;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableRenameTo;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableSetNewTableSpace;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableSetReset;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableSetSchema;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableSetTableSpace;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableSetWith;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterTableValidateConstraint;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2AlterUserStatement;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2ColumnDefinition;
import com.alibaba.druid.sql.dialect.db2.ast.stmt.alterTable.DB2CreateUserStatement;
import com.alibaba.druid.sql.dialect.db2.visitor.DB2ASTVisitor;
import com.alibaba.druid.sql.dialect.hive.ast.HiveInputOutputFormat;
import com.alibaba.druid.sql.dialect.hive.ast.stmt.HiveCreateTableStatement;
import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlKillStatement;
import com.alibaba.druid.sql.dialect.mysql.ast.statement.SQLAlterResourceGroupStatement;
import com.alibaba.druid.sql.dialect.mysql.ast.statement.SQLCreateResourceGroupStatement;
import com.alibaba.druid.sql.dialect.mysql.ast.statement.SQLListResourceGroupStatement;
import com.alibaba.druid.wall.WallProvider;
import com.alibaba.druid.wall.WallVisitor;

public class DB2WallVisitor extends WallVisitorBase implements WallVisitor, DB2ASTVisitor {
   public DB2WallVisitor(WallProvider provider) {
      super(provider);
   }

   public boolean isDenyTable(String name) {
      if (!this.config.isTableCheck()) {
         return false;
      } else {
         name = WallVisitorUtils.form(name);
         if (!name.startsWith("v$") && !name.startsWith("v_$")) {
            return !this.provider.checkDenyTable(name);
         } else {
            return true;
         }
      }
   }

   public DbType getDbType() {
      return DbType.db2;
   }

   public void endVisit(DB2SelectQueryBlock x) {
      this.endVisit((SQLSelectQueryBlock)x);
   }

   public boolean visit(DB2SelectQueryBlock x) {
      return this.visit((SQLSelectQueryBlock)x);
   }

   public void endVisit(DB2SelectQueryBlock.FetchClause x) {
   }

   public boolean visit(DB2SelectQueryBlock.FetchClause x) {
      return true;
   }

   public void endVisit(DB2SelectQueryBlock.ForClause x) {
   }

   public boolean visit(DB2SelectQueryBlock.ForClause x) {
      return true;
   }

   public void endVisit(DB2DeleteStatement x) {
   }

   public boolean visit(DB2DeleteStatement x) {
      return true;
   }

   public void endVisit(DB2InsertStatement x) {
   }

   public boolean visit(DB2InsertStatement x) {
      return true;
   }

   public void endVisit(DB2SelectStatement x) {
      this.endVisit((SQLSelectStatement)x);
   }

   public boolean visit(DB2SelectStatement x) {
      return this.visit((SQLSelectStatement)x);
   }

   public void endVisit(DB2UpdateStatement x) {
   }

   public boolean visit(DB2UpdateStatement x) {
      return true;
   }

   public void endVisit(DB2FunctionTableSource x) {
   }

   public boolean visit(DB2FunctionTableSource x) {
      return true;
   }

   public void endVisit(DB2TypeCastExpr x) {
   }

   public boolean visit(DB2TypeCastExpr x) {
      return true;
   }

   public void endVisit(DB2ExtractExpr x) {
   }

   public boolean visit(DB2ExtractExpr x) {
      return true;
   }

   public void endVisit(DB2BoxExpr x) {
   }

   public boolean visit(DB2BoxExpr x) {
      return true;
   }

   public void endVisit(DB2PointExpr x) {
   }

   public boolean visit(DB2PointExpr x) {
      return true;
   }

   public void endVisit(DB2MacAddrExpr x) {
   }

   public boolean visit(DB2MacAddrExpr x) {
      return true;
   }

   public void endVisit(DB2InetExpr x) {
   }

   public boolean visit(DB2InetExpr x) {
      return true;
   }

   public void endVisit(DB2CidrExpr x) {
   }

   public boolean visit(DB2CidrExpr x) {
      return true;
   }

   public void endVisit(DB2PolygonExpr x) {
   }

   public boolean visit(DB2PolygonExpr x) {
      return true;
   }

   public void endVisit(DB2CircleExpr x) {
   }

   public boolean visit(DB2CircleExpr x) {
      return true;
   }

   public void endVisit(DB2LineSegmentsExpr x) {
   }

   public boolean visit(DB2LineSegmentsExpr x) {
      return true;
   }

   public void endVisit(DB2ShowStatement x) {
   }

   public boolean visit(DB2ShowStatement x) {
      return true;
   }

   public void endVisit(DB2StartTransactionStatement x) {
   }

   public boolean visit(DB2StartTransactionStatement x) {
      return true;
   }

   public void endVisit(DB2ConnectToStatement x) {
   }

   public boolean visit(DB2ConnectToStatement x) {
      return true;
   }

   public void endVisit(DB2CreateSchemaStatement x) {
   }

   public boolean visit(DB2CreateSchemaStatement x) {
      return true;
   }

   public void endVisit(DB2DropSchemaStatement x) {
   }

   public boolean visit(DB2DropSchemaStatement x) {
      return true;
   }

   public void endVisit(DB2AlterSchemaStatement x) {
   }

   public boolean visit(DB2AlterSchemaStatement x) {
      return true;
   }

   public void endVisit(DB2MethodInvokeTableSource x) {
   }

   public boolean visit(DB2MethodInvokeTableSource x) {
      return true;
   }

   public void endVisit(DB2ExprTableSource x) {
   }

   public boolean visit(DB2ExprTableSource x) {
      return true;
   }

   public void endVisit(DB2SubqueryTableSource x) {
   }

   public boolean visit(DB2SubqueryTableSource x) {
      return true;
   }

   public void endVisit(DB2ValuesTableSource x) {
   }

   public boolean visit(DB2ValuesTableSource x) {
      return true;
   }

   public void endVisit(DB2ValuesTableSource.ValueRow x) {
   }

   public boolean visit(DB2ValuesTableSource.ValueRow x) {
      return true;
   }

   public void endVisit(DB2SelectQueryBlock.ForClauses x) {
   }

   public boolean visit(DB2SelectQueryBlock.ForClauses x) {
      return true;
   }

   public void endVisit(DB2ColumnSimpleDefinitionExpr x) {
   }

   public boolean visit(DB2ColumnSimpleDefinitionExpr x) {
      return true;
   }

   public void endVisit(DB2RowsFromTableSource x) {
   }

   public boolean visit(DB2RowsFromTableSource x) {
      return true;
   }

   public void endVisit(DB2AlterDatabaseStatement x) {
   }

   public boolean visit(DB2AlterDatabaseStatement x) {
      return true;
   }

   public void endVisit(DB2AlterIndexStatement x) {
   }

   public boolean visit(DB2AlterIndexStatement x) {
      return true;
   }

   public void endVisit(DB2AlterSequenceStatement x) {
   }

   public boolean visit(DB2AlterSequenceStatement x) {
      return true;
   }

   public void endVisit(DB2AlterTableStatement x) {
   }

   public boolean visit(DB2AlterTableStatement x) {
      return true;
   }

   public void endVisit(DB2AlterTableRenameColumn x) {
   }

   public boolean visit(DB2AlterTableRenameColumn x) {
      return true;
   }

   public void endVisit(DB2AlterTableRenameConstraint x) {
   }

   public boolean visit(DB2AlterTableRenameConstraint x) {
      return true;
   }

   public void endVisit(DB2AlterTableRenameTo x) {
   }

   public boolean visit(DB2AlterTableRenameTo x) {
      return true;
   }

   public void endVisit(DB2AlterTableSetSchema x) {
   }

   public boolean visit(DB2AlterTableSetSchema x) {
      return true;
   }

   public void endVisit(DB2AlterTableSetNewTableSpace x) {
   }

   public boolean visit(DB2AlterTableSetNewTableSpace x) {
      return true;
   }

   public void endVisit(DB2AlterTableSetWith x) {
   }

   public boolean visit(DB2AlterTableSetWith x) {
      return true;
   }

   public void endVisit(DB2AlterTableAddColumn x) {
   }

   public boolean visit(DB2AlterTableAddColumn x) {
      return true;
   }

   public void endVisit(DB2AlterTableSetWith.DB2AlterTableDistributeByOption x) {
   }

   public boolean visit(DB2AlterTableSetWith.DB2AlterTableDistributeByOption x) {
      return true;
   }

   public void endVisit(DB2AlterTableDropColumn x) {
   }

   public boolean visit(DB2AlterTableDropColumn x) {
      return true;
   }

   public void endVisit(DB2AlterTableAlterColumn x) {
   }

   public boolean visit(DB2AlterTableAlterColumn x) {
      return true;
   }

   public void endVisit(DB2AlterTableAlterColumnOptions x) {
   }

   public boolean visit(DB2AlterTableAlterColumnOptions x) {
      return true;
   }

   public void endVisit(DB2AlterTableAlterColumnOptions.DB2AlterTableAlterColumnOptionValue x) {
   }

   public boolean visit(DB2AlterTableAlterColumnOptions.DB2AlterTableAlterColumnOptionValue x) {
      return true;
   }

   public void endVisit(DB2AlterTableAddConstraint x) {
   }

   public boolean visit(DB2AlterTableAddConstraint x) {
      return true;
   }

   public void endVisit(DB2AlterTableAddConstraint.DB2AlterTableAddConstraintUsingIndex x) {
   }

   public boolean visit(DB2AlterTableAddConstraint.DB2AlterTableAddConstraintUsingIndex x) {
      return true;
   }

   public void endVisit(DB2AlterTableValidateConstraint x) {
   }

   public boolean visit(DB2AlterTableValidateConstraint x) {
      return true;
   }

   public void endVisit(DB2AlterTableDropConstraint x) {
   }

   public boolean visit(DB2AlterTableDropConstraint x) {
      return true;
   }

   public void endVisit(DB2AlterTableDisableEnabelTrigger x) {
   }

   public boolean visit(DB2AlterTableDisableEnabelTrigger x) {
      return true;
   }

   public void endVisit(DB2AlterTableCluster x) {
   }

   public boolean visit(DB2AlterTableCluster x) {
      return true;
   }

   public void endVisit(DB2AlterTableSetReset x) {
   }

   public boolean visit(DB2AlterTableSetReset x) {
      return true;
   }

   public void endVisit(DB2AlterTableSetReset.StorageParameter x) {
   }

   public boolean visit(DB2AlterTableSetReset.StorageParameter x) {
      return true;
   }

   public void endVisit(DB2AlterTableInheriteOrNotParentTable x) {
   }

   public boolean visit(DB2AlterTableInheriteOrNotParentTable x) {
      return true;
   }

   public void endVisit(DB2AlterTableOf x) {
   }

   public boolean visit(DB2AlterTableOf x) {
      return true;
   }

   public void endVisit(DB2AlterTableSetTableSpace x) {
   }

   public boolean visit(DB2AlterTableSetTableSpace x) {
      return true;
   }

   public void endVisit(DB2CreateDatabaseStatement x) {
   }

   public boolean visit(DB2CreateDatabaseStatement x) {
      return true;
   }

   public void endVisit(DB2Constraint x) {
   }

   public boolean visit(DB2Constraint x) {
      return true;
   }

   public void endVisit(DB2Constraint.DB2ConstraintCheck x) {
   }

   public boolean visit(DB2Constraint.DB2ConstraintCheck x) {
      return true;
   }

   public void endVisit(DB2Constraint.DB2Unique x) {
   }

   public boolean visit(DB2Constraint.DB2Unique x) {
      return true;
   }

   public void endVisit(DB2Constraint.DB2PrimaryKey x) {
   }

   public boolean visit(DB2Constraint.DB2PrimaryKey x) {
      return true;
   }

   public void endVisit(DB2Constraint.DB2ForeignKey x) {
   }

   public boolean visit(DB2Constraint.DB2ForeignKey x) {
      return true;
   }

   public void endVisit(DB2OptionValue x) {
   }

   public boolean visit(DB2OptionValue x) {
      return true;
   }

   public void endVisit(DB2StorageParameter x) {
   }

   public boolean visit(DB2StorageParameter x) {
      return true;
   }

   public void endVisit(DB2Constraint.DB2IndexParamaters x) {
   }

   public boolean visit(DB2Constraint.DB2IndexParamaters x) {
      return true;
   }

   public void endVisit(DB2Constraint.DB2Reference x) {
   }

   public boolean visit(DB2Constraint.DB2Reference x) {
      return true;
   }

   public void endVisit(DB2ColumnDefinition x) {
   }

   public boolean visit(DB2ColumnDefinition x) {
      return true;
   }

   public void endVisit(DB2CreateTableStatement x) {
   }

   public boolean visit(DB2CreateTableStatement x) {
      return true;
   }

   public void endVisit(DB2CreateTableStatement.DB2TableDistributedBy x) {
   }

   public boolean visit(DB2CreateTableStatement.DB2TableDistributedBy x) {
      return true;
   }

   public void endVisit(DB2SQLObjectCollection x) {
   }

   public boolean visit(DB2SQLObjectCollection x) {
      return true;
   }

   public void endVisit(DB2SchemaTables x) {
   }

   public boolean visit(DB2SchemaTables x) {
      return true;
   }

   public void endVisit(DB2GrantStatement x) {
   }

   public boolean visit(DB2GrantStatement x) {
      return true;
   }

   public boolean visit(DB2AlterViewStatement x) {
      return true;
   }

   public boolean visit(DB2CreateSeqenceStatement x) {
      return true;
   }

   public boolean visit(DB2CreateTableSpaceStatement x) {
      return true;
   }

   public boolean visit(DB2CreateViewStatement x) {
      return true;
   }

   public boolean visit(DB2DropSequenceStatement x) {
      return true;
   }

   public boolean visit(DB2SQLPartitionBy x) {
      return true;
   }

   public boolean visit(DB2SQLPartition x) {
      return true;
   }

   public boolean visit(DB2SQLIndexSpec x) {
      return true;
   }

   public boolean visit(DB2CreateIndexStatement x) {
      return true;
   }

   public void endVisit(DB2AlterSessionStatement x) {
   }

   public boolean visit(DB2AlterSessionStatement x) {
      return true;
   }

   public void endVisit(DB2AlterSystemKillSessionStatement x) {
   }

   public boolean visit(DB2AlterSystemKillSessionStatement x) {
      return true;
   }

   public void endVisit(DB2AlterTableSpaceStatement x) {
   }

   public boolean visit(DB2AlterTableSpaceStatement x) {
      return true;
   }

   public void endVisit(DB2AlterTableModify x) {
   }

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

   public void endVisit(DB2CreateUserStatement x) {
   }

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

   public void endVisit(DB2AlterUserStatement x) {
   }

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

   public void endVisit(DB2CommonStatement x) {
   }

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

   public void endVisit(DB2CreateGroupStatement x) {
   }

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

   public void endVisit(DB2AlterGroupStatement x) {
   }

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

   public void endVisit(DB2CreateMaterializedViewStatement x) {
   }

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

   public void endVisit(DB2DropSequenceStatement x) {
   }

   public void endVisit(DB2CreateSynonymStatement x) {
   }

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

   public void endVisit(DB2AlterSynonymStatement x) {
   }

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

   public void endVisit(DB2CreateRoleStatement x) {
   }

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

   public void endVisit(DB2AlterRoleStatement x) {
   }

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

   public void endVisit(DB2CreateTableAsStatement x) {
   }

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

   public void endVisit(DB2RevokeStatement x) {
   }

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

   public void endVisit(DB2CreateTriggerStatement x) {
   }

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

   public void endVisit(DB2AlterTriggerStatement x) {
   }

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

   public void endVisit(DB2DropTriggerStatement x) {
   }

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

   public void endVisit(DB2SetTransactionStatement x) {
   }

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

   public void endVisit(DB2SetSessionStatement x) {
   }

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

   public void endVisit(DB2DropSessionStatement x) {
   }

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

   public void endVisit(DB2SetConnectionStatement x) {
   }

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

   public void endVisit(DB2DropConnectionStatement x) {
   }

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

   public void endVisit(DB2LockTableStatement x) {
   }

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

   public void endVisit(DB2CurrentTimeExpr x) {
   }

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

   public void endVisit(SQLAllColumnExpr x) {
   }

   public void endVisit(SQLBetweenExpr x) {
   }

   public void endVisit(SQLBinaryOpExpr x) {
   }

   public void endVisit(SQLCaseExpr x) {
   }

   public void endVisit(SQLCaseExpr.Item x) {
   }

   public void endVisit(SQLCaseStatement x) {
   }

   public void endVisit(SQLCaseStatement.Item x) {
   }

   public void endVisit(SQLCharExpr x) {
   }

   public void endVisit(SQLIdentifierExpr x) {
   }

   public void endVisit(SQLInListExpr x) {
   }

   public void endVisit(SQLIntegerExpr x) {
   }

   public void endVisit(SQLSmallIntExpr x) {
   }

   public void endVisit(SQLBigIntExpr x) {
   }

   public void endVisit(SQLTinyIntExpr x) {
   }

   public void endVisit(SQLExistsExpr x) {
   }

   public void endVisit(SQLNCharExpr x) {
   }

   public void endVisit(SQLNotExpr x) {
   }

   public void endVisit(SQLNullExpr x) {
   }

   public void endVisit(SQLNumberExpr x) {
   }

   public void endVisit(SQLRealExpr x) {
   }

   public void endVisit(SQLPropertyExpr x) {
   }

   public void endVisit(SQLSelectGroupByClause x) {
   }

   public void endVisit(SQLSelectItem x) {
   }

   public void endVisit(SQLSelectStatement x) {
   }

   public void postVisit(SQLObject x) {
   }

   public void preVisit(SQLObject x) {
   }

   public boolean visit(SQLAllColumnExpr x) {
      return true;
   }

   public boolean visit(SQLBetweenExpr x) {
      return true;
   }

   public boolean visit(SQLBinaryOpExpr x) {
      return true;
   }

   public boolean visit(SQLCaseExpr x) {
      return true;
   }

   public boolean visit(SQLCaseExpr.Item x) {
      return true;
   }

   public boolean visit(SQLCaseStatement x) {
      return true;
   }

   public boolean visit(SQLCaseStatement.Item x) {
      return true;
   }

   public boolean visit(SQLCastExpr x) {
      return true;
   }

   public boolean visit(SQLCharExpr x) {
      return true;
   }

   public boolean visit(SQLExistsExpr x) {
      return true;
   }

   public boolean visit(SQLIdentifierExpr x) {
      return true;
   }

   public boolean visit(SQLInListExpr x) {
      return true;
   }

   public boolean visit(SQLIntegerExpr x) {
      return true;
   }

   public boolean visit(SQLSmallIntExpr x) {
      return true;
   }

   public boolean visit(SQLBigIntExpr x) {
      return true;
   }

   public boolean visit(SQLTinyIntExpr x) {
      return true;
   }

   public boolean visit(SQLNCharExpr x) {
      return true;
   }

   public boolean visit(SQLNotExpr x) {
      return true;
   }

   public boolean visit(SQLNullExpr x) {
      return true;
   }

   public boolean visit(SQLNumberExpr x) {
      return true;
   }

   public boolean visit(SQLRealExpr x) {
      return true;
   }

   public boolean visit(SQLPropertyExpr x) {
      return true;
   }

   public boolean visit(SQLSelectGroupByClause x) {
      return true;
   }

   public boolean visit(SQLSelectItem x) {
      return true;
   }

   public void endVisit(SQLCastExpr x) {
   }

   public boolean visit(SQLSelectStatement x) {
      return true;
   }

   public void endVisit(SQLAggregateExpr x) {
   }

   public boolean visit(SQLAggregateExpr x) {
      return true;
   }

   public boolean visit(SQLVariantRefExpr x) {
      return true;
   }

   public void endVisit(SQLVariantRefExpr x) {
   }

   public boolean visit(SQLQueryExpr x) {
      return true;
   }

   public void endVisit(SQLQueryExpr x) {
   }

   public boolean visit(SQLUnaryExpr x) {
      return true;
   }

   public void endVisit(SQLUnaryExpr x) {
   }

   public boolean visit(SQLHexExpr x) {
      return true;
   }

   public void endVisit(SQLHexExpr x) {
   }

   public boolean visit(SQLSelect x) {
      return true;
   }

   public void endVisit(SQLSelect select) {
   }

   public boolean visit(SQLSelectQueryBlock x) {
      return true;
   }

   public void endVisit(SQLSelectQueryBlock x) {
   }

   public boolean visit(SQLExprTableSource x) {
      return true;
   }

   public void endVisit(SQLExprTableSource x) {
   }

   public boolean visit(SQLOrderBy x) {
      return true;
   }

   public void endVisit(SQLOrderBy x) {
   }

   public boolean visit(SQLSelectOrderByItem x) {
      return true;
   }

   public void endVisit(SQLSelectOrderByItem x) {
   }

   public boolean visit(SQLDropTableStatement x) {
      return true;
   }

   public void endVisit(SQLDropTableStatement x) {
   }

   public boolean visit(SQLCreateTableStatement x) {
      return true;
   }

   public void endVisit(SQLCreateTableStatement x) {
   }

   public boolean visit(SQLColumnDefinition x) {
      return true;
   }

   public void endVisit(SQLColumnDefinition x) {
   }

   public boolean visit(SQLColumnDefinition.Identity x) {
      return true;
   }

   public void endVisit(SQLColumnDefinition.Identity x) {
   }

   public boolean visit(SQLDataType x) {
      return true;
   }

   public void endVisit(SQLDataType x) {
   }

   public boolean visit(SQLCharacterDataType x) {
      return true;
   }

   public void endVisit(SQLCharacterDataType x) {
   }

   public boolean visit(SQLDeleteStatement x) {
      return true;
   }

   public void endVisit(SQLDeleteStatement x) {
   }

   public boolean visit(SQLCurrentOfCursorExpr x) {
      return true;
   }

   public void endVisit(SQLCurrentOfCursorExpr x) {
   }

   public boolean visit(SQLInsertStatement x) {
      return true;
   }

   public void endVisit(SQLInsertStatement x) {
   }

   public boolean visit(SQLInsertStatement.ValuesClause x) {
      return true;
   }

   public void endVisit(SQLInsertStatement.ValuesClause x) {
   }

   public boolean visit(SQLUpdateSetItem x) {
      return true;
   }

   public void endVisit(SQLUpdateSetItem x) {
   }

   public boolean visit(SQLUpdateStatement x) {
      return true;
   }

   public void endVisit(SQLUpdateStatement x) {
   }

   public boolean visit(SQLCreateViewStatement x) {
      return true;
   }

   public void endVisit(SQLCreateViewStatement x) {
   }

   public boolean visit(SQLCreateViewStatement.Column x) {
      return true;
   }

   public void endVisit(SQLCreateViewStatement.Column x) {
   }

   public boolean visit(SQLNotNullConstraint x) {
      return true;
   }

   public void endVisit(SQLNotNullConstraint x) {
   }

   public void endVisit(SQLMethodInvokeExpr x) {
   }

   public boolean visit(SQLMethodInvokeExpr x) {
      return true;
   }

   public void endVisit(SQLUnionQuery x) {
   }

   public boolean visit(SQLUnionQuery x) {
      return true;
   }

   public void endVisit(SQLSetStatement x) {
   }

   public boolean visit(SQLSetStatement x) {
      return true;
   }

   public void endVisit(SQLAssignItem x) {
   }

   public boolean visit(SQLAssignItem x) {
      return true;
   }

   public void endVisit(SQLCallStatement x) {
   }

   public boolean visit(SQLCallStatement x) {
      return true;
   }

   public void endVisit(SQLJoinTableSource x) {
   }

   public boolean visit(SQLJoinTableSource x) {
      return true;
   }

   public void endVisit(SQLJoinTableSource.UDJ x) {
   }

   public boolean visit(SQLJoinTableSource.UDJ x) {
      return true;
   }

   public void endVisit(SQLSomeExpr x) {
   }

   public boolean visit(SQLSomeExpr x) {
      return true;
   }

   public void endVisit(SQLAnyExpr x) {
   }

   public boolean visit(SQLAnyExpr x) {
      return true;
   }

   public void endVisit(SQLAllExpr x) {
   }

   public boolean visit(SQLAllExpr x) {
      return true;
   }

   public void endVisit(SQLInSubQueryExpr x) {
   }

   public boolean visit(SQLInSubQueryExpr x) {
      return true;
   }

   public void endVisit(SQLListExpr x) {
   }

   public boolean visit(SQLListExpr x) {
      return true;
   }

   public void endVisit(SQLSubqueryTableSource x) {
   }

   public boolean visit(SQLSubqueryTableSource x) {
      return true;
   }

   public void endVisit(SQLTruncateStatement x) {
   }

   public boolean visit(SQLTruncateStatement x) {
      return true;
   }

   public void endVisit(SQLDefaultExpr x) {
   }

   public boolean visit(SQLDefaultExpr x) {
      return true;
   }

   public void endVisit(SQLCommentStatement x) {
   }

   public boolean visit(SQLCommentStatement x) {
      return true;
   }

   public void endVisit(SQLUseStatement x) {
   }

   public boolean visit(SQLUseStatement x) {
      return true;
   }

   public boolean visit(SQLAlterTableAddColumn x) {
      return true;
   }

   public void endVisit(SQLAlterTableAddColumn x) {
   }

   public boolean visit(SQLAlterTableDeleteByCondition x) {
      return true;
   }

   public void endVisit(SQLAlterTableDeleteByCondition x) {
   }

   public boolean visit(SQLAlterTableModifyClusteredBy x) {
      return true;
   }

   public void endVisit(SQLAlterTableModifyClusteredBy x) {
   }

   public boolean visit(SQLAlterTableDropColumnItem x) {
      return true;
   }

   public void endVisit(SQLAlterTableDropColumnItem x) {
   }

   public boolean visit(SQLAlterTableDropIndex x) {
      return true;
   }

   public void endVisit(SQLAlterTableDropIndex x) {
   }

   public boolean visit(SQLAlterTableGroupStatement x) {
      return true;
   }

   public void endVisit(SQLAlterTableGroupStatement x) {
   }

   public boolean visit(SQLAlterSystemSetConfigStatement x) {
      return true;
   }

   public void endVisit(SQLAlterSystemSetConfigStatement x) {
   }

   public boolean visit(SQLAlterSystemGetConfigStatement x) {
      return true;
   }

   public void endVisit(SQLAlterSystemGetConfigStatement x) {
   }

   public boolean visit(SQLDropIndexStatement x) {
      return true;
   }

   public void endVisit(SQLDropIndexStatement x) {
   }

   public boolean visit(SQLDropViewStatement x) {
      return true;
   }

   public void endVisit(SQLDropViewStatement x) {
   }

   public boolean visit(SQLSavePointStatement x) {
      return true;
   }

   public void endVisit(SQLSavePointStatement x) {
   }

   public boolean visit(SQLRollbackStatement x) {
      return true;
   }

   public void endVisit(SQLRollbackStatement x) {
   }

   public boolean visit(SQLReleaseSavePointStatement x) {
      return true;
   }

   public void endVisit(SQLReleaseSavePointStatement x) {
   }

   public void endVisit(SQLCommentHint x) {
   }

   public boolean visit(SQLCommentHint x) {
      return true;
   }

   public void endVisit(SQLCreateDatabaseStatement x) {
   }

   public boolean visit(SQLCreateDatabaseStatement x) {
      return true;
   }

   public void endVisit(SQLOver x) {
   }

   public boolean visit(SQLOver x) {
      return true;
   }

   public void endVisit(SQLKeep x) {
   }

   public boolean visit(SQLKeep x) {
      return true;
   }

   public void endVisit(SQLColumnPrimaryKey x) {
   }

   public boolean visit(SQLColumnPrimaryKey x) {
      return true;
   }

   public boolean visit(SQLColumnUniqueKey x) {
      return true;
   }

   public void endVisit(SQLColumnUniqueKey x) {
   }

   public void endVisit(SQLWithSubqueryClause x) {
   }

   public boolean visit(SQLWithSubqueryClause x) {
      return true;
   }

   public void endVisit(SQLWithSubqueryClause.Entry x) {
   }

   public boolean visit(SQLWithSubqueryClause.Entry x) {
      return true;
   }

   public void endVisit(SQLAlterTableAlterColumn x) {
   }

   public boolean visit(SQLAlterTableAlterColumn x) {
      return true;
   }

   public boolean visit(SQLCheck x) {
      return true;
   }

   public void endVisit(SQLCheck x) {
   }

   public boolean visit(SQLDefault x) {
      return true;
   }

   public void endVisit(SQLDefault x) {
   }

   public boolean visit(SQLAlterTableDropForeignKey x) {
      return true;
   }

   public void endVisit(SQLAlterTableDropForeignKey x) {
   }

   public boolean visit(SQLAlterTableDropPrimaryKey x) {
      return true;
   }

   public void endVisit(SQLAlterTableDropPrimaryKey x) {
   }

   public boolean visit(SQLAlterTableDisableKeys x) {
      return true;
   }

   public void endVisit(SQLAlterTableDisableKeys x) {
   }

   public boolean visit(SQLAlterTableEnableKeys x) {
      return true;
   }

   public void endVisit(SQLAlterTableEnableKeys x) {
   }

   public boolean visit(SQLAlterTableStatement x) {
      return true;
   }

   public void endVisit(SQLAlterTableStatement x) {
   }

   public boolean visit(SQLAlterTableDisableConstraint x) {
      return true;
   }

   public void endVisit(SQLAlterTableDisableConstraint x) {
   }

   public boolean visit(SQLAlterTableEnableConstraint x) {
      return true;
   }

   public void endVisit(SQLAlterTableEnableConstraint x) {
   }

   public boolean visit(SQLColumnCheck x) {
      return true;
   }

   public void endVisit(SQLColumnCheck x) {
   }

   public boolean visit(SQLExprHint x) {
      return true;
   }

   public void endVisit(SQLExprHint x) {
   }

   public boolean visit(SQLAlterTableDropConstraint x) {
      return true;
   }

   public void endVisit(SQLAlterTableDropConstraint x) {
   }

   public boolean visit(SQLAlterTableDropCheck x) {
      return true;
   }

   public void endVisit(SQLAlterTableDropCheck x) {
   }

   public boolean visit(SQLUnique x) {
      return true;
   }

   public void endVisit(SQLUnique x) {
   }

   public boolean visit(SQLPrimaryKeyImpl x) {
      return true;
   }

   public void endVisit(SQLPrimaryKeyImpl x) {
   }

   public boolean visit(SQLCreateIndexStatement x) {
      return true;
   }

   public void endVisit(SQLCreateIndexStatement x) {
   }

   public boolean visit(SQLAlterTableRenameColumn x) {
      return true;
   }

   public void endVisit(SQLAlterTableRenameColumn x) {
   }

   public boolean visit(SQLColumnReference x) {
      return true;
   }

   public void endVisit(SQLColumnReference x) {
   }

   public boolean visit(SQLForeignKeyImpl x) {
      return true;
   }

   public void endVisit(SQLForeignKeyImpl x) {
   }

   public boolean visit(SQLDropSequenceStatement x) {
      return true;
   }

   public void endVisit(SQLDropSequenceStatement x) {
   }

   public boolean visit(SQLDropTriggerStatement x) {
      return true;
   }

   public void endVisit(SQLDropTriggerStatement x) {
   }

   public void endVisit(SQLDropUserStatement x) {
   }

   public boolean visit(SQLDropUserStatement x) {
      return true;
   }

   public void endVisit(SQLExplainStatement x) {
   }

   public boolean visit(SQLExplainStatement x) {
      return true;
   }

   public void endVisit(SQLGrantStatement x) {
   }

   public boolean visit(SQLGrantStatement x) {
      return true;
   }

   public void endVisit(SQLDropDatabaseStatement x) {
   }

   public boolean visit(SQLDropDatabaseStatement x) {
      return true;
   }

   public void endVisit(SQLIndexOptions x) {
   }

   public boolean visit(SQLIndexOptions x) {
      return true;
   }

   public void endVisit(SQLIndexDefinition x) {
   }

   public boolean visit(SQLIndexDefinition x) {
      return true;
   }

   public void endVisit(SQLAlterTableAddIndex x) {
   }

   public boolean visit(SQLAlterTableAddIndex x) {
      return true;
   }

   public void endVisit(SQLAlterTableAddConstraint x) {
   }

   public boolean visit(SQLAlterTableAddConstraint x) {
      return true;
   }

   public void endVisit(SQLCreateTriggerStatement x) {
   }

   public boolean visit(SQLCreateTriggerStatement x) {
      return true;
   }

   public void endVisit(SQLDropFunctionStatement x) {
   }

   public boolean visit(SQLDropFunctionStatement x) {
      return true;
   }

   public void endVisit(SQLDropTableSpaceStatement x) {
   }

   public boolean visit(SQLDropTableSpaceStatement x) {
      return true;
   }

   public void endVisit(SQLDropProcedureStatement x) {
   }

   public boolean visit(SQLDropProcedureStatement x) {
      return true;
   }

   public void endVisit(SQLBooleanExpr x) {
   }

   public boolean visit(SQLBooleanExpr x) {
      return true;
   }

   public void endVisit(SQLUnionQueryTableSource x) {
   }

   public boolean visit(SQLUnionQueryTableSource x) {
      return true;
   }

   public void endVisit(SQLTimestampExpr x) {
   }

   public boolean visit(SQLTimestampExpr x) {
      return true;
   }

   public void endVisit(SQLDateTimeExpr x) {
   }

   public boolean visit(SQLDateTimeExpr x) {
      return true;
   }

   public void endVisit(SQLDoubleExpr x) {
   }

   public boolean visit(SQLDoubleExpr x) {
      return true;
   }

   public void endVisit(SQLFloatExpr x) {
   }

   public boolean visit(SQLFloatExpr x) {
      return true;
   }

   public void endVisit(SQLRevokeStatement x) {
   }

   public boolean visit(SQLRevokeStatement x) {
      return true;
   }

   public void endVisit(SQLBinaryExpr x) {
   }

   public boolean visit(SQLBinaryExpr x) {
      return true;
   }

   public void endVisit(SQLAlterTableRename x) {
   }

   public boolean visit(SQLAlterTableRename x) {
      return true;
   }

   public void endVisit(SQLAlterViewRenameStatement x) {
   }

   public boolean visit(SQLAlterViewRenameStatement x) {
      return true;
   }

   public void endVisit(SQLShowTablesStatement x) {
   }

   public boolean visit(SQLShowTablesStatement x) {
      return true;
   }

   public void endVisit(SQLAlterTableAddPartition x) {
   }

   public boolean visit(SQLAlterTableAddPartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableAddExtPartition x) {
   }

   public boolean visit(SQLAlterTableAddExtPartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableDropExtPartition x) {
   }

   public boolean visit(SQLAlterTableDropExtPartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableDropPartition x) {
   }

   public boolean visit(SQLAlterTableDropPartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableRenamePartition x) {
   }

   public boolean visit(SQLAlterTableRenamePartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableSetComment x) {
   }

   public boolean visit(SQLAlterTableSetComment x) {
      return true;
   }

   public void endVisit(SQLAlterTableSetLifecycle x) {
   }

   public boolean visit(SQLPrivilegeItem x) {
      return true;
   }

   public void endVisit(SQLPrivilegeItem x) {
   }

   public boolean visit(SQLAlterTableSetLifecycle x) {
      return true;
   }

   public void endVisit(SQLAlterTableEnableLifecycle x) {
   }

   public boolean visit(SQLAlterTableSetLocation x) {
      return true;
   }

   public void endVisit(SQLAlterTableSetLocation x) {
   }

   public boolean visit(SQLAlterTableEnableLifecycle x) {
      return true;
   }

   public void endVisit(SQLAlterTablePartition x) {
   }

   public boolean visit(SQLAlterTablePartition x) {
      return true;
   }

   public void endVisit(SQLAlterTablePartitionSetProperties x) {
   }

   public boolean visit(SQLAlterTablePartitionSetProperties x) {
      return true;
   }

   public void endVisit(SQLAlterTableDisableLifecycle x) {
   }

   public boolean visit(SQLAlterTableDisableLifecycle x) {
      return true;
   }

   public void endVisit(SQLAlterTableTouch x) {
   }

   public boolean visit(SQLAlterTableTouch x) {
      return true;
   }

   public void endVisit(SQLArrayExpr x) {
   }

   public boolean visit(SQLArrayExpr x) {
      return true;
   }

   public void endVisit(SQLOpenStatement x) {
   }

   public boolean visit(SQLOpenStatement x) {
      return true;
   }

   public void endVisit(SQLFetchStatement x) {
   }

   public boolean visit(SQLFetchStatement x) {
      return true;
   }

   public void endVisit(SQLCloseStatement x) {
   }

   public boolean visit(SQLCloseStatement x) {
      return true;
   }

   public boolean visit(SQLGroupingSetExpr x) {
      return true;
   }

   public void endVisit(SQLGroupingSetExpr x) {
   }

   public boolean visit(SQLIfStatement x) {
      return true;
   }

   public void endVisit(SQLIfStatement x) {
   }

   public boolean visit(SQLIfStatement.ElseIf x) {
      return true;
   }

   public void endVisit(SQLIfStatement.ElseIf x) {
   }

   public boolean visit(SQLIfStatement.Else x) {
      return true;
   }

   public void endVisit(SQLIfStatement.Else x) {
   }

   public boolean visit(SQLLoopStatement x) {
      return true;
   }

   public void endVisit(SQLLoopStatement x) {
   }

   public boolean visit(SQLParameter x) {
      return true;
   }

   public void endVisit(SQLParameter x) {
   }

   public boolean visit(SQLCreateProcedureStatement x) {
      return true;
   }

   public void endVisit(SQLCreateProcedureStatement x) {
   }

   public boolean visit(SQLCreateFunctionStatement x) {
      return true;
   }

   public void endVisit(SQLCreateFunctionStatement x) {
   }

   public boolean visit(SQLBlockStatement x) {
      return true;
   }

   public void endVisit(SQLBlockStatement x) {
   }

   public boolean visit(SQLAlterTableDropKey x) {
      return true;
   }

   public void endVisit(SQLAlterTableDropKey x) {
   }

   public boolean visit(SQLDeclareItem x) {
      return true;
   }

   public void endVisit(SQLDeclareItem x) {
   }

   public boolean visit(SQLPartitionValue x) {
      return true;
   }

   public void endVisit(SQLPartitionValue x) {
   }

   public boolean visit(SQLPartition x) {
      return true;
   }

   public void endVisit(SQLPartition x) {
   }

   public boolean visit(SQLPartitionByRange x) {
      return true;
   }

   public void endVisit(SQLPartitionByRange x) {
   }

   public boolean visit(SQLPartitionByHash x) {
      return true;
   }

   public void endVisit(SQLPartitionByHash x) {
   }

   public boolean visit(SQLPartitionByList x) {
      return true;
   }

   public void endVisit(SQLPartitionByList x) {
   }

   public boolean visit(SQLSubPartition x) {
      return true;
   }

   public void endVisit(SQLSubPartition x) {
   }

   public boolean visit(SQLSubPartitionByHash x) {
      return true;
   }

   public void endVisit(SQLSubPartitionByHash x) {
   }

   public boolean visit(SQLSubPartitionByRange x) {
      return true;
   }

   public void endVisit(SQLSubPartitionByRange x) {
   }

   public boolean visit(SQLSubPartitionByList x) {
      return true;
   }

   public void endVisit(SQLSubPartitionByList x) {
   }

   public boolean visit(SQLAlterDatabaseStatement x) {
      return true;
   }

   public void endVisit(SQLAlterDatabaseStatement x) {
   }

   public boolean visit(SQLAlterTableConvertCharSet x) {
      return true;
   }

   public void endVisit(SQLAlterTableConvertCharSet x) {
   }

   public boolean visit(SQLAlterTableReOrganizePartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableReOrganizePartition x) {
   }

   public boolean visit(SQLAlterTableCoalescePartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableCoalescePartition x) {
   }

   public boolean visit(SQLAlterTableTruncatePartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableTruncatePartition x) {
   }

   public boolean visit(SQLAlterTableDiscardPartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableDiscardPartition x) {
   }

   public boolean visit(SQLAlterTableImportPartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableImportPartition x) {
   }

   public boolean visit(SQLAlterTableAnalyzePartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableAnalyzePartition x) {
   }

   public boolean visit(SQLAlterTableCheckPartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableCheckPartition x) {
   }

   public boolean visit(SQLAlterTableOptimizePartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableOptimizePartition x) {
   }

   public boolean visit(SQLAlterTableRebuildPartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableRebuildPartition x) {
   }

   public boolean visit(SQLAlterTableRepairPartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableRepairPartition x) {
   }

   public boolean visit(SQLSequenceExpr x) {
      return true;
   }

   public void endVisit(SQLSequenceExpr x) {
   }

   public boolean visit(SQLMergeStatement x) {
      return true;
   }

   public void endVisit(SQLMergeStatement x) {
   }

   public boolean visit(SQLMergeStatement.MergeUpdateClause x) {
      return true;
   }

   public void endVisit(SQLMergeStatement.MergeUpdateClause x) {
   }

   public boolean visit(SQLMergeStatement.MergeInsertClause x) {
      return true;
   }

   public void endVisit(SQLMergeStatement.MergeInsertClause x) {
   }

   public boolean visit(SQLErrorLoggingClause x) {
      return true;
   }

   public void endVisit(SQLErrorLoggingClause x) {
   }

   public boolean visit(SQLNullConstraint x) {
      return true;
   }

   public void endVisit(SQLNullConstraint x) {
   }

   public boolean visit(SQLCreateSequenceStatement x) {
      return true;
   }

   public void endVisit(SQLCreateSequenceStatement x) {
   }

   public boolean visit(SQLDateExpr x) {
      return true;
   }

   public void endVisit(SQLDateExpr x) {
   }

   public boolean visit(SQLLimit x) {
      return true;
   }

   public void endVisit(SQLLimit x) {
   }

   public void endVisit(SQLStartTransactionStatement x) {
   }

   public boolean visit(SQLStartTransactionStatement x) {
      return true;
   }

   public void endVisit(SQLDescribeStatement x) {
   }

   public boolean visit(SQLDescribeStatement x) {
      return true;
   }

   public boolean visit(SQLWhileStatement x) {
      return true;
   }

   public void endVisit(SQLWhileStatement x) {
   }

   public boolean visit(SQLDeclareStatement x) {
      return true;
   }

   public void endVisit(SQLDeclareStatement x) {
   }

   public boolean visit(SQLReturnStatement x) {
      return true;
   }

   public void endVisit(SQLReturnStatement x) {
   }

   public boolean visit(SQLArgument x) {
      return true;
   }

   public void endVisit(SQLArgument x) {
   }

   public boolean visit(SQLCommitStatement x) {
      return true;
   }

   public void endVisit(SQLCommitStatement x) {
   }

   public boolean visit(SQLFlashbackExpr x) {
      return true;
   }

   public void endVisit(SQLFlashbackExpr x) {
   }

   public boolean visit(SQLCreateMaterializedViewStatement x) {
      return true;
   }

   public void endVisit(SQLCreateMaterializedViewStatement x) {
   }

   public boolean visit(SQLShowCreateMaterializedViewStatement x) {
      return true;
   }

   public void endVisit(SQLShowCreateMaterializedViewStatement x) {
   }

   public boolean visit(SQLBinaryOpExprGroup x) {
      return true;
   }

   public void endVisit(SQLBinaryOpExprGroup x) {
   }

   public boolean visit(SQLScriptCommitStatement x) {
      return true;
   }

   public void endVisit(SQLScriptCommitStatement x) {
   }

   public boolean visit(SQLReplaceStatement x) {
      return true;
   }

   public void endVisit(SQLReplaceStatement x) {
   }

   public boolean visit(SQLCreateUserStatement x) {
      return true;
   }

   public void endVisit(SQLCreateUserStatement x) {
   }

   public boolean visit(SQLAlterFunctionStatement x) {
      return true;
   }

   public void endVisit(SQLAlterFunctionStatement x) {
   }

   public boolean visit(SQLAlterTypeStatement x) {
      return true;
   }

   public void endVisit(SQLAlterTypeStatement x) {
   }

   public boolean visit(SQLIntervalExpr x) {
      return true;
   }

   public void endVisit(SQLIntervalExpr x) {
   }

   public boolean visit(SQLLateralViewTableSource x) {
      return true;
   }

   public void endVisit(SQLLateralViewTableSource x) {
   }

   public boolean visit(SQLShowErrorsStatement x) {
      return true;
   }

   public void endVisit(SQLShowErrorsStatement x) {
   }

   public boolean visit(SQLShowGrantsStatement x) {
      return true;
   }

   public void endVisit(SQLShowGrantsStatement x) {
   }

   public boolean visit(SQLShowPackagesStatement x) {
      return true;
   }

   public void endVisit(SQLShowPackagesStatement x) {
   }

   public boolean visit(SQLShowRecylebinStatement x) {
      return true;
   }

   public void endVisit(SQLShowRecylebinStatement x) {
   }

   public boolean visit(SQLAlterCharacter x) {
      return true;
   }

   public void endVisit(SQLAlterCharacter x) {
   }

   public boolean visit(SQLExprStatement x) {
      return true;
   }

   public void endVisit(SQLExprStatement x) {
   }

   public boolean visit(SQLAlterProcedureStatement x) {
      return true;
   }

   public void endVisit(SQLAlterProcedureStatement x) {
   }

   public boolean visit(SQLAlterViewStatement x) {
      return true;
   }

   public void endVisit(SQLAlterViewStatement x) {
   }

   public boolean visit(SQLDropEventStatement x) {
      return true;
   }

   public void endVisit(SQLDropEventStatement x) {
   }

   public boolean visit(SQLDropLogFileGroupStatement x) {
      return true;
   }

   public void endVisit(SQLDropLogFileGroupStatement x) {
   }

   public boolean visit(SQLDropServerStatement x) {
      return true;
   }

   public void endVisit(SQLDropServerStatement x) {
   }

   public boolean visit(SQLDropSynonymStatement x) {
      return true;
   }

   public void endVisit(SQLDropSynonymStatement x) {
   }

   public boolean visit(SQLRecordDataType x) {
      return true;
   }

   public void endVisit(SQLRecordDataType x) {
   }

   public boolean visit(SQLDropTypeStatement x) {
      return true;
   }

   public void endVisit(SQLDropTypeStatement x) {
   }

   public boolean visit(SQLExternalRecordFormat x) {
      return true;
   }

   public void endVisit(SQLExternalRecordFormat x) {
   }

   public boolean visit(SQLArrayDataType x) {
      return true;
   }

   public void endVisit(SQLArrayDataType x) {
   }

   public boolean visit(SQLMapDataType x) {
      return true;
   }

   public void endVisit(SQLMapDataType x) {
   }

   public boolean visit(SQLStructDataType x) {
      return true;
   }

   public void endVisit(SQLStructDataType x) {
   }

   public boolean visit(SQLRowDataType x) {
      return true;
   }

   public void endVisit(SQLRowDataType x) {
   }

   public boolean visit(SQLStructDataType.Field x) {
      return true;
   }

   public void endVisit(SQLStructDataType.Field x) {
   }

   public boolean visit(SQLDropMaterializedViewStatement x) {
      return true;
   }

   public void endVisit(SQLDropMaterializedViewStatement x) {
   }

   public boolean visit(SQLShowMaterializedViewStatement x) {
      return true;
   }

   public void endVisit(SQLShowMaterializedViewStatement x) {
   }

   public boolean visit(SQLRefreshMaterializedViewStatement x) {
      return true;
   }

   public void endVisit(SQLRefreshMaterializedViewStatement x) {
   }

   public boolean visit(SQLAlterMaterializedViewStatement x) {
      return true;
   }

   public void endVisit(SQLAlterMaterializedViewStatement x) {
   }

   public boolean visit(SQLCreateTableGroupStatement x) {
      return true;
   }

   public void endVisit(SQLCreateTableGroupStatement x) {
   }

   public boolean visit(SQLDropTableGroupStatement x) {
      return true;
   }

   public void endVisit(SQLDropTableGroupStatement x) {
   }

   public boolean visit(SQLAlterTableSubpartitionAvailablePartitionNum x) {
      return true;
   }

   public void endVisit(SQLAlterTableSubpartitionAvailablePartitionNum x) {
   }

   public void endVisit(SQLShowDatabasesStatement x) {
   }

   public boolean visit(SQLShowDatabasesStatement x) {
      return true;
   }

   public void endVisit(SQLShowTableGroupsStatement x) {
   }

   public boolean visit(SQLShowTableGroupsStatement x) {
      return true;
   }

   public void endVisit(SQLShowColumnsStatement x) {
   }

   public boolean visit(SQLShowColumnsStatement x) {
      return true;
   }

   public void endVisit(SQLShowCreateTableStatement x) {
   }

   public boolean visit(SQLShowCreateTableStatement x) {
      return true;
   }

   public void endVisit(SQLShowProcessListStatement x) {
   }

   public boolean visit(SQLShowProcessListStatement x) {
      return true;
   }

   public void endVisit(SQLAlterTableSetOption x) {
   }

   public boolean visit(SQLAlterTableSetOption x) {
      return true;
   }

   public boolean visit(SQLShowCreateViewStatement x) {
      return true;
   }

   public void endVisit(SQLShowCreateViewStatement x) {
   }

   public boolean visit(SQLShowViewsStatement x) {
      return true;
   }

   public void endVisit(SQLShowViewsStatement x) {
   }

   public boolean visit(SQLAlterTableRenameIndex x) {
      return true;
   }

   public void endVisit(SQLAlterTableRenameIndex x) {
   }

   public boolean visit(SQLAlterSequenceStatement x) {
      return true;
   }

   public void endVisit(SQLAlterSequenceStatement x) {
   }

   public boolean visit(SQLAlterTableExchangePartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableExchangePartition x) {
   }

   public boolean visit(SQLCreateRoleStatement x) {
      return true;
   }

   public void endVisit(SQLCreateRoleStatement x) {
   }

   public boolean visit(SQLDropRoleStatement x) {
      return true;
   }

   public void endVisit(SQLDropRoleStatement x) {
   }

   public boolean visit(SQLAlterTableReplaceColumn x) {
      return true;
   }

   public void endVisit(SQLAlterTableReplaceColumn x) {
   }

   public boolean visit(SQLMatchAgainstExpr x) {
      return true;
   }

   public void endVisit(SQLMatchAgainstExpr x) {
   }

   public boolean visit(SQLTimeExpr x) {
      return true;
   }

   public void endVisit(SQLTimeExpr x) {
   }

   public boolean visit(SQLDropCatalogStatement x) {
      return true;
   }

   public void endVisit(SQLDropCatalogStatement x) {
   }

   public void endVisit(SQLShowPartitionsStmt x) {
   }

   public boolean visit(SQLShowPartitionsStmt x) {
      return true;
   }

   public void endVisit(SQLValuesExpr x) {
   }

   public boolean visit(SQLValuesExpr x) {
      return true;
   }

   public void endVisit(SQLContainsExpr x) {
   }

   public boolean visit(SQLContainsExpr x) {
      return true;
   }

   public void endVisit(SQLDumpStatement x) {
   }

   public boolean visit(SQLDumpStatement x) {
      return true;
   }

   public void endVisit(SQLValuesTableSource x) {
   }

   public boolean visit(SQLValuesTableSource x) {
      return true;
   }

   public void endVisit(SQLExtractExpr x) {
   }

   public boolean visit(SQLExtractExpr x) {
      return true;
   }

   public void endVisit(SQLWindow x) {
   }

   public boolean visit(SQLWindow x) {
      return true;
   }

   public void endVisit(SQLJSONExpr x) {
   }

   public boolean visit(SQLJSONExpr x) {
      return true;
   }

   public void endVisit(SQLDecimalExpr x) {
   }

   public boolean visit(SQLDecimalExpr x) {
      return true;
   }

   public void endVisit(SQLAnnIndex x) {
   }

   public boolean visit(SQLAnnIndex x) {
      return true;
   }

   public void endVisit(SQLUnionDataType x) {
   }

   public boolean visit(SQLUnionDataType x) {
      return true;
   }

   public void endVisit(SQLAlterTableRecoverPartitions x) {
   }

   public boolean visit(SQLAlterTableRecoverPartitions x) {
      return true;
   }

   public void endVisit(SQLAlterIndexStatement x) {
   }

   public boolean visit(SQLAlterIndexStatement x) {
      return true;
   }

   public boolean visit(SQLAlterIndexStatement.Rebuild x) {
      return true;
   }

   public void endVisit(SQLAlterIndexStatement.Rebuild x) {
   }

   public boolean visit(SQLShowIndexesStatement x) {
      return true;
   }

   public void endVisit(SQLShowIndexesStatement x) {
   }

   public boolean visit(SQLAnalyzeTableStatement x) {
      return true;
   }

   public void endVisit(SQLAnalyzeTableStatement x) {
   }

   public boolean visit(SQLExportTableStatement x) {
      return true;
   }

   public void endVisit(SQLExportTableStatement x) {
   }

   public boolean visit(SQLImportTableStatement x) {
      return true;
   }

   public void endVisit(SQLImportTableStatement x) {
   }

   public boolean visit(SQLTableSampling x) {
      return true;
   }

   public void endVisit(SQLTableSampling x) {
   }

   public boolean visit(SQLSizeExpr x) {
      return true;
   }

   public void endVisit(SQLSizeExpr x) {
   }

   public boolean visit(SQLAlterTableArchivePartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableArchivePartition x) {
   }

   public boolean visit(SQLAlterTableUnarchivePartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableUnarchivePartition x) {
   }

   public boolean visit(SQLCreateOutlineStatement x) {
      return true;
   }

   public void endVisit(SQLCreateOutlineStatement x) {
   }

   public boolean visit(SQLDropOutlineStatement x) {
      return true;
   }

   public void endVisit(SQLDropOutlineStatement x) {
   }

   public boolean visit(SQLAlterOutlineStatement x) {
      return true;
   }

   public void endVisit(SQLAlterOutlineStatement x) {
   }

   public boolean visit(SQLShowOutlinesStatement x) {
      return true;
   }

   public void endVisit(SQLShowOutlinesStatement x) {
   }

   public boolean visit(SQLPurgeTableStatement x) {
      return true;
   }

   public void endVisit(SQLPurgeTableStatement x) {
   }

   public boolean visit(SQLPurgeLogsStatement x) {
      return true;
   }

   public void endVisit(SQLPurgeLogsStatement x) {
   }

   public boolean visit(SQLPurgeRecyclebinStatement x) {
      return true;
   }

   public void endVisit(SQLPurgeRecyclebinStatement x) {
   }

   public boolean visit(SQLShowStatisticStmt x) {
      return true;
   }

   public void endVisit(SQLShowStatisticStmt x) {
   }

   public boolean visit(SQLShowStatisticListStmt x) {
      return true;
   }

   public void endVisit(SQLShowStatisticListStmt x) {
   }

   public boolean visit(SQLAlterTableAddSupplemental x) {
      return true;
   }

   public void endVisit(SQLAlterTableAddSupplemental x) {
   }

   public boolean visit(SQLShowCatalogsStatement x) {
      return true;
   }

   public void endVisit(SQLShowCatalogsStatement x) {
   }

   public boolean visit(SQLShowFunctionsStatement x) {
      return true;
   }

   public void endVisit(SQLShowFunctionsStatement x) {
   }

   public boolean visit(SQLShowSessionStatement x) {
      return true;
   }

   public void endVisit(SQLShowSessionStatement x) {
   }

   public boolean visit(SQLDbLinkExpr x) {
      return true;
   }

   public void endVisit(SQLDbLinkExpr x) {
   }

   public boolean visit(SQLCurrentTimeExpr x) {
      return true;
   }

   public void endVisit(SQLCurrentTimeExpr x) {
   }

   public boolean visit(SQLCurrentUserExpr x) {
      return true;
   }

   public void endVisit(SQLCurrentUserExpr x) {
   }

   public boolean visit(SQLShowQueryTaskStatement x) {
      return true;
   }

   public void endVisit(SQLShowQueryTaskStatement x) {
   }

   public boolean visit(SQLAdhocTableSource x) {
      return true;
   }

   public void endVisit(SQLAdhocTableSource x) {
   }

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

   public void endVisit(HiveCreateTableStatement x) {
   }

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

   public void endVisit(HiveInputOutputFormat x) {
   }

   public boolean visit(SQLExplainAnalyzeStatement x) {
      return true;
   }

   public void endVisit(SQLExplainAnalyzeStatement x) {
   }

   public boolean visit(SQLPartitionRef x) {
      return true;
   }

   public void endVisit(SQLPartitionRef x) {
   }

   public boolean visit(SQLPartitionRef.Item x) {
      return true;
   }

   public void endVisit(SQLPartitionRef.Item x) {
   }

   public boolean visit(SQLWhoamiStatement x) {
      return true;
   }

   public void endVisit(SQLWhoamiStatement x) {
   }

   public boolean visit(SQLDropResourceStatement x) {
      return true;
   }

   public void endVisit(SQLDropResourceStatement x) {
   }

   public boolean visit(SQLForStatement x) {
      return true;
   }

   public void endVisit(SQLForStatement x) {
   }

   public boolean visit(SQLUnnestTableSource x) {
      return true;
   }

   public void endVisit(SQLUnnestTableSource x) {
   }

   public boolean visit(SQLCopyFromStatement x) {
      return true;
   }

   public void endVisit(SQLCopyFromStatement x) {
   }

   public boolean visit(SQLShowUsersStatement x) {
      return true;
   }

   public void endVisit(SQLShowUsersStatement x) {
   }

   public boolean visit(SQLSubmitJobStatement x) {
      return true;
   }

   public void endVisit(SQLSubmitJobStatement x) {
   }

   public boolean visit(SQLTableLike x) {
      return true;
   }

   public void endVisit(SQLTableLike x) {
   }

   public boolean visit(SQLSyncMetaStatement x) {
      return true;
   }

   public void endVisit(SQLSyncMetaStatement x) {
   }

   public void endVisit(SQLValuesQuery x) {
   }

   public boolean visit(SQLValuesQuery x) {
      return true;
   }

   public void endVisit(SQLDataTypeRefExpr x) {
   }

   public boolean visit(SQLDataTypeRefExpr x) {
      return true;
   }

   public void endVisit(SQLArchiveTableStatement x) {
   }

   public boolean visit(SQLArchiveTableStatement x) {
      return true;
   }

   public void endVisit(SQLBackupStatement x) {
   }

   public boolean visit(SQLBackupStatement x) {
      return true;
   }

   public void endVisit(SQLRestoreStatement x) {
   }

   public boolean visit(SQLRestoreStatement x) {
      return true;
   }

   public void endVisit(SQLBuildTableStatement x) {
   }

   public boolean visit(SQLBuildTableStatement x) {
      return true;
   }

   public void endVisit(SQLCancelJobStatement x) {
   }

   public boolean visit(SQLCancelJobStatement x) {
      return true;
   }

   public void endVisit(SQLExportDatabaseStatement x) {
   }

   public boolean visit(SQLExportDatabaseStatement x) {
      return true;
   }

   public void endVisit(SQLImportDatabaseStatement x) {
   }

   public boolean visit(SQLImportDatabaseStatement x) {
      return true;
   }

   public void endVisit(SQLRenameUserStatement x) {
   }

   public boolean visit(SQLRenameUserStatement x) {
      return true;
   }

   public void endVisit(SQLPartitionByValue x) {
   }

   public boolean visit(SQLPartitionByValue x) {
      return true;
   }

   public void endVisit(SQLAlterTablePartitionCount x) {
   }

   public boolean visit(SQLAlterTablePartitionCount x) {
      return true;
   }

   public void endVisit(SQLAlterTableBlockSize x) {
   }

   public boolean visit(SQLAlterTableBlockSize x) {
      return true;
   }

   public void endVisit(SQLAlterTableCompression x) {
   }

   public boolean visit(SQLAlterTableCompression x) {
      return true;
   }

   public void endVisit(SQLAlterTablePartitionLifecycle x) {
   }

   public boolean visit(SQLAlterTablePartitionLifecycle x) {
      return true;
   }

   public void endVisit(SQLAlterTableSubpartitionLifecycle x) {
   }

   public boolean visit(SQLAlterTableSubpartitionLifecycle x) {
      return true;
   }

   public void endVisit(SQLAlterTableDropSubpartition x) {
   }

   public boolean visit(SQLAlterTableDropSubpartition x) {
      return true;
   }

   public void endVisit(SQLAlterTableDropClusteringKey x) {
   }

   public boolean visit(SQLAlterTableDropClusteringKey x) {
      return true;
   }

   public void endVisit(SQLAlterTableAddClusteringKey x) {
   }

   public boolean visit(SQLAlterTableAddClusteringKey x) {
      return true;
   }

   public void endVisit(MySqlKillStatement x) {
   }

   public boolean visit(MySqlKillStatement x) {
      return true;
   }

   public boolean visit(SQLCreateResourceGroupStatement x) {
      return true;
   }

   public void endVisit(SQLCreateResourceGroupStatement x) {
   }

   public boolean visit(SQLAlterResourceGroupStatement x) {
      return true;
   }

   public void endVisit(SQLAlterResourceGroupStatement x) {
   }

   public void endVisit(SQLDropResourceGroupStatement x) {
   }

   public boolean visit(SQLDropResourceGroupStatement x) {
      return true;
   }

   public void endVisit(SQLListResourceGroupStatement x) {
   }

   public boolean visit(SQLListResourceGroupStatement x) {
      return true;
   }

   public void endVisit(SQLAlterTableMergePartition x) {
   }

   public boolean visit(SQLAlterTableMergePartition x) {
      return true;
   }

   public void endVisit(SQLPartitionSpec x) {
   }

   public boolean visit(SQLPartitionSpec x) {
      return true;
   }

   public void endVisit(SQLPartitionSpec.Item x) {
   }

   public boolean visit(SQLPartitionSpec.Item x) {
      return true;
   }

   public boolean visit(SQLLoadIndexIntoCacheStatement x) {
      return true;
   }

   public void endVisit(SQLLoadIndexIntoCacheStatement x) {
   }

   public boolean visit(SQLAlterTableEnableTriggers x) {
      return true;
   }

   public void endVisit(SQLAlterTableEnableTriggers x) {
   }

   public boolean visit(SQLAlterTableDisableTriggers x) {
      return true;
   }

   public void endVisit(SQLAlterTableDisableTriggers x) {
   }

   public boolean visit(SQLAlterUserStatement x) {
      return true;
   }

   public void endVisit(SQLAlterUserStatement x) {
   }

   public boolean visit(SQLSetSchemaStatement x) {
      return true;
   }

   public void endVisit(SQLSetSchemaStatement x) {
   }

   public boolean visit(SQLCreateTablespaceStatement x) {
      return true;
   }

   public void endVisit(SQLCreateTablespaceStatement x) {
   }

   public boolean visit(SQLCreateTablespaceStatement.FileItem x) {
      return true;
   }

   public void endVisit(SQLCreateTablespaceStatement.FileItem x) {
   }

   public boolean visit(SQLAlterTablespaceStatement x) {
      return true;
   }

   public void endVisit(SQLAlterTablespaceStatement x) {
   }

   public boolean visit(SQLAlterTablespaceRename x) {
      return true;
   }

   public void endVisit(SQLAlterTablespaceRename x) {
   }

   public boolean visit(SQLAlterTablespaceRenameDatafile x) {
      return true;
   }

   public void endVisit(SQLAlterTablespaceRenameDatafile x) {
   }

   public boolean visit(SQLAlterTablespaceAddDatafile x) {
      return true;
   }

   public void endVisit(SQLAlterTablespaceAddDatafile x) {
   }

   public boolean visit(SQLAlterTablespaceResizeDatafile x) {
      return true;
   }

   public void endVisit(SQLAlterTablespaceResizeDatafile x) {
   }

   public boolean visit(SQLAlterTablespaceDatafile x) {
      return true;
   }

   public void endVisit(SQLAlterTablespaceDatafile x) {
   }

   public boolean visit(SQLCreateDomainStatement x) {
      return true;
   }

   public void endVisit(SQLCreateDomainStatement x) {
   }

   public boolean visit(SQLDropDomainStatement x) {
      return true;
   }

   public void endVisit(SQLDropDomainStatement x) {
   }

   public boolean visit(SQLCreateContextStatement x) {
      return true;
   }

   public void endVisit(SQLCreateContextStatement x) {
   }

   public boolean visit(SQLDropContextStatement x) {
      return true;
   }

   public void endVisit(SQLDropContextStatement x) {
   }

   public boolean visit(SQLCreateDirectoryStatement x) {
      return true;
   }

   public void endVisit(SQLCreateDirectoryStatement x) {
   }

   public boolean visit(SQLDropDirectoryStatement x) {
      return true;
   }

   public void endVisit(SQLDropDirectoryStatement x) {
   }

   public boolean visit(SQLSetTimeZoneStatement x) {
      return true;
   }

   public void endVisit(SQLSetTimeZoneStatement x) {
   }

   public boolean visit(SQLAlterSetNlsDateLanguageStatement x) {
      return true;
   }

   public void endVisit(SQLAlterSetNlsDateLanguageStatement x) {
   }

   public boolean visit(SQLAlterSetDateFormatStatement x) {
      return true;
   }

   public void endVisit(SQLAlterSetDateFormatStatement x) {
   }

   public boolean visit(SQLAlterSystemStatement x) {
      return true;
   }

   public void endVisit(SQLAlterSystemStatement x) {
   }

   public boolean visit(SQLAlterTablespaceCache x) {
      return true;
   }

   public void endVisit(SQLAlterTablespaceCache x) {
   }

   public boolean visit(SQLDropPackageStatement x) {
      return true;
   }

   public void endVisit(SQLDropPackageStatement x) {
   }
}
