def __sqlrepr__(self, db):
escape = self.escape
like = "%s %s (%s)" % (sqlrepr(self.expr, db), self.op, sqlrepr(self.string, db))
if escape is None:
return "(%s)" % like
else:
return "(%s ESCAPE %s)" % (like, sqlrepr(escape, db))
def __sqlrepr__(self, db):
s1 = sqlrepr(self.expr1, db)
s2 = sqlrepr(self.expr2, db)
if s1[0] != '(' and s1 != 'NULL':
s1 = '(' + s1 + ')'
if s2[0] != '(' and s2 != 'NULL':
s2 = '(' + s2 + ')'
return "(%s %s %s)" % (s1, self.op, s2)
def __sqlrepr__(self, db):
s1 = sqlrepr(self.expr1, db)
s2 = sqlrepr(self.expr2, db)
if s1[0] != "(" and s1 != "NULL":
s1 = "(" + s1 + ")"
if s2[0] != "(" and s2 != "NULL":
s2 = "(" + s2 + ")"
return "(%s %s %s)" % (s1, self.op, s2)
def __sqlrepr__(self, db):
if not self.valueList:
return ''
insert = "INSERT INTO %s" % self.table
allowNonDict = True
template = self.template
if template is NoDefault and type(self.valueList[0]) is type({}):
template = self.valueList[0].keys()
allowNonDict = False
if template is not NoDefault:
insert += " (%s)" % ", ".join(template)
first = True
insert += " VALUES "
for value in self.valueList:
if first:
first = False
else:
insert += ", "
if type(value) is type({}):
if template is NoDefault:
raise TypeError, "You can't mix non-dictionaries with dictionaries in an INSERT if you don't provide a template (%s)" % repr(value)
value = dictToList(template, value)
elif not allowNonDict:
raise TypeError, "You can't mix non-dictionaries with dictionaries in an INSERT if you don't provide a template (%s)" % repr(value)
insert += "(%s)" % ", ".join([sqlrepr(v, db) for v in value])
return insert
def __sqlrepr__(self, db):
if self.proxy.soClass is None:
return '_DELAYED_' + self.attr
val = self._resolve()
if isinstance(val, SQLExpression):
val = sqlrepr(val, db)
return val
def __sqlrepr__(self, db):
s = sqlrepr(self.expr, db)[1:-1] # remove quotes
if db in ('postgres', 'mysql'):
s = s.replace('%', '\\%')
else:
s = s.replace('%', '%%')
return "'%s%s%s'" % (self.prefix, s, self.postfix)
def __sqlrepr__(self, db):
if not self.valueList:
return ''
insert = "INSERT INTO %s" % self.table
allowNonDict = True
template = self.template
if template is NoDefault and type(self.valueList[0]) is type({}):
template = self.valueList[0].keys()
allowNonDict = False
if template is not NoDefault:
insert += " (%s)" % ", ".join(template)
first = True
insert += " VALUES "
for value in self.valueList:
if first:
first = False
else:
insert += ", "
if type(value) is type({}):
if template is NoDefault:
raise TypeError, "You can't mix non-dictionaries with dictionaries in an INSERT if you don't provide a template (%s)" % repr(value)
value = dictToList(template, value)
elif not allowNonDict:
raise TypeError, "You can't mix non-dictionaries with dictionaries in an INSERT if you don't provide a template (%s)" % repr(value)
insert += "(%s)" % ", ".join([sqlrepr(v, db) for v in value])
return insert
def __sqlrepr__(self, db):
if not self.valueList:
return ''
insert = "INSERT INTO %s" % self.table
allowNonDict = True
template = self.template
if (template is NoDefault) and isinstance(self.valueList[0], dict):
template = self.valueList[0].keys()
allowNonDict = False
if template is not NoDefault:
insert += " (%s)" % ", ".join(template)
insert += " VALUES "
listToJoin = []
listToJoin_app = listToJoin.append
for value in self.valueList:
if isinstance(value, dict):
if template is NoDefault:
raise TypeError, "You can't mix non-dictionaries with dictionaries in an INSERT if you don't provide a template (%s)" % repr(
value)
value = dictToList(template, value)
elif not allowNonDict:
raise TypeError, "You can't mix non-dictionaries with dictionaries in an INSERT if you don't provide a template (%s)" % repr(
value)
listToJoin_app("(%s)" % ", ".join([sqlrepr(v, db) for v in value]))
insert = "%s%s" % (insert, ", ".join(listToJoin))
return insert
def __sqlrepr__(self, db):
if not self.valueList:
return ""
insert = "INSERT INTO %s" % self.table
allowNonDict = True
template = self.template
if (template is NoDefault) and isinstance(self.valueList[0], dict):
template = list(sorted(self.valueList[0].keys()))
allowNonDict = False
if template is not NoDefault:
insert += " (%s)" % ", ".join(template)
insert += " VALUES "
listToJoin = []
listToJoin_app = listToJoin.append
for value in self.valueList:
if isinstance(value, dict):
if template is NoDefault:
raise TypeError, "You can't mix non-dictionaries with dictionaries in an INSERT if you don't provide a template (%s)" % repr(
value
)
value = dictToList(template, value)
elif not allowNonDict:
raise TypeError, "You can't mix non-dictionaries with dictionaries in an INSERT if you don't provide a template (%s)" % repr(
value
)
listToJoin_app("(%s)" % ", ".join([sqlrepr(v, db) for v in value]))
insert = "%s%s" % (insert, ", ".join(listToJoin))
return insert
def __sqlrepr__(self, db):
whereClause = self.whereClause
if whereClause is None:
return "DELETE FROM %s" % self.table
if isinstance(whereClause, SQLExpression):
whereClause = sqlrepr(whereClause, db)
return "DELETE FROM %s WHERE %s" % (self.table, whereClause)
def tablesUsedSet(self, db):
tables = set()
for table in self.tablesUsedImmediate():
if hasattr(table, '__sqlrepr__'):
table = sqlrepr(table, db)
tables.add(table)
for component in self.components():
tables.update(tablesUsedSet(component, db))
return tables
def __sqlrepr__(self, db):
s = self.expr
if isinstance(s, SQLExpression):
values = []
if self.prefix:
values.append("'%s'" % self.prefix)
s = _quote_like_special(sqlrepr(s, db), db)
values.append(s)
if self.postfix:
values.append("'%s'" % self.postfix)
if db == "mysql":
return "CONCAT(%s)" % ", ".join(values)
else:
return " || ".join(values)
elif isinstance(s, basestring):
s = _quote_like_special(sqlrepr(s, db)[1:-1], db)
return "'%s%s%s'" % (self.prefix, s, self.postfix)
else:
raise TypeError, "expected str, unicode or SQLExpression, got %s" % type(s)
def __sqlrepr__(self, db):
update = "%s %s" % (self.sqlName(), self.table)
update += " SET"
first = True
if self.template is not NoDefault:
for i in range(len(self.template)):
if first:
first = False
else:
update += ","
update += " %s=%s" % (self.template[i], sqlrepr(self.values[i], db))
else:
for key, value in self.values.items():
if first:
first = False
else:
update += ","
update += " %s=%s" % (key, sqlrepr(value, db))
if self.whereClause is not NoDefault:
update += " WHERE %s" % sqlrepr(self.whereClause, db)
return update
def __sqlrepr__(self, db):
select = "SELECT %s" % ", ".join([sqlrepr(v, db) for v in self.items])
tables = {}
things = self.items
if self.whereClause is not NoDefault:
things.append(self.whereClause)
for thing in things:
if isinstance(thing, SQLExpression):
tables.update(tablesUsedDict(thing))
tables = tables.keys()
if tables:
select += " FROM %s" % ", ".join(tables)
if self.whereClause is not NoDefault:
select += " WHERE %s" % sqlrepr(self.whereClause, db)
if self.groupBy is not NoDefault:
select += " GROUP BY %s" % sqlrepr(self.groupBy, db)
if self.having is not NoDefault:
select += " HAVING %s" % sqlrepr(self.having, db)
if self.orderBy is not NoDefault:
select += " ORDER BY %s" % sqlrepr(self.orderBy, db)
if self.limit is not NoDefault:
select += " LIMIT %s" % sqlrepr(self.limit, db)
return select
def __sqlrepr__(self, db):
select = "SELECT %s" % ", ".join([sqlrepr(v, db) for v in self.items])
tables = {}
things = self.items
if self.whereClause is not NoDefault:
things.append(self.whereClause)
for thing in things:
if isinstance(thing, SQLExpression):
tables.update(tablesUsedDict(thing))
tables = tables.keys()
if tables:
select += " FROM %s" % ", ".join(tables)
if self.whereClause is not NoDefault:
select += " WHERE %s" % sqlrepr(self.whereClause, db)
if self.groupBy is not NoDefault:
select += " GROUP BY %s" % sqlrepr(self.groupBy, db)
if self.having is not NoDefault:
select += " HAVING %s" % sqlrepr(self.having, db)
if self.orderBy is not NoDefault:
select += " ORDER BY %s" % sqlrepr(self.orderBy, db)
if self.limit is not NoDefault:
select += " LIMIT %s" % sqlrepr(self.limit, db)
return select
def __sqlrepr__(self, db):
if self.on_condition:
on_condition = self.on_condition
if hasattr(on_condition, "__sqlrepr__"):
on_condition = sqlrepr(on_condition, db)
join = "%s %s ON %s" % (self.op, self.table2, on_condition)
if self.table1:
join = "%s %s" % (self.table1, join)
return join
elif self.using_columns:
using_columns = []
for col in self.using_columns:
if hasattr(col, "__sqlrepr__"):
col = sqlrepr(col, db)
using_columns.append(col)
using_columns = ", ".join()
join = "%s %s USING (%s)" % (self.op, self.table2, using_columns)
if self.table1:
join = "%s %s" % (self.table1, join)
return join
else:
RuntimeError, "Impossible error"
def __sqlrepr__(self, db):
s = self.expr
if isinstance(s, SQLExpression):
values = []
if self.prefix:
values.append("'%s'" % self.prefix)
s = _quote_percent(sqlrepr(s, db), db)
values.append(s)
if self.postfix:
values.append("'%s'" % self.postfix)
if db == "mysql":
return "CONCAT(%s)" % ", ".join(values)
else:
return " || ".join(values)
else: # assuming s is a string
s = _quote_percent(s, db)
return "'%s%s%s'" % (self.prefix, s, self.postfix)
def __sqlrepr__(self, db):
select = "SELECT %s" % ", ".join([sqlrepr(v, db) for v in self.items])
join = []
if self.join is not NoDefault:
if isinstance(self.join, SQLJoin):
join.append(self.join)
else:
join.extend(self.join)
tables = {}
things = list(self.items)
if self.whereClause is not NoDefault:
things.append(self.whereClause)
for thing in things:
if isinstance(thing, SQLExpression):
tables.update(tablesUsedDict(thing))
for j in join:
if j.table1 in tables: del tables[j.table1]
if j.table2 in tables: del tables[j.table2]
tables = tables.keys()
if tables:
select += " FROM %s" % ", ".join(tables)
elif join:
select += " FROM "
for j in join:
if tables and j.table1:
sep = ", "
else:
sep = " "
select += sep + sqlrepr(j, db)
if self.whereClause is not NoDefault:
select += " WHERE %s" % sqlrepr(self.whereClause, db)
if self.groupBy is not NoDefault:
groupBy = sqlrepr(self.groupBy, db)
if isinstance(self.groupBy, list) or isinstance(self.groupBy, tuple):
groupBy = groupBy[1:-1] # Remove parens
select += " GROUP BY %s" % groupBy
if self.having is not NoDefault:
select += " HAVING %s" % sqlrepr(self.having, db)
if self.orderBy is not NoDefault:
orderBy = sqlrepr(self.orderBy, db)
if isinstance(self.orderBy, list) or isinstance(self.orderBy, tuple):
orderBy = orderBy[1:-1] # Remove parens
select += " ORDER BY %s" % orderBy
if self.limit is not NoDefault:
select += " LIMIT %s" % sqlrepr(self.limit, db)
return select
def __sqlrepr__(self, db):
if self.on_condition:
on_condition = self.on_condition
if hasattr(on_condition, "__sqlrepr__"):
on_condition = sqlrepr(on_condition, db)
join = "%s %s ON %s" % (self.op, sqlrepr(self.table2, db), on_condition)
if self.table1:
join = "%s %s" % (sqlrepr(self.table1, db), join)
return join
elif self.using_columns:
using_columns = []
for col in self.using_columns:
if hasattr(col, "__sqlrepr__"):
col = sqlrepr(col, db)
using_columns.append(col)
using_columns = ", ".join(using_columns)
join = "%s %s USING (%s)" % (self.op, sqlrepr(self.table2, db), using_columns)
if self.table1:
join = "%s %s" % (sqlrepr(self.table1, db), join)
return join
else:
RuntimeError, "Impossible error"
def __sqlrepr__(self, db):
select = "SELECT"
if self.ops['distinct']:
select += " DISTINCT"
if self.ops['distinctOn'] is not NoDefault:
select += " ON(%s)" % sqlrepr(self.ops['distinctOn'], db)
if not self.ops['lazyColumns']:
select += " %s" % ", ".join([str(sqlrepr(v, db)) for v in self.ops['items']])
else:
select += " %s" % sqlrepr(self.ops['items'][0], db)
join = []
join_str = ''
if self.ops['join'] is not NoDefault and self.ops['join'] is not None:
_join = self.ops['join']
if isinstance(_join, str):
join_str = " " + _join
elif isinstance(_join, SQLJoin):
join.append(_join)
else:
join.extend(_join)
tables = set()
for x in self.ops['staticTables']:
if isinstance(x, SQLExpression):
x = sqlrepr(x, db)
tables.add(x)
things = list(self.ops['items']) + join
if self.ops['clause'] is not NoDefault:
things.append(self.ops['clause'])
for thing in things:
if isinstance(thing, SQLExpression):
tables.update(tablesUsedSet(thing, db))
for j in join:
t1, t2 = sqlrepr(j.table1, db), sqlrepr(j.table2, db)
if t1 in tables: tables.remove(t1)
if t2 in tables: tables.remove(t2)
if tables:
select += " FROM %s" % ", ".join(tables)
elif join:
select += " FROM"
tablesYet = tables
for j in join:
if tablesYet and j.table1:
sep = ", "
else:
sep = " "
select += sep + sqlrepr(j, db)
tablesYet = True
if join_str:
select += join_str
if self.ops['clause'] is not NoDefault:
select += " WHERE %s" % sqlrepr(self.ops['clause'], db)
if self.ops['groupBy'] is not NoDefault:
groupBy = sqlrepr(self.ops['groupBy'], db)
if isinstance(self.ops['groupBy'], (list, tuple)):
groupBy = groupBy[1:-1] # Remove parens
select += " GROUP BY %s" % groupBy
if self.ops['having'] is not NoDefault:
select += " HAVING %s" % sqlrepr(self.ops['having'], db)
if self.ops['orderBy'] is not NoDefault and self.ops['orderBy'] is not None:
orderBy = self.ops['orderBy']
if self.ops['reversed']:
reverser = DESC
else:
reverser = lambda x: x
if isinstance(orderBy, (list, tuple)):
select += " ORDER BY %s" % ", ".join([sqlrepr(reverser(x), db) for x in orderBy])
else:
select += " ORDER BY %s" % sqlrepr(reverser(orderBy), db)
start, end = self.ops['start'], self.ops['end']
if self.ops['limit'] is not NoDefault:
end = start + self.ops['limit']
if start or end:
from dbconnection import dbConnectionForScheme
select = dbConnectionForScheme(db)._queryAddLimitOffset(select, start, end)
if self.ops['forUpdate']:
select += " FOR UPDATE"
return select
def __sqlrepr__(self, db):
return " UNION ".join([str(sqlrepr(t, db)) for t in self.tables])
def __sqlrepr__(self, db):
return sqlrepr(self.q, db)
def __sqlrepr__(self, db):
return "%s %s %s" % (sqlrepr(self.tableName, db), self.as_string, self.alias)
def __sqlrepr__(self, db):
fieldName = self.fieldName
if isinstance(fieldName, SQLExpression):
fieldName = sqlrepr(fieldName, db)
return self.alias + "." + fieldName
def __sqlrepr__(self, db):
if isinstance(self.expr, DESC):
return sqlrepr(self.expr.expr, db)
return '%s DESC' % sqlrepr(self.expr, db)
def __sqlrepr__(self, db):
return "%s%s" % (sqlrepr(self.expr, db), sqlrepr(self.args, db))
def getExpression(self, desc, db):
if isinstance(desc['expression'], str):
return desc['expression']
else:
return sqlrepr(desc['expression'], db)
def __sqlrepr__(self, db):
return "%s (%s)" % (self.op, sqlrepr(self.subquery, db))
def __sqlrepr__(self, db):
if db == 'sqlite':
return SQLOp.__sqlrepr__(self, db)
s1 = sqlrepr(self.expr1, db)
s2 = sqlrepr(self.expr2, db)
return "MOD(%s, %s)" % (s1, s2)
def _str_or_sqlrepr(expr, db):
if isinstance(expr, basestring):
return expr
return sqlrepr(expr, db)
def __sqlrepr__(self, db):
return "%s %s" % (self.prefix, sqlrepr(self.expr, db))
def __sqlrepr__(self, db):
if self.whereClause is None:
return "DELETE FROM %s" % self.table
return "DELETE FROM %s WHERE %s" \
% (self.table, sqlrepr(self.whereClause, db))
def __sqlrepr__(self, db):
if isinstance(self.tableName, str):
return self.tableName
return sqlrepr(self.tableName, db)
def __sqlrepr__(self, db):
return "%s %s %s" % (sqlrepr(self.expr1, db), self.op, sqlrepr(self.expr2, db))
def sqlrepr(self, v):
return sqlrepr(v, self.dbName)
def __sqlrepr__(self, db):
if self.table1:
return "%s%s %s" % (sqlrepr(self.table1, db), self.op, sqlrepr(self.table2, db))
else:
return "%s %s" % (self.op, sqlrepr(self.table2, db))
def __sqlrepr__(self, db):
return "(%s %s (%s))" % (
sqlrepr(self.expr, db), self._get_op(db), sqlrepr(self.string, db)
)
