PHOENIX-3837 Feature enabling to set property on an index with Alter statement
Signed-off-by: aertoria <casti...@gmail.com> Project: http://git-wip-us.apache.org/repos/asf/phoenix/repo Commit: http://git-wip-us.apache.org/repos/asf/phoenix/commit/ef174bb2 Tree: http://git-wip-us.apache.org/repos/asf/phoenix/tree/ef174bb2 Diff: http://git-wip-us.apache.org/repos/asf/phoenix/diff/ef174bb2 Branch: refs/heads/4.x-HBase-1.2 Commit: ef174bb22ccce806dcdf5435d17319cbfa86c0d5 Parents: 5b49396 Author: aertoria <casti...@gmail.com> Authored: Mon Nov 27 03:13:53 2017 +0000 Committer: James Taylor <jtay...@salesforce.com> Committed: Sat Dec 16 16:42:54 2017 -0800 ---------------------------------------------------------------------- .../apache/phoenix/end2end/AlterTableIT.java | 2 +- .../phoenix/end2end/index/IndexMetadataIT.java | 55 ++ phoenix-core/src/main/antlr3/PhoenixSQL.g | 5 +- .../apache/phoenix/jdbc/PhoenixStatement.java | 10 +- .../phoenix/parse/AddColumnStatement.java | 2 +- .../phoenix/parse/AlterIndexStatement.java | 14 + .../apache/phoenix/parse/ParseNodeFactory.java | 6 +- .../phoenix/query/ConnectionQueryServices.java | 2 + .../query/ConnectionQueryServicesImpl.java | 20 + .../query/ConnectionlessQueryServicesImpl.java | 7 + .../query/DelegateConnectionQueryServices.java | 8 +- .../apache/phoenix/schema/MetaDataClient.java | 566 +++++++++++++------ 12 files changed, 520 insertions(+), 177 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/phoenix/blob/ef174bb2/phoenix-core/src/it/java/org/apache/phoenix/end2end/AlterTableIT.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/AlterTableIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/AlterTableIT.java index 5265b09..17f08c4 100644 --- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/AlterTableIT.java +++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/AlterTableIT.java @@ -1080,7 +1080,7 @@ public class AlterTableIT extends ParallelStatsDisabledIT { } catch (SQLException e) { assertEquals(SQLExceptionCode.CANNOT_CREATE_TXN_TABLE_IF_TXNS_DISABLED.getErrorCode(), e.getErrorCode()); } - // altering a table to be transactional should fail if transactions are disabled + // altering a table to be transactional should fail if transactions are disabled conn.createStatement().execute("CREATE TABLE " + dataTableFullName + "(k INTEGER PRIMARY KEY, v VARCHAR)"); try { conn.createStatement().execute("ALTER TABLE " + dataTableFullName + " SET TRANSACTIONAL=true"); http://git-wip-us.apache.org/repos/asf/phoenix/blob/ef174bb2/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/IndexMetadataIT.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/IndexMetadataIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/IndexMetadataIT.java index 0ce36dd..986c317 100644 --- a/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/IndexMetadataIT.java +++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/index/IndexMetadataIT.java @@ -674,4 +674,59 @@ public class IndexMetadataIT extends ParallelStatsDisabledIT { conn.close(); } } + + + + @Test + public void testIndexAlterPhoenixProperty() throws Exception { + Properties props = PropertiesUtil.deepCopy(TEST_PROPERTIES); + Connection conn = DriverManager.getConnection(getUrl(), props); + String testTable = generateUniqueName(); + + + String ddl = "create table " + testTable + " (k varchar primary key, v1 varchar)"; + Statement stmt = conn.createStatement(); + stmt.execute(ddl); + String indexName = "IDX_" + generateUniqueName(); + + ddl = "CREATE INDEX " + indexName + " ON " + testTable + " (v1) "; + stmt.execute(ddl); + conn.createStatement().execute("ALTER INDEX "+indexName+" ON " + testTable +" ACTIVE SET GUIDE_POSTS_WIDTH = 10"); + + ResultSet rs = conn.createStatement().executeQuery( + "select GUIDE_POSTS_WIDTH from SYSTEM.\"CATALOG\" where TABLE_NAME='" + indexName + "'");assertTrue(rs.next()); + assertEquals(10,rs.getInt(1)); + + conn.createStatement().execute("ALTER INDEX "+indexName+" ON " + testTable +" ACTIVE SET GUIDE_POSTS_WIDTH = 20"); + rs = conn.createStatement().executeQuery( + "select GUIDE_POSTS_WIDTH from SYSTEM.\"CATALOG\" where TABLE_NAME='" + indexName + "'");assertTrue(rs.next()); + assertEquals(20,rs.getInt(1)); + } + + + @Test + public void testIndexAlterHBaseProperty() throws Exception { + Properties props = PropertiesUtil.deepCopy(TEST_PROPERTIES); + Connection conn = DriverManager.getConnection(getUrl(), props); + String testTable = generateUniqueName(); + + String ddl = "create table " + testTable + " (k varchar primary key, v1 varchar)"; + Statement stmt = conn.createStatement(); + stmt.execute(ddl); + String indexName = "IDX_" + generateUniqueName(); + + ddl = "CREATE INDEX " + indexName + " ON " + testTable + " (v1) "; + stmt.execute(ddl); + + conn.createStatement().execute("ALTER INDEX "+indexName+" ON " + testTable +" ACTIVE SET DISABLE_WAL=false"); + asssertIsWALDisabled(conn,indexName,false); + conn.createStatement().execute("ALTER INDEX "+indexName+" ON " + testTable +" ACTIVE SET DISABLE_WAL=true"); + asssertIsWALDisabled(conn,indexName,true); + } + + private static void asssertIsWALDisabled(Connection conn, String fullTableName, boolean expectedValue) throws SQLException { + PhoenixConnection pconn = conn.unwrap(PhoenixConnection.class); + assertEquals(expectedValue, pconn.getTable(new PTableKey(pconn.getTenantId(), fullTableName)).isWALDisabled()); + } + } http://git-wip-us.apache.org/repos/asf/phoenix/blob/ef174bb2/phoenix-core/src/main/antlr3/PhoenixSQL.g ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/antlr3/PhoenixSQL.g b/phoenix-core/src/main/antlr3/PhoenixSQL.g index 8c9c135..ccf654b 100644 --- a/phoenix-core/src/main/antlr3/PhoenixSQL.g +++ b/phoenix-core/src/main/antlr3/PhoenixSQL.g @@ -605,8 +605,9 @@ drop_index_node returns [DropIndexStatement ret] // Parse a alter index statement alter_index_node returns [AlterIndexStatement ret] - : ALTER INDEX (IF ex=EXISTS)? i=index_name ON t=from_table_name s=(USABLE | UNUSABLE | REBUILD | DISABLE | ACTIVE) (async=ASYNC)? - {ret = factory.alterIndex(factory.namedTable(null, TableName.create(t.getSchemaName(), i.getName())), t.getTableName(), ex!=null, PIndexState.valueOf(SchemaUtil.normalizeIdentifier(s.getText())), async!=null); } + : ALTER INDEX (IF ex=EXISTS)? i=index_name ON t=from_table_name + ((s=(USABLE | UNUSABLE | REBUILD | DISABLE | ACTIVE)) (async=ASYNC)? ((SET?)p=fam_properties)?) + {ret = factory.alterIndex(factory.namedTable(null, TableName.create(t.getSchemaName(), i.getName())), t.getTableName(), ex!=null, PIndexState.valueOf(SchemaUtil.normalizeIdentifier(s.getText())), async!=null, p); } ; // Parse a trace statement. http://git-wip-us.apache.org/repos/asf/phoenix/blob/ef174bb2/phoenix-core/src/main/java/org/apache/phoenix/jdbc/PhoenixStatement.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/jdbc/PhoenixStatement.java b/phoenix-core/src/main/java/org/apache/phoenix/jdbc/PhoenixStatement.java index 26b4415..c699088 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/jdbc/PhoenixStatement.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/jdbc/PhoenixStatement.java @@ -1216,8 +1216,8 @@ public class PhoenixStatement implements Statement, SQLCloseable { private static class ExecutableAlterIndexStatement extends AlterIndexStatement implements CompilableStatement { - public ExecutableAlterIndexStatement(NamedTableNode indexTableNode, String dataTableName, boolean ifExists, PIndexState state, boolean async) { - super(indexTableNode, dataTableName, ifExists, state, async); + public ExecutableAlterIndexStatement(NamedTableNode indexTableNode, String dataTableName, boolean ifExists, PIndexState state, boolean async, ListMultimap<String,Pair<String,Object>> props) { + super(indexTableNode, dataTableName, ifExists, state, async, props); } @SuppressWarnings("unchecked") @@ -1563,10 +1563,10 @@ public class PhoenixStatement implements Statement, SQLCloseable { public DropIndexStatement dropIndex(NamedNode indexName, TableName tableName, boolean ifExists) { return new ExecutableDropIndexStatement(indexName, tableName, ifExists); } - + @Override - public AlterIndexStatement alterIndex(NamedTableNode indexTableNode, String dataTableName, boolean ifExists, PIndexState state, boolean async) { - return new ExecutableAlterIndexStatement(indexTableNode, dataTableName, ifExists, state, async); + public AlterIndexStatement alterIndex(NamedTableNode indexTableNode, String dataTableName, boolean ifExists, PIndexState state, boolean async, ListMultimap<String,Pair<String,Object>> props) { + return new ExecutableAlterIndexStatement(indexTableNode, dataTableName, ifExists, state, async, props); } @Override http://git-wip-us.apache.org/repos/asf/phoenix/blob/ef174bb2/phoenix-core/src/main/java/org/apache/phoenix/parse/AddColumnStatement.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/parse/AddColumnStatement.java b/phoenix-core/src/main/java/org/apache/phoenix/parse/AddColumnStatement.java index 1890d31..678e560 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/parse/AddColumnStatement.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/parse/AddColumnStatement.java @@ -48,4 +48,4 @@ public class AddColumnStatement extends AlterTableStatement { public ListMultimap<String,Pair<String,Object>> getProps() { return props; } -} +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/phoenix/blob/ef174bb2/phoenix-core/src/main/java/org/apache/phoenix/parse/AlterIndexStatement.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/parse/AlterIndexStatement.java b/phoenix-core/src/main/java/org/apache/phoenix/parse/AlterIndexStatement.java index 11328c2..de04505 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/parse/AlterIndexStatement.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/parse/AlterIndexStatement.java @@ -17,20 +17,31 @@ */ package org.apache.phoenix.parse; +import com.google.common.collect.ImmutableListMultimap; +import com.google.common.collect.ListMultimap; +import org.apache.hadoop.hbase.util.Pair; import org.apache.phoenix.schema.PIndexState; +import org.apache.phoenix.schema.PTableType; public class AlterIndexStatement extends SingleTableStatement { private final String dataTableName; private final boolean ifExists; private final PIndexState indexState; private boolean async; + private ListMultimap<String,Pair<String,Object>> props; + private static final PTableType tableType=PTableType.INDEX; public AlterIndexStatement(NamedTableNode indexTableNode, String dataTableName, boolean ifExists, PIndexState indexState, boolean async) { + this(indexTableNode,dataTableName,ifExists,indexState,async,null); + } + + public AlterIndexStatement(NamedTableNode indexTableNode, String dataTableName, boolean ifExists, PIndexState indexState, boolean async, ListMultimap<String,Pair<String,Object>> props) { super(indexTableNode,0); this.dataTableName = dataTableName; this.ifExists = ifExists; this.indexState = indexState; this.async = async; + this.props= props==null ? ImmutableListMultimap.<String,Pair<String,Object>>of() : props; } public String getTableName() { @@ -54,4 +65,7 @@ public class AlterIndexStatement extends SingleTableStatement { return async; } + public ListMultimap<String,Pair<String,Object>> getProps() { return props; } + + public PTableType getTableType(){ return tableType; } } http://git-wip-us.apache.org/repos/asf/phoenix/blob/ef174bb2/phoenix-core/src/main/java/org/apache/phoenix/parse/ParseNodeFactory.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/parse/ParseNodeFactory.java b/phoenix-core/src/main/java/org/apache/phoenix/parse/ParseNodeFactory.java index 32c3d8d..9be59f3 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/parse/ParseNodeFactory.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/parse/ParseNodeFactory.java @@ -373,10 +373,10 @@ public class ParseNodeFactory { return new DropIndexStatement(indexName, tableName, ifExists); } - public AlterIndexStatement alterIndex(NamedTableNode indexTableNode, String dataTableName, boolean ifExists, PIndexState state, boolean async) { - return new AlterIndexStatement(indexTableNode, dataTableName, ifExists, state, async); + public AlterIndexStatement alterIndex(NamedTableNode indexTableNode, String dataTableName, boolean ifExists, PIndexState state, boolean async, ListMultimap<String,Pair<String,Object>> props) { + return new AlterIndexStatement(indexTableNode, dataTableName, ifExists, state, async, props); } - + public AlterIndexStatement alterIndex(NamedTableNode indexTableNode, String dataTableName, boolean ifExists, PIndexState state) { return new AlterIndexStatement(indexTableNode, dataTableName, ifExists, state, false); } http://git-wip-us.apache.org/repos/asf/phoenix/blob/ef174bb2/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionQueryServices.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionQueryServices.java b/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionQueryServices.java index 45ab5fa..90f8089 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionQueryServices.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionQueryServices.java @@ -86,6 +86,8 @@ public interface ConnectionQueryServices extends QueryServices, MetaDataMutated public MetaDataMutationResult addColumn(List<Mutation> tableMetaData, PTable table, Map<String, List<Pair<String,Object>>> properties, Set<String> colFamiliesForPColumnsToBeAdded, List<PColumn> columns) throws SQLException; public MetaDataMutationResult dropColumn(List<Mutation> tableMetadata, PTableType tableType) throws SQLException; public MetaDataMutationResult updateIndexState(List<Mutation> tableMetadata, String parentTableName) throws SQLException; + public MetaDataMutationResult updateIndexState(List<Mutation> tableMetadata, String parentTableName, Map<String, List<Pair<String,Object>>> stmtProperties, PTable table) throws SQLException; + public MutationState updateData(MutationPlan plan) throws SQLException; public void init(String url, Properties props) throws SQLException; http://git-wip-us.apache.org/repos/asf/phoenix/blob/ef174bb2/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionQueryServicesImpl.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionQueryServicesImpl.java b/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionQueryServicesImpl.java index 08aadfb..072bf28 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionQueryServicesImpl.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionQueryServicesImpl.java @@ -3601,6 +3601,26 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement } @Override + public MetaDataMutationResult updateIndexState(final List<Mutation> tableMetaData, String parentTableName, Map<String, List<Pair<String,Object>>> stmtProperties, PTable table) throws SQLException { + if(stmtProperties==null) return updateIndexState(tableMetaData,parentTableName); + + Map<String, Object> tableProps = new HashMap<String, Object>(); + Pair<HTableDescriptor,HTableDescriptor> tableDescriptorPair = separateAndValidateProperties(table, stmtProperties, new HashSet<String>(), tableProps); + HTableDescriptor tableDescriptor = tableDescriptorPair.getSecond(); + HTableDescriptor origTableDescriptor = tableDescriptorPair.getFirst(); + Set<HTableDescriptor> tableDescriptors = Collections.emptySet(); + Set<HTableDescriptor> origTableDescriptors = Collections.emptySet(); + if (tableDescriptor != null) { + tableDescriptors = Sets.newHashSetWithExpectedSize(3 + table.getIndexes().size()); + origTableDescriptors = Sets.newHashSetWithExpectedSize(3 + table.getIndexes().size()); + tableDescriptors.add(tableDescriptor); + origTableDescriptors.add(origTableDescriptor); + } + sendHBaseMetaData(tableDescriptors, true); + return updateIndexState(tableMetaData,parentTableName); + } + + @Override public long createSequence(String tenantId, String schemaName, String sequenceName, long startWith, long incrementBy, long cacheSize, long minValue, long maxValue, boolean cycle, long timestamp) throws SQLException { http://git-wip-us.apache.org/repos/asf/phoenix/blob/ef174bb2/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionlessQueryServicesImpl.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionlessQueryServicesImpl.java b/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionlessQueryServicesImpl.java index f15e0b1..3154f86 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionlessQueryServicesImpl.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/query/ConnectionlessQueryServicesImpl.java @@ -383,6 +383,13 @@ public class ConnectionlessQueryServicesImpl extends DelegateQueryServices imple } @Override + public MetaDataMutationResult updateIndexState(List<Mutation> tableMetadata, + String parentTableName, Map<String, List<Pair<String, Object>>> stmtProperties, + PTable table) throws SQLException { + return updateIndexState(tableMetadata,parentTableName); + } + + @Override public HTableDescriptor getTableDescriptor(byte[] tableName) throws SQLException { return null; } http://git-wip-us.apache.org/repos/asf/phoenix/blob/ef174bb2/phoenix-core/src/main/java/org/apache/phoenix/query/DelegateConnectionQueryServices.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/query/DelegateConnectionQueryServices.java b/phoenix-core/src/main/java/org/apache/phoenix/query/DelegateConnectionQueryServices.java index 6c464eb..05d1af6 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/query/DelegateConnectionQueryServices.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/query/DelegateConnectionQueryServices.java @@ -135,7 +135,13 @@ public class DelegateConnectionQueryServices extends DelegateQueryServices imple public MetaDataMutationResult updateIndexState(List<Mutation> tableMetadata, String parentTableName) throws SQLException { return getDelegate().updateIndexState(tableMetadata, parentTableName); } - + + @Override public MetaDataMutationResult updateIndexState(List<Mutation> tableMetadata, + String parentTableName, Map<String, List<Pair<String, Object>>> stmtProperties, + PTable table) throws SQLException { + return getDelegate().updateIndexState(tableMetadata, parentTableName, stmtProperties,table); + } + @Override public void init(String url, Properties props) throws SQLException { getDelegate().init(url, props); http://git-wip-us.apache.org/repos/asf/phoenix/blob/ef174bb2/phoenix-core/src/main/java/org/apache/phoenix/schema/MetaDataClient.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/schema/MetaDataClient.java b/phoenix-core/src/main/java/org/apache/phoenix/schema/MetaDataClient.java index 1f76e90..fc2e288 100644 --- a/phoenix-core/src/main/java/org/apache/phoenix/schema/MetaDataClient.java +++ b/phoenix-core/src/main/java/org/apache/phoenix/schema/MetaDataClient.java @@ -3007,6 +3007,21 @@ public class MetaDataClient { return mutationCode; } + private long incrementTableSeqNum(PTable table, PTableType expectedType, int columnCountDelta, MetaPropertiesEvaluated metaPropertiesEvaluated) + throws SQLException { + return incrementTableSeqNum(table, expectedType, columnCountDelta, + metaPropertiesEvaluated.getIsTransactional(), + metaPropertiesEvaluated.getUpdateCacheFrequency(), + metaPropertiesEvaluated.getIsImmutableRows(), + metaPropertiesEvaluated.getDisableWAL(), + metaPropertiesEvaluated.getMultiTenant(), + metaPropertiesEvaluated.getStoreNulls(), + metaPropertiesEvaluated.getGuidePostWidth(), + metaPropertiesEvaluated.getAppendOnlySchema(), + metaPropertiesEvaluated.getImmutableStorageScheme(), + metaPropertiesEvaluated.getUseStatsForParallelization()); + } + private long incrementTableSeqNum(PTable table, PTableType expectedType, int columnCountDelta, Boolean isTransactional, Long updateCacheFrequency) throws SQLException { return incrementTableSeqNum(table, expectedType, columnCountDelta, isTransactional, updateCacheFrequency, null, null, null, null, -1L, null, null, null); } @@ -3138,18 +3153,7 @@ public class MetaDataClient { PName tenantId = connection.getTenantId(); String schemaName = table.getSchemaName().getString(); String tableName = table.getTableName().getString(); - Boolean isImmutableRowsProp = null; - Boolean multiTenantProp = null; - Boolean disableWALProp = null; - Boolean storeNullsProp = null; - Boolean isTransactionalProp = null; - Long updateCacheFrequencyProp = null; - Boolean appendOnlySchemaProp = null; - Long guidePostWidth = -1L; - ImmutableStorageScheme immutableStorageSchemeProp = null; - Boolean useStatsForParallelizationProp = null; - - Map<String, List<Pair<String, Object>>> properties = new HashMap<>(stmtProperties.size()); + List<ColumnDef> columnDefs = null; if (table.isAppendOnlySchema()) { // only make the rpc if we are adding new columns @@ -3185,48 +3189,14 @@ public class MetaDataClient { else { columnDefs = origColumnDefs == null ? Collections.<ColumnDef>emptyList() : origColumnDefs; } - for (String family : stmtProperties.keySet()) { - List<Pair<String, Object>> origPropsList = stmtProperties.get(family); - List<Pair<String, Object>> propsList = Lists.newArrayListWithExpectedSize(origPropsList.size()); - for (Pair<String, Object> prop : origPropsList) { - String propName = prop.getFirst(); - if (TableProperty.isPhoenixTableProperty(propName)) { - TableProperty tableProp = TableProperty.valueOf(propName); - tableProp.validate(true, !family.equals(QueryConstants.ALL_FAMILY_PROPERTIES_KEY), table.getType()); - Object value = tableProp.getValue(prop.getSecond()); - if (propName.equals(PTable.IS_IMMUTABLE_ROWS_PROP_NAME)) { - isImmutableRowsProp = (Boolean)value; - } else if (propName.equals(PhoenixDatabaseMetaData.MULTI_TENANT)) { - multiTenantProp = (Boolean)value; - } else if (propName.equals(DISABLE_WAL)) { - disableWALProp = (Boolean)value; - } else if (propName.equals(STORE_NULLS)) { - storeNullsProp = (Boolean)value; - } else if (propName.equals(TRANSACTIONAL)) { - isTransactionalProp = (Boolean)value; - } else if (propName.equals(UPDATE_CACHE_FREQUENCY)) { - updateCacheFrequencyProp = (Long)value; - } else if (propName.equals(GUIDE_POSTS_WIDTH)) { - guidePostWidth = (Long)value; - } else if (propName.equals(APPEND_ONLY_SCHEMA)) { - appendOnlySchemaProp = (Boolean) value; - } else if (propName.equalsIgnoreCase(IMMUTABLE_STORAGE_SCHEME)) { - immutableStorageSchemeProp = (ImmutableStorageScheme)value; - } else if (propName.equalsIgnoreCase(USE_STATS_FOR_PARALLELIZATION)) { - useStatsForParallelizationProp = (Boolean)value; - } - } - // if removeTableProps is true only add the property if it is not a HTable or Phoenix Table property - if (!removeTableProps || (!TableProperty.isPhoenixTableProperty(propName) && !MetaDataUtil.isHTableProperty(propName))) { - propsList.add(prop); - } - } - properties.put(family, propsList); - } + boolean retried = false; boolean changingPhoenixTableProperty = false; - boolean nonTxToTx = false; + MetaProperties metaProperties = new MetaProperties(); while (true) { + Map<String, List<Pair<String, Object>>> properties=new HashMap<>(stmtProperties.size());; + metaProperties = loadStmtProperties(stmtProperties,properties,table,removeTableProps); + ColumnResolver resolver = FromCompiler.getResolver(namedTableNode, connection); table = resolver.getTables().get(0).getTable(); int nIndexes = table.getIndexes().size(); @@ -3253,108 +3223,11 @@ public class MetaDataClient { .setColumnName(lastPK.getName().getString()).build().buildException(); } - Boolean isImmutableRows = null; - if (isImmutableRowsProp != null) { - if (isImmutableRowsProp.booleanValue() != table.isImmutableRows()) { - if (table.getImmutableStorageScheme() != ImmutableStorageScheme.ONE_CELL_PER_COLUMN) { - throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_ALTER_IMMUTABLE_ROWS_PROPERTY) - .setSchemaName(schemaName).setTableName(tableName).build().buildException(); - } - isImmutableRows = isImmutableRowsProp; - changingPhoenixTableProperty = true; - } - } - Boolean multiTenant = null; - if (multiTenantProp != null) { - if (multiTenantProp.booleanValue() != table.isMultiTenant()) { - multiTenant = multiTenantProp; - changingPhoenixTableProperty = true; - } - } - Boolean disableWAL = null; - if (disableWALProp != null) { - if (disableWALProp.booleanValue() != table.isWALDisabled()) { - disableWAL = disableWALProp; - changingPhoenixTableProperty = true; - } - } - Long updateCacheFrequency = null; - if (updateCacheFrequencyProp != null) { - if (updateCacheFrequencyProp.longValue() != table.getUpdateCacheFrequency()) { - updateCacheFrequency = updateCacheFrequencyProp; - changingPhoenixTableProperty = true; - } - } - Boolean appendOnlySchema = null; - if (appendOnlySchemaProp !=null) { - if (appendOnlySchemaProp != table.isAppendOnlySchema()) { - appendOnlySchema = appendOnlySchemaProp; - changingPhoenixTableProperty = true; - } - } - ImmutableStorageScheme immutableStorageScheme = null; - if (immutableStorageSchemeProp!=null) { - if (table.getImmutableStorageScheme() == ONE_CELL_PER_COLUMN || - immutableStorageSchemeProp == ONE_CELL_PER_COLUMN) { - throw new SQLExceptionInfo.Builder(SQLExceptionCode.INVALID_IMMUTABLE_STORAGE_SCHEME_CHANGE) - .setSchemaName(schemaName).setTableName(tableName).build().buildException(); - } - else if (immutableStorageSchemeProp != table.getImmutableStorageScheme()) { - immutableStorageScheme = immutableStorageSchemeProp; - changingPhoenixTableProperty = true; - } - } - - if (guidePostWidth == null || guidePostWidth >= 0) { - changingPhoenixTableProperty = true; - } - Boolean storeNulls = null; - if (storeNullsProp != null) { - if (storeNullsProp.booleanValue() != table.getStoreNulls()) { - storeNulls = storeNullsProp; - changingPhoenixTableProperty = true; - } - } - Boolean useStatsForParallelization = null; - if (useStatsForParallelizationProp != null - && (table.useStatsForParallelization() == null - || (useStatsForParallelizationProp.booleanValue() != table - .useStatsForParallelization()))) { - useStatsForParallelization = useStatsForParallelizationProp; - changingPhoenixTableProperty = true; - } - Boolean isTransactional = null; - if (isTransactionalProp != null) { - if (isTransactionalProp.booleanValue() != table.isTransactional()) { - isTransactional = isTransactionalProp; - // We can only go one way: from non transactional to transactional - // Going the other way would require rewriting the cell timestamps - // and doing a major compaction to get rid of any Tephra specific - // delete markers. - if (!isTransactional) { - throw new SQLExceptionInfo.Builder(SQLExceptionCode.TX_MAY_NOT_SWITCH_TO_NON_TX) - .setSchemaName(schemaName).setTableName(tableName).build().buildException(); - } - // cannot create a transactional table if transactions are disabled - boolean transactionsEnabled = connection.getQueryServices().getProps().getBoolean( - QueryServices.TRANSACTIONS_ENABLED, - QueryServicesOptions.DEFAULT_TRANSACTIONS_ENABLED); - if (!transactionsEnabled) { - throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_ALTER_TO_BE_TXN_IF_TXNS_DISABLED) - .setSchemaName(schemaName).setTableName(tableName).build().buildException(); - } - // cannot make a table transactional if it has a row timestamp column - if (SchemaUtil.hasRowTimestampColumn(table)) { - throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_ALTER_TO_BE_TXN_WITH_ROW_TIMESTAMP) - .setSchemaName(schemaName).setTableName(tableName) - .build().buildException(); - } - changingPhoenixTableProperty = true; - nonTxToTx = true; - } - } - Long timeStamp = TransactionUtil.getTableTimestamp(connection, table.isTransactional() || nonTxToTx); + MetaPropertiesEvaluated metaPropertiesEvaluated = new MetaPropertiesEvaluated(); + changingPhoenixTableProperty = evaluateStmtProperties(metaProperties,metaPropertiesEvaluated,table,schemaName,tableName); + + Long timeStamp = TransactionUtil.getTableTimestamp(connection, table.isTransactional() || metaProperties.getNonTxToTx()); int numPkColumnsAdded = 0; List<PColumn> columns = Lists.newArrayListWithExpectedSize(numCols); Set<String> colFamiliesForPColumnsToBeAdded = new LinkedHashSet<>(); @@ -3471,7 +3344,7 @@ public class MetaDataClient { // Check that HBase configured properly for mutable secondary indexing // if we're changing from an immutable table to a mutable table and we // have existing indexes. - if (Boolean.FALSE.equals(isImmutableRows) && !table.getIndexes().isEmpty()) { + if (Boolean.FALSE.equals(metaPropertiesEvaluated.getIsImmutableRows()) && !table.getIndexes().isEmpty()) { int hbaseVersion = connection.getQueryServices().getLowestClusterHBaseVersion(); if (hbaseVersion < PhoenixDatabaseMetaData.MUTABLE_SI_VERSION_THRESHOLD) { throw new SQLExceptionInfo.Builder(SQLExceptionCode.NO_MUTABLE_INDEXES) @@ -3482,22 +3355,22 @@ public class MetaDataClient { .setSchemaName(schemaName).setTableName(tableName).build().buildException(); } } - if (Boolean.TRUE.equals(multiTenant)) { - throwIfInsufficientColumns(schemaName, tableName, table.getPKColumns(), table.getBucketNum()!=null, multiTenant); + if (Boolean.TRUE.equals(metaPropertiesEvaluated.getMultiTenant())) { + throwIfInsufficientColumns(schemaName, tableName, table.getPKColumns(), table.getBucketNum()!=null, metaPropertiesEvaluated.getMultiTenant()); } } - if (!table.getIndexes().isEmpty() && (numPkColumnsAdded>0 || nonTxToTx)) { + if (!table.getIndexes().isEmpty() && (numPkColumnsAdded>0 || metaProperties.getNonTxToTx())) { for (PTable index : table.getIndexes()) { - incrementTableSeqNum(index, index.getType(), numPkColumnsAdded, nonTxToTx ? Boolean.TRUE : null, updateCacheFrequency); + incrementTableSeqNum(index, index.getType(), numPkColumnsAdded, metaProperties.getNonTxToTx() ? Boolean.TRUE : null, metaPropertiesEvaluated.getUpdateCacheFrequency()); } tableMetaData.addAll(connection.getMutationState().toMutations(timeStamp).next().getSecond()); connection.rollback(); } if (changingPhoenixTableProperty || columnDefs.size() > 0) { - incrementTableSeqNum(table, tableType, columnDefs.size(), isTransactional, updateCacheFrequency, isImmutableRows, - disableWAL, multiTenant, storeNulls, guidePostWidth, appendOnlySchema, immutableStorageScheme, useStatsForParallelization); + incrementTableSeqNum(table, tableType, columnDefs.size(), metaPropertiesEvaluated); + tableMetaData.addAll(connection.getMutationState().toMutations(timeStamp).next().getSecond()); connection.rollback(); } @@ -3567,10 +3440,10 @@ public class MetaDataClient { // We could update the cache manually then too, it'd just be a pain. String fullTableName = SchemaUtil.getTableName(schemaName, tableName); long resolvedTimeStamp = TransactionUtil.getResolvedTime(connection, result); - if (table.getIndexes().isEmpty() || (numPkColumnsAdded==0 && !nonTxToTx)) { + if (table.getIndexes().isEmpty() || (numPkColumnsAdded==0 && ! metaProperties.getNonTxToTx())) { connection.addTable(result.getTable(), resolvedTimeStamp); table = result.getTable(); - } else if (updateCacheFrequency != null) { + } else if (metaPropertiesEvaluated.getUpdateCacheFrequency() != null) { // Force removal from cache as the update cache frequency has changed // Note that clients outside this JVM won't be affected. connection.removeTable(tenantId, fullTableName, null, resolvedTimeStamp); @@ -3578,7 +3451,7 @@ public class MetaDataClient { // Delete rows in view index if we haven't dropped it already // We only need to do this if the multiTenant transitioned to false if (table.getType() == PTableType.TABLE - && Boolean.FALSE.equals(multiTenant) + && Boolean.FALSE.equals(metaPropertiesEvaluated.getMultiTenant()) && MetaDataUtil.hasViewIndexTable(connection, table.getPhysicalName())) { connection.setAutoCommit(true); MetaDataUtil.deleteViewIndexSequences(connection, table.getPhysicalName(), table.isNamespaceMapped()); @@ -3940,9 +3813,19 @@ public class MetaDataClient { boolean wasAutoCommit = connection.getAutoCommit(); try { String dataTableName = statement.getTableName(); - String schemaName = statement.getTable().getName().getSchemaName(); String indexName = statement.getTable().getName().getTableName(); boolean isAsync = statement.isAsync(); + String tenantId = connection.getTenantId() == null ? null : connection.getTenantId().getString(); + PTable table = FromCompiler.getResolver(statement, connection).getTables().get(0).getTable(); + String schemaName = statement.getTable().getName().getSchemaName(); + String tableName = table.getTableName().getString(); + + Map<String, List<Pair<String, Object>>> properties=new HashMap<>(statement.getProps().size());; + MetaProperties metaProperties = loadStmtProperties(statement.getProps(),properties,table,false); + + MetaPropertiesEvaluated metaPropertiesEvaluated = new MetaPropertiesEvaluated(); + boolean changingPhoenixTableProperty= evaluateStmtProperties(metaProperties,metaPropertiesEvaluated,table,schemaName,tableName); + PIndexState newIndexState = statement.getIndexState(); if (isAsync && newIndexState != PIndexState.REBUILD) { throw new SQLExceptionInfo.Builder( SQLExceptionCode.ASYNC_NOT_ALLOWED) @@ -3980,7 +3863,15 @@ public class MetaDataClient { List<Mutation> tableMetadata = connection.getMutationState().toMutations(timeStamp).next().getSecond(); connection.rollback(); - MetaDataMutationResult result = connection.getQueryServices().updateIndexState(tableMetadata, dataTableName); + + if (changingPhoenixTableProperty) { + incrementTableSeqNum(table,statement.getTableType(), 0, metaPropertiesEvaluated); + tableMetadata.addAll(connection.getMutationState().toMutations(timeStamp).next().getSecond()); + connection.rollback(); + } + + MetaDataMutationResult result = connection.getQueryServices().updateIndexState(tableMetadata, dataTableName, properties, table); + MutationCode code = result.getMutationCode(); if (code == MutationCode.TABLE_NOT_FOUND) { throw new TableNotFoundException(schemaName,indexName); @@ -4306,4 +4197,351 @@ public class MetaDataClient { AccessControlClient.revoke(clusterConnection, changePermsStatement.getName(), Permission.Action.values()); } } + + private MetaProperties loadStmtProperties(ListMultimap<String, Pair<String, Object>> stmtProperties, Map<String, List<Pair<String, Object>>> properties, PTable table, boolean removeTableProps) + throws SQLException { + MetaProperties metaProperties = new MetaProperties(); + for (String family : stmtProperties.keySet()) { + List<Pair<String, Object>> origPropsList = stmtProperties.get(family); + List<Pair<String, Object>> propsList = Lists.newArrayListWithExpectedSize(origPropsList.size()); + for (Pair<String, Object> prop : origPropsList) { + String propName = prop.getFirst(); + if (TableProperty.isPhoenixTableProperty(propName)) { + TableProperty tableProp = TableProperty.valueOf(propName); + tableProp.validate(true, !family.equals(QueryConstants.ALL_FAMILY_PROPERTIES_KEY), table.getType()); + Object value = tableProp.getValue(prop.getSecond()); + if (propName.equals(PTable.IS_IMMUTABLE_ROWS_PROP_NAME)) { + metaProperties.setImmutableRowsProp((Boolean)value); + } else if (propName.equals(PhoenixDatabaseMetaData.MULTI_TENANT)) { + metaProperties.setMultiTenantProp((Boolean)value); + } else if (propName.equals(DISABLE_WAL)) { + metaProperties.setDisableWALProp((Boolean)value); + } else if (propName.equals(STORE_NULLS)) { + metaProperties.setStoreNullsProp((Boolean)value); + } else if (propName.equals(TRANSACTIONAL)) { + metaProperties.setIsTransactionalProp((Boolean)value); + } else if (propName.equals(UPDATE_CACHE_FREQUENCY)) { + metaProperties.setUpdateCacheFrequencyProp((Long)value); + } else if (propName.equals(GUIDE_POSTS_WIDTH)) { + metaProperties.setGuidePostWidth((Long)value); + } else if (propName.equals(APPEND_ONLY_SCHEMA)) { + metaProperties.setAppendOnlySchemaProp((Boolean) value); + } else if (propName.equalsIgnoreCase(IMMUTABLE_STORAGE_SCHEME)) { + metaProperties.setImmutableStorageSchemeProp((ImmutableStorageScheme)value); + } else if (propName.equalsIgnoreCase(USE_STATS_FOR_PARALLELIZATION)) { + metaProperties.setUseStatsForParallelizationProp((Boolean)value); + } + } + // if removeTableProps is true only add the property if it is not a HTable or Phoenix Table property + if (!removeTableProps || (!TableProperty.isPhoenixTableProperty(propName) && !MetaDataUtil.isHTableProperty(propName))) { + propsList.add(prop); + } + } + properties.put(family, propsList); + } + return metaProperties; + } + + private boolean evaluateStmtProperties(MetaProperties metaProperties, MetaPropertiesEvaluated metaPropertiesEvaluated, PTable table, String schemaName, String tableName) + throws SQLException { + boolean changingPhoenixTableProperty = false; + + if (metaProperties.getImmutableRowsProp() != null) { + if (metaProperties.getImmutableRowsProp().booleanValue() != table.isImmutableRows()) { + if (table.getImmutableStorageScheme() != ImmutableStorageScheme.ONE_CELL_PER_COLUMN) { + throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_ALTER_IMMUTABLE_ROWS_PROPERTY) + .setSchemaName(schemaName).setTableName(tableName).build().buildException(); + } + metaPropertiesEvaluated.setIsImmutableRows(metaProperties.getImmutableRowsProp()); + changingPhoenixTableProperty = true; + } + } + + if (metaProperties.getMultiTenantProp() != null) { + if (metaProperties.getMultiTenantProp().booleanValue() != table.isMultiTenant()) { + metaPropertiesEvaluated.setMultiTenant(metaProperties.getMultiTenantProp()); + changingPhoenixTableProperty = true; + } + } + + if (metaProperties.getDisableWALProp() != null) { + if (metaProperties.getDisableWALProp().booleanValue() != table.isWALDisabled()) { + metaPropertiesEvaluated.setDisableWAL(metaProperties.getDisableWALProp()); + changingPhoenixTableProperty = true; + } + } + + if (metaProperties.getUpdateCacheFrequencyProp() != null) { + if (metaProperties.getUpdateCacheFrequencyProp().longValue() != table.getUpdateCacheFrequency()) { + metaPropertiesEvaluated.setUpdateCacheFrequency(metaProperties.getUpdateCacheFrequencyProp()); + changingPhoenixTableProperty = true; + } + } + + if (metaProperties.getAppendOnlySchemaProp() !=null) { + if (metaProperties.getAppendOnlySchemaProp() != table.isAppendOnlySchema()) { + metaPropertiesEvaluated.setAppendOnlySchema(metaProperties.getAppendOnlySchemaProp()); + changingPhoenixTableProperty = true; + } + } + + if (metaProperties.getImmutableStorageSchemeProp()!=null) { + if (table.getImmutableStorageScheme() == ONE_CELL_PER_COLUMN || + metaProperties.getImmutableStorageSchemeProp() == ONE_CELL_PER_COLUMN) { + throw new SQLExceptionInfo.Builder(SQLExceptionCode.INVALID_IMMUTABLE_STORAGE_SCHEME_CHANGE) + .setSchemaName(schemaName).setTableName(tableName).build().buildException(); + } + else if (metaProperties.getImmutableStorageSchemeProp() != table.getImmutableStorageScheme()) { + metaPropertiesEvaluated.setImmutableStorageScheme(metaProperties.getImmutableStorageSchemeProp()); + changingPhoenixTableProperty = true; + } + } + + if (metaProperties.getGuidePostWidth() == null || metaProperties.getGuidePostWidth() >= 0) { + metaPropertiesEvaluated.setGuidePostWidth(metaProperties.getGuidePostWidth()); + changingPhoenixTableProperty = true; + } + + if (metaProperties.getStoreNullsProp() != null) { + if (metaProperties.getStoreNullsProp().booleanValue() != table.getStoreNulls()) { + metaPropertiesEvaluated.setStoreNulls(metaProperties.getStoreNullsProp()); + changingPhoenixTableProperty = true; + } + } + + if (metaProperties.getUseStatsForParallelizationProp() != null + && (table.useStatsForParallelization() == null + || (metaProperties.getUseStatsForParallelizationProp().booleanValue() != table + .useStatsForParallelization()))) { + metaPropertiesEvaluated.setUseStatsForParallelization(metaProperties.getUseStatsForParallelizationProp()); + changingPhoenixTableProperty = true; + } + + if (metaProperties.getIsTransactionalProp() != null) { + if (metaProperties.getIsTransactionalProp().booleanValue() != table.isTransactional()) { + metaPropertiesEvaluated.setIsTransactional(metaProperties.getIsTransactionalProp()); + // We can only go one way: from non transactional to transactional + // Going the other way would require rewriting the cell timestamps + // and doing a major compaction to get rid of any Tephra specific + // delete markers. + if (!metaPropertiesEvaluated.getIsTransactional()) { + throw new SQLExceptionInfo.Builder(SQLExceptionCode.TX_MAY_NOT_SWITCH_TO_NON_TX) + .setSchemaName(schemaName).setTableName(tableName).build().buildException(); + } + // cannot create a transactional table if transactions are disabled + boolean transactionsEnabled = connection.getQueryServices().getProps().getBoolean( + QueryServices.TRANSACTIONS_ENABLED, + QueryServicesOptions.DEFAULT_TRANSACTIONS_ENABLED); + if (!transactionsEnabled) { + throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_ALTER_TO_BE_TXN_IF_TXNS_DISABLED) + .setSchemaName(schemaName).setTableName(tableName).build().buildException(); + } + // cannot make a table transactional if it has a row timestamp column + if (SchemaUtil.hasRowTimestampColumn(table)) { + throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_ALTER_TO_BE_TXN_WITH_ROW_TIMESTAMP) + .setSchemaName(schemaName).setTableName(tableName) + .build().buildException(); + } + changingPhoenixTableProperty = true; + metaProperties.setNonTxToTx(true); + } + } + return changingPhoenixTableProperty; + } + + class MetaProperties{ + private Boolean isImmutableRowsProp = null; + private Boolean multiTenantProp = null; + private Boolean disableWALProp = null; + private Boolean storeNullsProp = null; + private Boolean isTransactionalProp = null; + private Long updateCacheFrequencyProp = null; + private Boolean appendOnlySchemaProp = null; + private Long guidePostWidth = -1L; + private ImmutableStorageScheme immutableStorageSchemeProp = null; + private Boolean useStatsForParallelizationProp = null; + private boolean nonTxToTx = false; + + public Boolean getImmutableRowsProp() { + return isImmutableRowsProp; + } + + public void setImmutableRowsProp(Boolean isImmutableRowsProp) { + this.isImmutableRowsProp = isImmutableRowsProp; + } + + public Boolean getMultiTenantProp() { + return multiTenantProp; + } + + public void setMultiTenantProp(Boolean multiTenantProp) { + this.multiTenantProp = multiTenantProp; + } + + public Boolean getDisableWALProp() { + return disableWALProp; + } + + public void setDisableWALProp(Boolean disableWALProp) { + this.disableWALProp = disableWALProp; + } + + public Boolean getStoreNullsProp() { + return storeNullsProp; + } + + public void setStoreNullsProp(Boolean storeNullsProp) { + this.storeNullsProp = storeNullsProp; + } + + public Boolean getIsTransactionalProp() { + return isTransactionalProp; + } + + public void setIsTransactionalProp(Boolean isTransactionalProp) { + this.isTransactionalProp = isTransactionalProp; + } + + public Long getUpdateCacheFrequencyProp() { + return updateCacheFrequencyProp; + } + + public void setUpdateCacheFrequencyProp(Long updateCacheFrequencyProp) { + this.updateCacheFrequencyProp = updateCacheFrequencyProp; + } + + public Boolean getAppendOnlySchemaProp() { + return appendOnlySchemaProp; + } + + public void setAppendOnlySchemaProp(Boolean appendOnlySchemaProp) { + this.appendOnlySchemaProp = appendOnlySchemaProp; + } + + public Long getGuidePostWidth() { + return guidePostWidth; + } + + public void setGuidePostWidth(Long guidePostWidth) { + this.guidePostWidth = guidePostWidth; + } + + public ImmutableStorageScheme getImmutableStorageSchemeProp() { + return immutableStorageSchemeProp; + } + + public void setImmutableStorageSchemeProp( + ImmutableStorageScheme immutableStorageSchemeProp) { + this.immutableStorageSchemeProp = immutableStorageSchemeProp; + } + + public Boolean getUseStatsForParallelizationProp() { + return useStatsForParallelizationProp; + } + + public void setUseStatsForParallelizationProp(Boolean useStatsForParallelizationProp) { + this.useStatsForParallelizationProp = useStatsForParallelizationProp; + } + + public boolean getNonTxToTx() { + return nonTxToTx; + } + + public void setNonTxToTx(boolean nonTxToTx) { + this.nonTxToTx = nonTxToTx; + } + } + + class MetaPropertiesEvaluated{ + private Boolean isImmutableRows; + private Boolean multiTenant = null; + private Boolean disableWAL = null; + private Long updateCacheFrequency = null; + private Boolean appendOnlySchema = null; + private Long guidePostWidth = -1L; + private ImmutableStorageScheme immutableStorageScheme = null; + private Boolean storeNulls = null; + private Boolean useStatsForParallelization = null; + private Boolean isTransactional = null; + + public Boolean getIsImmutableRows() { + return isImmutableRows; + } + + public void setIsImmutableRows(Boolean isImmutableRows) { + this.isImmutableRows = isImmutableRows; + } + + public Boolean getMultiTenant() { + return multiTenant; + } + + public void setMultiTenant(Boolean multiTenant) { + this.multiTenant = multiTenant; + } + + public Boolean getDisableWAL() { + return disableWAL; + } + + public void setDisableWAL(Boolean disableWAL) { + this.disableWAL = disableWAL; + } + + public Long getUpdateCacheFrequency() { + return updateCacheFrequency; + } + + public void setUpdateCacheFrequency(Long updateCacheFrequency) { + this.updateCacheFrequency = updateCacheFrequency; + } + + public Boolean getAppendOnlySchema() { + return appendOnlySchema; + } + + public void setAppendOnlySchema(Boolean appendOnlySchema) { + this.appendOnlySchema = appendOnlySchema; + } + + public Long getGuidePostWidth() { + return guidePostWidth; + } + + public void setGuidePostWidth(Long guidePostWidth) { + this.guidePostWidth = guidePostWidth; + } + + public ImmutableStorageScheme getImmutableStorageScheme() { + return immutableStorageScheme; + } + + public void setImmutableStorageScheme(ImmutableStorageScheme immutableStorageScheme) { + this.immutableStorageScheme = immutableStorageScheme; + } + + public Boolean getStoreNulls() { + return storeNulls; + } + + public void setStoreNulls(Boolean storeNulls) { + this.storeNulls = storeNulls; + } + + public Boolean getUseStatsForParallelization() { + return useStatsForParallelization; + } + + public void setUseStatsForParallelization(Boolean useStatsForParallelization) { + this.useStatsForParallelization = useStatsForParallelization; + } + + public Boolean getIsTransactional() { + return isTransactional; + } + + public void setIsTransactional(Boolean isTransactional) { + this.isTransactional = isTransactional; + } + } }
