) -> Tuple[Any, ...]:
...
- def get_load_function(self, oid: int, format: Format) -> LoadFunc:
+ def get_loader(self, oid: int, format: Format) -> "Loader":
...
def lookup_loader(self, oid: int, format: Format) -> LoaderType:
from .types.oids import builtins, INVALID_OID
if TYPE_CHECKING:
- from .adapt import Dumper
+ from .adapt import Dumper, Loader
Format = pq.Format
TEXT_OID = builtins["text"].oid
# mapping class, fmt -> Dumper instance
self._dumpers_cache: Dict[Tuple[type, Format], "Dumper"] = {}
+ # mapping oid, fmt -> Loader instance
+ self._loaders_cache: Dict[Tuple[int, Format], "Loader"] = {}
+
# mapping oid, fmt -> load function
self._load_funcs: Dict[Tuple[int, Format], LoadFunc] = {}
for i in range(nf):
oid = result.ftype(i)
fmt = result.fformat(i)
- rc.append(self.get_load_function(oid, fmt))
+ rc.append(self.get_loader(oid, fmt).load)
@property
def dumpers(self) -> DumpersMap:
def set_row_types(self, types: Iterable[Tuple[int, Format]]) -> None:
rc = self._row_loaders = []
for oid, fmt in types:
- rc.append(self.get_load_function(oid, fmt))
+ rc.append(self.get_loader(oid, fmt).load)
def get_dumper(self, obj: Any, format: Format) -> "Dumper":
key = (type(obj), format)
for i, val in enumerate(record)
)
- def get_load_function(self, oid: int, format: Format) -> LoadFunc:
+ def get_loader(self, oid: int, format: Format) -> "Loader":
key = (oid, format)
try:
- return self._load_funcs[key]
+ return self._loaders_cache[key]
except KeyError:
pass
- loader = self.lookup_loader(oid, format)
- func = self._load_funcs[key] = loader(oid, self).load
- return func
+ loader_cls = self.lookup_loader(*key)
+ self._loaders_cache[key] = loader = loader_cls(key[0], self)
+ return loader
def lookup_loader(self, oid: int, format: Format) -> LoaderType:
key = (oid, format)
def load(self, data: bytes) -> List[Any]:
rv = None
stack: List[Any] = []
- cast = self._tx.get_load_function(self.base_oid, Format.TEXT)
+ cast = self._tx.get_loader(self.base_oid, Format.TEXT).load
for m in self._re_parse.finditer(data):
t = m.group(1)
if not ndims:
return []
- fcast = self._tx.get_load_function(oid, Format.BINARY)
+ fcast = self._tx.get_loader(oid, Format.BINARY).load
p = 12 + 8 * ndims
dims = [
@Loader.text(builtins["record"].oid)
class RecordLoader(BaseCompositeLoader):
def load(self, data: bytes) -> Tuple[Any, ...]:
- cast = self._tx.get_load_function(TEXT_OID, format=Format.TEXT)
+ cast = self._tx.get_loader(TEXT_OID, format=Format.TEXT).load
return tuple(
cast(token) if token is not None else None
for token in self._parse_record(data)
import codecs
from typing import Any, Iterable, List, Optional, Sequence, Tuple
-from psycopg3.adapt import Dumper
+from psycopg3.adapt import Dumper, Loader
from psycopg3.proto import AdaptContext, DumpFunc, DumpersMap, DumperType
from psycopg3.proto import LoadFunc, LoadersMap, LoaderType, PQGen
from psycopg3.connection import BaseConnection
def set_row_types(
self, types: Sequence[Tuple[int, pq.Format]]
) -> None: ...
- def get_dumper(self, obj: Any, format: pq.Format) -> "Dumper": ...
+ def get_dumper(self, obj: Any, format: pq.Format) -> Dumper: ...
def lookup_dumper(self, src: type, format: pq.Format) -> DumperType: ...
def load_row(self, row: int) -> Optional[Tuple[Any, ...]]: ...
def load_sequence(
self, record: Sequence[Optional[bytes]]
) -> Tuple[Any, ...]: ...
- def get_load_function(self, oid: int, format: pq.Format) -> LoadFunc: ...
+ def get_loader(self, oid: int, format: pq.Format) -> Loader: ...
def lookup_loader(self, oid: int, format: pq.Format) -> LoaderType: ...
def register_builtin_c_loaders() -> None: ...
return tuple(rv)
- def get_load_function(self, oid: int, format: Format) -> "LoadFunc":
- key = (oid, format)
- try:
- return self._load_funcs[key]
- except KeyError:
- pass
-
- loader = self.lookup_loader(oid, format)
- func = self._load_funcs[key] = loader(oid, self).load
- return func
-
def get_loader(self, oid: int, format: Format) -> "Loader":
key = (oid, format)
try: