def _process_view( *, stype: s_objtypes.ObjectType, path_id: irast.PathId, path_id_namespace: Optional[irast.WeakNamespace] = None, elements: List[qlast.ShapeElement], view_rptr: Optional[context.ViewRPtr] = None, view_name: Optional[sn.QualName] = None, is_insert: bool = False, is_update: bool = False, is_delete: bool = False, parser_context: pctx.ParserContext, ctx: context.ContextLevel, ) -> s_objtypes.ObjectType: if (view_name is None and ctx.env.options.schema_view_mode and view_rptr is not None): # Make sure persistent schema expression aliases have properly formed # names as opposed to the usual mangled form of the ephemeral # aliases. This is needed for introspection readability, as well # as helps in maintaining proper type names for schema # representations that require alphanumeric names, such as # GraphQL. # # We use the name of the source together with the name # of the inbound link to form the name, so in e.g. # CREATE ALIAS V := (SELECT Foo { bar: { baz: { ... } }) # The name of the innermost alias would be "__V__bar__baz". source_name = view_rptr.source.get_name(ctx.env.schema).name if not source_name.startswith('__'): source_name = f'__{source_name}' if view_rptr.ptrcls_name is not None: ptr_name = view_rptr.ptrcls_name.name elif view_rptr.ptrcls is not None: ptr_name = view_rptr.ptrcls.get_shortname(ctx.env.schema).name else: raise errors.InternalServerError( '_process_view in schema mode received view_rptr with ' 'neither ptrcls_name, not ptrcls' ) name = f'{source_name}__{ptr_name}' view_name = sn.QualName( module=ctx.derived_target_module or '__derived__', name=name, ) view_scls = schemactx.derive_view( stype, is_insert=is_insert, is_update=is_update, is_delete=is_delete, derived_name=view_name, ctx=ctx, ) assert isinstance(view_scls, s_objtypes.ObjectType), view_scls is_mutation = is_insert or is_update is_defining_shape = ctx.expr_exposed or is_mutation if view_rptr is not None and view_rptr.ptrcls is None: derive_ptrcls( view_rptr, target_scls=view_scls, transparent=True, ctx=ctx) pointers = [] for shape_el in elements: with ctx.newscope(fenced=True) as scopectx: pointer = _normalize_view_ptr_expr( shape_el, view_scls, path_id=path_id, path_id_namespace=path_id_namespace, is_insert=is_insert, is_update=is_update, view_rptr=view_rptr, ctx=scopectx) if pointer in pointers: schema = ctx.env.schema vnp = pointer.get_verbosename(schema, with_parent=True) raise errors.QueryError( f'duplicate definition of {vnp}', context=shape_el.context) pointers.append(pointer) if is_insert: explicit_ptrs = { ptrcls.get_local_name(ctx.env.schema) for ptrcls in pointers } scls_pointers = stype.get_pointers(ctx.env.schema) for pn, ptrcls in scls_pointers.items(ctx.env.schema): if (pn in explicit_ptrs or ptrcls.is_pure_computable(ctx.env.schema)): continue default_expr = ptrcls.get_default(ctx.env.schema) if not default_expr: if ( ptrcls.get_required(ctx.env.schema) and pn != sn.UnqualName('__type__') ): if ptrcls.is_property(ctx.env.schema): # If the target is a sequence, there's no need # for an explicit value. ptrcls_target = ptrcls.get_target(ctx.env.schema) assert ptrcls_target is not None if ptrcls_target.issubclass( ctx.env.schema, ctx.env.schema.get( 'std::sequence', type=s_objects.SubclassableObject)): continue vn = ptrcls.get_verbosename( ctx.env.schema, with_parent=True) raise errors.MissingRequiredError( f'missing value for required {vn}') else: continue ptrcls_sn = ptrcls.get_shortname(ctx.env.schema) default_ql = qlast.ShapeElement( expr=qlast.Path( steps=[ qlast.Ptr( ptr=qlast.ObjectRef( name=ptrcls_sn.name, module=ptrcls_sn.module, ), ), ], ), compexpr=qlast.DetachedExpr( expr=default_expr.qlast, ), ) with ctx.newscope(fenced=True) as scopectx: pointers.append( _normalize_view_ptr_expr( default_ql, view_scls, path_id=path_id, path_id_namespace=path_id_namespace, is_insert=is_insert, is_update=is_update, from_default=True, view_rptr=view_rptr, ctx=scopectx, ), ) elif ( stype.get_name(ctx.env.schema).module == 'schema' and ctx.env.options.apply_query_rewrites ): explicit_ptrs = { ptrcls.get_local_name(ctx.env.schema) for ptrcls in pointers } scls_pointers = stype.get_pointers(ctx.env.schema) for pn, ptrcls in scls_pointers.items(ctx.env.schema): if ( pn in explicit_ptrs or ptrcls.is_pure_computable(ctx.env.schema) ): continue schema_deflt = ptrcls.get_schema_reflection_default(ctx.env.schema) if schema_deflt is None: continue with ctx.newscope(fenced=True) as scopectx: ptr_ref = s_utils.name_to_ast_ref(pn) implicit_ql = qlast.ShapeElement( expr=qlast.Path(steps=[qlast.Ptr(ptr=ptr_ref)]), compexpr=qlast.BinOp( left=qlast.Path( partial=True, steps=[ qlast.Ptr( ptr=ptr_ref, direction=( s_pointers.PointerDirection.Outbound ), ) ], ), right=qlparser.parse_fragment(schema_deflt), op='??', ), ) # Note: we only need to record the schema default # as a computable, but not include it in the type # shape, so we ignore the return value. _normalize_view_ptr_expr( implicit_ql, view_scls, path_id=path_id, path_id_namespace=path_id_namespace, is_insert=is_insert, is_update=is_update, view_rptr=view_rptr, ctx=scopectx, ) for ptrcls in pointers: source: Union[s_types.Type, s_pointers.PointerLike] if ptrcls.is_link_property(ctx.env.schema): assert view_rptr is not None and view_rptr.ptrcls is not None source = view_rptr.ptrcls else: source = view_scls if is_defining_shape: cinfo = ctx.source_map.get(ptrcls) if cinfo is not None: shape_op = cinfo.shape_op else: shape_op = qlast.ShapeOp.ASSIGN ctx.env.view_shapes[source].append((ptrcls, shape_op)) if (view_rptr is not None and view_rptr.ptrcls is not None and view_scls != stype): ctx.env.schema = view_scls.set_field_value( ctx.env.schema, 'rptr', view_rptr.ptrcls) return view_scls
def interpret_backend_error(schema, fields): err_details = get_error_details(fields) # all generic errors are static and have been handled by this point if err_details.code == PGErrorCode.NotNullViolationError: source_name = pointer_name = None if err_details.schema_name and err_details.table_name: tabname = (err_details.schema_name, err_details.table_name) source = common.get_object_from_backend_name( schema, s_objtypes.ObjectType, tabname) source_name = source.get_displayname(schema) if err_details.column_name: pointer_name = err_details.column_name if pointer_name is not None: pname = f'{source_name}.{pointer_name}' return errors.MissingRequiredError( f'missing value for required property {pname}') else: return errors.InternalServerError(err_details.message) elif err_details.code in constraint_errors: error_type = None for errtype, ere in constraint_res.items(): m = ere.match(err_details.message) if m: error_type = errtype break # no need for else clause since it would have been handled by # the static version # so far 'constraint' is the only expected error_type here, # but in the future that might change, so we leave the if if error_type == 'constraint': # similarly, if we're here it's because we have a constraint_id constraint_id, _, _ = err_details.constraint_name.rpartition(';') constraint_id = uuid.UUID(constraint_id) constraint = schema.get_by_id(constraint_id) return errors.ConstraintViolationError( constraint.format_error_message(schema)) elif err_details.code == PGErrorCode.InvalidTextRepresentation: return errors.InvalidValueError( translate_pgtype(schema, err_details.message)) elif err_details.code == PGErrorCode.NumericValueOutOfRange: return errors.NumericOutOfRangeError( translate_pgtype(schema, err_details.message)) elif err_details.code in { PGErrorCode.InvalidDatetimeFormatError, PGErrorCode.DatetimeError }: return errors.InvalidValueError( translate_pgtype(schema, err_details.message)) return errors.InternalServerError(err_details.message)
def _process_view(*, stype: s_nodes.Node, path_id: irast.PathId, path_id_namespace: typing.Optional[ irast.WeakNamespace] = None, elements: typing.List[qlast.ShapeElement], view_rptr: typing.Optional[context.ViewRPtr] = None, view_name: typing.Optional[sn.SchemaName] = None, is_insert: bool = False, is_update: bool = False, ctx: context.CompilerContext) -> s_nodes.Node: view_scls = schemactx.derive_view(stype, is_insert=is_insert, is_update=is_update, derived_name=view_name, ctx=ctx) is_mutation = is_insert or is_update is_defining_shape = ctx.expr_exposed or is_mutation if view_rptr is not None and view_rptr.ptrcls is None: derive_ptrcls(view_rptr, target_scls=view_scls, transparent=True, ctx=ctx) pointers = [] for shape_el in elements: with ctx.newscope(fenced=True) as scopectx: pointers.append( _normalize_view_ptr_expr(shape_el, view_scls, path_id=path_id, path_id_namespace=path_id_namespace, is_insert=is_insert, is_update=is_update, view_rptr=view_rptr, ctx=scopectx)) if is_insert: explicit_ptrs = { ptrcls.get_shortname(ctx.env.schema).name for ptrcls in pointers } scls_pointers = stype.get_pointers(ctx.env.schema) for pn, ptrcls in scls_pointers.items(ctx.env.schema): if (pn in explicit_ptrs or ptrcls.is_pure_computable(ctx.env.schema)): continue if not ptrcls.get_default(ctx.env.schema): if ptrcls.get_required(ctx.env.schema): if ptrcls.is_property(ctx.env.schema): what = 'property' else: what = 'link' raise errors.MissingRequiredError( f'missing value for required {what} ' f'{stype.get_displayname(ctx.env.schema)}.' f'{ptrcls.get_displayname(ctx.env.schema)}') else: continue ptrcls_sn = ptrcls.get_shortname(ctx.env.schema) default_ql = qlast.ShapeElement(expr=qlast.Path(steps=[ qlast.Ptr(ptr=qlast.ObjectRef(name=ptrcls_sn.name, module=ptrcls_sn.module)) ])) with ctx.newscope(fenced=True) as scopectx: pointers.append( _normalize_view_ptr_expr( default_ql, view_scls, path_id=path_id, path_id_namespace=path_id_namespace, is_insert=is_insert, is_update=is_update, view_rptr=view_rptr, ctx=scopectx)) for ptrcls in pointers: if ptrcls.is_link_property(ctx.env.schema): source = view_rptr.ptrcls else: source = view_scls if is_defining_shape: ctx.env.view_shapes[source].append(ptrcls) if (view_rptr is not None and view_rptr.ptrcls is not None and view_scls is not stype): ctx.env.schema = view_scls.set_field_value(ctx.env.schema, 'rptr', view_rptr.ptrcls) return view_scls
def _process_view(*, stype: s_nodes.Node, path_id: irast.PathId, path_id_namespace: typing.Optional[ irast.WeakNamespace] = None, elements: typing.List[qlast.ShapeElement], view_rptr: typing.Optional[context.ViewRPtr] = None, view_name: typing.Optional[sn.SchemaName] = None, is_insert: bool = False, is_update: bool = False, ctx: context.CompilerContext) -> s_nodes.Node: view_scls = schemactx.derive_view(stype, is_insert=is_insert, is_update=is_update, derived_name=view_name, ctx=ctx) is_mutation = is_insert or is_update is_defining_shape = ctx.expr_exposed or is_mutation pointers = [] for shape_el in elements: with ctx.newscope(fenced=True) as scopectx: pointers.append( _normalize_view_ptr_expr(shape_el, view_scls, path_id=path_id, path_id_namespace=path_id_namespace, is_insert=is_insert, is_update=is_update, view_rptr=view_rptr, ctx=scopectx)) if is_insert: explicit_ptrs = { ptrcls.get_shortname(ctx.env.schema).name for ptrcls in pointers } scls_pointers = stype.get_pointers(ctx.env.schema) for pn, ptrcls in scls_pointers.items(ctx.env.schema): if (pn in explicit_ptrs or ptrcls.is_pure_computable(ctx.env.schema)): continue if not ptrcls.get_default(ctx.env.schema): if ptrcls.get_required(ctx.env.schema): if ptrcls.is_property(ctx.env.schema): what = 'property' else: what = 'link' raise errors.MissingRequiredError( f'missing value for required {what} ' f'{stype.get_displayname(ctx.env.schema)}.' f'{ptrcls.get_displayname(ctx.env.schema)}') else: continue ptrcls_sn = ptrcls.get_shortname(ctx.env.schema) default_ql = qlast.ShapeElement(expr=qlast.Path(steps=[ qlast.Ptr(ptr=qlast.ObjectRef(name=ptrcls_sn.name, module=ptrcls_sn.module)) ])) with ctx.newscope(fenced=True) as scopectx: pointers.append( _normalize_view_ptr_expr( default_ql, view_scls, path_id=path_id, path_id_namespace=path_id_namespace, is_insert=is_insert, is_update=is_update, view_rptr=view_rptr, ctx=scopectx)) for ptrcls in pointers: if ptrcls.is_link_property(ctx.env.schema): source = view_rptr.derived_ptrcls else: source = view_scls if ptrcls.get_source(ctx.env.schema) is source: ctx.env.schema = source.add_pointer(ctx.env.schema, ptrcls, replace=True) if is_defining_shape: if source is None: # The nested shape is merely selecting the pointer, # so the link class has not been derived. But for # the purposes of shape tracking, we must derive it # still. The derived pointer must be treated the same # as the original, as this is not a new computable, # and both `Foo.ptr` and `Foo { ptr }` are the same path, # hence the `transparent` modifier. source = derive_ptrcls(view_rptr, target_scls=view_scls, transparent=True, ctx=ctx) ctx.env.view_shapes[source].append(ptrcls) if (view_rptr is not None and view_rptr.derived_ptrcls is not None and view_scls is not stype): ctx.env.schema = view_scls.set_field_value(ctx.env.schema, 'rptr', view_rptr.derived_ptrcls) return view_scls
def interpret_backend_error(schema, fields): # See https://www.postgresql.org/docs/current/protocol-error-fields.html # for the full list of PostgreSQL error message fields. message = fields.get('M') detail = fields.get('D') detail_json = None if detail and detail.startswith('{'): detail_json = json.loads(detail) detail = None if detail_json: errcode = detail_json.get('code') if errcode: try: errcls = type( errors.EdgeDBError).get_error_class_from_code(errcode) except LookupError: pass else: err = errcls(message) err.set_linecol(detail_json.get('line', -1), detail_json.get('column', -1)) return err try: code = PGError(fields['C']) except ValueError: return errors.InternalServerError(message) schema_name = fields.get('s') table_name = fields.get('t') column_name = fields.get('c') constraint_name = fields.get('n') if code == PGError.NotNullViolationError: source_name = pointer_name = None if schema_name and table_name: tabname = (schema_name, table_name) source = common.get_object_from_backend_name( schema, s_objtypes.ObjectType, tabname) source_name = source.get_displayname(schema) if column_name: pointer_name = column_name if pointer_name is not None: pname = f'{source_name}.{pointer_name}' return errors.MissingRequiredError( f'missing value for required property {pname}') else: return errors.InternalServerError(message) elif code in constraint_errors: source = pointer = None for errtype, ere in constraint_res.items(): m = ere.match(message) if m: error_type = errtype break else: return errors.InternalServerError(message) if error_type == 'cardinality': return errors.CardinalityViolationError('cardinality violation', source=source, pointer=pointer) elif error_type == 'link_target': if detail_json: srcname = detail_json.get('source') ptrname = detail_json.get('pointer') target = detail_json.get('target') expected = detail_json.get('expected') if srcname and ptrname: srcname = sn.Name(srcname) ptrname = sn.Name(ptrname) lname = '{}.{}'.format(srcname, ptrname.name) else: lname = '' msg = (f'invalid target for link {lname!r}: {target!r} ' f'(expecting {expected!r})') else: msg = 'invalid target for link' return errors.UnknownLinkError(msg) elif error_type == 'link_target_del': return errors.ConstraintViolationError(message, details=detail) elif error_type == 'constraint': if constraint_name is None: return errors.InternalServerError(message) constraint_id, _, _ = constraint_name.rpartition(';') try: constraint_id = uuid.UUID(constraint_id) except ValueError: return errors.InternalServerError(message) constraint = schema.get_by_id(constraint_id) return errors.ConstraintViolationError( constraint.format_error_message(schema)) elif error_type == 'id': return errors.ConstraintViolationError( 'unique link constraint violation') elif code == PGError.InvalidParameterValue: return errors.InvalidValueError(message, details=detail if detail else None) elif code == PGError.InvalidTextRepresentation: return errors.InvalidValueError(translate_pgtype(schema, message)) elif code == PGError.NumericValueOutOfRange: return errors.NumericOutOfRangeError(translate_pgtype(schema, message)) elif code == PGError.DivisionByZeroError: return errors.DivisionByZeroError(message) elif code == PGError.ReadOnlySQLTransactionError: return errors.TransactionError( 'cannot execute query in a read-only transaction') elif code in {PGError.InvalidDatetimeFormatError, PGError.DatetimeError}: return errors.InvalidValueError(translate_pgtype(schema, message)) elif code == PGError.TransactionSerializationFailure: return errors.TransactionSerializationError(message) elif code == PGError.TransactionDeadlockDetected: return errors.TransactionDeadlockError(message) return errors.InternalServerError(message)
def interpret_backend_error(schema, fields): # See https://www.postgresql.org/docs/current/protocol-error-fields.html # for the full list of PostgreSQL error message fields. message = fields.get('M') try: code = PGError(fields['C']) except ValueError: return errors.InternalServerError(message) schema_name = fields.get('s') table_name = fields.get('t') column_name = fields.get('c') detail = fields.get('D') constraint_name = fields.get('n') if code == PGError.NotNullViolationError: source_name = pointer_name = None if schema_name and table_name: tabname = (schema_name, table_name) source = common.get_object_from_backend_name( schema, s_objtypes.ObjectType, tabname) source_name = source.get_displayname(schema) if column_name: pointer_name = column_name if pointer_name is not None: pname = f'{source_name}.{pointer_name}' return errors.MissingRequiredError( f'missing value for required property {pname}') else: return errors.InternalServerError(message) elif code in constraint_errors: source = pointer = None for type, ere in constraint_res.items(): m = ere.match(message) if m: error_type = type break else: return errors.InternalServerError(message) if error_type == 'cardinality': return errors.CardinalityViolationError('cardinality violation', source=source, pointer=pointer) elif error_type == 'link_target': if detail: try: detail = json.loads(detail) except ValueError: detail = None if detail is not None: srcname = detail.get('source') ptrname = detail.get('pointer') target = detail.get('target') expected = detail.get('expected') if srcname and ptrname: srcname = sn.Name(srcname) ptrname = sn.Name(ptrname) lname = '{}.{}'.format(srcname, ptrname.name) else: lname = '' msg = (f'invalid target for link {lname!r}: {target!r} ' f'(expecting {expected!r})') else: msg = 'invalid target for link' return errors.UnknownLinkError(msg) elif error_type == 'link_target_del': return errors.ConstraintViolationError(message, details=detail) elif error_type == 'constraint': if constraint_name is None: return errors.InternalServerError(message) constraint_id, _, _ = constraint_name.rpartition(';') try: constraint_id = uuid.UUID(constraint_id) except ValueError: return errors.InternalServerError(message) constraint = schema.get_by_id(constraint_id) return errors.ConstraintViolationError( constraint.format_error_message(schema)) elif error_type == 'id': return errors.ConstraintViolationError( 'unique link constraint violation') elif code == PGError.NumericValueOutOfRange: return errors.NumericOutOfRangeError(message) return errors.InternalServerError(message)
def _process_view(*, stype: s_objtypes.ObjectType, path_id: irast.PathId, path_id_namespace: Optional[irast.WeakNamespace] = None, elements: List[qlast.ShapeElement], view_rptr: Optional[context.ViewRPtr] = None, view_name: Optional[sn.SchemaName] = None, is_insert: bool = False, is_update: bool = False, ctx: context.ContextLevel) -> s_objtypes.ObjectType: if (view_name is None and ctx.env.schema_view_mode and view_rptr is not None): # Make sure persistent schema expression aliases have properly formed # names as opposed to the usual mangled form of the ephemeral # aliases. This is needed for introspection readability, as well # as helps in maintaining proper type names for schema # representations that require alphanumeric names, such as # GraphQL. # # We use the name of the source together with the name # of the inbound link to form the name, so in e.g. # CREATE ALIAS V := (SELECT Foo { bar: { baz: { ... } }) # The name of the innermost alias would be "__V__bar__baz". source_name = view_rptr.source.get_name(ctx.env.schema).name if not source_name.startswith('__'): source_name = f'__{source_name}' if view_rptr.ptrcls_name is not None: ptr_name = view_rptr.ptrcls_name.name elif view_rptr.ptrcls is not None: ptr_name = view_rptr.ptrcls.get_shortname(ctx.env.schema).name else: raise errors.InternalServerError( '_process_view in schema mode received view_rptr with ' 'neither ptrcls_name, not ptrcls') name = f'{source_name}__{ptr_name}' view_name = sn.Name( module=ctx.derived_target_module or '__derived__', name=name, ) view_scls = schemactx.derive_view(stype, is_insert=is_insert, is_update=is_update, derived_name=view_name, ctx=ctx) assert isinstance(view_scls, s_objtypes.ObjectType) is_mutation = is_insert or is_update is_defining_shape = ctx.expr_exposed or is_mutation if view_rptr is not None and view_rptr.ptrcls is None: derive_ptrcls(view_rptr, target_scls=view_scls, transparent=True, ctx=ctx) pointers = [] for shape_el in elements: with ctx.newscope(fenced=True) as scopectx: pointers.append( _normalize_view_ptr_expr(shape_el, view_scls, path_id=path_id, path_id_namespace=path_id_namespace, is_insert=is_insert, is_update=is_update, view_rptr=view_rptr, ctx=scopectx)) if is_insert: assert isinstance(stype, s_objtypes.ObjectType) explicit_ptrs = { ptrcls.get_shortname(ctx.env.schema).name for ptrcls in pointers } scls_pointers = stype.get_pointers(ctx.env.schema) for pn, ptrcls in scls_pointers.items(ctx.env.schema): if (pn in explicit_ptrs or ptrcls.is_pure_computable(ctx.env.schema)): continue if not ptrcls.get_default(ctx.env.schema): if ptrcls.get_required(ctx.env.schema): if ptrcls.is_property(ctx.env.schema): # If the target is a sequence, there's no need # for an explicit value. if ptrcls.get_target(ctx.env.schema).issubclass( ctx.env.schema, ctx.env.schema.get('std::sequence')): continue what = 'property' else: what = 'link' raise errors.MissingRequiredError( f'missing value for required {what} ' f'{stype.get_displayname(ctx.env.schema)}.' f'{ptrcls.get_displayname(ctx.env.schema)}') else: continue ptrcls_sn = ptrcls.get_shortname(ctx.env.schema) default_ql = qlast.ShapeElement(expr=qlast.Path(steps=[ qlast.Ptr(ptr=qlast.ObjectRef(name=ptrcls_sn.name, module=ptrcls_sn.module)) ])) with ctx.newscope(fenced=True) as scopectx: pointers.append( _normalize_view_ptr_expr( default_ql, view_scls, path_id=path_id, path_id_namespace=path_id_namespace, is_insert=is_insert, is_update=is_update, view_rptr=view_rptr, ctx=scopectx)) for ptrcls in pointers: source: Union[s_types.Type, s_pointers.PointerLike] if ptrcls.is_link_property(ctx.env.schema): assert view_rptr is not None and view_rptr.ptrcls is not None source = view_rptr.ptrcls else: source = view_scls if is_defining_shape: ctx.env.view_shapes[source].append(ptrcls) if (view_rptr is not None and view_rptr.ptrcls is not None and view_scls is not stype): ctx.env.schema = view_scls.set_field_value(ctx.env.schema, 'rptr', view_rptr.ptrcls) return view_scls
def interpret_backend_error(schema, fields): err_details = get_error_details(fields) hint = None details = None if err_details.detail_json: hint = err_details.detail_json.get('hint') # all generic errors are static and have been handled by this point if err_details.code == PGErrorCode.NotNullViolationError: colname = err_details.column_name if colname: if colname.startswith('??'): ptr_id, *_ = colname[2:].partition('_') else: ptr_id = colname pointer = common.get_object_from_backend_name( schema, s_pointers.Pointer, ptr_id) pname = pointer.get_verbosename(schema, with_parent=True) else: pname = None if pname is not None: if err_details.detail_json: object_id = err_details.detail_json.get('object_id') if object_id is not None: details = f'Failing object id is {str(object_id)!r}.' return errors.MissingRequiredError( f'missing value for required {pname}', details=details, hint=hint, ) else: return errors.InternalServerError(err_details.message) elif err_details.code in constraint_errors: error_type = None match = None for errtype, ere in constraint_res.items(): m = ere.match(err_details.message) if m: error_type = errtype match = m break # no need for else clause since it would have been handled by # the static version if error_type == 'constraint': # similarly, if we're here it's because we have a constraint_id constraint_id, _, _ = err_details.constraint_name.rpartition(';') constraint_id = uuidgen.UUID(constraint_id) constraint = schema.get_by_id(constraint_id) return errors.ConstraintViolationError( constraint.format_error_message(schema)) elif error_type == 'newconstraint': # If we're here, it means that we already validated that # schema_name, table_name and column_name all exist. tabname = (err_details.schema_name, err_details.table_name) source = common.get_object_from_backend_name( schema, s_objtypes.ObjectType, tabname) source_name = source.get_displayname(schema) pointer = common.get_object_from_backend_name( schema, s_pointers.Pointer, err_details.column_name) pointer_name = pointer.get_shortname(schema).name return errors.ConstraintViolationError( f'Existing {source_name}.{pointer_name} ' f'values violate the new constraint') elif error_type == 'scalar': domain_name = match.group(1) stype_name = types.base_type_name_map_r.get(domain_name) if stype_name: msg = f'invalid value for scalar type {str(stype_name)!r}' else: msg = translate_pgtype(schema, err_details.message) return errors.InvalidValueError(msg) elif err_details.code == PGErrorCode.InvalidTextRepresentation: return errors.InvalidValueError( translate_pgtype(schema, err_details.message)) elif err_details.code == PGErrorCode.NumericValueOutOfRange: return errors.NumericOutOfRangeError( translate_pgtype(schema, err_details.message)) elif err_details.code in { PGErrorCode.InvalidDatetimeFormatError, PGErrorCode.DatetimeError }: return errors.InvalidValueError(translate_pgtype( schema, err_details.message), hint=hint) return errors.InternalServerError(err_details.message)
async def _interpret_db_error(cls, schema, intro_mech, constr_mech, err): if isinstance(err, asyncpg.NotNullViolationError): source_name = pointer_name = None if err.schema_name and err.table_name: tabname = (err.schema_name, err.table_name) source = common.get_object_from_backend_name( schema, s_objtypes.ObjectType, tabname) source_name = source.get_displayname(schema) if err.column_name: pointer_name = err.column_name if pointer_name is not None: pname = f'{source_name}.{pointer_name}' return errors.MissingRequiredError( 'missing value for required property {}'.format(pname), source_name=source_name, pointer_name=pointer_name) else: return errors.InternalServerError(err.message) elif isinstance(err, asyncpg.IntegrityConstraintViolationError): source = pointer = None for ecls, eres in cls.error_res.items(): if isinstance(err, ecls): break else: eres = {} for type, ere in eres.items(): m = ere.match(err.message) if m: error_type = type break else: return errors.InternalServerError(err.message) if error_type == 'cardinality': err = 'cardinality violation' errcls = errors.CardinalityViolationError return errcls(err, source=source, pointer=pointer) elif error_type == 'link_target': if err.detail: try: detail = json.loads(err.detail) except ValueError: detail = None if detail is not None: srcname = detail.get('source') ptrname = detail.get('pointer') target = detail.get('target') expected = detail.get('expected') if srcname and ptrname: srcname = sn.Name(srcname) ptrname = sn.Name(ptrname) lname = '{}.{}'.format(srcname, ptrname.name) else: lname = '' msg = 'invalid target for link {!r}: {!r} (' \ 'expecting {!r})'.format(lname, target, ' or '.join(expected)) else: msg = 'invalid target for link' return errors.UnknownLinkError(msg) elif error_type == 'link_target_del': return errors.ConstraintViolationError(err.message, detail=err.detail) elif error_type == 'constraint': if err.constraint_name is None: return errors.InternalServerError(err.message) constraint_id, _, _ = err.constraint_name.rpartition(';') try: constraint_id = uuid.UUID(constraint_id) except ValueError: return errors.InternalServerError(err.message) constraint = schema.get_by_id(constraint_id) return errors.ConstraintViolationError( constraint.format_error_message(schema)) elif error_type == 'id': msg = 'unique link constraint violation' errcls = errors.ConstraintViolationError return errcls(msg=msg) else: return errors.InternalServerError(err.message)
def interpret_backend_error(schema, fields): err_details = get_error_details(fields) hint = None details = None if err_details.detail_json: hint = err_details.detail_json.get('hint') # all generic errors are static and have been handled by this point if err_details.code == pgerrors.ERROR_NOT_NULL_VIOLATION: colname = err_details.column_name if colname: if colname.startswith('??'): ptr_id, *_ = colname[2:].partition('_') else: ptr_id = colname pointer = common.get_object_from_backend_name( schema, s_pointers.Pointer, ptr_id) pname = pointer.get_verbosename(schema, with_parent=True) else: pname = None if pname is not None: if err_details.detail_json: object_id = err_details.detail_json.get('object_id') if object_id is not None: details = f'Failing object id is {str(object_id)!r}.' return errors.MissingRequiredError( f'missing value for required {pname}', details=details, hint=hint, ) else: return errors.InternalServerError(err_details.message) elif err_details.code in constraint_errors: error_type = None match = None for errtype, ere in constraint_res.items(): m = ere.match(err_details.message) if m: error_type = errtype match = m break # no need for else clause since it would have been handled by # the static version if error_type == 'constraint': # similarly, if we're here it's because we have a constraint_id constraint_id, _, _ = err_details.constraint_name.rpartition(';') constraint_id = uuidgen.UUID(constraint_id) constraint = schema.get_by_id(constraint_id) return errors.ConstraintViolationError( constraint.format_error_message(schema)) elif error_type == 'newconstraint': # If we're here, it means that we already validated that # schema_name, table_name and column_name all exist. tabname = (err_details.schema_name, err_details.table_name) source = common.get_object_from_backend_name( schema, s_objtypes.ObjectType, tabname) source_name = source.get_displayname(schema) pointer = common.get_object_from_backend_name( schema, s_pointers.Pointer, err_details.column_name) pointer_name = pointer.get_shortname(schema).name return errors.ConstraintViolationError( f'Existing {source_name}.{pointer_name} ' f'values violate the new constraint') elif error_type == 'scalar': domain_name = match.group(1) stype_name = types.base_type_name_map_r.get(domain_name) if stype_name: if match.group(2) in range_constraints: msg = f'{str(stype_name)!r} value out of range' else: msg = f'invalid value for scalar type {str(stype_name)!r}' else: msg = translate_pgtype(schema, err_details.message) return errors.InvalidValueError(msg) elif err_details.code == pgerrors.ERROR_INVALID_TEXT_REPRESENTATION: return errors.InvalidValueError( translate_pgtype(schema, err_details.message)) elif err_details.code == pgerrors.ERROR_NUMERIC_VALUE_OUT_OF_RANGE: return errors.NumericOutOfRangeError( translate_pgtype(schema, err_details.message)) elif err_details.code in {pgerrors.ERROR_INVALID_DATETIME_FORMAT, pgerrors.ERROR_DATETIME_FIELD_OVERFLOW}: return errors.InvalidValueError( translate_pgtype(schema, err_details.message), hint=hint) elif ( err_details.code == pgerrors.ERROR_WRONG_OBJECT_TYPE and err_details.message == 'covariance error' ): ptr = schema.get_by_id(uuidgen.UUID(err_details.column_name)) wrong_obj = schema.get_by_id(uuidgen.UUID(err_details.table_name)) vn = ptr.get_verbosename(schema, with_parent=True) return errors.InvalidLinkTargetError( f"invalid target for {vn}: '{wrong_obj.get_name(schema)}'" f" (expecting '{ptr.get_target(schema).get_name(schema)}')" ) return errors.InternalServerError(err_details.message)
def _process_view( *, stype: s_objtypes.ObjectType, path_id: irast.PathId, path_id_namespace: Optional[irast.Namespace] = None, elements: Optional[Sequence[qlast.ShapeElement]], view_rptr: Optional[context.ViewRPtr] = None, view_name: Optional[sn.QualName] = None, is_insert: bool = False, is_update: bool = False, is_delete: bool = False, parser_context: Optional[pctx.ParserContext], ctx: context.ContextLevel, ) -> s_objtypes.ObjectType: if (view_name is None and ctx.env.options.schema_view_mode and view_rptr is not None): # Make sure persistent schema expression aliases have properly formed # names as opposed to the usual mangled form of the ephemeral # aliases. This is needed for introspection readability, as well # as helps in maintaining proper type names for schema # representations that require alphanumeric names, such as # GraphQL. # # We use the name of the source together with the name # of the inbound link to form the name, so in e.g. # CREATE ALIAS V := (SELECT Foo { bar: { baz: { ... } }) # The name of the innermost alias would be "__V__bar__baz". source_name = view_rptr.source.get_name(ctx.env.schema).name if not source_name.startswith('__'): source_name = f'__{source_name}' if view_rptr.ptrcls_name is not None: ptr_name = view_rptr.ptrcls_name.name elif view_rptr.ptrcls is not None: ptr_name = view_rptr.ptrcls.get_shortname(ctx.env.schema).name else: raise errors.InternalServerError( '_process_view in schema mode received view_rptr with ' 'neither ptrcls_name, not ptrcls' ) name = f'{source_name}__{ptr_name}' view_name = sn.QualName( module=ctx.derived_target_module or '__derived__', name=name, ) view_scls = schemactx.derive_view( stype, is_insert=is_insert, is_update=is_update, is_delete=is_delete, derived_name=view_name, ctx=ctx, ) assert isinstance(view_scls, s_objtypes.ObjectType), view_scls is_mutation = is_insert or is_update is_defining_shape = ctx.expr_exposed or is_mutation if view_rptr is not None and view_rptr.ptrcls is None: derive_ptrcls( view_rptr, target_scls=view_scls, transparent=True, ctx=ctx) pointers = [] elements = elements or () for shape_el in elements: with ctx.newscope(fenced=True) as scopectx: pointer = _normalize_view_ptr_expr( shape_el, view_scls, path_id=path_id, path_id_namespace=path_id_namespace, is_insert=is_insert, is_update=is_update, view_rptr=view_rptr, ctx=scopectx) if pointer in pointers: schema = ctx.env.schema vnp = pointer.get_verbosename(schema, with_parent=True) raise errors.QueryError( f'duplicate definition of {vnp}', context=shape_el.context) pointers.append(pointer) # If we are not defining a shape (so we might care about # materialization), look through our parent view (if one exists) # for materialized properties that are not present in this shape. # If any are found, inject them. # (See test_edgeql_volatility_rebind_flat_01 for an example.) schema = ctx.env.schema base = view_scls.get_bases(schema).objects(schema)[0] base_ptrs = (view_scls.get_pointers(schema).objects(schema) if not is_defining_shape else ()) for ptrcls in base_ptrs: if ptrcls in pointers or base not in ctx.env.view_shapes: continue pptr = ptrcls.get_bases(schema).objects(schema)[0] if (pptr, qlast.ShapeOp.MATERIALIZE) not in ctx.env.view_shapes[base]: continue # Make up a dummy shape element name = ptrcls.get_shortname(schema).name dummy_el = qlast.ShapeElement(expr=qlast.Path( steps=[qlast.Ptr(ptr=qlast.ObjectRef(name=name))])) with ctx.newscope(fenced=True) as scopectx: pointer = _normalize_view_ptr_expr( dummy_el, view_scls, path_id=path_id, path_id_namespace=path_id_namespace, is_insert=is_insert, is_update=is_update, view_rptr=view_rptr, ctx=scopectx) pointers.append(pointer) if is_insert: explicit_ptrs = { ptrcls.get_local_name(ctx.env.schema) for ptrcls in pointers } scls_pointers = stype.get_pointers(ctx.env.schema) for pn, ptrcls in scls_pointers.items(ctx.env.schema): if (pn in explicit_ptrs or ptrcls.is_pure_computable(ctx.env.schema)): continue default_expr = ptrcls.get_default(ctx.env.schema) if not default_expr: if ( ptrcls.get_required(ctx.env.schema) and pn != sn.UnqualName('__type__') ): if ptrcls.is_property(ctx.env.schema): # If the target is a sequence, there's no need # for an explicit value. ptrcls_target = ptrcls.get_target(ctx.env.schema) assert ptrcls_target is not None if ptrcls_target.issubclass( ctx.env.schema, ctx.env.schema.get( 'std::sequence', type=s_objects.SubclassableObject)): continue vn = ptrcls.get_verbosename( ctx.env.schema, with_parent=True) raise errors.MissingRequiredError( f'missing value for required {vn}') else: continue ptrcls_sn = ptrcls.get_shortname(ctx.env.schema) default_ql = qlast.ShapeElement( expr=qlast.Path( steps=[ qlast.Ptr( ptr=qlast.ObjectRef( name=ptrcls_sn.name, module=ptrcls_sn.module, ), ), ], ), compexpr=qlast.DetachedExpr( expr=default_expr.qlast, ), ) with ctx.newscope(fenced=True) as scopectx: pointers.append( _normalize_view_ptr_expr( default_ql, view_scls, path_id=path_id, path_id_namespace=path_id_namespace, is_insert=is_insert, is_update=is_update, from_default=True, view_rptr=view_rptr, ctx=scopectx, ), ) for ptrcls in pointers: source: Union[s_types.Type, s_pointers.PointerLike] if ptrcls.is_link_property(ctx.env.schema): assert view_rptr is not None and view_rptr.ptrcls is not None source = view_rptr.ptrcls else: source = view_scls if is_defining_shape: cinfo = ctx.source_map.get(ptrcls) if cinfo is not None: shape_op = cinfo.shape_op else: shape_op = qlast.ShapeOp.ASSIGN elif ptrcls.get_computable(ctx.env.schema): shape_op = qlast.ShapeOp.MATERIALIZE else: continue ctx.env.view_shapes[source].append((ptrcls, shape_op)) if (view_rptr is not None and view_rptr.ptrcls is not None and view_scls != stype): ctx.env.schema = view_scls.set_field_value( ctx.env.schema, 'rptr', view_rptr.ptrcls) return view_scls
def _interpret_constraint_errors(code, schema, err_details, hint): details = None if code == pgerrors.ERROR_NOT_NULL_VIOLATION: colname = err_details.column_name if colname: if colname.startswith('??'): ptr_id, *_ = colname[2:].partition('_') else: ptr_id = colname pointer = common.get_object_from_backend_name( schema, s_pointers.Pointer, ptr_id) pname = pointer.get_verbosename(schema, with_parent=True) else: pname = None if pname is not None: if err_details.detail_json: object_id = err_details.detail_json.get('object_id') if object_id is not None: details = f'Failing object id is {str(object_id)!r}.' return errors.MissingRequiredError( f'missing value for required {pname}', details=details, hint=hint, ) else: return errors.InternalServerError(err_details.message) error_type = None match = None for errtype, ere in constraint_res.items(): m = ere.match(err_details.message) if m: error_type = errtype match = m break # no need for else clause since it would have been handled by # the static version if error_type == 'constraint': # similarly, if we're here it's because we have a constraint_id constraint_id, _, _ = err_details.constraint_name.rpartition(';') constraint_id = uuidgen.UUID(constraint_id) constraint = schema.get_by_id(constraint_id) msg = constraint.format_error(schema) subject = constraint.get_subject(schema) vname = subject.get_verbosename(schema, with_parent=True) subjtitle = f"value of {vname}" details = constraint.format_error_message(schema, subjtitle) return errors.ConstraintViolationError(msg, details=details) elif error_type == 'newconstraint': # If we're here, it means that we already validated that # schema_name, table_name and column_name all exist. tabname = (err_details.schema_name, err_details.table_name) source = common.get_object_from_backend_name(schema, s_objtypes.ObjectType, tabname) source_name = source.get_displayname(schema) pointer = common.get_object_from_backend_name(schema, s_pointers.Pointer, err_details.column_name) pointer_name = pointer.get_shortname(schema).name return errors.ConstraintViolationError( f'Existing {source_name}.{pointer_name} ' f'values violate the new constraint') elif error_type == 'scalar': domain_name = match.group(1) stype_name = types.base_type_name_map_r.get(domain_name) if stype_name: if match.group(2) in range_constraints: msg = f'{str(stype_name)!r} value out of range' else: msg = f'invalid value for scalar type {str(stype_name)!r}' else: msg = translate_pgtype(schema, err_details.message) return errors.InvalidValueError(msg) return errors.InternalServerError(err_details.message)