def __init__(self,
query_resolvers=None,
mutation_resolvers=None,
omit=None,
hooks=None):
self.query_resolvers = to_tuple(query_resolvers
or self.query_resolvers)
self.mutation_resolvers = to_tuple(mutation_resolvers
or self.mutation_resolvers)
self.omit = omit or 0
self.hooks = hooks or self.hooks
def parse_query(self, queryable):
expr = self.parse_query_from_components(queryable.source,
queryable.selection,
queryable=queryable)
if queryable.recurse_column:
alias = self.root.create_alias(expr)
top_level = Select(alias,
columns=expr.columns +
tuple(expr.subqueries.keys()))
alias.push_selection(Selection(queryable.recurse_column))
cte_as = alias.expression
join = Join(alias)
recursive_expr = self.parse_query_from_components(
queryable.source, queryable.selection, queryable=queryable)
recursive_expr.push_selection(Selection(queryable.recurse_column))
# TODO: This is the worst.
if isinstance(recursive_expr.relation, As):
expr_to_update = recursive_expr.relation.expression.expression
else:
expr_to_update = recursive_expr
expr_to_update.joins = to_tuple(expr_to_update.joins) + (join, )
expr_to_update.where = Where(id=SQL('{}.{}').format(
Identifier(alias.alias), Identifier(queryable.recurse_column)))
cte_as.set_recursive_expression(recursive_expr)
expr = top_level
return expr
def add_model_field_hooks(self, model):
for field_name, field in model.Meta.fields.items():
hooks = to_tuple(getattr(field, 'hooks', ()))
context = HookContext(self,
model_class=model,
field=field,
field_name=field_name)
for hook in hooks:
self.add_hook(hook, context)
def __init__(self,
relation,
columns=None,
subqueries=None,
joins=None,
where=None,
limit=None,
order=None):
self.relation = relation
self.columns = columns or ()
self.subqueries = subqueries or {}
self.joins = joins or ()
self.where = where
self.limit = limit
self.order = to_tuple(order)
def format(self, format_string, *args):
# TODO: A little ugly. Now a lot ugly.
if isinstance(self.value, Composable):
format_string = format_string % '{}'
return SQL(format_string).format(*(args + (self.value, ))), ()
elif isinstance(self.value, Expression):
value_sql, value_args = self.value.to_sql()
format_string = format_string % '{}'
return SQL(format_string).format(*(args +
(value_sql, ))), value_args
else:
value = self.get_value()
if value == DiscardValue:
sql_args = ()
else:
sql_args = to_tuple(self.get_value(), keep_none=True)
return SQL(format_string).format(*args), sql_args
def get_columns_sql(self):
columns_sql = []
columns_args = ()
for name in to_tuple(self.columns):
if isinstance(name, Expression):
sql, args = name.to_sql()
elif isinstance(name, SQL):
sql = name
args = ()
else:
name_ident = Identifier(name)
sql = SQL('{}.{} AS {}').format(
Identifier(self.relation.alias), name_ident, name_ident)
args = ()
columns_sql.append(sql)
columns_args += args
if not columns_sql and not self.subqueries:
columns_sql = [SQL('*')]
return columns_sql, columns_args
def add_model_hooks(self, model):
self.add_model_field_hooks(model)
hooks = to_tuple(getattr(model.Meta, 'hooks', ()))
context = HookContext(self, model_class=model)
for hook in hooks:
self.add_hook(hook, context)