@Override public String getPreparedSQL(Session session, List<Value> parameters) { String sql; if (regexp) { sql = left.getPreparedSQL(session, parameters) + " REGEXP " + right.getPreparedSQL(session, parameters); } else { sql = left.getPreparedSQL(session, parameters) + " LIKE " + right.getPreparedSQL(session, parameters); if (escape != null) { sql += " ESCAPE " + escape.getPreparedSQL(session, parameters); } } return "(" + sql + ")"; }
/** * Convert this expression to a String. * * @return the string representation */ @Override public String toString() { return getSQL(); }
/** * Get the current value of the expression. * * @param session the session * @return the value */ public Value getCurrentValue(Session session) { return expression.getValue(session); }
/** * Set the default expression. * * @param session the session * @param defaultExpression the default expression */ public void setDefaultExpression(Session session, Expression defaultExpression) { // also to test that no column names are used if (defaultExpression != null) { defaultExpression = defaultExpression.optimize(session); if (defaultExpression.isConstant()) { defaultExpression = ValueExpression.get( defaultExpression.getValue(session)); } } this.defaultExpression = defaultExpression; }
/** * Map the columns and add the join condition. * * @param on the condition */ public void mapAndAddFilter(Expression on) { on.mapColumns(this, 0); addFilterCondition(on, true); on.createIndexConditions(session, this); if (nestedJoin != null) { on.mapColumns(nestedJoin, 0); on.createIndexConditions(session, nestedJoin); } if (join != null) { join.mapAndAddFilter(on); } }
private void generateColumnsFromQuery() { int columnCount = prepared.getQuery().getColumnCount(); ArrayList<Expression> expressions = prepared.getQuery().getExpressions(); for (int i = 0; i < columnCount; i++) { Expression expr = expressions.get(i); int type = expr.getType(); String name = expr.getAlias(); long precision = expr.getPrecision(); int displaySize = expr.getDisplaySize(); DataType dt = DataType.getDataType(type); if (precision > 0 && (dt.defaultPrecision == 0 || (dt.defaultPrecision > precision && dt.defaultPrecision < Byte.MAX_VALUE))) { // dont' set precision to MAX_VALUE if this is the default precision = dt.defaultPrecision; } int scale = expr.getScale(); if (scale > 0 && (dt.defaultScale == 0 || (dt.defaultScale > scale && dt.defaultScale < precision))) { scale = dt.defaultScale; } if (scale > precision) { precision = scale; } Column col = new Column(name, type, precision, scale, displaySize); prepared.addColumn(col); } }
for (int i = 0; i < visibleColumnCount; i++) { Expression expr = expressions.get(i); expr = expr.getNonAliasExpression(); String sql = expr.getSQL(); expressionSQL.add(sql); for (int i = 0; i < size; i++) { Expression expr = group.get(i); String sql = expr.getSQL(); int found = -1; for (int j = 0; j < expSize; j++) { if (db.equalsIdentifiers(sql, e.getAlias())) { found = j; break; sql = expr.getAlias(); if (db.equalsIdentifiers(sql, e.getAlias())) { found = j; break; Expression expr = expressions.get(havingIndex); SelectListColumnResolver res = new SelectListColumnResolver(this); expr.mapColumns(res, 0);
@Override public Expression optimize(Session session) { Expression e2 = condition.getNotIfPossible(session); if (e2 != null) { return e2.optimize(session); } Expression expr = condition.optimize(session); if (expr.isConstant()) { Value v = expr.getValue(session); if (v == ValueNull.INSTANCE) { return ValueExpression.getNull(); } return ValueExpression.get(v.convertTo(Value.BOOLEAN).negate()); } condition = expr; return this; }
/** * @see http://dev.mysql.com/doc/refman/5.7/en/delete.html */ @Override public SQLTranslated translate(Delete prepared, ObjectNode node) { ArrayList<Value> params = New.arrayList(); String forTable = node.getCompositeObjectName(); Expression condition = prepared.getCondition(); Expression limitExpr = prepared.getLimitExpr(); StatementBuilder sql = new StatementBuilder(); sql.append("DELETE FROM "); sql.append(identifier(forTable)); if (condition != null) { condition.getPreparedSQL(prepared.getSession(), params); sql.append(" WHERE ").append(StringUtils.unEnclose(condition.getSQL())); } if (limitExpr != null) { limitExpr.getPreparedSQL(prepared.getSession(), params); sql.append(" LIMIT ").append(StringUtils.unEnclose(limitExpr.getSQL())); } return SQLTranslated.build().sql(sql.toString()).sqlParams(params); }
left = left.optimize(session); right = right.optimize(session); int lc = left.getCost(), rc = right.getCost(); if (rc < lc) { Expression t = left; session, compRight, true); if (added != null) { added = added.optimize(session); ConditionAndOr a = new ConditionAndOr(AND, this, added); return a; session, compRight, false); if (added != null) { return added.optimize(session); getAdditional((Comparison) right); if (added != null) { return added.optimize(session); getAdditional((Comparison) left); if (added != null) { return added.optimize(session); getAdditional(session, (Comparison) right); if (added != null) { return added.optimize(session); getAdditional(session, (Comparison) left);
} else if (tableAlias == null && db.equalsIdentifiers(col, ec.getAlias())) { found = true; } else { Expression ec2 = ec.getNonAliasExpression(); if (ec2 instanceof ExpressionColumn) { ExpressionColumn c2 = (ExpressionColumn) ec2; String s = e.getSQL(); if (expressionSQL != null) { for (int j = 0, size = expressionSQL.size(); j < size; j++) { if (mustBeInResult) { throw DbException.get(ErrorCode.ORDER_BY_NOT_IN_RESULT, e.getSQL()); String sql = e.getSQL(); expressionSQL.add(sql); Expression expr = expressions.get(idx).getNonAliasExpression(); o.expression = expr;
/** * 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; }
for (int i = 0; i < args.length; i++) { Expression e = args[i]; Value v = e.getValue(session); if (v == ValueNull.INSTANCE) { return ValueNull.INSTANCE; result = session.getVariable(args[0].getSchemaName() + "." + args[0].getTableName() + "." + args[0].getColumnName()); break; case EXPAND:
Expression comp; Expression col = expressions.get(columnId); col = col.getNonAliasExpression(); if (col.isEverything(ExpressionVisitor.QUERY_COMPARABLE_VISITOR)) { comp = new Comparison(session, comparisonType, col, param); } else { comp = comp.optimize(session); boolean addToCondition = true; if (isGroupQuery) {
while (topTableFilter.next()) { setCurrentRowNumber(rowNumber + 1); if (condition == null || Boolean.TRUE.equals(condition.getBooleanValue(session))) { Value key; rowNumber++; int idx = groupIndex[i]; Expression expr = expressions.get(idx); keyValues[i] = expr.getValue(session); if (groupByExpression == null || !groupByExpression[i]) { Expression expr = expressions.get(i); expr.updateAggregate(session); row[j] = expr.getValue(session);
if (info.type == CASE) { if (args[0] != null) { buff.append(" ").append(args[0].getPreparedSQL(session, parameters)); buff.append(" WHEN ").append(args[i].getPreparedSQL(session, parameters)); buff.append(" THEN ").append(args[i + 1].getPreparedSQL(session, parameters)); buff.append(" ELSE ").append(args[args.length - 1].getPreparedSQL(session, parameters)); switch (info.type) { case CAST: { buff.append(args[0].getPreparedSQL(session, parameters)).append(" AS ") .append(new Column(null, dataType, precision, scale, displaySize).getCreateSQL()); break; buff.append(args[0].getPreparedSQL(session, parameters)).append(',') .append(new Column(null, dataType, precision, scale, displaySize).getCreateSQL()); break; ValueString v = (ValueString) args[0].getValue(null); buff.append(v.getString()).append(" FROM ").append(args[1].getPreparedSQL(session, parameters)); break; for (Expression e : args) { buff.appendExceptFirst(", "); buff.append(e.getPreparedSQL(session, parameters));
@Override public void prepare() { if (condition != null) { condition.mapColumns(tableFilter, 0); condition = condition.optimize(session); condition.createIndexConditions(session, tableFilter); } TableFilter[] filters = new TableFilter[] { tableFilter }; PlanItem item = tableFilter.getBestPlanItem(session, filters, 0); tableFilter.setPlanItem(item); tableFilter.prepare(); }
buff.appendExceptFirst(","); buff.append('\n'); buff.append(StringUtils.indent(exprList[i].getSQL(), 4, false)); buff.append("\nWHERE ").append(StringUtils.unEnclose(condition.getSQL())); for (int gi : groupIndex) { Expression g = exprList[gi]; g = g.getNonAliasExpression(); buff.appendExceptFirst(", "); buff.append(StringUtils.unEnclose(g.getSQL())); for (Expression g : group) { buff.appendExceptFirst(", "); buff.append(StringUtils.unEnclose(g.getSQL())); buff.append("\nHAVING ").append(StringUtils.unEnclose(h.getSQL())); } else if (havingIndex >= 0) { Expression h = exprList[havingIndex]; buff.append("\nHAVING ").append(StringUtils.unEnclose(h.getSQL())); buff.append("\nLIMIT ").append(StringUtils.unEnclose(limitExpr.getSQL())); if (offsetExpr != null) { buff.append(" OFFSET ").append(StringUtils.unEnclose(offsetExpr.getSQL())); buff.append("\nSAMPLE_SIZE ").append(StringUtils.unEnclose(sampleSizeExpr.getSQL()));
buff.appendExceptFirst(","); buff.append(' '); buff.append(selectCols[i].getPreparedSQL(select.getSession(), params)); if (condition != null) { buff.append(" WHERE ").append( StringUtils.unEnclose(condition.getPreparedSQL(select.getSession(), params))); for (int gi : groupIndex) { Expression g = exprList[gi]; g = g.getNonAliasExpression(); buff.appendExceptFirst(", "); buff.append(StringUtils.unEnclose(g.getPreparedSQL(select.getSession(), params))); for (Expression g : group) { buff.appendExceptFirst(", "); buff.append(StringUtils.unEnclose(g.getPreparedSQL(select.getSession(), params)));