Examples with LiteralExpression org.apache.phoenix.expression.LiteralExpression used on opensource projects

Example 21 with LiteralExpression

use of org.apache.phoenix.expression.LiteralExpression in project phoenix by apache.

the class ExpressionCompiler method visitLeave.

@Override
public Expression visitLeave(LikeParseNode node, List<Expression> children) throws SQLException {
    ParseNode lhsNode = node.getChildren().get(0);
    ParseNode rhsNode = node.getChildren().get(1);
    Expression lhs = children.get(0);
    Expression rhs = children.get(1);
    if (rhs.getDataType() != null && lhs.getDataType() != null && !lhs.getDataType().isCoercibleTo(rhs.getDataType()) && !rhs.getDataType().isCoercibleTo(lhs.getDataType())) {
        throw TypeMismatchException.newException(lhs.getDataType(), rhs.getDataType(), node.toString());
    }
    if (lhsNode instanceof BindParseNode) {
        context.getBindManager().addParamMetaData((BindParseNode) lhsNode, rhs);
    }
    if (rhsNode instanceof BindParseNode) {
        context.getBindManager().addParamMetaData((BindParseNode) rhsNode, lhs);
    }
    if (rhs instanceof LiteralExpression) {
        String pattern = (String) ((LiteralExpression) rhs).getValue();
        if (pattern == null || pattern.length() == 0) {
            return LiteralExpression.newConstant(null, rhs.getDeterminism());
        }
        // TODO: for pattern of '%' optimize to strlength(lhs) > 0
        // We can't use lhs IS NOT NULL b/c if lhs is NULL we need
        // to return NULL.
        int index = LikeExpression.indexOfWildcard(pattern);
        // Can't possibly be as long as the constant, then FALSE
        Integer lhsMaxLength = lhs.getMaxLength();
        if (lhsMaxLength != null && lhsMaxLength < index) {
            return LiteralExpression.newConstant(false, rhs.getDeterminism());
        }
        if (index == -1) {
            String rhsLiteral = LikeExpression.unescapeLike(pattern);
            if (lhsMaxLength != null && lhsMaxLength != rhsLiteral.length()) {
                return LiteralExpression.newConstant(false, rhs.getDeterminism());
            }
            if (node.getLikeType() == LikeType.CASE_SENSITIVE) {
                CompareOp op = node.isNegate() ? CompareOp.NOT_EQUAL : CompareOp.EQUAL;
                if (pattern.equals(rhsLiteral)) {
                    return new ComparisonExpression(children, op);
                } else {
                    rhs = LiteralExpression.newConstant(rhsLiteral, PChar.INSTANCE, rhs.getDeterminism());
                    return new ComparisonExpression(Arrays.asList(lhs, rhs), op);
                }
            }
        } else {
            byte[] wildcardString = new byte[pattern.length()];
            byte[] wildcard = { StringUtil.MULTI_CHAR_LIKE };
            StringUtil.fill(wildcardString, 0, pattern.length(), wildcard, 0, 1, false);
            if (pattern.equals(new String(wildcardString))) {
                List<Expression> compareChildren = Arrays.asList(lhs, NOT_NULL_STRING);
                return new ComparisonExpression(compareChildren, node.isNegate() ? CompareOp.LESS : CompareOp.GREATER_OR_EQUAL);
            }
        }
    }
    QueryServices services = context.getConnection().getQueryServices();
    boolean useByteBasedRegex = services.getProps().getBoolean(QueryServices.USE_BYTE_BASED_REGEX_ATTRIB, QueryServicesOptions.DEFAULT_USE_BYTE_BASED_REGEX);
    Expression expression;
    if (useByteBasedRegex) {
        expression = ByteBasedLikeExpression.create(children, node.getLikeType());
    } else {
        expression = StringBasedLikeExpression.create(children, node.getLikeType());
    }
    if (ExpressionUtil.isConstant(expression)) {
        ImmutableBytesWritable ptr = context.getTempPtr();
        if (!expression.evaluate(null, ptr)) {
            return LiteralExpression.newConstant(null, expression.getDeterminism());
        } else {
            return LiteralExpression.newConstant(Boolean.TRUE.equals(PBoolean.INSTANCE.toObject(ptr)) ^ node.isNegate(), expression.getDeterminism());
        }
    }
    if (node.isNegate()) {
        expression = new NotExpression(expression);
    }
    return wrapGroupByExpression(expression);
}

Example 22 with LiteralExpression

use of org.apache.phoenix.expression.LiteralExpression in project phoenix by apache.

the class ListJarsQueryPlan method iterator.

@Override
public ResultIterator iterator(ParallelScanGrouper scanGrouper) throws SQLException {
    return new ResultIterator() {

        private RemoteIterator<LocatedFileStatus> listFiles = null;

        @Override
        public void close() throws SQLException {
        }

        @Override
        public Tuple next() throws SQLException {
            try {
                if (first) {
                    String dynamicJarsDir = stmt.getConnection().getQueryServices().getProps().get(QueryServices.DYNAMIC_JARS_DIR_KEY);
                    if (dynamicJarsDir == null) {
                        throw new SQLException(QueryServices.DYNAMIC_JARS_DIR_KEY + " is not configured for the listing the jars.");
                    }
                    dynamicJarsDir = dynamicJarsDir.endsWith("/") ? dynamicJarsDir : dynamicJarsDir + '/';
                    Configuration conf = HBaseFactoryProvider.getConfigurationFactory().getConfiguration();
                    Path dynamicJarsDirPath = new Path(dynamicJarsDir);
                    FileSystem fs = dynamicJarsDirPath.getFileSystem(conf);
                    listFiles = fs.listFiles(dynamicJarsDirPath, true);
                    first = false;
                }
                if (listFiles == null || !listFiles.hasNext())
                    return null;
                ImmutableBytesWritable ptr = new ImmutableBytesWritable();
                ParseNodeFactory factory = new ParseNodeFactory();
                LiteralParseNode literal = factory.literal(listFiles.next().getPath().toString());
                LiteralExpression expression = LiteralExpression.newConstant(literal.getValue(), PVarchar.INSTANCE, Determinism.ALWAYS);
                expression.evaluate(null, ptr);
                byte[] rowKey = ByteUtil.copyKeyBytesIfNecessary(ptr);
                Cell cell = CellUtil.createCell(rowKey, HConstants.EMPTY_BYTE_ARRAY, HConstants.EMPTY_BYTE_ARRAY, System.currentTimeMillis(), Type.Put.getCode(), HConstants.EMPTY_BYTE_ARRAY);
                List<Cell> cells = new ArrayList<Cell>(1);
                cells.add(cell);
                return new ResultTuple(Result.create(cells));
            } catch (IOException e) {
                throw new SQLException(e);
            }
        }

        @Override
        public void explain(List<String> planSteps) {
        }
    };
}

Example 23 with LiteralExpression

use of org.apache.phoenix.expression.LiteralExpression in project phoenix by apache.

the class CreateIndexCompiler method compile.

public MutationPlan compile(final CreateIndexStatement create) throws SQLException {
    final PhoenixConnection connection = statement.getConnection();
    final ColumnResolver resolver = FromCompiler.getResolver(create, connection, create.getUdfParseNodes());
    Scan scan = new Scan();
    final StatementContext context = new StatementContext(statement, resolver, scan, new SequenceManager(statement));
    ExpressionCompiler expressionCompiler = new ExpressionCompiler(context);
    List<ParseNode> splitNodes = create.getSplitNodes();
    if (create.getIndexType() == IndexType.LOCAL) {
        if (!splitNodes.isEmpty()) {
            throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_SPLIT_LOCAL_INDEX).build().buildException();
        }
        List<Pair<String, Object>> list = create.getProps() != null ? create.getProps().get("") : null;
        if (list != null) {
            for (Pair<String, Object> pair : list) {
                if (pair.getFirst().equals(PhoenixDatabaseMetaData.SALT_BUCKETS)) {
                    throw new SQLExceptionInfo.Builder(SQLExceptionCode.CANNOT_SALT_LOCAL_INDEX).build().buildException();
                }
            }
        }
    }
    final byte[][] splits = new byte[splitNodes.size()][];
    for (int i = 0; i < splits.length; i++) {
        ParseNode node = splitNodes.get(i);
        if (!node.isStateless()) {
            throw new SQLExceptionInfo.Builder(SQLExceptionCode.SPLIT_POINT_NOT_CONSTANT).setMessage("Node: " + node).build().buildException();
        }
        LiteralExpression expression = (LiteralExpression) node.accept(expressionCompiler);
        splits[i] = expression.getBytes();
    }
    final MetaDataClient client = new MetaDataClient(connection);
    return new BaseMutationPlan(context, operation) {

        @Override
        public MutationState execute() throws SQLException {
            return client.createIndex(create, splits);
        }

        @Override
        public ExplainPlan getExplainPlan() throws SQLException {
            return new ExplainPlan(Collections.singletonList("CREATE INDEX"));
        }
    };
}