org.apache.phoenix.compile.RVCOffsetCompiler Maven / Gradle / Ivy
The newest version!
/*
* 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.compile;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.ibm.icu.impl.number.Parse;
import org.apache.commons.lang.StringUtils;
import org.apache.phoenix.expression.AndExpression;
import org.apache.phoenix.expression.CoerceExpression;
import org.apache.phoenix.expression.ComparisonExpression;
import org.apache.phoenix.expression.Expression;
import org.apache.phoenix.expression.IsNullExpression;
import org.apache.phoenix.expression.RowKeyColumnExpression;
import org.apache.phoenix.parse.CastParseNode;
import org.apache.phoenix.parse.ColumnParseNode;
import org.apache.phoenix.parse.EqualParseNode;
import org.apache.phoenix.parse.FilterableStatement;
import org.apache.phoenix.parse.HintNode;
import org.apache.phoenix.parse.LiteralParseNode;
import org.apache.phoenix.parse.OffsetNode;
import org.apache.phoenix.parse.ParseNode;
import org.apache.phoenix.parse.RowValueConstructorParseNode;
import org.apache.phoenix.query.KeyRange;
import org.apache.phoenix.schema.PColumn;
import org.apache.phoenix.schema.PTable;
import org.apache.phoenix.schema.PTableType;
import org.apache.phoenix.schema.RowKeySchema;
import org.apache.phoenix.schema.RowValueConstructorOffsetInternalErrorException;
import org.apache.phoenix.schema.RowValueConstructorOffsetNotAllowedInQueryException;
import org.apache.phoenix.schema.RowValueConstructorOffsetNotCoercibleException;
import org.apache.phoenix.schema.TypeMismatchException;
import org.apache.phoenix.util.IndexUtil;
import org.apache.phoenix.util.ParseNodeUtil;
import org.apache.phoenix.util.ScanUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
public class RVCOffsetCompiler {
private final static Logger LOGGER = LoggerFactory.getLogger(RVCOffsetCompiler.class);
private final static RVCOffsetCompiler INSTANCE = new RVCOffsetCompiler();
private RVCOffsetCompiler() {
}
public static RVCOffsetCompiler getInstance() {
return INSTANCE;
}
public CompiledOffset getRVCOffset(StatementContext context, FilterableStatement statement,
boolean inJoin, boolean inUnion, OffsetNode offsetNode) throws SQLException {
// We have a RVC offset. See PHOENIX-4845
// This is a EqualParseNode with LHS and RHS RowValueConstructorParseNodes
// This is enforced as part of the grammar
EqualParseNode equalParseNode = (EqualParseNode) offsetNode.getOffsetParseNode();
RowValueConstructorParseNode
rvcColumnsParseNode =
(RowValueConstructorParseNode) equalParseNode.getLHS();
RowValueConstructorParseNode
rvcConstantParseNode =
(RowValueConstructorParseNode) equalParseNode.getRHS();
// disallow use with aggregations
if (statement.isAggregate()) {
throw new RowValueConstructorOffsetNotAllowedInQueryException("RVC Offset not allowed in Aggregates");
}
// Get the Select Type should not be join/union
// Note cannot use the SelectStatement as for Left/Right joins we won't get passed in the join context
if (inJoin || inUnion) {
throw new RowValueConstructorOffsetNotAllowedInQueryException("RVC Offset not allowed in Joins or Unions");
}
// Get the tables primary keys
if (context.getResolver().getTables().size() != 1) {
throw new RowValueConstructorOffsetNotAllowedInQueryException("RVC Offset not allowed with zero or multiple tables");
}
PTable pTable = context.getCurrentTable().getTable();
List columns = pTable.getPKColumns();
int numUserColumns = columns.size(); // columns specified by the user
int userColumnIndex = 0; // index into the ordered list, columns, of where user specified start
// if we are salted we need to take a subset of the pk
Integer buckets = pTable.getBucketNum();
if (buckets != null && buckets > 0) { // We are salted
numUserColumns--;
userColumnIndex++;
}
if (pTable.isMultiTenant() && context.getConnection().getTenantId() != null) {
// the tenantId is one of the pks and will be handled automatically
numUserColumns--;
userColumnIndex++;
}
boolean isIndex = false;
if (PTableType.INDEX.equals(pTable.getType())) {
isIndex = true;
// If we are a view index we have to handle the idxId column
// Note that viewIndexId comes before tenantId (what about salt byte?)
if (pTable.getViewIndexId() != null) {
numUserColumns--;
userColumnIndex++;
}
}
// Sanity check that they are providing all the user defined keys to this table
if (numUserColumns != rvcConstantParseNode.getChildren().size()) {
throw new RowValueConstructorOffsetNotCoercibleException(
"RVC Offset must exactly cover the tables PK.");
}
// Make sure the order is the same and all the user defined columns are mentioned in the column RVC
if (numUserColumns != rvcColumnsParseNode.getChildren().size()) {
throw new RowValueConstructorOffsetNotCoercibleException(
"RVC Offset must specify the tables PKs.");
}
List
rvcColumnParseNodeList = buildListOfColumnParseNodes(rvcColumnsParseNode, isIndex);
// Make sure we have all column parse nodes for the left hand
if (rvcColumnParseNodeList.size() != numUserColumns) {
throw new RowValueConstructorOffsetNotCoercibleException(
"RVC Offset must specify the tables PKs.");
}
// We resolve the mini-where now so we can compare to tables pks PColumns and to produce a row offset
// Construct a mini where clause
ParseNode miniWhere = equalParseNode;
Set originalHints = statement.getHint().getHints();
WhereCompiler.WhereExpressionCompiler whereCompiler = new WhereCompiler.WhereExpressionCompiler(context);
Expression whereExpression;
try {
whereExpression = miniWhere.accept(whereCompiler);
}catch(TypeMismatchException e) {
throw new RowValueConstructorOffsetNotCoercibleException(
"RVC Offset could not be coerced to the tables PKs. " + e.getMessage());
} catch (Exception e) {
LOGGER.error("Unexpected error while compiling RVC Offset, got null expression.",e);
throw new RowValueConstructorOffsetInternalErrorException(
"RVC Offset unexpected failure.");
}
if (whereExpression == null) {
LOGGER.error("Unexpected error while compiling RVC Offset, got null expression.");
throw new RowValueConstructorOffsetInternalErrorException(
"RVC Offset unexpected failure.");
}
Expression expression;
try {
expression =
WhereOptimizer
.pushKeyExpressionsToScan(context, originalHints, whereExpression, null,
Optional.absent());
} catch (Exception e) {
LOGGER.error("Unexpected error while compiling RVC Offset, got null expression.");
throw new RowValueConstructorOffsetInternalErrorException(
"RVC Offset unexpected failure.");
}
//If the whereExpression is a single term comparison/isNull it will be entirely removed
if (expression == null && whereExpression instanceof AndExpression) {
LOGGER.error("Unexpected error while compiling RVC Offset, got null expression.");
throw new RowValueConstructorOffsetInternalErrorException(
"RVC Offset unexpected failure.");
}
// Now that columns etc have been resolved lets check to make sure they match the pk order
RowKeyColumnExpressionOutput rowKeyColumnExpressionOutput =
buildListOfRowKeyColumnExpressions(whereExpression, isIndex);
List
rowKeyColumnExpressionList = rowKeyColumnExpressionOutput.getRowKeyColumnExpressions();
if (rowKeyColumnExpressionList.size() != numUserColumns) {
LOGGER.warn("Unexpected error while compiling RVC Offset, expected " + numUserColumns
+ " found " + rowKeyColumnExpressionList.size());
throw new RowValueConstructorOffsetInternalErrorException(
"RVC Offset must specify the table's PKs.");
}
for (int i = 0; i < numUserColumns; i++) {
PColumn column = columns.get(i + userColumnIndex);
ColumnParseNode columnParseNode = rvcColumnParseNodeList.get(i);
String columnParseNodeString = columnParseNode.getFullName();
if (isIndex) {
columnParseNodeString = IndexUtil.getDataColumnName(columnParseNodeString);
}
RowKeyColumnExpression rowKeyColumnExpression = rowKeyColumnExpressionList.get(i);
String expressionName = rowKeyColumnExpression.getName();
// Not sure why it is getting quoted
expressionName = expressionName.replace("\"", "");
if (isIndex) {
expressionName = IndexUtil.getDataColumnName(expressionName);
}
if (!StringUtils.equals(expressionName, columnParseNodeString)) {
throw new RowValueConstructorOffsetNotCoercibleException(
"RVC Offset must specify the table's PKs.");
}
String columnString = column.getName().getString();
if (isIndex) {
columnString = IndexUtil.getDataColumnName(columnString);
}
if (!StringUtils.equals(expressionName, columnString)) {
throw new RowValueConstructorOffsetNotCoercibleException(
"RVC Offset must specify the table's PKs.");
}
}
byte[] key;
// check to see if this was a single key expression
ScanRanges scanRanges = context.getScanRanges();
//We do not generate a point lookup today in phoenix if the rowkey has a trailing null, we generate a range scan.
if (!scanRanges.isPointLookup()) {
//Since we use a range scan to guarantee we get only the null value and the upper bound is unset this suffices
//sanity check
if (!rowKeyColumnExpressionOutput.isTrailingNull()) {
throw new RowValueConstructorOffsetNotCoercibleException(
"RVC Offset must be a point lookup.");
}
key = scanRanges.getScanRange().getUpperRange();
} else {
RowKeySchema.RowKeySchemaBuilder builder = new RowKeySchema.RowKeySchemaBuilder(columns.size());
for (PColumn column : columns) {
builder.addField(column, column.isNullable(), column.getSortOrder());
}
RowKeySchema rowKeySchema = builder.build();
//we make a ScanRange with 1 keyslots that cover the entire PK to reuse the code
KeyRange pointKeyRange = scanRanges.getScanRange();
KeyRange keyRange = KeyRange.getKeyRange(pointKeyRange.getLowerRange(), false, KeyRange.UNBOUND, true);
List myRangeList = Lists.newArrayList(keyRange);
List> slots = new ArrayList<>();
slots.add(myRangeList);
int[] slotSpan = new int[1];
//subtract 1 see ScanUtil.SINGLE_COLUMN_SLOT_SPAN is 0
slotSpan[0] = columns.size() - 1;
key = ScanUtil.getMinKey(rowKeySchema, slots, slotSpan);
}
// Note the use of ByteUtil.nextKey() to generate exclusive offset
CompiledOffset
compiledOffset =
new CompiledOffset(Optional.absent(),
Optional.of(key));
return compiledOffset;
}
@VisibleForTesting
static class RowKeyColumnExpressionOutput {
public RowKeyColumnExpressionOutput(List rowKeyColumnExpressions, boolean trailingNull) {
this.rowKeyColumnExpressions = rowKeyColumnExpressions;
this.trailingNull = trailingNull;
}
private final List rowKeyColumnExpressions;
private final boolean trailingNull;
public List getRowKeyColumnExpressions() {
return rowKeyColumnExpressions;
}
public boolean isTrailingNull() {
return trailingNull;
}
}
@VisibleForTesting
RowKeyColumnExpressionOutput buildListOfRowKeyColumnExpressions (
Expression whereExpression, boolean isIndex)
throws RowValueConstructorOffsetNotCoercibleException, RowValueConstructorOffsetInternalErrorException {
boolean trailingNull = false;
List expressions;
if((whereExpression instanceof AndExpression)) {
expressions = whereExpression.getChildren();
} else if (whereExpression instanceof ComparisonExpression || whereExpression instanceof IsNullExpression) {
expressions = Lists.newArrayList(whereExpression);
} else {
LOGGER.warn("Unexpected error while compiling RVC Offset, expected either a Comparison/IsNull Expression of a AndExpression got "
+ whereExpression.getClass().getName());
throw new RowValueConstructorOffsetInternalErrorException(
"RVC Offset must specify the tables PKs.");
}
List
rowKeyColumnExpressionList =
new ArrayList();
for (int i = 0; i < expressions.size(); i++) {
Expression child = expressions.get(i);
if (!(child instanceof ComparisonExpression || child instanceof IsNullExpression)) {
LOGGER.warn("Unexpected error while compiling RVC Offset");
throw new RowValueConstructorOffsetNotCoercibleException(
"RVC Offset must specify the tables PKs.");
}
//if this is the last position
if(i == expressions.size() - 1) {
if(child instanceof IsNullExpression) {
trailingNull = true;
}
}
//For either case comparison/isNull the first child should be the rowkey
Expression possibleRowKeyColumnExpression = child.getChildren().get(0);
// Note that since we store indexes in variable length form there may be casts from fixed types to
// variable length
if (isIndex) {
if (possibleRowKeyColumnExpression instanceof CoerceExpression) {
// Cast today has 1 child
possibleRowKeyColumnExpression =
((CoerceExpression) possibleRowKeyColumnExpression).getChild();
}
}
if (!(possibleRowKeyColumnExpression instanceof RowKeyColumnExpression)) {
LOGGER.warn("Unexpected error while compiling RVC Offset");
throw new RowValueConstructorOffsetNotCoercibleException(
"RVC Offset must specify the tables PKs.");
}
rowKeyColumnExpressionList.add((RowKeyColumnExpression) possibleRowKeyColumnExpression);
}
return new RowKeyColumnExpressionOutput(rowKeyColumnExpressionList,trailingNull);
}
@VisibleForTesting List buildListOfColumnParseNodes(
RowValueConstructorParseNode rvcColumnsParseNode, boolean isIndex)
throws RowValueConstructorOffsetNotCoercibleException {
List nodes = new ArrayList();
for (ParseNode node : rvcColumnsParseNode.getChildren()) {
// Note that since we store indexes in variable length form there may be casts from fixed types to
// variable length
if (isIndex) {
if (node instanceof CastParseNode) {
// Cast today has 1 child
node = node.getChildren().get(0);
}
}
if (!(node instanceof ColumnParseNode)) {
throw new RowValueConstructorOffsetNotCoercibleException(
"RVC Offset must specify the tables PKs.");
} else {
nodes.add((ColumnParseNode) node);
}
}
return nodes;
}
} © 2015 - 2024 Weber Informatics LLC | Privacy Policy