You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@phoenix.apache.org by ja...@apache.org on 2014/02/18 11:04:55 UTC
[1/4] PHOENIX-21: Support indexes on multi-tenant views. Still needs
more testing
Repository: incubator-phoenix
Updated Branches:
refs/heads/master 9a46c0e0c -> e2bd0ee06
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/test/java/org/apache/phoenix/end2end/QueryDatabaseMetaDataTest.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/end2end/QueryDatabaseMetaDataTest.java b/phoenix-core/src/test/java/org/apache/phoenix/end2end/QueryDatabaseMetaDataTest.java
index 253ebfe..b4daa19 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/end2end/QueryDatabaseMetaDataTest.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/end2end/QueryDatabaseMetaDataTest.java
@@ -46,6 +46,7 @@ import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
+import java.util.Arrays;
import java.util.Properties;
import org.apache.hadoop.hbase.HColumnDescriptor;
@@ -61,6 +62,7 @@ import org.apache.hadoop.hbase.util.Bytes;
import org.apache.phoenix.coprocessor.GroupedAggregateRegionObserver;
import org.apache.phoenix.coprocessor.ServerCachingEndpointImpl;
import org.apache.phoenix.coprocessor.UngroupedAggregateRegionObserver;
+import org.apache.phoenix.exception.SQLExceptionCode;
import org.apache.phoenix.jdbc.PhoenixConnection;
import org.apache.phoenix.jdbc.PhoenixDatabaseMetaData;
import org.apache.phoenix.schema.ColumnNotFoundException;
@@ -749,10 +751,57 @@ public class QueryDatabaseMetaDataTest extends BaseClientManagedTimeTest {
Connection conn9 = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
conn9.createStatement().execute("CREATE INDEX idx ON " + MDTEST_NAME + "(B.COL1)");
+ props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 30));
+ Connection conn91 = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
+ ps = conn91.prepareStatement(dropView);
+ ps.execute();
+ conn91.close();
+
+ props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 35));
+ Connection conn92 = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
+ createStmt = "create view " + MDTEST_NAME +
+ " (id char(1) not null primary key,\n" +
+ " b.col1 integer,\n" +
+ " \"c\".col2 bigint) as\n" +
+ " select * from " + MDTEST_NAME +
+ " where b.col1 = 1";
+ conn92.createStatement().execute(createStmt);
+ conn92.close();
+
+ put = new Put(Bytes.toBytes("1"));
+ put.add(cfB, Bytes.toBytes("COL1"), ts+39, PDataType.INTEGER.toBytes(3));
+ put.add(cfC, Bytes.toBytes("COL2"), ts+39, PDataType.LONG.toBytes(4));
+ htable.put(put);
+
+ props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 40));
+ Connection conn92a = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
+ rs = conn92a.createStatement().executeQuery("select count(*) from " + MDTEST_NAME);
+ assertTrue(rs.next());
+ assertEquals(1,rs.getInt(1));
+ conn92a.close();
+
+ props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 45));
+ Connection conn93 = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
+ try {
+ String alterView = "alter view " + MDTEST_NAME + " drop column b.col1";
+ conn93.createStatement().execute(alterView);
+ fail();
+ } catch (SQLException e) {
+ assertEquals(SQLExceptionCode.CANNOT_MUTATE_TABLE.getErrorCode(), e.getErrorCode());
+ }
+ conn93.close();
+
+ props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 50));
+ Connection conn94 = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
+ String alterView = "alter view " + MDTEST_NAME + " drop column \"c\".col2";
+ conn94.createStatement().execute(alterView);
+ conn94.close();
+
} finally {
HTableInterface htable = pconn.getQueryServices().getTable(SchemaUtil.getTableNameAsBytes(MDTEST_SCHEMA_NAME,MDTEST_NAME));
- Delete delete = new Delete(Bytes.toBytes("0"));
- htable.delete(delete);
+ Delete delete1 = new Delete(Bytes.toBytes("0"));
+ Delete delete2 = new Delete(Bytes.toBytes("1"));
+ htable.batch(Arrays.asList(delete1, delete2));
}
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/test/java/org/apache/phoenix/end2end/TenantSpecificViewIndexTest.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/end2end/TenantSpecificViewIndexTest.java b/phoenix-core/src/test/java/org/apache/phoenix/end2end/TenantSpecificViewIndexTest.java
new file mode 100644
index 0000000..30411e2
--- /dev/null
+++ b/phoenix-core/src/test/java/org/apache/phoenix/end2end/TenantSpecificViewIndexTest.java
@@ -0,0 +1,80 @@
+/*
+ * 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.
+ */
+package org.apache.phoenix.end2end;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.util.Properties;
+
+import org.apache.phoenix.util.PhoenixRuntime;
+import org.apache.phoenix.util.QueryUtil;
+import org.junit.Test;
+
+public class TenantSpecificViewIndexTest extends BaseHBaseManagedTimeTest {
+ @Test
+ public void testUpdatableView() throws Exception {
+ Connection conn = DriverManager.getConnection(getUrl());
+ String ddl = "CREATE TABLE t (t_id VARCHAR NOT NULL, k1 INTEGER NOT NULL, k2 INTEGER NOT NULL, v1 VARCHAR, CONSTRAINT pk PRIMARY KEY (t_id, k1, k2)) multi_tenant=true";
+ conn.createStatement().execute(ddl);
+ conn.close();
+
+ Properties props = new Properties();
+ props.setProperty(PhoenixRuntime.TENANT_ID_ATTRIB, "me");
+ conn = DriverManager.getConnection(getUrl(), props);
+ ddl = "CREATE VIEW v(v2 VARCHAR) AS SELECT * FROM t WHERE k1 = 1";
+ conn.createStatement().execute(ddl);
+ for (int i = 0; i < 10; i++) {
+ conn.createStatement().execute("UPSERT INTO v(k2,v1,v2) VALUES(" + i + ",'v1-" + (i%5) + "','v2-" + (i%2) + "')");
+ }
+ conn.commit();
+
+ conn.createStatement().execute("CREATE INDEX i ON v(v2)");
+
+ String query = "SELECT k1, k2, v2 FROM v WHERE v2='v2-1'";
+ ResultSet rs = conn.createStatement().executeQuery(query);
+ assertTrue(rs.next());
+ assertEquals(1, rs.getInt(1));
+ assertEquals(1, rs.getInt(2));
+ assertEquals("v2-1", rs.getString(3));
+ assertTrue(rs.next());
+ assertEquals(1, rs.getInt(1));
+ assertEquals(3, rs.getInt(2));
+ assertEquals("v2-1", rs.getString(3));
+ assertTrue(rs.next());
+ assertEquals(1, rs.getInt(1));
+ assertEquals(5, rs.getInt(2));
+ assertEquals("v2-1", rs.getString(3));
+ assertTrue(rs.next());
+ assertEquals(1, rs.getInt(1));
+ assertEquals(7, rs.getInt(2));
+ assertEquals("v2-1", rs.getString(3));
+ assertTrue(rs.next());
+ assertEquals(1, rs.getInt(1));
+ assertEquals(9, rs.getInt(2));
+ assertEquals("v2-1", rs.getString(3));
+ assertFalse(rs.next());
+ rs = conn.createStatement().executeQuery("EXPLAIN " + query);
+ assertEquals("CLIENT PARALLEL 1-WAY RANGE SCAN OVER I ['me',-32768,'v2-1']", QueryUtil.getExplainPlan(rs));
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/test/java/org/apache/phoenix/end2end/ViewTest.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/end2end/ViewTest.java b/phoenix-core/src/test/java/org/apache/phoenix/end2end/ViewTest.java
index aae87a8..da21389 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/end2end/ViewTest.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/end2end/ViewTest.java
@@ -25,10 +25,11 @@ import static org.junit.Assert.fail;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
+import java.sql.SQLException;
-import org.junit.Test;
-
+import org.apache.phoenix.exception.SQLExceptionCode;
import org.apache.phoenix.schema.ReadOnlyTableException;
+import org.junit.Test;
public class ViewTest extends BaseHBaseManagedTimeTest {
@@ -174,4 +175,38 @@ public class ViewTest extends BaseHBaseManagedTimeTest {
assertEquals(5, rs.getInt(3));
assertFalse(rs.next());
}
+
+ @Test
+ public void testDisallowDropOfReferencedColumn() throws Exception {
+ Connection conn = DriverManager.getConnection(getUrl());
+ String ddl = "CREATE TABLE t (k1 INTEGER NOT NULL, k2 INTEGER NOT NULL, v1 DECIMAL, CONSTRAINT pk PRIMARY KEY (k1, k2))";
+ conn.createStatement().execute(ddl);
+ ddl = "CREATE VIEW v1(v2 VARCHAR, v3 VARCHAR) AS SELECT * FROM t WHERE v1 = 1.0";
+ conn.createStatement().execute(ddl);
+
+ try {
+ conn.createStatement().execute("ALTER VIEW v1 DROP COLUMN v1");
+ fail();
+ } catch (SQLException e) {
+ assertEquals(SQLExceptionCode.CANNOT_MUTATE_TABLE.getErrorCode(), e.getErrorCode());
+ }
+
+ ddl = "CREATE VIEW v2 AS SELECT * FROM v1 WHERE v2 != 'foo'";
+ conn.createStatement().execute(ddl);
+
+ try {
+ conn.createStatement().execute("ALTER VIEW v2 DROP COLUMN v1");
+ fail();
+ } catch (SQLException e) {
+ assertEquals(SQLExceptionCode.CANNOT_MUTATE_TABLE.getErrorCode(), e.getErrorCode());
+ }
+ try {
+ conn.createStatement().execute("ALTER VIEW v2 DROP COLUMN v2");
+ fail();
+ } catch (SQLException e) {
+ assertEquals(SQLExceptionCode.CANNOT_MUTATE_TABLE.getErrorCode(), e.getErrorCode());
+ }
+ conn.createStatement().execute("ALTER VIEW v2 DROP COLUMN v3");
+
+ }
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/test/java/org/apache/phoenix/expression/ColumnExpressionTest.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/expression/ColumnExpressionTest.java b/phoenix-core/src/test/java/org/apache/phoenix/expression/ColumnExpressionTest.java
index 6d54965..8e20a28 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/expression/ColumnExpressionTest.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/expression/ColumnExpressionTest.java
@@ -39,7 +39,7 @@ public class ColumnExpressionTest {
int maxLen = 30;
int scale = 5;
PColumn column = new PColumnImpl(PNameFactory.newName("c1"), PNameFactory.newName("f1"), PDataType.DECIMAL, maxLen, scale,
- true, 20, SortOrder.getDefault(), 0);
+ true, 20, SortOrder.getDefault(), 0, null);
ColumnExpression colExp = new KeyValueColumnExpression(column);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dOut = new DataOutputStream(baos);
@@ -59,7 +59,7 @@ public class ColumnExpressionTest {
public void testSerializationWithNullScale() throws Exception {
int maxLen = 30;
PColumn column = new PColumnImpl(PNameFactory.newName("c1"), PNameFactory.newName("f1"), PDataType.BINARY, maxLen, null,
- true, 20, SortOrder.getDefault(), 0);
+ true, 20, SortOrder.getDefault(), 0, null);
ColumnExpression colExp = new KeyValueColumnExpression(column);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dOut = new DataOutputStream(baos);
@@ -79,7 +79,7 @@ public class ColumnExpressionTest {
public void testSerializationWithNullMaxLength() throws Exception {
int scale = 5;
PColumn column = new PColumnImpl(PNameFactory.newName("c1"), PNameFactory.newName("f1"), PDataType.VARCHAR, null, scale,
- true, 20, SortOrder.getDefault(), 0);
+ true, 20, SortOrder.getDefault(), 0, null);
ColumnExpression colExp = new KeyValueColumnExpression(column);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dOut = new DataOutputStream(baos);
@@ -98,7 +98,7 @@ public class ColumnExpressionTest {
@Test
public void testSerializationWithNullScaleAndMaxLength() throws Exception {
PColumn column = new PColumnImpl(PNameFactory.newName("c1"), PNameFactory.newName("f1"), PDataType.DECIMAL, null, null, true,
- 20, SortOrder.getDefault(), 0);
+ 20, SortOrder.getDefault(), 0, null);
ColumnExpression colExp = new KeyValueColumnExpression(column);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dOut = new DataOutputStream(baos);
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/test/java/org/apache/phoenix/iterate/AggregateResultScannerTest.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/test/java/org/apache/phoenix/iterate/AggregateResultScannerTest.java b/phoenix-core/src/test/java/org/apache/phoenix/iterate/AggregateResultScannerTest.java
index 8be97de..a9bb235 100644
--- a/phoenix-core/src/test/java/org/apache/phoenix/iterate/AggregateResultScannerTest.java
+++ b/phoenix-core/src/test/java/org/apache/phoenix/iterate/AggregateResultScannerTest.java
@@ -46,10 +46,10 @@ import org.apache.phoenix.expression.function.SumAggregateFunction;
import org.apache.phoenix.jdbc.PhoenixConnection;
import org.apache.phoenix.jdbc.PhoenixStatement;
import org.apache.phoenix.query.BaseConnectionlessQueryTest;
-import org.apache.phoenix.schema.SortOrder;
import org.apache.phoenix.schema.PDataType;
import org.apache.phoenix.schema.PLongColumn;
import org.apache.phoenix.schema.PName;
+import org.apache.phoenix.schema.SortOrder;
import org.apache.phoenix.schema.tuple.SingleKeyValueTuple;
import org.apache.phoenix.schema.tuple.Tuple;
import org.apache.phoenix.util.AssertResults;
@@ -120,6 +120,11 @@ public class AggregateResultScannerTest extends BaseConnectionlessQueryTest {
public Integer getArraySize() {
return 0;
}
+
+ @Override
+ public byte[] getViewConstant() {
+ return null;
+ }
})), null);
aggregationManager.setAggregators(new ClientAggregators(Collections.<SingleAggregateFunction>singletonList(func), 1));
ResultIterators iterators = new ResultIterators() {
[4/4] git commit: PHOENIX-21: Support indexes on multi-tenant views.
Still needs more testing
Posted by ja...@apache.org.
PHOENIX-21: Support indexes on multi-tenant views. Still needs more testing
Project: http://git-wip-us.apache.org/repos/asf/incubator-phoenix/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-phoenix/commit/e2bd0ee0
Tree: http://git-wip-us.apache.org/repos/asf/incubator-phoenix/tree/e2bd0ee0
Diff: http://git-wip-us.apache.org/repos/asf/incubator-phoenix/diff/e2bd0ee0
Branch: refs/heads/master
Commit: e2bd0ee06b2d2982155ddcb34549fff1249f67fc
Parents: 9a46c0e
Author: James Taylor <ja...@apache.org>
Authored: Tue Feb 18 02:04:43 2014 -0800
Committer: James Taylor <ja...@apache.org>
Committed: Tue Feb 18 02:04:43 2014 -0800
----------------------------------------------------------------------
.../phoenix/compile/CreateTableCompiler.java | 68 +++-
.../apache/phoenix/compile/DeleteCompiler.java | 12 +-
.../phoenix/compile/ExpressionCompiler.java | 7 +-
.../apache/phoenix/compile/FromCompiler.java | 4 +-
.../phoenix/compile/IndexStatementRewriter.java | 25 +-
.../apache/phoenix/compile/JoinCompiler.java | 18 +-
.../apache/phoenix/compile/PostDDLCompiler.java | 54 ++-
.../phoenix/compile/PostIndexDDLCompiler.java | 11 +-
.../phoenix/compile/ProjectionCompiler.java | 7 +-
.../apache/phoenix/compile/QueryCompiler.java | 9 -
.../org/apache/phoenix/compile/QueryPlan.java | 2 +
.../apache/phoenix/compile/UpsertCompiler.java | 19 +-
.../apache/phoenix/compile/WhereOptimizer.java | 21 +-
.../coprocessor/MetaDataEndpointImpl.java | 58 ++-
.../phoenix/exception/SQLExceptionCode.java | 3 +-
.../apache/phoenix/execute/BasicQueryPlan.java | 6 +
.../apache/phoenix/execute/HashJoinPlan.java | 15 +-
.../phoenix/expression/LiteralExpression.java | 4 +-
.../apache/phoenix/index/IndexMaintainer.java | 94 +++--
.../phoenix/jdbc/PhoenixDatabaseMetaData.java | 9 +
.../apache/phoenix/jdbc/PhoenixStatement.java | 5 +
.../apache/phoenix/optimize/QueryOptimizer.java | 63 ++-
.../phoenix/parse/CreateSequenceStatement.java | 4 +
.../apache/phoenix/parse/LiteralParseNode.java | 7 +
.../phoenix/query/ConnectionQueryServices.java | 3 +-
.../query/ConnectionQueryServicesImpl.java | 203 ++++++++--
.../query/ConnectionlessQueryServicesImpl.java | 2 +-
.../query/DelegateConnectionQueryServices.java | 4 +-
.../apache/phoenix/query/QueryConstants.java | 32 +-
.../org/apache/phoenix/query/QueryServices.java | 2 +-
.../phoenix/query/QueryServicesOptions.java | 4 +-
.../apache/phoenix/schema/DelegateColumn.java | 5 +
.../apache/phoenix/schema/MetaDataClient.java | 400 ++++++++++++++-----
.../java/org/apache/phoenix/schema/PColumn.java | 2 +
.../org/apache/phoenix/schema/PColumnImpl.java | 30 +-
.../org/apache/phoenix/schema/PDataType.java | 9 +
.../apache/phoenix/schema/PMetaDataImpl.java | 2 +-
.../java/org/apache/phoenix/schema/PTable.java | 4 +-
.../org/apache/phoenix/schema/PTableImpl.java | 109 +++--
.../org/apache/phoenix/schema/SaltingUtil.java | 2 +-
.../schema/TableAlreadyExistsException.java | 6 +-
.../org/apache/phoenix/util/MetaDataUtil.java | 74 +++-
.../end2end/QueryDatabaseMetaDataTest.java | 53 ++-
.../end2end/TenantSpecificViewIndexTest.java | 80 ++++
.../org/apache/phoenix/end2end/ViewTest.java | 39 +-
.../expression/ColumnExpressionTest.java | 8 +-
.../iterate/AggregateResultScannerTest.java | 7 +-
47 files changed, 1262 insertions(+), 343 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/CreateTableCompiler.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/CreateTableCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/CreateTableCompiler.java
index 86f0d42..5e06249 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/CreateTableCompiler.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/CreateTableCompiler.java
@@ -39,6 +39,7 @@ import org.apache.phoenix.expression.RowKeyColumnExpression;
import org.apache.phoenix.expression.visitor.TraverseNoExpressionVisitor;
import org.apache.phoenix.jdbc.PhoenixConnection;
import org.apache.phoenix.jdbc.PhoenixStatement;
+import org.apache.phoenix.parse.ColumnParseNode;
import org.apache.phoenix.parse.CreateTableStatement;
import org.apache.phoenix.parse.ParseNode;
import org.apache.phoenix.parse.SQLParser;
@@ -46,6 +47,8 @@ import org.apache.phoenix.parse.SelectStatement;
import org.apache.phoenix.parse.TableName;
import org.apache.phoenix.parse.WildcardParseNode;
import org.apache.phoenix.query.DelegateConnectionQueryServices;
+import org.apache.phoenix.query.QueryConstants;
+import org.apache.phoenix.schema.ColumnRef;
import org.apache.phoenix.schema.MetaDataClient;
import org.apache.phoenix.schema.PMetaData;
import org.apache.phoenix.schema.PTable;
@@ -77,12 +80,15 @@ public class CreateTableCompiler {
ViewType viewTypeToBe = null;
Scan scan = new Scan();
final StatementContext context = new StatementContext(statement, resolver, statement.getParameters(), scan);
- ExpressionCompiler expressionCompiler = new ExpressionCompiler(context);
// TODO: support any statement for a VIEW instead of just a WHERE clause
ParseNode whereNode = create.getWhereClause();
String viewStatementToBe = null;
+ byte[][] viewColumnConstantsToBe = MetaDataClient.EMPTY_VIEW_CONSTANTS;
if (type == PTableType.VIEW) {
TableRef tableRef = resolver.getTables().get(0);
+ viewColumnConstantsToBe = new byte[tableRef.getTable().getColumns().size()][];
+ // Used to track column references and their
+ ExpressionCompiler expressionCompiler = new ColumnTrackingExpressionCompiler(context, viewColumnConstantsToBe);
parentToBe = tableRef.getTable();
viewTypeToBe = parentToBe.getViewType() == ViewType.MAPPED ? ViewType.MAPPED : ViewType.UPDATABLE;
if (whereNode == null) {
@@ -127,7 +133,7 @@ public class CreateTableCompiler {
}
},
connection, tableRef.getTimeStamp());
- ViewWhereExpressionVisitor visitor = new ViewWhereExpressionVisitor();
+ ViewWhereExpressionVisitor visitor = new ViewWhereExpressionVisitor(parentToBe, viewColumnConstantsToBe);
where.accept(visitor);
viewTypeToBe = visitor.isUpdatable() ? ViewType.UPDATABLE : ViewType.READ_ONLY;
}
@@ -135,9 +141,11 @@ public class CreateTableCompiler {
}
final ViewType viewType = viewTypeToBe;
final String viewStatement = viewStatementToBe;
+ final byte[][] viewColumnConstants = viewColumnConstantsToBe;
List<ParseNode> splitNodes = create.getSplitNodes();
final byte[][] splits = new byte[splitNodes.size()][];
ImmutableBytesWritable ptr = context.getTempPtr();
+ ExpressionCompiler expressionCompiler = new ExpressionCompiler(context);
for (int i = 0; i < splits.length; i++) {
ParseNode node = splitNodes.get(i);
if (node.isStateless()) {
@@ -163,7 +171,7 @@ public class CreateTableCompiler {
@Override
public MutationState execute() throws SQLException {
try {
- return client.createTable(create, splits, parent, viewStatement, viewType);
+ return client.createTable(create, splits, parent, viewStatement, viewType, viewColumnConstants);
} finally {
if (client.getConnection() != connection) {
client.getConnection().close();
@@ -184,9 +192,38 @@ public class CreateTableCompiler {
};
}
+ private static class ColumnTrackingExpressionCompiler extends ExpressionCompiler {
+ private final byte[][] columnValues;
+
+ public ColumnTrackingExpressionCompiler(StatementContext context, byte[][] columnValues) {
+ super(context);
+ this.columnValues = columnValues;
+ }
+
+ @Override
+ protected ColumnRef resolveColumn(ColumnParseNode node) throws SQLException {
+ ColumnRef ref = super.resolveColumn(node);
+ // Set columnValue at position to any non null value.
+ // We always strip the last byte so that we can recognize null
+ // as a value with a single byte.
+ // Will be overridden during ViewWhereExpressionVisitor
+ columnValues[ref.getColumn().getPosition()] = QueryConstants.SEPARATOR_BYTE_ARRAY;
+ return ref;
+ }
+ }
+
private static class ViewWhereExpressionVisitor extends TraverseNoExpressionVisitor<Boolean> {
private boolean isUpdatable = true;
+ private final PTable table;
+ private int position;
+ private final byte[][] columnValues;
+ private final ImmutableBytesWritable ptr = new ImmutableBytesWritable();
+ public ViewWhereExpressionVisitor (PTable table, byte[][] columnValues) {
+ this.table = table;
+ this.columnValues = columnValues;
+ }
+
public boolean isUpdatable() {
return isUpdatable;
}
@@ -211,12 +248,26 @@ public class CreateTableCompiler {
@Override
public Iterator<Expression> visitEnter(ComparisonExpression node) {
- return node.getFilterOp() == CompareOp.EQUAL && node.getChildren().get(1).isStateless() && node.getChildren().get(1).isDeterministic() ? Iterators.singletonIterator(node.getChildren().get(0)) : super.visitEnter(node);
+ if (node.getFilterOp() == CompareOp.EQUAL && node.getChildren().get(1).isStateless() && node.getChildren().get(1).isDeterministic()) {
+ return Iterators.singletonIterator(node.getChildren().get(0));
+ }
+ return super.visitEnter(node);
}
@Override
public Boolean visitLeave(ComparisonExpression node, List<Boolean> l) {
- return l.isEmpty() ? null : Boolean.TRUE;
+ if (l.isEmpty()) {
+ return null;
+ }
+
+ node.getChildren().get(1).evaluate(null, ptr);
+ // Set the columnValue at the position of the column to the
+ // constant with which it is being compared.
+ // We always strip the last byte so that we can recognize null
+ // as a value with a single byte.
+ columnValues[position] = new byte [ptr.getLength() + 1];
+ System.arraycopy(ptr.get(), ptr.getOffset(), columnValues[position], 0, ptr.getLength());
+ return Boolean.TRUE;
}
@Override
@@ -226,16 +277,23 @@ public class CreateTableCompiler {
@Override
public Boolean visitLeave(IsNullExpression node, List<Boolean> l) {
+ // Nothing to do as we've already set the position to an empty byte array
return l.isEmpty() ? null : Boolean.TRUE;
}
@Override
public Boolean visit(RowKeyColumnExpression node) {
+ this.position = table.getPKColumns().get(node.getPosition()).getPosition();
return Boolean.TRUE;
}
@Override
public Boolean visit(KeyValueColumnExpression node) {
+ try {
+ this.position = table.getColumnFamily(node.getColumnFamily()).getColumn(node.getColumnName()).getPosition();
+ } catch (SQLException e) {
+ throw new RuntimeException(e); // Impossible
+ }
return Boolean.TRUE;
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/DeleteCompiler.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/DeleteCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/DeleteCompiler.java
index c5ddcdf..a6d9dbe 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/DeleteCompiler.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/DeleteCompiler.java
@@ -68,6 +68,7 @@ import org.apache.phoenix.schema.SortOrder;
import org.apache.phoenix.schema.TableRef;
import org.apache.phoenix.schema.tuple.Tuple;
import org.apache.phoenix.util.IndexUtil;
+import org.apache.phoenix.util.MetaDataUtil;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
@@ -93,10 +94,14 @@ public class DeleteCompiler {
PTable table = tableRef.getTable();
List<PColumn> pkColumns = table.getPKColumns();
boolean isMultiTenant = table.isMultiTenant() && tenantId != null;
- int offset = (table.getBucketNum() == null ? 0 : 1) + (isMultiTenant ? 1 : 0); // Take into account salting and multi-tenant
+ boolean isSharedViewIndex = table.getViewIndexId() != null;
+ int offset = (table.getBucketNum() == null ? 0 : 1);
byte[][] values = new byte[pkColumns.size()][];
if (isMultiTenant) {
- values[offset-1] = tenantId;
+ values[offset++] = tenantId;
+ }
+ if (isSharedViewIndex) {
+ values[offset++] = MetaDataUtil.getViewIndexIdDataType().toBytes(table.getViewIndexId());
}
ResultSet rs = new PhoenixResultSet(iterator, projector, statement);
int rowCount = 0;
@@ -193,7 +198,8 @@ public class DeleteCompiler {
List<AliasedNode> aliasedNodes = Lists.newArrayListWithExpectedSize(table.getPKColumns().size());
boolean isSalted = table.getBucketNum() != null;
boolean isMultiTenant = connection.getTenantId() != null && table.isMultiTenant();
- for (int i = (isSalted ? 1 : 0) + (isMultiTenant ? 1 : 0); i < table.getPKColumns().size(); i++) {
+ boolean isSharedViewIndex = table.getViewIndexId() != null;
+ for (int i = (isSalted ? 1 : 0) + (isMultiTenant ? 1 : 0) + (isSharedViewIndex ? 1 : 0); i < table.getPKColumns().size(); i++) {
PColumn column = table.getPKColumns().get(i);
aliasedNodes.add(FACTORY.aliasedNode(null, FACTORY.column(null, '"' + column.getName().getString() + '"', null)));
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/ExpressionCompiler.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/ExpressionCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/ExpressionCompiler.java
index fc4772c..9d1f4f1 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/ExpressionCompiler.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/ExpressionCompiler.java
@@ -87,7 +87,6 @@ import org.apache.phoenix.parse.SequenceValueParseNode;
import org.apache.phoenix.parse.StringConcatParseNode;
import org.apache.phoenix.parse.SubtractParseNode;
import org.apache.phoenix.parse.UnsupportedAllParseNodeVisitor;
-import org.apache.phoenix.schema.SortOrder;
import org.apache.phoenix.schema.ColumnNotFoundException;
import org.apache.phoenix.schema.ColumnRef;
import org.apache.phoenix.schema.DelegateDatum;
@@ -97,6 +96,7 @@ import org.apache.phoenix.schema.PDatum;
import org.apache.phoenix.schema.PTable;
import org.apache.phoenix.schema.PTableType;
import org.apache.phoenix.schema.RowKeyValueAccessor;
+import org.apache.phoenix.schema.SortOrder;
import org.apache.phoenix.schema.TableRef;
import org.apache.phoenix.schema.TypeMismatchException;
import org.apache.phoenix.util.SchemaUtil;
@@ -312,11 +312,12 @@ public class ExpressionCompiler extends UnsupportedAllParseNodeVisitor<Expressio
ColumnRef ref = context.getResolver().resolveColumn(node.getSchemaName(), node.getTableName(), node.getName());
PTable table = ref.getTable();
int pkPosition = ref.getPKSlotPosition();
- // Disallow explicit reference to SALT or TENANT_ID columns
+ // Disallow explicit reference to salting column, tenant ID column, and index ID column
if (pkPosition >= 0) {
boolean isSalted = table.getBucketNum() != null;
boolean isMultiTenant = context.getConnection().getTenantId() != null && table.isMultiTenant();
- int minPosition = (isSalted ? 1 : 0) + (isMultiTenant ? 1 : 0);
+ boolean isSharedViewIndex = table.getViewIndexId() != null;
+ int minPosition = (isSalted ? 1 : 0) + (isMultiTenant ? 1 : 0) + (isSharedViewIndex ? 1 : 0);
if (pkPosition < minPosition) {
throw new ColumnNotFoundException(table.getSchemaName().getString(), table.getTableName().getString(), null, ref.getColumn().getName().getString());
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/FromCompiler.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/FromCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/FromCompiler.java
index 57a8914..6f63ad4 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/FromCompiler.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/FromCompiler.java
@@ -184,7 +184,7 @@ public class FromCompiler {
}
}
Long scn = connection.getSCN();
- PTable theTable = new PTableImpl(table.getName().getSchemaName(), table.getName().getTableName(), scn == null ? HConstants.LATEST_TIMESTAMP : scn, families);
+ PTable theTable = new PTableImpl(connection.getTenantId(), table.getName().getSchemaName(), table.getName().getTableName(), scn == null ? HConstants.LATEST_TIMESTAMP : scn, families);
theTable = this.addDynamicColumns(table.getDynamicColumns(), theTable);
alias = null;
tableRefs = ImmutableList.of(new TableRef(alias, theTable, timeStamp, !table.getDynamicColumns().isEmpty()));
@@ -319,7 +319,7 @@ public class FromCompiler {
familyName = PNameFactory.newName(family);
}
allcolumns.add(new PColumnImpl(name, familyName, dynColumn.getDataType(), dynColumn.getMaxLength(),
- dynColumn.getScale(), dynColumn.isNull(), position, dynColumn.getSortOrder(), dynColumn.getArraySize()));
+ dynColumn.getScale(), dynColumn.isNull(), position, dynColumn.getSortOrder(), dynColumn.getArraySize(), null));
position++;
}
theTable = PTableImpl.makePTable(theTable, allcolumns);
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/IndexStatementRewriter.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/IndexStatementRewriter.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/IndexStatementRewriter.java
index ddcaba8..8d4b7db 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/IndexStatementRewriter.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/IndexStatementRewriter.java
@@ -21,8 +21,10 @@ package org.apache.phoenix.compile;
import java.sql.SQLException;
import java.util.Map;
+import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.phoenix.parse.ColumnParseNode;
import org.apache.phoenix.parse.FamilyWildcardParseNode;
+import org.apache.phoenix.parse.LiteralParseNode;
import org.apache.phoenix.parse.ParseNode;
import org.apache.phoenix.parse.ParseNodeFactory;
import org.apache.phoenix.parse.ParseNodeRewriter;
@@ -31,7 +33,10 @@ import org.apache.phoenix.parse.TableName;
import org.apache.phoenix.parse.TableWildcardParseNode;
import org.apache.phoenix.parse.WildcardParseNode;
import org.apache.phoenix.schema.ColumnRef;
+import org.apache.phoenix.schema.PColumn;
import org.apache.phoenix.schema.PDataType;
+import org.apache.phoenix.schema.PTable;
+import org.apache.phoenix.schema.PTable.ViewType;
import org.apache.phoenix.schema.TableRef;
import org.apache.phoenix.util.IndexUtil;
@@ -39,6 +44,7 @@ public class IndexStatementRewriter extends ParseNodeRewriter {
private static final ParseNodeFactory FACTORY = new ParseNodeFactory();
private Map<TableRef, TableRef> multiTableRewriteMap;
+ private final ImmutableBytesWritable ptr = new ImmutableBytesWritable();
public IndexStatementRewriter(ColumnResolver dataResolver, Map<TableRef, TableRef> multiTableRewriteMap) {
super(dataResolver);
@@ -73,14 +79,27 @@ public class IndexStatementRewriter extends ParseNodeRewriter {
@Override
public ParseNode visit(ColumnParseNode node) throws SQLException {
ColumnRef dataColRef = getResolver().resolveColumn(node.getSchemaName(), node.getTableName(), node.getName());
- TableName tName = getReplacedTableName(dataColRef.getTableRef());
+ PColumn dataCol = dataColRef.getColumn();
+ TableRef dataTableRef = dataColRef.getTableRef();
+ PTable dataTable = dataTableRef.getTable();
+ // Rewrite view constants in updatable views as literals, as they won't be in the schema for
+ // an index on the view.
+ if (dataTable.getViewType() == ViewType.UPDATABLE && dataCol.getViewConstant() != null) {
+ byte[] viewConstant = dataCol.getViewConstant();
+ // Ignore last byte, as it's only there so we can have a way to differentiate null
+ // from the absence of a value.
+ ptr.set(viewConstant, 0, viewConstant.length-1);
+ Object literal = dataCol.getDataType().toObject(ptr);
+ return new LiteralParseNode(literal, dataCol.getDataType());
+ }
+ TableName tName = getReplacedTableName(dataTableRef);
if (multiTableRewriteMap != null && tName == null)
return node;
- String indexColName = IndexUtil.getIndexColumnName(dataColRef.getColumn());
+ String indexColName = IndexUtil.getIndexColumnName(dataCol);
// Same alias as before, but use the index column name instead of the data column name
ParseNode indexColNode = new ColumnParseNode(tName, node.isCaseSensitive() ? '"' + indexColName + '"' : indexColName, node.getAlias());
- PDataType indexColType = IndexUtil.getIndexColumnDataType(dataColRef.getColumn());
+ PDataType indexColType = IndexUtil.getIndexColumnDataType(dataCol);
PDataType dataColType = dataColRef.getColumn().getDataType();
// Coerce index column reference back to same type as data column so that
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/JoinCompiler.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/JoinCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/JoinCompiler.java
index 9b7865b..5439574 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/JoinCompiler.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/JoinCompiler.java
@@ -324,10 +324,10 @@ public class JoinCompiler {
}
}
- PTable t = PTableImpl.makePTable(PNameFactory.newName(PROJECTED_TABLE_SCHEMA), table.getName(), PTableType.JOIN, table.getIndexState(),
- table.getTimeStamp(), table.getSequenceNumber(), table.getPKName(), retainPKColumns ? table.getBucketNum() : null,
- projectedColumns, table.getParentTableName(), table.getIndexes(),
- table.isImmutableRows(), Collections.<PName>emptyList(), null, null, table.isWALDisabled(), table.isMultiTenant(), table.getViewType());
+ PTable t = PTableImpl.makePTable(table.getTenantId(), PNameFactory.newName(PROJECTED_TABLE_SCHEMA), table.getName(), PTableType.JOIN,
+ table.getIndexState(), table.getTimeStamp(), table.getSequenceNumber(), table.getPKName(),
+ retainPKColumns ? table.getBucketNum() : null, projectedColumns, table.getParentTableName(),
+ table.getIndexes(), table.isImmutableRows(), Collections.<PName>emptyList(), null, null, table.isWALDisabled(), table.isMultiTenant(), table.getViewType(), table.getViewIndexId());
return new ProjectedPTableWrapper(t, columnNameMap, sourceExpressions);
}
@@ -353,7 +353,7 @@ public class JoinCompiler {
PName name = PNameFactory.newName(aliasedName);
PColumnImpl column = new PColumnImpl(name, familyName, sourceColumn.getDataType(),
sourceColumn.getMaxLength(), sourceColumn.getScale(), sourceColumn.isNullable(),
- position, sourceColumn.getSortOrder(), sourceColumn.getArraySize());
+ position, sourceColumn.getSortOrder(), sourceColumn.getArraySize(), sourceColumn.getViewConstant());
Expression sourceExpression = new ColumnRef(sourceTable, sourceColumn.getPosition()).newColumnExpression();
projectedColumns.add(column);
sourceExpressions.add(sourceExpression);
@@ -1133,16 +1133,16 @@ public class JoinCompiler {
PColumnImpl column = new PColumnImpl(c.getName(),
PNameFactory.newName(ScanProjector.VALUE_COLUMN_FAMILY), c.getDataType(),
c.getMaxLength(), c.getScale(), innerJoin ? c.isNullable() : true, position++,
- c.getSortOrder(), c.getArraySize());
+ c.getSortOrder(), c.getArraySize(), c.getViewConstant());
merged.add(column);
}
}
if (left.getBucketNum() != null) {
merged.remove(0);
}
- PTable t = PTableImpl.makePTable(left.getSchemaName(), PNameFactory.newName(SchemaUtil.getTableName(left.getName().getString(), right.getName().getString())),
- left.getType(), left.getIndexState(), left.getTimeStamp(), left.getSequenceNumber(), left.getPKName(), left.getBucketNum(), merged, left.getParentTableName(),
- left.getIndexes(), left.isImmutableRows(), Collections.<PName>emptyList(), null, null, PTable.DEFAULT_DISABLE_WAL, left.isMultiTenant(), left.getViewType());
+ PTable t = PTableImpl.makePTable(left.getTenantId(), left.getSchemaName(),
+ PNameFactory.newName(SchemaUtil.getTableName(left.getName().getString(), right.getName().getString())), left.getType(), left.getIndexState(), left.getTimeStamp(), left.getSequenceNumber(), left.getPKName(), left.getBucketNum(), merged,
+ left.getParentTableName(), left.getIndexes(), left.isImmutableRows(), Collections.<PName>emptyList(), null, null, PTable.DEFAULT_DISABLE_WAL, left.isMultiTenant(), left.getViewType(), left.getViewIndexId());
ListMultimap<String, String> mergedMap = ArrayListMultimap.<String, String>create();
mergedMap.putAll(lWrapper.getColumnNameMap());
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/PostDDLCompiler.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/PostDDLCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/PostDDLCompiler.java
index 7e89144..6e0ec7e 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/PostDDLCompiler.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/PostDDLCompiler.java
@@ -36,10 +36,14 @@ import org.apache.phoenix.jdbc.PhoenixParameterMetaData;
import org.apache.phoenix.jdbc.PhoenixStatement;
import org.apache.phoenix.parse.SelectStatement;
import org.apache.phoenix.query.QueryConstants;
+import org.apache.phoenix.schema.AmbiguousColumnException;
+import org.apache.phoenix.schema.ColumnFamilyNotFoundException;
+import org.apache.phoenix.schema.ColumnNotFoundException;
import org.apache.phoenix.schema.ColumnRef;
import org.apache.phoenix.schema.PColumn;
import org.apache.phoenix.schema.PColumnFamily;
import org.apache.phoenix.schema.PDataType;
+import org.apache.phoenix.schema.TableNotFoundException;
import org.apache.phoenix.schema.TableRef;
import org.apache.phoenix.schema.tuple.Tuple;
import org.apache.phoenix.util.ScanUtil;
@@ -139,7 +143,7 @@ public class PostDDLCompiler {
if (deleteList.isEmpty()) {
scan.setAttribute(UngroupedAggregateRegionObserver.DELETE_AGG, QueryConstants.TRUE);
// In the case of a row deletion, add index metadata so mutable secondary indexing works
- /* TODO
+ /* TODO: we currently manually run a scan to delete the index data here
ImmutableBytesWritable ptr = context.getTempPtr();
tableRef.getTable().getIndexMaintainers(ptr);
if (ptr.getLength() > 0) {
@@ -181,29 +185,45 @@ public class PostDDLCompiler {
}
projector = new RowProjector(projector,false);
}
- WhereCompiler.compile(context, select); // Push where clause into scan
+ // Ignore exceptions due to not being able to resolve any view columns,
+ // as this just means the view is invalid. Continue on and try to perform
+ // any other Post DDL operations.
+ try {
+ WhereCompiler.compile(context, select); // Push where clause into scan
+ } catch (ColumnFamilyNotFoundException e) {
+ continue;
+ } catch (ColumnNotFoundException e) {
+ continue;
+ } catch (AmbiguousColumnException e) {
+ continue;
+ }
QueryPlan plan = new AggregatePlan(context, select, tableRef, projector, null, OrderBy.EMPTY_ORDER_BY, null, GroupBy.EMPTY_GROUP_BY, null);
- ResultIterator iterator = plan.iterator();
try {
- Tuple row = iterator.next();
- ImmutableBytesWritable ptr = context.getTempPtr();
- totalMutationCount += (Long)projector.getColumnProjector(0).getValue(row, PDataType.LONG, ptr);
- } catch (SQLException e) {
- sqlE = e;
- } finally {
+ ResultIterator iterator = plan.iterator();
try {
- iterator.close();
+ Tuple row = iterator.next();
+ ImmutableBytesWritable ptr = context.getTempPtr();
+ totalMutationCount += (Long)projector.getColumnProjector(0).getValue(row, PDataType.LONG, ptr);
} catch (SQLException e) {
- if (sqlE == null) {
- sqlE = e;
- } else {
- sqlE.setNextException(e);
- }
+ sqlE = e;
} finally {
- if (sqlE != null) {
- throw sqlE;
+ try {
+ iterator.close();
+ } catch (SQLException e) {
+ if (sqlE == null) {
+ sqlE = e;
+ } else {
+ sqlE.setNextException(e);
+ }
+ } finally {
+ if (sqlE != null) {
+ throw sqlE;
+ }
}
}
+ } catch (TableNotFoundException e) {
+ // Ignore and continue, as HBase throws when table hasn't been written to
+ // FIXME: Remove if this is fixed in 0.96
}
} finally {
if (cache != null) { // Remove server cache if there is one
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/PostIndexDDLCompiler.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/PostIndexDDLCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/PostIndexDDLCompiler.java
index d337fc5..2f0ce7a 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/PostIndexDDLCompiler.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/PostIndexDDLCompiler.java
@@ -20,6 +20,7 @@ package org.apache.phoenix.compile;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.SQLException;
+import java.util.List;
import org.apache.phoenix.execute.MutationState;
import org.apache.phoenix.jdbc.PhoenixConnection;
@@ -79,7 +80,15 @@ public class PostIndexDDLCompiler {
// that would allow the user to easily monitor the process of index creation.
StringBuilder indexColumns = new StringBuilder();
StringBuilder dataColumns = new StringBuilder();
- for (PColumn col: dataTableRef.getTable().getColumns()) {
+ List<PColumn> dataTableColumns = dataTableRef.getTable().getColumns();
+ PTable dataTable = dataTableRef.getTable();
+ int nColumns = dataTable.getColumns().size();
+ boolean isSalted = dataTable.getBucketNum() != null;
+ boolean isMultiTenant = connection.getTenantId() != null && dataTable.isMultiTenant();
+ boolean isSharedViewIndex = dataTable.getViewIndexId() != null;
+ int posOffset = (isSalted ? 1 : 0) + (isMultiTenant ? 1 : 0) + (isSharedViewIndex ? 1 : 0);
+ for (int i = posOffset; i < nColumns; i++) {
+ PColumn col = dataTableColumns.get(i);
String indexColName = IndexUtil.getIndexColumnName(col);
try {
indexTable.getColumn(indexColName);
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/ProjectionCompiler.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/ProjectionCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/ProjectionCompiler.java
index 6b66ba8..3d5f8fe 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/ProjectionCompiler.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/ProjectionCompiler.java
@@ -120,8 +120,11 @@ public class ProjectionCompiler {
ColumnResolver resolver = context.getResolver();
PTable table = tableRef.getTable();
int posOffset = table.getBucketNum() == null ? 0 : 1;
- // In SELECT *, don't include tenant column for tenant connection
- if (tableRef.getTable().isMultiTenant() && context.getConnection().getTenantId() != null) {
+ // In SELECT *, don't include tenant column or index ID column for tenant connection
+ if (table.isMultiTenant() && context.getConnection().getTenantId() != null) {
+ posOffset++;
+ }
+ if (table.getViewIndexId() != null) {
posOffset++;
}
for (int i = posOffset; i < table.getColumns().size(); i++) {
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/QueryCompiler.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/QueryCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/QueryCompiler.java
index 9ead4c5..948c112 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/QueryCompiler.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/QueryCompiler.java
@@ -33,7 +33,6 @@ import org.apache.phoenix.compile.JoinCompiler.ProjectedPTableWrapper;
import org.apache.phoenix.compile.OrderByCompiler.OrderBy;
import org.apache.phoenix.execute.AggregatePlan;
import org.apache.phoenix.execute.BasicQueryPlan;
-import org.apache.phoenix.execute.DegenerateQueryPlan;
import org.apache.phoenix.execute.HashJoinPlan;
import org.apache.phoenix.execute.ScanPlan;
import org.apache.phoenix.expression.Expression;
@@ -53,9 +52,7 @@ import org.apache.phoenix.query.QueryConstants;
import org.apache.phoenix.schema.AmbiguousColumnException;
import org.apache.phoenix.schema.ColumnNotFoundException;
import org.apache.phoenix.schema.PDatum;
-import org.apache.phoenix.schema.PIndexState;
import org.apache.phoenix.schema.PTable;
-import org.apache.phoenix.schema.PTableType;
import org.apache.phoenix.schema.TableRef;
import org.apache.phoenix.util.ScanUtil;
@@ -245,12 +242,6 @@ public class QueryCompiler {
PhoenixConnection connection = statement.getConnection();
ColumnResolver resolver = context.getResolver();
TableRef tableRef = context.getCurrentTable();
- // Short circuit out if we're compiling an index query and the index isn't active.
- // We must do this after the ColumnResolver resolves the table, as we may be updating the local
- // cache of the index table and it may now be inactive.
- if (tableRef.getTable().getType() == PTableType.INDEX && tableRef.getTable().getIndexState() != PIndexState.ACTIVE) {
- return new DegenerateQueryPlan(context, select, tableRef);
- }
PTable table = tableRef.getTable();
if (table.getViewStatement() != null) {
ParseNode viewNode = new SQLParser(table.getViewStatement()).parseQuery().getWhere();
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/QueryPlan.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/QueryPlan.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/QueryPlan.java
index 689b812..80c4e14 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/QueryPlan.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/QueryPlan.java
@@ -64,4 +64,6 @@ public interface QueryPlan extends StatementPlan {
StatementContext getContext();
FilterableStatement getStatement();
+
+ public boolean isDegenerate();
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/UpsertCompiler.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/UpsertCompiler.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/UpsertCompiler.java
index 1a85c38..c060ac0 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/UpsertCompiler.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/UpsertCompiler.java
@@ -83,6 +83,7 @@ import org.apache.phoenix.schema.TableRef;
import org.apache.phoenix.schema.TypeMismatchException;
import org.apache.phoenix.schema.tuple.Tuple;
import org.apache.phoenix.util.ByteUtil;
+import org.apache.phoenix.util.MetaDataUtil;
import org.apache.phoenix.util.SchemaUtil;
import com.google.common.collect.Lists;
@@ -213,6 +214,7 @@ public class UpsertCompiler {
}
boolean isSalted = table.getBucketNum() != null;
boolean isTenantSpecific = table.isMultiTenant() && connection.getTenantId() != null;
+ boolean isSharedViewIndex = table.getViewIndexId() != null;
String tenantId = isTenantSpecific ? connection.getTenantId().getString() : null;
int posOffset = isSalted ? 1 : 0;
// Setup array of column indexes parallel to values that are going to be set
@@ -260,7 +262,7 @@ public class UpsertCompiler {
} else {
// Size for worse case
int numColsInUpsert = columnNodes.size();
- nColumnsToSet = numColsInUpsert + addViewColumns.size() + (isTenantSpecific ? 1 : 0);
+ nColumnsToSet = numColsInUpsert + addViewColumns.size() + (isTenantSpecific ? 1 : 0) + + (isSharedViewIndex ? 1 : 0);
columnIndexesToBe = new int[nColumnsToSet];
pkSlotIndexesToBe = new int[columnIndexesToBe.length];
targetColumns = Lists.newArrayListWithExpectedSize(columnIndexesToBe.length);
@@ -305,6 +307,13 @@ public class UpsertCompiler {
targetColumns.set(i, tenantColumn);
i++;
}
+ if (isSharedViewIndex) {
+ PColumn indexIdColumn = table.getPKColumns().get(posOffset+1);
+ columnIndexesToBe[i] = indexIdColumn.getPosition();
+ pkColumnsSet.set(pkSlotIndexesToBe[i] = posOffset+1);
+ targetColumns.set(i, indexIdColumn);
+ i++;
+ }
i = posOffset;
for ( ; i < table.getPKColumns().size(); i++) {
PColumn pkCol = table.getPKColumns().get(i);
@@ -370,7 +379,7 @@ public class UpsertCompiler {
// Cannot auto commit if doing aggregation or topN or salted
// Salted causes problems because the row may end up living on a different region
} else {
- nValuesToSet = valueNodes.size() + addViewColumns.size() + (isTenantSpecific ? 1 : 0);
+ nValuesToSet = valueNodes.size() + addViewColumns.size() + (isTenantSpecific ? 1 : 0) + (isSharedViewIndex ? 1 : 0);
}
final RowProjector projector = rowProjectorToBe;
final UpsertingParallelIteratorFactory upsertParallelIteratorFactory = upsertParallelIteratorFactoryToBe;
@@ -661,6 +670,9 @@ public class UpsertCompiler {
if (isTenantSpecific) {
values[nodeIndex++] = connection.getTenantId().getBytes();
}
+ if (isSharedViewIndex) {
+ values[nodeIndex++] = MetaDataUtil.getViewIndexIdDataType().toBytes(table.getViewIndexId());
+ }
return new MutationPlan() {
@Override
@@ -787,6 +799,9 @@ public class UpsertCompiler {
if (table.isMultiTenant() && tenantId != null) {
selectNodes.add(new AliasedNode(null, new LiteralParseNode(tenantId)));
}
+ if (table.getViewIndexId() != null) {
+ selectNodes.add(new AliasedNode(null, new LiteralParseNode(table.getViewIndexId())));
+ }
return SelectStatement.create(select, selectNodes);
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereOptimizer.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereOptimizer.java b/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereOptimizer.java
index 14a1a30..daddae3 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereOptimizer.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/compile/WhereOptimizer.java
@@ -49,15 +49,16 @@ import org.apache.phoenix.parse.FilterableStatement;
import org.apache.phoenix.parse.HintNode.Hint;
import org.apache.phoenix.query.KeyRange;
import org.apache.phoenix.query.QueryConstants;
-import org.apache.phoenix.schema.SortOrder;
import org.apache.phoenix.schema.PColumn;
import org.apache.phoenix.schema.PDataType;
import org.apache.phoenix.schema.PName;
import org.apache.phoenix.schema.PTable;
import org.apache.phoenix.schema.RowKeySchema;
import org.apache.phoenix.schema.SaltingUtil;
+import org.apache.phoenix.schema.SortOrder;
import org.apache.phoenix.schema.tuple.Tuple;
import org.apache.phoenix.util.ByteUtil;
+import org.apache.phoenix.util.MetaDataUtil;
import org.apache.phoenix.util.SchemaUtil;
import com.google.common.base.Preconditions;
@@ -153,11 +154,19 @@ public class WhereOptimizer {
pkPos++;
}
- // aAd tenant data isolation for tenant-specific tables
+ // Add tenant data isolation for tenant-specific tables
if (tenantId != null && table.isMultiTenant()) {
KeyRange tenantIdKeyRange = KeyRange.getKeyRange(tenantId.getBytes());
cnf.add(singletonList(tenantIdKeyRange));
- if (iterator.hasNext()) iterator.next();
+ //if (iterator.hasNext()) iterator.next();
+ pkPos++;
+ }
+ // Add unique index ID for shared indexes on views. This ensures
+ // that different indexes don't interleave.
+ if (table.getViewIndexId() != null) {
+ KeyRange indexIdKeyRange = KeyRange.getKeyRange(MetaDataUtil.getViewIndexIdDataType().toBytes(table.getViewIndexId()));
+ cnf.add(singletonList(indexIdKeyRange));
+ //if (iterator.hasNext()) iterator.next();
pkPos++;
}
// Concat byte arrays of literals to form scan start key
@@ -318,7 +327,7 @@ public class WhereOptimizer {
return null;
}
- int positionOffset = table.getBucketNum() == null ? 0 : 1;
+ int positionOffset = (table.getBucketNum() ==null ? 0 : 1) + (this.context.getConnection().getTenantId() != null && table.isMultiTenant() ? 1 : 0) + (table.getViewIndexId() == null ? 0 : 1);
int position = 0;
for (KeySlots slots : childSlots) {
KeySlot keySlot = slots.iterator().next();
@@ -409,7 +418,7 @@ public class WhereOptimizer {
KeySlot[] keySlot = new KeySlot[nColumns];
KeyRange minMaxRange = KeyRange.EVERYTHING_RANGE;
List<Expression> minMaxExtractNodes = Lists.<Expression>newArrayList();
- int initPosition = (table.getBucketNum() ==null ? 0 : 1);
+ int initPosition = (table.getBucketNum() ==null ? 0 : 1) + (this.context.getConnection().getTenantId() != null && table.isMultiTenant() ? 1 : 0) + (table.getViewIndexId() == null ? 0 : 1);
for (KeySlots childSlot : childSlots) {
if (childSlot == DEGENERATE_KEY_PARTS) {
return DEGENERATE_KEY_PARTS;
@@ -468,7 +477,7 @@ public class WhereOptimizer {
if (orExpression.getChildren().size() != childSlots.size()) {
return null;
}
- int initialPos = (table.getBucketNum() == null ? 0 : 1);
+ int initialPos = (table.getBucketNum() ==null ? 0 : 1) + (this.context.getConnection().getTenantId() != null && table.isMultiTenant() ? 1 : 0) + (table.getViewIndexId() == null ? 0 : 1);
KeySlot theSlot = null;
List<Expression> slotExtractNodes = Lists.<Expression>newArrayList();
int thePosition = -1;
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/MetaDataEndpointImpl.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/MetaDataEndpointImpl.java b/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/MetaDataEndpointImpl.java
index 9811511..09d2c6b 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/MetaDataEndpointImpl.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/coprocessor/MetaDataEndpointImpl.java
@@ -19,14 +19,13 @@ package org.apache.phoenix.coprocessor;
import static com.google.common.collect.Lists.newArrayList;
import static org.apache.hadoop.hbase.filter.CompareFilter.CompareOp.EQUAL;
-import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.ARRAY_SIZE;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.ARRAY_SIZE_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.COLUMN_COUNT_BYTES;
-import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SORT_ORDER;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.COLUMN_NAME_INDEX;
-import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.COLUMN_SIZE;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.COLUMN_SIZE_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.DATA_TABLE_NAME_BYTES;
-import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.DATA_TYPE;
-import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.DECIMAL_DIGITS;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.DATA_TYPE_BYTES;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.DECIMAL_DIGITS_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.DEFAULT_COLUMN_FAMILY_NAME_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.DISABLE_WAL_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.FAMILY_NAME_INDEX;
@@ -34,16 +33,19 @@ import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.IMMUTABLE_ROWS_BYT
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.INDEX_STATE_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.LINK_TYPE_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.MULTI_TENANT_BYTES;
-import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.NULLABLE;
-import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.ORDINAL_POSITION;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.NULLABLE_BYTES;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.ORDINAL_POSITION_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.PK_NAME_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SALT_BUCKETS_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SCHEMA_NAME_INDEX;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SORT_ORDER_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TABLE_FAMILY_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TABLE_NAME_INDEX;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TABLE_SEQ_NUM_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TABLE_TYPE_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TENANT_ID_INDEX;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.VIEW_CONSTANT_BYTES;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.VIEW_INDEX_ID_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.VIEW_STATEMENT_BYTES;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.VIEW_TYPE_BYTES;
import static org.apache.phoenix.schema.PTableType.INDEX;
@@ -86,7 +88,6 @@ import org.apache.phoenix.jdbc.PhoenixDatabaseMetaData;
import org.apache.phoenix.query.QueryConstants;
import org.apache.phoenix.schema.AmbiguousColumnException;
import org.apache.phoenix.schema.ColumnFamilyNotFoundException;
-import org.apache.phoenix.schema.SortOrder;
import org.apache.phoenix.schema.ColumnNotFoundException;
import org.apache.phoenix.schema.PColumn;
import org.apache.phoenix.schema.PColumnFamily;
@@ -100,6 +101,7 @@ import org.apache.phoenix.schema.PTable.LinkType;
import org.apache.phoenix.schema.PTable.ViewType;
import org.apache.phoenix.schema.PTableImpl;
import org.apache.phoenix.schema.PTableType;
+import org.apache.phoenix.schema.SortOrder;
import org.apache.phoenix.schema.TableNotFoundException;
import org.apache.phoenix.util.ByteUtil;
import org.apache.phoenix.util.IndexUtil;
@@ -144,6 +146,7 @@ public class MetaDataEndpointImpl extends BaseEndpointCoprocessor implements Met
private static final KeyValue DISABLE_WAL_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, DISABLE_WAL_BYTES);
private static final KeyValue MULTI_TENANT_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, MULTI_TENANT_BYTES);
private static final KeyValue VIEW_TYPE_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, VIEW_TYPE_BYTES);
+ private static final KeyValue VIEW_INDEX_ID_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, VIEW_INDEX_ID_BYTES);
private static final List<KeyValue> TABLE_KV_COLUMNS = Arrays.<KeyValue>asList(
TABLE_TYPE_KV,
TABLE_SEQ_NUM_KV,
@@ -157,7 +160,8 @@ public class MetaDataEndpointImpl extends BaseEndpointCoprocessor implements Met
DEFAULT_COLUMN_FAMILY_KV,
DISABLE_WAL_KV,
MULTI_TENANT_KV,
- VIEW_TYPE_KV
+ VIEW_TYPE_KV,
+ VIEW_INDEX_ID_KV
);
static {
Collections.sort(TABLE_KV_COLUMNS, KeyValue.COMPARATOR);
@@ -175,15 +179,17 @@ public class MetaDataEndpointImpl extends BaseEndpointCoprocessor implements Met
private static final int DISABLE_WAL_INDEX = TABLE_KV_COLUMNS.indexOf(DISABLE_WAL_KV);
private static final int MULTI_TENANT_INDEX = TABLE_KV_COLUMNS.indexOf(MULTI_TENANT_KV);
private static final int VIEW_TYPE_INDEX = TABLE_KV_COLUMNS.indexOf(VIEW_TYPE_KV);
+ private static final int VIEW_INDEX_ID_INDEX = TABLE_KV_COLUMNS.indexOf(VIEW_INDEX_ID_KV);
// KeyValues for Column
- private static final KeyValue DECIMAL_DIGITS_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, Bytes.toBytes(DECIMAL_DIGITS));
- private static final KeyValue COLUMN_SIZE_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, Bytes.toBytes(COLUMN_SIZE));
- private static final KeyValue NULLABLE_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, Bytes.toBytes(NULLABLE));
- private static final KeyValue DATA_TYPE_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, Bytes.toBytes(DATA_TYPE));
- private static final KeyValue ORDINAL_POSITION_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, Bytes.toBytes(ORDINAL_POSITION));
- private static final KeyValue SORT_ORDER_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, Bytes.toBytes(SORT_ORDER));
- private static final KeyValue ARRAY_SIZE_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, Bytes.toBytes(ARRAY_SIZE));
+ private static final KeyValue DECIMAL_DIGITS_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, DECIMAL_DIGITS_BYTES);
+ private static final KeyValue COLUMN_SIZE_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, COLUMN_SIZE_BYTES);
+ private static final KeyValue NULLABLE_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, NULLABLE_BYTES);
+ private static final KeyValue DATA_TYPE_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, DATA_TYPE_BYTES);
+ private static final KeyValue ORDINAL_POSITION_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, ORDINAL_POSITION_BYTES);
+ private static final KeyValue SORT_ORDER_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, SORT_ORDER_BYTES);
+ private static final KeyValue ARRAY_SIZE_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, ARRAY_SIZE_BYTES);
+ private static final KeyValue VIEW_CONSTANT_KV = KeyValue.createFirstOnRow(ByteUtil.EMPTY_BYTE_ARRAY, TABLE_FAMILY_BYTES, VIEW_CONSTANT_BYTES);
private static final List<KeyValue> COLUMN_KV_COLUMNS = Arrays.<KeyValue>asList(
DECIMAL_DIGITS_KV,
COLUMN_SIZE_KV,
@@ -192,7 +198,8 @@ public class MetaDataEndpointImpl extends BaseEndpointCoprocessor implements Met
ORDINAL_POSITION_KV,
SORT_ORDER_KV,
DATA_TABLE_NAME_KV, // included in both column and table row for metadata APIs
- ARRAY_SIZE_KV
+ ARRAY_SIZE_KV,
+ VIEW_CONSTANT_KV
);
static {
Collections.sort(COLUMN_KV_COLUMNS, KeyValue.COMPARATOR);
@@ -204,6 +211,7 @@ public class MetaDataEndpointImpl extends BaseEndpointCoprocessor implements Met
private static final int ORDINAL_POSITION_INDEX = COLUMN_KV_COLUMNS.indexOf(ORDINAL_POSITION_KV);
private static final int SORT_ORDER_INDEX = COLUMN_KV_COLUMNS.indexOf(SORT_ORDER_KV);
private static final int ARRAY_SIZE_INDEX = COLUMN_KV_COLUMNS.indexOf(ARRAY_SIZE_KV);
+ private static final int VIEW_CONSTANT_INDEX = COLUMN_KV_COLUMNS.indexOf(VIEW_CONSTANT_KV);
private static final int LINK_TYPE_INDEX = 0;
@@ -311,7 +319,9 @@ public class MetaDataEndpointImpl extends BaseEndpointCoprocessor implements Met
SortOrder sortOrder = sortOrderKv == null ? SortOrder.getDefault() : SortOrder.fromSystemValue(PDataType.INTEGER.getCodec().decodeInt(sortOrderKv.getBuffer(), sortOrderKv.getValueOffset(), SortOrder.getDefault()));
KeyValue arraySizeKv = colKeyValues[ARRAY_SIZE_INDEX];
Integer arraySize = arraySizeKv == null ? null : PDataType.INTEGER.getCodec().decodeInt(arraySizeKv.getBuffer(), arraySizeKv.getValueOffset(), SortOrder.getDefault());
- PColumn column = new PColumnImpl(colName, famName, dataType, maxLength, scale, isNullable, position-1, sortOrder, arraySize);
+ KeyValue viewConstantKv = colKeyValues[VIEW_CONSTANT_INDEX];
+ byte[] viewConstant = viewConstantKv == null ? null : viewConstantKv.getValue();
+ PColumn column = new PColumnImpl(colName, famName, dataType, maxLength, scale, isNullable, position-1, sortOrder, arraySize, viewConstant);
columns.add(column);
}
@@ -400,6 +410,8 @@ public class MetaDataEndpointImpl extends BaseEndpointCoprocessor implements Met
boolean multiTenant = multiTenantKv == null ? false : Boolean.TRUE.equals(PDataType.BOOLEAN.toObject(multiTenantKv.getBuffer(), multiTenantKv.getValueOffset(), multiTenantKv.getValueLength()));
KeyValue viewTypeKv = tableKeyValues[VIEW_TYPE_INDEX];
ViewType viewType = viewTypeKv == null ? null : ViewType.fromSerializedValue(viewTypeKv.getBuffer()[viewTypeKv.getValueOffset()]);
+ KeyValue viewIndexIdKv = tableKeyValues[VIEW_INDEX_ID_INDEX];
+ Short viewIndexId = viewIndexIdKv == null ? null : (Short)MetaDataUtil.getViewIndexIdDataType().getCodec().decodeShort(viewIndexIdKv.getBuffer(), viewIndexIdKv.getValueOffset(), SortOrder.getDefault());
List<PColumn> columns = Lists.newArrayListWithExpectedSize(columnCount);
List<PTable> indexes = new ArrayList<PTable>();
@@ -429,8 +441,8 @@ public class MetaDataEndpointImpl extends BaseEndpointCoprocessor implements Met
}
}
- return PTableImpl.makePTable(schemaName, tableName, tableType, indexState, timeStamp, tableSeqNum, pkName, saltBucketNum, columns, tableType == INDEX ? dataTableName : null,
- indexes, isImmutableRows, physicalTables, defaultFamilyName, viewStatement, disableWAL, multiTenant, viewType);
+ return PTableImpl.makePTable(tenantId, schemaName, tableName, tableType, indexState, timeStamp, tableSeqNum, pkName, saltBucketNum, columns,
+ tableType == INDEX ? dataTableName : null, indexes, isImmutableRows, physicalTables, defaultFamilyName, viewStatement, disableWAL, multiTenant, viewType, viewIndexId);
}
private PTable buildDeletedTable(byte[] key, ImmutableBytesPtr cacheKey, HRegion region, long clientTimeStamp) throws IOException {
@@ -722,7 +734,8 @@ public class MetaDataEndpointImpl extends BaseEndpointCoprocessor implements Met
return new MetaDataMutationResult(MutationCode.UNALLOWED_TABLE_MUTATION, EnvironmentEdgeManager.currentTimeMillis(), null);
}
if (table.getType() != PTableType.VIEW) { // Add to list of HTables to delete, unless it's a view
- tableNamesToDelete.add(table.getName().getBytes());
+ byte[] fullName = table.getName().getBytes();
+ tableNamesToDelete.add(fullName);
}
List<byte[]> indexNames = Lists.newArrayList();
invalidateList.add(cacheKey);
@@ -945,6 +958,9 @@ public class MetaDataEndpointImpl extends BaseEndpointCoprocessor implements Met
} else {
continue;
}
+ if (columnToDelete.getViewConstant() != null) { // Disallow deletion of column referenced in WHERE clause of view
+ return new MetaDataMutationResult(MutationCode.UNALLOWED_TABLE_MUTATION, EnvironmentEdgeManager.currentTimeMillis(), table, columnToDelete);
+ }
// Look for columnToDelete in any indexes. If found as PK column, get lock and drop the index. If found as covered column, delete from index (do this client side?).
// In either case, invalidate index if the column is in it
for (PTable index : table.getIndexes()) {
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/exception/SQLExceptionCode.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/exception/SQLExceptionCode.java b/phoenix-core/src/main/java/org/apache/phoenix/exception/SQLExceptionCode.java
index 2e5f2d7..814f45a 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/exception/SQLExceptionCode.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/exception/SQLExceptionCode.java
@@ -206,9 +206,10 @@ public enum SQLExceptionCode {
CANNOT_CREATE_TENANT_SPECIFIC_TABLE(1030, "42Y89", "Cannot create table for tenant-specific connection"),
CANNOT_DEFINE_PK_FOR_VIEW(1031, "42Y90", "Defining PK columns for a VIEW is not allowed."),
DEFAULT_COLUMN_FAMILY_ONLY_ON_CREATE_TABLE(1034, "42Y93", "Default column family may only be specified when creating a table."),
- INSUFFICIENT_MULTI_TENANT_COLUMNS(1040, "42Y96", "A MULTI_TENANT table must have 2 or more PK columns with the first column being VARCHAR or CHAR."),
+ INSUFFICIENT_MULTI_TENANT_COLUMNS(1040, "42Y96", "A MULTI_TENANT table must have two or more PK columns with the first column being NOT NULL and of type VARCHAR or CHAR."),
VIEW_WHERE_IS_CONSTANT(1045, "43A02", "WHERE clause in VIEW should not evaluate to a constant."),
CANNOT_UPDATE_VIEW_COLUMN(1046, "43A03", "Column used in WHERE clause of VIEW may not be updated."),
+ TOO_MANY_VIEW_INDEXES(1047, "43A04", "Too many indexes have already been created on the physical table."),
/** Sequence related */
SEQUENCE_ALREADY_EXIST(1200, "42Z00", "Sequence already exists.", new Factory() {
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/execute/BasicQueryPlan.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/execute/BasicQueryPlan.java b/phoenix-core/src/main/java/org/apache/phoenix/execute/BasicQueryPlan.java
index a615bd7..7108498 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/execute/BasicQueryPlan.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/execute/BasicQueryPlan.java
@@ -82,6 +82,12 @@ public abstract class BasicQueryPlan implements QueryPlan {
}
@Override
+ public boolean isDegenerate() {
+ return context.getScanRanges() == ScanRanges.NOTHING;
+
+ }
+
+ @Override
public GroupBy getGroupBy() {
return groupBy;
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/execute/HashJoinPlan.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/execute/HashJoinPlan.java b/phoenix-core/src/main/java/org/apache/phoenix/execute/HashJoinPlan.java
index 692b9e2..2f74075 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/execute/HashJoinPlan.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/execute/HashJoinPlan.java
@@ -24,17 +24,16 @@ import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
-import org.apache.hadoop.hbase.client.Scan;
-import com.google.common.collect.Lists;
+import org.apache.hadoop.hbase.client.Scan;
import org.apache.phoenix.cache.ServerCacheClient.ServerCache;
import org.apache.phoenix.compile.ExplainPlan;
+import org.apache.phoenix.compile.GroupByCompiler.GroupBy;
+import org.apache.phoenix.compile.OrderByCompiler.OrderBy;
import org.apache.phoenix.compile.QueryPlan;
import org.apache.phoenix.compile.RowProjector;
import org.apache.phoenix.compile.ScanRanges;
import org.apache.phoenix.compile.StatementContext;
-import org.apache.phoenix.compile.GroupByCompiler.GroupBy;
-import org.apache.phoenix.compile.OrderByCompiler.OrderBy;
import org.apache.phoenix.expression.Expression;
import org.apache.phoenix.hbase.index.util.ImmutableBytesPtr;
import org.apache.phoenix.iterate.ResultIterator;
@@ -47,6 +46,8 @@ import org.apache.phoenix.query.KeyRange;
import org.apache.phoenix.schema.TableRef;
import org.apache.phoenix.util.SQLCloseable;
+import com.google.common.collect.Lists;
+
public class HashJoinPlan implements QueryPlan {
private BasicQueryPlan plan;
@@ -182,5 +183,11 @@ public class HashJoinPlan implements QueryPlan {
return plan.getStatement();
}
+ @Override
+ public boolean isDegenerate() {
+ // TODO can we determine this won't return anything?
+ return false;
+ }
+
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java
index e334e02..7aa7554 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/LiteralExpression.java
@@ -27,9 +27,9 @@ import org.apache.hadoop.io.WritableUtils;
import org.apache.phoenix.exception.SQLExceptionCode;
import org.apache.phoenix.exception.SQLExceptionInfo;
import org.apache.phoenix.expression.visitor.ExpressionVisitor;
-import org.apache.phoenix.schema.SortOrder;
import org.apache.phoenix.schema.IllegalDataException;
import org.apache.phoenix.schema.PDataType;
+import org.apache.phoenix.schema.SortOrder;
import org.apache.phoenix.schema.TypeMismatchException;
import org.apache.phoenix.schema.tuple.Tuple;
import org.apache.phoenix.util.ByteUtil;
@@ -98,7 +98,7 @@ public class LiteralExpression extends BaseTerminalExpression {
}
PDataType type = PDataType.fromLiteral(value);
byte[] b = type.toBytes(value);
- if (b.length == 0) {
+ if (type.isNull(b)) {
return TYPED_NULL_EXPRESSIONS[type.ordinal() + ( isDeterministic ? 0 : TYPED_NULL_EXPRESSIONS.length/2)];
}
if (type == PDataType.VARCHAR) {
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/index/IndexMaintainer.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/index/IndexMaintainer.java b/phoenix-core/src/main/java/org/apache/phoenix/index/IndexMaintainer.java
index 3b28382..471626c 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/index/IndexMaintainer.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/index/IndexMaintainer.java
@@ -48,6 +48,7 @@ import org.apache.phoenix.schema.PColumn;
import org.apache.phoenix.schema.PColumnFamily;
import org.apache.phoenix.schema.PDataType;
import org.apache.phoenix.schema.PIndexState;
+import org.apache.phoenix.schema.PName;
import org.apache.phoenix.schema.PTable;
import org.apache.phoenix.schema.PTableType;
import org.apache.phoenix.schema.RowKeySchema;
@@ -58,6 +59,7 @@ import org.apache.phoenix.schema.ValueSchema.Field;
import org.apache.phoenix.util.BitSet;
import org.apache.phoenix.util.ByteUtil;
import org.apache.phoenix.util.IndexUtil;
+import org.apache.phoenix.util.MetaDataUtil;
import org.apache.phoenix.util.SchemaUtil;
import org.apache.phoenix.util.TrustedByteArrayOutputStream;
@@ -195,6 +197,8 @@ public class IndexMaintainer implements Writable, Iterable<ColumnReference> {
return maintainers;
}
+ private byte[] viewIndexId;
+ private boolean isMultiTenant;
private Set<ColumnReference> indexedColumns;
private Set<ColumnReference> coveredColumns;
private Set<ColumnReference> allColumns;
@@ -236,6 +240,9 @@ public class IndexMaintainer implements Writable, Iterable<ColumnReference> {
int nIndexPKColumns = index.getPKColumns().size() - indexPosOffset;
int nDataPKColumns = dataRowKeySchema.getFieldCount() - (isDataTableSalted ? 1 : 0);
+ PName tenantId = dataTable.getTenantId();
+ this.isMultiTenant = tenantId != null;
+ this.viewIndexId = dataTable.getViewIndexId() == null ? null : MetaDataUtil.getViewIndexIdDataType().toBytes(dataTable.getViewIndexId());
this.indexTableName = indexTableName;
this.indexedColumns = Sets.newLinkedHashSetWithExpectedSize(nIndexPKColumns-nDataPKColumns);
this.indexedColumnTypes = Lists.<PDataType>newArrayListWithExpectedSize(nIndexPKColumns-nDataPKColumns);
@@ -260,7 +267,6 @@ public class IndexMaintainer implements Writable, Iterable<ColumnReference> {
if (nIndexSaltBuckets > 0) {
output.write(0); // will be set at end to index salt byte
}
-
// The dataRowKeySchema includes the salt byte field,
// so we must adjust for that here.
int dataPosOffset = isDataTableSalted ? 1 : 0 ;
@@ -269,6 +275,18 @@ public class IndexMaintainer implements Writable, Iterable<ColumnReference> {
// Skip data table salt byte
int maxRowKeyOffset = rowKeyPtr.getOffset() + rowKeyPtr.getLength();
dataRowKeySchema.iterator(rowKeyPtr, ptr, dataPosOffset);
+ if (isMultiTenant) {
+ dataRowKeySchema.next(ptr, dataPosOffset, maxRowKeyOffset);
+ output.write(ptr.get(), ptr.getOffset(), ptr.getLength());
+ if (!dataRowKeySchema.getField(dataPosOffset).getDataType().isFixedWidth()) {
+ output.writeByte(QueryConstants.SEPARATOR_BYTE);
+ }
+ dataPosOffset++;
+ }
+ if (viewIndexId != null) {
+ output.write(viewIndexId);
+ }
+
// Write index row key
for (int i = dataPosOffset; i < dataRowKeySchema.getFieldCount(); i++) {
Boolean hasValue=dataRowKeySchema.next(ptr, i, maxRowKeyOffset);
@@ -497,8 +515,17 @@ public class IndexMaintainer implements Writable, Iterable<ColumnReference> {
@Override
public void readFields(DataInput input) throws IOException {
- nIndexSaltBuckets = WritableUtils.readVInt(input);
- int nIndexedColumns = WritableUtils.readVInt(input);
+ int encodedIndexSaltBucketsAndMultiTenant = WritableUtils.readVInt(input);
+ isMultiTenant = encodedIndexSaltBucketsAndMultiTenant < 0;
+ nIndexSaltBuckets = Math.abs(encodedIndexSaltBucketsAndMultiTenant) - 1;
+ int encodedIndexedColumnsAndViewId = WritableUtils.readVInt(input);
+ boolean hasViewIndexId = encodedIndexedColumnsAndViewId < 0;
+ if (hasViewIndexId) {
+ // Fixed length
+ viewIndexId = new byte[MetaDataUtil.getViewIndexIdDataType().getByteSize()];
+ input.readFully(viewIndexId);
+ }
+ int nIndexedColumns = Math.abs(encodedIndexedColumnsAndViewId) - 1;
indexedColumns = Sets.newLinkedHashSetWithExpectedSize(nIndexedColumns);
for (int i = 0; i < nIndexedColumns; i++) {
byte[] cf = Bytes.readByteArray(input);
@@ -538,8 +565,13 @@ public class IndexMaintainer implements Writable, Iterable<ColumnReference> {
@Override
public void write(DataOutput output) throws IOException {
- WritableUtils.writeVInt(output, nIndexSaltBuckets);
- WritableUtils.writeVInt(output, indexedColumns.size());
+ // Encode nIndexSaltBuckets and isMultiTenant together
+ WritableUtils.writeVInt(output, (nIndexSaltBuckets + 1) * (isMultiTenant ? -1 : 1));
+ // Encode indexedColumns.size() and whether or not there's a viewIndexId
+ WritableUtils.writeVInt(output, (indexedColumns.size() + 1) * (viewIndexId != null ? -1 : 1));
+ if (viewIndexId != null) {
+ output.write(viewIndexId);
+ }
for (ColumnReference ref : indexedColumns) {
Bytes.writeByteArray(output, ref.getFamily());
Bytes.writeByteArray(output, ref.getQualifier());
@@ -567,6 +599,33 @@ public class IndexMaintainer implements Writable, Iterable<ColumnReference> {
WritableUtils.writeVInt(output, (nDataCFs + 1) * (indexWALDisabled ? -1 : 1));
}
+ public int getEstimatedByteSize() {
+ int size = WritableUtils.getVIntSize(nIndexSaltBuckets);
+ size += WritableUtils.getVIntSize(indexedColumns.size());
+ size += viewIndexId == null ? 0 : viewIndexId.length;
+ for (ColumnReference ref : indexedColumns) {
+ size += WritableUtils.getVIntSize(ref.getFamily().length);
+ size += ref.getFamily().length;
+ size += WritableUtils.getVIntSize(ref.getQualifier().length);
+ size += ref.getQualifier().length;
+ }
+ size += indexedColumnTypes.size();
+ size += indexedColumnByteSizes.size();
+ size += WritableUtils.getVIntSize(coveredColumns.size());
+ for (ColumnReference ref : coveredColumns) {
+ size += WritableUtils.getVIntSize(ref.getFamily().length);
+ size += ref.getFamily().length;
+ size += WritableUtils.getVIntSize(ref.getQualifier().length);
+ size += ref.getQualifier().length;
+ }
+ size += indexTableName.length + WritableUtils.getVIntSize(indexTableName.length);
+ size += rowKeyMetaData.getByteSize();
+ size += dataEmptyKeyValueCF.length + WritableUtils.getVIntSize(dataEmptyKeyValueCF.length);
+ size += emptyKeyValueCFPtr.getLength() + WritableUtils.getVIntSize(emptyKeyValueCFPtr.getLength());
+ size += WritableUtils.getVIntSize(nDataCFs+1);
+ return size;
+ }
+
private int estimateIndexRowKeyByteSize() {
int estimatedIndexRowKeyBytes = dataRowKeySchema.getEstimatedValueLength() + (nIndexSaltBuckets == 0 ? 0 : SaltingUtil.NUM_SALTING_BYTES);
for (Integer byteSize : indexedColumnByteSizes) {
@@ -645,31 +704,6 @@ public class IndexMaintainer implements Writable, Iterable<ColumnReference> {
return capacity < 0xFF ? new ByteSizeRowKeyMetaData(capacity) : new IntSizedRowKeyMetaData(capacity);
}
- public int getEstimatedByteSize() {
- int size = WritableUtils.getVIntSize(nIndexSaltBuckets);
- size += WritableUtils.getVIntSize(indexedColumns.size());
- for (ColumnReference ref : indexedColumns) {
- size += WritableUtils.getVIntSize(ref.getFamily().length);
- size += ref.getFamily().length;
- size += WritableUtils.getVIntSize(ref.getQualifier().length);
- size += ref.getQualifier().length;
- }
- size += indexedColumnTypes.size();
- size += indexedColumnByteSizes.size();
- size += WritableUtils.getVIntSize(coveredColumns.size());
- for (ColumnReference ref : coveredColumns) {
- size += WritableUtils.getVIntSize(ref.getFamily().length);
- size += ref.getFamily().length;
- size += WritableUtils.getVIntSize(ref.getQualifier().length);
- size += ref.getQualifier().length;
- }
- size += indexTableName.length + WritableUtils.getVIntSize(indexTableName.length);
- size += rowKeyMetaData.getByteSize();
- size += dataEmptyKeyValueCF.length + + WritableUtils.getVIntSize(dataEmptyKeyValueCF.length);
- size += WritableUtils.getVIntSize(nDataCFs+1);
- return size;
- }
-
private static void writeInverted(byte[] buf, int offset, int length, DataOutput output) throws IOException {
for (int i = offset; i < offset + length; i++) {
byte b = SortOrder.invert(buf[i]);
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/jdbc/PhoenixDatabaseMetaData.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/jdbc/PhoenixDatabaseMetaData.java b/phoenix-core/src/main/java/org/apache/phoenix/jdbc/PhoenixDatabaseMetaData.java
index 3a8084f..6746080 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/jdbc/PhoenixDatabaseMetaData.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/jdbc/PhoenixDatabaseMetaData.java
@@ -145,15 +145,19 @@ public class PhoenixDatabaseMetaData implements DatabaseMetaData, org.apache.pho
public static final byte[] DATA_TYPE_BYTES = Bytes.toBytes(DATA_TYPE);
public static final String TYPE_NAME = "TYPE_NAME";
public static final String COLUMN_SIZE = "COLUMN_SIZE";
+ public static final byte[] COLUMN_SIZE_BYTES = Bytes.toBytes(COLUMN_SIZE);
public static final String BUFFER_LENGTH = "BUFFER_LENGTH";
public static final String DECIMAL_DIGITS = "DECIMAL_DIGITS";
+ public static final byte[] DECIMAL_DIGITS_BYTES = Bytes.toBytes(DECIMAL_DIGITS);
public static final String NUM_PREC_RADIX = "NUM_PREC_RADIX";
public static final String NULLABLE = "NULLABLE";
+ public static final byte[] NULLABLE_BYTES = Bytes.toBytes(NULLABLE);
public static final String COLUMN_DEF = "COLUMN_DEF";
public static final String SQL_DATA_TYPE = "SQL_DATA_TYPE";
public static final String SQL_DATETIME_SUB = "SQL_DATETIME_SUB";
public static final String CHAR_OCTET_LENGTH = "CHAR_OCTET_LENGTH";
public static final String ORDINAL_POSITION = "ORDINAL_POSITION";
+ public static final byte[] ORDINAL_POSITION_BYTES = Bytes.toBytes(ORDINAL_POSITION);
public static final String IS_NULLABLE = "IS_NULLABLE";
public static final String SCOPE_CATALOG = "SCOPE_CATALOG";
public static final String SCOPE_SCHEMA = "SCOPE_SCHEMA";
@@ -161,6 +165,7 @@ public class PhoenixDatabaseMetaData implements DatabaseMetaData, org.apache.pho
public static final String SOURCE_DATA_TYPE = "SOURCE_DATA_TYPE";
public static final String IS_AUTOINCREMENT = "IS_AUTOINCREMENT";
public static final String SORT_ORDER = "SORT_ORDER";
+ public static final byte[] SORT_ORDER_BYTES = Bytes.toBytes(SORT_ORDER);
public static final String IMMUTABLE_ROWS = "IMMUTABLE_ROWS";
public static final byte[] IMMUTABLE_ROWS_BYTES = Bytes.toBytes(IMMUTABLE_ROWS);
public static final String DEFAULT_COLUMN_FAMILY_NAME = "DEFAULT_COLUMN_FAMILY";
@@ -177,6 +182,10 @@ public class PhoenixDatabaseMetaData implements DatabaseMetaData, org.apache.pho
public static final byte[] LINK_TYPE_BYTES = Bytes.toBytes(LINK_TYPE);
public static final String ARRAY_SIZE = "ARRAY_SIZE";
public static final byte[] ARRAY_SIZE_BYTES = Bytes.toBytes(ARRAY_SIZE);
+ public static final String VIEW_CONSTANT = "VIEW_CONSTANT";
+ public static final byte[] VIEW_CONSTANT_BYTES = Bytes.toBytes(VIEW_CONSTANT);
+ public static final String VIEW_INDEX_ID = "VIEW_INDEX_ID";
+ public static final byte[] VIEW_INDEX_ID_BYTES = Bytes.toBytes(VIEW_INDEX_ID);
public static final String TABLE_FAMILY = QueryConstants.DEFAULT_COLUMN_FAMILY;
public static final byte[] TABLE_FAMILY_BYTES = QueryConstants.DEFAULT_COLUMN_FAMILY_BYTES;
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/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 5cec44d..fc6b5d5 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
@@ -388,6 +388,11 @@ public class PhoenixStatement implements Statement, SQLCloseable, org.apache.pho
public FilterableStatement getStatement() {
return null;
}
+
+ @Override
+ public boolean isDegenerate() {
+ return false;
+ }
};
}
[2/4] PHOENIX-21: Support indexes on multi-tenant views. Still needs
more testing
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/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 4ee071c..5c99e4b 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
@@ -47,6 +47,8 @@ import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TABLE_TYPE_NAME;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TENANT_ID;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TYPE_SCHEMA;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TYPE_TABLE;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.VIEW_CONSTANT;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.VIEW_INDEX_ID;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.VIEW_STATEMENT;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.VIEW_TYPE;
import static org.apache.phoenix.query.QueryServices.DROP_METADATA_ATTRIB;
@@ -126,6 +128,7 @@ import com.google.common.primitives.Ints;
public class MetaDataClient {
private static final Logger logger = LoggerFactory.getLogger(MetaDataClient.class);
+ public static final byte[][] EMPTY_VIEW_CONSTANTS = new byte[0][];
private static final ParseNodeFactory FACTORY = new ParseNodeFactory();
private static final String CREATE_TABLE =
@@ -145,8 +148,9 @@ public class MetaDataClient {
VIEW_STATEMENT + "," +
DISABLE_WAL + "," +
MULTI_TENANT + "," +
- VIEW_TYPE +
- ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+ VIEW_TYPE + "," +
+ VIEW_INDEX_ID +
+ ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
private static final String CREATE_LINK =
"UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\"( " +
TENANT_ID + "," +
@@ -169,11 +173,29 @@ public class MetaDataClient {
TABLE_NAME_NAME + "," +
TABLE_TYPE_NAME + "," +
TABLE_SEQ_NUM + "," +
- COLUMN_COUNT + "," +
- IMMUTABLE_ROWS + "," +
- DISABLE_WAL + "," +
- MULTI_TENANT +
- ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";
+ COLUMN_COUNT +
+ ") VALUES (?, ?, ?, ?, ?, ?)";
+ private static final String MUTATE_MULTI_TENANT =
+ "UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\"( " +
+ TENANT_ID + "," +
+ TABLE_SCHEM_NAME + "," +
+ TABLE_NAME_NAME + "," +
+ MULTI_TENANT +
+ ") VALUES (?, ?, ?, ?)";
+ private static final String MUTATE_DISABLE_WAL =
+ "UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\"( " +
+ TENANT_ID + "," +
+ TABLE_SCHEM_NAME + "," +
+ TABLE_NAME_NAME + "," +
+ DISABLE_WAL +
+ ") VALUES (?, ?, ?, ?)";
+ private static final String MUTATE_IMMUTABLE_ROWS =
+ "UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\"( " +
+ TENANT_ID + "," +
+ TABLE_SCHEM_NAME + "," +
+ TABLE_NAME_NAME + "," +
+ IMMUTABLE_ROWS +
+ ") VALUES (?, ?, ?, ?)";
private static final String UPDATE_INDEX_STATE =
"UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\"( " +
TENANT_ID + "," +
@@ -195,8 +217,9 @@ public class MetaDataClient {
ORDINAL_POSITION + "," +
SORT_ORDER + "," +
DATA_TABLE_NAME + "," + // write this both in the column and table rows for access by metadata APIs
- ARRAY_SIZE +
- ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+ ARRAY_SIZE + "," +
+ VIEW_CONSTANT +
+ ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
private static final String UPDATE_COLUMN_POSITION =
"UPSERT INTO " + TYPE_SCHEMA + ".\"" + TYPE_TABLE + "\" ( " +
TENANT_ID + "," +
@@ -337,6 +360,7 @@ public class MetaDataClient {
} else {
colUpsert.setInt(13, column.getArraySize());
}
+ colUpsert.setBytes(14, column.getViewConstant());
colUpsert.execute();
}
@@ -374,19 +398,18 @@ public class MetaDataClient {
}
PColumn column = new PColumnImpl(PNameFactory.newName(columnName), familyName, def.getDataType(),
- def.getMaxLength(), def.getScale(), def.isNull(), position, sortOrder, def.getArraySize());
+ def.getMaxLength(), def.getScale(), def.isNull(), position, sortOrder, def.getArraySize(), null);
return column;
} catch (IllegalArgumentException e) { // Based on precondition check in constructor
throw new SQLException(e);
}
}
- public MutationState createTable(CreateTableStatement statement, byte[][] splits, PTable parent, String viewStatement, ViewType viewType) throws SQLException {
- PTable table = createTableInternal(statement, splits, parent, viewStatement, viewType);
+ public MutationState createTable(CreateTableStatement statement, byte[][] splits, PTable parent, String viewStatement, ViewType viewType, byte[][] viewColumnConstants) throws SQLException {
+ PTable table = createTableInternal(statement, splits, parent, viewStatement, viewType, viewColumnConstants);
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.
@@ -488,8 +511,11 @@ public class MetaDataClient {
ColumnResolver resolver = FromCompiler.getResolver(statement, connection);
tableRef = resolver.getTables().get(0);
PTable dataTable = tableRef.getTable();
- if (dataTable.getType() == PTableType.VIEW && dataTable.getViewType() != ViewType.MAPPED) {
- throw new SQLFeatureNotSupportedException("Creating an index on a view is not supported currently, but will be soon");
+ boolean isTenantConnection = connection.getTenantId() != null;
+ if (isTenantConnection) {
+ if (dataTable.getType() != PTableType.VIEW) {
+ throw new SQLFeatureNotSupportedException("An index may only be created for a VIEW through a tenant-specific connection");
+ }
}
int hbaseVersion = connection.getQueryServices().getLowestClusterHBaseVersion();
if (!dataTable.isImmutableRows()) {
@@ -500,33 +526,59 @@ public class MetaDataClient {
throw new SQLExceptionInfo.Builder(SQLExceptionCode.INVALID_MUTABLE_INDEX_CONFIG).setTableName(indexTableName.getTableName()).build().buildException();
}
}
+ int posOffset = 0;
Set<PColumn> unusedPkColumns;
if (dataTable.getBucketNum() != null) { // Ignore SALT column
unusedPkColumns = new LinkedHashSet<PColumn>(dataTable.getPKColumns().subList(1, dataTable.getPKColumns().size()));
+ posOffset++;
} else {
unusedPkColumns = new LinkedHashSet<PColumn>(dataTable.getPKColumns());
}
List<Pair<ColumnName, SortOrder>> allPkColumns = Lists.newArrayListWithExpectedSize(unusedPkColumns.size());
List<ColumnDef> columnDefs = Lists.newArrayListWithExpectedSize(includedColumns.size() + indexedPkColumns.size());
+ if (dataTable.isMultiTenant()) {
+ // Add tenant ID column as first column in index
+ PColumn col = dataTable.getPKColumns().get(posOffset);
+ unusedPkColumns.remove(col);
+ PDataType dataType = IndexUtil.getIndexColumnDataType(col);
+ ColumnName colName = ColumnName.caseSensitiveColumnName(IndexUtil.getIndexColumnName(col));
+ allPkColumns.add(new Pair<ColumnName, SortOrder>(colName, col.getSortOrder()));
+ columnDefs.add(FACTORY.columnDef(colName, dataType.getSqlTypeName(), col.isNullable(), col.getMaxLength(), col.getScale(), false, SortOrder.getDefault()));
+ }
+ if (dataTable.getType() == PTableType.VIEW && dataTable.getViewType() != ViewType.MAPPED) {
+ // Next add index ID column
+ PDataType dataType = MetaDataUtil.getViewIndexIdDataType();
+ ColumnName colName = ColumnName.caseSensitiveColumnName(MetaDataUtil.getViewIndexIdColumnName());
+ allPkColumns.add(new Pair<ColumnName, SortOrder>(colName, SortOrder.getDefault()));
+ columnDefs.add(FACTORY.columnDef(colName, dataType.getSqlTypeName(), false, null, null, false, SortOrder.getDefault()));
+ }
+ boolean isUpdatableView = dataTable.getViewType() == ViewType.UPDATABLE;
// First columns are the indexed ones
for (Pair<ColumnName, SortOrder> pair : indexedPkColumns) {
ColumnName colName = pair.getFirst();
PColumn col = resolver.resolveColumn(null, colName.getFamilyName(), colName.getColumnName()).getColumn();
unusedPkColumns.remove(col);
- PDataType dataType = IndexUtil.getIndexColumnDataType(col);
- colName = ColumnName.caseSensitiveColumnName(IndexUtil.getIndexColumnName(col));
- allPkColumns.add(new Pair<ColumnName, SortOrder>(colName, pair.getSecond()));
- columnDefs.add(FACTORY.columnDef(colName, dataType.getSqlTypeName(), col.isNullable(), col.getMaxLength(), col.getScale(), false, SortOrder.getDefault()));
+ // Ignore view constants for updatable views as we don't need these in the index
+ if (!isUpdatableView || col.getViewConstant() == null) {
+ PDataType dataType = IndexUtil.getIndexColumnDataType(col);
+ colName = ColumnName.caseSensitiveColumnName(IndexUtil.getIndexColumnName(col));
+ allPkColumns.add(new Pair<ColumnName, SortOrder>(colName, pair.getSecond()));
+ columnDefs.add(FACTORY.columnDef(colName, dataType.getSqlTypeName(), col.isNullable(), col.getMaxLength(), col.getScale(), false, SortOrder.getDefault()));
+ }
}
// Next all the PK columns from the data table that aren't indexed
if (!unusedPkColumns.isEmpty()) {
for (PColumn col : unusedPkColumns) {
- ColumnName colName = ColumnName.caseSensitiveColumnName(IndexUtil.getIndexColumnName(col));
- allPkColumns.add(new Pair<ColumnName, SortOrder>(colName, col.getSortOrder()));
- PDataType dataType = IndexUtil.getIndexColumnDataType(col);
- columnDefs.add(FACTORY.columnDef(colName, dataType.getSqlTypeName(), col.isNullable(), col.getMaxLength(), col.getScale(), false, col.getSortOrder()));
+ // Don't add columns with constant values from updatable views, as
+ // we don't need these in the index
+ if (!isUpdatableView || col.getViewConstant() == null) {
+ ColumnName colName = ColumnName.caseSensitiveColumnName(IndexUtil.getIndexColumnName(col));
+ allPkColumns.add(new Pair<ColumnName, SortOrder>(colName, col.getSortOrder()));
+ PDataType dataType = IndexUtil.getIndexColumnDataType(col);
+ columnDefs.add(FACTORY.columnDef(colName, dataType.getSqlTypeName(), col.isNullable(), col.getMaxLength(), col.getScale(), false, col.getSortOrder()));
+ }
}
}
pk = FACTORY.primaryKey(null, allPkColumns);
@@ -544,7 +596,7 @@ public class MetaDataClient {
if (pk.contains(colName)) {
throw new SQLExceptionInfo.Builder(SQLExceptionCode.COLUMN_EXIST_IN_DEF).build().buildException();
}
- if (!SchemaUtil.isPKColumn(col)) {
+ if (!SchemaUtil.isPKColumn(col) && (!isUpdatableView || col.getViewConstant() == null)) {
// Need to re-create ColumnName, since the above one won't have the column family name
colName = ColumnName.caseSensitiveColumnName(col.getFamilyName().getString(), IndexUtil.getIndexColumnName(col));
columnDefs.add(FACTORY.columnDef(colName, col.getDataType().getSqlTypeName(), col.isNullable(), col.getMaxLength(), col.getScale(), false, col.getSortOrder()));
@@ -553,11 +605,12 @@ public class MetaDataClient {
}
// Set DEFAULT_COLUMN_FAMILY_NAME of index to match data table
+ // We need this in the props so that the correct column family is created
if (dataTable.getDefaultFamilyName() != null && dataTable.getType() != PTableType.VIEW) {
statement.getProps().put("", new Pair<String,Object>(DEFAULT_COLUMN_FAMILY_NAME,dataTable.getDefaultFamilyName().getString()));
}
CreateTableStatement tableStatement = FACTORY.createTable(indexTableName, statement.getProps(), columnDefs, pk, statement.getSplitNodes(), PTableType.INDEX, statement.ifNotExists(), null, null, statement.getBindCount());
- table = createTableInternal(tableStatement, splits, dataTable, null, null); // TODO: tenant-specific index
+ table = createTableInternal(tableStatement, splits, dataTable, null, null, EMPTY_VIEW_CONSTANTS);
break;
} catch (ConcurrentTableMutationException e) { // Can happen if parent data table changes while above is in progress
if (retry) {
@@ -599,13 +652,15 @@ public class MetaDataClient {
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();
+ return createSequence(tenantId, statement.getSequenceName().getSchemaName(), statement.getSequenceName().getTableName(), statement.ifNotExists(), startWith, incrementBy, cacheSize, timestamp);
+ }
+
+ private MutationState createSequence(String tenantId, String schemaName, String sequenceName, boolean ifNotExists, long startWith, long incrementBy, int cacheSize, long timestamp) throws SQLException {
try {
connection.getQueryServices().createSequence(tenantId, schemaName, sequenceName, startWith, incrementBy, cacheSize, timestamp);
} catch (SequenceAlreadyExistsException e) {
- if (statement.ifNotExists()) {
+ if (ifNotExists) {
return new MutationState(0, connection);
}
throw e;
@@ -622,7 +677,7 @@ public class MetaDataClient {
return null;
}
- private PTable createTableInternal(CreateTableStatement statement, byte[][] splits, final PTable parent, String viewStatement, ViewType viewType) throws SQLException {
+ private PTable createTableInternal(CreateTableStatement statement, byte[][] splits, final PTable parent, String viewStatement, ViewType viewType, byte[][] viewColumnConstants) throws SQLException {
final PTableType tableType = statement.getTableType();
boolean wasAutoCommit = connection.getAutoCommit();
connection.rollback();
@@ -634,9 +689,49 @@ public class MetaDataClient {
String schemaName = tableNameNode.getSchemaName();
String tableName = tableNameNode.getTableName();
String parentTableName = null;
- String tenantId = connection.getTenantId() == null ? null : connection.getTenantId().getString();
+ Long scn = connection.getSCN();
+ long timestamp = scn == null ? HConstants.LATEST_TIMESTAMP : scn;
+ PName tenantId = connection.getTenantId();
+ String tenantIdStr = tenantId == null ? null : connection.getTenantId().getString();
boolean isParentImmutableRows = false;
+ Short viewIndexId = null;
+ boolean multiTenant = false;
+ Integer saltBucketNum = null;
+ String defaultFamilyName = null;
+ boolean isImmutableRows = false;
+ List<PName> physicalNames = Collections.emptyList();
if (parent != null && tableType == PTableType.INDEX) {
+ // Index on view
+ // TODO: Can we support a multi-tenant index directly on a multi-tenant
+ // table instead of only a view? We don't have anywhere to put the link
+ // from the table to the index, though.
+ if (parent.getType() == PTableType.VIEW && parent.getViewType() != ViewType.MAPPED) {
+ PName physicalName = parent.getPhysicalName();
+ SequenceKey key = MetaDataUtil.getViewIndexSequenceKey(tenantIdStr, physicalName);
+ // Create at parent timestamp as we know that will be earlier than now
+ // and earlier than any SCN if one is set.
+ // TODO: If sequence already exists, then we don't need to ensure metadata is already created.
+ // Set physicalName to null in this case?
+ createSequence(key.getTenantId(), key.getSchemaName(), key.getSequenceName(), true, Short.MIN_VALUE, 1, 1, parent.getTimeStamp());
+ long[] seqValues = new long[1];
+ SQLException[] sqlExceptions = new SQLException[1];
+ connection.getQueryServices().incrementSequenceValues(Collections.singletonList(key), timestamp, seqValues, sqlExceptions);
+ if (sqlExceptions[0] != null) {
+ throw sqlExceptions[0];
+ }
+ long seqValue = seqValues[0];
+ if (seqValue > Short.MAX_VALUE) {
+ throw new SQLExceptionInfo.Builder(SQLExceptionCode.TOO_MANY_VIEW_INDEXES)
+ .setSchemaName(SchemaUtil.getSchemaNameFromFullName(physicalName.getString())).setTableName(SchemaUtil.getTableNameFromFullName(physicalName.getString())).build().buildException();
+ }
+ viewIndexId = (short) seqValue;
+ saltBucketNum = parent.getBucketNum();
+ defaultFamilyName = parent.getDefaultFamilyName() == null ? null : parent.getDefaultFamilyName().getString();
+ // Set physical name of view index table
+ physicalNames = Collections.singletonList(PNameFactory.newName(MetaDataUtil.getViewIndexPhysicalName(physicalName.getBytes())));
+ }
+
+ multiTenant = parent.isMultiTenant();
isParentImmutableRows = parent.isImmutableRows();
parentTableName = parent.getTableName().getString();
// Pass through data table sequence number so we can check it hasn't changed
@@ -689,10 +784,6 @@ public class MetaDataClient {
}
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're managing the index maintenance yourself.
if (tableType != PTableType.VIEW || viewType == ViewType.MAPPED) {
@@ -704,7 +795,8 @@ public class MetaDataClient {
}
}
- if (tableType != PTableType.VIEW) {
+ // Can't set any of these on views or shared indexes on views
+ if (tableType != PTableType.VIEW && viewIndexId == null) {
saltBucketNum = (Integer) tableProps.remove(PhoenixDatabaseMetaData.SALT_BUCKETS);
if (saltBucketNum != null && (saltBucketNum < 0 || saltBucketNum > SaltingUtil.MAX_BUCKET_NUM)) {
throw new SQLExceptionInfo.Builder(SQLExceptionCode.INVALID_BUCKET_NUM).build().buildException();
@@ -719,11 +811,13 @@ public class MetaDataClient {
}
isSalted = (saltBucketNum != null);
- Boolean multiTenantProp = (Boolean) tableProps.remove(PhoenixDatabaseMetaData.MULTI_TENANT);
- multiTenant = Boolean.TRUE.equals(multiTenantProp);
-
- // Don't remove this prop, as we need it when we create the HBase metadata
- defaultFamilyName = (String)tableProps.get(PhoenixDatabaseMetaData.DEFAULT_COLUMN_FAMILY_NAME);
+ // Can't set MULTI_TENANT or DEFAULT_COLUMN_FAMILY_NAME on an index
+ if (tableType != PTableType.INDEX) {
+ Boolean multiTenantProp = (Boolean) tableProps.remove(PhoenixDatabaseMetaData.MULTI_TENANT);
+ multiTenant = Boolean.TRUE.equals(multiTenantProp);
+ // Don't remove this prop, as we need it when we create the HBase metadata
+ defaultFamilyName = (String)tableProps.get(PhoenixDatabaseMetaData.DEFAULT_COLUMN_FAMILY_NAME);
+ }
}
boolean disableWAL = false;
@@ -734,7 +828,7 @@ public class MetaDataClient {
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()) {
+ if ((statement.getTableType() == PTableType.VIEW || viewIndexId != null) && !tableProps.isEmpty()) {
throw new SQLExceptionInfo.Builder(SQLExceptionCode.VIEW_WITH_PROPERTIES).build().buildException();
}
@@ -742,12 +836,11 @@ public class MetaDataClient {
List<PColumn> columns;
LinkedHashSet<PColumn> pkColumns;
- if (tenantId != null && tableType != PTableType.VIEW) {
+ if (tenantId != null && (tableType != PTableType.VIEW && viewIndexId == null)) {
throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_CREATE_TENANT_SPECIFIC_TABLE)
.setSchemaName(schemaName).setTableName(tableName).build().buildException();
}
- List<PName> physicalNames = Collections.emptyList();
if (tableType == PTableType.VIEW) {
physicalNames = Collections.singletonList(PNameFactory.newName(parent.getPhysicalName().getString()));
if (viewType == ViewType.MAPPED) {
@@ -764,22 +857,26 @@ public class MetaDataClient {
columns = newArrayListWithExpectedSize(parent.getColumns().size() + colDefs.size());
columns.addAll(parent.getColumns());
pkColumns = newLinkedHashSet(parent.getPKColumns());
-
- // Add row linking from data table row to physical table row
- PreparedStatement linkStatement = connection.prepareStatement(CREATE_LINK);
- for (PName physicalName : physicalNames) {
- linkStatement.setString(1, connection.getTenantId() == null ? null : connection.getTenantId().getString());
- linkStatement.setString(2, schemaName);
- linkStatement.setString(3, tableName);
- linkStatement.setString(4, physicalName.getString());
- linkStatement.setByte(5, LinkType.PHYSICAL_TABLE.getSerializedValue());
- linkStatement.execute();
- }
}
} else {
columns = newArrayListWithExpectedSize(colDefs.size());
pkColumns = newLinkedHashSetWithExpectedSize(colDefs.size() + 1); // in case salted
}
+
+ // Don't add link for mapped view, as it just points back to itself and causes the drop to
+ // fail because it looks like there's always a view associated with it.
+ if (viewType != ViewType.MAPPED && !physicalNames.isEmpty()) {
+ // Add row linking from data table row to physical table row
+ PreparedStatement linkStatement = connection.prepareStatement(CREATE_LINK);
+ for (PName physicalName : physicalNames) {
+ linkStatement.setString(1, connection.getTenantId() == null ? null : connection.getTenantId().getString());
+ linkStatement.setString(2, schemaName);
+ linkStatement.setString(3, tableName);
+ linkStatement.setString(4, physicalName.getString());
+ linkStatement.setByte(5, LinkType.PHYSICAL_TABLE.getSerializedValue());
+ linkStatement.execute();
+ }
+ }
PreparedStatement colUpsert = connection.prepareStatement(INSERT_COLUMN);
Map<String, PName> familyNames = Maps.newLinkedHashMap();
@@ -911,13 +1008,13 @@ public class MetaDataClient {
// 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,
- Collections.<PName>emptyList(), defaultFamilyName == null ? null : PNameFactory.newName(defaultFamilyName),
- null, Boolean.TRUE.equals(disableWAL), false, null);
+ PTable table = PTableImpl.makePTable(tenantId,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, Collections.<PName>emptyList(),
+ defaultFamilyName == null ? null : PNameFactory.newName(defaultFamilyName), null, Boolean.TRUE.equals(disableWAL), false, null, viewIndexId);
connection.addTable(table);
- } else if (tableType == PTableType.INDEX) {
+ } else if (tableType == PTableType.INDEX && viewIndexId == null) {
if (tableProps.get(HTableDescriptor.MAX_FILESIZE) == null) {
int nIndexRowKeyColumns = isPK ? 1 : pkColumnsNames.size();
int nIndexKeyValueColumns = columns.size() - nIndexRowKeyColumns;
@@ -941,7 +1038,19 @@ public class MetaDataClient {
}
}
- for (PColumn column : columns) {
+ for (int i = 0; i < columns.size(); i++) {
+ PColumn column = columns.get(i);
+ int columnPosition = column.getPosition();
+ final byte[] viewConstant = columnPosition < viewColumnConstants.length ? viewColumnConstants[columnPosition] : null;
+ // For client-side cache, we need to update the column
+ if (viewConstant != null) {
+ columns.set(i, column = new DelegateColumn(column) {
+ @Override
+ public byte[] getViewConstant() {
+ return viewConstant;
+ }
+ });
+ }
addColumnMutation(schemaName, tableName, column, colUpsert, parentTableName);
}
@@ -951,7 +1060,7 @@ public class MetaDataClient {
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(1, tenantIdStr);
tableUpsert.setString(2, schemaName);
tableUpsert.setString(3, tableName);
tableUpsert.setString(4, tableType.getSerializedValue());
@@ -975,6 +1084,11 @@ public class MetaDataClient {
} else {
tableUpsert.setByte(16, viewType.getSerializedValue());
}
+ if (viewIndexId == null) {
+ tableUpsert.setNull(17, Types.SMALLINT);
+ } else {
+ tableUpsert.setShort(17, viewIndexId);
+ }
tableUpsert.execute();
tableMetaData.addAll(connection.getMutationState().toMutations().next().getSecond());
@@ -992,7 +1106,7 @@ public class MetaDataClient {
QueryServices.ROW_KEY_ORDER_SALTED_TABLE_ATTRIB, QueryServicesOptions.DEFAULT_ROW_KEY_ORDER_SALTED_TABLE));
MetaDataMutationResult result = connection.getQueryServices().createTable(
tableMetaData,
- viewType == ViewType.MAPPED ? physicalNames.get(0).getBytes() : null,
+ viewType == ViewType.MAPPED || viewIndexId != null ? physicalNames.get(0).getBytes() : null,
tableType, tableProps, familyPropList, splits);
MutationCode code = result.getMutationCode();
switch(code) {
@@ -1014,11 +1128,10 @@ public class MetaDataClient {
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, physicalNames,
- defaultFamilyName == null ? null : PNameFactory.newName(defaultFamilyName),
- viewStatement, Boolean.TRUE.equals(disableWAL), multiTenant, viewType);
+ tenantId, 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, physicalNames,
+ defaultFamilyName == null ? null : PNameFactory.newName(defaultFamilyName), viewStatement, Boolean.TRUE.equals(disableWAL), multiTenant, viewType, viewIndexId);
connection.addTable(table);
return table;
}
@@ -1067,8 +1180,11 @@ public class MetaDataClient {
if (isSalted) {
iterator.next();
}
+ // Tenant ID must be VARCHAR or CHAR and be NOT NULL
+ // NOT NULL is a requirement, since otherwise the table key would conflict
+ // potentially with the global table definition.
PColumn tenantIdCol = iterator.next();
- if (!tenantIdCol.getDataType().isCoercibleTo(VARCHAR)) {
+ if (!tenantIdCol.getDataType().isCoercibleTo(VARCHAR) || tenantIdCol.isNullable()) {
throw new SQLExceptionInfo.Builder(INSUFFICIENT_MULTI_TENANT_COLUMNS).setSchemaName(schemaName).setTableName(tableName).build().buildException();
}
}
@@ -1124,22 +1240,36 @@ public class MetaDataClient {
connection.removeTable(tableName);
} catch (TableNotFoundException ignore) { } // Ignore - just means wasn't cached
+ // TODO: we need to drop the index data when a view is dropped
boolean dropMetaData = connection.getQueryServices().getProps().getBoolean(DROP_METADATA_ATTRIB, DEFAULT_DROP_METADATA);
- if (result.getTable() != null && tableType != PTableType.VIEW && !dropMetaData) {
+ if (result.getTable() != null && tableType != PTableType.VIEW) {
connection.setAutoCommit(true);
- // Delete everything in the column. You'll still be able to do queries at earlier timestamps
+ PTable table = result.getTable();
long ts = (scn == null ? result.getMutationTime() : scn);
// Create empty table and schema - they're only used to get the name from
// PName name, PTableType type, long timeStamp, long sequenceNumber, List<PColumn> columns
- PTable table = result.getTable();
- List<TableRef> tableRefs = Lists.newArrayListWithExpectedSize(1 + table.getIndexes().size());
- tableRefs.add(new TableRef(null, table, ts, false));
- // TODO: Let the standard mutable secondary index maintenance handle this?
- for (PTable index: table.getIndexes()) {
- tableRefs.add(new TableRef(null, index, ts, false));
+ List<TableRef> tableRefs = Lists.newArrayListWithExpectedSize(2 + table.getIndexes().size());
+ if (tableType == PTableType.TABLE && MetaDataUtil.hasViewIndexTable(connection, table.getPhysicalName())) {
+ MetaDataUtil.deleteViewIndexSequences(connection, table.getPhysicalName());
+ // TODO: consider removing this, as the DROP INDEX done for each DROP VIEW command
+ // would have deleted all the rows already
+ if (!dropMetaData) {
+ String viewIndexSchemaName = MetaDataUtil.getViewIndexSchemaName(schemaName);
+ String viewIndexTableName = MetaDataUtil.getViewIndexTableName(tableName);
+ PTable viewIndexTable = new PTableImpl(null, viewIndexSchemaName, viewIndexTableName, ts, table.getColumnFamilies());
+ tableRefs.add(new TableRef(null, viewIndexTable, ts, false));
+ }
+ }
+ if (!dropMetaData) {
+ // Delete everything in the column. You'll still be able to do queries at earlier timestamps
+ tableRefs.add(new TableRef(null, table, ts, false));
+ // TODO: Let the standard mutable secondary index maintenance handle this?
+ for (PTable index: table.getIndexes()) {
+ tableRefs.add(new TableRef(null, index, ts, false));
+ }
+ MutationPlan plan = new PostDDLCompiler(connection).compile(tableRefs, null, null, Collections.<PColumn>emptyList(), ts);
+ return connection.getQueryServices().updateData(plan);
}
- MutationPlan plan = new PostDDLCompiler(connection).compile(tableRefs, null, null, Collections.<PColumn>emptyList(), ts);
- return connection.getQueryServices().updateData(plan);
}
break;
}
@@ -1156,8 +1286,17 @@ public class MetaDataClient {
connection.removeTable(tableName);
throw new TableNotFoundException(schemaName, tableName);
case UNALLOWED_TABLE_MUTATION:
+ String columnName = null;
+ String familyName = null;
+ String msg = null;
+ // TODO: better to return error code
+ if (result.getColumnName() != null) {
+ familyName = result.getFamilyName() == null ? null : Bytes.toString(result.getFamilyName());
+ columnName = Bytes.toString(result.getColumnName());
+ msg = "Cannot drop column referenced by VIEW";
+ }
throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_MUTATE_TABLE)
- .setSchemaName(schemaName).setTableName(tableName).build().buildException();
+ .setSchemaName(schemaName).setTableName(tableName).setFamilyName(familyName).setColumnName(columnName).setMessage(msg).build().buildException();
case COLUMN_ALREADY_EXISTS:
case COLUMN_NOT_FOUND:
break;
@@ -1185,30 +1324,52 @@ public class MetaDataClient {
}
private long incrementTableSeqNum(PTable table, PTableType expectedType, int columnCountDelta) throws SQLException {
- return incrementTableSeqNum(table, expectedType, table.isImmutableRows(), table.isWALDisabled(), table.isMultiTenant(), columnCountDelta);
+ return incrementTableSeqNum(table, expectedType, columnCountDelta, null, null, null);
}
- private long incrementTableSeqNum(PTable table, PTableType expectedType, boolean isImmutableRows, boolean disableWAL, boolean isMultiTenant, int columnCountDelta) throws SQLException {
+ private long incrementTableSeqNum(PTable table, PTableType expectedType, int columnCountDelta, Boolean isImmutableRows, Boolean disableWAL, Boolean isMultiTenant) throws SQLException {
String schemaName = table.getSchemaName().getString();
String tableName = table.getTableName().getString();
// Ordinal position is 1-based and we don't count SALT column in ordinal position
int totalColumnCount = table.getColumns().size() + (table.getBucketNum() == null ? 0 : -1);
final long seqNum = table.getSequenceNumber() + 1;
PreparedStatement tableUpsert = connection.prepareStatement(MUTATE_TABLE);
+ String tenantId = connection.getTenantId() == null ? null : connection.getTenantId().getString();
try {
- tableUpsert.setString(1, connection.getTenantId() == null ? null : connection.getTenantId().getString());
+ tableUpsert.setString(1, tenantId);
tableUpsert.setString(2, schemaName);
tableUpsert.setString(3, tableName);
tableUpsert.setString(4, expectedType.getSerializedValue());
tableUpsert.setLong(5, seqNum);
tableUpsert.setInt(6, totalColumnCount + columnCountDelta);
- tableUpsert.setBoolean(7, isImmutableRows);
- tableUpsert.setBoolean(8, disableWAL);
- tableUpsert.setBoolean(9, isMultiTenant);
tableUpsert.execute();
} finally {
tableUpsert.close();
}
+ if (isImmutableRows != null) {
+ PreparedStatement tableBoolUpsert = connection.prepareStatement(MUTATE_IMMUTABLE_ROWS);
+ tableBoolUpsert.setString(1, tenantId);
+ tableBoolUpsert.setString(2, schemaName);
+ tableBoolUpsert.setString(3, tableName);
+ tableBoolUpsert.setBoolean(4, isImmutableRows);
+ tableBoolUpsert.execute();
+ }
+ if (disableWAL != null) {
+ PreparedStatement tableBoolUpsert = connection.prepareStatement(MUTATE_DISABLE_WAL);
+ tableBoolUpsert.setString(1, tenantId);
+ tableBoolUpsert.setString(2, schemaName);
+ tableBoolUpsert.setString(3, tableName);
+ tableBoolUpsert.setBoolean(4, disableWAL);
+ tableBoolUpsert.execute();
+ }
+ if (isMultiTenant != null) {
+ PreparedStatement tableBoolUpsert = connection.prepareStatement(MUTATE_MULTI_TENANT);
+ tableBoolUpsert.setString(1, tenantId);
+ tableBoolUpsert.setString(2, schemaName);
+ tableBoolUpsert.setString(3, tableName);
+ tableBoolUpsert.setBoolean(4, isMultiTenant);
+ tableBoolUpsert.execute();
+ }
return seqNum;
}
@@ -1223,7 +1384,7 @@ public class MetaDataClient {
// Outside of retry loop, as we're removing the property and wouldn't find it the second time
Boolean isImmutableRowsProp = (Boolean)statement.getProps().remove(PTable.IS_IMMUTABLE_ROWS_PROP_NAME);
Boolean multiTenantProp = (Boolean)statement.getProps().remove(PhoenixDatabaseMetaData.MULTI_TENANT);
- boolean disableWAL = Boolean.TRUE.equals(statement.getProps().remove(DISABLE_WAL));
+ Boolean disableWALProp = (Boolean)statement.getProps().remove(DISABLE_WAL);
boolean retried = false;
while (true) {
@@ -1249,13 +1410,23 @@ public class MetaDataClient {
.setColumnName(lastPK.getName().getString()).build().buildException();
}
- boolean isImmutableRows = table.isImmutableRows();
+ Boolean isImmutableRows = null;
if (isImmutableRowsProp != null) {
- isImmutableRows = isImmutableRowsProp;
+ if (isImmutableRowsProp.booleanValue() != table.isImmutableRows()) {
+ isImmutableRows = isImmutableRowsProp;
+ }
}
- boolean multiTenant = table.isMultiTenant();
+ Boolean multiTenant = null;
if (multiTenantProp != null) {
- multiTenant = Boolean.TRUE.equals(multiTenantProp);
+ if (multiTenantProp.booleanValue() != table.isMultiTenant()) {
+ multiTenant = multiTenantProp;
+ }
+ }
+ Boolean disableWAL = null;
+ if (disableWALProp != null) {
+ if (disableWALProp.booleanValue() != table.isWALDisabled()) {
+ disableWAL = isImmutableRowsProp;
+ }
}
if (statement.getProps().get(PhoenixDatabaseMetaData.SALT_BUCKETS) != null) {
@@ -1279,6 +1450,14 @@ public class MetaDataClient {
List<PColumn> columns = Lists.newArrayListWithExpectedSize(columnDefs.size());
if ( columnDefs.size() > 0 ) {
+ // Disallow setting these props for now on an add column, as that
+ // would a bit of a strange thing to do. We can revisit later if
+ // need be. We'd need to do the error checking we do in the else
+ // if we want to support this.
+ if (isImmutableRowsProp != null || multiTenantProp != null) {
+ throw new SQLExceptionInfo.Builder(SQLExceptionCode.SET_UNSUPPORTED_PROP_ON_ALTER_TABLE)
+ .setTableName(table.getName().getString()).build().buildException();
+ }
for( ColumnDef colDef : columnDefs) {
if (colDef != null && !colDef.isNull()) {
if(colDef.isPK()) {
@@ -1322,7 +1501,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 (isImmutableRowsProp != null && !isImmutableRows && table.isImmutableRows() && !table.getIndexes().isEmpty()) {
+ if (Boolean.FALSE.equals(isImmutableRows) && !table.getIndexes().isEmpty()) {
int hbaseVersion = connection.getQueryServices().getLowestClusterHBaseVersion();
if (hbaseVersion < PhoenixDatabaseMetaData.MUTABLE_SI_VERSION_THRESHOLD) {
throw new SQLExceptionInfo.Builder(SQLExceptionCode.NO_MUTABLE_INDEXES).setSchemaName(schemaName).setTableName(tableName).build().buildException();
@@ -1331,7 +1510,9 @@ public class MetaDataClient {
throw new SQLExceptionInfo.Builder(SQLExceptionCode.INVALID_MUTABLE_INDEX_CONFIG).setSchemaName(schemaName).setTableName(tableName).build().buildException();
}
}
- // TODO: if switching table to multiTenant or multiType, do some error checking
+ if (Boolean.TRUE.equals(multiTenant)) {
+ throwIfInsufficientColumns(schemaName, tableName, table.getPKColumns(), table.getBucketNum()!=null, multiTenant);
+ }
}
if (isAddingPKColumn && !table.getIndexes().isEmpty()) {
@@ -1341,7 +1522,7 @@ public class MetaDataClient {
tableMetaData.addAll(connection.getMutationState().toMutations().next().getSecond());
connection.rollback();
}
- long seqNum = incrementTableSeqNum(table, statement.getTableType(), isImmutableRows, disableWAL, multiTenant, 1);
+ long seqNum = incrementTableSeqNum(table, statement.getTableType(), 1, isImmutableRows, disableWAL, multiTenant);
tableMetaData.addAll(connection.getMutationState().toMutations().next().getSecond());
connection.rollback();
@@ -1351,7 +1532,6 @@ public class MetaDataClient {
Pair<byte[],Map<String,Object>> family = families.size() > 0 ? families.get(0) : null;
// Figure out if the empty column family is changing as a result of adding the new column
- // The empty column family of an index will never change as a result of adding a new data column
byte[] emptyCF = null;
byte[] projectCF = null;
if (table.getType() != PTableType.VIEW && family != null) {
@@ -1366,7 +1546,7 @@ public class MetaDataClient {
}
}
}
- MetaDataMutationResult result = connection.getQueryServices().addColumn(tableMetaData, statement.getTableType(), families);
+ MetaDataMutationResult result = connection.getQueryServices().addColumn(tableMetaData, families, table);
try {
MutationCode code = processMutationResult(schemaName, tableName, result);
if (code == MutationCode.COLUMN_ALREADY_EXISTS) {
@@ -1379,7 +1559,31 @@ public class MetaDataClient {
// Only update client side cache if we aren't adding a PK column to a table with indexes.
// We could update the cache manually then too, it'd just be a pain.
if (!isAddingPKColumn || table.getIndexes().isEmpty()) {
- connection.addColumn(SchemaUtil.getTableName(schemaName, tableName), columns, result.getMutationTime(), seqNum, isImmutableRows);
+ connection.addColumn(SchemaUtil.getTableName(schemaName, tableName), columns, result.getMutationTime(), seqNum, isImmutableRows == null ? table.isImmutableRows() : isImmutableRows);
+ }
+ // 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)
+ && MetaDataUtil.hasViewIndexTable(connection, table.getPhysicalName())) {
+ connection.setAutoCommit(true);
+ MetaDataUtil.deleteViewIndexSequences(connection, table.getPhysicalName());
+ // If we're not dropping metadata, then make sure no rows are left in
+ // our view index physical table.
+ // TODO: remove this, as the DROP INDEX commands run when the DROP VIEW
+ // commands are run would remove all rows already.
+ if (!connection.getQueryServices().getProps().getBoolean(DROP_METADATA_ATTRIB, DEFAULT_DROP_METADATA)) {
+ Long scn = connection.getSCN();
+ long ts = (scn == null ? result.getMutationTime() : scn);
+ String viewIndexSchemaName = MetaDataUtil.getViewIndexSchemaName(schemaName);
+ String viewIndexTableName = MetaDataUtil.getViewIndexTableName(tableName);
+ PTable viewIndexTable = new PTableImpl(null, viewIndexSchemaName, viewIndexTableName, ts,
+ table.getColumnFamilies());
+ List<TableRef> tableRefs = Collections.singletonList(new TableRef(null, viewIndexTable, ts, false));
+ MutationPlan plan = new PostDDLCompiler(connection).compile(tableRefs, null, null,
+ Collections.<PColumn> emptyList(), ts);
+ connection.getQueryServices().updateData(plan);
+ }
}
if (emptyCF != null) {
Long scn = connection.getSCN();
@@ -1573,7 +1777,7 @@ public class MetaDataClient {
Collections.<Mutation>singletonList(new Put(SchemaUtil.getTableKey
(tenantIdBytes, tableContainingColumnToDrop.getSchemaName().getBytes(),
tableContainingColumnToDrop.getTableName().getBytes()))),
- tableContainingColumnToDrop.getType(),family);
+ family,tableContainingColumnToDrop);
}
}
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/schema/PColumn.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/schema/PColumn.java b/phoenix-core/src/main/java/org/apache/phoenix/schema/PColumn.java
index 4cca8c5..a2d8718 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/schema/PColumn.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/schema/PColumn.java
@@ -46,4 +46,6 @@ public interface PColumn extends PDatum, Writable {
* @return the declared array size or zero if this is not an array
*/
Integer getArraySize();
+
+ byte[] getViewConstant();
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/schema/PColumnImpl.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/schema/PColumnImpl.java b/phoenix-core/src/main/java/org/apache/phoenix/schema/PColumnImpl.java
index dc1ab6a..081e37e 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/schema/PColumnImpl.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/schema/PColumnImpl.java
@@ -42,6 +42,7 @@ public class PColumnImpl implements PColumn {
private int position;
private SortOrder sortOrder;
private Integer arraySize;
+ private byte[] viewConstant;
public PColumnImpl() {
}
@@ -53,13 +54,13 @@ public class PColumnImpl implements PColumn {
Integer scale,
boolean nullable,
int position,
- SortOrder sortOrder, Integer arrSize) {
- init(name, familyName, dataType, maxLength, scale, nullable, position, sortOrder, arrSize);
+ SortOrder sortOrder, Integer arrSize, byte[] viewConstant) {
+ init(name, familyName, dataType, maxLength, scale, nullable, position, sortOrder, arrSize, viewConstant);
}
public PColumnImpl(PColumn column, int position) {
this(column.getName(), column.getFamilyName(), column.getDataType(), column.getMaxLength(),
- column.getScale(), column.isNullable(), position, column.getSortOrder(), column.getArraySize());
+ column.getScale(), column.isNullable(), position, column.getSortOrder(), column.getArraySize(), column.getViewConstant());
}
private void init(PName name,
@@ -70,7 +71,8 @@ public class PColumnImpl implements PColumn {
boolean nullable,
int position,
SortOrder sortOrder,
- Integer arrSize) {
+ Integer arrSize,
+ byte[] viewConstant) {
Preconditions.checkNotNull(sortOrder);
this.dataType = dataType;
if (familyName == null) {
@@ -90,6 +92,7 @@ public class PColumnImpl implements PColumn {
this.position = position;
this.sortOrder = sortOrder;
this.arraySize = arrSize;
+ this.viewConstant = viewConstant;
}
@Override
@@ -156,10 +159,16 @@ public class PColumnImpl implements PColumn {
int scale = WritableUtils.readVInt(input);
boolean nullable = input.readBoolean();
int position = WritableUtils.readVInt(input);
+ boolean hasViewConstant = (position < 0);
+ position = Math.abs(position)-1;
+ byte[] viewConstant = null;
+ if (hasViewConstant) {
+ viewConstant = Bytes.readByteArray(input);
+ }
SortOrder sortOrder = SortOrder.fromSystemValue(WritableUtils.readVInt(input));
int arrSize = WritableUtils.readVInt(input);
init(columnName, familyName, dataType, maxLength == NO_MAXLENGTH ? null : maxLength,
- scale == NO_SCALE ? null : scale, nullable, position, sortOrder, arrSize == -1 ? null : arrSize);
+ scale == NO_SCALE ? null : scale, nullable, position, sortOrder, arrSize == -1 ? null : arrSize, viewConstant);
}
@Override
@@ -170,7 +179,11 @@ public class PColumnImpl implements PColumn {
WritableUtils.writeVInt(output, maxLength == null ? NO_MAXLENGTH : maxLength);
WritableUtils.writeVInt(output, scale == null ? NO_SCALE : scale);
output.writeBoolean(nullable);
- WritableUtils.writeVInt(output, position);
+ boolean hasViewConstant = (viewConstant != null);
+ WritableUtils.writeVInt(output, (position+1) * (hasViewConstant ? -1 : 1));
+ if (hasViewConstant) {
+ Bytes.writeByteArray(output, viewConstant);
+ }
WritableUtils.writeVInt(output, sortOrder.getSystemValue());
WritableUtils.writeVInt(output, arraySize == null ? -1 : arraySize);
}
@@ -203,4 +216,9 @@ public class PColumnImpl implements PColumn {
public Integer getArraySize() {
return arraySize;
}
+
+ @Override
+ public byte[] getViewConstant() {
+ return viewConstant;
+ }
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/schema/PDataType.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/schema/PDataType.java b/phoenix-core/src/main/java/org/apache/phoenix/schema/PDataType.java
index 61f7d68..81f2119 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/schema/PDataType.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/schema/PDataType.java
@@ -6623,6 +6623,15 @@ public enum PDataType {
public abstract boolean isFixedWidth();
public abstract Integer getByteSize();
+ /*
+ * We need an empty byte array to mean null, since
+ * we have no other representation in the row key
+ * for null.
+ */
+ public final boolean isNull(byte[] value) {
+ return value == null || value.length == 0;
+ }
+
public abstract byte[] toBytes(Object object);
public byte[] toBytes(Object object, SortOrder sortOrder) {
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/schema/PMetaDataImpl.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/schema/PMetaDataImpl.java b/phoenix-core/src/main/java/org/apache/phoenix/schema/PMetaDataImpl.java
index e20a893..3423873 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/schema/PMetaDataImpl.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/schema/PMetaDataImpl.java
@@ -132,7 +132,7 @@ public class PMetaDataImpl implements PMetaData {
// Update position of columns that follow removed column
for (int i = position+1; i < oldColumns.size(); i++) {
PColumn oldColumn = oldColumns.get(i);
- PColumn newColumn = new PColumnImpl(oldColumn.getName(), oldColumn.getFamilyName(), oldColumn.getDataType(), oldColumn.getMaxLength(), oldColumn.getScale(), oldColumn.isNullable(), i-1+positionOffset, oldColumn.getSortOrder(), oldColumn.getArraySize());
+ PColumn newColumn = new PColumnImpl(oldColumn.getName(), oldColumn.getFamilyName(), oldColumn.getDataType(), oldColumn.getMaxLength(), oldColumn.getScale(), oldColumn.isNullable(), i-1+positionOffset, oldColumn.getSortOrder(), oldColumn.getArraySize(), oldColumn.getViewConstant());
columns.add(newColumn);
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/schema/PTable.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/schema/PTable.java b/phoenix-core/src/main/java/org/apache/phoenix/schema/PTable.java
index da5af1c..d76a116 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/schema/PTable.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/schema/PTable.java
@@ -122,7 +122,8 @@ public interface PTable extends Writable {
*/
PName getName();
PName getSchemaName();
- PName getTableName();
+ PName getTableName();
+ PName getTenantId();
/**
* @return the table type
@@ -275,4 +276,5 @@ public interface PTable extends Writable {
ViewType getViewType();
String getViewStatement();
+ Short getViewIndexId();
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/schema/PTableImpl.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/schema/PTableImpl.java b/phoenix-core/src/main/java/org/apache/phoenix/schema/PTableImpl.java
index ee95f46..8425809 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/schema/PTableImpl.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/schema/PTableImpl.java
@@ -78,6 +78,7 @@ public class PTableImpl implements PTable {
private PName name;
private PName schemaName;
private PName tableName;
+ private PName tenantId;
private PTableType type;
private PIndexState state;
private long sequenceNumber;
@@ -108,15 +109,13 @@ public class PTableImpl implements PTable {
private boolean disableWAL;
private boolean multiTenant;
private ViewType viewType;
+ private Short viewIndexId;
public PTableImpl() {
}
- public PTableImpl(PName name) { // For finding table ref
- this.name = name;
- }
-
- public PTableImpl(String schemaName, String tableName, long timestamp, List<PColumnFamily> families) { // For base table of mapped VIEW
+ public PTableImpl(PName tenantId, String schemaName, String tableName, long timestamp, List<PColumnFamily> families) { // For base table of mapped VIEW
+ this.tenantId = tenantId;
this.name = PNameFactory.newName(SchemaUtil.getTableName(schemaName, tableName));
this.schemaName = PNameFactory.newName(schemaName);
this.tableName = PNameFactory.newName(tableName);
@@ -133,6 +132,7 @@ public class PTableImpl implements PTable {
familyByString.put(family.getName().getString(), family);
}
this.families = families;
+ this.physicalNames = Collections.emptyList();;
}
public PTableImpl(long timeStamp) { // For delete marker
@@ -153,6 +153,7 @@ public class PTableImpl implements PTable {
this.familyByString = Collections.emptyMap();
this.rowKeySchema = RowKeySchema.EMPTY_SCHEMA;
this.indexes = Collections.emptyList();
+ this.physicalNames = Collections.emptyList();;
}
// When cloning table, ignore the salt column as it will be added back in the constructor
@@ -162,52 +163,52 @@ public class PTableImpl implements PTable {
public static PTableImpl makePTable(PTable table, long timeStamp, List<PTable> indexes) throws SQLException {
return new PTableImpl(
- table.getSchemaName(), table.getTableName(), table.getType(), table.getIndexState(), timeStamp, table.getSequenceNumber() + 1,
- table.getPKName(), table.getBucketNum(), getColumnsToClone(table), table.getParentTableName(), indexes, table.isImmutableRows(),
- table.getPhysicalNames(), table.getDefaultFamilyName(), table.getViewStatement(), table.isWALDisabled(), table.isMultiTenant(), table.getViewType());
+ table.getTenantId(), table.getSchemaName(), table.getTableName(), table.getType(), table.getIndexState(), timeStamp,
+ table.getSequenceNumber() + 1, table.getPKName(), table.getBucketNum(), getColumnsToClone(table), table.getParentTableName(), indexes,
+ table.isImmutableRows(), table.getPhysicalNames(), table.getDefaultFamilyName(), table.getViewStatement(), table.isWALDisabled(), table.isMultiTenant(), table.getViewType(), table.getViewIndexId());
}
public static PTableImpl makePTable(PTable table, List<PColumn> columns) throws SQLException {
return new PTableImpl(
- table.getSchemaName(), table.getTableName(), table.getType(), table.getIndexState(), table.getTimeStamp(), table.getSequenceNumber(),
- table.getPKName(), table.getBucketNum(), columns, table.getParentTableName(), table.getIndexes(), table.isImmutableRows(), table.getPhysicalNames(),
- table.getDefaultFamilyName(), table.getViewStatement(), table.isWALDisabled(), table.isMultiTenant(), table.getViewType());
+ table.getTenantId(), table.getSchemaName(), table.getTableName(), table.getType(), table.getIndexState(), table.getTimeStamp(),
+ table.getSequenceNumber(), table.getPKName(), table.getBucketNum(), columns, table.getParentTableName(), table.getIndexes(), table.isImmutableRows(),
+ table.getPhysicalNames(), table.getDefaultFamilyName(), table.getViewStatement(), table.isWALDisabled(), table.isMultiTenant(), table.getViewType(), table.getViewIndexId());
}
public static PTableImpl makePTable(PTable table, long timeStamp, long sequenceNumber, List<PColumn> columns) throws SQLException {
return new PTableImpl(
- table.getSchemaName(), table.getTableName(), table.getType(), table.getIndexState(), timeStamp, sequenceNumber,
- table.getPKName(), table.getBucketNum(), columns, table.getParentTableName(), table.getIndexes(), table.isImmutableRows(), table.getPhysicalNames(),
- table.getDefaultFamilyName(), table.getViewStatement(), table.isWALDisabled(), table.isMultiTenant(), table.getViewType());
+ table.getTenantId(), table.getSchemaName(), table.getTableName(), table.getType(), table.getIndexState(), timeStamp,
+ sequenceNumber, table.getPKName(), table.getBucketNum(), columns, table.getParentTableName(), table.getIndexes(), table.isImmutableRows(),
+ table.getPhysicalNames(), table.getDefaultFamilyName(), table.getViewStatement(), table.isWALDisabled(), table.isMultiTenant(), table.getViewType(), table.getViewIndexId());
}
public static PTableImpl makePTable(PTable table, long timeStamp, long sequenceNumber, List<PColumn> columns, boolean isImmutableRows) throws SQLException {
return new PTableImpl(
- table.getSchemaName(), table.getTableName(), table.getType(), table.getIndexState(), timeStamp, sequenceNumber,
- table.getPKName(), table.getBucketNum(), columns, table.getParentTableName(), table.getIndexes(), isImmutableRows,
- table.getPhysicalNames(), table.getDefaultFamilyName(), table.getViewStatement(), table.isWALDisabled(), table.isMultiTenant(), table.getViewType());
+ table.getTenantId(), table.getSchemaName(), table.getTableName(), table.getType(), table.getIndexState(), timeStamp,
+ sequenceNumber, table.getPKName(), table.getBucketNum(), columns, table.getParentTableName(), table.getIndexes(),
+ isImmutableRows, table.getPhysicalNames(), table.getDefaultFamilyName(), table.getViewStatement(), table.isWALDisabled(), table.isMultiTenant(), table.getViewType(), table.getViewIndexId());
}
public static PTableImpl makePTable(PTable table, PIndexState state) throws SQLException {
return new PTableImpl(
- table.getSchemaName(), table.getTableName(), table.getType(), state, table.getTimeStamp(), table.getSequenceNumber(),
- table.getPKName(), table.getBucketNum(), getColumnsToClone(table), table.getParentTableName(),
- table.getIndexes(), table.isImmutableRows(), table.getPhysicalNames(),
- table.getDefaultFamilyName(), table.getViewStatement(), table.isWALDisabled(), table.isMultiTenant(), table.getViewType());
+ table.getTenantId(), table.getSchemaName(), table.getTableName(), table.getType(), state, table.getTimeStamp(),
+ table.getSequenceNumber(), table.getPKName(), table.getBucketNum(), getColumnsToClone(table),
+ table.getParentTableName(), table.getIndexes(), table.isImmutableRows(),
+ table.getPhysicalNames(), table.getDefaultFamilyName(), table.getViewStatement(), table.isWALDisabled(), table.isMultiTenant(), table.getViewType(), table.getViewIndexId());
}
- public static PTableImpl makePTable(PName schemaName, PName tableName, PTableType type, PIndexState state, long timeStamp, long sequenceNumber, PName pkName,
- Integer bucketNum, List<PColumn> columns, PName dataTableName, List<PTable> indexes, boolean isImmutableRows, List<PName> physicalNames,
- PName defaultFamilyName, String viewExpression, boolean disableWAL, boolean multiTenant, ViewType viewType) throws SQLException {
- return new PTableImpl(schemaName, tableName, type, state, timeStamp, sequenceNumber, pkName, bucketNum, columns, dataTableName, indexes,
- isImmutableRows, physicalNames, defaultFamilyName, viewExpression, disableWAL, multiTenant, viewType);
+ public static PTableImpl makePTable(PName tenantId, PName schemaName, PName tableName, PTableType type, PIndexState state, long timeStamp, long sequenceNumber,
+ PName pkName, Integer bucketNum, List<PColumn> columns, PName dataTableName, List<PTable> indexes, boolean isImmutableRows,
+ List<PName> physicalNames, PName defaultFamilyName, String viewExpression, boolean disableWAL, boolean multiTenant, ViewType viewType, Short viewIndexId) throws SQLException {
+ return new PTableImpl(tenantId, schemaName, tableName, type, state, timeStamp, sequenceNumber, pkName, bucketNum, columns, dataTableName,
+ indexes, isImmutableRows, physicalNames, defaultFamilyName, viewExpression, disableWAL, multiTenant, viewType, viewIndexId);
}
- private PTableImpl(PName schemaName, PName tableName, PTableType type, PIndexState state, long timeStamp, long sequenceNumber, PName pkName,
- Integer bucketNum, List<PColumn> columns, PName dataTableName, List<PTable> indexes, boolean isImmutableRows, List<PName> physicalNames,
- PName defaultFamilyName, String viewExpression, boolean disableWAL, boolean multiTenant, ViewType viewType) throws SQLException {
- init(schemaName, tableName, type, state, timeStamp, sequenceNumber, pkName, bucketNum, columns, new PTableStatsImpl(),
- dataTableName, indexes, isImmutableRows, physicalNames, defaultFamilyName, viewExpression, disableWAL, multiTenant, viewType);
+ private PTableImpl(PName tenantId, PName schemaName, PName tableName, PTableType type, PIndexState state, long timeStamp, long sequenceNumber,
+ PName pkName, Integer bucketNum, List<PColumn> columns, PName dataTableName, List<PTable> indexes, boolean isImmutableRows,
+ List<PName> physicalNames, PName defaultFamilyName, String viewExpression, boolean disableWAL, boolean multiTenant, ViewType viewType, Short viewIndexId) throws SQLException {
+ init(tenantId, schemaName, tableName, type, state, timeStamp, sequenceNumber, pkName, bucketNum, columns,
+ new PTableStatsImpl(), dataTableName, indexes, isImmutableRows, physicalNames, defaultFamilyName, viewExpression, disableWAL, multiTenant, viewType, viewIndexId);
}
@Override
@@ -220,9 +221,9 @@ public class PTableImpl implements PTable {
return viewType;
}
- private void init(PName schemaName, PName tableName, PTableType type, PIndexState state, long timeStamp, long sequenceNumber, PName pkName,
- Integer bucketNum, List<PColumn> columns, PTableStats stats, PName parentTableName, List<PTable> indexes, boolean isImmutableRows,
- List<PName> physicalNames, PName defaultFamilyName, String viewExpression, boolean disableWAL, boolean multiTenant, ViewType viewType) throws SQLException {
+ private void init(PName tenantId, PName schemaName, PName tableName, PTableType type, PIndexState state, long timeStamp, long sequenceNumber,
+ PName pkName, Integer bucketNum, List<PColumn> columns, PTableStats stats, PName parentTableName, List<PTable> indexes,
+ boolean isImmutableRows, List<PName> physicalNames, PName defaultFamilyName, String viewExpression, boolean disableWAL, boolean multiTenant, ViewType viewType, Short viewIndexId) throws SQLException {
if (schemaName == null) {
throw new NullPointerException();
}
@@ -240,6 +241,7 @@ public class PTableImpl implements PTable {
this.disableWAL = disableWAL;
this.multiTenant = multiTenant;
this.viewType = viewType;
+ this.viewIndexId = viewIndexId;
List<PColumn> pkColumns;
PColumn[] allColumns;
@@ -567,7 +569,7 @@ public class PTableImpl implements PTable {
byte[] qualifier = column.getName().getBytes();
PDataType type = column.getDataType();
// Check null, since some types have no byte representation for null
- if (byteValue == null || byteValue.length == 0) {
+ if (type.isNull(byteValue)) {
if (!column.isNullable()) {
throw new ConstraintViolationException(name.getString() + "." + column.getName().getString() + " may not be null");
}
@@ -643,15 +645,22 @@ public class PTableImpl implements PTable {
@Override
public void readFields(DataInput input) throws IOException {
+ byte[] tenantIdBytes = Bytes.readByteArray(input);
byte[] schemaNameBytes = Bytes.readByteArray(input);
byte[] tableNameBytes = Bytes.readByteArray(input);
+ PName tenantId = tenantIdBytes.length == 0 ? null : PNameFactory.newName(tenantIdBytes);
PName schemaName = PNameFactory.newName(schemaNameBytes);
PName tableName = PNameFactory.newName(tableNameBytes);
PTableType tableType = PTableType.values()[WritableUtils.readVInt(input)];
PIndexState indexState = null;
+ Short viewIndexId = null;
if (tableType == PTableType.INDEX) {
int ordinal = WritableUtils.readVInt(input);
- if (ordinal >= 0) {
+ if (ordinal < 0) {
+ viewIndexId = input.readShort();
+ }
+ ordinal = Math.abs(ordinal) - 1;
+ if (ordinal < PIndexState.values().length) {
indexState = PIndexState.values()[ordinal];
}
}
@@ -699,6 +708,8 @@ public class PTableImpl implements PTable {
viewType = ViewType.fromSerializedValue(input.readByte());
byte[] viewStatementBytes = Bytes.readByteArray(input);
viewStatement = viewStatementBytes.length == 0 ? null : (String)PDataType.VARCHAR.toObject(viewStatementBytes);
+ }
+ if (tableType == PTableType.VIEW || viewIndexId != null) {
int nPhysicalNames = WritableUtils.readVInt(input);
physicalNames = Lists.newArrayListWithExpectedSize(nPhysicalNames);
for (int i = 0; i < nPhysicalNames; i++) {
@@ -708,10 +719,10 @@ public class PTableImpl implements PTable {
}
PTableStats stats = new PTableStatsImpl(guidePosts);
try {
- init(schemaName, tableName, tableType, indexState, timeStamp, sequenceNumber, pkName,
- bucketNum.equals(NO_SALTING) ? null : bucketNum, columns, stats, dataTableName,
- indexes, isImmutableRows, physicalNames, defaultFamilyName,
- viewStatement, disableWAL, multiTenant, viewType);
+ init(tenantId, schemaName, tableName, tableType, indexState, timeStamp, sequenceNumber,
+ pkName, bucketNum.equals(NO_SALTING) ? null : bucketNum, columns, stats,
+ dataTableName, indexes, isImmutableRows, physicalNames,
+ defaultFamilyName, viewStatement, disableWAL, multiTenant, viewType, viewIndexId);
} catch (SQLException e) {
throw new RuntimeException(e); // Impossible
}
@@ -719,11 +730,15 @@ public class PTableImpl implements PTable {
@Override
public void write(DataOutput output) throws IOException {
+ Bytes.writeByteArray(output, tenantId == null ? ByteUtil.EMPTY_BYTE_ARRAY : tenantId.getBytes());
Bytes.writeByteArray(output, schemaName.getBytes());
Bytes.writeByteArray(output, tableName.getBytes());
WritableUtils.writeVInt(output, type.ordinal());
if (type == PTableType.INDEX) {
- WritableUtils.writeVInt(output, state == null ? -1 : state.ordinal());
+ WritableUtils.writeVInt(output, (((state == null ? PIndexState.values().length : state.ordinal()) + 1) * (viewIndexId == null ? 1 : -1)));
+ if (viewIndexId != null) {
+ output.writeShort(viewIndexId);
+ }
}
WritableUtils.writeVLong(output, sequenceNumber);
output.writeLong(timeStamp);
@@ -754,6 +769,8 @@ public class PTableImpl implements PTable {
if (type == PTableType.VIEW) {
output.writeByte(viewType.getSerializedValue());
Bytes.writeByteArray(output, viewStatement == null ? ByteUtil.EMPTY_BYTE_ARRAY : PDataType.VARCHAR.toBytes(viewStatement));
+ }
+ if (type == PTableType.VIEW || viewIndexId != null) {
WritableUtils.writeVInt(output, physicalNames.size());
for (int i = 0; i < physicalNames.size(); i++) {
Bytes.writeByteArray(output, physicalNames.get(i).getBytes());
@@ -860,4 +877,14 @@ public class PTableImpl implements PTable {
public boolean isWALDisabled() {
return disableWAL;
}
+
+ @Override
+ public Short getViewIndexId() {
+ return viewIndexId;
+ }
+
+ @Override
+ public PName getTenantId() {
+ return tenantId;
+ }
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/schema/SaltingUtil.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/schema/SaltingUtil.java b/phoenix-core/src/main/java/org/apache/phoenix/schema/SaltingUtil.java
index 74cbaee..4cf9ff1 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/schema/SaltingUtil.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/schema/SaltingUtil.java
@@ -36,7 +36,7 @@ public class SaltingUtil {
public static final String SALTING_COLUMN_NAME = "_SALT";
public static final String SALTED_ROW_KEY_NAME = "_SALTED_KEY";
public static final PColumnImpl SALTING_COLUMN = new PColumnImpl(
- PNameFactory.newName(SALTING_COLUMN_NAME), null, PDataType.BINARY, 1, 0, false, 0, SortOrder.getDefault(), 0);
+ PNameFactory.newName(SALTING_COLUMN_NAME), null, PDataType.BINARY, 1, 0, false, 0, SortOrder.getDefault(), 0, null);
public static final RowKeySchema VAR_BINARY_SALTED_SCHEMA = new RowKeySchemaBuilder(1)
.addField(SALTING_COLUMN, false, SortOrder.getDefault())
.addField(SchemaUtil.VAR_BINARY_DATUM, false, SortOrder.getDefault()).build();
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/schema/TableAlreadyExistsException.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/schema/TableAlreadyExistsException.java b/phoenix-core/src/main/java/org/apache/phoenix/schema/TableAlreadyExistsException.java
index 48ff40a..466b4a4 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/schema/TableAlreadyExistsException.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/schema/TableAlreadyExistsException.java
@@ -37,7 +37,11 @@ public class TableAlreadyExistsException extends SQLException {
private final String tableName;
public TableAlreadyExistsException(String schemaName, String tableName) {
- super(new SQLExceptionInfo.Builder(code).setSchemaName(schemaName).setTableName(tableName).build().toString(),
+ this(schemaName, tableName, null);
+ }
+
+ public TableAlreadyExistsException(String schemaName, String tableName, String msg) {
+ super(new SQLExceptionInfo.Builder(code).setSchemaName(schemaName).setTableName(tableName).setMessage(msg).build().toString(),
code.getSQLState(), code.getErrorCode());
this.schemaName = schemaName;
this.tableName = tableName;
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/util/MetaDataUtil.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/util/MetaDataUtil.java b/phoenix-core/src/main/java/org/apache/phoenix/util/MetaDataUtil.java
index 09684cb..9ae2558 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/util/MetaDataUtil.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/util/MetaDataUtil.java
@@ -19,23 +19,34 @@ package org.apache.phoenix.util;
import static org.apache.phoenix.util.SchemaUtil.getVarChars;
+import java.sql.SQLException;
import java.util.Collection;
import java.util.List;
+import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.client.Mutation;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.phoenix.coprocessor.MetaDataProtocol;
+import org.apache.phoenix.jdbc.PhoenixConnection;
import org.apache.phoenix.jdbc.PhoenixDatabaseMetaData;
import org.apache.phoenix.query.QueryConstants;
import org.apache.phoenix.schema.PDataType;
+import org.apache.phoenix.schema.PName;
import org.apache.phoenix.schema.PTableType;
+import org.apache.phoenix.schema.SequenceKey;
import org.apache.phoenix.schema.SortOrder;
+import org.apache.phoenix.schema.TableNotFoundException;
public class MetaDataUtil {
-
+ public static final String VIEW_INDEX_TABLE_PREFIX = "_IDX_";
+ public static final byte[] VIEW_INDEX_TABLE_PREFIX_BYTES = Bytes.toBytes(VIEW_INDEX_TABLE_PREFIX);
+ public static final String VIEW_INDEX_SEQUENCE_PREFIX = "_SEQ_";
+ public static final byte[] VIEW_INDEX_SEQUENCE_PREFIX_BYTES = Bytes.toBytes(VIEW_INDEX_SEQUENCE_PREFIX);
+ public static final String VIEW_INDEX_ID_COLUMN_NAME = "_INDEX_ID";
+
public static boolean areClientAndServerCompatible(long version) {
// A server and client with the same major and minor version number must be compatible.
// So it's important that we roll the PHOENIX_MAJOR_VERSION or PHOENIX_MINOR_VERSION
@@ -184,7 +195,7 @@ public class MetaDataUtil {
return kv == null ? ByteUtil.EMPTY_BYTE_ARRAY : kv.getValue();
}
- private static KeyValue getMutationKeyValue(Mutation headerRow, byte[] key) {
+ public static KeyValue getMutationKeyValue(Mutation headerRow, byte[] key) {
List<KeyValue> kvs = headerRow.getFamilyMap().get(PhoenixDatabaseMetaData.TABLE_FAMILY_BYTES);
if (kvs != null) {
for (KeyValue kv : kvs) {
@@ -229,4 +240,63 @@ public class MetaDataUtil {
public static byte[] getParentLinkKey(byte[] tenantId, byte[] schemaName, byte[] tableName, byte[] indexName) {
return ByteUtil.concat(tenantId == null ? ByteUtil.EMPTY_BYTE_ARRAY : tenantId, QueryConstants.SEPARATOR_BYTE_ARRAY, schemaName == null ? ByteUtil.EMPTY_BYTE_ARRAY : schemaName, QueryConstants.SEPARATOR_BYTE_ARRAY, tableName, QueryConstants.SEPARATOR_BYTE_ARRAY, QueryConstants.SEPARATOR_BYTE_ARRAY, indexName);
}
+
+ public static boolean isMultiTenant(Mutation m) {
+ return Boolean.TRUE.equals(PDataType.BOOLEAN.toObject(MetaDataUtil.getMutationKVByteValue(m, PhoenixDatabaseMetaData.MULTI_TENANT_BYTES)));
+ }
+
+ public static boolean isSalted(Mutation m) {
+ return MetaDataUtil.getMutationKeyValue(m, PhoenixDatabaseMetaData.SALT_BUCKETS_BYTES) != null;
+ }
+
+ public static byte[] getViewIndexPhysicalName(byte[] physicalTableName) {
+ return ByteUtil.concat(VIEW_INDEX_TABLE_PREFIX_BYTES, physicalTableName);
+ }
+
+ public static String getViewIndexTableName(String tableName) {
+ return VIEW_INDEX_TABLE_PREFIX + tableName;
+ }
+
+ public static String getViewIndexSchemaName(String schemaName) {
+ return schemaName;
+ }
+
+ public static SequenceKey getViewIndexSequenceKey(String tenantId, PName physicalName) {
+ // Create global sequence of the form: <prefixed base table name><tenant id>
+ // rather than tenant-specific sequence, as it makes it much easier
+ // to cleanup when the physical table is dropped, as we can delete
+ // all global sequences leading with <prefix> + physical name.
+ String schemaName = VIEW_INDEX_SEQUENCE_PREFIX + physicalName.getString();
+ String tableName = tenantId == null ? "" : tenantId;
+ return new SequenceKey(null, schemaName, tableName);
+ }
+
+ public static PDataType getViewIndexIdDataType() {
+ return PDataType.SMALLINT;
+ }
+
+ public static String getViewIndexIdColumnName() {
+ return VIEW_INDEX_ID_COLUMN_NAME;
+ }
+
+ public static boolean hasViewIndexTable(PhoenixConnection connection, PName name) throws SQLException {
+ byte[] physicalIndexName = MetaDataUtil.getViewIndexPhysicalName(name.getBytes());
+ try {
+ HTableDescriptor desc = connection.getQueryServices().getTableDescriptor(physicalIndexName);
+ return desc != null && Boolean.TRUE.equals(PDataType.BOOLEAN.toObject(desc.getValue(IS_VIEW_INDEX_TABLE_PROP_BYTES)));
+ } catch (TableNotFoundException e) {
+ return false;
+ }
+ }
+
+ public static void deleteViewIndexSequences(PhoenixConnection connection, PName name) throws SQLException {
+ SequenceKey key = getViewIndexSequenceKey(null, name);
+ connection.createStatement().executeUpdate("DELETE FROM " + PhoenixDatabaseMetaData.SEQUENCE_TABLE_NAME +
+ " WHERE " + PhoenixDatabaseMetaData.TENANT_ID + " IS NULL AND " +
+ PhoenixDatabaseMetaData.SEQUENCE_SCHEMA + " = '" + key.getSchemaName() + "'");
+
+ }
+
+ public static final String IS_VIEW_INDEX_TABLE_PROP_NAME = "IS_VIEW_INDEX_TABLE";
+ public static final byte[] IS_VIEW_INDEX_TABLE_PROP_BYTES = Bytes.toBytes(IS_VIEW_INDEX_TABLE_PROP_NAME);
}
[3/4] PHOENIX-21: Support indexes on multi-tenant views. Still needs
more testing
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/optimize/QueryOptimizer.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/optimize/QueryOptimizer.java b/phoenix-core/src/main/java/org/apache/phoenix/optimize/QueryOptimizer.java
index 26009ca..0d72c87 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/optimize/QueryOptimizer.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/optimize/QueryOptimizer.java
@@ -43,6 +43,7 @@ import org.apache.phoenix.schema.PColumn;
import org.apache.phoenix.schema.PDatum;
import org.apache.phoenix.schema.PIndexState;
import org.apache.phoenix.schema.PTable;
+import org.apache.phoenix.schema.PTable.ViewType;
import org.apache.phoenix.schema.PTableType;
import com.google.common.collect.Lists;
@@ -85,7 +86,7 @@ public class QueryOptimizer {
}
PTable dataTable = dataPlan.getTableRef().getTable();
List<PTable>indexes = Lists.newArrayList(dataTable.getIndexes());
- if (indexes.isEmpty() || dataPlan.getTableRef().hasDynamicCols() || select.getHint().hasHint(Hint.NO_INDEX)) {
+ if (indexes.isEmpty() || dataPlan.isDegenerate() || dataPlan.getTableRef().hasDynamicCols() || select.getHint().hasHint(Hint.NO_INDEX)) {
return dataPlan;
}
@@ -110,7 +111,14 @@ public class QueryOptimizer {
return hintedPlan;
}
for (PTable index : indexes) {
- addPlan(statement, translatedIndexSelect, index, targetColumns, parallelIteratorFactory, plans);
+ QueryPlan plan = addPlan(statement, translatedIndexSelect, index, targetColumns, parallelIteratorFactory, dataPlan);
+ if (plan != null) {
+ // Query can't possibly return anything so just return this plan.
+ if (plan.isDegenerate()) {
+ return plan;
+ }
+ plans.add(plan);
+ }
}
return chooseBestPlan(select, plans);
@@ -151,8 +159,9 @@ public class QueryOptimizer {
int indexPos = getIndexPosition(indexes, indexName);
if (indexPos >= 0) {
// Hinted index is applicable, so return it. It'll be the plan at position 1, after the data plan
- if (addPlan(statement, select, indexes.get(indexPos), targetColumns, parallelIteratorFactory, plans)) {
- return plans.get(1);
+ QueryPlan plan = addPlan(statement, select, indexes.get(indexPos), targetColumns, parallelIteratorFactory, dataPlan);
+ if (plan != null) {
+ return plan;
}
indexes.remove(indexPos);
}
@@ -171,8 +180,7 @@ public class QueryOptimizer {
return -1;
}
- private static boolean addPlan(PhoenixStatement statement, SelectStatement select, PTable index, List<? extends PDatum> targetColumns, ParallelIteratorFactory parallelIteratorFactory, List<QueryPlan> plans) throws SQLException {
- QueryPlan dataPlan = plans.get(0);
+ private static QueryPlan addPlan(PhoenixStatement statement, SelectStatement select, PTable index, List<? extends PDatum> targetColumns, ParallelIteratorFactory parallelIteratorFactory, QueryPlan dataPlan) throws SQLException {
int nColumns = dataPlan.getProjector().getColumnCount();
String alias = '"' + dataPlan.getTableRef().getTableAlias() + '"'; // double quote in case it's case sensitive
String schemaName = dataPlan.getTableRef().getTable().getSchemaName().getString();
@@ -183,13 +191,15 @@ public class QueryOptimizer {
try {
SelectStatement indexSelect = FACTORY.select(select, tables);
ColumnResolver resolver = FromCompiler.getResolver(indexSelect, statement.getConnection());
- QueryCompiler compiler = new QueryCompiler(statement, indexSelect, resolver, targetColumns, parallelIteratorFactory);
- QueryPlan plan = compiler.compile();
- // Checking the index status and number of columns handles the wildcard cases correctly
- // We can't check the status earlier, because the index table may be out-of-date.
- if (plan.getTableRef().getTable().getIndexState() == PIndexState.ACTIVE && plan.getProjector().getColumnCount() == nColumns) {
- plans.add(plan);
- return true;
+ // Check index state of now potentially updated index table to make sure it's active
+ if (PIndexState.ACTIVE.equals(resolver.getTables().get(0).getTable().getIndexState())) {
+ QueryCompiler compiler = new QueryCompiler(statement, indexSelect, resolver, targetColumns, parallelIteratorFactory);
+ QueryPlan plan = compiler.compile();
+ // Checking number of columns handles the wildcard cases correctly, as in that case the index
+ // must contain all columns from the data table to be able to be used.
+ if (plan.getTableRef().getTable().getIndexState() == PIndexState.ACTIVE && plan.getProjector().getColumnCount() == nColumns) {
+ return plan;
+ }
}
} catch (ColumnNotFoundException e) {
/* Means that a column is being used that's not in our index.
@@ -198,7 +208,7 @@ public class QueryOptimizer {
* the index table to the data table.
*/
}
- return false;
+ return null;
}
/**
@@ -215,9 +225,9 @@ public class QueryOptimizer {
* @return
*/
private QueryPlan chooseBestPlan(SelectStatement select, List<QueryPlan> plans) {
- QueryPlan firstPlan = plans.get(0);
+ final QueryPlan dataPlan = plans.get(0);
if (plans.size() == 1) {
- return firstPlan;
+ return dataPlan;
}
/**
@@ -253,12 +263,31 @@ public class QueryOptimizer {
if (bestCandidates.isEmpty()) {
bestCandidates.addAll(stillCandidates);
}
+
+ int nViewConstants = 0;
+ PTable dataTable = dataPlan.getTableRef().getTable();
+ if (dataTable.getViewType() == ViewType.UPDATABLE) {
+ for (PColumn column : dataTable.getColumns()) {
+ if (column.getViewConstant() != null) {
+ nViewConstants++;
+ }
+ }
+ }
+ final int boundRanges = nViewConstants;
final int comparisonOfDataVersusIndexTable = select.getHint().hasHint(Hint.USE_DATA_OVER_INDEX_TABLE) ? -1 : 1;
Collections.sort(bestCandidates, new Comparator<QueryPlan>() {
@Override
public int compare(QueryPlan plan1, QueryPlan plan2) {
+ PTable table1 = plan1.getTableRef().getTable();
+ PTable table2 = plan2.getTableRef().getTable();
int c = plan2.getContext().getScanRanges().getRanges().size() - plan1.getContext().getScanRanges().getRanges().size();
+ // Account for potential view constants which are always bound
+ if (plan1 == dataPlan) { // plan2 is index plan. Ignore the viewIndexId if present
+ c += boundRanges - (table2.getViewIndexId() == null ? 0 : 1);
+ } else { // plan1 is index plan. Ignore the viewIndexId if present
+ c -= boundRanges - (table1.getViewIndexId() == null ? 0 : 1);
+ }
if (c != 0) return c;
if (plan1.getGroupBy()!=null && plan2.getGroupBy()!=null) {
if (plan1.getGroupBy().isOrderPreserving() != plan2.getGroupBy().isOrderPreserving()) {
@@ -266,8 +295,6 @@ public class QueryOptimizer {
}
}
// Use smaller table (table with fewest kv columns)
- PTable table1 = plan1.getTableRef().getTable();
- PTable table2 = plan2.getTableRef().getTable();
c = (table1.getColumns().size() - table1.getPKColumns().size()) - (table2.getColumns().size() - table2.getPKColumns().size());
if (c != 0) return c;
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/parse/CreateSequenceStatement.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/parse/CreateSequenceStatement.java b/phoenix-core/src/main/java/org/apache/phoenix/parse/CreateSequenceStatement.java
index 325554b..44d5f34 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/parse/CreateSequenceStatement.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/parse/CreateSequenceStatement.java
@@ -19,6 +19,10 @@ package org.apache.phoenix.parse;
public class CreateSequenceStatement extends MutableStatement {
+ public static CreateSequenceStatement create(TableName sequenceName) {
+ return new CreateSequenceStatement(sequenceName, null, null, null, true, 0);
+ }
+
private final TableName sequenceName;
private final ParseNode startWith;
private final ParseNode incrementBy;
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/parse/LiteralParseNode.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/parse/LiteralParseNode.java b/phoenix-core/src/main/java/org/apache/phoenix/parse/LiteralParseNode.java
index 4636caf..f9bbea1 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/parse/LiteralParseNode.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/parse/LiteralParseNode.java
@@ -48,6 +48,13 @@ public class LiteralParseNode extends TerminalParseNode {
this.value = this.type == null ? null : this.type.toObject(value, this.type);
}
+ public LiteralParseNode(Object value, PDataType type) {
+ this.type = type;
+ // This will make the value null if the value passed through represents null for the given type.
+ // For example, an empty string is treated as a null.
+ this.value = this.type == null ? null : this.type.toObject(value, this.type);
+ }
+
public PDataType getType() {
return type;
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/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 a2e8eaa..192db11 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
@@ -34,6 +34,7 @@ import org.apache.phoenix.compile.MutationPlan;
import org.apache.phoenix.coprocessor.MetaDataProtocol.MetaDataMutationResult;
import org.apache.phoenix.execute.MutationState;
import org.apache.phoenix.jdbc.PhoenixConnection;
+import org.apache.phoenix.schema.PTable;
import org.apache.phoenix.schema.PTableType;
import org.apache.phoenix.schema.SequenceKey;
@@ -67,7 +68,7 @@ public interface ConnectionQueryServices extends QueryServices, MetaDataMutated
public MetaDataMutationResult getTable(byte[] tenantId, byte[] schemaName, byte[] tableName, long tableTimestamp, long clientTimetamp) throws SQLException;
public MetaDataMutationResult createTable(List<Mutation> tableMetaData, byte[] tableName, PTableType tableType, Map<String,Object> tableProps, List<Pair<byte[],Map<String,Object>>> families, byte[][] splits) throws SQLException;
public MetaDataMutationResult dropTable(List<Mutation> tableMetadata, PTableType tableType) throws SQLException;
- public MetaDataMutationResult addColumn(List<Mutation> tableMetaData, PTableType tableType, List<Pair<byte[],Map<String,Object>>> families) throws SQLException;
+ public MetaDataMutationResult addColumn(List<Mutation> tableMetaData, List<Pair<byte[],Map<String,Object>>> families, PTable table) throws SQLException;
public MetaDataMutationResult dropColumn(List<Mutation> tableMetadata, PTableType tableType) throws SQLException;
public MetaDataMutationResult updateIndexState(List<Mutation> tableMetadata, String parentTableName) throws SQLException;
public MutationState updateData(MutationPlan plan) throws SQLException;
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/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 8b73e49..02e3f2b 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
@@ -38,6 +38,7 @@ import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HConstants;
import org.apache.hadoop.hbase.HRegionLocation;
import org.apache.hadoop.hbase.HTableDescriptor;
+import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.TableExistsException;
import org.apache.hadoop.hbase.ZooKeeperConnectionException;
import org.apache.hadoop.hbase.client.Append;
@@ -80,13 +81,17 @@ import org.apache.phoenix.schema.EmptySequenceCacheException;
import org.apache.phoenix.schema.MetaDataSplitPolicy;
import org.apache.phoenix.schema.NewerTableAlreadyExistsException;
import org.apache.phoenix.schema.PColumn;
+import org.apache.phoenix.schema.PColumnFamily;
+import org.apache.phoenix.schema.PDataType;
import org.apache.phoenix.schema.PMetaData;
import org.apache.phoenix.schema.PMetaDataImpl;
import org.apache.phoenix.schema.PTable;
import org.apache.phoenix.schema.PTableType;
import org.apache.phoenix.schema.ReadOnlyTableException;
+import org.apache.phoenix.schema.SaltingUtil;
import org.apache.phoenix.schema.Sequence;
import org.apache.phoenix.schema.SequenceKey;
+import org.apache.phoenix.schema.TableAlreadyExistsException;
import org.apache.phoenix.schema.TableNotFoundException;
import org.apache.phoenix.util.ByteUtil;
import org.apache.phoenix.util.JDBCUtil;
@@ -275,6 +280,9 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement
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;
@@ -522,7 +530,7 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement
if (tableType == PTableType.VIEW) {
String fullTableName = Bytes.toString(tableName);
throw new ReadOnlyTableException(
- "The HBase column families for a read-only table must already exist",
+ "The HBase column families for a VIEW must already exist",
SchemaUtil.getSchemaNameFromFullName(fullTableName),
SchemaUtil.getTableNameFromFullName(fullTableName),
Bytes.toString(family.getFirst()));
@@ -530,9 +538,11 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement
columnDescriptor = generateColumnFamilyDescriptor(family, tableType );
} else {
columnDescriptor = new HColumnDescriptor(oldDescriptor);
- if (tableType != PTableType.VIEW) {
- modifyColumnFamilyDescriptor(columnDescriptor, family);
+ // Don't attempt to make any metadata changes for a VIEW
+ if (tableType == PTableType.VIEW) {
+ return;
}
+ modifyColumnFamilyDescriptor(columnDescriptor, family);
}
if (columnDescriptor.equals(oldDescriptor)) {
@@ -573,12 +583,13 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement
/**
*
* @param tableName
- * @param familyNames
* @param splits
+ * @param modifyExistingMetaData TODO
+ * @param familyNames
* @return true if table was created and false if it already exists
* @throws SQLException
*/
- private boolean ensureTableCreated(byte[] tableName, PTableType tableType , Map<String,Object> props, List<Pair<byte[],Map<String,Object>>> families, byte[][] splits) 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;
@@ -618,7 +629,7 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement
} catch (TableExistsException e) {
// We can ignore this, as it just means that another client beat us
// to creating the HBase metadata.
- return false;
+ return null;
}
if (isMetaTable) {
checkClientServerCompatibility();
@@ -633,14 +644,14 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement
admin.modifyTable(tableName, newDesc);
admin.enableTable(tableName);
}
- return true;
+ return null;
} else {
- if (existingDesc.equals(newDesc)) {
+ if (!modifyExistingMetaData || existingDesc.equals(newDesc)) {
// Table is already created. Note that the presplits are ignored in this case
if (isMetaTable) {
checkClientServerCompatibility();
}
- return false;
+ return existingDesc;
}
if (isMetaTable) {
@@ -656,7 +667,7 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement
// TODO: What if not all existing column families are present?
admin.modifyTable(tableName, newDesc);
admin.enableTable(tableName);
- return false;
+ return newDesc;
}
} catch (IOException e) {
@@ -678,7 +689,7 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement
}
}
}
- return true; // will never make it here
+ return null; // will never make it here
}
private static boolean isInvalidMutableIndexConfig(Long serverVersion) {
@@ -786,22 +797,95 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement
}
}
+ private void ensureViewIndexTableCreated(byte[] physicalTableName, Map<String,Object> tableProps, List<Pair<byte[],Map<String,Object>>> families, byte[][] splits, long timestamp) throws SQLException {
+ Long maxFileSize = (Long)tableProps.get(HTableDescriptor.MAX_FILESIZE);
+ if (maxFileSize == null) {
+ maxFileSize = this.config.getLong(HConstants.HREGION_MAX_FILESIZE, HConstants.DEFAULT_MAX_FILE_SIZE);
+ }
+ byte[] physicalIndexName = MetaDataUtil.getViewIndexPhysicalName(physicalTableName);
+
+ int indexMaxFileSizePerc;
+ // Get percentage to use from table props first and then fallback to config
+ Integer indexMaxFileSizePercProp = (Integer)tableProps.remove(QueryServices.INDEX_MAX_FILESIZE_PERC_ATTRIB);
+ if (indexMaxFileSizePercProp == null) {
+ indexMaxFileSizePerc = config.getInt(QueryServices.INDEX_MAX_FILESIZE_PERC_ATTRIB, QueryServicesOptions.DEFAULT_INDEX_MAX_FILESIZE_PERC);
+ } else {
+ indexMaxFileSizePerc = indexMaxFileSizePercProp;
+ }
+ long indexMaxFileSize = maxFileSize * indexMaxFileSizePerc / 100;
+ tableProps.put(HTableDescriptor.MAX_FILESIZE, indexMaxFileSize);
+ tableProps.put(MetaDataUtil.IS_VIEW_INDEX_TABLE_PROP_NAME, PDataType.TRUE_BYTES);
+ // Only use splits if table is salted, otherwise it may not be applicable
+ HTableDescriptor desc = ensureTableCreated(physicalIndexName, PTableType.TABLE, tableProps, families, splits, false);
+ if (desc != null) {
+ if (!Boolean.TRUE.equals(PDataType.BOOLEAN.toObject(desc.getValue(MetaDataUtil.IS_VIEW_INDEX_TABLE_PROP_BYTES)))) {
+ String fullTableName = Bytes.toString(physicalIndexName);
+ throw new TableAlreadyExistsException(
+ "Unable to create shared physical table for indexes on views.",
+ SchemaUtil.getSchemaNameFromFullName(fullTableName),
+ SchemaUtil.getTableNameFromFullName(fullTableName));
+ }
+ }
+ }
+
+ private boolean ensureViewIndexTableDropped(byte[] physicalTableName, long timestamp) throws SQLException {
+ byte[] physicalIndexName = MetaDataUtil.getViewIndexPhysicalName(physicalTableName);
+ HTableDescriptor desc = null;
+ HBaseAdmin admin = null;
+ boolean wasDeleted = false;
+ try {
+ admin = new HBaseAdmin(config);
+ try {
+ desc = admin.getTableDescriptor(physicalIndexName);
+ if (Boolean.TRUE.equals(PDataType.BOOLEAN.toObject(desc.getValue(MetaDataUtil.IS_VIEW_INDEX_TABLE_PROP_BYTES)))) {
+ final ReadOnlyProps props = this.getProps();
+ final boolean dropMetadata = props.getBoolean(DROP_METADATA_ATTRIB, DEFAULT_DROP_METADATA);
+ if (dropMetadata) {
+ admin.disableTable(physicalIndexName);
+ admin.deleteTable(physicalIndexName);
+ wasDeleted = true;
+ }
+ }
+ } catch (org.apache.hadoop.hbase.TableNotFoundException ignore) {
+ // Ignore, as we may never have created a view index table
+ }
+ } catch (IOException e) {
+ throw ServerUtil.parseServerException(e);
+ } finally {
+ try {
+ if (admin != null) admin.close();
+ } catch (IOException e) {
+ logger.warn("",e);
+ }
+ }
+ return wasDeleted;
+ }
+
@Override
public MetaDataMutationResult createTable(final List<Mutation> tableMetaData, byte[] physicalTableName, PTableType tableType,
Map<String,Object> tableProps, final List<Pair<byte[],Map<String,Object>>> families, byte[][] splits) throws SQLException {
byte[][] rowKeyMetadata = new byte[3][];
- Mutation m = tableMetaData.get(0);
+ Mutation m = MetaDataUtil.getPutOnlyTableHeaderRow(tableMetaData);
byte[] key = m.getRow();
SchemaUtil.getVarChars(key, rowKeyMetadata);
byte[] tenantIdBytes = rowKeyMetadata[PhoenixDatabaseMetaData.TENANT_ID_INDEX];
byte[] schemaBytes = rowKeyMetadata[PhoenixDatabaseMetaData.SCHEMA_NAME_INDEX];
byte[] tableBytes = rowKeyMetadata[PhoenixDatabaseMetaData.TABLE_NAME_INDEX];
- if (tableType != PTableType.VIEW || physicalTableName != null) {
- if (physicalTableName == null) {
- physicalTableName = SchemaUtil.getTableNameAsBytes(schemaBytes, tableBytes);
+ byte[] tableName = physicalTableName != null ? physicalTableName : SchemaUtil.getTableNameAsBytes(schemaBytes, tableBytes);
+ if ((tableType == PTableType.VIEW && physicalTableName != null) || (tableType != PTableType.VIEW && physicalTableName == null)) {
+ // For views this will ensure that metadata already exists
+ ensureTableCreated(tableName, tableType, tableProps, families, splits, true);
+ }
+
+ if (tableType == PTableType.INDEX && physicalTableName != null) { // Index on view
+ // Physical index table created up front for multi tenant
+ // TODO: if viewIndexId is Short.MIN_VALUE, then we don't need to attempt to create it
+ if (!MetaDataUtil.isMultiTenant(m)) {
+ ensureViewIndexTableCreated(physicalTableName, MetaDataUtil.getClientTimeStamp(m));
}
- ensureTableCreated(physicalTableName, tableType, tableProps, families, splits);
+ } else if (tableType == PTableType.TABLE && MetaDataUtil.isMultiTenant(m)) { // Create view index table up front for multi tenant tables
+ ensureViewIndexTableCreated(tableName, tableProps, families, MetaDataUtil.isSalted(m) ? splits : null, MetaDataUtil.getClientTimeStamp(m));
}
byte[] tableKey = SchemaUtil.getTableKey(tenantIdBytes, schemaBytes, tableBytes);
@@ -848,11 +932,16 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement
final MutationCode code = result.getMutationCode();
switch(code) {
case TABLE_ALREADY_EXISTS:
- final ReadOnlyProps props = this.getProps();
- final boolean dropMetadata = props.getBoolean(DROP_METADATA_ATTRIB, DEFAULT_DROP_METADATA);
+ ReadOnlyProps props = this.getProps();
+ boolean dropMetadata = props.getBoolean(DROP_METADATA_ATTRIB, DEFAULT_DROP_METADATA);
if (dropMetadata) {
dropTables(result.getTableNamesToDelete());
}
+ if (tableType == PTableType.TABLE) {
+ byte[] physicalTableName = SchemaUtil.getTableNameAsBytes(schemaBytes, tableBytes);
+ long timestamp = MetaDataUtil.getClientTimeStamp(tableMetaData);
+ ensureViewIndexTableDropped(physicalTableName, timestamp);
+ }
break;
default:
break;
@@ -895,20 +984,76 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement
}
}
+ private static Map<String,Object> createPropertiesMap(Map<ImmutableBytesWritable,ImmutableBytesWritable> htableProps) {
+ Map<String,Object> props = Maps.newHashMapWithExpectedSize(htableProps.size());
+ for (Map.Entry<ImmutableBytesWritable,ImmutableBytesWritable> entry : htableProps.entrySet()) {
+ ImmutableBytesWritable key = entry.getKey();
+ ImmutableBytesWritable value = entry.getValue();
+ props.put(Bytes.toString(key.get(), key.getOffset(), key.getLength()), Bytes.toString(value.get(), value.getOffset(), value.getLength()));
+ }
+ return props;
+ }
+
+ private void ensureViewIndexTableCreated(byte[] physicalIndexTableName, long timestamp) throws SQLException {
+ PTable table;
+ String name = Bytes.toString(
+ physicalIndexTableName,
+ MetaDataUtil.VIEW_INDEX_TABLE_PREFIX_BYTES.length,
+ physicalIndexTableName.length-MetaDataUtil.VIEW_INDEX_TABLE_PREFIX_BYTES.length);
+ try {
+ table = latestMetaData.getTable(name);
+ if (table.getTimeStamp() >= timestamp) { // Table in cache is newer than client timestamp which shouldn't be the case
+ throw new TableNotFoundException(table.getSchemaName().getString(), table.getTableName().getString());
+ }
+ } catch (TableNotFoundException e) {
+ byte[] schemaName = Bytes.toBytes(SchemaUtil.getSchemaNameFromFullName(name));
+ byte[] tableName = Bytes.toBytes(SchemaUtil.getTableNameFromFullName(name));
+ MetaDataMutationResult result = this.getTable(null, schemaName, tableName, HConstants.LATEST_TIMESTAMP, timestamp);
+ table = result.getTable();
+ if (table == null) {
+ throw e;
+ }
+ }
+ ensureViewIndexTableCreated(table, timestamp);
+ }
+
+ private void ensureViewIndexTableCreated(PTable table, long timestamp) throws SQLException {
+ byte[] physicalTableName = table.getPhysicalName().getBytes();
+ HTableDescriptor htableDesc = this.getTableDescriptor(physicalTableName);
+ Map<String,Object> tableProps = createPropertiesMap(htableDesc.getValues());
+ List<Pair<byte[],Map<String,Object>>> families = Lists.newArrayListWithExpectedSize(Math.max(1, table.getColumnFamilies().size()));
+ if (families.isEmpty()) {
+ byte[] familyName = SchemaUtil.getEmptyColumnFamily(table);
+ Map<String,Object> familyProps = createPropertiesMap(htableDesc.getFamily(familyName).getValues());
+ families.add(new Pair<byte[],Map<String,Object>>(familyName, familyProps));
+ } else {
+ for (PColumnFamily family : table.getColumnFamilies()) {
+ byte[] familyName = SchemaUtil.getEmptyColumnFamily(table);
+ Map<String,Object> familyProps = createPropertiesMap(htableDesc.getFamily(familyName).getValues());
+ families.add(new Pair<byte[],Map<String,Object>>(family.getName().getBytes(), familyProps));
+ }
+ }
+ byte[][] splits = null;
+ if (table.getBucketNum() != null) {
+ splits = SaltingUtil.getSalteByteSplitPoints(table.getBucketNum());
+ }
+
+ ensureViewIndexTableCreated(physicalTableName, tableProps, families, splits, timestamp);
+ }
+
@Override
- public MetaDataMutationResult addColumn(final List<Mutation> tableMetaData, PTableType tableType, List<Pair<byte[],Map<String,Object>>> families) throws SQLException {
+ public MetaDataMutationResult addColumn(final List<Mutation> tableMetaData, List<Pair<byte[],Map<String,Object>>> families, PTable table) throws SQLException {
byte[][] rowKeyMetaData = new byte[3][];
+ PTableType tableType = table.getType();
- byte[] rowKey = tableMetaData.get(0).getRow();
+ Mutation m = tableMetaData.get(0);
+ byte[] rowKey = m.getRow();
SchemaUtil.getVarChars(rowKey, rowKeyMetaData);
byte[] tenantIdBytes = rowKeyMetaData[PhoenixDatabaseMetaData.TENANT_ID_INDEX];
byte[] schemaBytes = rowKeyMetaData[PhoenixDatabaseMetaData.SCHEMA_NAME_INDEX];
byte[] tableBytes = rowKeyMetaData[PhoenixDatabaseMetaData.TABLE_NAME_INDEX];
byte[] tableKey = SchemaUtil.getTableKey(tenantIdBytes, schemaBytes, tableBytes);
- byte[] tableName = SchemaUtil.getTableNameAsBytes(schemaBytes, tableBytes);
for ( Pair<byte[],Map<String,Object>> family : families) {
-
- PTable table = latestMetaData.getTable(Bytes.toString(tableName));
ensureFamilyCreated(table.getPhysicalName().getBytes(), tableType, family);
}
// Special case for call during drop table to ensure that the empty column family exists.
@@ -926,6 +1071,18 @@ public class ConnectionQueryServicesImpl extends DelegateQueryServices implement
return instance.addColumn(tableMetaData);
}
});
+ if (tableType == PTableType.TABLE && result.getMutationCode() == MutationCode.COLUMN_NOT_FOUND) { // Success
+ // If we're changing MULTI_TENANT to true or false, create or drop the view index table
+ KeyValue kv = MetaDataUtil.getMutationKeyValue(m, PhoenixDatabaseMetaData.MULTI_TENANT_BYTES);
+ if (kv != null) {
+ long timestamp = MetaDataUtil.getClientTimeStamp(m);
+ if (Boolean.TRUE.equals(PDataType.BOOLEAN.toObject(kv.getBuffer(), kv.getValueOffset(), kv.getValueLength()))) {
+ this.ensureViewIndexTableCreated(table, timestamp);
+ } else {
+ this.ensureViewIndexTableDropped(table.getPhysicalName().getBytes(), timestamp);
+ }
+ }
+ }
return result;
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/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 59761f1..6927d0a 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
@@ -176,7 +176,7 @@ public class ConnectionlessQueryServicesImpl extends DelegateQueryServices imple
}
@Override
- public MetaDataMutationResult addColumn(List<Mutation> tableMetaData, PTableType readOnly, List<Pair<byte[],Map<String,Object>>> families) throws SQLException {
+ public MetaDataMutationResult addColumn(List<Mutation> tableMetaData, List<Pair<byte[],Map<String,Object>>> families, PTable table) throws SQLException {
return new MetaDataMutationResult(MutationCode.TABLE_ALREADY_EXISTS, 0, null);
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/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 7d92ab3..f586c9e 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
@@ -118,8 +118,8 @@ public class DelegateConnectionQueryServices extends DelegateQueryServices imple
}
@Override
- public MetaDataMutationResult addColumn(List<Mutation> tabeMetaData, PTableType tableType, List<Pair<byte[],Map<String,Object>>> families ) throws SQLException {
- return getDelegate().addColumn(tabeMetaData, tableType, families);
+ public MetaDataMutationResult addColumn(List<Mutation> tabeMetaData, List<Pair<byte[],Map<String,Object>>> families, PTable table) throws SQLException {
+ return getDelegate().addColumn(tabeMetaData, families, table);
}
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/query/QueryConstants.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/query/QueryConstants.java b/phoenix-core/src/main/java/org/apache/phoenix/query/QueryConstants.java
index b62c3e9..4987158 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/query/QueryConstants.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/query/QueryConstants.java
@@ -24,7 +24,6 @@ import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.CACHE_SIZE;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.CHAR_OCTET_LENGTH;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.COLUMN_COUNT;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.COLUMN_DEF;
-import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SORT_ORDER;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.COLUMN_NAME;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.COLUMN_SIZE;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.CURRENT_VALUE;
@@ -53,6 +52,7 @@ import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SCOPE_TABLE;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SELF_REFERENCING_COL_NAME_NAME;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SEQUENCE_NAME;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SEQUENCE_SCHEMA;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SORT_ORDER;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SOURCE_DATA_TYPE;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SQL_DATA_TYPE;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.SQL_DATETIME_SUB;
@@ -67,6 +67,8 @@ import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TYPE_NAME;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TYPE_SCHEMA;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TYPE_SEQUENCE;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.TYPE_TABLE;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.VIEW_CONSTANT;
+import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.VIEW_INDEX_ID;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.VIEW_STATEMENT;
import static org.apache.phoenix.jdbc.PhoenixDatabaseMetaData.VIEW_TYPE;
@@ -167,6 +169,16 @@ public interface QueryConstants {
REF_GENERATION_NAME + " VARCHAR," +
TABLE_SEQ_NUM + " BIGINT," +
COLUMN_COUNT + " INTEGER," +
+ SALT_BUCKETS + " INTEGER," +
+ DATA_TABLE_NAME + " VARCHAR," +
+ INDEX_STATE + " CHAR(1),\n" +
+ IMMUTABLE_ROWS + " BOOLEAN,\n" +
+ VIEW_STATEMENT + " VARCHAR,\n" +
+ DEFAULT_COLUMN_FAMILY_NAME + " VARCHAR,\n" +
+ DISABLE_WAL + " BOOLEAN,\n" +
+ MULTI_TENANT + " BOOLEAN,\n" +
+ VIEW_TYPE + " UNSIGNED_TINYINT,\n" +
+ VIEW_INDEX_ID + " SMALLINT,\n" +
// Column metadata (will be null for table row)
COLUMN_SIZE + " INTEGER," +
BUFFER_LENGTH + " INTEGER," +
@@ -182,23 +194,13 @@ public interface QueryConstants {
SCOPE_CATALOG + " VARCHAR," +
SCOPE_SCHEMA + " VARCHAR," +
SCOPE_TABLE + " VARCHAR," +
- SOURCE_DATA_TYPE + " INTEGER," + // supposed to be SHORT
+ SOURCE_DATA_TYPE + " SMALLINT," +
IS_AUTOINCREMENT + " VARCHAR," +
- // Columns added in 1.2.1
SORT_ORDER + " INTEGER," +
- SALT_BUCKETS + " INTEGER," +
- // Columns added in 2.0.0
- DATA_TABLE_NAME + " VARCHAR," +
- INDEX_STATE + " CHAR(1),\n" +
- IMMUTABLE_ROWS + " BOOLEAN,\n" +
- // Columns added in 3.0.0
- VIEW_STATEMENT + " VARCHAR,\n" +
- DEFAULT_COLUMN_FAMILY_NAME + " VARCHAR,\n" +
- DISABLE_WAL + " BOOLEAN,\n" +
- MULTI_TENANT + " BOOLEAN,\n" +
- VIEW_TYPE + " UNSIGNED_TINYINT,\n" +
- LINK_TYPE + " UNSIGNED_TINYINT,\n" +
ARRAY_SIZE + " INTEGER,\n" +
+ VIEW_CONSTANT + " VARBINARY,\n" +
+ // Link metadata (only set on rows linking table to index or view)
+ LINK_TYPE + " UNSIGNED_TINYINT,\n" +
"CONSTRAINT " + SYSTEM_TABLE_PK_NAME + " PRIMARY KEY (" + TENANT_ID + ","
+ TABLE_SCHEM_NAME + "," + TABLE_NAME_NAME + "," + COLUMN_NAME + "," + TABLE_CAT_NAME + "))\n" +
HConstants.VERSIONS + "=" + MetaDataProtocol.DEFAULT_MAX_META_DATA_VERSIONS + ",\n" +
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/query/QueryServices.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/query/QueryServices.java b/phoenix-core/src/main/java/org/apache/phoenix/query/QueryServices.java
index b91068a..b6a65c0 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/query/QueryServices.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/query/QueryServices.java
@@ -20,7 +20,6 @@ package org.apache.phoenix.query;
import java.util.concurrent.ExecutorService;
import org.apache.http.annotation.Immutable;
-
import org.apache.phoenix.iterate.SpoolTooBigToDiskException;
import org.apache.phoenix.memory.MemoryManager;
import org.apache.phoenix.optimize.QueryOptimizer;
@@ -93,6 +92,7 @@ public interface QueryServices extends SQLCloseable {
public static final String ZOOKEEPER_ROOT_NODE_ATTRIB = "zookeeper.znode.parent";
public static final String DISTINCT_VALUE_COMPRESS_THRESHOLD_ATTRIB = "phoenix.distinct.value.compress.threshold";
public static final String SEQUENCE_CACHE_SIZE_ATTRIB = "phoenix.sequence.cacheSize";
+ public static final String INDEX_MAX_FILESIZE_PERC_ATTRIB = "phoenix.index.maxDataFileSizePerc";
/**
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/query/QueryServicesOptions.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/query/QueryServicesOptions.java b/phoenix-core/src/main/java/org/apache/phoenix/query/QueryServicesOptions.java
index 4a07245..f9fdbfe 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/query/QueryServicesOptions.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/query/QueryServicesOptions.java
@@ -22,8 +22,8 @@ import static org.apache.phoenix.query.QueryServices.CALL_QUEUE_ROUND_ROBIN_ATTR
import static org.apache.phoenix.query.QueryServices.DATE_FORMAT_ATTRIB;
import static org.apache.phoenix.query.QueryServices.DROP_METADATA_ATTRIB;
import static org.apache.phoenix.query.QueryServices.GROUPBY_MAX_CACHE_SIZE_ATTRIB;
-import static org.apache.phoenix.query.QueryServices.GROUPBY_SPILL_FILES_ATTRIB;
import static org.apache.phoenix.query.QueryServices.GROUPBY_SPILLABLE_ATTRIB;
+import static org.apache.phoenix.query.QueryServices.GROUPBY_SPILL_FILES_ATTRIB;
import static org.apache.phoenix.query.QueryServices.IMMUTABLE_ROWS_ATTRIB;
import static org.apache.phoenix.query.QueryServices.INDEX_MUTATE_BATCH_SIZE_THRESHOLD_ATTRIB;
import static org.apache.phoenix.query.QueryServices.KEEP_ALIVE_MS_ATTRIB;
@@ -57,7 +57,6 @@ import java.util.Map.Entry;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HConstants;
import org.apache.hadoop.hbase.regionserver.wal.WALEditCodec;
-
import org.apache.phoenix.util.DateUtil;
import org.apache.phoenix.util.ReadOnlyProps;
@@ -111,6 +110,7 @@ public class QueryServicesOptions {
public static final long DEFAULT_GROUPBY_MAX_CACHE_MAX = 1024L*1024L*100L; // 100 Mb
public static final int DEFAULT_SEQUENCE_CACHE_SIZE = 100; // reserve 100 sequences at a time
+ public static final int DEFAULT_INDEX_MAX_FILESIZE_PERC = 50; // % of data table max file size for index table
private final Configuration config;
http://git-wip-us.apache.org/repos/asf/incubator-phoenix/blob/e2bd0ee0/phoenix-core/src/main/java/org/apache/phoenix/schema/DelegateColumn.java
----------------------------------------------------------------------
diff --git a/phoenix-core/src/main/java/org/apache/phoenix/schema/DelegateColumn.java b/phoenix-core/src/main/java/org/apache/phoenix/schema/DelegateColumn.java
index c916555..aa2fb3e 100644
--- a/phoenix-core/src/main/java/org/apache/phoenix/schema/DelegateColumn.java
+++ b/phoenix-core/src/main/java/org/apache/phoenix/schema/DelegateColumn.java
@@ -66,4 +66,9 @@ public class DelegateColumn extends DelegateDatum implements PColumn {
public Integer getArraySize() {
return getDelegate().getArraySize();
}
+
+ @Override
+ public byte[] getViewConstant() {
+ return getDelegate().getViewConstant();
+ }
}