altcodepro-polydb-python 2.5.12__py3-none-any.whl → 2.5.19__py3-none-any.whl

{altcodepro_polydb_python-2.5.12.dist-info → altcodepro_polydb_python-2.5.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.5.12
+Version: 2.5.19
 Summary: Production-ready multi-cloud database abstraction layer with connection pooling, retry logic, and thread safety
 Author: AltCodePro
 Project-URL: Homepage, https://github.com/altcodepro/polydb-python

{altcodepro_polydb_python-2.5.12.dist-info → altcodepro_polydb_python-2.5.19.dist-info}/RECORD

@@ -1,12 +1,12 @@
-altcodepro_polydb_python-2.5.12.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
-polydb/PolyDB.py,sha256=_6YaeX7-9G9fK6hj4I-JbsfdVIwAotx7E_4IJqdGcjQ,23536
-polydb/__init__.py,sha256=EAtfxsNp7-RDyYP3yEz8Rb9TL41ASloYJrQghAaSny0,1876
+altcodepro_polydb_python-2.5.19.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
+polydb/PolyDB.py,sha256=Lp0QtG7D89Z6P6nt9fVoT8rVHAy8xlE2kFRSS70r-mk,23672
+polydb/__init__.py,sha256=p9dAWJ3-JNCeHgb1WzkTMkuURFQy-RUNI4QeD9zBVf0,1876
 polydb/advanced_query.py,sha256=M9sKmdF2PsLZWSc-zKpXRcwaDumbYYTsibmL_IAjKP4,6931
 polydb/aio.py,sha256=0EQ6hXrf6N4If6pcht6L9B7qz0PU2yGahyGzEss2eQg,8340
 polydb/batch.py,sha256=ulvSdtVeofsOiVNVAQwrE9tXIIaP8fjiW1Sbpz3dcv0,4093
 polydb/cache.py,sha256=ArI0zRbuhAYd6kn4TPVMBHBptdRmuZyy05_hwIATUsQ,11784
 polydb/cloudDatabaseFactory.py,sha256=eJiNKycdaC9nO2BKWPjkig3GaNGkNjoJci6yVJC7A_c,25301
-polydb/databaseFactory.py,sha256=eE53-luKwMr-5J5Ezsh9gLjZkq1aYG7UiyLTU846MZ8,53058
+polydb/databaseFactory.py,sha256=8A6Nmx0TTBxyVxLBMTBPp-sxuO7SeUWF5eVlG0I8WCE,54546
 polydb/errors.py,sha256=AtXCLdzkHE2ncUaE1P0wH5HmIyW3NXx9KHL-fCejjA4,1832
 polydb/json_safe.py,sha256=jj3ZA6gImGwgTO0dCZVcckjeUHtewa2HP6OA1-u6VZ0,137
 polydb/models.py,sha256=Pq_63FXu1IiTxl-RshZ2vmoe-5m5k6qft-tXpHLn-70,12600
@@ -17,7 +17,7 @@ polydb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 polydb/query.py,sha256=17V-e70df9NaiaUYPN5_MQz7O0vRdBaCR4xlZU3F2YE,8511
 polydb/registry.py,sha256=RD_elvFXcmhTdCyZDm2f3ej0elxqhArnSJ2aO9k5VCU,2352
 polydb/retry.py,sha256=0rILN3-auuzomOXPveIAvgnhBbtXXGNKvxg6qcRgN4g,4926
-polydb/schema.py,sha256=7Nz1EHcl4FWpdfsTonoFpMrkb0HcWKOiBpW_TTpPlrE,6447
+polydb/schema.py,sha256=jDjUuOaz2DANddhMTSxMwZ1MB-EOVDgDrCHbxkp-iM4,7712
 polydb/security.py,sha256=IF8Oh6Y6YU9xSjz_pi6lotfJuhIUJgP7cCmpGc8bz6w,20158
 polydb/types.py,sha256=Z1R8z06-WYoh7cnn0oE_2N10v6hdx7VJD7TNL5ynWhA,2667
 polydb/utils.py,sha256=YS-BhBpQfQsOf-z_i1zw_kvMYwJ05Zn1S2Xt6K4_2ak,3171
@@ -27,7 +27,7 @@ polydb/adapters/AzureBlobStorageAdapter.py,sha256=ZTovSC_CVduGnIoIQUUeNxDQlf-IbF
 polydb/adapters/AzureFileStorageAdapter.py,sha256=VZNprqlBXCuWUgtqClNT-NrQmRf-XFYEiRA2BLbf-Sc,7046
 polydb/adapters/AzureKeyVaultAdapter.py,sha256=7Nizs9qGh6cytbZNgV78f-odOO4Z6sUlwm_HQYqt-pc,2339
 polydb/adapters/AzureQueueAdapter.py,sha256=1e2HiFvkH1BI_JKS9fgays2J41kOfH6pUPbZDe1wmWA,13658
-polydb/adapters/AzureTableStorageAdapter.py,sha256=Ff4xbpqJKMN6EdMcsR9WMMFkMaceXmzb32v-nIiqVRo,33340
+polydb/adapters/AzureTableStorageAdapter.py,sha256=u2DsUIMOjYnBX_2G4abaLCjRaVOCORQQnwC4e0XrJ0Q,35567
 polydb/adapters/BlockchainBlobAdapter.py,sha256=85H3PxiL9rGDtK-sTsW26jOuUQ_SGipLSPu3s-juZRA,3298
 polydb/adapters/BlockchainFileAdapter.py,sha256=lZbRyC18LghZcVh5QyIRP7tCftNF_Ep1FKG0KRkvMmk,8335
 polydb/adapters/BlockchainKVAdapter.py,sha256=pvpiPshDE5Z_IRcSBvBwgAXT--86lgEyIsEUeqcmoE8,5422
@@ -41,7 +41,7 @@ polydb/adapters/GCPSecretManagerAdapter.py,sha256=ZFL2FGh7uTaBfpUo-HKXZAxS9s-w0w
 polydb/adapters/GCPStorageAdapter.py,sha256=ce7vCOW46XbdjiupAgMgkgopy3IV7nM5YvIwEhLIKvQ,7133
 polydb/adapters/KafkaQueueAdapter.py,sha256=_FrcI6JLIoJHPOtSIL2q1uXHeao9ZkGMyUnT68p36HQ,14329
 polydb/adapters/MongoDBAdapter.py,sha256=Rs1L9gbGj2hHiJuz62Ms7uRK6sppHc1aIO4MNrtZ3Zo,11750
-polydb/adapters/PostgreSQLAdapter.py,sha256=NPmf-s4UMGUFtQsqlAufrGtWI0N1vDvBYNSGAFEnBW4,45040
+polydb/adapters/PostgreSQLAdapter.py,sha256=n73HfBIXCF8Em4bHPvRVvipOJKdt9qZuZWdzRNCxS3w,48166
 polydb/adapters/RabbitMQAdapter.py,sha256=rMeqWXQmnfRX_pakaZX6q1bHkZ8E1boQ_Pkj3byl4E4,19903
 polydb/adapters/S3Adapter.py,sha256=ZkMR91u1e4SnrXSUbV3siKFYdw0ykYHJfyP2cUJUVso,7564
 polydb/adapters/S3CompatibleAdapter.py,sha256=Qj9SUtCnOFNL9c05wNVjICxZacFCnee-Wn_-hh0lwwE,7006
@@ -57,7 +57,7 @@ polydb/audit/__init__.py,sha256=VANh47kW5V9gi7anUCZ7LklQ6ofaFRmBKrPVitRxdw0,245
 polydb/audit/context.py,sha256=jbw58vDoslY2mEcS0qUBlEhYg54EoMk4Xcfuq1L3FuY,1945
 polydb/audit/manager.py,sha256=DgBkDcZlf_EotUm-RlKA1CWAoVi3DIUlRCsN4wzsfgc,1237
 polydb/audit/models.py,sha256=XHT-te2XpmdywfakKm1cVH09yi3C9Fa4FaBTZaJ5vqY,7044
-polydb/base/NoSQLKVAdapter.py,sha256=eGI-AyO_9nKnNchKKA5s9gxJaYJHlPGmcxu6ROhsp0I,14814
+polydb/base/NoSQLKVAdapter.py,sha256=TJ9jyYiLA26WmxJjGuL5DbQ00ZN-RYTV-IznN7RwMw4,16927
 polydb/base/ObjectStorageAdapter.py,sha256=mr6UMGmAFOBKlJeoyubaUJ7x7BDZMlylqnuggIatEv0,2289
 polydb/base/QueueAdapter.py,sha256=PzTlEuc37TXEnYNdsrrmxzFworbieWBxljDXJ-qq4XQ,8206
 polydb/base/SecretsAdapter.py,sha256=RaWejh21oQji0TdEBa7P5JgD9y6N06M1aCBbLvzTQU0,990
@@ -68,7 +68,7 @@ polydb/observability/logging.py,sha256=FWYky-Mg1IhLpwuaKuLIsTROBZc9bI_-AO-y53nvE
 polydb/services/__init__.py,sha256=Zs3PZbHutgPdPjJatygvtYvKPZMBt1qKSqESbFRPHJs,241
 polydb/services/compliance_service.py,sha256=UMjCbQ4z13-w6pT4RLQpMi_u1zbShEpiz8kawA2WsSU,5075
 polydb/services/security_service.py,sha256=gGo_j9Ca_rgvxS7s6C5JUktugQBj1PV1DXpMnOYAGbI,4992
-altcodepro_polydb_python-2.5.12.dist-info/METADATA,sha256=YOVEJeI2-82-3kaLNgwPT4E3cT20C10GkPV1B9_0HdU,15599
-altcodepro_polydb_python-2.5.12.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-altcodepro_polydb_python-2.5.12.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
-altcodepro_polydb_python-2.5.12.dist-info/RECORD,,
+altcodepro_polydb_python-2.5.19.dist-info/METADATA,sha256=jxSgbkqTALqYYLf5XwA6qNZPY--DLXDSdsxCwbItZR8,15599
+altcodepro_polydb_python-2.5.19.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+altcodepro_polydb_python-2.5.19.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
+altcodepro_polydb_python-2.5.19.dist-info/RECORD,,

polydb/PolyDB.py

@@ -158,6 +158,8 @@ class PolyDB:
         cache_ttl: Optional[int] = None,
         include_deleted: bool = False,
         engine_override: Optional[EngineOverride] = None,
+        fields: Optional[List[str]] = None,
+        omit: Optional[List[str]] = None,
     ) -> List[JsonDict]:
         return self.db.read(
             model,
@@ -168,6 +170,8 @@ class PolyDB:
             cache_ttl=cache_ttl,
             include_deleted=include_deleted,
             engine_override=engine_override,
+            fields=fields,
+            omit=omit,
         )
 
     def read_one(

polydb/__init__.py

@@ -4,7 +4,7 @@ PolyDB - Enterprise Cloud-Independent Database Abstraction
 Full LINQ support, field-level audit, cache, soft delete, overflow storage
 """
 
-__version__ = "2.5.12"
+__version__ = "2.5.18"
 
 from .aio import AsyncDatabaseFactory, AsyncPolyDB
 from .audit.context import AuditContext

polydb/adapters/AzureTableStorageAdapter.py

@@ -125,6 +125,19 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
         s = re.sub(r"[\\/#\?\x00-\x1f\x7f:+ ]", "_", s)
         return s[:1024] if len(s) > 1024 else s
 
+    def _check_overflow(self, data: JsonDict):  # type: ignore[override]
+        """Azure overflows per PROPERTY inside `_put_raw`, never per record.
+
+        The base class' whole-record overflow replaces the record with a stub
+        of underscore keys (`_overflow`, `_blob_key`, ...), but `_put_raw`
+        drops every key starting with "_" when it builds the entity -- so the
+        stub's pointer was never stored and the real fields of the write were
+        silently lost (only an orphaned blob remained). Returning the data
+        untouched lets `_put_raw` spill each >30KB property on its own, which
+        `_get_raw`/`_query_raw` already rehydrate.
+        """
+        return data, None
+
     def _sanitize_prop_name(self, name: Any) -> str:
         s = str(name)
         s = re.sub(r"[^A-Za-z0-9_]", "_", s)
@@ -620,9 +633,35 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
                 return None
             raise NoSQLError(f"Azure Table get failed: {str(e)}")
 
+    # `fields` / `omit` are sent to Azure as `$select`, so unrequested properties never leave the service.
+    SUPPORTS_SELECT_PUSHDOWN = True
+
+    def _select_properties(self, select: Optional[List[str]]) -> Optional[List[str]]:
+        """The Azure property names to `$select` for the requested field names -- the requested ones, plus what `_unpack_entity`
+        needs to rebuild a row (the keys, the model tag, and the sanitized-name map). A per-property blob overflow is stored in
+        the property itself, so selecting the property is enough for `_restore_overflow_properties`. None = no pushdown: if any
+        requested name is rewritten by `_sanitize_prop_name` (so its stored name could carry a collision suffix), the whole row is
+        fetched and trimmed afterwards instead of risking a silently missing column."""
+        if not select:
+            return None
+        props: List[str] = []
+        for name in select:
+            safe = self._sanitize_prop_name(name)
+            if safe != str(name):
+                return None
+            props.append(safe)
+        for needed in ("PartitionKey", "RowKey", _MODEL_FIELD, "__keymap__"):
+            if needed not in props:
+                props.append(needed)
+        return props
+
     @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
     def _query_raw(
-        self, model: type, filters: Dict[str, Any], limit: Optional[int]
+        self,
+        model: type,
+        filters: Dict[str, Any],
+        limit: Optional[int],
+        select: Optional[List[str]] = None,
     ) -> List[JsonDict]:
         try:
             table_client = self._get_table_client(model)
@@ -672,7 +711,11 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
             else:
                 query_filter = " and ".join(parts)
 
-            entities = table_client.query_entities(query_filter=query_filter)
+            props = self._select_properties(select)
+            if props is None:
+                entities = table_client.query_entities(query_filter=query_filter)
+            else:
+                entities = table_client.query_entities(query_filter=query_filter, select=props)
 
             results: List[JsonDict] = []
             count = 0

polydb/adapters/PostgreSQLAdapter.py

@@ -365,6 +365,50 @@ class PostgreSQLAdapter:
         return [self._serialize_param(p) for p in params]
 
     def _deserialize_row(self, row: JsonDict) -> JsonDict:
+        """Best-effort convenience decode: any string column value that
+        LOOKS like JSON (starts/ends with `{}`/`[]`) is `json.loads`'d,
+        regardless of the column's own declared type. This is a real,
+        deliberate, LOAD-BEARING convenience a real caller depends on --
+        e.g. universal-interprter's `observability.py`'s `Observability.
+        query()` writes a `logs.emit` payload as `json.dumps(...)` into a
+        plain TEXT column (`payload`, never JSONB -- see that module's
+        own comment) and its own docstring explicitly promises "logs.
+        query's own `payload` field gets a real dict back"; removing this
+        heuristic (briefly tried, then reverted -- see this repo's own
+        2.5.16/2.5.17 CLAUDE.md history) silently broke that real,
+        already-shipped contract. `query_log.py`'s own `fields` column is
+        the identical shape, just defended a second way: it independently
+        `json.loads`'s its own value with an `isinstance(..., str)` guard
+        rather than relying on this method at all -- proof this repo has
+        real callers on both sides (some lean on this adapter-level
+        decode, some defend for themselves).
+
+        **The real, honest trade-off, unavoidable at this layer**: a
+        genuinely non-JSON TEXT/VARCHAR string whose own real content
+        merely LOOKS JSON-shaped (e.g. a prompt template's own `content`
+        column holding a literal JSON-encoded email template -- see
+        universal-interprter's `prompt_template_store.py`) gets coerced
+        from `str` to `dict`/`list` here too, since this method has no
+        way to distinguish "real app data serialized as JSON text" from
+        "a legitimately JSON-shaped string that must stay a string" --
+        both are simply "a string that starts with `{` and ends with
+        `}`." This adapter deliberately does NOT try to solve that
+        ambiguity generically (declaring the column JSONB instead sidesteps
+        it entirely -- psycopg2 registers global JSON/JSONB typecasters
+        for OIDs 114/3802 automatically at import time, so a genuine
+        `json`/`jsonb` column never even reaches this heuristic, `isinstance
+        (v, str)` already `False` by the time this method sees it); a
+        caller that must keep a TEXT column's string content literal
+        despite it being JSON-shaped owns that coercion at ITS OWN layer
+        instead (see `prompt_template_store.py`'s own `_coerce_content_to_str`
+        for the concrete pattern: re-`json.dumps()` a `content` value that
+        came back non-`str`, restoring the real string every caller of
+        that store is promised). This adapter stays a "dumb storage
+        layer" in the sense that it never MODELS what a column's real
+        semantic type should be -- it does still apply this one generic,
+        best-effort convenience decode uniformly, exactly as it always
+        has.
+        """
         for k, v in list(row.items()):
             if isinstance(v, str):
                 s = v.strip()
@@ -443,8 +487,12 @@ class PostgreSQLAdapter:
         tx: Optional[Any] = None,
         *,
         session_vars: Optional[Dict[str, str]] = None,
+        fields: Optional[List[str]] = None,
     ) -> List[JsonDict]:
         table = validate_table_name(table)
+        if fields:
+            for f in fields:
+                validate_column_name(f)
         conn = tx
         own_conn = False
         if not conn:
@@ -454,7 +502,7 @@ class PostgreSQLAdapter:
         try:
             self._apply_session_vars(conn, session_vars)
             cursor = conn.cursor()
-            sql = f"SELECT * FROM {table}"
+            sql = f"SELECT {', '.join(fields)} FROM {table}" if fields else f"SELECT * FROM {table}"
             params: List[Any] = []
 
             if query:

polydb/base/NoSQLKVAdapter.py

@@ -17,9 +17,43 @@ if TYPE_CHECKING:
     from ..models import PartitionConfig
 
 
+def project_rows(
+    rows: List[JsonDict], fields: Optional[List[str]] = None, omit: Optional[List[str]] = None
+) -> List[JsonDict]:
+    """The exact `fields` / `omit` semantics every NoSQL read shares: `fields` keeps only those keys, `omit` drops those keys
+    (`fields` wins if both are given). Applied by the base `query()` AFTER overflow rehydration, so it is correct for every
+    adapter whether or not it also pushes the projection down to the store."""
+    if fields:
+        keep = set(fields)
+        return [{k: v for k, v in r.items() if k in keep} for r in rows]
+    if omit:
+        drop = set(omit)
+        return [{k: v for k, v in r.items() if k not in drop} for r in rows]
+    return rows
+
+
+def select_columns(
+    fields: Optional[List[str]], omit: Optional[List[str]], columns: Optional[List[str]]
+) -> Optional[List[str]]:
+    """The column list a store can be asked for: `fields` as given, or -- for `omit` -- the model's known `columns` minus the
+    omitted ones. None means "no column list can be derived" (no projection, or `omit` on a model whose columns are unknown):
+    the read then fetches whole rows and `project_rows` trims them."""
+    if fields:
+        return list(fields)
+    if omit and columns:
+        drop = set(omit)
+        return [c for c in columns if c not in drop]
+    return None
+
+
 class NoSQLKVAdapter:
     """Base with auto-overflow and LINQ support"""
 
+    # An adapter sets this True when its `_query_raw` accepts `select=[property names]` and really sends it to the store (Azure
+    # Table's `$select`). False (the default) means `fields`/`omit` are applied after the rows come back -- same result, no
+    # network saving. Opt in per adapter only once the adapter's own rehydration is proven to survive a narrowed row.
+    SUPPORTS_SELECT_PUSHDOWN = False
+
     def __init__(
         self,
         partition_config: Optional[PartitionConfig] = None,
@@ -242,9 +276,15 @@ class NoSQLKVAdapter:
         limit: Optional[int] = None,
         no_cache: bool = False,
         cache_ttl: Optional[int] = None,
+        fields: Optional[List[str]] = None,
+        omit: Optional[List[str]] = None,
     ) -> List[JsonDict]:
-        results = self._query_raw(model, query or {}, limit)
-        return [self._retrieve_overflow(r) for r in results]
+        select = select_columns(fields, omit, getattr(model, "__polydb__", {}).get("columns"))
+        if select is not None and self.SUPPORTS_SELECT_PUSHDOWN:
+            results = self._query_raw(model, query or {}, limit, select=select)
+        else:
+            results = self._query_raw(model, query or {}, limit)
+        return project_rows([self._retrieve_overflow(r) for r in results], fields, omit)
 
     def query_page(
         self, model: type, query: Lookup, page_size: int, continuation_token: Optional[str] = None

polydb/databaseFactory.py

@@ -24,7 +24,7 @@ from tenacity import retry, stop_after_attempt, wait_exponential
 from .adapters.PostgreSQLAdapter import PostgreSQLAdapter
 from .audit.context import AuditContext
 from .audit.manager import AuditManager
-from .base.NoSQLKVAdapter import NoSQLKVAdapter
+from .base.NoSQLKVAdapter import NoSQLKVAdapter, project_rows, select_columns
 from .batch import BatchOperations
 from .cache import CacheWarmer, RedisCacheEngine
 from .cloudDatabaseFactory import CloudDatabaseFactory
@@ -453,30 +453,53 @@ class DatabaseFactory:
         include_deleted: bool = False,
         engine_override: Optional[EngineOverride] = None,
         session_vars: Optional[Dict[str, str]] = None,
+        fields: Optional[List[str]] = None,
+        omit: Optional[List[str]] = None,
     ) -> List[JsonDict]:
+        """`fields` returns only those keys; `omit` returns every key except those (`fields` wins if both are given). SQL
+        names the columns in the SELECT; NoSQL adapters that can ($select on Azure Table) send the property list to the store,
+        the rest trim the rows after the read -- same result either way. `omit` needs the model's `__polydb__["columns"]` to
+        be turned into a column list for the store; without it the whole row is fetched and trimmed. A projected read never
+        goes through the external cache (its key does not include the projection)."""
         name = _model_name(model)
         meta = _extract_meta(model)
+        columns = (getattr(model, "__polydb__", None) or {}).get("columns") if isinstance(model, type) else None
+        projected = bool(fields or omit)
+        sql_columns = select_columns(fields, omit, columns)
 
         if self._soft_delete and not include_deleted:
             query = self._apply_soft_delete_filter(query)
 
         adapters = self._adapters_for(model, meta, engine_override)
-        use_external_cache = self._enable_cache and self._cache and getattr(meta, "cache", False)
+        use_external_cache = (
+            self._enable_cache and self._cache and getattr(meta, "cache", False) and not projected
+        )
         encrypted_fields = getattr(meta, "encrypted_fields", [])
 
         def _op() -> List[JsonDict]:
             if self._is_sql(meta, engine_override):
-                raw = adapters.sql.select(
-                    meta.table, query, limit=limit, offset=offset, session_vars=session_vars
-                )
+                if sql_columns is not None:
+                    raw = adapters.sql.select(
+                        meta.table, query, limit=limit, offset=offset,
+                        session_vars=session_vars, fields=sql_columns,
+                    )
+                else:
+                    raw = adapters.sql.select(
+                        meta.table, query, limit=limit, offset=offset, session_vars=session_vars
+                    )
+                    raw = project_rows(raw, fields, omit)
             else:
                 cls = (
                     model
                     if isinstance(model, type)
                     else type(name, (), {"__polydb__": meta.__dict__})
                 )
+                nosql_kwargs: Dict[str, Any] = {}
+                if projected:
+                    nosql_kwargs = {"fields": fields, "omit": omit}
                 raw = adapters.nosql.query(
-                    cls, query=query, limit=limit, no_cache=no_cache or bool(use_external_cache)
+                    cls, query=query, limit=limit, no_cache=no_cache or bool(use_external_cache),
+                    **nosql_kwargs,
                 )
             if self.encryption and encrypted_fields:
                 raw = [self.encryption.decrypt_fields(r, encrypted_fields) for r in raw]

polydb/schema.py

@@ -61,6 +61,17 @@ class Index:
     name: str
     columns: List[str]
     unique: bool = False
+    # Postgres index access method -- "btree" (the default, and the only
+    # one Postgres actually permits combined with UNIQUE) plus the real
+    # non-default methods a caller may need for a specific column shape:
+    # "gin"/"gist" (full-text search, JSONB containment, array overlap),
+    # "hash" (equality-only, smaller than btree for that one case), "brin"
+    # (large, naturally-ordered, append-mostly columns -- cheap to
+    # maintain relative to btree at real scale). Never validated against
+    # Postgres's own real per-type support here -- that's a live DDL
+    # concern the caller's own database will enforce; this dataclass only
+    # carries the caller's choice through to the generated statement.
+    using: str = "btree"
 
 
 class SchemaBuilder:
@@ -128,10 +139,17 @@ class SchemaBuilder:
 
         for idx in self.indexes:
             unique = "UNIQUE " if idx.unique else ""
+            # "btree" omitted outright rather than spelled out as
+            # "USING btree" -- it's Postgres's own implicit default, and
+            # every index this codebase generated before `using` existed
+            # rendered without a USING clause at all; emitting it only for
+            # a non-default method keeps every pre-existing caller's own
+            # generated SQL text byte-for-byte unchanged.
+            using = f"USING {idx.using} " if idx.using != "btree" else ""
             cols = ", ".join(validate_column_name(c) for c in idx.columns)
             sql = (
                 f"CREATE {unique}INDEX IF NOT EXISTS {validate_table_name(idx.name)} "
-                f"ON {table_name}({cols});"
+                f"ON {table_name}{' ' if using else ''}{using}({cols});"
             )
             statements.append(sql)