88import struct
99from collections import namedtuple
1010from typing import Any , Callable , cast , Dict , Iterator , List , Optional
11- from typing import Sequence , Tuple , Type
11+ from typing import NamedTuple , Sequence , Tuple , Type
1212
1313from .. import pq
1414from .. import abc
1515from .. import postgres
1616from ..adapt import Transformer , PyFormat , RecursiveDumper , Loader , Dumper
17+ from .._compat import cache
1718from .._struct import pack_len , unpack_len
1819from ..postgres import TEXT_OID
1920from .._typeinfo import CompositeInfo as CompositeInfo # exported here
@@ -69,8 +70,8 @@ def dump(self, obj: Tuple[Any, ...]) -> bytes:
6970class TupleBinaryDumper (Dumper ):
7071 format = pq .Format .BINARY
7172
72- # Subclasses must set an info
73- info : CompositeInfo
73+ # Subclasses must set this info
74+ _field_types : Tuple [ int , ...]
7475
7576 def __init__ (self , cls : type , context : Optional [abc .AdaptContext ] = None ):
7677 super ().__init__ (cls , context )
@@ -80,17 +81,17 @@ def __init__(self, cls: type, context: Optional[abc.AdaptContext] = None):
8081 # in case the composite contains another composite. Make sure to use
8182 # a separate Transformer instance instead.
8283 self ._tx = Transformer (context )
83- self ._tx .set_dumper_types (self .info . field_types , self .format )
84+ self ._tx .set_dumper_types (self ._field_types , self .format )
8485
85- nfields = len (self .info . field_types )
86+ nfields = len (self ._field_types )
8687 self ._formats = (PyFormat .from_pq (self .format ),) * nfields
8788
8889 def dump (self , obj : Tuple [Any , ...]) -> bytearray :
8990 out = bytearray (pack_len (len (obj )))
9091 adapted = self ._tx .dump_sequence (obj , self ._formats )
9192 for i in range (len (obj )):
9293 b = adapted [i ]
93- oid = self .info . field_types [i ]
94+ oid = self ._field_types [i ]
9495 if b is not None :
9596 out += _pack_oidlen (oid , len (b ))
9697 out += b
@@ -243,43 +244,27 @@ def register_composite(
243244 info .register (context )
244245
245246 if not factory :
246- factory = namedtuple ( # type: ignore
247- _as_python_identifier (info .name ),
248- [_as_python_identifier (n ) for n in info .field_names ],
249- )
247+ factory = _nt_from_info (info )
250248
251249 adapters = context .adapters if context else postgres .adapters
252250
253251 # generate and register a customized text loader
254- loader : Type [BaseCompositeLoader ] = type (
255- f"{ info .name .title ()} Loader" ,
256- (CompositeLoader ,),
257- {
258- "factory" : factory ,
259- "fields_types" : info .field_types ,
260- },
261- )
252+ loader : Type [BaseCompositeLoader ]
253+ loader = _make_loader (info .name , tuple (info .field_types ), factory )
262254 adapters .register_loader (info .oid , loader )
263255
264256 # generate and register a customized binary loader
265- loader = type (
266- f"{ info .name .title ()} BinaryLoader" ,
267- (CompositeBinaryLoader ,),
268- {"factory" : factory },
269- )
257+ loader = _make_binary_loader (info .name , factory )
270258 adapters .register_loader (info .oid , loader )
271259
272260 # If the factory is a type, create and register dumpers for it
273261 if isinstance (factory , type ):
274- dumper = type (
275- f"{ info .name .title ()} BinaryDumper" ,
276- (TupleBinaryDumper ,),
277- {"oid" : info .oid , "info" : info },
278- )
262+ dumper : Type [Dumper ]
263+ dumper = _make_binary_dumper (info .name , info .oid , tuple (info .field_types ))
279264 adapters .register_dumper (factory , dumper )
280265
281266 # Default to the text dumper because it is more flexible
282- dumper = type ( f" { info .name . title () } Dumper" , ( TupleDumper ,), { "oid" : info .oid } )
267+ dumper = _make_dumper ( info .name , info .oid )
283268 adapters .register_dumper (factory , dumper )
284269
285270 info .python_type = factory
@@ -290,3 +275,54 @@ def register_default_adapters(context: abc.AdaptContext) -> None:
290275 adapters .register_dumper (tuple , TupleDumper )
291276 adapters .register_loader ("record" , RecordLoader )
292277 adapters .register_loader ("record" , RecordBinaryLoader )
278+
279+
280+ def _nt_from_info (info : CompositeInfo ) -> Type [NamedTuple ]:
281+ name = _as_python_identifier (info .name )
282+ fields = tuple (_as_python_identifier (n ) for n in info .field_names )
283+ return _make_nt (name , fields )
284+
285+
286+ # Cache all dynamically-generated types to avoid leaks in case the types
287+ # cannot be GC'd.
288+
289+
290+ @cache
291+ def _make_nt (name : str , fields : Tuple [str , ...]) -> Type [NamedTuple ]:
292+ return namedtuple (name , fields ) # type: ignore[return-value]
293+
294+
295+ @cache
296+ def _make_loader (
297+ name : str , types : Tuple [int , ...], factory : Callable [..., Any ]
298+ ) -> Type [BaseCompositeLoader ]:
299+ return type (
300+ f"{ name .title ()} Loader" ,
301+ (CompositeLoader ,),
302+ {"factory" : factory , "fields_types" : list (types )},
303+ )
304+
305+
306+ @cache
307+ def _make_binary_loader (
308+ name : str , factory : Callable [..., Any ]
309+ ) -> Type [BaseCompositeLoader ]:
310+ return type (
311+ f"{ name .title ()} BinaryLoader" , (CompositeBinaryLoader ,), {"factory" : factory }
312+ )
313+
314+
315+ @cache
316+ def _make_dumper (name : str , oid : int ) -> Type [TupleDumper ]:
317+ return type (f"{ name .title ()} Dumper" , (TupleDumper ,), {"oid" : oid })
318+
319+
320+ @cache
321+ def _make_binary_dumper (
322+ name : str , oid : int , field_types : Tuple [int , ...]
323+ ) -> Type [TupleBinaryDumper ]:
324+ return type (
325+ f"{ name .title ()} BinaryDumper" ,
326+ (TupleBinaryDumper ,),
327+ {"oid" : oid , "_field_types" : field_types },
328+ )
0 commit comments