* Copyright (c) 2013, Salesforce.com, Inc.

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

*     Redistributions of source code must retain the above copyright notice,

*     this list of conditions and the following disclaimer.

*     Redistributions in binary form must reproduce the above copyright notice,

*     this list of conditions and the following disclaimer in the documentation

*     and/or other materials provided with the distribution.

*     Neither the name of Salesforce.com nor the names of its contributors may

*     be used to endorse or promote products derived from this software without

*     specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

******************************************************************************/

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

    private static final ParseNodeFactory FACTORY = new ParseNodeFactory();

    private static final String CREATE_TABLE =

            "UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\"( " +

            TENANT_ID + "," +

            TABLE_SCHEM_NAME + "," +

            TABLE_NAME_NAME + "," +

            TABLE_TYPE_NAME + "," +

            TABLE_SEQ_NUM + "," +

            COLUMN_COUNT + "," +

            SALT_BUCKETS + "," +

            PK_NAME + "," +

            DATA_TABLE_NAME + "," +

            INDEX_STATE + "," +

            IMMUTABLE_ROWS + "," +

            DEFAULT_COLUMN_FAMILY_NAME + "," +

            VIEW_EXPRESSION + "," +

            DISABLE_WAL + "," +

            MULTI_TENANT + "," +

            VIEW_TYPE + "," +

            BASE_SCHEMA_NAME + "," +

            BASE_TABLE_NAME +

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

    private static final String CREATE_INDEX_LINK =

            "UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\"( " +

            TENANT_ID + "," +

            TABLE_SCHEM_NAME + "," +

            TABLE_NAME_NAME + "," +

            TABLE_CAT_NAME +

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

    private static final String INCREMENT_SEQ_NUM =

            "UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\"( " +

            TENANT_ID + "," +

            TABLE_SCHEM_NAME + "," +

            TABLE_NAME_NAME + "," +

            TABLE_SEQ_NUM  +

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

    private static final String MUTATE_TABLE =

        "UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\"( " +

        TENANT_ID + "," +

        TABLE_SCHEM_NAME + "," +

        TABLE_NAME_NAME + "," +

        TABLE_TYPE_NAME + "," +

        TABLE_SEQ_NUM + "," +

        COLUMN_COUNT + "," +

        IMMUTABLE_ROWS + "," +

        DISABLE_WAL + "," +

        MULTI_TENANT +

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

    private static final String UPDATE_INDEX_STATE =

            "UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\"( " +

            TENANT_ID + "," +

            TABLE_SCHEM_NAME + "," +

            TABLE_NAME_NAME + "," +

            INDEX_STATE +

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

    private static final String INSERT_COLUMN =

        "UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\"( " +

        TENANT_ID + "," +

        TABLE_SCHEM_NAME + "," +

        TABLE_NAME_NAME + "," +

        COLUMN_NAME + "," +

        TABLE_CAT_NAME + "," +

        DATA_TYPE + "," +

        NULLABLE + "," +

        COLUMN_SIZE + "," +

        DECIMAL_DIGITS + "," +

        ORDINAL_POSITION + "," +

        COLUMN_MODIFIER + "," +

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

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

    private static final String UPDATE_COLUMN_POSITION =

        "UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\" ( " +

        TENANT_ID + "," +

        TABLE_SCHEM_NAME + "," +

        TABLE_NAME_NAME + "," +

        COLUMN_NAME + "," +

        TABLE_CAT_NAME + "," +

        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 static final MetaDataMutationResult SYSTEM_TABLE_RESULT = new MetaDataMutationResult(MutationCode.TABLE_ALREADY_EXISTS,QueryConstants.UNSET_TIMESTAMP,null);

   

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

        Long scn = connection.getSCN();

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

        if (TYPE_SCHEMA.equals(schemaName) && !alwaysHitServer) {

            return SYSTEM_TABLE_RESULT;

        }

        PTable table = null;

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

        long tableTimestamp = HConstants.LATEST_TIMESTAMP;

        PName tenantIdName = connection.getTenantId();

        try {

            table = connection.getPMetaData().getTable(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 && tableTimestamp == clientTimeStamp - 1 && !alwaysHitServer) {

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

        }

       

        byte[] tenantId = null;

        int maxTryCount = 1;

        if (tenantIdName != null) {

            tenantId = tenantIdName.getBytes();

            maxTryCount = 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 (TYPE_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) {

                // Don't cache the table unless it has the same tenantId

                // as the connection or it's not multi-tenant.

                if (tryCount == 0 || !resultTable.isMultiTenant()) {

                    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(fullTableName);

                    }

                }

            }

            tenantId = null;

        } while (++tryCount < maxTryCount);

       

        return result;

    }

    private void addColumnMutation(String schemaName, String tableName, PColumn column, PreparedStatement colUpsert, String parentTableName) 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() + 1);

        colUpsert.setInt(11, ColumnModifier.toSystemValue(column.getColumnModifier()));

        colUpsert.setString(12, parentTableName);

        colUpsert.execute();

    }

    private PColumn newColumn(int position, ColumnDef def, PrimaryKeyConstraint pkConstraint) throws SQLException {

        try {

            ColumnName columnDefName = def.getColumnDefName();

            ColumnModifier columnModifier = def.getColumnModifier();

            boolean isPK = def.isPK();

            if (pkConstraint != null) {

                Pair<ColumnName,ColumnModifier> pkColumnModifier = pkConstraint.getColumn(columnDefName);

                if (pkColumnModifier != null) {

                    isPK = true;

                    columnModifier = pkColumnModifier.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();

            }

            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(QueryConstants.DEFAULT_COLUMN_FAMILY);

            }

           

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

                    def.getMaxLength(), def.getScale(), def.isNull(), position, columnModifier);

            return column;

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

            throw new SQLException(e);

        }

    }

    public MutationState createTable(CreateTableStatement statement, byte[][] splits, PTable parent, Expression viewExpression, ViewType viewType) throws SQLException {

        PTable table = createTableInternal(statement, splits, parent, viewExpression, viewType);

        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.getColumnFamilies());

        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 {

        PostIndexDDLCompiler compiler = new PostIndexDDLCompiler(connection, dataTableRef);

        MutationPlan plan = compiler.compile(index);

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

        AlterIndexStatement 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;

    }

    /**

     * 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, ColumnModifier>> indexedPkColumns = pk.getColumnNames();

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

        TableRef tableRef = null;

        PTable table = null;

        boolean retry = true;

        while (true) {

            try {

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

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

                PTable dataTable = tableRef.getTable();

                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();

                    }

                }

                Set<PColumn> unusedPkColumns;

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

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

                } else {

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

                }

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

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

               

                // First columns are the indexed ones

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

                    ColumnName colName = pair.getFirst();

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

                    unusedPkColumns.remove(col);

                    PDataType dataType = IndexUtil.getIndexColumnDataType(col);

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

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

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

                }

               

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

                if (!unusedPkColumns.isEmpty()) {

                    for (PColumn col : unusedPkColumns) {

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

                        allPkColumns.add(new Pair<ColumnName, ColumnModifier>(colName, col.getColumnModifier()));

                        PDataType dataType = IndexUtil.getIndexColumnDataType(col);

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

                    }

                }

                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)) {

                            // 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.getColumnModifier()));

                        }

                    }

                }

               

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

                table = createTableInternal(tableStatement, splits, tableRef.getTable(), null, null); // TODO: tenant-specific index

                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, int cacheSize) 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().createSequence(tenantId, schemaName, sequenceName, startWith, incrementBy, cacheSize, timestamp);

        } catch (SequenceAlreadyExistsException e) {

            if (statement.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, Expression viewExpression, ViewType viewType) 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;

            String viewExpressionStr = viewExpression == null ? null : viewExpression.toString();

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

            boolean isParentImmutableRows = false;

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

                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_INDEX_LINK);

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

                linkStatement.setString(2, schemaName);

                linkStatement.setString(3, parentTableName);

                linkStatement.setString(4, tableName);

                linkStatement.execute();

            }

           

            PrimaryKeyConstraint pkConstraint = statement.getPrimaryKeyConstraint();

            String pkName = null;

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

            Iterator<Pair<ColumnName,ColumnModifier>> 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());

                    }

                }

            }

           

            boolean isSalted = false;

            Integer saltBucketNum = null;

            String defaultFamilyName = null;

            boolean isImmutableRows = false;

            boolean multiTenant = false;

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

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

            if (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;

                }

            }

           

            if (tableType != PTableType.VIEW) {

                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) {

                    saltBucketNum = null; // Provides a way for an index to not be salted if its data table is salted

                }

                isSalted = (saltBucketNum != null);

               

                defaultFamilyName = (String)tableProps.remove(PhoenixDatabaseMetaData.DEFAULT_COLUMN_FAMILY_NAME);

                if (defaultFamilyName == null) {

                    // Until we change this default, we need to have all tables set it

                    defaultFamilyName = QueryConstants.DEFAULT_COLUMN_FAMILY;

                }

               

                Boolean multiTenantProp = (Boolean) tableProps.remove(PhoenixDatabaseMetaData.MULTI_TENANT);

                multiTenant = Boolean.TRUE.equals(multiTenantProp);

            }

           

            boolean disableWAL = false;

            Boolean disableWALProp = (Boolean) tableProps.remove(PhoenixDatabaseMetaData.DISABLE_WAL);

            if (disableWALProp == null) {

                disableWAL = isParentImmutableRows; // By default, disable WAL for immutable indexes

            } else {

                disableWAL = disableWALProp;

            }

            // Delay this check as it is supported to have IMMUTABLE_ROWS and SALT_BUCKETS defined on views

            if (statement.getTableType() == PTableType.VIEW && !tableProps.isEmpty()) {

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

            }

           

            List<ColumnDef> colDefs = statement.getColumnDefs();

            List<PColumn> columns;

            LinkedHashSet<PColumn> pkColumns;   

           

            TableName baseName = statement.getBaseTableName();

            String baseTableName = null;

            String baseSchemaName = null;

            if (baseName != null) {

                baseTableName = baseName.getTableName();

                baseSchemaName = baseName.getSchemaName();

            }

           

            if (tenantId != null && baseTableName == null) {

                throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_CREATE_TENANT_SPECIFIC_BASE_TABLE)

                    .setSchemaName(schemaName).setTableName(tableName).build().buildException();

            }

           

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

                if (parent.getType() == PTableType.VIEW) {

                    viewExpressionStr = AndExpression.combine(viewExpressionStr, parent.getViewExpression());

                    viewType = ViewType.combine(viewType, parent.getViewType());

                    baseTableName = parent.getBaseTableName().getString();

                    baseSchemaName = parent.getBaseSchemaName() == null ? null : parent.getBaseSchemaName().getString();

                }

                // Propagate property values to VIEW.

                // TODO: formalize the known set of these properties

                multiTenant = parent.isMultiTenant();

                saltBucketNum = parent.getBucketNum();

                isImmutableRows = parent.isImmutableRows();

                disableWAL = (disableWALProp == null ? parent.isWALDisabled() : disableWALProp);

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

                columns = newArrayListWithExpectedSize(parent.getColumns().size() + colDefs.size());

                columns.addAll(parent.getColumns());

                pkColumns = newLinkedHashSet(parent.getPKColumns());

            } else {

                columns = newArrayListWithExpectedSize(colDefs.size());

                pkColumns = newLinkedHashSetWithExpectedSize(colDefs.size() + 1); // in case salted 

            }

           

            PreparedStatement colUpsert = connection.prepareStatement(INSERT_COLUMN);

            Map<String, PName> familyNames = Maps.newLinkedHashMap();

            boolean isPK = false;

           

            int positionOffset = columns.size();

            if (isSalted) {

                positionOffset++;

                pkColumns.add(SaltingUtil.SALTING_COLUMN);

            }

            int position = positionOffset;

           

            for (ColumnDef colDef : colDefs) {

                if (colDef.isPK()) {

                    if (isPK) {

                        throw new SQLExceptionInfo.Builder(SQLExceptionCode.PRIMARY_KEY_ALREADY_EXISTS)

                            .setColumnName(colDef.getColumnDefName().getColumnName()).build().buildException();

                    }

                    isPK = true;

                }

                PColumn column = newColumn(position++, colDef, pkConstraint);

                if (SchemaUtil.isPKColumn(column)) {

                    // TODO: remove this constraint?

                    if (pkColumnsIterator.hasNext() && !column.getName().getString().equals(pkColumnsIterator.next().getFirst().getColumnName())) {

                        throw new SQLExceptionInfo.Builder(SQLExceptionCode.PRIMARY_KEY_OUT_OF_ORDER)

                            .setSchemaName(schemaName)

                            .setTableName(tableName)

                            .setColumnName(column.getName().getString())

                            .build().buildException();

                    }

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

                        throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_DEFINE_PK_FOR_VIEW)

                            .setSchemaName(schemaName)

                            .setTableName(tableName)

                            .setColumnName(colDef.getColumnDefName().getColumnName())

                            .build().buildException();

                    }

                    // disallow array type usage in primary key constraint

                    if (colDef.isArray()) {

                        throw new SQLExceptionInfo.Builder(SQLExceptionCode.ARRAY_NOT_ALLOWED_IN_PRIMARY_KEY)

                        .setSchemaName(schemaName)

                        .setTableName(tableName)

                        .setColumnName(colDef.getColumnDefName().getColumnName())

                        .build().buildException();

                    }

                    if (!pkColumns.add(column)) {

                        throw new ColumnAlreadyExistsException(schemaName, tableName, column.getName().getString());

                    }

                }

                if (tableType == PTableType.VIEW && hasColumnWithSameNameAndFamily(columns, column)) {

                    // we only need to check for dup columns for views because they inherit columns from parent

                    throw new ColumnAlreadyExistsException(schemaName, tableName, column.getName().getString());

                }

                columns.add(column);

                if (colDef.getDataType() == PDataType.VARBINARY

                        && SchemaUtil.isPKColumn(column)

                        && pkColumnsNames.size() > 1

                        && column.getPosition() < pkColumnsNames.size() - 1) {

                    throw new SQLExceptionInfo.Builder(SQLExceptionCode.VARBINARY_IN_ROW_KEY)

                        .setSchemaName(schemaName)

                        .setTableName(tableName)

                        .setColumnName(column.getName().getString())

                        .build().buildException();

                }

                if (column.getFamilyName() != null) {

                    familyNames.put(column.getFamilyName().getString(),column.getFamilyName());

                }

            }

            // We need a PK definition for a TABLE or mapped VIEW

            if (!isPK && pkColumnsNames.isEmpty() && tableType != PTableType.VIEW && viewType != ViewType.MAPPED) {

                throw new SQLExceptionInfo.Builder(SQLExceptionCode.PRIMARY_KEY_MISSING)

                    .setSchemaName(schemaName)

                    .setTableName(tableName)

                    .build().buildException();

            }

            if (!pkColumnsNames.isEmpty() && pkColumnsNames.size() != pkColumns.size() - positionOffset) { // Then a column name in the primary key constraint wasn't resolved

                Iterator<Pair<ColumnName,ColumnModifier>> pkColumnNamesIterator = pkColumnsNames.iterator();

                while (pkColumnNamesIterator.hasNext()) {

                    ColumnName colName = pkColumnNamesIterator.next().getFirst();

                    ColumnDef colDef = findColumnDefOrNull(colDefs, colName);

                    if (colDef == null) {

                        throw new ColumnNotFoundException(schemaName, tableName, null, colName.getColumnName());

                    }

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

                        throw new SQLExceptionInfo.Builder(SQLExceptionCode.PRIMARY_KEY_WITH_FAMILY_NAME)

                        .setSchemaName(schemaName)

                        .setTableName(tableName)

                        .setColumnName(colDef.getColumnDefName().getColumnName() )

                        .setFamilyName(colDef.getColumnDefName().getFamilyName())

                        .build().buildException();

                    }

                }

                // The above should actually find the specific one, but just in case...

                throw new SQLExceptionInfo.Builder(SQLExceptionCode.INVALID_PRIMARY_KEY_CONSTRAINT)

                    .setSchemaName(schemaName)

                    .setTableName(tableName)

                    .build().buildException();

            }

           

            List<Pair<byte[],Map<String,Object>>> familyPropList = Lists.newArrayListWithExpectedSize(familyNames.size());

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

                for (String familyName : statement.getProps().keySet()) {

                    if (!familyName.equals(QueryConstants.ALL_FAMILY_PROPERTIES_KEY)) {

                        if (familyNames.get(familyName) == null) {

                            throw new SQLExceptionInfo.Builder(SQLExceptionCode.PROPERTIES_FOR_FAMILY)

                                .setFamilyName(familyName).build().buildException();

                        } else if (statement.getTableType() == PTableType.VIEW) {

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

                        }

                    }

                }

            }

            throwIfInsufficientColumns(schemaName, tableName, pkColumns, isSalted, multiTenant);

           

            for (PName familyName : familyNames.values()) {

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

                if (props.isEmpty()) {

                    familyPropList.add(new Pair<byte[],Map<String,Object>>(familyName.getBytes(),commonFamilyProps));

                } else {

                    Map<String,Object> combinedFamilyProps = Maps.newHashMapWithExpectedSize(props.size() + commonFamilyProps.size());

                    combinedFamilyProps.putAll(commonFamilyProps);

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

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

                    }

                    familyPropList.add(new Pair<byte[],Map<String,Object>>(familyName.getBytes(),combinedFamilyProps));

                }

            }

           

           

            // Bootstrapping for our SYSTEM.TABLE that creates itself before it exists

            if (SchemaUtil.isMetaTable(schemaName,tableName)) {

                PTable table = PTableImpl.makePTable(PNameFactory.newName(schemaName),PNameFactory.newName(tableName), tableType, null,

                        MetaDataProtocol.MIN_TABLE_TIMESTAMP, PTable.INITIAL_SEQ_NUM, PNameFactory.newName(QueryConstants.SYSTEM_TABLE_PK_NAME),

                        null, columns, null, Collections.<PTable>emptyList(), isImmutableRows,

                        null, null, defaultFamilyName == null ? null : PNameFactory.newName(defaultFamilyName),

                        null, Boolean.TRUE.equals(disableWAL), false, null);

                connection.addTable(table);

            } else if (tableType == PTableType.INDEX) {

                if (tableProps.get(HTableDescriptor.MAX_FILESIZE) == null) {

                    int nIndexRowKeyColumns = isPK ? 1 : pkColumnsNames.size();

                    int nIndexKeyValueColumns = columns.size() - nIndexRowKeyColumns;

                    int nBaseRowKeyColumns = parent.getPKColumns().size() - (parent.getBucketNum() == null ? 0 : 1);

                    int nBaseKeyValueColumns = parent.getColumns().size() - parent.getPKColumns().size();

                    /*

                     * Approximate ratio between index table size and data table size:

                     * More or less equal to the ratio between the number of key value columns in each. We add one to

                     * the key value column count to take into account our empty key value. We add 1/4 for any key

                     * value data table column that was moved into the index table row key.

                     */

                    double ratio = (1+nIndexKeyValueColumns + (nIndexRowKeyColumns - nBaseRowKeyColumns)/4d)/(1+nBaseKeyValueColumns);

                    HTableDescriptor descriptor = connection.getQueryServices().getTableDescriptor(parent.getPhysicalName().getBytes());

                    if (descriptor != null) { // Is null for connectionless

                        long maxFileSize = descriptor.getMaxFileSize();

                        if (maxFileSize == -1) { // If unset, use default

                            maxFileSize = HConstants.DEFAULT_MAX_FILE_SIZE;

                        }

                        tableProps.put(HTableDescriptor.MAX_FILESIZE, (long)(maxFileSize * ratio));

                    }

                }

            }

           

            for (PColumn column : columns) {

                addColumnMutation(schemaName, tableName, column, colUpsert, parentTableName);

            }

           

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

            connection.rollback();

           

            String dataTableName = parent == null || tableType == PTableType.VIEW ? null : parent.getTableName().getString();

            PIndexState indexState = parent == null || tableType == PTableType.VIEW  ? null : PIndexState.BUILDING;

            PreparedStatement tableUpsert = connection.prepareStatement(CREATE_TABLE);

            tableUpsert.setString(1, tenantId);

            tableUpsert.setString(2, schemaName);

            tableUpsert.setString(3, tableName);

            tableUpsert.setString(4, tableType.getSerializedValue());

            tableUpsert.setLong(5, PTable.INITIAL_SEQ_NUM);

            tableUpsert.setInt(6, position);

            if (saltBucketNum != null) {

                tableUpsert.setInt(7, saltBucketNum);

            } else {

                tableUpsert.setNull(7, Types.INTEGER);

            }

            tableUpsert.setString(8, pkName);

            tableUpsert.setString(9, dataTableName);

            tableUpsert.setString(10, indexState == null ? null : indexState.getSerializedValue());

            tableUpsert.setBoolean(11, isImmutableRows);

            tableUpsert.setString(12, defaultFamilyName);

            tableUpsert.setString(13, viewExpressionStr);

            tableUpsert.setBoolean(14, disableWAL);

            tableUpsert.setBoolean(15, multiTenant);

            if (viewType == null) {

                tableUpsert.setNull(16, Types.TINYINT);

            } else {

                tableUpsert.setByte(16, viewType.getSerializedValue());

            }

            tableUpsert.setString(17, baseSchemaName);

            tableUpsert.setString(18, baseTableName);

            tableUpsert.execute();

           

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

            connection.rollback();

           

            /*

             * The table metadata must be in the following order:

             * 1) table header row

             * 2) everything else

             * 3) parent table header row

             */

            Collections.reverse(tableMetaData);

           

            splits = SchemaUtil.processSplits(splits, pkColumns, saltBucketNum, connection.getQueryServices().getProps().getBoolean(

                    QueryServices.ROW_KEY_ORDER_SALTED_TABLE_ATTRIB, QueryServicesOptions.DEFAULT_ROW_KEY_ORDER_SALTED_TABLE));

            MetaDataMutationResult result = connection.getQueryServices().createTable(

                    tableMetaData,

                    viewType == ViewType.MAPPED ? SchemaUtil.getTableNameAsBytes(baseSchemaName, baseTableName) : null,

                    tableType, tableProps, familyPropList, splits);

            MutationCode code = result.getMutationCode();

            switch(code) {

            case TABLE_ALREADY_EXISTS:

                connection.addTable(result.getTable());

                if (!statement.ifNotExists()) {

                    throw new TableAlreadyExistsException(schemaName, tableName);

                }

                return null;

            case PARENT_TABLE_NOT_FOUND:

                throw new TableNotFoundException(schemaName, parent.getName().getString());

            case NEWER_TABLE_FOUND:

                throw new NewerTableAlreadyExistsException(schemaName, tableName);

            case UNALLOWED_TABLE_MUTATION:

                throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_MUTATE_TABLE)

                    .setSchemaName(schemaName).setTableName(tableName).build().buildException();

            case CONCURRENT_TABLE_MUTATION:

                connection.addTable(result.getTable());

                throw new ConcurrentTableMutationException(schemaName, tableName);

            default:

                PTable table =  PTableImpl.makePTable(

                        PNameFactory.newName(schemaName), PNameFactory.newName(tableName), tableType, indexState, result.getMutationTime(), PTable.INITIAL_SEQ_NUM,

                        pkName == null ? null : PNameFactory.newName(pkName), saltBucketNum, columns, dataTableName == null ? null : PNameFactory.newName(dataTableName),

                        Collections.<PTable>emptyList(), isImmutableRows, baseSchemaName == null ? null : PNameFactory.newName(baseSchemaName),

                        baseTableName == null ? null : PNameFactory.newName(baseTableName), defaultFamilyName == null ? null : PNameFactory.newName(defaultFamilyName),

                        viewExpressionStr, Boolean.TRUE.equals(disableWAL), multiTenant, viewType);