Search in sources :

Example 1 with And

use of com.revolsys.record.query.And in project com.revolsys.open by revolsys.

the class CodeTableProperty method loadId.

@Override
protected synchronized Identifier loadId(final List<Object> values, final boolean createId) {
    if (this.loadAll && !this.loadMissingCodes && !isEmpty()) {
        return null;
    }
    Identifier id = null;
    if (createId && this.loadAll && !isLoaded()) {
        loadAll();
        id = getIdentifier(values, false);
    } else {
        final Query query = new Query(this.typePath);
        final And and = new And();
        if (!values.isEmpty()) {
            int i = 0;
            for (final String fieldName : this.valueFieldNames) {
                final Object value = values.get(i);
                if (value == null) {
                    and.and(Q.isNull(fieldName));
                } else {
                    final FieldDefinition fieldDefinition = this.recordDefinition.getField(fieldName);
                    and.and(Q.equal(fieldDefinition, value));
                }
                i++;
            }
        }
        query.setWhereCondition(and);
        final Reader<Record> reader = this.recordStore.getRecords(query);
        try {
            final List<Record> codes = reader.toList();
            if (codes.size() > 0) {
                final CategoryLabelCountMap statistics = this.recordStore.getStatistics();
                if (statistics != null) {
                    statistics.getLabelCountMap("query").addCount(this.typePath, -codes.size());
                }
                addValues(codes);
            }
            id = getIdByValue(values);
            Property.firePropertyChange(this, "valuesChanged", false, true);
        } finally {
            reader.close();
        }
    }
    if (createId && id == null) {
        return newIdentifier(values);
    } else {
        return id;
    }
}
Also used : Identifier(com.revolsys.identifier.Identifier) SingleIdentifier(com.revolsys.identifier.SingleIdentifier) ListIdentifier(com.revolsys.identifier.ListIdentifier) Query(com.revolsys.record.query.Query) CategoryLabelCountMap(com.revolsys.util.count.CategoryLabelCountMap) And(com.revolsys.record.query.And) FieldDefinition(com.revolsys.record.schema.FieldDefinition) Record(com.revolsys.record.Record)

Example 2 with And

use of com.revolsys.record.query.And in project com.revolsys.open by revolsys.

the class QueryWhereConditionField method toQueryValue.

@SuppressWarnings("unchecked")
private <V extends QueryValue> V toQueryValue(final ValueNode expression) {
    if (expression instanceof BetweenOperatorNode) {
        final BetweenOperatorNode betweenExpression = (BetweenOperatorNode) expression;
        final ValueNode leftValueNode = betweenExpression.getLeftOperand();
        final ValueNodeList rightOperandList = betweenExpression.getRightOperandList();
        final ValueNode betweenExpressionStart = rightOperandList.get(0);
        final ValueNode betweenExpressionEnd = rightOperandList.get(1);
        if (!(leftValueNode instanceof ColumnReference)) {
            setInvalidMessage("Between operator must use a column name not: " + leftValueNode);
            return null;
        }
        if (!(betweenExpressionStart instanceof NumericConstantNode)) {
            setInvalidMessage("Between min value must be a number not: " + betweenExpressionStart);
            return null;
        }
        if (!(betweenExpressionEnd instanceof NumericConstantNode)) {
            setInvalidMessage("Between max value must be a number not: " + betweenExpressionEnd);
            return null;
        }
        final Column column = toQueryValue(leftValueNode);
        final Value min = toQueryValue(betweenExpressionStart);
        final Value max = toQueryValue(betweenExpressionEnd);
        final FieldDefinition fieldDefinition = this.recordDefinition.getField(column.getName());
        min.convert(fieldDefinition);
        max.convert(fieldDefinition);
        return (V) new Between(column, min, max);
    } else if (expression instanceof BinaryLogicalOperatorNode) {
        final BinaryLogicalOperatorNode binaryOperatorNode = (BinaryLogicalOperatorNode) expression;
        final String operator = binaryOperatorNode.getOperator().toUpperCase();
        final ValueNode leftValueNode = binaryOperatorNode.getLeftOperand();
        final ValueNode rightValueNode = binaryOperatorNode.getRightOperand();
        final QueryValue leftValue = toQueryValue(leftValueNode);
        if (leftValue instanceof Condition) {
            final Condition leftCondition = (Condition) leftValue;
            final QueryValue rightValue = toQueryValue(rightValueNode);
            if (rightValue instanceof Condition) {
                final Condition rightCondition = (Condition) rightValue;
                if ("AND".equals(operator)) {
                    return (V) new And(leftCondition, rightCondition);
                } else if ("OR".equals(operator)) {
                    return (V) new Or(leftCondition, rightCondition);
                } else {
                    setInvalidMessage("Binary logical operator " + operator + " not supported.");
                    return null;
                }
            } else {
                setInvalidMessage("Right side of " + operator + " must be a condition (e.g. column_name = 'value') not: " + rightValue);
                return null;
            }
        } else {
            setInvalidMessage("Left side of " + operator + " must be a condition (e.g. column_name = 'value') not: " + leftValue);
            return null;
        }
    } else if (expression instanceof BinaryOperatorNode) {
        final BinaryOperatorNode binaryOperatorNode = (BinaryOperatorNode) expression;
        final String operator = binaryOperatorNode.getOperator();
        final ValueNode leftValueNode = binaryOperatorNode.getLeftOperand();
        final ValueNode rightValueNode = binaryOperatorNode.getRightOperand();
        if (QueryValue.SUPPORTED_BINARY_OPERATORS.contains(operator.toUpperCase())) {
            final QueryValue leftCondition = toQueryValue(leftValueNode);
            QueryValue rightCondition = toQueryValue(rightValueNode);
            if (leftCondition instanceof Column) {
                if (rightCondition instanceof Value) {
                    final Object value = ((Value) rightCondition).getValue();
                    if (value == null) {
                        setInvalidMessage("Values can't be null for " + operator + " use IS NULL or IS NOT NULL instead.");
                    } else {
                        final Column column = (Column) leftCondition;
                        final String name = column.getName();
                        final FieldDefinition fieldDefinition = this.recordDefinition.getField(name);
                        final CodeTable codeTable = this.recordDefinition.getCodeTableByFieldName(name);
                        if (codeTable == null || fieldDefinition == this.recordDefinition.getIdField()) {
                            try {
                                final Object convertedValue = fieldDefinition.toFieldValueException(value);
                                if (convertedValue == null) {
                                    setInvalidMessage("Values can't be null for " + operator + " use IS NULL or IS NOT NULL instead.");
                                    return null;
                                } else {
                                    rightCondition = new Value(fieldDefinition, convertedValue);
                                }
                            } catch (final Throwable t) {
                                setInvalidMessage(name + "='" + value + "' is not a valid " + fieldDefinition.getDataType().getValidationName());
                            }
                        } else {
                            Object id;
                            if (value instanceof String) {
                                final String string = (String) value;
                                final String[] values = string.split(":");
                                id = codeTable.getIdentifier((Object[]) values);
                            } else {
                                id = codeTable.getIdentifier(value);
                            }
                            if (id == null) {
                                setInvalidMessage(name + "='" + value + "' could not be found in the code table " + codeTable.getName());
                            } else {
                                rightCondition = new Value(fieldDefinition, id);
                            }
                        }
                    }
                }
            }
            if (expression instanceof BinaryArithmeticOperatorNode) {
                final QueryValue arithmaticCondition = Q.arithmatic(leftCondition, operator, rightCondition);
                return (V) arithmaticCondition;
            } else {
                final Condition binaryCondition = Q.binary(leftCondition, operator, rightCondition);
                return (V) binaryCondition;
            }
        } else {
            setInvalidMessage("Unsupported binary operator " + operator);
        }
    } else if (expression instanceof ColumnReference) {
        final ColumnReference column = (ColumnReference) expression;
        String columnName = column.getColumnName();
        columnName = columnName.replaceAll("\"", "");
        final FieldDefinition fieldDefinition = this.recordDefinition.getField(columnName);
        if (fieldDefinition == null) {
            setInvalidMessage("Invalid field name " + columnName);
        } else {
            return (V) new Column(fieldDefinition);
        }
    } else if (expression instanceof LikeEscapeOperatorNode) {
        final LikeEscapeOperatorNode likeEscapeOperatorNode = (LikeEscapeOperatorNode) expression;
        final ValueNode leftValueNode = likeEscapeOperatorNode.getReceiver();
        final ValueNode rightValueNode = likeEscapeOperatorNode.getLeftOperand();
        final QueryValue leftCondition = toQueryValue(leftValueNode);
        final QueryValue rightCondition = toQueryValue(rightValueNode);
        return (V) new ILike(leftCondition, rightCondition);
    } else if (expression instanceof NotNode) {
        final NotNode notNode = (NotNode) expression;
        final ValueNode operand = notNode.getOperand();
        final Condition condition = toQueryValue(operand);
        return (V) new Not(condition);
    } else if (expression instanceof InListOperatorNode) {
        final InListOperatorNode inListOperatorNode = (InListOperatorNode) expression;
        final ValueNode leftOperand = inListOperatorNode.getLeftOperand();
        final QueryValue leftCondition = toQueryValue(leftOperand);
        final List<QueryValue> conditions = new ArrayList<>();
        final RowConstructorNode itemsList = inListOperatorNode.getRightOperandList();
        for (final ValueNode itemValueNode : itemsList.getNodeList()) {
            final QueryValue itemCondition = toQueryValue(itemValueNode);
            conditions.add(itemCondition);
        }
        return (V) new In(leftCondition, new CollectionValue(conditions));
    } else if (expression instanceof IsNullNode) {
        final IsNullNode isNullNode = (IsNullNode) expression;
        final ValueNode operand = isNullNode.getOperand();
        final QueryValue value = toQueryValue(operand);
        if (isNullNode.getNodeType() == NodeTypes.IS_NOT_NULL_NODE) {
            return (V) new IsNotNull(value);
        } else {
            return (V) new IsNull(value);
        }
    // } else if (expression instanceof Parenthesis) {
    // final Parenthesis parenthesis = (Parenthesis)expression;
    // final ValueNode parenthesisValueNode = parenthesis.getExpression();
    // final Condition condition = toCondition(parenthesisExpression);
    // final ParenthesisCondition parenthesisCondition = new
    // ParenthesisCondition(
    // condition);
    // if (parenthesis.isNot()) {
    // return (V)Q.not(parenthesisCondition);
    // } else {
    // return (V)parenthesisCondition;
    // }
    } else if (expression instanceof RowConstructorNode) {
        final RowConstructorNode rowConstructorNode = (RowConstructorNode) expression;
        final ValueNodeList values = rowConstructorNode.getNodeList();
        final ValueNode valueNode = values.get(0);
        return (V) toQueryValue(valueNode);
    } else if (expression instanceof UserTypeConstantNode) {
        final UserTypeConstantNode constant = (UserTypeConstantNode) expression;
        final Object objectValue = constant.getObjectValue();
        return (V) new Value(objectValue);
    } else if (expression instanceof ConstantNode) {
        final ConstantNode constant = (ConstantNode) expression;
        final Object value = constant.getValue();
        return (V) new Value(value);
    } else if (expression instanceof SimpleStringOperatorNode) {
        final SimpleStringOperatorNode operatorNode = (SimpleStringOperatorNode) expression;
        final String functionName = operatorNode.getMethodName().toUpperCase();
        final ValueNode operand = operatorNode.getOperand();
        final QueryValue condition = toQueryValue(operand);
        return (V) new Function(functionName, condition);
    } else if (expression instanceof CastNode) {
        final CastNode castNode = (CastNode) expression;
        final String typeName = castNode.getType().getSQLstring();
        final ValueNode operand = castNode.getCastOperand();
        final QueryValue condition = toQueryValue(operand);
        return (V) new Cast(condition, typeName);
    } else if (expression == null) {
        return null;
    } else {
        setInvalidMessage("Unsupported expression" + expression.getClass() + " " + expression);
    }
    return null;
}
Also used : Cast(com.revolsys.record.query.Cast) NotNode(com.akiban.sql.parser.NotNode) Or(com.revolsys.record.query.Or) In(com.revolsys.record.query.In) FieldDefinition(com.revolsys.record.schema.FieldDefinition) ArrayList(java.util.ArrayList) BinaryArithmeticOperatorNode(com.akiban.sql.parser.BinaryArithmeticOperatorNode) UserTypeConstantNode(com.akiban.sql.parser.UserTypeConstantNode) Function(com.revolsys.record.query.functions.Function) CollectionValue(com.revolsys.record.query.CollectionValue) IsNotNull(com.revolsys.record.query.IsNotNull) NumericConstantNode(com.akiban.sql.parser.NumericConstantNode) ConstantNode(com.akiban.sql.parser.ConstantNode) UserTypeConstantNode(com.akiban.sql.parser.UserTypeConstantNode) Column(com.revolsys.record.query.Column) ValueNodeList(com.akiban.sql.parser.ValueNodeList) NumericConstantNode(com.akiban.sql.parser.NumericConstantNode) SimpleStringOperatorNode(com.akiban.sql.parser.SimpleStringOperatorNode) InListOperatorNode(com.akiban.sql.parser.InListOperatorNode) BinaryOperatorNode(com.akiban.sql.parser.BinaryOperatorNode) BetweenOperatorNode(com.akiban.sql.parser.BetweenOperatorNode) Condition(com.revolsys.record.query.Condition) CodeTable(com.revolsys.record.code.CodeTable) BinaryLogicalOperatorNode(com.akiban.sql.parser.BinaryLogicalOperatorNode) Between(com.revolsys.record.query.Between) ILike(com.revolsys.record.query.ILike) QueryValue(com.revolsys.record.query.QueryValue) CastNode(com.akiban.sql.parser.CastNode) Not(com.revolsys.record.query.Not) IsNullNode(com.akiban.sql.parser.IsNullNode) And(com.revolsys.record.query.And) ValueNode(com.akiban.sql.parser.ValueNode) QueryValue(com.revolsys.record.query.QueryValue) CollectionValue(com.revolsys.record.query.CollectionValue) Value(com.revolsys.record.query.Value) IsNull(com.revolsys.record.query.IsNull) RowConstructorNode(com.akiban.sql.parser.RowConstructorNode) ColumnReference(com.akiban.sql.parser.ColumnReference) LikeEscapeOperatorNode(com.akiban.sql.parser.LikeEscapeOperatorNode)

Aggregations

And (com.revolsys.record.query.And)2 FieldDefinition (com.revolsys.record.schema.FieldDefinition)2 BetweenOperatorNode (com.akiban.sql.parser.BetweenOperatorNode)1 BinaryArithmeticOperatorNode (com.akiban.sql.parser.BinaryArithmeticOperatorNode)1 BinaryLogicalOperatorNode (com.akiban.sql.parser.BinaryLogicalOperatorNode)1 BinaryOperatorNode (com.akiban.sql.parser.BinaryOperatorNode)1 CastNode (com.akiban.sql.parser.CastNode)1 ColumnReference (com.akiban.sql.parser.ColumnReference)1 ConstantNode (com.akiban.sql.parser.ConstantNode)1 InListOperatorNode (com.akiban.sql.parser.InListOperatorNode)1 IsNullNode (com.akiban.sql.parser.IsNullNode)1 LikeEscapeOperatorNode (com.akiban.sql.parser.LikeEscapeOperatorNode)1 NotNode (com.akiban.sql.parser.NotNode)1 NumericConstantNode (com.akiban.sql.parser.NumericConstantNode)1 RowConstructorNode (com.akiban.sql.parser.RowConstructorNode)1 SimpleStringOperatorNode (com.akiban.sql.parser.SimpleStringOperatorNode)1 UserTypeConstantNode (com.akiban.sql.parser.UserTypeConstantNode)1 ValueNode (com.akiban.sql.parser.ValueNode)1 ValueNodeList (com.akiban.sql.parser.ValueNodeList)1 Identifier (com.revolsys.identifier.Identifier)1