use of com.revolsys.record.query.IsNotNull 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;
}
use of com.revolsys.record.query.IsNotNull in project com.revolsys.open by revolsys.
the class FieldFilterPanel method setFilter.
public void setFilter(final Condition filter) {
if (!this.fieldNames.isEmpty()) {
Invoke.later(() -> {
try (BaseCloseable settingFilter = this.settingFilter.closeable(true)) {
setSearchFilter(filter);
boolean simple = false;
if (Property.isEmpty(filter)) {
final Field searchField = (Field) this.searchField;
if (searchField != null) {
searchField.setFieldValue(null);
}
setSearchOperator("=");
simple = true;
} else if (filter instanceof Not) {
final Not not = (Not) filter;
final QueryValue condition = not.getValue();
if (condition instanceof IsNull) {
final IsNull isNull = (IsNull) condition;
final IsNotNull isNotNull = new IsNotNull(isNull.getValue());
setFilter(isNotNull);
return;
}
} else if (filter instanceof ILike) {
final ILike equal = (ILike) filter;
final QueryValue leftCondition = equal.getLeft();
final QueryValue rightCondition = equal.getRight();
if (leftCondition instanceof Column && rightCondition instanceof Value) {
final Column column = (Column) leftCondition;
final String searchFieldName = column.getName();
setSearchFieldName(searchFieldName);
if (setSearchOperator("Like")) {
final Value value = (Value) rightCondition;
final Object searchValue = value.getValue();
String searchText = DataTypes.toString(searchValue);
if (Property.hasValue(searchText)) {
setSearchField(this.searchTextField);
searchText = searchText.replaceAll("%", "");
final String previousSearchText = this.searchTextField.getText();
if (!DataType.equal(searchText, previousSearchText)) {
this.searchTextField.setFieldValue(searchText);
}
simple = true;
} else {
setSearchFilter(null);
}
}
}
} else if (filter instanceof BinaryCondition) {
final BinaryCondition condition = (BinaryCondition) filter;
final QueryValue leftCondition = condition.getLeft();
final QueryValue rightCondition = condition.getRight();
if (leftCondition instanceof Column && rightCondition instanceof Value) {
final Column column = (Column) leftCondition;
final String searchFieldName = column.getName();
setSearchFieldName(searchFieldName);
final String searchOperator = condition.getOperator();
if (setSearchOperator(searchOperator)) {
final Value value = (Value) rightCondition;
final Object searchValue = value.getValue();
final String searchText = DataTypes.toString(searchValue);
final Field searchField = (Field) this.searchField;
final Object oldValue = searchField.getFieldValue();
if (!searchText.equalsIgnoreCase(DataTypes.toString(oldValue))) {
searchField.setFieldValue(searchText);
}
simple = true;
}
}
} else if (filter instanceof RightUnaryCondition) {
final RightUnaryCondition condition = (RightUnaryCondition) filter;
final String operator = condition.getOperator();
if (filter instanceof IsNull || filter instanceof IsNotNull) {
final QueryValue leftValue = condition.getValue();
if (leftValue instanceof Column) {
final Column column = (Column) leftValue;
final String searchFieldName = column.getName();
setSearchFieldName(searchFieldName);
if (setSearchOperator(operator)) {
simple = true;
}
}
}
}
if (simple) {
this.whereLabel.setVisible(false);
if (this.nameField != null) {
this.nameField.setVisible(true);
}
if (this.operatorField != null) {
this.operatorField.setVisible(true);
}
this.searchFieldPanel.setVisible(true);
} else {
String filterText = filter.toString();
if (filterText.length() > 40) {
filterText = filterText.substring(0, 40) + "...";
}
this.whereLabel.setText(filterText);
this.whereLabel.setToolTipText(filterText);
this.whereLabel.setVisible(true);
if (this.nameField != null) {
this.nameField.setVisible(false);
}
this.operatorField.setVisible(false);
this.searchFieldPanel.setVisible(false);
}
}
});
}
}
Aggregations