@Override public int getColumnType(int i) { return expressions[i].getType(); }
@Override public int getColumnType(int i) { return expressions[i].getType(); }
@Override public int getType() { return expr.getType(); }
@Override public void prepare() { expression = expression.optimize(session); expressions = new Expression[] { expression }; isResultSet = expression.getType() == Value.RESULT_SET; if (isResultSet) { prepareAlways = true; } }
@Override public int getType() { return getExpression().getType(); }
private Value[] convert(Value[] values, int columnCount) { Value[] newValues; if (columnCount == values.length) { // re-use the array if possible newValues = values; } else { // create a new array if needed, // for the value hash set newValues = new Value[columnCount]; } for (int i = 0; i < columnCount; i++) { Expression e = expressions.get(i); newValues[i] = values[i].convertTo(e.getType()); } return newValues; }
/** * Create a new IN(..) condition. * * @param session the session * @param left the expression before IN * @param valueList the value list (at least two elements) */ public ConditionInConstantSet(final Session session, Expression left, ArrayList<Expression> valueList) { this.left = left; this.valueList = valueList; this.valueSet = new TreeSet<>(new Comparator<Value>() { @Override public int compare(Value o1, Value o2) { return session.getDatabase().compare(o1, o2); } }); int type = left.getType(); for (Expression expression : valueList) { valueSet.add(expression.getValue(session).convertTo(type)); } }
/** * Add an additional element if possible. Example: given two conditions * A IN(1, 2) OR A=3, the constant 3 is added: A IN(1, 2, 3). * * @param session the session * @param other the second condition * @return null if the condition was not added, or the new condition */ Expression getAdditional(Session session, Comparison other) { Expression add = other.getIfEquals(left); if (add != null) { if (add.isConstant()) { valueList.add(add); valueSet.add(add.getValue(session).convertTo(left.getType())); return this; } } return null; } }
columnExp.getType()));
@Override public Expression[] getExpressionColumns(Session session) { ExpressionColumn[] expr = new ExpressionColumn[list.length]; for (int i = 0; i < list.length; i++) { Expression e = list[i]; Column col = new Column("C" + (i + 1), e.getType(), e.getPrecision(), e.getScale(), e.getDisplaySize()); expr[i] = new ExpressionColumn(session.getDatabase(), col); } return expr; }
@Override public Expression optimize(Session session) { userConnection = session.createConnection(false); int len = args.length; argTypes = new int[len]; for (int i = 0; i < len; i++) { Expression expr = args[i]; args[i] = expr.optimize(session); int type = expr.getType(); argTypes[i] = type; } try { Aggregate aggregate = getInstance(); dataType = aggregate.getInternalType(argTypes); } catch (SQLException e) { throw DbException.convert(e); } if (filterCondition != null) { filterCondition = filterCondition.optimize(session); } return this; }
boolean b = false; for (int i = 0; i < expressions.length; i++) { int type = expressions[i].getType(); Column col = new Column(COLUMN_NAME + i, type);
int leftType = left.getType(); if (leftType == Value.UNKNOWN) { return this;
for (int i = 0; i < columnCount; i++) { Expression expr = expressions.get(i); int type = expr.getType(); String name = columnNamer.getColumnName(expr,i,expr.getAlias()); long precision = expr.getPrecision();
left = left.optimize(session); right = right.optimize(session); if (left.getType() == Value.STRING_IGNORECASE) { ignoreCase = true;
int colType = left.getType(); int constType = r.getType(); int resType = Value.getHigherOrder(colType, constType);
DataType dfltType = DataType.getDataType(col.getDefaultExpression().getType());