]> git.ipfire.org Git - thirdparty/psycopg.git/commitdiff
Dropped Transform.dump_sequence(), Transform.types_sequence()
authorDaniele Varrazzo <daniele.varrazzo@gmail.com>
Thu, 6 Aug 2020 02:51:12 +0000 (03:51 +0100)
committerDaniele Varrazzo <daniele.varrazzo@gmail.com>
Sun, 23 Aug 2020 18:24:02 +0000 (19:24 +0100)
psycopg3/psycopg3/copy.py
psycopg3/psycopg3/proto.py
psycopg3/psycopg3/transform.py
psycopg3/psycopg3/utils/queries.py
psycopg3_c/psycopg3_c/_psycopg3.pyi
psycopg3_c/psycopg3_c/transform.pyx

index 1849f16c0369673263344395654c0eaf45ad70c9..4a6ebaaafe8f8a410430a02224a4a1529038614f 100644 (file)
@@ -8,7 +8,7 @@ import re
 import codecs
 import struct
 from typing import TYPE_CHECKING, AsyncGenerator, Generator
-from typing import Any, Dict, Match, Optional, Sequence, Type, Union
+from typing import Any, Dict, List, Match, Optional, Sequence, Type, Union
 from types import TracebackType
 
 from . import pq
@@ -87,12 +87,16 @@ class BaseCopy:
             raise TypeError(f"can't write {type(data).__name__}")
 
     def format_row(self, row: Sequence[Any]) -> bytes:
-        # TODO: cache this, or pass just a single format
-        formats = [self.format] * len(row)
-        out = self._transformer.dump_sequence(row, formats)
+        out: List[Optional[bytes]] = []
+        for item in row:
+            if item is not None:
+                dumper = self._transformer.get_dumper(item, self.format)
+                out.append(dumper.dump(item))
+            else:
+                out.append(None)
         return self._format_row(out)
 
-    def _format_row_text(self, row: Sequence[Optional[bytes]],) -> bytes:
+    def _format_row_text(self, row: Sequence[Optional[bytes]]) -> bytes:
         return (
             b"\t".join(
                 _bsrepl_re.sub(_bsrepl_sub, item)
index a8499e4eb4243d176ddd39fe8173fc1d42e6ef2e..d46eab0ee667a0bbb81ca71e2bf615f79e5486af 100644 (file)
@@ -5,7 +5,7 @@ Protocol objects representing different implementations of the same classes.
 # Copyright (C) 2020 The Psycopg Team
 
 import codecs
-from typing import Any, Callable, Dict, Generator, Iterable, List, Mapping
+from typing import Any, Callable, Dict, Generator, Mapping
 from typing import Optional, Sequence, Tuple, Type, TypeVar, Union
 from typing import TYPE_CHECKING
 from typing_extensions import Protocol
@@ -76,14 +76,6 @@ class Transformer(Protocol):
     def set_row_types(self, types: Sequence[Tuple[int, Format]]) -> None:
         ...
 
-    def dump_sequence(
-        self, objs: Iterable[Any], formats: Iterable[Format]
-    ) -> List[Optional[bytes]]:
-        ...
-
-    def types_sequence(self) -> List[int]:
-        ...
-
     def get_dumper(self, obj: Any, format: Format) -> "Dumper":
         ...
 
index 0095ab45c0fdd6a13f3772c8d5c6eca4333ee80e..e3f96dcae8af2e0c1465c379431d0f4c86ebc12c 100644 (file)
@@ -142,28 +142,6 @@ class Transformer:
         for oid, fmt in types:
             rc.append(self.get_load_function(oid, fmt))
 
-    # TODO: drop?
-    def dump_sequence(
-        self, objs: Iterable[Any], formats: Iterable[Format]
-    ) -> List[Optional[bytes]]:
-        out: List[Optional[bytes]] = []
-        oids = self._oids = []
-
-        for var, fmt in zip(objs, formats):
-            if var is not None:
-                dumper = self.get_dumper(var, fmt)
-                out.append(dumper.dump(var))
-                oids.append(dumper.oid)
-            else:
-                out.append(None)
-                oids.append(TEXT_OID)
-
-        return out
-
-    # TODO: drop?
-    def types_sequence(self) -> List[int]:
-        return self._oids
-
     def get_dumper(self, obj: Any, format: Format) -> "Dumper":
         key = (type(obj), format)
         try:
index ab70eb8e0868dfbb825ccf580237b0d5b4d749c6..6aa91a7a3fafaf5f0fa0a2a6a38fb5257ee6b7c9 100644 (file)
@@ -16,6 +16,8 @@ from ..proto import Query, Params
 if TYPE_CHECKING:
     from ..proto import Transformer
 
+TEXT_OID = 25  # TODO: builtins["text"].oid
+
 
 class QueryPart(NamedTuple):
     pre: bytes
@@ -69,9 +71,28 @@ class PostgresQuery:
             params = _validate_and_reorder_params(
                 self._parts, vars, self._order
             )
-            self.params = self._tx.dump_sequence(params, self.formats or ())
+            self.params = []
+            assert self.formats is not None
+
             if self.types is None:
-                self.types = self._tx.types_sequence()
+                self.types = []
+                for i in range(len(params)):
+                    param = params[i]
+                    if param is not None:
+                        dumper = self._tx.get_dumper(param, self.formats[i])
+                        self.params.append(dumper.dump(param))
+                        self.types.append(dumper.oid)
+                    else:
+                        self.params.append(None)
+                        self.types.append(TEXT_OID)
+            else:
+                for i in range(len(params)):
+                    param = params[i]
+                    if param is not None:
+                        dumper = self._tx.get_dumper(param, self.formats[i])
+                        self.params.append(dumper.dump(param))
+                    else:
+                        self.params.append(None)
         else:
             self.params = self.types = None
 
index 985f00109e4c2d30445800ef118572d1f4841283..50bf51bc5db2a472d0c3657908f01a90398564b1 100644 (file)
@@ -33,10 +33,6 @@ class Transformer:
     def set_row_types(
         self, types: Sequence[Tuple[int, pq.Format]]
     ) -> None: ...
-    def dump_sequence(
-        self, objs: Iterable[Any], formats: Iterable[pq.Format]
-    ) -> List[Optional[bytes]]: ...
-    def types_sequence(self) -> List[int]: ...
     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, ...]]: ...
index c1436547f48aaf8fd14cc7ca0d771c6a67e0faa4..d83eda46089794316f6809f9673557f4d1d34f17 100644 (file)
@@ -219,26 +219,6 @@ cdef class Transformer:
             loader.context = cloader.get_context(pyloader.__self__)
             loader.own_context = 1
 
-    def dump_sequence(
-        self, objs: Iterable[Any], formats: Iterable[Format]
-    ) -> List[Optional[bytes]]:
-        out: List[Optional[bytes]] = []
-        oids = self._oids = []
-
-        for var, fmt in zip(objs, formats):
-            if var is not None:
-                dumper = self.get_dumper(var, fmt)
-                out.append(dumper.dump(var))
-                oids.append(dumper.oid)
-            else:
-                out.append(None)
-                oids.append(TEXT_OID)
-
-        return out
-
-    def types_sequence(self) -> List[int]:
-        return self._oids
-
     def get_dumper(self, obj: Any, format: Format) -> "Dumper":
         key = (type(obj), format)
         try: