vastdb 0.1.5__tar.gz → 0.1.6__tar.gz

{vastdb-0.1.5 → vastdb-0.1.6}/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [0.1.6] (2024-05-23)
+[0.1.6]: https://github.com/vast-data/vastdb_sdk/compare/v0.1.5...v0.1.6
+
+### Added
+ - Allow listing and querying Catalog snapshots
+ - Support nested schemas
+ - Use automatic split estimation
+
+### Fixed
+ - Allow using specific semi-sorted projection (needs VAST 5.1+ release)
+ - Add a client-side check for too large requests
+
 ## [0.1.5] (2024-05-16)
 [0.1.5]: https://github.com/vast-data/vastdb_sdk/compare/v0.1.4...v0.1.5
 

{vastdb-0.1.5/vastdb.egg-info → vastdb-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vastdb
-Version: 0.1.5
+Version: 0.1.6
 Summary: VAST Data SDK
 Home-page: https://github.com/vast-data/vastdb_sdk
 Author: VAST DATA

{vastdb-0.1.5 → vastdb-0.1.6}/setup.py

@@ -29,7 +29,7 @@ setup(
     name='vastdb',
     python_requires='>=3.9.0',
     description='VAST Data SDK',
-    version='0.1.5' + suffix,
+    version='0.1.6' + suffix,
     url='https://github.com/vast-data/vastdb_sdk',
     author='VAST DATA',
     author_email='hello@vastdata.com',

{vastdb-0.1.5 → vastdb-0.1.6}/vastdb/bench/test_perf.py

@@ -1,7 +1,6 @@
 import logging
 import time
 
-import pyarrow as pa
 import pytest
 
 from vastdb import util
@@ -20,7 +19,7 @@ def test_bench(session, clean_bucket_name, parquets_path, crater_path):
         t = util.create_table_from_files(s, 't1', files, config=ImportConfig(import_concurrency=8))
         config = QueryConfig(num_splits=8, num_sub_splits=4)
         s = time.time()
-        pa_table = pa.Table.from_batches(t.select(columns=['sid'], predicate=t['sid'] == 10033007, config=config))
+        pa_table = t.select(columns=['sid'], predicate=t['sid'] == 10033007, config=config).read_all()
         e = time.time()
         log.info("'SELECT sid from TABLE WHERE sid = 10033007' returned in %s seconds.", e - s)
         if crater_path:

{vastdb-0.1.5 → vastdb-0.1.6}/vastdb/bucket.py

@@ -5,7 +5,7 @@ It is possible to list and access VAST snapshots generated over a bucket.
 """
 
 import logging
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, List, Optional
 
 from . import errors, schema, transaction
@@ -22,48 +22,23 @@ class Bucket:
 
     name: str
     tx: "transaction.Transaction"
+    _root_schema: "Schema" = field(init=False, compare=False, repr=False)
 
-    def create_schema(self, path: str, fail_if_exists=True) -> "Schema":
+    def __post_init__(self):
+        """Root schema is empty."""
+        self._root_schema = schema.Schema(name="", bucket=self)
+
+    def create_schema(self, name: str, fail_if_exists=True) -> "Schema":
         """Create a new schema (a container of tables) under this bucket."""
-        if current := self.schema(path, fail_if_missing=False):
-            if fail_if_exists:
-                raise errors.SchemaExists(self.name, path)
-            else:
-                return current
-        self.tx._rpc.api.create_schema(self.name, path, txid=self.tx.txid)
-        log.info("Created schema: %s", path)
-        return self.schema(path)  # type: ignore[return-value]
+        return self._root_schema.create_schema(name=name, fail_if_exists=fail_if_exists)
 
-    def schema(self, path: str, fail_if_missing=True) -> Optional["Schema"]:
+    def schema(self, name: str, fail_if_missing=True) -> Optional["Schema"]:
         """Get a specific schema (a container of tables) under this bucket."""
-        s = self.schemas(path)
-        log.debug("schema: %s", s)
-        if not s:
-            if fail_if_missing:
-                raise errors.MissingSchema(self.name, path)
-            else:
-                return None
-        assert len(s) == 1, f"Expected to receive only a single schema, but got: {len(s)}. ({s})"
-        log.debug("Found schema: %s", s[0].name)
-        return s[0]
+        return self._root_schema.schema(name=name, fail_if_missing=fail_if_missing)
 
-    def schemas(self, name: Optional[str] = None) -> List["Schema"]:
+    def schemas(self, batch_size=None):
         """List bucket's schemas."""
-        schemas = []
-        next_key = 0
-        exact_match = bool(name)
-        log.debug("list schemas param: schema=%s, exact_match=%s", name, exact_match)
-        while True:
-            _bucket_name, curr_schemas, next_key, is_truncated, _ = \
-                self.tx._rpc.api.list_schemas(bucket=self.name, next_key=next_key, txid=self.tx.txid,
-                                               name_prefix=name, exact_match=exact_match)
-            if not curr_schemas:
-                break
-            schemas.extend(curr_schemas)
-            if not is_truncated:
-                break
-
-        return [schema.Schema(name=name, bucket=self) for name, *_ in schemas]
+        return self._root_schema.schemas(batch_size=batch_size)
 
     def snapshot(self, name, fail_if_missing=True) -> Optional["Bucket"]:
         """Get snapshot by name (if exists)."""

{vastdb-0.1.5 → vastdb-0.1.6}/vastdb/conftest.py

@@ -30,14 +30,23 @@ def test_bucket_name(request):
     return request.config.getoption("--tabular-bucket-name")
 
 
+def iter_schemas(s):
+    """Recusively scan all schemas."""
+    children = s.schemas()
+    for c in children:
+        yield from iter_schemas(c)
+    yield s
+
+
 @pytest.fixture(scope="function")
 def clean_bucket_name(request, test_bucket_name, session):
     with session.transaction() as tx:
         b = tx.bucket(test_bucket_name)
-        for s in b.schemas():
-            for t in s.tables():
-                t.drop()
-            s.drop()
+        for top_schema in b.schemas():
+            for s in iter_schemas(top_schema):
+                for t in s.tables():
+                    t.drop()
+                s.drop()
     return test_bucket_name
 
 

{vastdb-0.1.5 → vastdb-0.1.6}/vastdb/errors.py

@@ -89,7 +89,11 @@ class InvalidArgument(Exception):
     pass
 
 
-class TooWideRow(InvalidArgument):
+class TooLargeRequest(InvalidArgument):
+    pass
+
+
+class TooWideRow(TooLargeRequest):
     pass
 
 

{vastdb-0.1.5 → vastdb-0.1.6}/vastdb/internal_commands.py

@@ -6,7 +6,6 @@ import struct
 import urllib.parse
 from collections import defaultdict, namedtuple
 from enum import Enum
-from ipaddress import IPv4Address, IPv6Address
 from typing import Any, Dict, Iterator, List, Optional, Union
 
 import flatbuffers
@@ -1031,25 +1030,7 @@ class VastdbApi:
         num_rows = stats.NumRows()
         size_in_bytes = stats.SizeInBytes()
         is_external_rowid_alloc = stats.IsExternalRowidAlloc()
-        endpoints = []
-        if stats.VipsLength() == 0:
-            endpoints.append(self.url)
-        else:
-            url = urllib3.util.parse_url(self.url)
-
-            ip_cls = IPv6Address if (stats.AddressType() == "ipv6") else IPv4Address
-            vips = [stats.Vips(i) for i in range(stats.VipsLength())]
-            ips = []
-            # extract the vips into list of IPs
-            for vip in vips:
-                start_ip = int(ip_cls(vip.StartAddress().decode()))
-                ips.extend(ip_cls(start_ip + i) for i in range(vip.AddressCount()))
-            # build a list of endpoint URLs, reusing schema and port (if specified when constructing the session).
-            # it is assumed that the client can access the returned IPs (e.g. if they are part of the VIP pool).
-            for ip in ips:
-                d = url._asdict()
-                d['host'] = str(ip)
-                endpoints.append(str(urllib3.util.Url(**d)))
+        endpoints = [self.url]  # we cannot replace the host by a VIP address in HTTPS-based URLs
         return TableStatsResult(num_rows, size_in_bytes, is_external_rowid_alloc, tuple(endpoints))
 
     def alter_table(self, bucket, schema, name, txid=0, client_tags=[], table_properties="",

{vastdb-0.1.5 → vastdb-0.1.6}/vastdb/schema.py

@@ -31,6 +31,51 @@ class Schema:
         """VAST transaction used for this schema."""
         return self.bucket.tx
 
+    def _subschema_full_name(self, name: str) -> str:
+        return f"{self.name}/{name}" if self.name else name
+
+    def create_schema(self, name: str, fail_if_exists=True) -> "Schema":
+        """Create a new schema (a container of tables) under this schema."""
+        if current := self.schema(name, fail_if_missing=False):
+            if fail_if_exists:
+                raise errors.SchemaExists(self.bucket.name, name)
+            else:
+                return current
+        full_name = self._subschema_full_name(name)
+        self.tx._rpc.api.create_schema(self.bucket.name, full_name, txid=self.tx.txid)
+        log.info("Created schema: %s", full_name)
+        return self.schema(name)  # type: ignore[return-value]
+
+    def schema(self, name: str, fail_if_missing=True) -> Optional["Schema"]:
+        """Get a specific schema (a container of tables) under this schema."""
+        _bucket_name, schemas, _next_key, _is_truncated, _ = \
+            self.tx._rpc.api.list_schemas(bucket=self.bucket.name, schema=self.name, next_key=0, txid=self.tx.txid,
+                                          name_prefix=name, exact_match=True, max_keys=1)
+        names = [name for name, *_ in schemas]
+        log.debug("Found schemas: %s", names)
+        if not names:
+            if fail_if_missing:
+                raise errors.MissingSchema(self.bucket.name, self._subschema_full_name(name))
+            else:
+                return None
+
+        assert len(names) == 1, f"Expected to receive only a single schema, but got {len(schemas)}: ({schemas})"
+        return schema.Schema(name=self._subschema_full_name(names[0]), bucket=self.bucket)
+
+    def schemas(self, batch_size=None) -> List["Schema"]:
+        """List child schemas."""
+        next_key = 0
+        if not batch_size:
+            batch_size = 1000
+        result: List["Schema"] = []
+        while True:
+            _bucket_name, curr_schemas, next_key, is_truncated, _ = \
+                self.tx._rpc.api.list_schemas(bucket=self.bucket.name, schema=self.name, next_key=next_key, max_keys=batch_size, txid=self.tx.txid)
+            result.extend(schema.Schema(name=self._subschema_full_name(name), bucket=self.bucket) for name, *_ in curr_schemas)
+            if not is_truncated:
+                break
+        return result
+
     def create_table(self, table_name: str, columns: pa.Schema, fail_if_exists=True) -> "Table":
         """Create a new table under this schema."""
         if current := self.table(table_name, fail_if_missing=False):

{vastdb-0.1.5 → vastdb-0.1.6}/vastdb/session.py

@@ -7,12 +7,15 @@ For more details see:
 - [Tabular identity policy with the proper permissions](https://support.vastdata.com/s/article/UUID-14322b60-d6a2-89ac-3df0-3dfbb6974182)
 """
 
+import logging
 import os
 
 import boto3
 
 from . import errors, internal_commands, transaction
 
+log = logging.getLogger()
+
 
 class Features:
     """VAST database features - check if server is already support a feature."""
@@ -21,15 +24,28 @@ class Features:
         """Save the server version."""
         self.vast_version = vast_version
 
-    def check_imports_table(self):
-        """Check if the feature that support imports table is supported."""
-        if self.vast_version < (5, 2):
-            raise errors.NotSupportedVersion("import_table requires 5.2+", self.vast_version)
+        self.check_imports_table = self._check(
+            "Imported objects' table feature requires 5.2+ VAST release",
+            vast_version >= (5, 2))
+
+        self.check_return_row_ids = self._check(
+            "Returning row IDs requires 5.1+ VAST release",
+            vast_version >= (5, 1))
+
+        self.check_enforce_semisorted_projection = self._check(
+            "Semi-sorted projection enforcement requires 5.1+ VAST release",
+            vast_version >= (5, 1))
+
+    def _check(self, msg, supported):
+        log.debug("%s (current version is %s): supported=%s", msg, self.vast_version, supported)
+        if not supported:
+            def fail():
+                raise errors.NotSupportedVersion(msg, self.vast_version)
+            return fail
 
-    def check_return_row_ids(self):
-        """Check if insert/update/delete can return the row_ids."""
-        if self.vast_version < (5, 1):
-            raise errors.NotSupportedVersion("return_row_ids requires 5.1+", self.vast_version)
+        def noop():
+            pass
+        return noop
 
 
 class Session:

{vastdb-0.1.5 → vastdb-0.1.6}/vastdb/table.py

@@ -54,7 +54,8 @@ class QueryConfig:
     num_sub_splits: int = 4
 
     # used to split the table into disjoint subsets of rows, to be processed concurrently using multiple RPCs
-    num_splits: int = 1
+    # will be estimated from the table's row count, if not explicitly set
+    num_splits: Optional[int] = None
 
     # each endpoint will be handled by a separate worker thread
     # a single endpoint can be specified more than once to benefit from multithreaded execution
@@ -64,12 +65,15 @@ class QueryConfig:
     limit_rows_per_sub_split: int = 128 * 1024
 
     # each fiber will read the following number of rowgroups coninuously before skipping
-    # in order to use semi-sorted projections this value must be 8
+    # in order to use semi-sorted projections this value must be 8 (this is the hard coded size of a row groups per row block).
     num_row_groups_per_sub_split: int = 8
 
     # can be disabled for benchmarking purposes
     use_semi_sorted_projections: bool = True
 
+    # enforce using a specific semi-sorted projection (if enabled above)
+    semi_sorted_projection_name: Optional[str] = None
+
     # used to estimate the number of splits, given the table rows' count
     rows_per_split: int = 4000000
 
@@ -117,7 +121,8 @@ class SelectSplitState:
                             limit_rows=self.config.limit_rows_per_sub_split,
                             sub_split_start_row_ids=self.subsplits_state.items(),
                             enable_sorted_projections=self.config.use_semi_sorted_projections,
-                            query_imports_table=self.table._imports_table)
+                            query_imports_table=self.table._imports_table,
+                            projection=self.config.semi_sorted_projection_name)
             pages_iter = internal_commands.parse_query_data_response(
                 conn=response.raw,
                 schema=self.query_data_request.response_schema,
@@ -313,11 +318,16 @@ class Table:
 
         # Take a snapshot of enpoints
         stats = self.get_stats()
+        log.debug("stats: %s", stats)
         endpoints = stats.endpoints if config.data_endpoints is None else config.data_endpoints
+        log.debug("endpoints: %s", endpoints)
+
+        if config.num_splits is None:
+            config.num_splits = max(1, stats.num_rows // config.rows_per_split)
+        log.debug("config: %s", config)
 
-        if stats.num_rows > config.rows_per_split and config.num_splits is None:
-            config.num_splits = stats.num_rows // config.rows_per_split
-        log.debug(f"num_rows={stats.num_rows} rows_per_splits={config.rows_per_split} num_splits={config.num_splits} ")
+        if config.semi_sorted_projection_name:
+            self.tx._rpc.features.check_enforce_semisorted_projection()
 
         if columns is None:
             columns = [f.name for f in self.arrow_schema]
@@ -342,6 +352,8 @@ class Table:
             schema=query_schema,
             predicate=predicate,
             field_names=columns)
+        if len(query_data_request.serialized) > util.MAX_QUERY_DATA_REQUEST_SIZE:
+            raise errors.TooLargeRequest(f"{len(query_data_request.serialized)} bytes")
 
         splits_queue: queue.Queue[int] = queue.Queue()
 

{vastdb-0.1.5 → vastdb-0.1.6}/vastdb/tests/test_imports.py

@@ -38,13 +38,13 @@ def test_parallel_imports(session, clean_bucket_name, s3):
             t.create_imports_table()
         log.info("Starting import of %d files", num_files)
         t.import_files(files)
-        arrow_table = pa.Table.from_batches(t.select(columns=['num']))
+        arrow_table = t.select(columns=['num']).read_all()
         assert arrow_table.num_rows == num_rows * num_files
-        arrow_table = pa.Table.from_batches(t.select(columns=['num'], predicate=t['num'] == 100))
+        arrow_table = t.select(columns=['num'], predicate=t['num'] == 100).read_all()
         assert arrow_table.num_rows == num_files
         import_table = t.imports_table()
         # checking all imports are on the imports table:
-        objects_name = pa.Table.from_batches(import_table.select(columns=["ObjectName"]))
+        objects_name = import_table.select(columns=["ObjectName"]).read_all()
         objects_name = objects_name.to_pydict()
         object_names = set(objects_name['ObjectName'])
         prefix = 'prq'

{vastdb-0.1.5 → vastdb-0.1.6}/vastdb/tests/test_nested.py

@@ -22,13 +22,13 @@ def test_nested_select(session, clean_bucket_name):
     ])
 
     with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
-        actual = pa.Table.from_batches(t.select())
+        actual = t.select().read_all()
         assert actual == expected
 
         names = [f.name for f in columns]
         for n in range(len(names) + 1):
             for cols in itertools.permutations(names, n):
-                actual = pa.Table.from_batches(t.select(columns=cols))
+                actual = t.select(columns=cols).read_all()
                 assert actual == expected.select(cols)
 
 
@@ -53,7 +53,7 @@ def test_nested_filter(session, clean_bucket_name):
     ])
 
     with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
-        actual = pa.Table.from_batches(t.select())
+        actual = t.select().read_all()
         assert actual == expected
 
         names = list('xyzw')
@@ -62,7 +62,7 @@ def test_nested_filter(session, clean_bucket_name):
                 ibis_predicate = functools.reduce(
                     operator.and_,
                     (t[col] > 2 for col in cols))
-                actual = pa.Table.from_batches(t.select(predicate=ibis_predicate), t.arrow_schema)
+                actual = t.select(predicate=ibis_predicate).read_all()
 
                 arrow_predicate = functools.reduce(
                     operator.and_,

vastdb-0.1.6/vastdb/tests/test_projections.py

@@ -0,0 +1,121 @@
+import logging
+import time
+
+import pyarrow as pa
+
+from vastdb.table import QueryConfig
+
+log = logging.getLogger(__name__)
+
+
+def test_basic_projections(session, clean_bucket_name):
+    with session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).create_schema('s1')
+        columns = pa.schema([
+            ('a', pa.int8()),
+            ('b', pa.int16()),
+            ('c', pa.string()),
+            ('d', pa.int16()),
+            ('e', pa.int64()),
+            ('s', pa.struct([('x', pa.int8()), ('y', pa.int16())]))
+        ])
+
+        assert s.tables() == []
+        t = s.create_table('t1', columns)
+        assert s.tables() == [t]
+
+        sorted_columns = ['a']
+        unsorted_columns = ['b']
+        p1 = t.create_projection('p1', sorted_columns, unsorted_columns)
+
+        sorted_columns = ['b']
+        unsorted_columns = ['c', 'd']
+        p2 = t.create_projection('p2', sorted_columns, unsorted_columns)
+
+        projs = t.projections()
+        assert projs == [t.projection('p1'), t.projection('p2')]
+        p1 = t.projection('p1')
+        assert p1.name == 'p1'
+        p2 = t.projection('p2')
+        assert p2.name == 'p2'
+
+        p1.rename('p_new')
+        p2.drop()
+        projs = t.projections()
+        assert len(projs) == 1
+        assert projs[0].name == 'p_new'
+
+
+def test_query_data_with_projection(session, clean_bucket_name):
+    columns = pa.schema([
+        ('a', pa.int64()),
+        ('b', pa.int64()),
+        ('s', pa.utf8()),
+    ])
+    # need to be large enough in order to consider as projection
+
+    GROUP_SIZE = 128 * 1024
+    expected = pa.table(schema=columns, data=[
+        [i for i in range(GROUP_SIZE)],
+        [i for i in reversed(range(GROUP_SIZE))],
+        [f's{i}' for i in range(GROUP_SIZE)],
+    ])
+
+    expected_projection_p1 = pa.table(schema=columns, data=[
+        [i for i in reversed(range(GROUP_SIZE - 5, GROUP_SIZE))],
+        [i for i in range(5)],
+        [f's{i}' for i in reversed(range(GROUP_SIZE - 5, GROUP_SIZE))],
+    ])
+
+    expected_projection_p2 = pa.table(schema=columns, data=[
+        [i for i in range(GROUP_SIZE - 5, GROUP_SIZE)],
+        [i for i in reversed(range(5))],
+        [f's{i}' for i in range(GROUP_SIZE - 5, GROUP_SIZE)],
+    ])
+
+    schema_name = "schema"
+    table_name = "table"
+    with session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).create_schema(schema_name)
+        t = s.create_table(table_name, expected.schema)
+
+        sorted_columns = ['b']
+        unsorted_columns = ['a', 's']
+        t.create_projection('p1', sorted_columns, unsorted_columns)
+
+        sorted_columns = ['a']
+        unsorted_columns = ['b', 's']
+        t.create_projection('p2', sorted_columns, unsorted_columns)
+
+    with session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).schema(schema_name)
+        t = s.table(table_name)
+        t.insert(expected)
+        actual = pa.Table.from_batches(t.select(columns=['a', 'b', 's']))
+        assert actual == expected
+
+    time.sleep(3)
+
+    with session.transaction() as tx:
+        config = QueryConfig()
+        # in nfs mock server num row groups per row block is 1 so need to change this in the config
+        config.num_row_groups_per_sub_split = 1
+
+        s = tx.bucket(clean_bucket_name).schema(schema_name)
+        t = s.table(table_name)
+        projection_actual = pa.Table.from_batches(t.select(columns=['a', 'b', 's'], predicate=(t['b'] < 5), config=config))
+        # no projection supply - need to be with p1 projeciton
+        assert expected_projection_p1 == projection_actual
+
+        config.semi_sorted_projection_name = 'p1'
+        projection_actual = pa.Table.from_batches(t.select(columns=['a', 'b', 's'], predicate=(t['b'] < 5), config=config))
+        # expecting results of projection p1 since we asked it specificaly
+        assert expected_projection_p1 == projection_actual
+
+        config.semi_sorted_projection_name = 'p2'
+        projection_actual = pa.Table.from_batches(t.select(columns=['a', 'b', 's'], predicate=(t['b'] < 5), config=config))
+        # expecting results of projection p2 since we asked it specificaly
+        assert expected_projection_p2 == projection_actual
+
+        t.drop()
+        s.drop()

{vastdb-0.1.5 → vastdb-0.1.6}/vastdb/tests/test_schemas.py

@@ -61,3 +61,52 @@ def test_list_snapshots(session, clean_bucket_name):
     with session.transaction() as tx:
         b = tx.bucket(clean_bucket_name)
         b.snapshots()  # VAST Catalog may create some snapshots
+
+
+def test_nested_schemas(session, clean_bucket_name):
+    with session.transaction() as tx:
+        b = tx.bucket(clean_bucket_name)
+        s1 = b.create_schema('s1')
+        s1_s2 = s1.create_schema('s2')
+        s1_s3 = s1.create_schema('s3')
+        s1_s3_s4 = s1_s3.create_schema('s4')
+        s5 = b.create_schema('s5')
+
+        assert b.schema('s1') == s1
+        assert s1.schema('s2') == s1_s2
+        assert s1.schema('s3') == s1_s3
+        assert s1_s3.schema('s4') == s1_s3_s4
+        assert b.schema('s5') == s5
+
+        assert b.schemas() == [s1, s5]
+        assert s1.schemas() == [s1_s2, s1_s3]
+        assert s1_s2.schemas() == []
+        assert s1_s3.schemas() == [s1_s3_s4]
+        assert s1_s3_s4.schemas() == []
+        assert s5.schemas() == []
+
+        s1_s3_s4.drop()
+        assert s1_s3.schemas() == []
+        s1_s3.drop()
+        assert s1.schemas() == [s1_s2]
+        s1_s2.drop()
+        assert s1.schemas() == []
+
+        assert b.schemas() == [s1, s5]
+        s1.drop()
+        assert b.schemas() == [s5]
+        s5.drop()
+        assert b.schemas() == []
+
+
+def test_schema_pagination(session, clean_bucket_name):
+    with session.transaction() as tx:
+        b = tx.bucket(clean_bucket_name)
+        names = [f's{i}' for i in range(10)]
+        schemas = [b.create_schema(name) for name in names]
+        assert b.schemas(batch_size=3) == schemas
+
+        s0 = b.schema('s0')
+        names = [f'q{i}' for i in range(10)]
+        subschemas = [s0.create_schema(name) for name in names]
+        assert s0.schemas(batch_size=3) == subschemas