def range_for_material_objtype(objtype: s_objtypes.ObjectType, path_id: irast.PathId, *, include_overlays: bool = True, env: context.Environment) -> pgast.BaseRangeVar: from . import pathctx # XXX: fix cycle objtype = objtype.material_type() table_schema_name, table_name = common.objtype_name_to_table_name( objtype.name, catenate=False) if objtype.name.module == 'schema': # Redirect all queries to schema tables to edgedbss table_schema_name = 'edgedbss' relation = pgast.Relation( schemaname=table_schema_name, name=table_name, nullable=False, path_id=path_id, ) rvar = pgast.RangeVar( relation=relation, alias=pgast.Alias(aliasname=env.aliases.get(objtype.name.name))) overlays = env.rel_overlays.get(objtype.name) if overlays and include_overlays: set_ops = [] qry = pgast.SelectStmt() qry.from_clause.append(rvar) pathctx.put_path_value_rvar(qry, path_id, rvar, env=env) qry.path_scope.add(path_id) set_ops.append(('union', qry)) for op, cte in overlays: rvar = pgast.RangeVar( relation=cte, alias=pgast.Alias(aliasname=env.aliases.get(hint=cte.name))) qry = pgast.SelectStmt(from_clause=[rvar], ) pathctx.put_path_value_rvar(qry, path_id, rvar, env=env) qry.path_scope.add(path_id) if op == 'replace': op = 'union' set_ops = [] set_ops.append((op, qry)) rvar = range_from_queryset(set_ops, objtype, env=env) return rvar
def _new_inline_pointer_rvar( ir_ptr: irast.Pointer, *, nullable: bool = False, lateral: bool = True, ptr_info: pg_types.PointerStorageInfo, src_rvar: pgast.BaseRangeVar, ctx: context.CompilerContextLevel) -> pgast.BaseRangeVar: ptr_rel = pgast.SelectStmt() ptr_rvar = dbobj.rvar_for_rel(ptr_rel, lateral=lateral, env=ctx.env) ptr_rvar.query.path_id = ir_ptr.target.path_id.ptr_path() is_inbound = ir_ptr.direction == s_pointers.PointerDirection.Inbound if is_inbound: far_pid = ir_ptr.source.path_id else: far_pid = ir_ptr.target.path_id far_ref = pathctx.get_rvar_path_identity_var(src_rvar, far_pid, env=ctx.env) ptr_rvar.path_scope.add(far_pid) pathctx.put_path_identity_var(ptr_rel, far_pid, var=far_ref, env=ctx.env) return ptr_rvar
def new_empty_rvar(ir_set: irast.EmptySet, *, ctx: context.CompilerContextLevel) -> pgast.BaseRangeVar: nullref_alias = ctx.env.aliases.get('e') val = typecomp.cast(pgast.Constant(val=None, nullable=True), source_type=ir_set.scls, target_type=ir_set.scls, force=True, env=ctx.env) nullrel = pgast.SelectStmt( target_list=[pgast.ResTarget(val=val, name=nullref_alias)], nullable=True) rvar = dbobj.rvar_for_rel(nullrel, env=ctx.env) rvar.path_scope.add(ir_set.path_id) rvar.value_scope.add(ir_set.path_id) null_ref = pgast.ColumnRef(name=[nullref_alias], nullable=True) pathctx.put_rvar_path_output(rvar, ir_set.path_id, aspect='value', var=null_ref, env=ctx.env) if ir_set.path_id.is_objtype_path(): pathctx.put_rvar_path_output(rvar, ir_set.path_id, aspect='identity', var=null_ref, env=ctx.env) return rvar
def range_from_queryset(set_ops: typing.Sequence[typing.Tuple[ str, pgast.BaseRelation]], scls: s_obj.Object, *, env: context.Environment) -> pgast.BaseRangeVar: if len(set_ops) > 1: # More than one class table, generate a UNION/EXCEPT clause. qry = pgast.SelectStmt(all=True, larg=set_ops[0][1]) for op, rarg in set_ops[1:]: qry.op, qry.rarg = op, rarg qry = pgast.SelectStmt(all=True, larg=qry) qry = qry.larg rvar = pgast.RangeSubselect( subquery=qry, alias=pgast.Alias(aliasname=env.aliases.get(scls.shortname.name))) else: # Just one class table, so return it directly rvar = set_ops[0][1].from_clause[0] return rvar
def new_static_class_rvar( ir_set: irast.Set, *, lateral: bool = True, ctx: context.CompilerContextLevel) -> pgast.BaseRangeVar: set_rvar = new_root_rvar(ir_set, ctx=ctx) clsname = pgast.Constant(val=ir_set.rptr.source.scls.material_type().name) nameref = dbobj.get_column(set_rvar, common.edgedb_name_to_pg_name('schema::name')) condition = astutils.new_binop(nameref, clsname, op='=') substmt = pgast.SelectStmt() include_rvar(substmt, set_rvar, ir_set.path_id, aspect='value', ctx=ctx) substmt.where_clause = astutils.extend_binop(substmt.where_clause, condition) return new_rel_rvar(ir_set, substmt, ctx=ctx)
def range_for_objtype(objtype: s_objtypes.ObjectType, path_id: irast.PathId, *, include_overlays: bool = True, env: context.Environment) -> pgast.BaseRangeVar: from . import pathctx # XXX: fix cycle if not objtype.is_virtual: rvar = range_for_material_objtype(objtype, path_id, include_overlays=include_overlays, env=env) else: # Union object types are represented as a UNION of selects # from their children, which is, for most purposes, equivalent # to SELECTing from a parent table. children = frozenset(objtype.children(env.schema)) set_ops = [] for child in children: c_rvar = range_for_objtype(child, path_id=path_id, include_overlays=include_overlays, env=env) qry = pgast.SelectStmt(from_clause=[c_rvar], ) pathctx.put_path_value_rvar(qry, path_id, c_rvar, env=env) qry.path_scope.add(path_id) set_ops.append(('union', qry)) rvar = range_from_queryset(set_ops, objtype, env=env) rvar.query.is_distinct = True rvar.query.path_id = path_id return rvar
def __init__(self, prevlevel, mode): if prevlevel is None: self.env = None self.argmap = collections.OrderedDict() stmt = pgast.SelectStmt() self.toplevel_stmt = None self.stmt = stmt self.rel = stmt self.rel_hierarchy = {} self.pending_query = None self.clause = None self.toplevel_clause = None self.expr_exposed = None self.volatility_ref = None self.group_by_rels = {} self.shape_format = ShapeFormat.SERIALIZED self.disable_semi_join = set() self.unique_paths = set() self.path_scope = collections.ChainMap() self.scope_tree = None else: self.env = prevlevel.env self.argmap = prevlevel.argmap self.toplevel_stmt = prevlevel.toplevel_stmt self.stmt = prevlevel.stmt self.rel = prevlevel.rel self.rel_hierarchy = prevlevel.rel_hierarchy self.pending_query = prevlevel.pending_query self.clause = prevlevel.clause self.toplevel_clause = prevlevel.toplevel_clause self.expr_exposed = prevlevel.expr_exposed self.volatility_ref = prevlevel.volatility_ref self.group_by_rels = prevlevel.group_by_rels self.shape_format = prevlevel.shape_format self.disable_semi_join = prevlevel.disable_semi_join.copy() self.unique_paths = prevlevel.unique_paths.copy() self.path_scope = prevlevel.path_scope self.scope_tree = prevlevel.scope_tree if mode in { ContextSwitchMode.SUBREL, ContextSwitchMode.NEWREL, ContextSwitchMode.SUBSTMT }: if self.pending_query and mode == ContextSwitchMode.SUBSTMT: self.rel = self.pending_query else: self.rel = pgast.SelectStmt() if mode != ContextSwitchMode.NEWREL: self.rel_hierarchy[self.rel] = prevlevel.rel self.pending_query = None self.clause = 'result' if mode == ContextSwitchMode.SUBSTMT: self.stmt = self.rel if mode == ContextSwitchMode.NEWSCOPE: self.path_scope = prevlevel.path_scope.new_child()
def process_link_update( ir_stmt: irast.MutatingStmt, ir_expr: irast.Base, props_only: bool, wrapper: pgast.Query, dml_cte: pgast.CommonTableExpr, iterator_cte: pgast.CommonTableExpr, *, ctx: context.CompilerContextLevel) -> typing.Optional[pgast.Query]: """Perform updates to a link relation as part of a DML statement. :param ir_stmt: IR of the statement. :param ir_expr: IR of the INSERT/UPDATE body element. :param props_only: Whether this link update only touches link properties. :param wrapper: Top-level SQL query. :param dml_cte: CTE representing the SQL INSERT or UPDATE to the main relation of the Object. :param iterator_cte: CTE representing the iterator range in the FOR clause of the EdgeQL DML statement. """ toplevel = ctx.toplevel_stmt edgedb_ptr_tab = pgast.RangeVar( relation=pgast.Relation(schemaname='edgedb', name='pointer'), alias=pgast.Alias(aliasname=ctx.env.aliases.get(hint='ptr'))) ltab_alias = edgedb_ptr_tab.alias.aliasname rptr = ir_expr.rptr ptrcls = rptr.ptrcls target_is_scalar = isinstance(ptrcls.target, s_scalars.ScalarType) path_id = rptr.source.path_id.extend(ptrcls, rptr.direction, rptr.target.scls) # The links in the dml class shape have been derived, # but we must use the correct specialized link class for the # base material type. mptrcls = ptrcls.material_type() # Lookup link class id by link name. lname_to_id = pgast.CommonTableExpr(query=pgast.SelectStmt( from_clause=[edgedb_ptr_tab], target_list=[ pgast.ResTarget(val=pgast.ColumnRef(name=[ltab_alias, 'id'])) ], where_clause=astutils.new_binop( lexpr=pgast.ColumnRef(name=[ltab_alias, 'name']), rexpr=pgast.Constant(val=mptrcls.name), op=ast.ops.EQ)), name=ctx.env.aliases.get(hint='lid')) lname_to_id_rvar = pgast.RangeVar(relation=lname_to_id) toplevel.ctes.append(lname_to_id) target_rvar = dbobj.range_for_ptrcls(mptrcls, '>', include_overlays=False, env=ctx.env) target_alias = target_rvar.alias.aliasname if target_is_scalar: target_tab_name = (target_rvar.relation.schemaname, target_rvar.relation.name) else: target_tab_name = common.link_name_to_table_name(mptrcls.shortname, catenate=False) tab_cols = \ ctx.env.backend._type_mech.get_cached_table_columns(target_tab_name) assert tab_cols, "could not get cols for {!r}".format(target_tab_name) dml_cte_rvar = pgast.RangeVar( relation=dml_cte, alias=pgast.Alias(aliasname=ctx.env.aliases.get('m'))) col_data = { 'ptr_item_id': pgast.ColumnRef(name=[lname_to_id.name, 'id']), 'std::source': pathctx.get_rvar_path_identity_var(dml_cte_rvar, ir_stmt.subject.path_id, env=ctx.env) } # Drop all previous link records for this source. delcte = pgast.CommonTableExpr(query=pgast.DeleteStmt( relation=target_rvar, where_clause=astutils.new_binop( lexpr=col_data['std::source'], op=ast.ops.EQ, rexpr=pgast.ColumnRef(name=[target_alias, 'std::source'])), using_clause=[dml_cte_rvar], returning_list=[ pgast.ResTarget(val=pgast.ColumnRef( name=[target_alias, pgast.Star()])) ]), name=ctx.env.aliases.get(hint='d')) pathctx.put_path_value_rvar(delcte.query, path_id.ptr_path(), target_rvar, env=ctx.env) # Record the effect of this removal in the relation overlay # context to ensure that the RETURNING clause potentially # referencing this link yields the expected results. overlays = ctx.env.rel_overlays[ptrcls.shortname] overlays.append(('except', delcte)) toplevel.ctes.append(delcte) # Turn the IR of the expression on the right side of := # into a subquery returning records for the link table. data_cte = process_link_values(ir_stmt, ir_expr, target_tab_name, tab_cols, col_data, dml_cte_rvar, [lname_to_id_rvar], props_only, target_is_scalar, iterator_cte, ctx=ctx) toplevel.ctes.append(data_cte) data_select = pgast.SelectStmt( target_list=[ pgast.ResTarget(val=pgast.ColumnRef( name=[data_cte.name, pgast.Star()])) ], from_clause=[pgast.RangeVar(relation=data_cte)]) # Inserting rows into the link table may produce cardinality # constraint violations, since the INSERT into the link table # is executed in the snapshot where the above DELETE from # the link table is not visible. Hence, we need to use # the ON CONFLICT clause to resolve this. conflict_cols = ['std::source', 'std::target', 'ptr_item_id'] conflict_inference = [] conflict_exc_row = [] for col in conflict_cols: conflict_inference.append(pgast.ColumnRef(name=[col])) conflict_exc_row.append(pgast.ColumnRef(name=['excluded', col])) conflict_data = pgast.SelectStmt( target_list=[ pgast.ResTarget(val=pgast.ColumnRef( name=[data_cte.name, pgast.Star()])) ], from_clause=[pgast.RangeVar(relation=data_cte)], where_clause=astutils.new_binop( lexpr=pgast.ImplicitRowExpr(args=conflict_inference), rexpr=pgast.ImplicitRowExpr(args=conflict_exc_row), op='=')) cols = [pgast.ColumnRef(name=[col]) for col in tab_cols] updcte = pgast.CommonTableExpr( name=ctx.env.aliases.get(hint='i'), query=pgast.InsertStmt( relation=target_rvar, select_stmt=data_select, cols=cols, on_conflict=pgast.OnConflictClause( action='update', infer=pgast.InferClause(index_elems=conflict_inference), target_list=[ pgast.MultiAssignRef(columns=cols, source=conflict_data) ]), returning_list=[ pgast.ResTarget(val=pgast.ColumnRef(name=[pgast.Star()])) ])) pathctx.put_path_value_rvar(updcte.query, path_id.ptr_path(), target_rvar, env=ctx.env) # Record the effect of this insertion in the relation overlay # context to ensure that the RETURNING clause potentially # referencing this link yields the expected results. overlays = ctx.env.rel_overlays[ptrcls.shortname] overlays.append(('union', updcte)) toplevel.ctes.append(updcte) return data_cte
def process_update_body(ir_stmt: irast.MutatingStmt, wrapper: pgast.Query, update_cte: pgast.CommonTableExpr, range_cte: pgast.CommonTableExpr, *, ctx: context.CompilerContextLevel): """Generate SQL DML CTEs from an UpdateStmt IR. :param ir_stmt: IR of the statement. :param wrapper: Top-level SQL query. :param update_cte: CTE representing the SQL UPDATE to the main relation of the Object. :param range_cte: CTE representing the range affected by the statement. """ update_stmt = update_cte.query external_updates = [] toplevel = ctx.toplevel_stmt toplevel.ctes.append(range_cte) toplevel.ctes.append(update_cte) with ctx.newscope() as subctx: # It is necessary to process the expressions in # the UpdateStmt shape body in the context of the # UPDATE statement so that references to the current # values of the updated object are resolved correctly. subctx.path_scope[ir_stmt.subject.path_id] = update_stmt subctx.rel = update_stmt subctx.expr_exposed = False subctx.shape_format = context.ShapeFormat.FLAT for shape_el in ir_stmt.subject.shape: with subctx.newscope() as scopectx: ptrcls = shape_el.rptr.ptrcls updvalue = shape_el.expr ptr_info = pg_types.get_pointer_storage_info( ptrcls, schema=scopectx.env.schema, resolve_type=True, link_bias=False) # First, process all internal link updates if ptr_info.table_type == 'ObjectType': updvalue = pgast.TypeCast( arg=dispatch.compile(updvalue, ctx=scopectx), type_name=typecomp.type_node(ptr_info.column_type)) update_stmt.targets.append( pgast.UpdateTarget(name=ptr_info.column_name, val=updvalue)) props_only = is_props_only_update(shape_el) ptr_info = pg_types.get_pointer_storage_info(ptrcls, resolve_type=False, link_bias=True) if ptr_info and ptr_info.table_type == 'link': external_updates.append((shape_el, props_only)) if not update_stmt.targets: # No updates directly to the set target table, # so convert the UPDATE statement into a SELECT. update_cte.query = pgast.SelectStmt( ctes=update_stmt.ctes, target_list=update_stmt.returning_list, from_clause=[update_stmt.relation] + update_stmt.from_clause, where_clause=update_stmt.where_clause, path_namespace=update_stmt.path_namespace, path_outputs=update_stmt.path_outputs, path_scope=update_stmt.path_scope, path_rvar_map=update_stmt.path_rvar_map.copy(), view_path_id_map=update_stmt.view_path_id_map.copy(), ptr_join_map=update_stmt.ptr_join_map.copy(), ) # Process necessary updates to the link tables. for expr, props_only in external_updates: if props_only: process_linkprop_update(ir_stmt, expr, wrapper, update_cte, ctx=ctx) else: process_link_update(ir_stmt, expr, False, wrapper, update_cte, None, ctx=ctx)
def process_insert_body(ir_stmt: irast.MutatingStmt, wrapper: pgast.Query, insert_cte: pgast.CommonTableExpr, insert_rvar: pgast.BaseRangeVar, *, ctx: context.CompilerContextLevel) -> None: """Generate SQL DML CTEs from an InsertStmt IR. :param ir_stmt: IR of the statement. :param wrapper: Top-level SQL query. :param insert_cte: CTE representing the SQL INSERT to the main relation of the Object. """ cols = [pgast.ColumnRef(name=['std::__type__'])] select = pgast.SelectStmt(target_list=[]) values = select.target_list # The main INSERT query of this statement will always be # present to insert at least the std::id and std::__type__ # links. insert_stmt = insert_cte.query insert_stmt.cols = cols insert_stmt.select_stmt = select if ir_stmt.parent_stmt is not None: iterator_set = ir_stmt.parent_stmt.iterator_stmt else: iterator_set = None if iterator_set is not None: with ctx.substmt() as ictx: ictx.path_scope = ictx.path_scope.new_child() ictx.path_scope[iterator_set.path_id] = ictx.rel clauses.compile_iterator_expr(ictx.rel, iterator_set, ctx=ictx) ictx.rel.path_id = iterator_set.path_id pathctx.put_path_bond(ictx.rel, iterator_set.path_id) iterator_cte = pgast.CommonTableExpr( query=ictx.rel, name=ctx.env.aliases.get('iter')) ictx.toplevel_stmt.ctes.append(iterator_cte) iterator_rvar = dbobj.rvar_for_rel(iterator_cte, env=ctx.env) relctx.include_rvar(select, iterator_rvar, path_id=ictx.rel.path_id, ctx=ctx) iterator_id = pathctx.get_path_identity_var(select, iterator_set.path_id, env=ctx.env) else: iterator_cte = None iterator_id = None values.append( pgast.ResTarget(val=pgast.SelectStmt( target_list=[pgast.ResTarget(val=pgast.ColumnRef(name=['id']))], from_clause=[ pgast.RangeVar(relation=pgast.Relation(name='objecttype', schemaname='edgedb')) ], where_clause=astutils.new_binop( op=ast.ops.EQ, lexpr=pgast.ColumnRef(name=['name']), rexpr=pgast.Constant(val=ir_stmt.subject.scls.shortname))))) external_inserts = [] tuple_elements = [] parent_link_props = [] with ctx.newrel() as subctx: subctx.rel = select subctx.rel_hierarchy[select] = insert_stmt subctx.expr_exposed = False subctx.shape_format = context.ShapeFormat.FLAT if iterator_cte is not None: subctx.path_scope = ctx.path_scope.new_child() subctx.path_scope[iterator_cte.query.path_id] = select # Process the Insert IR and separate links that go # into the main table from links that are inserted into # a separate link table. for shape_el in ir_stmt.subject.shape: rptr = shape_el.rptr ptrcls = rptr.ptrcls.material_type() if (ptrcls.is_link_property() and rptr.source.path_id != ir_stmt.subject.path_id): parent_link_props.append(shape_el) continue ptr_info = pg_types.get_pointer_storage_info( ptrcls, schema=subctx.env.schema, resolve_type=True, link_bias=False) props_only = False # First, process all local link inserts. if ptr_info.table_type == 'ObjectType': props_only = True field = pgast.ColumnRef(name=[ptr_info.column_name]) cols.append(field) insvalue = insert_value_for_shape_element(insert_stmt, wrapper, ir_stmt, shape_el, iterator_id, ptr_info=ptr_info, ctx=subctx) tuple_el = astutils.tuple_element_for_shape_el(shape_el, field) tuple_elements.append(tuple_el) values.append(pgast.ResTarget(val=insvalue)) ptr_info = pg_types.get_pointer_storage_info(ptrcls, resolve_type=False, link_bias=True) if ptr_info and ptr_info.table_type == 'link': external_inserts.append((shape_el, props_only)) if iterator_cte is not None: cols.append(pgast.ColumnRef(name=['__edb_token'])) values.append(pgast.ResTarget(val=iterator_id)) pathctx.put_path_identity_var(insert_stmt, iterator_set.path_id, cols[-1], force=True, env=subctx.env) pathctx.put_path_bond(insert_stmt, iterator_set.path_id) toplevel = ctx.toplevel_stmt toplevel.ctes.append(insert_cte) # Process necessary updates to the link tables. for shape_el, props_only in external_inserts: process_link_update(ir_stmt, shape_el, props_only, wrapper, insert_cte, iterator_cte, ctx=ctx) if parent_link_props: prop_elements = [] with ctx.newscope() as scopectx: scopectx.rel = wrapper for shape_el in parent_link_props: rptr = shape_el.rptr scopectx.path_scope[rptr.source.path_id] = wrapper pathctx.put_path_rvar_if_not_exists(wrapper, rptr.source.path_id, insert_rvar, aspect='value', env=scopectx.env) dispatch.compile(shape_el, ctx=scopectx) tuple_el = astutils.tuple_element_for_shape_el(shape_el, None) prop_elements.append(tuple_el) valtuple = pgast.TupleVar(elements=prop_elements, named=True) pathctx.put_path_value_var(wrapper, ir_stmt.subject.path_id, valtuple, force=True, env=ctx.env)
def range_for_ptrcls(ptrcls: s_links.Link, direction: s_pointers.PointerDirection, *, include_overlays: bool = True, env: context.Environment) -> pgast.BaseRangeVar: """"Return a Range subclass corresponding to a given ptr step. If `ptrcls` is a generic link, then a simple RangeVar is returned, otherwise the return value may potentially be a UNION of all tables corresponding to a set of specialized links computed from the given `ptrcls` taking source inheritance into account. """ linkname = ptrcls.shortname endpoint = ptrcls.source tgt_col = pgtypes.get_pointer_storage_info(ptrcls, resolve_type=False, link_bias=True).column_name cols = ['std::source', tgt_col] set_ops = [] ptrclses = set() for source in {endpoint} | set(endpoint.descendants(env.schema)): # Sift through the descendants to see who has this link try: src_ptrcls = source.pointers[linkname].material_type() except KeyError: # This source has no such link, skip it continue else: if src_ptrcls in ptrclses: # Seen this link already continue ptrclses.add(src_ptrcls) table = table_from_ptrcls(src_ptrcls, env=env) qry = pgast.SelectStmt() qry.from_clause.append(table) qry.rptr_rvar = table # Make sure all property references are pulled up properly for colname in cols: selexpr = pgast.ColumnRef(name=[table.alias.aliasname, colname]) qry.target_list.append(pgast.ResTarget(val=selexpr, name=colname)) set_ops.append(('union', qry)) overlays = env.rel_overlays.get(src_ptrcls.shortname) if overlays and include_overlays: for op, cte in overlays: rvar = pgast.RangeVar( relation=cte, alias=pgast.Alias(aliasname=env.aliases.get(cte.name))) qry = pgast.SelectStmt( target_list=[ pgast.ResTarget(val=pgast.ColumnRef(name=[col])) for col in cols ], from_clause=[rvar], ) set_ops.append((op, qry)) rvar = range_from_queryset(set_ops, ptrcls, env=env) return rvar
def cast(node: pgast.Base, *, source_type: s_obj.Object, target_type: s_obj.Object, force: bool = False, env: context.Environment) -> pgast.Base: if source_type.name == target_type.name and not force: return node schema = env.schema real_t = schema.get('std::anyreal') int_t = schema.get('std::anyint') json_t = schema.get('std::json') str_t = schema.get('std::str') datetime_t = schema.get('std::datetime') bool_t = schema.get('std::bool') if isinstance(target_type, s_types.Collection): if target_type.schema_name == 'array': if source_type.issubclass(json_t): # If we are casting a jsonb array to array, we do the # following transformation: # EdgeQL: <array<T>>MAP_VALUE # SQL: # SELECT array_agg(j::T) # FROM jsonb_array_elements(MAP_VALUE) AS j inner_cast = cast(pgast.ColumnRef(name=['j']), source_type=source_type, target_type=target_type.element_type, env=env) return pgast.SelectStmt( target_list=[ pgast.ResTarget(val=pgast.FuncCall( name=('array_agg', ), args=[inner_cast])) ], from_clause=[ pgast.RangeFunction(functions=[ pgast.FuncCall(name=('jsonb_array_elements', ), args=[node]) ], alias=pgast.Alias(aliasname='j')) ]) else: # EdgeQL: <array<int64>>['1', '2'] # to SQL: ARRAY['1', '2']::int[] elem_pgtype = pg_types.pg_type_from_object( schema, target_type.element_type, topbase=True) return pgast.TypeCast(arg=node, type_name=pgast.TypeName( name=elem_pgtype, array_bounds=[-1])) elif target_type.schema_name == 'map': if source_type.issubclass(json_t): # If the source type is json do nothing, since # maps are already encoded in json. return node # EdgeQL: <map<Tkey,Tval>>MAP<Vkey,Vval> # to SQL: SELECT jsonb_object_agg( # key::Vkey::Tkey::text, # value::Vval::Tval) # FROM jsonb_each_text(MAP) key_cast = cast( cast( cast(pgast.ColumnRef(name=['key']), source_type=str_t, target_type=source_type.key_type, env=env), source_type=source_type.key_type, target_type=target_type.key_type, env=env, ), source_type=target_type.key_type, target_type=str_t, env=env, ) target_v_type = target_type.element_type val_cast = cast(cast(pgast.ColumnRef(name=['value']), source_type=str_t, target_type=source_type.element_type, env=env), source_type=source_type.element_type, target_type=target_v_type, env=env) map_cast = pgast.SelectStmt( target_list=[ pgast.ResTarget( val=pgast.FuncCall(name=('jsonb_object_agg', ), args=[key_cast, val_cast])) ], from_clause=[ pgast.RangeFunction(functions=[ pgast.FuncCall(name=('jsonb_each_text', ), args=[node]) ]) ]) return pgast.FuncCall( name=('coalesce', ), args=[ map_cast, pgast.TypeCast(arg=pgast.Constant(val='{}'), type_name=pgast.TypeName(name=('jsonb', ))) ]) else: # `target_type` is not a collection. if (source_type.issubclass(datetime_t) and target_type.issubclass(str_t)): # Normalize datetime to text conversion to have the same # format as one would get by serializing to JSON. # # EdgeQL: <text><datetime>'2010-10-10'; # To SQL: trim(to_json('2010-01-01'::timestamptz)::text, '"') return pgast.FuncCall( name=('trim', ), args=[ pgast.TypeCast(arg=pgast.FuncCall(name=('to_json', ), args=[node]), type_name=pgast.TypeName(name=('text', ))), pgast.Constant(val='"') ]) elif source_type.issubclass(bool_t) and target_type.issubclass(int_t): # PostgreSQL 9.6 doesn't allow to cast 'boolean' to any integer # other than int32: # SELECT 'true'::boolean::bigint; # ERROR: cannot cast type boolean to bigint # So we transform EdgeQL: <int64>BOOL # to SQL: BOOL::int::<targetint> return pgast.TypeCast( arg=pgast.TypeCast(arg=node, type_name=pgast.TypeName(name=('int', ))), type_name=pgast.TypeName( name=pg_types.pg_type_from_scalar(schema, target_type))) elif source_type.issubclass(int_t) and target_type.issubclass(bool_t): # PostgreSQL 9.6 doesn't allow to cast any integer other # than int32 to 'boolean': # SELECT 1::bigint::boolean; # ERROR: cannot cast type bigint to boolea # So we transform EdgeQL: <boolean>INT # to SQL: (INT != 0) return astutils.new_binop(node, pgast.Constant(val=0), op=ast.ops.NE) elif source_type.issubclass(json_t): if (target_type.issubclass(real_t) or target_type.issubclass(bool_t)): # Simply cast to text and the to the target type. return cast(cast(node, source_type=source_type, target_type=str_t, env=env), source_type=str_t, target_type=target_type, env=env) elif target_type.issubclass(str_t): # It's not possible to cast jsonb string to text directly, # so we do a trick: # EdgeQL: <str>JSONB_VAL # SQL: array_to_json(ARRAY[JSONB_VAL])->>0 return astutils.new_binop(pgast.FuncCall( name=('array_to_json', ), args=[pgast.ArrayExpr(elements=[node])]), pgast.Constant(val=0), op='->>') elif target_type.issubclass(json_t): return pgast.TypeCast( arg=node, type_name=pgast.TypeName(name=('jsonb', ))) else: const_type = pg_types.pg_type_from_object(schema, target_type, topbase=True) return pgast.TypeCast(arg=node, type_name=pgast.TypeName(name=const_type)) raise RuntimeError( f'could not cast {source_type.name} to {target_type.name}')