def compile_tablejoin(compile, expr, state):
if expr._nested:
state.sql.append('(')
if expr._left is not None:
compile(expr._left, state)
if expr._join_type:
state.sql.append(SPACE)
if expr._natural:
state.sql.append('NATURAL ')
state.sql.append(expr._join_type)
state.sql.append(SPACE)
state.push('context', CONTEXT.TABLE)
compile(expr._table, state)
state.pop()
if expr._on is not None:
state.sql.append(' ON ')
state.push("context", CONTEXT.EXPR)
compile(expr._on, state)
state.pop()
elif expr._using is not None:
state.sql.append(' USING ')
compile(expr._using, state)
if expr._hint is not None:
state.sql.append(SPACE)
compile(expr._hint, state)
if expr._nested:
state.sql.append(')')
def compile_subfield(compile, expr, state):
parent = expr.parent
if True: # get me from context
parent = Parentheses(parent)
compile(parent)
state.sql.append('.')
compile(expr.name, state)
def compile_cast(compile, expr, state):
state.sql.append(expr.sql)
state.sql.append('(')
compile(expr.expr, state)
state.sql.append(' AS ')
state.sql.append(expr.type)
state.sql.append(')')
def compile_like(compile, expr, state):
compile_binary(compile, expr, state)
if expr.escape is not Undef:
state.sql.append(' ESCAPE ')
compile(
Value(expr.escape)
if isinstance(expr.escape, string_types) else expr.escape, state)
def compile_tablejoin(compile, expr, state):
if expr._nested:
state.sql.append('(')
if expr._left is not None:
compile(expr._left, state)
if expr._join_type:
state.sql.append(SPACE)
if expr._natural:
state.sql.append('NATURAL ')
state.sql.append(expr._join_type)
state.sql.append(SPACE)
state.push('context', CONTEXT.TABLE)
compile(expr._table, state)
state.pop()
if expr._on is not None:
state.sql.append(' ON ')
state.push("context", CONTEXT.EXPR)
compile(expr._on, state)
state.pop()
elif expr._using is not None:
state.sql.append(' USING ')
compile(expr._using, state)
if expr._hint is not None:
state.sql.append(SPACE)
compile(expr._hint, state)
if expr._nested:
state.sql.append(')')
def compile_arrayitem(compile, expr, state):
compile(expr.array)
state.sql.append("[")
state.sql.append("{0:d}".format(expr.key.start))
if expr.key.stop is not None:
state.sql.append(", ")
state.sql.append("{0:d}".format(expr.key.stop))
state.sql.append("]")
def compile_field(compile, expr, state):
if expr._prefix is not None and state.context != CONTEXT.FIELD_NAME:
state.auto_tables.append(expr._prefix) # it's important to know the concrete alias of table.
state.push("context", CONTEXT.FIELD_PREFIX)
compile(expr._prefix, state)
state.pop()
state.sql.append('.')
compile(expr._name, state)
def compile_exprlist(compile, expr, state):
first = True
for a in expr:
if first:
first = False
else:
state.sql.append(expr.sql)
compile(a, state)
def compile_concat(compile, expr, state):
if not expr.ws():
return compile_exprlist(compile, expr, state)
state.sql.append('concat_ws(')
compile(expr.ws(), state)
for a in expr:
state.sql.append(expr.sql)
compile(a, state)
state.sql.append(')')
def compile_case(compile, expr, state):
state.sql.append('CASE')
if expr.expr is not Undef:
state.sql.append(SPACE)
compile(expr.expr, state)
for clause, value in expr.cases:
state.sql.append(' WHEN ')
compile(clause, state)
state.sql.append(' THEN ')
compile(value, state)
if expr.default is not Undef:
state.sql.append(' ELSE ')
compile(expr.default, state)
state.sql.append(' END ')
def compile_delete(compile, expr, state):
state.sql.append("DELETE FROM ")
state.push("context", CONTEXT.TABLE)
compile(expr.table, state)
state.context = CONTEXT.EXPR
if expr.where:
state.sql.append(" WHERE ")
compile(expr.where, state)
if expr.order_by:
state.sql.append(" ORDER BY ")
compile(expr.order_by, state)
if expr.limit is not None:
state.sql.append(" LIMIT ")
compile(expr.limit, state)
state.pop()
def compile_raw(compile, expr, state):
compile(expr._raw, state)
if expr._limit is not None:
state.sql.append(" LIMIT ")
compile(expr._limit, state)
if expr._offset:
state.sql.append(" OFFSET ")
compile(expr._offset, state)
def compile_ternary(compile, expr, state):
compile(expr.first, state)
state.sql.append(SPACE)
state.sql.append(expr.sql)
state.sql.append(SPACE)
compile(expr.second, state)
state.sql.append(SPACE)
state.sql.append(expr.second_sql)
state.sql.append(SPACE)
compile(expr.third, state)
def compile_set(compile, expr, state):
state.push("context", CONTEXT.SELECT)
if expr._all:
op = ' {0} ALL '.format(expr.sql)
else:
op = ' {0} '.format(expr.sql)
# TODO: add tests for nested sets.
state.precedence += 0.5 # to correct handle sub-set with limit, offset
compile(expr._exprs.join(op), state)
state.precedence -= 0.5
if expr._order_by:
# state.context = CONTEXT.FIELD_NAME
state.context = CONTEXT.EXPR
state.sql.append(" ORDER BY ")
compile(expr._order_by, state)
if expr._limit is not None:
state.sql.append(" LIMIT ")
compile(expr._limit, state)
if expr._offset:
state.sql.append(" OFFSET ")
compile(expr._offset, state)
if expr._for_update:
state.sql.append(" FOR UPDATE")
state.pop()
def compile_alias(compile, expr, state):
if state.context == CONTEXT.FIELD:
compile(expr.expr, state)
state.sql.append(' AS ')
compile(expr.sql, state)
def compile_table(compile, expr, state):
compile(expr._name, state)
def compile_list(compile, expr, state):
compile(Parentheses(ExprList(*expr).join(", ")), state)
def compile_tablealias(compile, expr, state):
if expr._table is not None and state.context == CONTEXT.TABLE:
compile(expr._table, state)
state.sql.append(' AS ')
compile(expr._name, state)
def compile_tablealias(compile, expr, state):
if expr._table is not None and state.context == CONTEXT.TABLE:
compile(expr._table, state)
state.sql.append(' AS ')
compile(expr._name, state)
def compile_escapeforlike(compile, expr, state):
escaped = expr.expr
for k, v in expr.escape_map:
escaped = func.Replace(escaped, Value(k), Value(v))
compile(escaped, state)
def compile_omitparentheses(compile, expr, state):
state.precedence = 0
compile(expr.expr, state)
def compile_update(compile, expr, state):
state.push("context", CONTEXT.TABLE)
state.sql.append("UPDATE ")
if expr.ignore:
state.sql.append("IGNORE ")
compile(expr.table, state)
state.sql.append(" SET ")
first = True
for field, value in zip(expr.fields, expr.values):
if first:
first = False
else:
state.sql.append(", ")
state.context = CONTEXT.FIELD_NAME
compile(field, state)
state.context = CONTEXT.EXPR
state.sql.append(" = ")
compile(value, state)
state.context = CONTEXT.EXPR
if expr.where:
state.sql.append(" WHERE ")
compile(expr.where, state)
if expr.order_by:
state.sql.append(" ORDER BY ")
compile(expr.order_by, state)
if expr.limit is not None:
state.sql.append(" LIMIT ")
compile(expr.limit, state)
state.pop()
def compile_postfix(compile, expr, state):
compile(expr.expr, state)
state.sql.append(SPACE)
state.sql.append(expr.sql)
def compile_unary(compile, expr, state):
state.sql.append(expr.sql)
compile(expr.expr, state)
def compile_fieldproxy(compile, expr, state):
compile(expr.id._prefix, state)
def compile_type(compile, model, state):
""" Any class can be used as Table """
compile(model_registry[model], state)
def compile_fieldproxy(compile, expr, state):
compile(expr.id._prefix, state)
def qn(name, compile):
return compile(Name(name))[0]
def expr_repr(expr):
return "<{0}: {1}, {2!r}>".format(type(expr).__name__, *compile(expr))
def compile_callable(compile, expr, state):
compile(expr.expr, state)
state.sql.append('(')
compile(expr.args, state)
state.sql.append(')')
def compile_namedcallable(compile, expr, state):
state.sql.append(expr.sql)
state.sql.append('(')
compile(expr.args, state)
state.sql.append(')')
def compile_type(compile, model, state):
""" Any class can be used as Table """
compile(model_registry[model], state)
def compile_prefix(compile, expr, state):
state.sql.append(expr.sql)
state.sql.append(SPACE)
compile(expr.expr, state)
def compile_table(compile, expr, state):
compile(expr._name, state)
def compile_binary(compile, expr, state):
compile(expr.left, state)
state.sql.append(SPACE)
state.sql.append(expr.sql)
state.sql.append(SPACE)
compile(expr.right, state)
def compile_param(compile, expr, state):
compile(expr.params, state)
def qn(name, compile):
return compile(Name(name))[0]
def compile_parentheses(compile, expr, state):
state.precedence += MAX_PRECEDENCE
compile(expr.expr, state)
