async def read_events(self, schema): events = await datasources.schema.policy.fetch_events(self.connection) basemap = {} for r in events: name = sn.Name(r['name']) title = self.json_to_word_combination(r['title']) description = r['description'] if r['bases']: bases = tuple(sn.Name(b) for b in r['bases']) elif name != 'std::event': bases = (sn.Name('std::event'), ) else: bases = tuple() basemap[name] = bases event = s_policy.Event(name=name, title=title, description=description) schema.add(event) for event in schema.get_objects(type='event'): try: bases = basemap[event.name] except KeyError: pass else: event.bases = [schema.get(b) for b in bases] for event in schema.get_objects(type='event'): event.acquire_ancestor_inheritance(schema)
async def read_constraints(self, schema): constraints_list = await datasources.schema.constraints.fetch( self.connection) constraints_list = collections.OrderedDict((sn.Name(r['name']), r) for r in constraints_list) basemap = {} for name, r in constraints_list.items(): bases = tuple() if r['subject']: bases = (s_constr.Constraint.get_shortname(name), ) elif r['bases']: bases = tuple(sn.Name(b) for b in r['bases']) elif name != 'std::constraint': bases = (sn.Name('std::constraint'), ) title = self.json_to_word_combination(r['title']) description = r['description'] subject = schema.get(r['subject']) if r['subject'] else None basemap[name] = bases paramtypes = None if r['paramtypes']: paramtypes = [ s[1] for s in self.unpack_typedesc_nodes( r['paramtypes']['types'], schema)] constraint = s_constr.Constraint( name=name, subject=subject, title=title, description=description, is_abstract=r['is_abstract'], is_final=r['is_final'], expr=r['expr'], subjectexpr=r['subjectexpr'], localfinalexpr=r['localfinalexpr'], finalexpr=r['finalexpr'], errmessage=r['errmessage'], paramtypes=paramtypes, varparam=r['varparam'], args=r['args']) if subject: subject.add_constraint(constraint) schema.add(constraint) for constraint in schema.get_objects(type='constraint'): try: bases = basemap[constraint.name] except KeyError: pass else: constraint.bases = [schema.get(b) for b in bases] for constraint in schema.get_objects(type='constraint'): constraint.acquire_ancestor_inheritance(schema)
async def get_type_map(self, force_reload=False): if not self.type_cache or force_reload: cl_ds = datasources.schema.objtypes for row in await cl_ds.fetch(self.connection): self.type_cache[row['name']] = row['id'] self.type_cache[row['id']] = sn.Name(row['name']) cl_ds = datasources.schema.scalars for row in await cl_ds.fetch(self.connection): self.type_cache[row['name']] = row['id'] self.type_cache[row['id']] = sn.Name(row['name']) return self.type_cache
def __init__(self, source, target, *, optional, cardinality): name = 'optindirection' if optional else 'indirection' self._name = s_name.Name(module='__type__', name=name) self._source = source self._target = target self._cardinality = cardinality self._optional = optional
async def read_functions(self, schema): func_list = await datasources.schema.functions.fetch(self.connection) for row in func_list: name = sn.Name(row['name']) paramtypes = None if row['paramtypes']: paramtypes = [ s[1] for s in self.unpack_typedesc_nodes( row['paramtypes']['types'], schema)] func_data = { 'name': name, 'title': self.json_to_word_combination(row['title']), 'description': row['description'], 'aggregate': row['aggregate'], 'set_returning': row['set_returning'], 'varparam': row['varparam'], 'from_function': row['from_function'], 'code': row['code'], 'initial_value': row['initial_value'], 'paramtypes': paramtypes, 'paramnames': row['paramnames'] if row['paramnames'] else [], 'paramdefaults': row['paramdefaults'] if row['paramdefaults'] else [], 'paramkinds': row['paramkinds'] if row['paramkinds'] else [], 'returntype': self.unpack_typeref(row['returntype'], schema) } func = s_funcs.Function(**func_data) schema.add(func)
async def read_objtypes(self, schema, only_modules, exclude_modules): objtype_list = await datasources.schema.objtypes.fetch( self.connection, modules=only_modules, exclude_modules=exclude_modules) objtype_list = collections.OrderedDict( (sn.Name(row['name']), row) for row in objtype_list) basemap = {} for name, row in objtype_list.items(): objtype = { 'id': row['id'], 'name': name, 'is_abstract': row['is_abstract'], 'is_final': row['is_final'], 'view_type': (s_types.ViewType(row['view_type']) if row['view_type'] else None), 'expr': (s_expr.ExpressionText(row['expr']) if row['expr'] else None) } basemap[name] = row['bases'] or [] schema, objtype = s_objtypes.ObjectType.create_in_schema( schema, id=objtype['id'], name=name, is_abstract=objtype['is_abstract'], is_final=objtype['is_final'], view_type=objtype['view_type'], expr=objtype['expr']) for objtype in schema.get_objects(type=s_objtypes.BaseObjectType): try: bases = basemap[objtype.get_name(schema)] except KeyError: pass else: schema = objtype.set_field_value( schema, 'bases', [schema.get(b) for b in bases]) derived = await datasources.schema.objtypes.fetch_derived( self.connection) for row in derived: attrs = dict(row) attrs['name'] = sn.SchemaName(attrs['name']) attrs['bases'] = [schema.get(b) for b in attrs['bases']] attrs['view_type'] = (s_types.ViewType(attrs['view_type']) if attrs['view_type'] else None) attrs['is_derived'] = True schema, objtype = s_objtypes.ObjectType.create_in_schema( schema, **attrs) return schema
async def read_attribute_values(self, schema, only_modules, exclude_modules): attributes = await datasources.schema.attributes.fetch_values( self.connection, modules=only_modules, exclude_modules=exclude_modules) for r in attributes: name = sn.Name(r['name']) subject = schema.get(r['subject_name']) attribute = schema.get(r['attribute_name']) value = r['value'] schema, attribute = s_attrs.AttributeValue.create_in_schema( schema, id=r['id'], name=name, subject=subject, attribute=attribute, value=value, inheritable=r['inheritable'], ) schema = subject.add_attribute(schema, attribute) return schema
def amend_empty_set_type(es: irast.EmptySet, t: s_obj.Object, schema) -> None: alias = es.path_id[-1].name.name scls_name = s_name.Name(module='__expr__', name=alias) scls = t.__class__(name=scls_name, bases=[t]) scls.acquire_ancestor_inheritance(schema) es.path_id = irast.PathId(scls) es.scls = t
async def read_functions(self, schema, only_modules, exclude_modules): ds = datasources.schema.functions func_list = await ds.fetch(self.connection, modules=only_modules, exclude_modules=exclude_modules) param_list = await ds.fetch_params(self.connection, modules=only_modules, exclude_modules=exclude_modules) param_map = {p['name']: p for p in param_list} for row in func_list: name = sn.Name(row['name']) schema, params = self._decode_func_params(schema, row, param_map) func_data = { 'id': row['id'], 'name': name, 'language': row['language'], 'params': params, 'return_typemod': row['return_typemod'], 'from_function': row['from_function'], 'force_return_cast': row['force_return_cast'], 'code': row['code'], 'initial_value': row['initial_value'], 'return_type': self.unpack_typeref(row['return_type'], schema) } schema, _ = s_funcs.Function.create_in_schema(schema, **func_data) return schema
async def read_casts(self, schema, only_modules, exclude_modules): self._operator_commutators.clear() ds = datasources.schema cast_list = await ds.casts.fetch(self.connection, modules=only_modules, exclude_modules=exclude_modules) for row in cast_list: name = sn.Name(row['name']) cast_data = { 'id': row['id'], 'name': name, 'from_type': self.unpack_typeref(row['from_type'], schema), 'to_type': self.unpack_typeref(row['to_type'], schema), 'language': row['language'], 'from_cast': row['from_cast'], 'from_function': row['from_function'], 'from_expr': row['from_expr'], 'allow_implicit': row['allow_implicit'], 'allow_assignment': row['allow_assignment'], 'code': row['code'], } schema, oper = s_casts.Cast.create_in_schema(schema, **cast_data) return schema
def _cb(node): if isinstance(node, qlast.ObjectRef): name = sn.Name(name=node.name, module=node.module) upd = callback(name) if name != upd: node.name = upd.name node.module = upd.module
def resolve_schema_name(name: str, module: str, *, ctx: context.ContextLevel) -> sn.Name: schema_module = ctx.modaliases.get(module) if schema_module is None: return None else: return sn.Name(name=name, module=schema_module)
def __init__(self, source, target, *, optional, cardinality): name = 'optindirection' if optional else 'indirection' super().__init__(name=s_name.Name(module='__type__', name=name), source=source, target=target, direction=s_pointers.PointerDirection.Outbound) self.optional = optional self.cardinality = cardinality
def compile_GroupQuery( expr: qlast.Base, *, ctx: context.ContextLevel) -> irast.Base: with ctx.subquery() as ictx: stmt = irast.GroupStmt() init_stmt(stmt, expr, ctx=ictx, parent_ctx=ctx) c = s_objtypes.ObjectType( name=s_name.Name( module='__group__', name=ctx.aliases.get('Group')), bases=[ctx.schema.get('std::Object')] ) c.acquire_ancestor_inheritance(ctx.schema) stmt.group_path_id = pathctx.get_path_id(c, ctx=ictx) pathctx.register_set_in_scope(stmt.group_path_id, ctx=ictx) with ictx.newscope(fenced=True) as subjctx: subjctx.clause = 'input' subject_set = setgen.scoped_set( dispatch.compile(expr.subject, ctx=subjctx), ctx=subjctx) alias = expr.subject_alias or subject_set.path_id.target.name stmt.subject = stmtctx.declare_inline_view( subject_set, alias, ctx=ictx) with subjctx.new() as grpctx: stmt.groupby = compile_groupby_clause( expr.groupby, ctx=grpctx) with ictx.subquery() as isctx, isctx.newscope(fenced=True) as sctx: o_stmt = sctx.stmt = irast.SelectStmt() o_stmt.result = compile_result_clause( expr.result, view_scls=ctx.view_scls, view_rptr=ctx.view_rptr, result_alias=expr.result_alias, view_name=ctx.toplevel_result_view_name, ctx=sctx) o_stmt.where = clauses.compile_where_clause( expr.where, ctx=sctx) o_stmt.orderby = clauses.compile_orderby_clause( expr.orderby, ctx=sctx) o_stmt.offset = clauses.compile_limit_offset_clause( expr.offset, ctx=sctx) o_stmt.limit = clauses.compile_limit_offset_clause( expr.limit, ctx=sctx) stmt.result = setgen.scoped_set(o_stmt, ctx=sctx) result = fini_stmt(stmt, expr, ctx=ictx, parent_ctx=ctx) return result
def new_empty_set(schema, *, scls=None, alias): if scls is None: base_scls = schema.get('std::str') else: base_scls = scls cls_name = s_name.Name(module='__expr__', name=alias) cls = base_scls.__class__(name=cls_name, bases=[base_scls]) cls.acquire_ancestor_inheritance(schema) return irast.EmptySet(path_id=irast.PathId(cls), scls=scls)
def new_empty_set(schema, *, stype=None, alias): if stype is None: path_id_scls = s_pseudo.Any.create() else: path_id_scls = stype typename = s_name.Name(module='__expr__', name=alias) path_id = irast.PathId.from_type(schema, path_id_scls, typename=typename) return irast.EmptySet(path_id=path_id, stype=stype)
def get_expression_path_id(t: s_types.Type, alias: str, *, ctx: context.ContextLevel) -> irast.PathId: cls_name = s_name.Name(module='__expr__', name=alias) if isinstance(t, (s_types.Collection, s_types.Tuple)): et = t.copy() et.name = cls_name else: et = t.__class__(name=cls_name, bases=[t]) et.acquire_ancestor_inheritance(ctx.schema) return pathctx.get_path_id(et, ctx=ctx)
async def read_attributes(self, schema): attributes = await datasources.schema.attributes.fetch(self.connection) for r in attributes: name = sn.Name(r['name']) title = self.json_to_word_combination(r['title']) description = r['description'] attribute = s_attrs.Attribute( name=name, title=title, description=description, type=self.unpack_typeref(r['type'], schema)) schema.add(attribute)
async def read_actions(self, schema): actions = await datasources.schema.policy.fetch_actions( self.connection) for r in actions: name = sn.Name(r['name']) title = self.json_to_word_combination(r['title']) description = r['description'] action = s_policy.Action( name=name, title=title, description=description) schema.add(action)
async def _init_scalar_map_cache(self): scalar_list = await datasources.schema.scalars.fetch(self.connection) domain_to_scalar_map = {} for row in scalar_list: name = sn.Name(row['name']) domain_name = common.scalar_name_to_domain_name(name, catenate=False) domain_to_scalar_map[domain_name] = name return domain_to_scalar_map
async def constraint_name_from_pg_name(self, connection, pg_name): if self._constraints_cache is None: self._constraints_cache = \ await self._populate_constraint_cache(connection) try: cdata = self._constraints_cache[pg_name] except KeyError: return None else: name = cdata['constraint_description'] name, _, _ = name.rpartition(';') return sn.Name(name)
def _get_backend_constraint_name(schema, constraint, catenate=True, prefix='edgedb_', *, aspect=None): if aspect not in ('trigproc', ): raise ValueError( f'unexpected aspect for constraint backend name: {aspect!r}') name = s_name.Name(module=constraint.get_name(schema).module, name=str(constraint.id)) return convert_name(name, aspect, catenate, prefix=prefix)
async def read_attribute_values(self, schema): attributes = await datasources.schema.attributes.fetch_values( self.connection) for r in attributes: name = sn.Name(r['name']) subject = schema.get(r['subject_name']) attribute = schema.get(r['attribute_name']) value = pickle.loads(r['value']) attribute = s_attrs.AttributeValue( name=name, subject=subject, attribute=attribute, value=value) subject.add_attribute(attribute) schema.add(attribute)
async def read_policies(self, schema): policies = await datasources.schema.policy.fetch_policies( self.connection) for r in policies: name = sn.Name(r['name']) title = self.json_to_word_combination(r['title']) description = r['description'] policy = s_policy.Policy( name=name, title=title, description=description, subject=schema.get(r['subject']), event=schema.get(r['event']), actions=[schema.get(a) for a in r['actions']]) schema.add(policy) policy.subject.add_policy(policy)
async def read_indexes(self, schema, only_modules, exclude_modules): pg_index_data = await introspection.tables.fetch_indexes( self.connection, schema_pattern='edgedb%', index_pattern='%_reg_idx') pg_indexes = set() for row in pg_index_data: table_name = tuple(row['table_name']) for pg_index in self.interpret_indexes(table_name, row['indexes']): pg_indexes.add( (table_name, pg_index.get_metadata('schemaname'))) ds = datasources.schema.indexes indexes = await ds.fetch(self.connection, modules=only_modules, exclude_modules=exclude_modules) for index_data in indexes: subj = schema.get(index_data['subject_name']) subj_table_name = common.get_backend_name(schema, subj, catenate=False) index_name = sn.Name(index_data['name']) try: pg_indexes.remove((subj_table_name, index_name)) except KeyError: raise errors.SchemaError( 'internal metadata inconsistency', details=f'Index {index_name} is defined in schema, but' f'the corresponding PostgreSQL index is missing.' ) from None schema, index = s_indexes.SourceIndex.create_in_schema( schema, id=index_data['id'], name=index_name, subject=subj, expr=index_data['expr']) schema = subj.add_index(schema, index) if pg_indexes and not only_modules and not exclude_modules: details = f'Extraneous PostgreSQL indexes found: {pg_indexes!r}' raise errors.SchemaError('internal metadata inconsistency', details=details) return schema
async def read_attributes(self, schema, only_modules, exclude_modules): attributes = await datasources.schema.attributes.fetch( self.connection, modules=only_modules, exclude_modules=exclude_modules) for r in attributes: name = sn.Name(r['name']) schema, attribute = s_attrs.Attribute.create_in_schema( schema, id=r['id'], name=name, inheritable=r['inheritable'], ) return schema
def get_schema_object( name: typing.Union[str, qlast.ObjectRef], module: typing.Optional[str] = None, *, item_types: typing.Optional[typing.List[s_obj.ObjectMeta]], ctx: context.ContextLevel, srcctx: typing.Optional[parsing.ParserContext] = None) -> s_obj.Object: if isinstance(name, qlast.ObjectRef): if srcctx is None: srcctx = name.context module = name.module name = name.name if module: name = sn.Name(name=name, module=module) if not module: result = ctx.aliased_views.get(name) if result is not None: return result try: scls = ctx.schema.get(name=name, module_aliases=ctx.modaliases, type=item_types) except s_err.ItemNotFoundError as e: qlerror = qlerrors.EdgeQLError(e.args[0], context=srcctx) s_utils.enrich_schema_lookup_error(qlerror, name, modaliases=ctx.modaliases, schema=ctx.schema, item_types=item_types) raise qlerror except s_err.SchemaError as e: raise qlerrors.EdgeQLError(e.args[0], context=srcctx) result = ctx.aliased_views.get(scls.name) if result is None: result = scls return result
def _get_backend_objtype_name(schema, objtype, catenate=True, aspect=None): if aspect is None: aspect = 'table' if aspect not in ('table', 'target-del-def-t', 'target-del-imm-t', 'source-del-def-t', 'source-del-imm-t', 'target-del-def-f', 'target-del-imm-f', 'source-del-def-f', 'source-del-imm-f'): raise ValueError( f'unexpected aspect for object type backend name: {aspect!r}') name = s_name.Name(module=objtype.get_name(schema).module, name=str(objtype.id)) if aspect != 'table': suffix = aspect else: suffix = '' return convert_name(name, suffix=suffix, catenate=catenate)
def compile_FunctionCall( expr: qlast.Base, *, ctx: context.ContextLevel) -> irast.Base: with ctx.new() as fctx: if isinstance(expr.func, str): funcname = expr.func else: funcname = sn.Name(expr.func[1], expr.func[0]) funcs = fctx.schema.get_functions( funcname, module_aliases=fctx.modaliases) if funcs is None: raise errors.EdgeQLError( f'could not resolve function name {funcname}', context=expr.context) fctx.in_func_call = True args, kwargs, arg_types = process_func_args(expr, funcname, ctx=fctx) fatal_array_check = len(funcs) == 1 for funcobj in funcs: if check_function(expr, funcname, funcobj, arg_types, fatal_array_check=fatal_array_check): break else: raise errors.EdgeQLError( f'could not find a function variant {funcname}', context=expr.context) fixup_param_scope(funcobj, args, kwargs, ctx=fctx) node = irast.FunctionCall(func=funcobj, args=args, kwargs=kwargs) if funcobj.initial_value is not None: rtype = irutils.infer_type(node, fctx.schema) iv_ql = qlast.TypeCast( expr=qlparser.parse_fragment(funcobj.initial_value), type=typegen.type_to_ql_typeref(rtype) ) node.initial_value = dispatch.compile(iv_ql, ctx=fctx) ir_set = setgen.ensure_set(node, ctx=ctx) return ir_set
def get_schema_object( name: typing.Union[str, qlast.ObjectRef], module: typing.Optional[str] = None, *, item_types: typing.Optional[typing.List[s_obj.ObjectMeta]], ctx: context.ContextLevel, srcctx: typing.Optional[parsing.ParserContext] = None) -> s_obj.Object: if isinstance(name, qlast.ObjectRef): if srcctx is None: srcctx = name.context module = name.module name = name.name elif isinstance(name, qlast.AnyType): return s_pseudo.Any.create() if module: name = sn.Name(name=name, module=module) if not module: result = ctx.aliased_views.get(name) if result is not None: return result try: stype = ctx.env.schema.get(name=name, module_aliases=ctx.modaliases, type=item_types) except errors.QueryError as e: s_utils.enrich_schema_lookup_error(e, name, modaliases=ctx.modaliases, schema=ctx.env.schema, item_types=item_types) raise result = ctx.aliased_views.get(stype.get_name(ctx.env.schema)) if result is None: result = stype return result