async def _on_before_drop_db(self, dbname: str,
current_dbname: str) -> None:
if current_dbname == dbname:
raise errors.ExecutionError(
f'cannot drop the currently open database {dbname!r}')
await self._ensure_database_not_connected(dbname)
async def _on_drop_db(self, dbname: str, current_dbname: str) -> None:
assert self._dbindex is not None
if current_dbname == dbname:
raise errors.ExecutionError(
f'cannot drop the currently open database {dbname!r}')
if self._dbindex.count_connections(dbname):
# If there are open EdgeDB connections to the `dbname` DB
# just raise the error Postgres would have raised itself.
raise errors.ExecutionError(
f'database {dbname!r} is being accessed by other users')
else:
# If, however, there are no open EdgeDB connections, prune
# all non-active postgres connection to the `dbname` DB.
await self._pg_pool.prune_inactive_connections(dbname)
async def _on_before_create_db_from_template(self, dbname: str,
current_dbname: str):
if current_dbname == dbname:
raise errors.ExecutionError(
f'cannot create database using currently open database '
f'{dbname!r} as a template database')
await self._ensure_database_not_connected(dbname)
async def _ensure_database_not_connected(self, dbname: str):
assert self._dbindex is not None
if self._dbindex.count_connections(dbname):
# If there are open EdgeDB connections to the `dbname` DB
# just raise the error Postgres would have raised itself.
raise errors.ExecutionError(
f'database {dbname!r} is being accessed by other users')
else:
# If, however, there are no open EdgeDB connections, prune
# all non-active postgres connection to the `dbname` DB.
await self._pg_pool.prune_inactive_connections(dbname)
def static_interpret_backend_error(fields):
err_details = get_error_details(fields)
# handle some generic errors if possible
err = get_generic_exception_from_err_details(err_details)
if err is not None:
return err
if err_details.code == PGErrorCode.NotNullViolationError:
if err_details.table_name or err_details.column_name:
return SchemaRequired
else:
return errors.InternalServerError(err_details.message)
elif err_details.code in constraint_errors:
source = pointer = None
for errtype, ere in constraint_res.items():
m = ere.match(err_details.message)
if m:
error_type = errtype
break
else:
return errors.InternalServerError(err_details.message)
if error_type == 'cardinality':
return errors.CardinalityViolationError('cardinality violation',
source=source,
pointer=pointer)
elif error_type == 'link_target':
if err_details.detail_json:
srcname = err_details.detail_json.get('source')
ptrname = err_details.detail_json.get('pointer')
target = err_details.detail_json.get('target')
expected = err_details.detail_json.get('expected')
if srcname and ptrname:
srcname = sn.QualName.from_string(srcname)
ptrname = sn.QualName.from_string(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(err_details.message,
details=err_details.detail)
elif error_type == 'constraint':
if err_details.constraint_name is None:
return errors.InternalServerError(err_details.message)
constraint_id, _, _ = err_details.constraint_name.rpartition(';')
try:
constraint_id = uuidgen.UUID(constraint_id)
except ValueError:
return errors.InternalServerError(err_details.message)
return SchemaRequired
elif error_type == 'newconstraint':
# We can reconstruct what went wrong from the schema_name,
# table_name, and column_name. But we don't expect
# constraint_name to be present (because the constraint is
# not yet present in the schema?).
if (err_details.schema_name and err_details.table_name
and err_details.column_name):
return SchemaRequired
else:
return errors.InternalServerError(err_details.message)
elif error_type == 'scalar':
return SchemaRequired
elif error_type == 'id':
return errors.ConstraintViolationError(
'unique link constraint violation')
elif err_details.code in SCHEMA_CODES:
if err_details.code == PGErrorCode.InvalidDatetimeFormatError:
hint = None
if err_details.detail_json:
hint = err_details.detail_json.get('hint')
if err_details.message.startswith('missing required time zone'):
return errors.InvalidValueError(err_details.message, hint=hint)
elif err_details.message.startswith('unexpected time zone'):
return errors.InvalidValueError(err_details.message, hint=hint)
return SchemaRequired
elif err_details.code == PGErrorCode.InvalidParameterValue:
return errors.InvalidValueError(
err_details.message,
details=err_details.detail if err_details.detail else None)
elif err_details.code == PGErrorCode.WrongObjectType:
return errors.InvalidValueError(
err_details.message,
details=err_details.detail if err_details.detail else None)
elif err_details.code == PGErrorCode.DivisionByZeroError:
return errors.DivisionByZeroError(err_details.message)
elif err_details.code == PGErrorCode.ReadOnlySQLTransactionError:
return errors.TransactionError(
'cannot execute query in a read-only transaction')
elif err_details.code == PGErrorCode.TransactionSerializationFailure:
return errors.TransactionSerializationError(err_details.message)
elif err_details.code == PGErrorCode.TransactionDeadlockDetected:
return errors.TransactionDeadlockError(err_details.message)
elif err_details.code == PGErrorCode.InvalidCatalogNameError:
return errors.AuthenticationError(err_details.message)
elif err_details.code == PGErrorCode.ObjectInUse:
return errors.ExecutionError(err_details.message)
return errors.InternalServerError(err_details.message)
def static_interpret_backend_error(fields):
err_details = get_error_details(fields)
# handle some generic errors if possible
err = get_generic_exception_from_err_details(err_details)
if err is not None:
return err
if err_details.code == pgerrors.ERROR_NOT_NULL_VIOLATION:
if err_details.table_name or err_details.column_name:
return SchemaRequired
else:
return errors.InternalServerError(err_details.message)
elif err_details.code in constraint_errors:
source = pointer = None
for errtype, ere in constraint_res.items():
m = ere.match(err_details.message)
if m:
error_type = errtype
break
else:
return errors.InternalServerError(err_details.message)
if error_type == 'cardinality':
return errors.CardinalityViolationError(
'cardinality violation',
source=source, pointer=pointer)
elif error_type == 'link_target':
if err_details.detail_json:
srcname = err_details.detail_json.get('source')
ptrname = err_details.detail_json.get('pointer')
target = err_details.detail_json.get('target')
expected = err_details.detail_json.get('expected')
if srcname and ptrname:
srcname = sn.QualName.from_string(srcname)
ptrname = sn.QualName.from_string(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(
err_details.message, details=err_details.detail)
elif error_type == 'constraint':
if err_details.constraint_name is None:
return errors.InternalServerError(err_details.message)
constraint_id, _, _ = err_details.constraint_name.rpartition(';')
try:
constraint_id = uuidgen.UUID(constraint_id)
except ValueError:
return errors.InternalServerError(err_details.message)
return SchemaRequired
elif error_type == 'newconstraint':
# We can reconstruct what went wrong from the schema_name,
# table_name, and column_name. But we don't expect
# constraint_name to be present (because the constraint is
# not yet present in the schema?).
if (err_details.schema_name and err_details.table_name and
err_details.column_name):
return SchemaRequired
else:
return errors.InternalServerError(err_details.message)
elif error_type == 'scalar':
return SchemaRequired
elif error_type == 'id':
return errors.ConstraintViolationError(
'unique link constraint violation')
elif err_details.code in SCHEMA_CODES:
if err_details.code == pgerrors.ERROR_INVALID_DATETIME_FORMAT:
hint = None
if err_details.detail_json:
hint = err_details.detail_json.get('hint')
if err_details.message.startswith('missing required time zone'):
return errors.InvalidValueError(err_details.message, hint=hint)
elif err_details.message.startswith('unexpected time zone'):
return errors.InvalidValueError(err_details.message, hint=hint)
return SchemaRequired
elif err_details.code == pgerrors.ERROR_INVALID_PARAMETER_VALUE:
return errors.InvalidValueError(
err_details.message,
details=err_details.detail if err_details.detail else None
)
elif err_details.code == pgerrors.ERROR_WRONG_OBJECT_TYPE:
if err_details.column_name:
return SchemaRequired
return errors.InvalidValueError(
err_details.message,
details=err_details.detail if err_details.detail else None
)
elif err_details.code == pgerrors.ERROR_DIVISION_BY_ZERO:
return errors.DivisionByZeroError(err_details.message)
elif err_details.code == pgerrors.ERROR_INTERVAL_FIELD_OVERFLOW:
return errors.NumericOutOfRangeError(err_details.message)
elif err_details.code == pgerrors.ERROR_READ_ONLY_SQL_TRANSACTION:
return errors.TransactionError(
'cannot execute query in a read-only transaction')
elif err_details.code == pgerrors.ERROR_SERIALIZATION_FAILURE:
return errors.TransactionSerializationError(err_details.message)
elif err_details.code == pgerrors.ERROR_DEADLOCK_DETECTED:
return errors.TransactionDeadlockError(err_details.message)
elif err_details.code == pgerrors.ERROR_INVALID_CATALOG_NAME:
return errors.UnknownDatabaseError(err_details.message)
elif err_details.code == pgerrors.ERROR_OBJECT_IN_USE:
return errors.ExecutionError(err_details.message)
elif err_details.code == pgerrors.ERROR_DUPLICATE_DATABASE:
return errors.DuplicateDatabaseDefinitionError(err_details.message)
elif (
err_details.code == pgerrors.ERROR_CARDINALITY_VIOLATION
and err_details.constraint_name == 'std::assert_single'
):
return errors.CardinalityViolationError(err_details.message)
return errors.InternalServerError(err_details.message)