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)