from .consts import VERSION as __version__ # noqa
from .connection import AsyncConnection, Connection
-from .exceptions import (
+from .errors import (
Warning,
Error,
InterfaceError,
from typing import Any, Callable, Dict, Generator, List, Optional, Sequence
from typing import Tuple, Union
-from . import exceptions as exc
+from . import errors as e
from .pq import Format, PGresult
from .cursor import BaseCursor
from .types.oids import type_oid, INVALID_OID
if key in Adapter.globals:
return Adapter.globals[key]
- raise exc.ProgrammingError(
+ raise e.ProgrammingError(
f"cannot adapt type {cls} to format {Format(fmt).name}"
)
from typing import cast, TYPE_CHECKING
from . import pq
-from . import exceptions as exc
+from . import errors as e
from . import cursor
from .conninfo import make_conninfo
from .waiting import wait, wait_async, Wait, Ready
logger.debug("connection started, status %s", conn.status.name)
while 1:
if conn.status == pq.ConnStatus.BAD:
- raise exc.OperationalError(
+ raise e.OperationalError(
f"connection is bad: {pq.error_message(conn)}"
)
elif status == pq.PollingStatus.WRITING:
yield conn.socket, Wait.W
elif status == pq.PollingStatus.FAILED:
- raise exc.OperationalError(
+ raise e.OperationalError(
f"connection failed: {pq.error_message(conn)}"
)
else:
- raise exc.InternalError(f"unexpected poll status: {status}")
+ raise e.InternalError(f"unexpected poll status: {status}")
conn.nonblocking = 1
return conn
self.pgconn.send_query(command)
(pgres,) = self.wait(self._exec_gen(self.pgconn))
if pgres.status != pq.ExecStatus.COMMAND_OK:
- raise exc.OperationalError(
+ raise e.OperationalError(
f"error on {command.decode('utf8')}:"
f" {pq.error_message(pgres)}"
)
self.pgconn.send_query(command)
(pgres,) = await self.wait(self._exec_gen(self.pgconn))
if pgres.status != pq.ExecStatus.COMMAND_OK:
- raise exc.OperationalError(
+ raise e.OperationalError(
f"error on {command.decode('utf8')}:"
f" {pq.error_message(pgres)}"
)
from typing import Any, Dict, List
from . import pq
-from . import exceptions as exc
+from . import errors as e
def make_conninfo(conninfo: str = "", **kwargs: Any) -> str:
"""
try:
return pq.Conninfo.parse(conninfo.encode("utf8"))
- except pq.PQerror as e:
- raise exc.ProgrammingError(str(e))
+ except pq.PQerror as ex:
+ raise e.ProgrammingError(str(ex))
re_escape = re.compile(r"([\\'])")
from typing import Any, List, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING
-from . import exceptions as exc
+from . import errors as e
from .pq import error_message, DiagnosticField, ExecStatus, PGresult, Format
from .utils.queries import query2pg, reorder_params
from .utils.typing import Query, Params
def _execute_results(self, results: List[PGresult]) -> None:
# Implement part of execute() after waiting common to sync and async
if not results:
- raise exc.InternalError("got no result from the query")
+ raise e.InternalError("got no result from the query")
badstats = {res.status for res in results} - {
ExecStatus.TUPLES_OK,
return
if results[-1].status == ExecStatus.FATAL_ERROR:
- ecls = exc.class_for_state(
+ ecls = e.class_for_state(
results[-1].error_field(DiagnosticField.SQLSTATE)
)
raise ecls(error_message(results[-1]))
ExecStatus.COPY_OUT,
ExecStatus.COPY_BOTH,
}:
- raise exc.ProgrammingError(
+ raise e.ProgrammingError(
"COPY cannot be used with execute(); use copy() insead"
)
else:
- raise exc.InternalError(
+ raise e.InternalError(
f"got unexpected status from query:"
f" {', '.join(sorted(s.name for s in sorted(badstats)))}"
)
from ctypes import c_char, c_char_p, c_int, c_uint, c_void_p
from typing import List, Tuple
-from psycopg3.exceptions import NotSupportedError
+from psycopg3.errors import NotSupportedError
libname = ctypes.util.find_library("pq")
if libname is None:
)
from .misc import error_message, ConninfoOption
from . import _pq_ctypes as impl
-from ..exceptions import OperationalError
+from ..errors import OperationalError
from ..utils.typing import Oid
from typing import Any, Dict, List, Mapping, Match, NamedTuple, Optional
from typing import Sequence, Tuple, Union
-from .. import exceptions as exc
+from .. import errors as e
from ..pq import Format
from .typing import Params
if isinstance(vars, Sequence) and not isinstance(vars, (bytes, str)):
if len(vars) != len(parts) - 1:
- raise exc.ProgrammingError(
+ raise e.ProgrammingError(
f"the query has {len(parts) - 1} placeholders but"
f" {len(vars)} parameters were passed"
)
chunks.append(ph)
else:
if seen[part.item][1] != part.format:
- raise exc.ProgrammingError(
+ raise e.ProgrammingError(
f"placeholder '{part.item}' cannot have"
f" different formats"
)
continue
if ph == b"%(":
- raise exc.ProgrammingError(
+ raise e.ProgrammingError(
f"incomplete placeholder:"
f" '{query[m.span(0)[0]:].split()[0].decode(encoding)}'"
)
elif ph == b"% ":
# explicit messasge for a typical error
- raise exc.ProgrammingError(
+ raise e.ProgrammingError(
"incomplete placeholder: '%'; if you want to use '%' as an"
" operator you can double it up, i.e. use '%%'"
)
elif ph[-1:] not in b"bs":
- raise exc.ProgrammingError(
+ raise e.ProgrammingError(
f"only '%s' and '%b' placeholders allowed, got"
f" {m.group(0).decode(encoding)}"
)
phtype = type(item)
else:
if phtype is not type(item): # noqa
- raise exc.ProgrammingError(
+ raise e.ProgrammingError(
"positional and named placeholders cannot be mixed"
)
try:
return [params[item] for item in order]
except KeyError:
- raise exc.ProgrammingError(
+ raise e.ProgrammingError(
f"query parameter missing:"
f" {', '.join(sorted(i for i in order if i not in params))}"
)
from asyncio import get_event_loop, Event
from selectors import DefaultSelector, EVENT_READ, EVENT_WRITE
-from . import exceptions as exc
+from . import errors as e
class Wait(IntEnum):
assert len(ready) == 1
fd, s = gen.send(ready[0][1])
- except StopIteration as e:
- rv: RV = e.args[0]
+ except StopIteration as ex:
+ rv: RV = ex.args[0]
return rv
loop.remove_reader(fd)
loop.remove_writer(fd)
else:
- raise exc.InternalError("bad poll status: %s")
+ raise e.InternalError("bad poll status: %s")
fd, s = gen.send(ready)
- except StopIteration as e:
- rv: RV = e.args[0]
+ except StopIteration as ex:
+ rv: RV = ex.args[0]
return rv
projects / thirdparty / psycopg.git / commitdiff
