vastdb 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

vastdb/tests/test_tables.py

@@ -1,41 +1,24 @@
-import duckdb
-import pytest
-import threading
+import datetime as dt
+import decimal
+import logging
 import random
+import threading
+from contextlib import closing
+from tempfile import NamedTemporaryFile
+
 import pyarrow as pa
 import pyarrow.compute as pc
 import pyarrow.parquet as pq
-import decimal
-import datetime as dt
-
-from tempfile import NamedTemporaryFile
-from contextlib import contextmanager, closing
-
+import pytest
 from requests.exceptions import HTTPError
-import logging
 
-from ..table import INTERNAL_ROW_ID, QueryConfig
 from .. import errors
-
+from ..table import INTERNAL_ROW_ID, QueryConfig
+from .util import prepare_data
 
 log = logging.getLogger(__name__)
 
 
-@contextmanager
-def prepare_data(session, clean_bucket_name, schema_name, table_name, arrow_table):
-    with session.transaction() as tx:
-        s = tx.bucket(clean_bucket_name).create_schema(schema_name)
-        t = s.create_table(table_name, arrow_table.schema)
-        row_ids_array = t.insert(arrow_table)
-        row_ids = row_ids_array.to_pylist()
-        log.debug("row_ids=%s" % row_ids)
-        assert row_ids == list(range(arrow_table.num_rows))
-        yield t
-        t.drop()
-        s.drop()
-
-log = logging.getLogger(__name__)
-
 def test_tables(session, clean_bucket_name):
     columns = pa.schema([
         ('a', pa.int64()),
@@ -86,6 +69,27 @@ def test_tables(session, clean_bucket_name):
             's': ['ccc']
         }
 
+
+def test_exists(session, clean_bucket_name):
+    with session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).create_schema('s1')
+        assert s.tables() == []
+
+        t = s.create_table('t', pa.schema([('x', pa.int64())]))
+
+        assert s.tables() == [t]
+        with pytest.raises(errors.TableExists):
+            s.create_table('t', pa.schema([('x', pa.int64())]))
+
+        assert s.tables() == [t]
+        assert s.create_table('t', pa.schema([('x', pa.int64())]), fail_if_exists=False) == t
+        assert s.tables() == [t]
+        assert s.create_table('t', pa.schema([('y', pa.int64())]), fail_if_exists=False) == t
+        assert s.tables() == [t]
+        assert s.create_table('t', pa.schema([('x', pa.int64())]), fail_if_exists=False) == t
+        assert s.tables() == [t]
+
+
 def test_update_table(session, clean_bucket_name):
     columns = pa.schema([
         ('a', pa.int64()),
@@ -141,12 +145,13 @@ def test_update_table(session, clean_bucket_name):
             'b': [0.5, 1.5, 2.5]
         }
 
+
 def test_select_with_multisplits(session, clean_bucket_name):
     columns = pa.schema([
         ('a', pa.int32())
     ])
 
-    data = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     data = data * 1000
     expected = pa.table(schema=columns, data=[data])
 
@@ -169,21 +174,36 @@ def test_types(session, clean_bucket_name):
         ('d', pa.decimal128(7, 3)),
         ('bin', pa.binary()),
         ('date', pa.date32()),
-        ('ts' ,pa.timestamp('s')),
+        ('t0', pa.time32('s')),
+        ('t3', pa.time32('ms')),
+        ('t6', pa.time64('us')),
+        ('t9', pa.time64('ns')),
+        ('ts0', pa.timestamp('s')),
+        ('ts3', pa.timestamp('ms')),
+        ('ts6', pa.timestamp('us')),
+        ('ts9', pa.timestamp('ns')),
     ])
 
     expected = pa.table(schema=columns, data=[
         [True, True, False],
-        [1 , 2, 4],
+        [1, 2, 4],
         [1999, 2000, 2001],
         [11122221, 222111122, 333333],
         [0.5, 1.5, 2.5],
         ["a", "v", "s"],
         [decimal.Decimal('110.52'), decimal.Decimal('231.15'), decimal.Decimal('3332.44')],
         [b"\x01\x02", b"\x01\x05", b"\x01\x07"],
-        [dt.datetime.now().date(), dt.datetime.now().date(), dt.datetime.now().date()],
-        [dt.datetime.fromtimestamp(10000), dt.datetime.fromtimestamp(100), dt.datetime.fromtimestamp(0)]
+        [dt.date(2024, 4, 10), dt.date(2024, 4, 11), dt.date(2024, 4, 12)],
+        [dt.time(12, 34, 56), dt.time(12, 34, 57), dt.time(12, 34, 58)],
+        [dt.time(12, 34, 56, 789000), dt.time(12, 34, 57, 789000), dt.time(12, 34, 58, 789000)],
+        [dt.time(12, 34, 56, 789789), dt.time(12, 34, 57, 789789), dt.time(12, 34, 58, 789789)],
+        [dt.time(12, 34, 56, 789789), dt.time(12, 34, 57, 789789), dt.time(12, 34, 58, 789789)],
+        [dt.datetime(2024, 4, 10, 12, 34, 56), dt.datetime(2025, 4, 10, 12, 34, 56), dt.datetime(2026, 4, 10, 12, 34, 56)],
+        [dt.datetime(2024, 4, 10, 12, 34, 56, 789000), dt.datetime(2025, 4, 10, 12, 34, 56, 789000), dt.datetime(2026, 4, 10, 12, 34, 56, 789000)],
+        [dt.datetime(2024, 4, 10, 12, 34, 56, 789789), dt.datetime(2025, 4, 10, 12, 34, 56, 789789), dt.datetime(2026, 4, 10, 12, 34, 56, 789789)],
+        [dt.datetime(2024, 4, 10, 12, 34, 56, 789789), dt.datetime(2025, 4, 10, 12, 34, 56, 789789), dt.datetime(2026, 4, 10, 12, 34, 56, 789789)],
     ])
+
     with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
         def select(predicate):
             return pa.Table.from_batches(t.select(predicate=predicate))
@@ -197,7 +217,33 @@ def test_types(session, clean_bucket_name):
         assert select(t['s'] == "v") == expected.filter(pc.field('s') == "v")
         assert select(t['d'] == 231.15) == expected.filter(pc.field('d') == 231.15)
         assert select(t['bin'] == b"\x01\x02") == expected.filter(pc.field('bin') == b"\x01\x02")
-        assert select(t['date'] == dt.datetime.now().date()) == expected.filter(pc.field('date') == dt.datetime.now().date())
+
+        date_literal = dt.date(2024, 4, 10)
+        assert select(t['date'] == date_literal) == expected.filter(pc.field('date') == date_literal)
+
+        time_literal = dt.time(12, 34, 56)
+        assert select(t['t0'] == time_literal) == expected.filter(pc.field('t0') == time_literal)
+
+        time_literal = dt.time(12, 34, 56, 789000)
+        assert select(t['t3'] == time_literal) == expected.filter(pc.field('t3') == time_literal)
+
+        time_literal = dt.time(12, 34, 56, 789789)
+        assert select(t['t6'] == time_literal) == expected.filter(pc.field('t6') == time_literal)
+
+        time_literal = dt.time(12, 34, 56, 789789)
+        assert select(t['t9'] == time_literal) == expected.filter(pc.field('t9') == time_literal)
+
+        ts_literal = dt.datetime(2024, 4, 10, 12, 34, 56)
+        assert select(t['ts0'] == ts_literal) == expected.filter(pc.field('ts0') == ts_literal)
+
+        ts_literal = dt.datetime(2024, 4, 10, 12, 34, 56, 789000)
+        assert select(t['ts3'] == ts_literal) == expected.filter(pc.field('ts3') == ts_literal)
+
+        ts_literal = dt.datetime(2024, 4, 10, 12, 34, 56, 789789)
+        assert select(t['ts6'] == ts_literal) == expected.filter(pc.field('ts6') == ts_literal)
+
+        ts_literal = dt.datetime(2024, 4, 10, 12, 34, 56, 789789)
+        assert select(t['ts9'] == ts_literal) == expected.filter(pc.field('ts9') == ts_literal)
 
 
 def test_filters(session, clean_bucket_name):
@@ -248,7 +294,7 @@ def test_filters(session, clean_bucket_name):
         assert select(((t['a'] > 111) | (t['a'] < 333)) & (t['b'] < 2.5)) == expected.filter(((pc.field('a') > 111) | (pc.field('a') < 333)) & (pc.field('b') < 2.5))
         with pytest.raises(NotImplementedError):
             assert select((t['a'] > 111) | (t['b'] > 0) | (t['s'] < 'ccc')) == expected.filter((pc.field('a') > 111) | (pc.field('b') > 0) | (pc.field('s') < 'ccc'))
-        assert select((t['a'] > 111) | (t['a'] < 333) | (t['a'] == 777) ) == expected.filter((pc.field('a') > 111) | (pc.field('a') < 333) | (pc.field('a') == 777))
+        assert select((t['a'] > 111) | (t['a'] < 333) | (t['a'] == 777)) == expected.filter((pc.field('a') > 111) | (pc.field('a') < 333) | (pc.field('a') == 777))
 
         assert select(t['s'].isnull()) == expected.filter(pc.field('s').is_null())
         assert select((t['s'].isnull()) | (t['s'] == 'bb'))  == expected.filter((pc.field('s').is_null()) | (pc.field('s') == 'bb'))
@@ -259,26 +305,6 @@ def test_filters(session, clean_bucket_name):
         assert select(t['s'].contains('y')) == expected.filter(pc.field('s') == 'xyz')
 
 
-def test_duckdb(session, clean_bucket_name):
-    columns = pa.schema([
-        ('a', pa.int32()),
-        ('b', pa.float64()),
-    ])
-    data = pa.table(schema=columns, data=[
-        [111, 222, 333],
-        [0.5, 1.5, 2.5],
-    ])
-    with prepare_data(session, clean_bucket_name, 's', 't', data) as t:
-        conn = duckdb.connect()
-        batches = t.select(columns=['a'], predicate=(t['b'] < 2))  # noqa: F841
-        actual = conn.execute('SELECT max(a) as "a_max" FROM batches').arrow()
-        expected = (data
-            .filter(pc.field('b') < 2)
-            .group_by([])
-            .aggregate([('a', 'max')]))
-        assert actual == expected
-
-
 def test_parquet_export(session, clean_bucket_name):
     with session.transaction() as tx:
         s = tx.bucket(clean_bucket_name).create_schema('s1')
@@ -297,8 +323,7 @@ def test_parquet_export(session, clean_bucket_name):
             ['a', 'b'],
         ])
         expected = pa.Table.from_batches([rb])
-        rb = t.insert(rb)
-        assert rb.to_pylist() == [0, 1]
+        t.insert(rb)
         actual = pa.Table.from_batches(t.select())
         assert actual == expected
 
@@ -312,6 +337,7 @@ def test_parquet_export(session, clean_bucket_name):
 
             assert expected == pq.read_table(parquet_file.name)
 
+
 def test_errors(session, clean_bucket_name):
     with pytest.raises(errors.MissingSchema):
         with session.transaction() as tx:
@@ -331,7 +357,8 @@ def test_errors(session, clean_bucket_name):
                 ('s', pa.utf8()),
             ])
             s.create_table('t1', columns)
-            s.drop() # cannot drop schema without dropping its tables first
+            s.drop()  # cannot drop schema without dropping its tables first
+
 
 def test_rename_schema(session, clean_bucket_name):
 
@@ -389,20 +416,21 @@ def test_rename_table(session, clean_bucket_name):
             s.table('t')
         t = s.table('t2')
 
-        #assert that other transactions are isolated
+        # assert that other transactions are isolated
         with pytest.raises(errors.MissingTable):
             tx2.bucket(clean_bucket_name).schema('s').table('t2')
         tx2.bucket(clean_bucket_name).schema('s').table('t')
 
     with session.transaction() as tx:
         s = tx.bucket(clean_bucket_name).schema('s')
-        #assert that new transactions see the change
+        # assert that new transactions see the change
         with pytest.raises(errors.MissingTable):
             s.table('t')
         t = s.table('t2')
         t.drop()
         s.drop()
 
+
 def test_add_column(session, clean_bucket_name):
     columns = pa.schema([
             ('a', pa.int16()),
@@ -425,18 +453,18 @@ def test_add_column(session, clean_bucket_name):
         # in which it was added
         assert t.arrow_schema == new_schema
 
-        #assert that other transactions are isolated
+        # assert that other transactions are isolated
         assert tx2.bucket(clean_bucket_name).schema('s').table('t').arrow_schema == columns
 
-
     with session.transaction() as tx:
         s = tx.bucket(clean_bucket_name).schema('s')
         t = s.table('t')
-        #assert that new transactions see the change
+        # assert that new transactions see the change
         assert t.arrow_schema == new_schema
         t.drop()
         s.drop()
 
+
 def test_drop_column(session, clean_bucket_name):
     columns = pa.schema([
             ('a', pa.int16()),
@@ -460,31 +488,32 @@ def test_drop_column(session, clean_bucket_name):
         # in which it was added
         assert t.arrow_schema == new_schema
 
-        #assert that other transactions are isolated
+        # assert that other transactions are isolated
         assert tx2.bucket(clean_bucket_name).schema('s').table('t').arrow_schema == columns
 
-
     with session.transaction() as tx:
         s = tx.bucket(clean_bucket_name).schema('s')
         t = s.table('t')
-        #assert that new transactions see the change
+        # assert that new transactions see the change
         assert t.arrow_schema == new_schema
         t.drop()
         s.drop()
 
+
 def test_rename_column(session, clean_bucket_name):
     columns = pa.schema([
             ('a', pa.int16()),
             ('b', pa.float32()),
             ('s', pa.utf8()),
         ])
-    def prepare_rename_column(schema : pa.Schema, old_name : str, new_name : str) -> pa.Schema:
+
+    def prepare_rename_column(schema: pa.Schema, old_name: str, new_name: str) -> pa.Schema:
         field_idx = schema.get_field_index(old_name)
         column_to_rename = schema.field(field_idx)
         renamed_column = column_to_rename.with_name(new_name)
         return schema.set(field_idx, renamed_column)
 
-    new_schema = prepare_rename_column(columns,'a','aaa')
+    new_schema = prepare_rename_column(columns, 'a', 'aaa')
 
     with session.transaction() as tx:
         s = tx.bucket(clean_bucket_name).create_schema('s')
@@ -499,10 +528,10 @@ def test_rename_column(session, clean_bucket_name):
         # in which it was added
         assert t.arrow_schema == new_schema
 
-        #assert that other transactions are isolated
+        # assert that other transactions are isolated
         assert tx2.bucket(clean_bucket_name).schema('s').table('t').arrow_schema == columns
 
-    #assert that new transactions see the change
+    # assert that new transactions see the change
     with session.transaction() as tx:
         s = tx.bucket(clean_bucket_name).schema('s')
         t = s.table('t')
@@ -517,7 +546,7 @@ def test_rename_column(session, clean_bucket_name):
             t1 = tx1.bucket(clean_bucket_name).schema('s').table('t')
             t2 = tx2.bucket(clean_bucket_name).schema('s').table('t')
             t1.rename_column('b', 'bb')
-            with pytest.raises(HTTPError, match = '409 Client Error: Conflict'):
+            with pytest.raises(HTTPError, match='409 Client Error: Conflict'):
                 t2.rename_column('b', 'bbb')
 
     with session.transaction() as tx:
@@ -533,6 +562,7 @@ def test_rename_column(session, clean_bucket_name):
         t.drop()
         s.drop()
 
+
 def test_select_stop(session, clean_bucket_name):
     columns = pa.schema([
             ('a', pa.uint8()),
@@ -555,15 +585,16 @@ def test_select_stop(session, clean_bucket_name):
     qc = QueryConfig(num_sub_splits=2, num_splits=4, num_row_groups_per_sub_split=1)
     with session.transaction() as tx:
         t = tx.bucket(clean_bucket_name).schema('s').table('t')
-        t.refresh_stats()
-        qc.data_endpoints = list(t.stats.endpoints) * 2
+        qc.data_endpoints = list(t.get_stats().endpoints) * 2
 
     # Duplicate the table until it is large enough to generate enough batches
     while num_rows < (qc.num_sub_splits * qc.num_splits) * ROWS_PER_GROUP:
+        # We need two separate transactions to prevent an infinite loop that may happen
+        # while appending and reading the same table using a single transaction.
         with session.transaction() as tx_read, session.transaction() as tx_write:
             t_read = tx_read.bucket(clean_bucket_name).schema('s').table('t')
             t_write = tx_write.bucket(clean_bucket_name).schema('s').table('t')
-            for batch in t_read.select(['a'],config=qc):
+            for batch in t_read.select(['a'], config=qc):
                 t_write.insert(batch)
         num_rows = num_rows * 2
         log.info("Num rows: %d", num_rows)
@@ -580,11 +611,12 @@ def test_select_stop(session, clean_bucket_name):
     # If this assert triggers it just means that the test assumptions about how
     # the tabular server splits the batches is not true anymore and we need to
     # rewrite the test.
-    assert read_batches == qc.num_splits*qc.num_sub_splits
-    qc.query_id = str(random.randint(0,2**32))
+    assert read_batches == qc.num_splits * qc.num_sub_splits
+    qc.query_id = str(random.randint(0, 2**32))
     log.info("query id is: %s", qc.query_id)
+
     def active_threads():
-        log.debug("%s",[t.getName() for t in threading.enumerate() if t.is_alive()])
+        log.debug("%s", [t.getName() for t in threading.enumerate() if t.is_alive()])
         return sum([1 if t.is_alive() and qc.query_id in t.getName() else 0 for t in threading.enumerate()])
 
     assert active_threads() == 0

vastdb/tests/util.py

@@ -0,0 +1,15 @@
+import logging
+from contextlib import contextmanager
+
+log = logging.getLogger(__name__)
+
+
+@contextmanager
+def prepare_data(session, clean_bucket_name, schema_name, table_name, arrow_table):
+    with session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).create_schema(schema_name)
+        t = s.create_table(table_name, arrow_table.schema)
+        t.insert(arrow_table)
+        yield t
+        t.drop()
+        s.drop()

vastdb/transaction.py

@@ -6,22 +6,23 @@ A transcation is used as a context manager, since every Database-related operati
         tx.bucket("bucket").create_schema("schema")
 """
 
-from . import bucket, errors, session
+import logging
+from dataclasses import dataclass
+from typing import Optional
 
 import botocore
 
-from dataclasses import dataclass
-import logging
-
+from . import bucket, errors, schema, session, table
 
 log = logging.getLogger(__name__)
 
+
 @dataclass
 class Transaction:
     """A holder of a single VAST transaction."""
 
     _rpc: "session.Session"
-    txid: int = None
+    txid: Optional[int] = None
 
     def __enter__(self):
         """Create a transaction and store its ID."""
@@ -32,12 +33,14 @@ class Transaction:
 
     def __exit__(self, exc_type, exc_value, exc_traceback):
         """On success, the transaction is committed. Otherwise, it is rolled back."""
+        txid = self.txid
+        self.txid = None
         if (exc_type, exc_value, exc_traceback) == (None, None, None):
-            log.debug("committing txid=%016x", self.txid)
-            self._rpc.api.commit_transaction(self.txid)
+            log.debug("committing txid=%016x", txid)
+            self._rpc.api.commit_transaction(txid)
         else:
-            log.exception("rolling back txid=%016x due to:", self.txid)
-            self._rpc.api.rollback_transaction(self.txid)
+            log.exception("rolling back txid=%016x due to:", txid)
+            self._rpc.api.rollback_transaction(txid)
 
     def __repr__(self):
         """Don't show the session details."""
@@ -53,3 +56,9 @@ class Transaction:
                 raise errors.MissingBucket(name)
             raise
         return bucket.Bucket(name, self)
+
+    def catalog(self, fail_if_missing=True) -> Optional["table.Table"]:
+        """Return VAST Catalog table."""
+        b = bucket.Bucket("vast-big-catalog-bucket", self)
+        s = schema.Schema("vast_big_catalog_schema", b)
+        return s.table(name="vast_big_catalog_table", fail_if_missing=fail_if_missing)

vastdb/util.py

@@ -1,18 +1,20 @@
 import logging
-from typing import Callable
+from typing import Callable, List, Optional
 
 import pyarrow as pa
 import pyarrow.parquet as pq
 
 from .errors import InvalidArgument
 from .schema import Schema
-from .table import Table
+from .table import ImportConfig, Table
 
 log = logging.getLogger(__name__)
 
 
 def create_table_from_files(
-        schema: Schema, table_name: str, parquet_files: [str], schema_merge_func: Callable = None) -> Table:
+        schema: Schema, table_name: str, parquet_files: List[str],
+        schema_merge_func: Optional[Callable] = None,
+        config: Optional[ImportConfig] = None) -> Table:
     if not schema_merge_func:
         schema_merge_func = default_schema_merge
     else:
@@ -32,7 +34,7 @@ def create_table_from_files(
     table = schema.create_table(table_name, current_schema)
 
     log.info("Starting import of %d files to table: %s", len(parquet_files), table)
-    table.import_files(parquet_files)
+    table.import_files(parquet_files, config=config)
     log.info("Finished import of %d files to table: %s", len(parquet_files), table)
     return table
 

{vastdb-0.1.0.dist-info → vastdb-0.1.2.dist-info}/METADATA

@@ -1,12 +1,11 @@
 Metadata-Version: 2.1
 Name: vastdb
-Version: 0.1.0
+Version: 0.1.2
 Summary: VAST Data SDK
 Home-page: https://github.com/vast-data/vastdb_sdk
 Author: VAST DATA
 Author-email: hello@vastdata.com
 License: Copyright (C) VAST Data Ltd.
-Platform: UNKNOWN
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
@@ -34,5 +33,3 @@ and [VAST Catalog](https://vastdata.com/blog/vast-catalog-treat-your-file-system
 enabling schema and table management, efficient ingest, query and modification of columnar data.
 
 For more details, see [our whitepaper](https://vastdata.com/whitepaper/#TheVASTDataBase).
-
-

{vastdb-0.1.0.dist-info → vastdb-0.1.2.dist-info}/RECORD

@@ -148,24 +148,29 @@ vast_flatbuf/tabular/ObjectDetails.py,sha256=qW0WtbkCYYE_L-Kw6VNRDCLYaRm5lKvTbLN
 vast_flatbuf/tabular/S3File.py,sha256=KC9c2oS5-JXwTTriUVFdjOvRG0B54Cq9kviSDZY3NI0,4450
 vast_flatbuf/tabular/VipRange.py,sha256=_BJd1RRZAcK76T9vlsHzXKYVsPVaz6WTEAqStMQCAUQ,2069
 vast_flatbuf/tabular/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vastdb/__init__.py,sha256=GY30IfZQApfl7HfcFmfTzFpx48oHgQIrDcUQCiTnxpo,206
-vastdb/bucket.py,sha256=Xbgn5Ns7veBL4oKH7EaSj4SxTPDRlicl9Saaz_39ZsU,2526
-vastdb/errors.py,sha256=mveQ2O0fLKOS51V9k5Y-HwY8Y1XiYdE9aJ9j0wlltWQ,3119
-vastdb/internal_commands.py,sha256=FR4rkr-sRvqMc-Y5hW7APOPa41a8d7L8DNJ2ROHRaFM,104441
-vastdb/schema.py,sha256=TbgqaUqAraj43vKCyVQNUSOMuJdw2Y4M06svs5jpcPo,2836
-vastdb/session.py,sha256=qgjT9rt1yUr4GyHOZRsVGFj3HYBoHFAEdczi_R26O8o,1731
-vastdb/table.py,sha256=p0uE0Gw9hen7hLTx9xC_MbxTaG6ZhZEFieaenUnbyUY,20442
-vastdb/transaction.py,sha256=jleiVmg4iui2q1GqMFsPo5GZRNtIa5NzGLFVooBbzkQ,1797
-vastdb/util.py,sha256=pBw4ywNJfkvKik-T7ZKPrWBoZOqGns-WsSZkG7HHa2I,2908
+vastdb/__init__.py,sha256=cMJtZuJ0IL9aKyM3DUWqTCzuP1H1MXXVivKKE1-q0DY,292
+vastdb/bucket.py,sha256=xtKs7S4w0jmI4MujDWH3HDI-iEgbq5Xqqsod-tw4zSo,2991
+vastdb/conftest.py,sha256=pKpo_46Vq4QHzTDQAFxasrVhnZ2V2L-y6IMLxojxaFM,2132
+vastdb/errors.py,sha256=fxpKSxjEgoJZuBtEGWzTW9lpDlEjuzgpgXwAQc1W6BQ,3436
+vastdb/internal_commands.py,sha256=3F6FiYu-Ama1zBO7hENPxCaQYJT8mcZP6rSQvtI7Sks,101273
+vastdb/schema.py,sha256=MrQr-WIrES8KcQ0V6cJkRRp_-9jj9FboyrBnkNBsw-8,3324
+vastdb/session.py,sha256=VZOFGZbAdr5Tl4cp88VRQYnR4Q16UNuYjSmX_QPW1II,1718
+vastdb/table.py,sha256=bdx3C1iWiFivKmtifH7MyG7TMqnVVIU91as-_hMn1rE,20532
+vastdb/transaction.py,sha256=1uCSHXqWcwsMJv6DuNx4WyQMGUm8P-RCCqYdBdUGusI,2196
+vastdb/util.py,sha256=Tjj6p4gqabK5G21uWuCiuYM9FaaR04_Zk5X8NWtcdj8,3022
+vastdb/bench/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vastdb/bench/test_perf.py,sha256=iHE3E60fvyU5SBDHPi4h03Dj6QcY6VI9l9mMhgNMtPc,1117
 vastdb/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vastdb/tests/conftest.py,sha256=VLqImQ1XMr1FLCLCqZpgv8wMjNskfYAtMp-qjZFBqWo,1694
-vastdb/tests/test_imports.py,sha256=OhkbuhTeLgD4I6Vbub-B7wQo-G37TlXoHVQhGCLz9Wo,5035
-vastdb/tests/test_projections.py,sha256=PRi1Jf__95fsL9ZCQ_s2PtszWIO5FIFbniiL6FnV18M,1253
-vastdb/tests/test_sanity.py,sha256=gijOWK4ymGhVRHkf0ecHibVlaJxl92RinPdFUwWj1OQ,2959
-vastdb/tests/test_schemas.py,sha256=YX0lF8FbXzNCNVUAxq3g0L0OCjGq1OwkQaNaBtzDe4Q,1253
-vastdb/tests/test_tables.py,sha256=qnDRBtOPh9qcV4O3kB6xF4WJFj3B3WX2RAmUzkzl05g,23634
-vastdb-0.1.0.dist-info/LICENSE,sha256=obffan7LYrq7hLHNrY7vHcn2pKUTBUYXMKu-VOAvDxU,11333
-vastdb-0.1.0.dist-info/METADATA,sha256=pCY34hVZGzoB51SyIgrzrtxDaOXC_2DGOQbafZdOmQg,1331
-vastdb-0.1.0.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
-vastdb-0.1.0.dist-info/top_level.txt,sha256=Vsj2MKtlhPg0J4so64slQtnwjhgoPmJgcG-6YcVAwVc,20
-vastdb-0.1.0.dist-info/RECORD,,
+vastdb/tests/test_duckdb.py,sha256=KDuv4PrjGEwChCGHG36xNT2JiFlBOt6K3DQ3L06Kq-A,1913
+vastdb/tests/test_imports.py,sha256=fDUjO5U-5i4QTIMoNnSSW4X_ZnOStLbx0mJkNq2pj9Q,5033
+vastdb/tests/test_nested.py,sha256=3kejEvtSqV0LrUgb1QglRjrlxnKI4_AXTFw2nE7Q520,951
+vastdb/tests/test_projections.py,sha256=_cDNfD5zTwbCXLk6uGpPUWGN0P-4HElu5OjubWu-Jg0,1255
+vastdb/tests/test_sanity.py,sha256=ixx0QPo73hLHjAa7bByFXjS1XST0WvmSwLEpgnHh_JY,2960
+vastdb/tests/test_schemas.py,sha256=b-JpYHOFYVTdE570_La7O2RWf8BGN-q8KDXNXeC8CSg,1724
+vastdb/tests/test_tables.py,sha256=TXM4LSBvPb3EEu7XScZ5iEiu_zhHClq61W18EQodxw8,25667
+vastdb/tests/util.py,sha256=NaCzKymEGy1xuiyMxyt2_0frKVfVk9iGrFwLf3GHjTI,435
+vastdb-0.1.2.dist-info/LICENSE,sha256=obffan7LYrq7hLHNrY7vHcn2pKUTBUYXMKu-VOAvDxU,11333
+vastdb-0.1.2.dist-info/METADATA,sha256=edJPdDWmHj6tRHRR97eSppfN9_4ARfIr0jS9HMjHfSQ,1311
+vastdb-0.1.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+vastdb-0.1.2.dist-info/top_level.txt,sha256=Vsj2MKtlhPg0J4so64slQtnwjhgoPmJgcG-6YcVAwVc,20
+vastdb-0.1.2.dist-info/RECORD,,

{vastdb-0.1.0.dist-info → vastdb-0.1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any