* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

    private static final Logger logger = LoggerFactory.getLogger(MetaDataClient.class);

    private static final ParseNodeFactory FACTORY = new ParseNodeFactory();

    private static final String CREATE_TABLE =

            "UPSERT INTO " + SYSTEM_CATALOG_SCHEMA + ".\"" + SYSTEM_CATALOG_TABLE + "\"( " +

            TENANT_ID + "," +

            TABLE_SCHEM + "," +

            TABLE_NAME + "," +

            TABLE_TYPE + "," +

            TABLE_SEQ_NUM + "," +

            COLUMN_COUNT + "," +

            SALT_BUCKETS + "," +

            PK_NAME + "," +

            DATA_TABLE_NAME + "," +

            INDEX_STATE + "," +

            IMMUTABLE_ROWS + "," +

            DEFAULT_COLUMN_FAMILY_NAME + "," +

            VIEW_STATEMENT + "," +

            DISABLE_WAL + "," +

            MULTI_TENANT + "," +

            VIEW_TYPE + "," +

            VIEW_INDEX_ID +

            ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";

    private static final String CREATE_LINK =

            "UPSERT INTO " + SYSTEM_CATALOG_SCHEMA + ".\"" + SYSTEM_CATALOG_TABLE + "\"( " +

            TENANT_ID + "," +

            TABLE_SCHEM + "," +

            TABLE_NAME + "," +

            COLUMN_FAMILY + "," +

            LINK_TYPE +

            ") VALUES (?, ?, ?, ?, ?)";

    private static final String INCREMENT_SEQ_NUM =

            "UPSERT INTO " + SYSTEM_CATALOG_SCHEMA + ".\"" + SYSTEM_CATALOG_TABLE + "\"( " +

            TENANT_ID + "," +

            TABLE_SCHEM + "," +

            TABLE_NAME + "," +

            TABLE_SEQ_NUM  +

            ") VALUES (?, ?, ?, ?)";

    private static final String MUTATE_TABLE =

        "UPSERT INTO " + SYSTEM_CATALOG_SCHEMA + ".\"" + SYSTEM_CATALOG_TABLE + "\"( " +

        TENANT_ID + "," +

        TABLE_SCHEM + "," +

        TABLE_NAME + "," +

        TABLE_TYPE + "," +

        TABLE_SEQ_NUM + "," +

        COLUMN_COUNT +

        ") VALUES (?, ?, ?, ?, ?, ?)";

    private static final String MUTATE_MULTI_TENANT =

            "UPSERT INTO " + SYSTEM_CATALOG_SCHEMA + ".\"" + SYSTEM_CATALOG_TABLE + "\"( " +

            TENANT_ID + "," +

            TABLE_SCHEM + "," +

            TABLE_NAME + "," +

            MULTI_TENANT +

            ") VALUES (?, ?, ?, ?)";

    private static final String MUTATE_DISABLE_WAL =

            "UPSERT INTO " + SYSTEM_CATALOG_SCHEMA + ".\"" + SYSTEM_CATALOG_TABLE + "\"( " +

            TENANT_ID + "," +

            TABLE_SCHEM + "," +

            TABLE_NAME + "," +

            DISABLE_WAL +

            ") VALUES (?, ?, ?, ?)";

    private static final String MUTATE_IMMUTABLE_ROWS =

            "UPSERT INTO " + SYSTEM_CATALOG_SCHEMA + ".\"" + SYSTEM_CATALOG_TABLE + "\"( " +

            TENANT_ID + "," +

            TABLE_SCHEM + "," +

            TABLE_NAME + "," +

            IMMUTABLE_ROWS +

            ") VALUES (?, ?, ?, ?)";

    private static final String UPDATE_INDEX_STATE =

        "UPSERT INTO " + SYSTEM_CATALOG_SCHEMA + ".\"" + SYSTEM_CATALOG_TABLE + "\"( " +

        TENANT_ID + "," +

        TABLE_SCHEM + "," +

        TABLE_NAME + "," +

        INDEX_STATE +

        ") VALUES (?, ?, ?, ?)";

    private static final String UPDATE_INDEX_STATE_TO_ACTIVE =

            "UPSERT INTO " + SYSTEM_CATALOG_SCHEMA + ".\"" + SYSTEM_CATALOG_TABLE + "\"( " +

            TENANT_ID + "," +

            TABLE_SCHEM + "," +

            TABLE_NAME + "," +

            INDEX_STATE + "," +

            INDEX_DISABLE_TIMESTAMP +

            ") VALUES (?, ?, ?, ?, ?)";

    private static final String INSERT_COLUMN =

        "UPSERT INTO " + SYSTEM_CATALOG_SCHEMA + ".\"" + SYSTEM_CATALOG_TABLE + "\"( " +

        TENANT_ID + "," +

        TABLE_SCHEM + "," +

        TABLE_NAME + "," +

        COLUMN_NAME + "," +

        COLUMN_FAMILY + "," +

        DATA_TYPE + "," +

        NULLABLE + "," +

        COLUMN_SIZE + "," +

        DECIMAL_DIGITS + "," +

        ORDINAL_POSITION + "," +

        SORT_ORDER + "," +

        DATA_TABLE_NAME + "," + // write this both in the column and table rows for access by metadata APIs

        ARRAY_SIZE + "," +

        VIEW_CONSTANT + "," +

        IS_VIEW_REFERENCED + "," +

        PK_NAME + "," +  // write this both in the column and table rows for access by metadata APIs

        KEY_SEQ +

        ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";

    private static final String UPDATE_COLUMN_POSITION =

        "UPSERT INTO " + SYSTEM_CATALOG_SCHEMA + ".\"" + SYSTEM_CATALOG_TABLE + "\" ( " +

        TENANT_ID + "," +

        TABLE_SCHEM + "," +

        TABLE_NAME + "," +

        COLUMN_NAME + "," +

        COLUMN_FAMILY + "," +

        ORDINAL_POSITION +

        ") VALUES (?, ?, ?, ?, ?, ?)";

   

    private final PhoenixConnection connection;

    public MetaDataClient(PhoenixConnection connection) {

        this.connection = connection;

    }

   

    public PhoenixConnection getConnection() {

        return connection;

    }

    public long getCurrentTime(String schemaName, String tableName) throws SQLException {

        MetaDataMutationResult result = updateCache(schemaName, tableName, true);

        return result.getMutationTime();

    }

   

    /**

     * Update the cache with the latest as of the connection scn.

     * @param schemaName

     * @param tableName

     * @return the timestamp from the server, negative if the table was added to the cache and positive otherwise

     * @throws SQLException

     */

    public MetaDataMutationResult updateCache(String schemaName, String tableName) throws SQLException {

        return updateCache(schemaName, tableName, false);

    }

   

    private MetaDataMutationResult updateCache(String schemaName, String tableName, boolean alwaysHitServer) throws SQLException { // TODO: pass byte[] here

        Long scn = connection.getSCN();

        boolean systemTable = SYSTEM_CATALOG_SCHEMA.equals(schemaName);

        // System tables must always have a null tenantId

        PName tenantId = systemTable ? null : connection.getTenantId();

        long clientTimeStamp = scn == null ? HConstants.LATEST_TIMESTAMP : scn;

        PTable table = null;

        String fullTableName = SchemaUtil.getTableName(schemaName, tableName);

        long tableTimestamp = HConstants.LATEST_TIMESTAMP;

        try {

            table = connection.getMetaDataCache().getTable(new PTableKey(tenantId, fullTableName));

            tableTimestamp = table.getTimeStamp();

        } catch (TableNotFoundException e) {

            // TODO: Try again on services cache, as we may be looking for

            // a global multi-tenant table

        }

        // Don't bother with server call: we can't possibly find a newer table

        if (table != null && !alwaysHitServer && (systemTable || tableTimestamp == clientTimeStamp - 1)) {

            return new MetaDataMutationResult(MutationCode.TABLE_ALREADY_EXISTS,QueryConstants.UNSET_TIMESTAMP,table);

        }

       

        int maxTryCount = tenantId == null ? 1 : 2;

        int tryCount = 0;

        MetaDataMutationResult result;

       

        do {

            final byte[] schemaBytes = PDataType.VARCHAR.toBytes(schemaName);

            final byte[] tableBytes = PDataType.VARCHAR.toBytes(tableName);

            result = connection.getQueryServices().getTable(tenantId, schemaBytes, tableBytes, tableTimestamp, clientTimeStamp);

           

            if (SYSTEM_CATALOG_SCHEMA.equals(schemaName)) {

                return result;

            }

            MutationCode code = result.getMutationCode();

            PTable resultTable = result.getTable();

            // We found an updated table, so update our cache

            if (resultTable != null) {

                // Cache table, even if multi-tenant table found for null tenant_id

                // These may be accessed by tenant-specific connections, as the

                // tenant_id will always be added to mask other tenants data.

                // Otherwise, a tenant would be required to create a VIEW first

                // which is not really necessary unless you want to filter or add

                // columns

                connection.addTable(resultTable);

                return result;

            } else {

                // if (result.getMutationCode() == MutationCode.NEWER_TABLE_FOUND) {

                // TODO: No table exists at the clientTimestamp, but a newer one exists.

                // Since we disallow creation or modification of a table earlier than the latest

                // timestamp, we can handle this such that we don't ask the

                // server again.

                // If table was not found at the current time stamp and we have one cached, remove it.

                // Otherwise, we're up to date, so there's nothing to do.

                if (table != null) {

                    result.setTable(table);

                    if (code == MutationCode.TABLE_ALREADY_EXISTS) {

                        return result;

                    }

                    if (code == MutationCode.TABLE_NOT_FOUND && tryCount + 1 == maxTryCount) {

                        connection.removeTable(tenantId, fullTableName, table.getParentName() == null ? null : table.getParentName().getString(), table.getTimeStamp());

                    }

                }

            }

            tenantId = null; // Try again with global tenantId

        } while (++tryCount < maxTryCount);

       

        return result;

    }

    private void addColumnMutation(String schemaName, String tableName, PColumn column, PreparedStatement colUpsert, String parentTableName, String pkName, Short keySeq, boolean isSalted) throws SQLException {

        colUpsert.setString(1, connection.getTenantId() == null ? null : connection.getTenantId().getString());

        colUpsert.setString(2, schemaName);

        colUpsert.setString(3, tableName);

        colUpsert.setString(4, column.getName().getString());

        colUpsert.setString(5, column.getFamilyName() == null ? null : column.getFamilyName().getString());

        colUpsert.setInt(6, column.getDataType().getSqlType());

        colUpsert.setInt(7, column.isNullable() ? ResultSetMetaData.columnNullable : ResultSetMetaData.columnNoNulls);

        if (column.getMaxLength() == null) {

            colUpsert.setNull(8, Types.INTEGER);

        } else {

            colUpsert.setInt(8, column.getMaxLength());

        }

        if (column.getScale() == null) {

            colUpsert.setNull(9, Types.INTEGER);

        } else {

            colUpsert.setInt(9, column.getScale());

        }

        colUpsert.setInt(10, column.getPosition() + (isSalted ? 0 : 1));

        colUpsert.setInt(11, column.getSortOrder().getSystemValue());

        colUpsert.setString(12, parentTableName);

        if (column.getArraySize() == null) {

            colUpsert.setNull(13, Types.INTEGER);

        } else {

            colUpsert.setInt(13, column.getArraySize());

        }

        colUpsert.setBytes(14, column.getViewConstant());

        colUpsert.setBoolean(15, column.isViewReferenced());

        colUpsert.setString(16, pkName);

        if (keySeq == null) {

            colUpsert.setNull(17, Types.SMALLINT);

        } else {

            colUpsert.setShort(17, keySeq);

        }

        colUpsert.execute();

    }

    private PColumn newColumn(int position, ColumnDef def, PrimaryKeyConstraint pkConstraint, String defaultColumnFamily, boolean addingToPK) throws SQLException {

        try {

            ColumnName columnDefName = def.getColumnDefName();

            SortOrder sortOrder = def.getSortOrder();

            boolean isPK = def.isPK();

            if (pkConstraint != null) {

                Pair<ColumnName, SortOrder> pkSortOrder = pkConstraint.getColumn(columnDefName);

                if (pkSortOrder != null) {

                    isPK = true;

                    sortOrder = pkSortOrder.getSecond();

                }

            }

           

            String columnName = columnDefName.getColumnName();

            PName familyName = null;

            if (def.isPK() && !pkConstraint.getColumnNames().isEmpty() ) {

                throw new SQLExceptionInfo.Builder(SQLExceptionCode.PRIMARY_KEY_ALREADY_EXISTS)

                    .setColumnName(columnName).build().buildException();

            }

            boolean isNull = def.isNull();

            if (def.getColumnDefName().getFamilyName() != null) {

                String family = def.getColumnDefName().getFamilyName();

                if (isPK) {

                    throw new SQLExceptionInfo.Builder(SQLExceptionCode.PRIMARY_KEY_WITH_FAMILY_NAME)

                        .setColumnName(columnName).setFamilyName(family).build().buildException();

                } else if (!def.isNull()) {

                    throw new SQLExceptionInfo.Builder(SQLExceptionCode.KEY_VALUE_NOT_NULL)

                        .setColumnName(columnName).setFamilyName(family).build().buildException();

                }

                familyName = PNameFactory.newName(family);

            } else if (!isPK) {

                familyName = PNameFactory.newName(defaultColumnFamily == null ? QueryConstants.DEFAULT_COLUMN_FAMILY : defaultColumnFamily);

            }

           

            if (isPK && !addingToPK && pkConstraint.getColumnNames().size() <= 1) {

                if (def.isNull() && def.isNullSet()) {

                    throw new SQLExceptionInfo.Builder(SQLExceptionCode.SINGLE_PK_MAY_NOT_BE_NULL)

                    .setColumnName(columnName).build().buildException();

                }

                isNull = false;

            }

           

            PColumn column = new PColumnImpl(PNameFactory.newName(columnName), familyName, def.getDataType(),

                    def.getMaxLength(), def.getScale(), isNull, position, sortOrder, def.getArraySize(), null, false);

            return column;

        } catch (IllegalArgumentException e) { // Based on precondition check in constructor

            throw new SQLException(e);

        }

    }

    public MutationState createTable(CreateTableStatement statement, byte[][] splits, PTable parent, String viewStatement, ViewType viewType, byte[][] viewColumnConstants, BitSet isViewColumnReferenced) throws SQLException {

        PTable table = createTableInternal(statement, splits, parent, viewStatement, viewType, viewColumnConstants, isViewColumnReferenced, null);

        if (table == null || table.getType() == PTableType.VIEW) {

            return new MutationState(0,connection);

        }

        // Hack to get around the case when an SCN is specified on the connection.

        // In this case, we won't see the table we just created yet, so we hack

        // around it by forcing the compiler to not resolve anything.

        PostDDLCompiler compiler = new PostDDLCompiler(connection);

        //connection.setAutoCommit(true);

        // Execute any necessary data updates

        Long scn = connection.getSCN();

        long ts = (scn == null ? table.getTimeStamp() : scn);

        // Getting the schema through the current connection doesn't work when the connection has an scn specified

        // Since the table won't be added to the current connection.

        TableRef tableRef = new TableRef(null, table, ts, false);

        byte[] emptyCF = SchemaUtil.getEmptyColumnFamily(table);

        MutationPlan plan = compiler.compile(Collections.singletonList(tableRef), emptyCF, null, null, tableRef.getTimeStamp());

        return connection.getQueryServices().updateData(plan);

    }

    private MutationState buildIndexAtTimeStamp(PTable index, NamedTableNode dataTableNode) throws SQLException {

        // If our connection is at a fixed point-in-time, we need to open a new

        // connection so that our new index table is visible.

        Properties props = new Properties(connection.getClientInfo());

        props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(connection.getSCN()+1));

        PhoenixConnection conn = DriverManager.getConnection(connection.getURL(), props).unwrap(PhoenixConnection.class);

        MetaDataClient newClientAtNextTimeStamp = new MetaDataClient(conn);

       

        // Re-resolve the tableRef from the now newer connection

        conn.setAutoCommit(true);

        ColumnResolver resolver = FromCompiler.getResolver(dataTableNode, conn);

        TableRef tableRef = resolver.getTables().get(0);

        boolean success = false;

        SQLException sqlException = null;

        try {

            MutationState state = newClientAtNextTimeStamp.buildIndex(index, tableRef);

            success = true;

            return state;

        } catch (SQLException e) {

            sqlException = e;

        } finally {

            try {

                conn.close();

            } catch (SQLException e) {

                if (sqlException == null) {

                    // If we're not in the middle of throwing another exception

                    // then throw the exception we got on close.

                    if (success) {

                        sqlException = e;

                    }

                } else {

                    sqlException.setNextException(e);

                }

            }

            if (sqlException != null) {

                throw sqlException;

            }

        }

        throw new IllegalStateException(); // impossible

    }

   

    private MutationState buildIndex(PTable index, TableRef dataTableRef) throws SQLException {

        AlterIndexStatement indexStatement = null;

        boolean wasAutoCommit = connection.getAutoCommit();

        connection.rollback();

        try {

            connection.setAutoCommit(true);

            PostIndexDDLCompiler compiler = new PostIndexDDLCompiler(connection, dataTableRef);

            MutationPlan plan = compiler.compile(index);

            try {

                plan.getContext().setScanTimeRange(new TimeRange(dataTableRef.getLowerBoundTimeStamp(), Long.MAX_VALUE));

            } catch (IOException e) {

                throw new SQLException(e);

            }

            MutationState state = connection.getQueryServices().updateData(plan);

            indexStatement = FACTORY.alterIndex(FACTORY.namedTable(null,

                    TableName.create(index.getSchemaName().getString(), index.getTableName().getString())),

                    dataTableRef.getTable().getTableName().getString(), false, PIndexState.ACTIVE);

            alterIndex(indexStatement);

           

            return state;

        } finally {

            connection.setAutoCommit(wasAutoCommit);

        }

    }

    /**

     * Rebuild indexes from a timestamp which is the value from hbase row key timestamp field

     */

    public void buildPartialIndexFromTimeStamp(PTable index, TableRef dataTableRef) throws SQLException {

        boolean needRestoreIndexState = false;

        // Need to change index state from Disable to InActive when build index partially so that

        // new changes will be indexed during index rebuilding

        AlterIndexStatement indexStatement = FACTORY.alterIndex(FACTORY.namedTable(null,

            TableName.create(index.getSchemaName().getString(), index.getTableName().getString())),

            dataTableRef.getTable().getTableName().getString(), false, PIndexState.INACTIVE);

        alterIndex(indexStatement);

        needRestoreIndexState = true;

        try {

            buildIndex(index, dataTableRef);

            needRestoreIndexState = false;

        } finally {

            if(needRestoreIndexState) {

                // reset index state to disable

                indexStatement = FACTORY.alterIndex(FACTORY.namedTable(null,

                    TableName.create(index.getSchemaName().getString(), index.getTableName().getString())),

                    dataTableRef.getTable().getTableName().getString(), false, PIndexState.DISABLE);

                alterIndex(indexStatement);

            }

        }

    }

    /**

     * Create an index table by morphing the CreateIndexStatement into a CreateTableStatement and calling

     * MetaDataClient.createTable. In doing so, we perform the following translations:

     * 1) Change the type of any columns being indexed to types that support null if the column is nullable.

     *    For example, a BIGINT type would be coerced to a DECIMAL type, since a DECIMAL type supports null

     *    when it's in the row key while a BIGINT does not.

     * 2) Append any row key column from the data table that is not in the indexed column list. Our indexes

     *    rely on having a 1:1 correspondence between the index and data rows.

     * 3) Change the name of the columns to include the column family. For example, if you have a column

     *    named "B" in a column family named "A", the indexed column name will be "A:B". This makes it easy

     *    to translate the column references in a query to the correct column references in an index table

     *    regardless of whether the column reference is prefixed with the column family name or not. It also

     *    has the side benefit of allowing the same named column in different column families to both be

     *    listed as an index column.

     * @param statement

     * @param splits

     * @return MutationState from population of index table from data table

     * @throws SQLException

     */

    public MutationState createIndex(CreateIndexStatement statement, byte[][] splits) throws SQLException {

        PrimaryKeyConstraint pk = statement.getIndexConstraint();

        TableName indexTableName = statement.getIndexTableName();

       

        List<Pair<ColumnName, SortOrder>> indexedPkColumns = pk.getColumnNames();

        List<ColumnName> includedColumns = statement.getIncludeColumns();

        TableRef tableRef = null;

        PTable table = null;

        boolean retry = true;

        Short viewIndexId = null;

        boolean allocateViewIndexId = false;

        while (true) {

            try {

                ColumnResolver resolver = FromCompiler.getResolver(statement, connection);

                tableRef = resolver.getTables().get(0);

                PTable dataTable = tableRef.getTable();

                boolean isTenantConnection = connection.getTenantId() != null;

                if (isTenantConnection) {

                    if (dataTable.getType() != PTableType.VIEW) {

                        throw new SQLFeatureNotSupportedException("An index may only be created for a VIEW through a tenant-specific connection");

                    }

                }

                int hbaseVersion = connection.getQueryServices().getLowestClusterHBaseVersion();

                if (!dataTable.isImmutableRows()) {

                    if (hbaseVersion < PhoenixDatabaseMetaData.MUTABLE_SI_VERSION_THRESHOLD) {

                        throw new SQLExceptionInfo.Builder(SQLExceptionCode.NO_MUTABLE_INDEXES).setTableName(indexTableName.getTableName()).build().buildException();

                    }

                    if (connection.getQueryServices().hasInvalidIndexConfiguration()) {

                        throw new SQLExceptionInfo.Builder(SQLExceptionCode.INVALID_MUTABLE_INDEX_CONFIG).setTableName(indexTableName.getTableName()).build().buildException();

                    }

                }

                int posOffset = 0;

                Set<PColumn> unusedPkColumns;

                if (dataTable.getBucketNum() != null) { // Ignore SALT column

                    unusedPkColumns = new LinkedHashSet<PColumn>(dataTable.getPKColumns().subList(1, dataTable.getPKColumns().size()));

                    posOffset++;

                } else {

                    unusedPkColumns = new LinkedHashSet<PColumn>(dataTable.getPKColumns());

                }

                List<Pair<ColumnName, SortOrder>> allPkColumns = Lists.newArrayListWithExpectedSize(unusedPkColumns.size());

                List<ColumnDef> columnDefs = Lists.newArrayListWithExpectedSize(includedColumns.size() + indexedPkColumns.size());

               

                if (dataTable.isMultiTenant()) {

                    // Add tenant ID column as first column in index

                    PColumn col = dataTable.getPKColumns().get(posOffset);

                    unusedPkColumns.remove(col);

                    PDataType dataType = IndexUtil.getIndexColumnDataType(col);

                    ColumnName colName = ColumnName.caseSensitiveColumnName(IndexUtil.getIndexColumnName(col));

                    allPkColumns.add(new Pair<ColumnName, SortOrder>(colName, col.getSortOrder()));

                    columnDefs.add(FACTORY.columnDef(colName, dataType.getSqlTypeName(), col.isNullable(), col.getMaxLength(), col.getScale(), false, SortOrder.getDefault()));

                }

                if (dataTable.getType() == PTableType.VIEW && dataTable.getViewType() != ViewType.MAPPED) {

                    allocateViewIndexId = true;

                    // Next add index ID column

                    PDataType dataType = MetaDataUtil.getViewIndexIdDataType();

                    ColumnName colName = ColumnName.caseSensitiveColumnName(MetaDataUtil.getViewIndexIdColumnName());

                    allPkColumns.add(new Pair<ColumnName, SortOrder>(colName, SortOrder.getDefault()));

                    columnDefs.add(FACTORY.columnDef(colName, dataType.getSqlTypeName(), false, null, null, false, SortOrder.getDefault()));

                }

                // First columns are the indexed ones

                for (Pair<ColumnName, SortOrder> pair : indexedPkColumns) {

                    ColumnName colName = pair.getFirst();

                    PColumn col = resolver.resolveColumn(null, colName.getFamilyName(), colName.getColumnName()).getColumn();

                    unusedPkColumns.remove(col);

                    // Ignore view constants for updatable views as we don't need these in the index

                    if (col.getViewConstant() == null) {

                        PDataType dataType = IndexUtil.getIndexColumnDataType(col);

                        colName = ColumnName.caseSensitiveColumnName(IndexUtil.getIndexColumnName(col));

                        allPkColumns.add(new Pair<ColumnName, SortOrder>(colName, pair.getSecond()));

                        columnDefs.add(FACTORY.columnDef(colName, dataType.getSqlTypeName(), col.isNullable(), col.getMaxLength(), col.getScale(), false, SortOrder.getDefault()));

                    }

                }

               

                // Next all the PK columns from the data table that aren't indexed

                if (!unusedPkColumns.isEmpty()) {

                    for (PColumn col : unusedPkColumns) {

                        // Don't add columns with constant values from updatable views, as

                        // we don't need these in the index

                        if (col.getViewConstant() == null) {

                            ColumnName colName = ColumnName.caseSensitiveColumnName(IndexUtil.getIndexColumnName(col));

                            allPkColumns.add(new Pair<ColumnName, SortOrder>(colName, col.getSortOrder()));

                            PDataType dataType = IndexUtil.getIndexColumnDataType(col);

                            columnDefs.add(FACTORY.columnDef(colName, dataType.getSqlTypeName(), col.isNullable(), col.getMaxLength(), col.getScale(), false, col.getSortOrder()));

                        }

                    }

                }

                pk = FACTORY.primaryKey(null, allPkColumns);

               

                // Last all the included columns (minus any PK columns)

                for (ColumnName colName : includedColumns) {

                    PColumn col = resolver.resolveColumn(null, colName.getFamilyName(), colName.getColumnName()).getColumn();

                    if (SchemaUtil.isPKColumn(col)) {

                        if (!unusedPkColumns.contains(col)) {

                            throw new SQLExceptionInfo.Builder(SQLExceptionCode.COLUMN_EXIST_IN_DEF).build().buildException();

                        }

                    } else {

                        colName = ColumnName.caseSensitiveColumnName(IndexUtil.getIndexColumnName(col));

                        // Check for duplicates between indexed and included columns

                        if (pk.contains(colName)) {

                            throw new SQLExceptionInfo.Builder(SQLExceptionCode.COLUMN_EXIST_IN_DEF).build().buildException();

                        }

                        if (!SchemaUtil.isPKColumn(col) && col.getViewConstant() == null) {

                            // Need to re-create ColumnName, since the above one won't have the column family name

                            colName = ColumnName.caseSensitiveColumnName(col.getFamilyName().getString(), IndexUtil.getIndexColumnName(col));

                            columnDefs.add(FACTORY.columnDef(colName, col.getDataType().getSqlTypeName(), col.isNullable(), col.getMaxLength(), col.getScale(), false, col.getSortOrder()));

                        }

                    }

                }

               

                // Don't re-allocate viewIndexId on ConcurrentTableMutationException,

                // as there's no need to burn another sequence value.

                if (allocateViewIndexId && viewIndexId == null) {

                    Long scn = connection.getSCN();

                    long timestamp = scn == null ? HConstants.LATEST_TIMESTAMP : scn;

                    PName tenantId = connection.getTenantId();

                    String tenantIdStr = tenantId == null ? null : connection.getTenantId().getString();

                    PName physicalName = dataTable.getPhysicalName();

                    SequenceKey key = MetaDataUtil.getViewIndexSequenceKey(tenantIdStr, physicalName);

                    // Create at parent timestamp as we know that will be earlier than now

                    // and earlier than any SCN if one is set.

                    createSequence(key.getTenantId(), key.getSchemaName(), key.getSequenceName(),

                        true, Short.MIN_VALUE, 1, 1, false, Long.MIN_VALUE, Long.MAX_VALUE,

                        dataTable.getTimeStamp());

                    long[] seqValues = new long[1];

                    SQLException[] sqlExceptions = new SQLException[1];

                    connection.getQueryServices().incrementSequences(Collections.singletonList(key), timestamp, seqValues, sqlExceptions);

                    if (sqlExceptions[0] != null) {

                        throw sqlExceptions[0];

                    }

                    long seqValue = seqValues[0];

                    if (seqValue > Short.MAX_VALUE) {

                        throw new SQLExceptionInfo.Builder(SQLExceptionCode.TOO_MANY_VIEW_INDEXES)

                        .setSchemaName(SchemaUtil.getSchemaNameFromFullName(physicalName.getString())).setTableName(SchemaUtil.getTableNameFromFullName(physicalName.getString())).build().buildException();

                    }

                    viewIndexId = (short) seqValue;

                }

                // Set DEFAULT_COLUMN_FAMILY_NAME of index to match data table

                // We need this in the props so that the correct column family is created

                if (dataTable.getDefaultFamilyName() != null && dataTable.getType() != PTableType.VIEW) {

                    statement.getProps().put("", new Pair<String,Object>(DEFAULT_COLUMN_FAMILY_NAME,dataTable.getDefaultFamilyName().getString()));

                }

                CreateTableStatement tableStatement = FACTORY.createTable(indexTableName, statement.getProps(), columnDefs, pk, statement.getSplitNodes(), PTableType.INDEX, statement.ifNotExists(), null, null, statement.getBindCount());

                table = createTableInternal(tableStatement, splits, dataTable, null, null, null, null, viewIndexId);

                break;

            } catch (ConcurrentTableMutationException e) { // Can happen if parent data table changes while above is in progress

                if (retry) {

                    retry = false;

                    continue;

                }

                throw e;

            }

        }

        if (table == null) {

            return new MutationState(0,connection);

        }

       

        // If our connection is at a fixed point-in-time, we need to open a new

        // connection so that our new index table is visible.

        if (connection.getSCN() != null) {

            return buildIndexAtTimeStamp(table, statement.getTable());

        }

       

        return buildIndex(table, tableRef);

    }

    public MutationState dropSequence(DropSequenceStatement statement) throws SQLException {

        Long scn = connection.getSCN();

        long timestamp = scn == null ? HConstants.LATEST_TIMESTAMP : scn;

        String schemaName = statement.getSequenceName().getSchemaName();

        String sequenceName = statement.getSequenceName().getTableName();

        String tenantId = connection.getTenantId() == null ? null : connection.getTenantId().getString();

        try {

            connection.getQueryServices().dropSequence(tenantId, schemaName, sequenceName, timestamp);

        } catch (SequenceNotFoundException e) {

            if (statement.ifExists()) {

                return new MutationState(0, connection);

            }

            throw e;

        }

        return new MutationState(1, connection);

    }

   

    public MutationState createSequence(CreateSequenceStatement statement, long startWith,

            long incrementBy, long cacheSize, long minValue, long maxValue) throws SQLException {

        Long scn = connection.getSCN();

        long timestamp = scn == null ? HConstants.LATEST_TIMESTAMP : scn;

        String tenantId =

                connection.getTenantId() == null ? null : connection.getTenantId().getString();

        return createSequence(tenantId, statement.getSequenceName().getSchemaName(), statement

                .getSequenceName().getTableName(), statement.ifNotExists(), startWith, incrementBy,

            cacheSize, statement.getCycle(), minValue, maxValue, timestamp);

    }

    private MutationState createSequence(String tenantId, String schemaName, String sequenceName,

            boolean ifNotExists, long startWith, long incrementBy, long cacheSize, boolean cycle,

            long minValue, long maxValue, long timestamp) throws SQLException {

        try {

            connection.getQueryServices().createSequence(tenantId, schemaName, sequenceName,

                startWith, incrementBy, cacheSize, minValue, maxValue, cycle, timestamp);

        } catch (SequenceAlreadyExistsException e) {

            if (ifNotExists) {

                return new MutationState(0, connection);

            }

            throw e;

        }

        return new MutationState(1, connection);

    }

    private static ColumnDef findColumnDefOrNull(List<ColumnDef> colDefs, ColumnName colName) {

        for (ColumnDef colDef : colDefs) {

            if (colDef.getColumnDefName().getColumnName().equals(colName.getColumnName())) {

                return colDef;

            }

        }

        return null;

    }

   

    private PTable createTableInternal(CreateTableStatement statement, byte[][] splits, final PTable parent, String viewStatement, ViewType viewType, final byte[][] viewColumnConstants, final BitSet isViewColumnReferenced, Short viewIndexId) throws SQLException {

        final PTableType tableType = statement.getTableType();

        boolean wasAutoCommit = connection.getAutoCommit();

        connection.rollback();

        try {

            connection.setAutoCommit(false);

            List<Mutation> tableMetaData = Lists.newArrayListWithExpectedSize(statement.getColumnDefs().size() + 3);

           

            TableName tableNameNode = statement.getTableName();

            String schemaName = tableNameNode.getSchemaName();

            String tableName = tableNameNode.getTableName();

            String parentTableName = null;

            PName tenantId = connection.getTenantId();

            String tenantIdStr = tenantId == null ? null : connection.getTenantId().getString();

            boolean isParentImmutableRows = false;

            boolean multiTenant = false;

            Integer saltBucketNum = null;

            String defaultFamilyName = null;

            boolean isImmutableRows = false;

            List<PName> physicalNames = Collections.emptyList();

            boolean addSaltColumn = false;

            if (parent != null && tableType == PTableType.INDEX) {

                // Index on view

                // TODO: Can we support a multi-tenant index directly on a multi-tenant

                // table instead of only a view? We don't have anywhere to put the link

                // from the table to the index, though.

                if (parent.getType() == PTableType.VIEW && parent.getViewType() != ViewType.MAPPED) {

                    PName physicalName = parent.getPhysicalName();

                    saltBucketNum = parent.getBucketNum();

                    addSaltColumn = (saltBucketNum != null);

                    defaultFamilyName = parent.getDefaultFamilyName() == null ? null : parent.getDefaultFamilyName().getString();

                    // Set physical name of view index table

                    physicalNames = Collections.singletonList(PNameFactory.newName(MetaDataUtil.getViewIndexPhysicalName(physicalName.getBytes())));

                }

               

                multiTenant = parent.isMultiTenant();

                isParentImmutableRows = parent.isImmutableRows();

                parentTableName = parent.getTableName().getString();

                // Pass through data table sequence number so we can check it hasn't changed

                PreparedStatement incrementStatement = connection.prepareStatement(INCREMENT_SEQ_NUM);

                incrementStatement.setString(1, connection.getTenantId() == null ? null : connection.getTenantId().getString());

                incrementStatement.setString(2, schemaName);

                incrementStatement.setString(3, parentTableName);

                incrementStatement.setLong(4, parent.getSequenceNumber());

                incrementStatement.execute();

                // Get list of mutations and add to table meta data that will be passed to server

                // to guarantee order. This row will always end up last

                tableMetaData.addAll(connection.getMutationState().toMutations().next().getSecond());

                connection.rollback();

                // Add row linking from data table row to index table row

                PreparedStatement linkStatement = connection.prepareStatement(CREATE_LINK);

                linkStatement.setString(1, connection.getTenantId() == null ? null : connection.getTenantId().getString());

                linkStatement.setString(2, schemaName);

                linkStatement.setString(3, parentTableName);

                linkStatement.setString(4, tableName);

                linkStatement.setByte(5, LinkType.INDEX_TABLE.getSerializedValue());

                linkStatement.execute();

            }

           

            PrimaryKeyConstraint pkConstraint = statement.getPrimaryKeyConstraint();

            String pkName = null;

            List<Pair<ColumnName,SortOrder>> pkColumnsNames = Collections.<Pair<ColumnName,SortOrder>>emptyList();

            Iterator<Pair<ColumnName,SortOrder>> pkColumnsIterator = Iterators.emptyIterator();

            if (pkConstraint != null) {

                pkColumnsNames = pkConstraint.getColumnNames();

                pkColumnsIterator = pkColumnsNames.iterator();

                pkName = pkConstraint.getName();

            }

           

            Map<String,Object> tableProps = Maps.newHashMapWithExpectedSize(statement.getProps().size());

            Map<String,Object> commonFamilyProps = Collections.emptyMap();

            // Somewhat hacky way of determining if property is for HColumnDescriptor or HTableDescriptor

            HColumnDescriptor defaultDescriptor = new HColumnDescriptor(QueryConstants.DEFAULT_COLUMN_FAMILY_BYTES);

            if (!statement.getProps().isEmpty()) {

                commonFamilyProps = Maps.newHashMapWithExpectedSize(statement.getProps().size());

               

                Collection<Pair<String,Object>> props = statement.getProps().get(QueryConstants.ALL_FAMILY_PROPERTIES_KEY);

                for (Pair<String,Object> prop : props) {

                    if (defaultDescriptor.getValue(prop.getFirst()) == null) {

                        tableProps.put(prop.getFirst(), prop.getSecond());

                    } else {

                        commonFamilyProps.put(prop.getFirst(), prop.getSecond());

                    }

                }

            }

           

            // Although unusual, it's possible to set a mapped VIEW as having immutable rows.

            // This tells Phoenix that you're managing the index maintenance yourself.

            if (tableType != PTableType.INDEX && (tableType != PTableType.VIEW || viewType == ViewType.MAPPED)) {

                Boolean isImmutableRowsProp = (Boolean) tableProps.remove(PTable.IS_IMMUTABLE_ROWS_PROP_NAME);

                if (isImmutableRowsProp == null) {

                    isImmutableRows = connection.getQueryServices().getProps().getBoolean(QueryServices.IMMUTABLE_ROWS_ATTRIB, QueryServicesOptions.DEFAULT_IMMUTABLE_ROWS);

                } else {

                    isImmutableRows = isImmutableRowsProp;

                }

            }

           

            // Can't set any of these on views or shared indexes on views

            if (tableType != PTableType.VIEW && viewIndexId == null) {

                saltBucketNum = (Integer) tableProps.remove(PhoenixDatabaseMetaData.SALT_BUCKETS);

                if (saltBucketNum != null && (saltBucketNum < 0 || saltBucketNum > SaltingUtil.MAX_BUCKET_NUM)) {

                    throw new SQLExceptionInfo.Builder(SQLExceptionCode.INVALID_BUCKET_NUM).build().buildException();

                }

                // Salt the index table if the data table is salted

                if (saltBucketNum == null) {

                    if (parent != null) {

                        saltBucketNum = parent.getBucketNum();

                    }

                } else if (saltBucketNum.intValue() == 0) {