vastdb 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

vastdb/bench/perf_bench/query/query_vastdb.py

@@ -0,0 +1,78 @@
+# ruff: noqa: F841, PLW0603
+
+import datetime as dt
+import logging
+from typing import Any, Dict, Optional, Sequence
+
+import pyarrow as pa
+
+import vastdb.bench.perf_bench.common.log_utils
+from vastdb.bench.perf_bench.common import utils as bu
+from vastdb.bench.perf_bench.common.constants import VastConnDetails
+from vastdb.bench.perf_bench.dataset import secmaster as sm
+from vastdb.bench.perf_bench.dataset.schemas import BF
+from vastdb.table import QueryConfig
+
+LOG = vastdb.bench.perf_bench.common.log_utils.get_logger(__name__)
+
+
+# noinspection PyUnusedLocal,PyArgumentList
+def query_vastdb(
+    universe: Sequence[str],
+    columns: Optional[Sequence[str]] = None,
+    from_t: Optional[dt.datetime] = None,
+    to_t: Optional[dt.datetime] = None,
+    path: Optional[str] = None,
+    use_sid: bool = True,
+    logger: Optional[logging.Logger] = None,
+    backend_kwargs: Optional[Dict[str, Any]] = None,
+) -> pa.Table:
+    # ------------------------------------------------------------
+    #    Query via VastDB
+    # ------------------------------------------------------------
+    kwargs = backend_kwargs or {}
+    conn_details: Optional[VastConnDetails] = kwargs.pop("conn_details", None)
+    conn_details = conn_details or VastConnDetails()
+    ss = bu.get_vastdb_session(
+        access=conn_details.access,
+        secret=conn_details.secret,
+        vastdb_endpoint=conn_details.vastdb_endpoint,
+        ssl_verify=conn_details.vastdb_ssl_verify,
+    )
+    with ss.transaction() as tx:
+        b = tx.bucket(conn_details.vastdb_bucket)
+        s = b.schema(conn_details.vastdb_schema)
+        t = s.table(conn_details.vastdb_table)
+
+        if use_sid:
+            fld = BF.sid.value
+            sid_uni = sorted(sm.to_sid(s) for s in universe)
+            filters = t[fld].isin(sid_uni)
+        else:
+            fld = BF.ticker.value
+            filters = t[fld].isin(sorted(universe))
+
+        if from_t and to_t:
+            # noinspection PyTypedDict
+            filters = filters & (t["ts"] >= from_t) & (t["ts"] < to_t)
+        elif from_t:
+            filters = filters & (t["ts"] >= from_t)
+        elif to_t:
+            filters.append(t["ts"] < to_t)
+
+        # Cleanup the kwargs to be passed to the arrow scanner
+        kwargs.pop("arrow_kwargs", None)
+        if kwargs.pop("filter", None):
+            raise ValueError("Can't use filter with VastDB query")
+
+        # Perform the query
+        # noinspection PyTypeChecker
+        config = QueryConfig(**kwargs)
+        endpoint = conn_details.vastdb_endpoint
+        config.num_splits = 32
+        config.num_sub_splits = 8
+        config.data_endpoints = [endpoint] * config.num_splits
+        table = pa.Table.from_batches(
+            batches=t.select(predicate=filters, columns=columns, config=config)
+        )
+    return table

vastdb/bench/perf_bench/run.py

@@ -0,0 +1,79 @@
+# ruff: noqa: PLW2901, C901
+
+import datetime as dt
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional, Sequence
+
+import pandas as pd
+
+from vastdb.bench.perf_bench.common.constants import (
+    DEFAULT_RESULTS_DIR,
+)
+from vastdb.bench.perf_bench.common.log_utils import get_logger
+from vastdb.bench.perf_bench.common.types import PathLikeT
+from vastdb.bench.perf_bench.orchestrate import results_helpers as bc
+from vastdb.bench.perf_bench.orchestrate.bench_spec import BenchResult
+from vastdb.bench.perf_bench.orchestrate.scenario import BenchScenario
+
+LOG = get_logger(__name__)
+
+
+@dataclass(frozen=True)
+class RunnableBenchSession:
+    bench_name: str
+    scenarios: Sequence[BenchScenario]
+    runs_per_bench: int
+    parallelism: int
+    results_base_dir: Optional[PathLikeT]
+
+
+def run_scenarios(
+    scenarios: Sequence[BenchScenario],
+    runs_per_bench: int = 3,
+    parallelism: int = 1,
+    results_base_dir: Optional[str] = None,
+):
+    results_path = (
+        Path(results_base_dir or DEFAULT_RESULTS_DIR)
+        / f"results_{dt.datetime.now().strftime('%Y%m%d_%H%M%S')}_par{parallelism}.csv"
+    )
+
+    if (runs_per_bench := int(runs_per_bench)) < 1:
+        raise ValueError(f"runs_per_bench must be >= 1: {runs_per_bench=}")
+    if (parallelism := int(parallelism)) < 1:
+        raise ValueError(f"parallelism must be >= 1: {parallelism=}")
+
+    LOG.info("Will run '%d' scenarios", len(scenarios))
+
+    # noinspection PyShadowingNames
+    def worker_init():
+        import numpy as np  # noqa: F401
+        import pandas as pd  # noqa: F401
+        import pyarrow as pa  # noqa: F401
+
+        from vastdb.bench.perf_bench.common.utils import get_logger
+
+        get_logger(__name__).info("Warmed up.")
+
+    results: List[BenchResult] = []
+    for i, scen in enumerate(scenarios):
+        LOG.info(f"Running scenario: {scen.key} [{i + 1} of {len(scenarios)}]")
+        scen.run(
+            n_runs=runs_per_bench,
+            discard_first_run=True,
+            parallelism=parallelism,
+            workers_init=worker_init,
+        )
+        results.extend(scen.results or ())
+        bc.save_results(results, results_path=results_path)
+
+    # Save the results from all workers and print stats
+    bc.save_results(results, results_path=results_path)
+    results_stats_df = bc.calculate_aggregate_stats(results=results)
+    LOG.info(f"\n{results_stats_df.to_string()}")
+
+    # Verify the results written
+    results_df = bc.results_to_df(results)
+    results_df2 = pd.read_csv(results_path).astype(results_df.dtypes)
+    pd.testing.assert_frame_equal(results_df, results_df2)

vastdb/bench/test_sample.py

@@ -109,7 +109,7 @@ def load_batch(bucket, session_kwargs, offset, limit):
 
 def test_ingest(test_bucket_name, session_kwargs, tabular_endpoint_urls, num_workers, perf_metrics_db):
     session = vastdb.connect(**session_kwargs)
-    metrics_table = metrics.Table(perf_metrics_db, "ingest")
+    metrics_table = metrics.Table(perf_metrics_db, "test_ingest")
 
     with session.transaction() as tx:
         b = tx.bucket(test_bucket_name)
@@ -201,9 +201,11 @@ def run_query(session_kwargs, i, bucket_name, endpoint_url):
                 nbytes=data, rows=rows, cols=len(cols),
                 pid=pid, tid=tid, sdk_version=sdk_version))
 
+    return metrics_rows
+
 
 def test_scan(test_bucket_name, session, num_workers, session_kwargs, tabular_endpoint_urls, perf_metrics_db):
-    metrics_table = metrics.Table(perf_metrics_db, "query")
+    metrics_table = metrics.Table(perf_metrics_db, "test_scan")
 
     log.info("starting %d workers, endpoints=%s", num_workers, tabular_endpoint_urls)
     with ProcessPoolExecutor(max_workers=num_workers) as executor:

vastdb/conftest.py

@@ -102,4 +102,4 @@ def table_name(request):
 
 @pytest.fixture(scope="function")
 def perf_metrics_db(crater_path):
-    return sqlite3.connect(f"{crater_path}/metrics.sqlite")
+    return sqlite3.connect(f"{crater_path}/metrics.sqlite" if crater_path else ":memory:")

vastdb/session.py

@@ -23,8 +23,6 @@ class Session:
                  timeout=None,
                  backoff_config: Optional["BackoffConfig"] = None):
         """Connect to a VAST Database endpoint, using specified credentials."""
-        import boto3
-
         from . import _internal, features
 
         if access is None:
@@ -42,10 +40,6 @@ class Session:
             timeout=timeout,
             backoff_config=backoff_config)
         self.features = features.Features(self.api.vast_version)
-        self.s3 = boto3.client('s3',
-            aws_access_key_id=access,
-            aws_secret_access_key=secret,
-            endpoint_url=endpoint)
 
     def __repr__(self):
         """Don't show the secret key."""

vastdb/table.py

@@ -227,22 +227,23 @@ class Table:
         stop_event = Event()
         num_files_in_batch = min(ceil(len(source_files) / len(endpoints)), max_batch_size)
 
-        def import_worker(q, session):
+        def import_worker(q, endpoint):
             try:
-                while not q.empty():
-                    if stop_event.is_set():
-                        log.debug("stop_event is set, exiting")
-                        break
-                    files_batch = {}
-                    try:
-                        for _ in range(num_files_in_batch):
-                            files_batch.update({q.get(block=False)})
-                    except queue.Empty:
-                        pass
-                    if files_batch:
-                        log.debug("Starting import batch of %s files", len(files_batch))
-                        session.import_data(
-                            self.bucket.name, self.schema.name, self.name, files_batch, txid=self.tx.txid)
+                with self.tx._rpc.api.with_endpoint(endpoint) as session:
+                    while not q.empty():
+                        if stop_event.is_set():
+                            log.debug("stop_event is set, exiting")
+                            break
+                        files_batch = {}
+                        try:
+                            for _ in range(num_files_in_batch):
+                                files_batch.update({q.get(block=False)})
+                        except queue.Empty:
+                            pass
+                        if files_batch:
+                            log.debug("Starting import batch of %s files", len(files_batch))
+                            session.import_data(
+                                self.bucket.name, self.schema.name, self.name, files_batch, txid=self.tx.txid)
             except (Exception, KeyboardInterrupt) as e:
                 stop_event.set()
                 log.error("Got exception inside import_worker. exception: %s", e)
@@ -253,8 +254,7 @@ class Table:
                 max_workers=config.import_concurrency, thread_name_prefix='import_thread') as pool:
             try:
                 for endpoint in endpoints:
-                    session = self.tx._rpc.api.with_endpoint(endpoint)
-                    futures.append(pool.submit(import_worker, files_queue, session))
+                    futures.append(pool.submit(import_worker, files_queue, endpoint))
 
                 log.debug("Waiting for import workers to finish")
                 for future in concurrent.futures.as_completed(futures):
@@ -351,23 +351,23 @@ class Table:
 
         def single_endpoint_worker(endpoint: str):
             try:
-                host_api = self.tx._rpc.api.with_endpoint(endpoint)
-                backoff_decorator = self.tx._rpc.api._backoff_decorator
-                while True:
-                    check_stop()
-                    try:
-                        split = splits_queue.get_nowait()
-                    except queue.Empty:
-                        log.debug("splits queue is empty")
-                        break
-
-                    split_state = SelectSplitState(query_data_request=query_data_request,
-                                                   table=self,
-                                                   split_id=split,
-                                                   config=config)
-
-                    process_with_retries = backoff_decorator(split_state.process_split)
-                    process_with_retries(host_api, record_batches_queue, check_stop)
+                with self.tx._rpc.api.with_endpoint(endpoint) as host_api:
+                    backoff_decorator = self.tx._rpc.api._backoff_decorator
+                    while True:
+                        check_stop()
+                        try:
+                            split = splits_queue.get_nowait()
+                        except queue.Empty:
+                            log.debug("splits queue is empty")
+                            break
+
+                        split_state = SelectSplitState(query_data_request=query_data_request,
+                                                       table=self,
+                                                       split_id=split,
+                                                       config=config)
+
+                        process_with_retries = backoff_decorator(split_state.process_split)
+                        process_with_retries(host_api, record_batches_queue, check_stop)
 
             except StoppedException:
                 log.debug("stop signal.", exc_info=True)
@@ -439,7 +439,7 @@ class Table:
             self.update(rows=column_record_batch, columns=columns_name_chunk)
         return row_ids
 
-    def insert(self, rows: pa.RecordBatch):
+    def insert(self, rows: Union[pa.RecordBatch, pa.Table]):
         """Insert a RecordBatch into this table."""
         if self._imports_table:
             raise errors.NotSupportedCommand(self.bucket.name, self.schema.name, self.name)

vastdb/tests/test_nested.py

@@ -100,3 +100,61 @@ def test_nested_unsupported_filter(session, clean_bucket_name):
 
         with pytest.raises(NotImplementedError):
             list(t.select(predicate=(t['s'].isnull())))
+
+
+def test_nested_subfields_predicate_pushdown(session, clean_bucket_name):
+    columns = pa.schema([
+        ('x', pa.int64()),
+        ('l', pa.list_(pa.int8())),
+        ('y', pa.int64()),
+        ('m', pa.map_(pa.utf8(), pa.float64())),
+        ('z', pa.int64()),
+        ('s', pa.struct([
+            ('x', pa.int16()),
+            ('y', pa.int32()),
+            ('q', pa.struct([
+                ('q1', pa.utf8()),
+                ('q2', pa.float32())
+            ]))
+        ])),
+        ('w', pa.int64()),
+    ])
+    expected = pa.table(schema=columns, data=[
+        [1, 2, 3, None],
+        [[1], [], [2, 3], None],
+        [1, 2, None, 3],
+        [None, {'a': 2.5}, {'b': 0.25, 'c': 0.025}, {}],
+        [1, None, 2, 3],
+        [
+            {'x': 1, 'y': None, 'q': {'q1': 'AAA', 'q2': 1.0}},
+            None,
+            {'x': 2, 'y': 3, 'q': {'q1': 'B', 'q2': 2.0}},
+            {'x': None, 'y': 4, 'q': {'q1': 'CC', 'q2': 2.0}}],
+        [None, 1, 2, 3],
+    ])
+
+    with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
+
+        assert t.select(predicate=(t['s']['x'] == 1)).read_all() == expected.take([0])
+        assert t.select(predicate=(t['s']['y'].isnull())).read_all() == expected.take([0, 1])
+        assert t.select(predicate=(t['s']['q']['q1'] == 'AAA')).read_all() == expected.take([0])
+        assert t.select(predicate=(t['s']['q']['q1'] < 'B')).read_all() == expected.take([0])
+        assert t.select(predicate=(t['s']['q']['q1'] <= 'B')).read_all() == expected.take([0, 2])
+        assert t.select(predicate=(t['s']['q']['q2'] == 1.0)).read_all() == expected.take([0])
+
+        assert t.select(predicate=(t['s']['q']['q1'].isnull())).read_all() == expected.take([1])
+        assert t.select(predicate=(t['s']['q']['q2'].isnull())).read_all() == expected.take([1])
+
+        assert t.select(predicate=(t['s']['x'] == 2)).read_all() == expected.take([2])
+        assert t.select(predicate=(t['s']['y'] == 3)).read_all() == expected.take([2])
+        assert t.select(predicate=(t['s']['q']['q1'] == 'B')).read_all() == expected.take([2])
+        assert t.select(predicate=(t['s']['q']['q2'] == 2.0)).read_all() == expected.take([2, 3])
+
+        assert t.select(predicate=(t['s']['x'].isnull())).read_all() == expected.take([1, 3])
+        assert t.select(predicate=(t['s']['y'] == 4)).read_all() == expected.take([3])
+        assert t.select(predicate=(t['s']['q']['q1'] == 'CC')).read_all() == expected.take([3])
+        assert t.select(predicate=(t['s']['q']['q1'] > 'B')).read_all() == expected.take([3])
+        assert t.select(predicate=(t['s']['q']['q1'] >= 'B')).read_all() == expected.take([2, 3])
+
+        assert t.select(predicate=(t['s']['x'] == 1) | (t['s']['x'] == 2)).read_all() == expected.take([0, 2])
+        assert t.select(predicate=(t['s']['x'].isnull()) & (t['s']['y'].isnull())).read_all() == expected.take([1])

vastdb/tests/test_tables.py

@@ -81,6 +81,19 @@ def test_insert_wide_row(session, clean_bucket_name):
         assert actual == expected
 
 
+def test_multi_batch_table(session, clean_bucket_name):
+    columns = pa.schema([pa.field('s', pa.utf8())])
+    expected = pa.Table.from_batches([
+        pa.record_batch(schema=columns, data=[['a']]),
+        pa.record_batch(schema=columns, data=[['b']]),
+        pa.record_batch(schema=columns, data=[['c']]),
+    ])
+
+    with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
+        actual = t.select().read_all()
+        assert actual == expected
+
+
 def test_insert_empty(session, clean_bucket_name):
     columns = pa.schema([('a', pa.int8()), ('b', pa.float32())])
     data = [[None] * 5, [None] * 5]

vastdb/transaction.py

@@ -10,8 +10,6 @@ import logging
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Iterable, Optional
 
-import botocore
-
 from . import bucket, errors, schema, session
 
 if TYPE_CHECKING:
@@ -64,12 +62,10 @@ class Transaction:
     def bucket(self, name: str) -> "Bucket":
         """Return a VAST Bucket, if exists."""
         try:
-            self._rpc.s3.head_bucket(Bucket=name)
-        except botocore.exceptions.ClientError as e:
-            log.warning("res: %s", e.response)
-            if e.response['Error']['Code'] == '404':
-                raise errors.MissingBucket(name) from e
-            raise
+            self._rpc.api.head_bucket(name)
+        except errors.NotFound as e:
+            raise errors.MissingBucket(name) from e
+
         return bucket.Bucket(name, self)
 
     def catalog_snapshots(self) -> Iterable["Bucket"]:

vastdb/util.py

@@ -114,6 +114,11 @@ def iter_serialized_slices(batch: Union[pa.RecordBatch, pa.Table], max_rows_per_
 
 def serialize_record_batch(batch: Union[pa.RecordBatch, pa.Table]):
     """Serialize a RecordBatch using Arrow IPC format."""
+    if isinstance(batch, pa.Table):
+        if len(batch.to_batches()) > 1:
+            # the server expects a single RecordBatch per request
+            batch = batch.combine_chunks()
+
     sink = pa.BufferOutputStream()
     with pa.ipc.new_stream(sink, batch.schema) as writer:
         writer.write(batch)

{vastdb-1.0.0.dist-info → vastdb-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vastdb
-Version: 1.0.0
+Version: 1.1.1
 Summary: VAST Data SDK
 Home-page: https://github.com/vast-data/vastdb_sdk
 Author: VAST DATA
@@ -19,13 +19,12 @@ Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aws-requests-auth
-Requires-Dist: boto3
 Requires-Dist: flatbuffers
-Requires-Dist: ibis-framework ==9.0.0
+Requires-Dist: ibis-framework==9.0.0
 Requires-Dist: pyarrow
 Requires-Dist: requests
 Requires-Dist: xmltodict
-Requires-Dist: backoff ==2.2.1
+Requires-Dist: backoff==2.2.1
 
 
 `vastdb` is a Python-based SDK designed for interacting

{vastdb-1.0.0.dist-info → vastdb-1.1.1.dist-info}/RECORD

@@ -149,36 +149,61 @@ vast_flatbuf/tabular/S3File.py,sha256=KC9c2oS5-JXwTTriUVFdjOvRG0B54Cq9kviSDZY3NI
 vast_flatbuf/tabular/VipRange.py,sha256=_BJd1RRZAcK76T9vlsHzXKYVsPVaz6WTEAqStMQCAUQ,2069
 vast_flatbuf/tabular/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vastdb/__init__.py,sha256=J1JjKiFkKC95BHowfh9kJfQFTjRce-QMsc6zF_FfxC0,432
-vastdb/_internal.py,sha256=jVQuXsqk7CDuzNsR4cmxBTYOYE09og9EUYPcJ0UA_7s,90096
+vastdb/_internal.py,sha256=KRFNlB25Ckj4nowVUneC5tBSYXpnIv-MDdw4Vn6KYnc,91255
 vastdb/bucket.py,sha256=5KuKhPjZOevznZqWHDVVocejvAy7dcwobPuV6BJCfPc,2544
 vastdb/config.py,sha256=1tMYtzKXerGcIUjH4tIGEvZNWvO4fviCEdcNCnELJZo,2269
-vastdb/conftest.py,sha256=ePzQiEQmlNGcM2T4GZevE4XuvcnFWfnTSzr8IVZpVKk,3438
+vastdb/conftest.py,sha256=X2kVveySPQYZlVBXUMoo7Oea5IsvmJzjdqq3fpH2kVw,3469
 vastdb/errors.py,sha256=2XR1ko7J5nkfiHSAgwuVAADw0SsyqxOwSeFaGgKZEXM,4186
 vastdb/features.py,sha256=DxV746LSkORwVSD6MP2hdXRfnyoLkJwtOwGmp1dnquo,1322
 vastdb/schema.py,sha256=X7IRrogXH7Z0kes-DsDh1bRqIhvjH6owlFigGBXy7XQ,5913
-vastdb/session.py,sha256=ZrQf8cecVIHIBUOPNg4ed8ZCnEEu0QW1OBxQgz_ia80,2241
-vastdb/table.py,sha256=7U4UbooR1DUSpnZo8t8hzAMP78hF7IVvZpqZRrDDAQw,30953
-vastdb/transaction.py,sha256=qu2rOlR7AS1ojMOzgWapQMpcorrutelZZLH1mLmTHxk,3186
-vastdb/util.py,sha256=4LTYBBR13na376AmDm5lQILJzLcfelIKdkNPy0IqI0o,5684
+vastdb/session.py,sha256=toMR0BXwTaECdWDKnIZky1F3MA1SmelRBiqCrqQ3GCM,2067
+vastdb/table.py,sha256=XLNAwlRjT9sE8nPzYoBC2ehdYpjbit0gLyG0ieNvVfs,31094
+vastdb/transaction.py,sha256=NlVkEowJ_pmtffjWBBDaKExYDKPekjSZyj_fK_bZPJE,3026
+vastdb/util.py,sha256=eunfTuqbCrqQEFZEO9T15N-Bu8Fqpw7Zlqp2TAGfYaY,5870
 vastdb/bench/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vastdb/bench/test_perf.py,sha256=gZIqfHva6lNFpD-9bHAe7M8COBjUyrPkHu3E7F8J2L0,1072
-vastdb/bench/test_sample.py,sha256=bFmw7BOCr5FoGn4TY9pQGd6_cVNK4uBeSRi33tTubyk,7847
+vastdb/bench/test_sample.py,sha256=LgF4syzij09sH3Noiv1EyCAJ9pvrUE5bxR4RJTVEYag,7881
+vastdb/bench/perf_bench/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vastdb/bench/perf_bench/cli.py,sha256=NtaPEBTDI6PWgEtwI1wVbwmUeA5bwGqAj_Z_2lDJ28I,5931
+vastdb/bench/perf_bench/run.py,sha256=2dKooybt7e8VqM7FzY1jrIu6wZYQuoAF9o7AHVh-WVQ,2632
+vastdb/bench/perf_bench/bench_repo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vastdb/bench/perf_bench/bench_repo/mega_combo.py,sha256=9d8quB3aO6WLNlcIGUL1vmNo3KqyJgEiXSnbQOCiK-U,2780
+vastdb/bench/perf_bench/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vastdb/bench/perf_bench/common/constants.py,sha256=HI6qQSrqkrqC3jjq3LcOKth6o0yXq1yIOEbp9Oqo1jA,2905
+vastdb/bench/perf_bench/common/log_utils.py,sha256=V0Y6n2kOGTPMK2zPZMMnYwEFvmgOzMZQzk0uu4r-O3o,2015
+vastdb/bench/perf_bench/common/types.py,sha256=tbrJ-gvFGcq-U2Ny89BVxM1ItGZtIxrubgYImXOHDuc,1085
+vastdb/bench/perf_bench/common/utils.py,sha256=c6NoPMVwIQqIg2uDd4LtJIW7Hlis9QvlfbIyJc9sGS4,6280
+vastdb/bench/perf_bench/dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vastdb/bench/perf_bench/dataset/generate_secmaster.py,sha256=zm0b6MIN_hQM7znb-GA0T7L316t8DPixeN7ptdNRLO8,2718
+vastdb/bench/perf_bench/dataset/generate_stocks_dataset.py,sha256=WiYTK31gcaygrzF6Fbldlf7dwod4tioG4XSTv0fSxmc,8486
+vastdb/bench/perf_bench/dataset/schemas.py,sha256=CvCAxCWHsWdI6jE9on2Mm6b0NTDhZXRIbfP61vMNVow,2575
+vastdb/bench/perf_bench/dataset/secmaster.py,sha256=Y3yt8B_RsFvGlhMWKvDqax31UV_ShxZM-7CJO4YmxL0,188169
+vastdb/bench/perf_bench/orchestrate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vastdb/bench/perf_bench/orchestrate/bench_spec.py,sha256=XMUVlKPyWuhkRkz_Z2-iKYxqDlMj0EKcA3N46MLIX2c,2469
+vastdb/bench/perf_bench/orchestrate/results_helpers.py,sha256=u-GeDjbdKZLhAfDdecg9xYe7mnbJ0q_xu3xJ8rrRWG0,4172
+vastdb/bench/perf_bench/orchestrate/scenario.py,sha256=DUsIWyVmoLyYbKqPcLpd4veNHVbJsmL9JE-RTdmmyiw,3482
+vastdb/bench/perf_bench/orchestrate/scenario_generator.py,sha256=Plnij1hHqwmMndYpG4EA6L-HNAMJUB-M6-KXm3KZtlk,5978
+vastdb/bench/perf_bench/query/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vastdb/bench/perf_bench/query/arrow_common.py,sha256=eTQx_-ChEJVhP3g3HdQIP4vjIQrogPNh9UZ8nl9P5ew,1821
+vastdb/bench/perf_bench/query/query.py,sha256=h98Ui6vUTw16LHMY0ufkLnyVO3QCR8f1cXUU8N6B2mE,1185
+vastdb/bench/perf_bench/query/query_pyarrow.py,sha256=Dj5YPUvb4dAj7RskHfJcPijJnM-rdYIAItEF2dp4jfo,2305
+vastdb/bench/perf_bench/query/query_vastdb.py,sha256=SZYem_EmsaynEftAa_VFobjSJZDAcli9BckyRS3SFvg,2810
 vastdb/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vastdb/tests/metrics.py,sha256=N6ELJUmZubhAMmUtDbisXr6TFhSDgVCTTU05gBVxHRA,1010
 vastdb/tests/test_duckdb.py,sha256=STw_1PwTQR8Naz6s0p6lQTV1ZTKKhe3LPBUbhqzTCu0,1880
 vastdb/tests/test_imports.py,sha256=xKub3-bisFjH0BsZM8COfiUWuMrtoOoQKprF6VQT9RI,5669
-vastdb/tests/test_nested.py,sha256=22NAxBTm7Aq-Vn6AIYbi5Cb1ET8W0XeLK3pp4D8BYWI,3448
+vastdb/tests/test_nested.py,sha256=LPU6uV3Ri23dBzAEMFQqRPbqapV5LfmiHSHkhILPIY0,6332
 vastdb/tests/test_projections.py,sha256=3y1kubwVrzO-xoR0hyps7zrjOJI8niCYspaFTN16Q9w,4540
 vastdb/tests/test_sanity.py,sha256=oiV2gb05aPyG5RMNUQZlyjNlg3T7Fig1_8OJzpAgcsk,3038
 vastdb/tests/test_schemas.py,sha256=l70YQMlx2UL1KRQhApriiG2ZM7GJF-IzWU31H3Yqn1U,3312
-vastdb/tests/test_tables.py,sha256=qWicD0BYuhrh1kRVqkHMJNsxcHxDcCprbEXuZJm1wm4,31529
+vastdb/tests/test_tables.py,sha256=3YYytrcPZiflFCM6yZPOBI3pz5iXKy0sQbmUDFRVmdA,32000
 vastdb/tests/test_util.py,sha256=Ok_sAEBJsRGF5Voa_v5eu3eAd52GWu8jMjjQbadwW-s,1260
 vastdb/tests/util.py,sha256=dpRJYbboDnlqL4qIdvScpp8--5fxRUBIcIYitrfcj9o,555
 vastdb/vast_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vastdb/vast_tests/test_ha.py,sha256=744P4G6VJ09RIkHhMQL4wlipCBJWQVMhyvUrSc4k1HQ,975
 vastdb/vast_tests/test_scale.py,sha256=EpjCJmVAQrNBxVnHGJ-KHCoxevhqOcyqYFPMIIY9s60,2714
-vastdb-1.0.0.dist-info/LICENSE,sha256=obffan7LYrq7hLHNrY7vHcn2pKUTBUYXMKu-VOAvDxU,11333
-vastdb-1.0.0.dist-info/METADATA,sha256=iEjwUBDXLAZ3RC64iEHRiQkz0afSR5PPnHGmsthuzRI,1363
-vastdb-1.0.0.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
-vastdb-1.0.0.dist-info/top_level.txt,sha256=Vsj2MKtlhPg0J4so64slQtnwjhgoPmJgcG-6YcVAwVc,20
-vastdb-1.0.0.dist-info/RECORD,,
+vastdb-1.1.1.dist-info/LICENSE,sha256=obffan7LYrq7hLHNrY7vHcn2pKUTBUYXMKu-VOAvDxU,11333
+vastdb-1.1.1.dist-info/METADATA,sha256=C6KtrB0iOL3E8noTM0UqjYvurcant8lSNjwukCXnXTE,1340
+vastdb-1.1.1.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+vastdb-1.1.1.dist-info/top_level.txt,sha256=Vsj2MKtlhPg0J4so64slQtnwjhgoPmJgcG-6YcVAwVc,20
+vastdb-1.1.1.dist-info/RECORD,,

{vastdb-1.0.0.dist-info → vastdb-1.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.3.0)
+Generator: setuptools (72.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any