* 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(ConnectionQueryServicesImpl.class);

    private static final int INITIAL_CHILD_SERVICES_CAPACITY = 100;

    private static final int DEFAULT_OUT_OF_ORDER_MUTATIONS_WAIT_TIME_MS = 1000;

    private static final String OLD_DEFAULT_COLUMN_FAMILY = "_0";

    private static final byte[] OLD_DEFAULT_COLUMN_FAMILY_BYTES = Bytes.toBytes(OLD_DEFAULT_COLUMN_FAMILY);

    private static final String OLD_SYSTEM_SCHEMA_NAME = "SYSTEM";

    private static final String OLD_SYSTEM_TABLE_NAME = "TABLE";

    private static final byte[] OLD_SYSTEM_TABLE_NAME_BYTES = SchemaUtil.getTableNameAsBytes("SYSTEM", "TABLE");

    // Don't use SYSTEM as the schema name, otherwise we'll treat it as a system table

    private static final String OLD_SYSTEM_TABLE_AS_VIEW_NAME = SchemaUtil.getTableName("META", "\"TABLE\"");

   

    public static final String UPGRADE_TO_3_0 = "UpgradeTo30";

    public static final String UPGRADE_TO_2_2 = "UpgradeTo22";

   

    protected final Configuration config;

    // Copy of config.getProps(), but read-only to prevent synchronization that we

    // don't need.

    private final ReadOnlyProps props;

    private final ConcurrentHashMap<ImmutableBytesWritable,ConnectionQueryServices> childServices;

    private final StatsManager statsManager;

    // Cache the latest meta data here for future connections

    private volatile PMetaData latestMetaData;

    private final Object latestMetaDataLock = new Object();

    // Lowest HBase version on the cluster.

    private int lowestClusterHBaseVersion = Integer.MAX_VALUE;

    private boolean hasInvalidIndexConfiguration = false;

    private int connectionCount = 0;

    private WhiteList upgradeWhiteList = null;

    private HConnection connection;

    private volatile boolean initialized;

    private volatile boolean closed;

    private volatile SQLException initializationException;

    private ConcurrentMap<SequenceKey,Sequence> sequenceMap = Maps.newConcurrentMap();

    private KeyValueBuilder kvBuilder;

    private PMetaData newEmptyMetaData() {

        long maxSizeBytes = props.getLong(QueryServices.MAX_CLIENT_METADATA_CACHE_SIZE_ATTRIB,

                QueryServicesOptions.DEFAULT_MAX_CLIENT_METADATA_CACHE_SIZE);

        return new PMetaDataImpl(INITIAL_META_DATA_TABLE_CAPACITY, maxSizeBytes);

    }

    /**

     * Construct a ConnectionQueryServicesImpl that represents a connection to an HBase

     * cluster.

     * @param services base services from where we derive our default configuration

     * @param connectionInfo to provide connection information

     * @throws SQLException

     */

    public ConnectionQueryServicesImpl(QueryServices services, ConnectionInfo connectionInfo) {

        super(services);

        Configuration config = HBaseFactoryProvider.getConfigurationFactory().getConfiguration();

        for (Entry<String,String> entry : services.getProps()) {

            config.set(entry.getKey(), entry.getValue());

        }

        for (Entry<String,String> entry : connectionInfo.asProps()) {

            config.set(entry.getKey(), entry.getValue());

        }

        // Without making a copy of the configuration we cons up, we lose some of our properties

        // on the server side during testing.

        this.config = HBaseConfiguration.create(config);

        // set replication required parameter

        ConfigUtil.setReplicationConfigIfAbsent(this.config);

        this.props = new ReadOnlyProps(this.config.iterator());

        this.latestMetaData = newEmptyMetaData();

        // TODO: should we track connection wide memory usage or just org-wide usage?

        // If connection-wide, create a MemoryManager here, otherwise just use the one from the delegate

        this.childServices = new ConcurrentHashMap<ImmutableBytesWritable,ConnectionQueryServices>(INITIAL_CHILD_SERVICES_CAPACITY);

        int statsUpdateFrequencyMs = this.getProps().getInt(QueryServices.STATS_UPDATE_FREQ_MS_ATTRIB, QueryServicesOptions.DEFAULT_STATS_UPDATE_FREQ_MS);

        int maxStatsAgeMs = this.getProps().getInt(QueryServices.MAX_STATS_AGE_MS_ATTRIB, QueryServicesOptions.DEFAULT_MAX_STATS_AGE_MS);

        this.statsManager = new StatsManagerImpl(this, statsUpdateFrequencyMs, maxStatsAgeMs);

       

        // find the HBase version and use that to determine the KeyValueBuilder that should be used

        String hbaseVersion = VersionInfo.getVersion();

        this.kvBuilder = KeyValueBuilder.get(hbaseVersion);

    }

   

    private void openConnection() throws SQLException {

        try {

            this.connection = HBaseFactoryProvider.getHConnectionFactory().createConnection(this.config);

        } catch (IOException e) {

            throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_ESTABLISH_CONNECTION)

                .setRootCause(e).build().buildException();

        }

        if (this.connection.isClosed()) { // TODO: why the heck doesn't this throw above?

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

        }

    }

    @Override

    public StatsManager getStatsManager() {

        return this.statsManager;

    }

   

    @Override

    public HTableInterface getTable(byte[] tableName) throws SQLException {

        try {

            return HBaseFactoryProvider.getHTableFactory().getTable(tableName, connection, getExecutor());

        } catch (org.apache.hadoop.hbase.TableNotFoundException e) {

            byte[][] schemaAndTableName = new byte[2][];

            SchemaUtil.getVarChars(tableName, schemaAndTableName);

            throw new TableNotFoundException(Bytes.toString(schemaAndTableName[0]), Bytes.toString(schemaAndTableName[1]));

        } catch (IOException e) {

          throw new SQLException(e);

        }

    }

   

    @Override

    public HTableDescriptor getTableDescriptor(byte[] tableName) throws SQLException {

        HTableInterface htable = getTable(tableName);

        try {

            return htable.getTableDescriptor();

        } catch (IOException e) {

            if(e instanceof org.apache.hadoop.hbase.TableNotFoundException ||

                e.getCause() instanceof org.apache.hadoop.hbase.TableNotFoundException) {

              byte[][] schemaAndTableName = new byte[2][];

              SchemaUtil.getVarChars(tableName, schemaAndTableName);

              throw new TableNotFoundException(Bytes.toString(schemaAndTableName[0]), Bytes.toString(schemaAndTableName[1]));

            }

            throw new RuntimeException(e);

        } finally {

            Closeables.closeQuietly(htable);

        }

    }

    @Override

    public ReadOnlyProps getProps() {

        return props;

    }

    /**

     * Closes the underlying connection to zookeeper. The QueryServices

     * may not be used after that point. When a Connection is closed,

     * this is not called, since these instances are pooled by the

     * Driver. Instead, the Driver should call this if the QueryServices

     * is ever removed from the pool

     */

    @Override

    public void close() throws SQLException {

        if (closed) {

            return;

        }

        synchronized (this) {

            if (closed) {

                return;

            }

            closed = true;

            SQLException sqlE = null;

            try {

                // Attempt to return any unused sequences.

                if (connection != null) returnAllSequences(this.sequenceMap);

            } catch (SQLException e) {

                sqlE = e;

            } finally {

                try {

                    // Clear any client-side caches. 

                    statsManager.clearStats();

                } catch (SQLException e) {

                    if (sqlE == null) {

                        sqlE = e;

                    } else {

                        sqlE.setNextException(e);

                    }

                } finally {

                    try {

                        childServices.clear();

                        latestMetaData = null;

                        if (connection != null) connection.close();

                    } catch (IOException e) {

                        if (sqlE == null) {

                            sqlE = ServerUtil.parseServerException(e);

                        } else {

                            sqlE.setNextException(ServerUtil.parseServerException(e));

                        }

                    } finally {

                        try {

                            super.close();

                        } catch (SQLException e) {

                            if (sqlE == null) {

                                sqlE = e;

                            } else {

                                sqlE.setNextException(e);

                            }

                        } finally {

                            if (sqlE != null) {

                                throw sqlE;

                            }

                        }

                    }

                }

            }

        }

    }   

    protected ConnectionQueryServices newChildQueryService() {

        return new ChildQueryServices(this);

    }

    /**

     * Get (and create if necessary) a child QueryService for a given tenantId.

     * The QueryService will be cached for the lifetime of the parent QueryService

     * @param tenantId the tenant ID

     * @return the child QueryService

     */

    @Override

    public ConnectionQueryServices getChildQueryServices(ImmutableBytesWritable tenantId) {

        ConnectionQueryServices childQueryService = childServices.get(tenantId);

        if (childQueryService == null) {

            childQueryService = newChildQueryService();

            ConnectionQueryServices prevQueryService = childServices.putIfAbsent(tenantId, childQueryService);

            return prevQueryService == null ? childQueryService : prevQueryService;

        }

        return childQueryService;

    }

    @SuppressWarnings("deprecation")

    @Override

    public void clearTableRegionCache(byte[] tableName) throws SQLException {

        connection.clearRegionCache(TableName.valueOf(tableName));

    }

   

    @Override

    public List<HRegionLocation> getAllTableRegions(byte[] tableName) throws SQLException {

        /*

         * Use HConnection.getRegionLocation as it uses the cache in HConnection, while getting

         * all region locations from the HTable doesn't.

         */

        int retryCount = 0, maxRetryCount = 1;

        boolean reload =false;

        while (true) {

            try {

                // We could surface the package projected HConnectionImplementation.getNumberOfCachedRegionLocations

                // to get the sizing info we need, but this would require a new class in the same package and a cast

                // to this implementation class, so it's probably not worth it.

                List<HRegionLocation> locations = Lists.newArrayList();

                byte[] currentKey = HConstants.EMPTY_START_ROW;

                do {

                  @SuppressWarnings("deprecation")

                HRegionLocation regionLocation = connection.getRegionLocation(

                    TableName.valueOf(tableName), currentKey, reload);

                  locations.add(regionLocation);

                  currentKey = regionLocation.getRegionInfo().getEndKey();

                } while (!Bytes.equals(currentKey, HConstants.EMPTY_END_ROW));

                return locations;

            } catch (org.apache.hadoop.hbase.TableNotFoundException e) {

                String fullName = Bytes.toString(tableName);

                throw new TableNotFoundException(SchemaUtil.getSchemaNameFromFullName(fullName), SchemaUtil.getTableNameFromFullName(fullName));

            } catch (IOException e) {

                if (retryCount++ < maxRetryCount) { // One retry, in case split occurs while navigating

                    reload = true;

                    continue;

                }

                throw new SQLExceptionInfo.Builder(SQLExceptionCode.GET_TABLE_REGIONS_FAIL)

                    .setRootCause(e).build().buildException();

            }

        }

    }

    @Override

    public PMetaData addTable(PTable table) throws SQLException {

        try {

            // If existing table isn't older than new table, don't replace

            // If a client opens a connection at an earlier timestamp, this can happen

            PTable existingTable = latestMetaData.getTable(new PTableKey(table.getTenantId(), table.getName().getString()));

            if (existingTable.getTimeStamp() >= table.getTimeStamp()) {

                return latestMetaData;

            }

        } catch (TableNotFoundException e) {

        }

        synchronized(latestMetaDataLock) {

            latestMetaData = latestMetaData.addTable(table);

            latestMetaDataLock.notifyAll();

            return latestMetaData;

        }

    }

        PMetaData mutate(PMetaData metaData) throws SQLException;

    }

    /**

     * Ensures that metaData mutations are handled in the correct order

     * @param tenantId TODO

     */

    private PMetaData metaDataMutated(PName tenantId, String tableName, long tableSeqNum, Mutator mutator) throws SQLException {

        synchronized(latestMetaDataLock) {

            PMetaData metaData = latestMetaData;

            PTable table;

            long endTime = System.currentTimeMillis() + DEFAULT_OUT_OF_ORDER_MUTATIONS_WAIT_TIME_MS;

            while (true) {

                try {

                    try {

                        table = metaData.getTable(new PTableKey(tenantId, tableName));

                        /* If the table is at the prior sequence number, then we're good to go.

                         * We know if we've got this far, that the server validated the mutations,

                         * so we'd just need to wait until the other connection that mutated the same

                         * table is processed.

                         */

                        if (table.getSequenceNumber() + 1 == tableSeqNum) {

                            // TODO: assert that timeStamp is bigger that table timeStamp?

                            metaData = mutator.mutate(metaData);

                            break;

                        } else if (table.getSequenceNumber() >= tableSeqNum) {

                            logger.warn("Attempt to cache older version of " + tableName + ": current= " + table.getSequenceNumber() + ", new=" + tableSeqNum);

                            break;

                        }

                    } catch (TableNotFoundException e) {

                    }

                    long waitTime = endTime - System.currentTimeMillis();

                    // We waited long enough - just remove the table from the cache

                    // and the next time it's used it'll be pulled over from the server.

                    if (waitTime <= 0) {

                        logger.warn("Unable to update meta data repo within " + (DEFAULT_OUT_OF_ORDER_MUTATIONS_WAIT_TIME_MS/1000) + " seconds for " + tableName);

                        metaData = metaData.removeTable(tenantId, tableName);

                        break;

                    }

                    latestMetaDataLock.wait(waitTime);

                } catch (InterruptedException e) {

                    throw new SQLExceptionInfo.Builder(SQLExceptionCode.INTERRUPTED_EXCEPTION)

                        .setRootCause(e).build().buildException(); // FIXME

                }

            }

            latestMetaData = metaData;

            latestMetaDataLock.notifyAll();

            return metaData;

        }

     }

    @Override

    public PMetaData addColumn(final PName tenantId, final String tableName, final List<PColumn> columns, final long tableTimeStamp, final long tableSeqNum, final boolean isImmutableRows) throws SQLException {

        return metaDataMutated(tenantId, tableName, tableSeqNum, new Mutator() {

            @Override

            public PMetaData mutate(PMetaData metaData) throws SQLException {

                try {

                    return metaData.addColumn(tenantId, tableName, columns, tableTimeStamp, tableSeqNum, isImmutableRows);

                } catch (TableNotFoundException e) {

                    // The DROP TABLE may have been processed first, so just ignore.

                    return metaData;

                }

            }

        });

     }

    @Override

    public PMetaData removeTable(PName tenantId, final String tableName) throws SQLException {

        synchronized(latestMetaDataLock) {

            latestMetaData = latestMetaData.removeTable(tenantId, tableName);

            latestMetaDataLock.notifyAll();

            return latestMetaData;

        }

    }

    @Override

    public PMetaData removeColumn(final PName tenantId, final String tableName, final String familyName, final String columnName, final long tableTimeStamp, final long tableSeqNum) throws SQLException {

        return metaDataMutated(tenantId, tableName, tableSeqNum, new Mutator() {

            @Override

            public PMetaData mutate(PMetaData metaData) throws SQLException {

                try {

                    return metaData.removeColumn(tenantId, tableName, familyName, columnName, tableTimeStamp, tableSeqNum);

                } catch (TableNotFoundException e) {

                    // The DROP TABLE may have been processed first, so just ignore.

                    return metaData;

                }

            }

        });

    }

    @Override

    public PhoenixConnection connect(String url, Properties info) throws SQLException {

        return new PhoenixConnection(this, url, info, latestMetaData);

    }

    private HColumnDescriptor generateColumnFamilyDescriptor(Pair<byte[],Map<String,Object>> family, PTableType tableType) throws SQLException {

        HColumnDescriptor columnDesc = new HColumnDescriptor(family.getFirst());

        if (tableType != PTableType.VIEW) {

            columnDesc.setKeepDeletedCells(true);

            columnDesc.setDataBlockEncoding(SchemaUtil.DEFAULT_DATA_BLOCK_ENCODING);

            for (Entry<String,Object> entry : family.getSecond().entrySet()) {

                String key = entry.getKey();

                Object value = entry.getValue();

                columnDesc.setValue(key, value == null ? null : value.toString());

            }

        }

        return columnDesc;

    }

    private void modifyColumnFamilyDescriptor(HColumnDescriptor hcd, Pair<byte[],Map<String,Object>> family) throws SQLException {

      for (Entry<String, Object> entry : family.getSecond().entrySet()) {

        String key = entry.getKey();

        Object value = entry.getValue();

        hcd.setValue(key, value == null ? null : value.toString());

      }

    }

   

    private static final String OLD_PACKAGE = "com.salesforce.";

    private static final String NEW_PACKAGE = "org.apache.";

    private static final String OLD_INDEXER_CLASS_NAME = "com.salesforce.hbase.index.Indexer";

   

    private HTableDescriptor generateTableDescriptor(byte[] tableName, HTableDescriptor existingDesc, PTableType tableType, Map<String,Object> tableProps, List<Pair<byte[],Map<String,Object>>> families, byte[][] splits) throws SQLException {

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

        HTableDescriptor descriptor = (existingDesc != null) ? new HTableDescriptor(existingDesc) :

          new HTableDescriptor(TableName.valueOf(tableName));

        for (Entry<String,Object> entry : tableProps.entrySet()) {

            String key = entry.getKey();

            Object value = entry.getValue();

            descriptor.setValue(key, value == null ? null : value.toString());

        }

        if (families.isEmpty()) {

            if (tableType != PTableType.VIEW) {

                byte[] defaultFamilyByes = defaultFamilyName == null ? QueryConstants.DEFAULT_COLUMN_FAMILY_BYTES : Bytes.toBytes(defaultFamilyName);

                // Add dummy column family so we have key values for tables that

                HColumnDescriptor columnDescriptor = generateColumnFamilyDescriptor(new Pair<byte[],Map<String,Object>>(defaultFamilyByes,Collections.<String,Object>emptyMap()), tableType);

                descriptor.addFamily(columnDescriptor);

            }

        } else {

            for (Pair<byte[],Map<String,Object>> family : families) {

                // If family is only in phoenix description, add it. otherwise, modify its property accordingly.

                byte[] familyByte = family.getFirst();

                if (descriptor.getFamily(familyByte) == null) {

                    if (tableType == PTableType.VIEW) {

                        String fullTableName = Bytes.toString(tableName);

                        throw new ReadOnlyTableException(

                                "The HBase column families for a read-only table must already exist",

                                SchemaUtil.getSchemaNameFromFullName(fullTableName),

                                SchemaUtil.getTableNameFromFullName(fullTableName),

                                Bytes.toString(familyByte));

                    }

                    HColumnDescriptor columnDescriptor = generateColumnFamilyDescriptor(family, tableType);

                    descriptor.addFamily(columnDescriptor);

                } else {

                    if (tableType != PTableType.VIEW) {

                        modifyColumnFamilyDescriptor(descriptor.getFamily(familyByte), family);

                    }

                }

            }

        }

        addCoprocessors(tableName, descriptor, tableType);

        return descriptor;

    }

    private void addCoprocessors(byte[] tableName, HTableDescriptor descriptor, PTableType tableType) throws SQLException {

        // The phoenix jar must be available on HBase classpath

        try {

            // Hack to detect that we're installing view on old SYSTEM.TABLE for conversion.

            // In this case, we do not want to uninstall the old coprocessors.

            boolean isOldSysTable = Bytes.compareTo(OLD_SYSTEM_TABLE_NAME_BYTES,tableName) == 0;

            if (!descriptor.hasCoprocessor(ScanRegionObserver.class.getName())) {

                if (!isOldSysTable) {

                    descriptor.removeCoprocessor(ScanRegionObserver.class.getName().replace(NEW_PACKAGE, OLD_PACKAGE));

                }

                descriptor.addCoprocessor(ScanRegionObserver.class.getName(), null, 1, null);

            }

            if (!descriptor.hasCoprocessor(UngroupedAggregateRegionObserver.class.getName())) {

                if (!isOldSysTable) {

                    descriptor.removeCoprocessor(UngroupedAggregateRegionObserver.class.getName().replace(NEW_PACKAGE, OLD_PACKAGE));

                }

                descriptor.addCoprocessor(UngroupedAggregateRegionObserver.class.getName(), null, 1, null);

            }

            if (!descriptor.hasCoprocessor(GroupedAggregateRegionObserver.class.getName())) {

                if (!isOldSysTable) {

                    descriptor.removeCoprocessor(GroupedAggregateRegionObserver.class.getName().replace(NEW_PACKAGE, OLD_PACKAGE));

                }

                descriptor.addCoprocessor(GroupedAggregateRegionObserver.class.getName(), null, 1, null);

            }

            if (!descriptor.hasCoprocessor(ServerCachingEndpointImpl.class.getName())) {

                if (!isOldSysTable) {

                    descriptor.removeCoprocessor(ServerCachingEndpointImpl.class.getName().replace(NEW_PACKAGE, OLD_PACKAGE));

                }

                descriptor.addCoprocessor(ServerCachingEndpointImpl.class.getName(), null, 1, null);

            }

           

            // Always try to remove, as this coprocessor doesn't exist anymore

            descriptor.removeCoprocessor("com.salesforce.phoenix.join.HashJoiningRegionObserver");

            // Remove indexing coprocessor if on VIEW or INDEX, as we may have added this by mistake in 2.x versions

            if (tableType == PTableType.INDEX || tableType == PTableType.VIEW) {

                if (!isOldSysTable) {

                    descriptor.removeCoprocessor(Indexer.class.getName());

                    descriptor.removeCoprocessor(OLD_INDEXER_CLASS_NAME);

                }

            }

            // TODO: better encapsulation for this

            // Since indexes can't have indexes, don't install our indexing coprocessor for indexes. Also,

            // don't install on the metadata table until we fix the TODO there.

            if ((tableType != PTableType.INDEX && tableType != PTableType.VIEW) && !SchemaUtil.isMetaTable(tableName) && !descriptor.hasCoprocessor(Indexer.class.getName())) {

                if (!isOldSysTable) {

                    descriptor.removeCoprocessor(OLD_INDEXER_CLASS_NAME);

                }

                Map<String, String> opts = Maps.newHashMapWithExpectedSize(1);

                opts.put(CoveredColumnsIndexBuilder.CODEC_CLASS_NAME_KEY, PhoenixIndexCodec.class.getName());

                Indexer.enableIndexing(descriptor, PhoenixIndexBuilder.class, opts);

            }

           

            // Setup split policy on Phoenix metadata table to ensure that the key values of a Phoenix table

            // stay on the same region.

            if (SchemaUtil.isMetaTable(tableName)) {

                descriptor.setValue(ConnectionQueryServicesImpl.UPGRADE_TO_3_0, Boolean.TRUE.toString());

                if (!descriptor.hasCoprocessor(MetaDataEndpointImpl.class.getName())) {

                    descriptor.removeCoprocessor(MetaDataEndpointImpl.class.getName().replace(NEW_PACKAGE, OLD_PACKAGE));

                    descriptor.addCoprocessor(MetaDataEndpointImpl.class.getName(), null, 1, null);

                }

                if (!descriptor.hasCoprocessor(MetaDataRegionObserver.class.getName())) {

                    descriptor.removeCoprocessor(MetaDataRegionObserver.class.getName().replace(NEW_PACKAGE, OLD_PACKAGE));

                    descriptor.addCoprocessor(MetaDataRegionObserver.class.getName(), null, 2, null);

                }

            } else if (SchemaUtil.isSequenceTable(tableName)) {

                if (!descriptor.hasCoprocessor(SequenceRegionObserver.class.getName())) {

                    descriptor.addCoprocessor(SequenceRegionObserver.class.getName(), null, 1, null);

                }

            }

        } catch (IOException e) {

            throw ServerUtil.parseServerException(e);

        }

    }

    private void ensureFamilyCreated(byte[] tableName, PTableType tableType , Pair<byte[],Map<String,Object>> family) throws SQLException {

        HBaseAdmin admin = null;

        SQLException sqlE = null;

        try {

            admin = new HBaseAdmin(config);

            try {

                HTableDescriptor existingDesc = admin.getTableDescriptor(tableName);

                HColumnDescriptor oldDescriptor = existingDesc.getFamily(family.getFirst());

                HColumnDescriptor columnDescriptor = null;

                if (oldDescriptor == null) {

                    if (tableType == PTableType.VIEW) {

                        String fullTableName = Bytes.toString(tableName);

                        throw new ReadOnlyTableException(

                                "The HBase column families for a VIEW must already exist",

                                SchemaUtil.getSchemaNameFromFullName(fullTableName),

                                SchemaUtil.getTableNameFromFullName(fullTableName),

                                Bytes.toString(family.getFirst()));

                    }

                    columnDescriptor = generateColumnFamilyDescriptor(family, tableType );

                } else {

                    columnDescriptor = new HColumnDescriptor(oldDescriptor);

                    // Don't attempt to make any metadata changes for a VIEW

                    if (tableType == PTableType.VIEW) {

                        return;

                    }

                    modifyColumnFamilyDescriptor(columnDescriptor, family);

                }

               

                if (columnDescriptor.equals(oldDescriptor)) {

                    // Table already has family and it's the same.

                    return;

                }

                admin.disableTable(tableName);

                if (oldDescriptor == null) {

                    admin.addColumn(tableName, columnDescriptor);

                } else {

                    admin.modifyColumn(tableName, columnDescriptor);

                }

                admin.enableTable(tableName);

            } catch (org.apache.hadoop.hbase.TableNotFoundException e) {

                sqlE = new SQLExceptionInfo.Builder(SQLExceptionCode.TABLE_UNDEFINED).setRootCause(e).build().buildException();

            }

        } catch (IOException e) {

            sqlE = ServerUtil.parseServerException(e);

        } finally {

            try {

                if (admin != null) {

                    admin.close();

                }

            } catch (IOException e) {

                if (sqlE == null) {

                    sqlE = ServerUtil.parseServerException(e);

                } else {

                    sqlE.setNextException(ServerUtil.parseServerException(e));

                }

            } finally {

                if (sqlE != null) {

                    throw sqlE;

                }

            }

        }

    }

   

    /**

     *

     * @param tableName

     * @param splits

     * @param modifyExistingMetaData TODO

     * @param familyNames

     * @return true if table was created and false if it already exists

     * @throws SQLException

     */

    private HTableDescriptor ensureTableCreated(byte[] tableName, PTableType tableType , Map<String,Object> props, List<Pair<byte[],Map<String,Object>>> families, byte[][] splits, boolean modifyExistingMetaData) throws SQLException {

        HBaseAdmin admin = null;

        SQLException sqlE = null;

        HTableDescriptor existingDesc = null;

        boolean isMetaTable = SchemaUtil.isMetaTable(tableName);

        boolean tableExist = true;

        try {

            logger.info("Found quorum: " + ZKConfig.getZKQuorumServersString(config));

            admin = new HBaseAdmin(config);

            try {

                existingDesc = admin.getTableDescriptor(tableName);

            } catch (org.apache.hadoop.hbase.TableNotFoundException e) {

                tableExist = false;

                if (tableType == PTableType.VIEW) {

                    String fullTableName = Bytes.toString(tableName);

                    throw new ReadOnlyTableException(

                            "An HBase table for a VIEW must already exist",

                            SchemaUtil.getSchemaNameFromFullName(fullTableName),

                            SchemaUtil.getTableNameFromFullName(fullTableName));

                }

            }

            HTableDescriptor newDesc = generateTableDescriptor(tableName, existingDesc, tableType , props, families, splits);

           

            if (!tableExist) {

                /*

                 * Remove the splitPolicy attribute due to an HBase bug (see below)

                 */

                if (isMetaTable) {

                    newDesc.remove(HTableDescriptor.SPLIT_POLICY);

                }

                try {

                    if (splits == null) {

                        admin.createTable(newDesc);

                    } else {

                        admin.createTable(newDesc, splits);