package gudusoft.gsqlparser.stmt;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.nodes.*;
import gudusoft.gsqlparser.nodes.flink.TFlinkWatermarkClause;
import gudusoft.gsqlparser.nodes.flink.TFlinkWithClause;
import gudusoft.gsqlparser.nodes.hive.*;
import gudusoft.gsqlparser.nodes.netezza.TExternalTableOption;
import gudusoft.gsqlparser.nodes.oracle.TPhysicalProperties;
import gudusoft.gsqlparser.nodes.postgresql.TInheritsClause;
import gudusoft.gsqlparser.nodes.postgresql.TPartitionBoundSpecSqlNode;
import gudusoft.gsqlparser.nodes.teradata.TIndexDefinition;
import gudusoft.gsqlparser.nodes.teradata.TTeradataPeriodForClause;

import java.util.*;

/**
 * SQL create table statement.
 * <br>
 * {@link #getTargetTable} returns the created table. {@link #getColumnList()} returns columns created in the table.
 * <br> {@link #getTableConstraints()} returns table level constraints if any.
 * <br> {@link #getSubQuery()} returns select statement that generate data for this table.
 * <br><br>Example:
 * <pre>
 *     CREATE TABLE dbo.Employee (EmployeeID int PRIMARY KEY CLUSTERED);
 * </pre>
 * Table:dbo.Employee can be fetched from {@link #getTargetTable} or the first element of {@link #tables}
 * <br> column definitions: can be fetched from {@link #getColumnList}
 * <br>
 * table constraints: {@link #getTableConstraints}
 *
 */
public class TCreateTableSqlStatement extends TCustomSqlStatement {


    public TInheritsClause getInheritsClause() {
        return inheritsClause;
    }

    private TInheritsClause inheritsClause;

    private TBaseTablePartition tablePartition;


    public TBaseTablePartition getTablePartition() {
        return tablePartition;
    }

    public void setPartitionBoundSpec(TPartitionBoundSpecSqlNode partitionBoundSpec) {
        this.partitionBoundSpec = partitionBoundSpec;
    }

    public TPartitionBoundSpecSqlNode getPartitionBoundSpec() {
        return partitionBoundSpec;
    }

    /**
     * postgresql PartitionBoundSpec
     * https://www.postgresql.org/docs/current/sql-createtable.html
     */
    private TPartitionBoundSpecSqlNode partitionBoundSpec;

    public TTableProperties getTableProperties() {
        return tableProperties;
    }

    public void setTableProperties(TTableProperties tableProperties) {
        this.tableProperties = tableProperties;
    }

    private TTableProperties tableProperties;

    public enum TableSourceType  {normal,subquery,like,clone,copy,partitionOf,forExchangeWith,usingTemplate};
    private TableSourceType tableSourceType = TableSourceType.normal;

    private List<String> externalTableOptionList = null;

    /**
     * sql server create external table with options
     * @return
     */
    public  List<String> getExternalTableOptionNames(){
        return  TBaseType.getOptionNames(externalTableOptionList);
    }

    /**
     * sql server create external table with option.
     *
     * @param optionName
     * @return
     */
    public String getExternalTableOption(String optionName){
        return TBaseType.getOption(externalTableOptionList,optionName);
    }

    public TableSourceType getTableSourceType() {
        return tableSourceType;
    }

    private TObjectName cloneSourceTable = null;

    public TObjectName getCloneSourceTable() {
        return cloneSourceTable;
    }

    private TExternalTableOption externalTableOption = null;

    public TExternalTableOption getExternalTableOption() {
        return externalTableOption;
    }

    private TExpression partitionByExpr;

    public void setPartitionByExpr(TExpression partitionByExpr) {
        this.partitionByExpr = partitionByExpr;
    }

    /**
     * Bigquery partition by expr
     *
     * @return expr
     */
    public TExpression getPartitionByExpr() {
        return partitionByExpr;
    }

    private String awsSnsTopic = null;

    public void setAwsSnsTopic(String awsSnsTopic) {
        this.awsSnsTopic = awsSnsTopic;
    }

    public String getAwsSnsTopic() {
        return awsSnsTopic;
    }

    private TObjectNameList partitionColumnList;

    public void setPartitionColumnList(TObjectNameList partitionColumnList) {
        this.partitionColumnList = partitionColumnList;
    }

    public TObjectNameList getPartitionColumnList() {
        return partitionColumnList;
    }

    public void setFileFormatName(String fileFormatName) {
        this.fileFormatName = fileFormatName;
    }

    public void setFileFormatType(String fileFormatType) {
        this.fileFormatType = fileFormatType;
    }

    public String getFileFormatName() {
        return fileFormatName;
    }

    public String getFileFormatType() {
        return fileFormatType;
    }

    private String fileFormatName = null;
    private String fileFormatType = null;

    private String regex_pattern;

    public void setRegex_pattern(String regex_pattern) {
        this.regex_pattern = regex_pattern;
    }

    public String getRegex_pattern() {
        return regex_pattern;
    }

    private TStageLocation stageLocation;

    public void setStageLocation(TStageLocation stageLocation) {
        this.stageLocation = stageLocation;
    }

    public TStageLocation getStageLocation() {
        return stageLocation;
    }

    public void setTableOptions(ArrayList<TCreateTableOption> tableOptions) {
        this.tableOptions = tableOptions;
    }

    public ArrayList<TCreateTableOption> getTableOptions() {
        return tableOptions;
    }

    private ArrayList<TCreateTableOption> tableOptions;

    public void setOnFilegroup(TDummy onFilegroup) {
        this.onFilegroup = onFilegroup;
    }

    public TDummy getOnFilegroup() {
        return onFilegroup;
    }

    private TDummy onFilegroup = null;

    /**
     * Oracle physical properties
     * @return Oracle physical properties
     */
    public TPhysicalProperties getPhysicalProperties() {
        return physicalProperties;
    }

    private TPhysicalProperties physicalProperties;

    private EnumSet<ETableKind> tableKinds = EnumSet.noneOf(ETableKind.class);

    public void setTableKinds(EnumSet<ETableKind> tableKinds) {
        this.tableKinds = tableKinds;
    }

    /**
     * Type of this table
     * @return Type of this table
     */
    public EnumSet<ETableKind> getTableKinds() {
        return tableKinds;
    }

    private TTable asTable;

    /**
     * Netezza, Teradata, as table name.
     * @return as table name
     */
    public TTable getAsTable() {
        return asTable;
    }

    private boolean externalTable;

    /**
     * @deprecated As of v1.9.7.2 , replace by {@link #isExternal}
     * <br>
     * Netezza, whether it is a external table
     * @return true if it's netezza create external table
     */
    public boolean isExternalTable() {
        return externalTable;
    }

    private ArrayList <TIndexDefinition> indexDefinitions;

    /**
     * Teradata index definition
     *
     * <pre>UNIQUE PRIMARY INDEX (storeid, productid, salesdate)</pre>
     * @return  list of index definition
     */
    public ArrayList<TIndexDefinition> getIndexDefinitions() {
        return indexDefinitions;
    }

    /**
     * Teradata PERIOD FOR clauses that define derived temporal columns.
     * A table can have multiple PERIOD FOR clauses (e.g., one for VALIDTIME and one for TRANSACTIONTIME).
     */
    private ArrayList<TTeradataPeriodForClause> periodForClauses;

    /**
     * Returns the list of Teradata PERIOD FOR clauses in this CREATE TABLE statement.
     * PERIOD FOR clauses define derived columns that represent time periods from two date/timestamp columns.
     *
     * @return list of PERIOD FOR clauses, may be null or empty if none are defined
     */
    public ArrayList<TTeradataPeriodForClause> getPeriodForClauses() {
        return periodForClauses;
    }

    /**
     * Flink WATERMARK clauses that define event-time processing.
     * A table typically has at most one WATERMARK clause.
     */
    private ArrayList<TFlinkWatermarkClause> watermarkClauses;

    /**
     * Returns the list of Flink WATERMARK clauses in this CREATE TABLE statement.
     * WATERMARK clauses define how watermarks are generated for event-time processing.
     *
     * @return list of WATERMARK clauses, may be null or empty if none are defined
     */
    public ArrayList<TFlinkWatermarkClause> getWatermarkClauses() {
        return watermarkClauses;
    }

    /**
     * Returns the first Flink WATERMARK clause in this CREATE TABLE statement.
     * Typically only one WATERMARK clause is defined per table.
     *
     * @return the first WATERMARK clause, or null if none are defined
     */
    public TFlinkWatermarkClause getWatermarkClause() {
        return (watermarkClauses != null && !watermarkClauses.isEmpty())
            ? watermarkClauses.get(0)
            : null;
    }

    private boolean external;
    private boolean usingTemplate;
    private boolean ifNotExists;
    private TObjectName tableLocation;
    private TObjectName tableComment;
    private THiveTableProperties hiveTableProperties;
    private THiveTablePartition hiveTablePartition;
    private THiveTableBuckets hiveTableBuckets;
    private THiveTableSkewed hiveTableSkewed;
    private THiveRowFormat hiveRowFormat;
    private THiveTableFileFormat hiveTableFileFormat;
    private TObjectName likeTableName;

    /**
     * Flink WITH clause containing connector properties.
     */
    private TFlinkWithClause flinkWithClause;

    /**
     * Get the Flink WITH clause containing connector properties.
     *
     * <p>Flink SQL uses the WITH clause to specify connector properties:</p>
     * <pre>
     * CREATE TABLE my_table (
     *   id BIGINT,
     *   name STRING
     * ) WITH (
     *   'connector' = 'kafka',
     *   'topic' = 'my-topic',
     *   'properties.bootstrap.servers' = 'localhost:9092',
     *   'format' = 'json'
     * );
     * </pre>
     *
     * @return the Flink WITH clause, or null if not present
     */
    public TFlinkWithClause getFlinkWithClause() {
        return flinkWithClause;
    }

    /**
     * Set the Flink WITH clause.
     * @param flinkWithClause the Flink WITH clause
     */
    public void setFlinkWithClause(TFlinkWithClause flinkWithClause) {
        this.flinkWithClause = flinkWithClause;
    }

    /**
     * Hive, Impala,Netezza,snowflake whether it is an external table
     * @return whether it is an external table
     */
    public boolean isExternal() {
        return external;
    }

    /**
     * Snowflake: whether this table is created with
     * {@code CREATE TABLE ... USING TEMPLATE <query>}, where the query result
     * (typically over INFER_SCHEMA) derives the column definitions.
     *
     * @return true if created via USING TEMPLATE
     */
    public boolean isUsingTemplate() {
        return usingTemplate;
    }

    /**
     * Hive, impala table row format
     * @return table row format
     */
    public THiveRowFormat getHiveRowFormat() {
        return hiveRowFormat;
    }

    /**
     * Hive, Impala table buckets
     * @return table buckets
     */
    public THiveTableBuckets getHiveTableBuckets() {
        return hiveTableBuckets;
    }

    /**
     * Hive, Impala table file format
     * @return table file format
     */
    public THiveTableFileFormat getHiveTableFileFormat() {
        return hiveTableFileFormat;
    }

    /**
     * Hive, Impala table partition
     * @return table partition
     */
    public THiveTablePartition getHiveTablePartition() {
        return hiveTablePartition;
    }

    /**
     * Hive, Impala table properties
     * @return table properties
     */
    public THiveTableProperties getHiveTableProperties() {
        return hiveTableProperties;
    }

    /**
     * Hive, Impala skewed by clause.
     * @return skewed by clause.
     */
    public THiveTableSkewed getHiveTableSkewed() {
        return hiveTableSkewed;
    }

    /**
     * Hive, Impala, if not exists clause
     * @return true if not exists clause is used in create table statement
     */
    public boolean isIfNotExists() {
        return ifNotExists;
    }

    /**
     * Greenplum, table used in like clause.
     * <br>Hive, Impala, table used in like clause.
     * @return table used in like clause.
     */
    public TObjectName getLikeTableName() {
        return likeTableName;
    }

    /**
     * Hive, Impala, comment of the table.
     * @return comment of the table.
     */
    public TObjectName getTableComment() {
        return tableComment;
    }

    /**
     * Hive, Impala, location of the table.
     * @return location of the table.
     */
    public TObjectName getTableLocation() {
        return tableLocation;
    }

    private TObjectName rowTypeName;
    private TObjectName superTableName;

    /**
     * Informix, typename used in of type clause.
     *
     * @return row type name
     */
    public TObjectName getRowTypeName() {
        return rowTypeName;
    }

    /**
     * Informix, table name used in the under clause.
     * @return table name used in the under clause.
     */
    public TObjectName getSuperTableName() {
        return superTableName;
    }

    /**
     * Data of the created table is derived from this select statement.
     *
     * @return {@link gudusoft.gsqlparser.stmt.TSelectSqlStatement} used in create table.
     */
    public TSelectSqlStatement getSubQuery() {
        return subQuery;
    }

    private TSelectSqlStatement subQuery = null;
    private TExecuteSqlStatement executePreparedStatement = null;//greenplum

    public TExecuteSqlStatement getExecutePreparedStatement() {
        return executePreparedStatement;
    }



    private TPTNodeList <TMySQLCreateTableOption> mySQLTableOptionList;

    /**
     * MySQL, option used in create table such as engine, auto_increment and etc.
     * @return option used in create table such as engine, auto_increment and etc.
     */
    public TPTNodeList<TMySQLCreateTableOption> getMySQLTableOptionList() {
        return mySQLTableOptionList;
    }

    public TCreateTableSqlStatement(EDbVendor dbvendor) {
        super(dbvendor);
        sqlstatementtype = ESqlStatementType.sstcreatetable;
    }

    void buildsql() {
    }

    void clear() {
    }

    String getasprettytext() {
        return "";
    }

    void iterate(TVisitorAbs pvisitor) {
    }

    private TObjectName tableName = null;

    /**
     * The first table in {@link #tables}, this is the same table as {@link #getTargetTable}
     *
     * @return The first table in {@link #tables}
     */
    public TObjectName getTableName() {
        return tables.getTable(0).getTableName();
    }

    private boolean webTable = false;

    public boolean isWebTable() {
        return webTable;
    }


    private boolean readable;

    public boolean isReadable() {
        return readable;
    }

    public boolean isWritable() {
        return writable;
    }

    private boolean writable;

    private TConstant executeCmd;


    public TConstant getExecuteCmd() {
        return executeCmd;
    }


    private ArrayList<TConstant> locationFiles;

    public void setLocationFiles(ArrayList<TConstant> locationFiles) {
        this.locationFiles = locationFiles;
    }

    public ArrayList<TConstant> getLocationFiles() {
        return locationFiles;
    }

    public int doParseStatement(TCustomSqlStatement psql) {
       if (rootNode == null) return -1;
       TCreateTableSqlNode createTableNode = (TCreateTableSqlNode)rootNode;
       super.doParseStatement(psql);
       this.tableKinds = createTableNode.getTableKinds();
       this.tableSourceType = createTableNode.getTableSourceType();
       this.setTargetTable(createTableNode.getTable());


       // move to TMetadataCollector

//       TSQLTable sqlTable = null;
//        if (getSqlEnv() != null)  {
//            if (createTableNode.getTable() != null){
//                sqlTable = getSqlEnv().addTable(createTableNode.getTable().getFullName(),true);
//            }
//
//            if (getSqlEnv().getDefaultCatalogName() != null){
//                if (createTableNode.getTable().getTableName().getDatabaseToken() == null){
//                    createTableNode.getTable().getTableName().setDatabaseToken(new TSourceToken(getSqlEnv().getDefaultCatalogName()),true);
//                }
//            }
//
//            createTableNode.getTable().getTableName().setSqlEnv(getSqlEnv());
//        }

        // end of move to TMetadataCollector

       externalTable = createTableNode.isExternalTable();
       physicalProperties = createTableNode.getPhysicalProperties();
       tableProperties = createTableNode.getTableProperties();
       this.tablePartition = createTableNode.getTablePartition();

       if (createTableNode.getNetezzaExternalTableOption() != null){
           this.externalTableOption = new TExternalTableOption(createTableNode.getNetezzaExternalTableOption().toString());
       }

       mySQLTableOptionList = createTableNode.getMySQLTableOptionList();
       tableOptions = createTableNode.getTableOptions();
       if (tableOptions != null){
           for(int i=0;i<tableOptions.size();i++){
               tableOptions.get(i).doParse(this,ESqlClause.unknown);
           }
       }

       superTableName = createTableNode.getSuperTableName();
       rowTypeName = createTableNode.getRowTypeName();
       onFilegroup = createTableNode.getOnFilegroup();
       cloneSourceTable = createTableNode.getCloneSourceTable();
       if (cloneSourceTable != null){
           cloneSourceTable.setDbObjectType(this.dbvendor,EDbObjectType.table);
       }
       likeTableName = createTableNode.getLikeTableName();
       if (likeTableName != null){
           likeTableName.setDbObjectType(this.dbvendor,EDbObjectType.table);
       }
       partitionBoundSpec = createTableNode.getPartitionBoundSpec();

       tables.addTable(createTableNode.getTable());
       asTable = createTableNode.getAsTable();
        if (asTable != null) tables.addTable(asTable);
       if ((createTableNode.getTableElementList() != null)&&(createTableNode.getTableElementList().size() >0 )){
           TTableElement te;
           TColumnDefinition cd;
           Set<String> columnNames = new LinkedHashSet<String>();
           for(int i=0; i<createTableNode.getTableElementList().size();i++){
              te = createTableNode.getTableElementList().getTableElement(i);
               if (te.getType() == TTableElement.type_column_def) {
                   cd = te.getColumnDefinition();
                   this.getColumnList().addColumn(cd);

                   cd.doParse(this, ESqlClause.createTable);
                   this.getTargetTable().getObjectNameReferences().addObjectName(cd.getColumnName());
                   cd.getColumnName().setLocation(ESqlClause.createTable);
                   cd.getColumnName().setLinkedColumnDef(cd);
                   getTargetTable().getLinkedColumns().addObjectName(cd.getColumnName());
                   cd.getColumnName().setSourceTable(getTargetTable());
                   // move to TMetadataCollector
//                   if (sqlTable != null){
//                       sqlTable.addColumn(cd.getColumnName().toString(),cd.getDatatype());
//                       //getTargetTable().setSqlTable(sqlTable);
//                   }
                   if (!columnNames.add(cd.getColumnName().toString())){
                       // find duplicate colum name
                       TSourceToken st = cd.getColumnName().getStartToken();
                       this.parseerrormessagehandle(new TSyntaxError(st.getAstext(), st.lineNo, st.columnNo
                               ,"duplicate column name", EErrorType.spfatalerror
                               , TBaseType.MSG_ERROR_DUPLICATED_COLUMN_NAME,this,st.posinlist));

                   }
               }
               else  if (te.getType() == TTableElement.type_table_like){
                   likeTableName = te.getParentTable();
               }else  if (te.getType() == TTableElement.type_supplemental_logging){

               }else  if (te.getType() == TTableElement.type_period_for_clause){
                   // Teradata PERIOD FOR clause - derived temporal column
                   if (periodForClauses == null) {
                       periodForClauses = new ArrayList<TTeradataPeriodForClause>();
                   }
                   periodForClauses.add(te.getPeriodForClause());
               }else  if (te.getType() == TTableElement.type_flink_watermark){
                   // Flink WATERMARK clause for event-time processing
                   if (watermarkClauses == null) {
                       watermarkClauses = new ArrayList<TFlinkWatermarkClause>();
                   }
                   watermarkClauses.add(te.getFlinkWatermarkClause());
               }else{
                   te.getConstraint().doParse(this,ESqlClause.unknown);
                   this.getTableConstraints().addConstraint(te.getConstraint());
               }
           }
       }

       // column name list used when create table using a subquery.
       TColumnDefinition t = null;
       if ((createTableNode.getColumnList() != null)&&(createTableNode.getColumnList().size() > 0)){
           for(int i=0;i<createTableNode.getColumnList().size();i++){
               t = new TColumnDefinition(createTableNode.getColumnList().getObjectName(i));
               t.setStartToken(t.getColumnName().getStartToken());
               t.setEndToken(t.getColumnName().getEndToken());
               this.getColumnList().addColumn(t);
               this.getTargetTable().getObjectNameReferences().addObjectName(createTableNode.getColumnList().getObjectName(i));
               getTargetTable().getLinkedColumns().addObjectName(createTableNode.getColumnList().getObjectName(i));
               createTableNode.getColumnList().getObjectName(i).setSourceTable(getTargetTable());
               // move to TMetadataCollector
//               if (sqlTable != null){
//                   sqlTable.addColumn(createTableNode.getColumnList().getObjectName(i).toString());
//               }
           }
       }

       if((subQuery == null) && (createTableNode.getSubQueryNode() != null) && (createTableNode.getSubQueryNode().getRelationExpr() == null)){
           subQuery = new TSelectSqlStatement(this.dbvendor);
           subQuery.rootNode = createTableNode.getSubQueryNode();
           subQuery.doParseStatement(this);


           // link column alias in subquery to table in create statement if columnList is not specified.
           // Skipped for Snowflake USING TEMPLATE: the template query (e.g. ARRAY_AGG over
           // INFER_SCHEMA) only infers the schema, so its select-list columns must NOT become
           // columns of the target table the way a CREATE TABLE AS SELECT would.
           if (createTableNode.getColumnList() == null && !createTableNode.isUsingTemplate()){
               TSelectSqlStatement viewQuery = subQuery;
               if (subQuery.isCombinedQuery()){
                   viewQuery = subQuery.getRightStmt();
               }

                        if (viewQuery.getResultColumnList() != null) {
               for(int i=0;i<viewQuery.getResultColumnList().size();i++){
                   TResultColumn resultColumn = viewQuery.getResultColumnList().getResultColumn(i);
                   TObjectName aliasName = null;
                   if (resultColumn.getAliasClause() != null){
                       if (resultColumn.getAliasClause().getColumns() != null){
                           // select explode(str_to_map(regexp_replace(regexp_replace(regexp_replace(lower(t.input), '', ''), '',''), '', ''), '', '')) as (`key`, `value`) from B t1
                            for (int j=0;j<resultColumn.getAliasClause().getColumns().size();j++){
                                TObjectName aliasName1 =  resultColumn.getAliasClause().getColumns().getObjectName(j);
                                aliasName1.setLocation(ESqlClause.columnAlias);
                                resultColumn.getAliasNameList().add(aliasName1);
                            }
                       }else {
                           aliasName = TObjectName.createObjectName (this.dbvendor, EDbObjectType.column,resultColumn.getAliasClause().getAliasName().getStartToken());
                           aliasName.getReferencedObjects().addObjectName(resultColumn.getAliasClause().getAliasName());
                           aliasName.setLocation(resultColumn.getAliasClause().getAliasName().getLocation());
                       }
                   }else{
                       if (resultColumn.getExpr().getObjectOperand() != null){
                           aliasName =  TObjectName.createObjectName (this.dbvendor, EDbObjectType.column,resultColumn.getExpr().getObjectOperand().getPartToken());
                           aliasName.getReferencedObjects().addObjectName(resultColumn.getExpr().getObjectOperand());
                           aliasName.setLocation(resultColumn.getExpr().getObjectOperand().getLocation());
                       }
                   }

                   if (aliasName != null){
                       if (aliasName.getLocation() == ESqlClause.unknown){
                           aliasName.setLocation(ESqlClause.columnAlias);
                       }
                       getTargetTable().getLinkedColumns().addObjectName(aliasName);
                       aliasName.setSourceTable(getTargetTable());
                       resultColumn.setAliasName(aliasName.toString());

                       // move to TMetadataCollector
//                       if (sqlTable != null){
//                           sqlTable.addColumn(TSQLEnv.getObjectName(aliasName.toString()));
//                       }
                   }
               }
                        }
           }
       }else if ((createTableNode.getSubQueryNode() != null) && (createTableNode.getSubQueryNode().getRelationExpr() != null)){
            // CREATE TABLE a AS TABLE b
           asTable = new TTable(createTableNode.getSubQueryNode().getRelationExpr().getRelationName());
           tables.addTable(asTable);
       }

       if (createTableNode.getExecuteSqlNode() != null){
           executePreparedStatement = new TExecuteSqlStatement(this.dbvendor);
           executePreparedStatement.rootNode = createTableNode.getExecuteSqlNode();
           executePreparedStatement.doParseStatement(this);
       }

        external = createTableNode.isExternal();
        usingTemplate = createTableNode.isUsingTemplate();
       if (!external && tableKinds.contains(ETableKind.etkExternal)){
           external = true;
       }
       if (external){
           if (createTableNode.getOptionStartParenthesis() != null){
               externalTableOptionList = TBaseType.getArrayListBetweenTokens(createTableNode.getOptionStartParenthesis(),createTableNode.getOptionEndParenthesis(),false);
           }
       }
        ifNotExists = createTableNode.isIfNotExists();
        if (createTableNode.getTableComment() != null){
            tableComment = createTableNode.getTableComment();
        }

        locationFiles = createTableNode.getLocationFiles();
        readable = createTableNode.isReadable();
        writable = createTableNode.isWritable();
        executeCmd = createTableNode.getExecuteCmd();
        webTable = createTableNode.isWebTable();

        tableLocation = createTableNode.getTableLocation();
        hiveTableProperties = createTableNode.getHiveTableProperties();
        hiveTablePartition = createTableNode.getHiveTablePartition();
        hiveTableBuckets = createTableNode.getHiveTableBuckets();
        hiveRowFormat = createTableNode.getHiveRowFormat();
        hiveTableSkewed = createTableNode.getHiveTableSkewed();
        hiveTableFileFormat = createTableNode.getHiveTableFileFormat();
        flinkWithClause = createTableNode.getFlinkWithClause();
        if (likeTableName == null){
            likeTableName = createTableNode.getLikeTableName();
        }
        indexDefinitions = createTableNode.getIndexDefinitions();
        if (indexDefinitions != null){
            for(int i=0;i<indexDefinitions.size();i++){
                indexDefinitions.get(i).doParse(this,ESqlClause.tableIndexOption);
            }
        }

        inheritsClause = createTableNode.getInheritsClause();
        if (inheritsClause != null) {
            for(int i=0;i<inheritsClause.getParentTables().size();i++){
                inheritsClause.getParentTables().getObjectName(i).setDbObjectType(this.dbvendor, EDbObjectType.table);
            }
        }
        return 0;
    }

    /**
     * table level constraints.
     * @return List of table constraints of this table.
     */
    public TConstraintList getTableConstraints() {
        if (this.tableConstraints == null){
            this.tableConstraints = new TConstraintList();

        }
        
        return tableConstraints;
    }

    /**
     *  columns created in create table statement.
     *
     * @return List of column definitions of this table.
     */
    public TColumnDefinitionList getColumnList() {
        if (this.columnList == null){
            this.columnList = new TColumnDefinitionList();

        }
        return columnList;
    }

    private TColumnDefinitionList columnList = null;
    private TConstraintList tableConstraints = null;

    public void accept(TParseTreeVisitor v){
        v.preVisit(this);
        v.postVisit(this);
    }

    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);
        //tables.acceptChildren(v);
        if (getTargetTable() != null) {
            getTargetTable().acceptChildren(v);
        }
        this.getColumnList().acceptChildren(v);
        if ((this.getTableConstraints() != null)&&(this.getTableConstraints().size()>0)){
            this.getTableConstraints().acceptChildren(v);
        }
        if (this.getSubQuery() != null){
            this.getSubQuery().acceptChildren(v);
        }
        if (getHiveTablePartition() != null){
            getHiveTablePartition().acceptChildren(v);
        }
        v.postVisit(this);
    }

    public void setColumnList(TColumnDefinitionList columnList) {
        this.columnList = columnList;
    }

    public void setAsTable(TTable asTable) {
        this.asTable = asTable;
    }

    public void setExternalTable(boolean externalTable) {
        this.externalTable = externalTable;
    }

    public void setIndexDefinitions(ArrayList<TIndexDefinition> indexDefinitions) {
        this.indexDefinitions = indexDefinitions;
    }

    public void setExternal(boolean external) {
        this.external = external;
    }

    public void setIfNotExists(boolean ifNotExists) {
        this.ifNotExists = ifNotExists;
    }

    public void setTableLocation(TObjectName tableLocation) {
        this.tableLocation = tableLocation;
    }

    public void setTableComment(TObjectName tableComment) {
        this.tableComment = tableComment;
    }

    public void setHiveTableProperties(THiveTableProperties hiveTableProperties) {
        this.hiveTableProperties = hiveTableProperties;
    }

    public void setHiveTablePartition(THiveTablePartition hiveTablePartition) {
        this.hiveTablePartition = hiveTablePartition;
    }

    public void setHiveTableBuckets(THiveTableBuckets hiveTableBuckets) {
        this.hiveTableBuckets = hiveTableBuckets;
    }

    public void setHiveTableSkewed(THiveTableSkewed hiveTableSkewed) {
        this.hiveTableSkewed = hiveTableSkewed;
    }

    public void setHiveRowFormat(THiveRowFormat hiveRowFormat) {
        this.hiveRowFormat = hiveRowFormat;
    }

    public void setHiveTableFileFormat(THiveTableFileFormat hiveTableFileFormat) {
        this.hiveTableFileFormat = hiveTableFileFormat;
    }

    public void setLikeTableName(TObjectName likeTableName) {
        this.likeTableName = likeTableName;
    }

    public void setRowTypeName(TObjectName rowTypeName) {
        this.rowTypeName = rowTypeName;
    }

    public void setSuperTableName(TObjectName superTableName) {
        this.superTableName = superTableName;
    }

    public void setSubQuery(TSelectSqlStatement subQuery) {
        this.subQuery = subQuery;
    }

    public void setExecutePreparedStatement(TExecuteSqlStatement executePreparedStatement) {
        this.executePreparedStatement = executePreparedStatement;
    }

    public void setMySQLTableOptionList(TPTNodeList<TMySQLCreateTableOption> mySQLTableOptionList) {
        this.mySQLTableOptionList = mySQLTableOptionList;
    }

    public void setTableName(TObjectName tableName) {
        this.tableName = tableName;
    }

    public void setTableConstraints(TConstraintList tableConstraints) {
        this.tableConstraints = tableConstraints;
    }
}