vastdb 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

vastdb/table.py

@@ -21,6 +21,7 @@ log = logging.getLogger(__name__)
 
 INTERNAL_ROW_ID = "$row_id"
 INTERNAL_ROW_ID_FIELD = pa.field(INTERNAL_ROW_ID, pa.uint64())
+INTERNAL_ROW_ID_SORTED_FIELD = pa.field(INTERNAL_ROW_ID, pa.decimal128(38, 0))  # Sorted tables have longer row ids
 
 MAX_ROWS_PER_BATCH = 512 * 1024
 # for insert we need a smaller limit due to response amplification
@@ -28,6 +29,7 @@ MAX_ROWS_PER_BATCH = 512 * 1024
 MAX_INSERT_ROWS_PER_PATCH = 512 * 1024
 # in case insert has TooWideRow - need to insert in smaller batches - each cell could contain up to 128K, and our wire is limited to 5MB
 MAX_COLUMN_IN_BATCH = int(5 * 1024 / 128)
+SORTING_SCORE_BITS = 63
 
 
 @dataclass
@@ -36,7 +38,12 @@ class TableStats:
 
     num_rows: int
     size_in_bytes: int
+    sorting_score: int
+    write_amplification: int
+    acummulative_row_inserition_count: int
     is_external_rowid_alloc: bool = False
+    sorting_key_enabled: bool = False
+    sorting_done: bool = False
     endpoints: Tuple[str, ...] = ()
 
 
@@ -115,6 +122,7 @@ class Table:
     arrow_schema: pa.Schema = field(init=False, compare=False, repr=False)
     _ibis_table: ibis.Schema = field(init=False, compare=False, repr=False)
     _imports_table: bool
+    sorted_table: bool
 
     def __post_init__(self):
         """Also, load columns' metadata."""
@@ -157,6 +165,29 @@ class Table:
         self.arrow_schema = pa.schema(fields)
         return self.arrow_schema
 
+    def sorted_columns(self) -> list:
+        """Return sorted columns' metadata."""
+        fields = []
+        try:
+            self.tx._rpc.features.check_elysium()
+            next_key = 0
+            while True:
+                cur_columns, next_key, is_truncated, _count = self.tx._rpc.api.list_sorted_columns(
+                    bucket=self.bucket.name, schema=self.schema.name, table=self.name, next_key=next_key, txid=self.tx.txid, list_imports_table=self._imports_table)
+                fields.extend(cur_columns)
+                if not is_truncated:
+                    break
+        except errors.BadRequest:
+            pass
+        except errors.InternalServerError as ise:
+            log.warning("Failed to get the sorted columns Elysium might not be supported: %s", ise)
+            pass
+        except errors.NotSupportedVersion:
+            log.warning("Failed to get the sorted columns, Elysium not supported")
+            pass
+
+        return fields
+
     def projection(self, name: str) -> "Projection":
         """Get a specific semi-sorted projection of this table."""
         if self._imports_table:
@@ -228,6 +259,10 @@ class Table:
         endpoints = [self.tx._rpc.api.url for _ in range(config.import_concurrency)]  # TODO: use valid endpoints...
         files_queue = queue.Queue()
 
+        key_names = config.key_names or []
+        if key_names:
+            self.tx._rpc.features.check_zip_import()
+
         for source_file in source_files.items():
             files_queue.put(source_file)
 
@@ -248,9 +283,11 @@ class Table:
                         except queue.Empty:
                             pass
                         if files_batch:
-                            log.debug("Starting import batch of %s files", len(files_batch))
+                            log.info("Starting import batch of %s files", len(files_batch))
+                            log.debug(f"starting import of {files_batch}")
                             session.import_data(
-                                self.bucket.name, self.schema.name, self.name, files_batch, txid=self.tx.txid)
+                                self.bucket.name, self.schema.name, self.name, files_batch, txid=self.tx.txid,
+                                key_names=key_names)
             except (Exception, KeyboardInterrupt) as e:
                 stop_event.set()
                 log.error("Got exception inside import_worker. exception: %s", e)
@@ -277,6 +314,21 @@ class Table:
             imports_table_stats=self._imports_table)
         return TableStats(**stats_tuple._asdict())
 
+    def _get_row_estimate(self, columns: List[str], predicate: ibis.expr.types.BooleanColumn, arrow_schema: pa.Schema):
+        query_data_request = _internal.build_query_data_request(
+            schema=arrow_schema,
+            predicate=predicate,
+            field_names=columns)
+        response = self.tx._rpc.api.query_data(
+            bucket=self.bucket.name,
+            schema=self.schema.name,
+            table=self.name,
+            params=query_data_request.serialized,
+            split=(0xffffffff - 3, 1, 1),
+            txid=self.tx.txid)
+        batch = _internal.read_first_batch(response.raw)
+        return batch.num_rows * 2**16 if batch is not None else 0
+
     def select(self, columns: Optional[List[str]] = None,
                predicate: Union[ibis.expr.types.BooleanColumn, ibis.common.deferred.Deferred] = None,
                config: Optional[QueryConfig] = None,
@@ -293,30 +345,22 @@ class Table:
         if config is None:
             config = QueryConfig()
 
+        stats = None
         # Retrieve snapshots only if needed
-        if config.data_endpoints is None or config.num_splits is None:
+        if config.data_endpoints is None:
             stats = self.get_stats()
             log.debug("stats: %s", stats)
-
-        if config.data_endpoints is None:
             endpoints = stats.endpoints
         else:
             endpoints = tuple(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 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]
 
         query_schema = self.arrow_schema
         if internal_row_id:
-            queried_fields = [INTERNAL_ROW_ID_FIELD]
+            queried_fields = [INTERNAL_ROW_ID_SORTED_FIELD if self.sorted_table else INTERNAL_ROW_ID_FIELD]
             queried_fields.extend(column for column in self.arrow_schema)
             query_schema = pa.schema(queried_fields)
             columns.append(INTERNAL_ROW_ID)
@@ -330,6 +374,22 @@ class Table:
         if isinstance(predicate, ibis.common.deferred.Deferred):
             predicate = predicate.resolve(self._ibis_table)  # may raise if the predicate is invalid (e.g. wrong types / missing column)
 
+        if config.num_splits is None:
+            num_rows = 0
+            if self.sorted_table:
+                num_rows = self._get_row_estimate(columns, predicate, query_schema)
+                log.debug(f'sorted estimate: {num_rows}')
+            if num_rows == 0:
+                if stats is None:
+                    stats = self.get_stats()
+                num_rows = stats.num_rows
+
+            config.num_splits = max(1, num_rows // config.rows_per_split)
+        log.debug("config: %s", config)
+
+        if config.semi_sorted_projection_name:
+            self.tx._rpc.features.check_enforce_semisorted_projection()
+
         query_data_request = _internal.build_query_data_request(
             schema=query_schema,
             predicate=predicate,
@@ -485,7 +545,7 @@ class Table:
         if columns is None:
             columns = [name for name in rows.schema.names if name != INTERNAL_ROW_ID]
 
-        update_fields = [(INTERNAL_ROW_ID, pa.uint64())]
+        update_fields = [INTERNAL_ROW_ID_SORTED_FIELD if self.sorted_table else INTERNAL_ROW_ID_FIELD]
         update_values = [_combine_chunks(rows_chunk)]
         for col in columns:
             update_fields.append(rows.field(col))
@@ -511,7 +571,7 @@ class Table:
             rows_chunk = rows[INTERNAL_ROW_ID]
         except KeyError:
             raise errors.MissingRowIdColumn
-        delete_rows_rb = pa.record_batch(schema=pa.schema([(INTERNAL_ROW_ID, pa.uint64())]),
+        delete_rows_rb = pa.record_batch(schema=pa.schema([INTERNAL_ROW_ID_SORTED_FIELD if self.sorted_table else INTERNAL_ROW_ID_FIELD]),
                                          data=[_combine_chunks(rows_chunk)])
 
         delete_rows_rb = util.sort_record_batch_if_needed(delete_rows_rb, INTERNAL_ROW_ID)
@@ -535,6 +595,13 @@ class Table:
         log.info("Renamed table from %s to %s ", self.name, new_name)
         self.name = new_name
 
+    def add_sorting_key(self, sorting_key: list) -> None:
+        """Ads a sorting key to a table that doesn't have any."""
+        self.tx._rpc.features.check_elysium()
+        self.tx._rpc.api.alter_table(
+            self.bucket.name, self.schema.name, self.name, txid=self.tx.txid, sorting_key=sorting_key)
+        log.info("Enabled Elysium for table %s with sorting key %s ", self.name, str(sorting_key))
+
     def add_column(self, new_column: pa.Schema) -> None:
         """Add a new column."""
         if self._imports_table:
@@ -583,7 +650,7 @@ class Table:
     def imports_table(self) -> Optional["Table"]:
         """Get the imports table of this table."""
         self.tx._rpc.features.check_imports_table()
-        return Table(name=self.name, schema=self.schema, handle=int(self.handle), _imports_table=True)
+        return Table(name=self.name, schema=self.schema, handle=int(self.handle), _imports_table=True, sorted_table=self.sorted_table)
 
     def __getitem__(self, col_name: str):
         """Allow constructing ibis-like column expressions from this table.
@@ -592,6 +659,20 @@ class Table:
         """
         return self._ibis_table[col_name]
 
+    def sorting_done(self) -> int:
+        """Sorting done indicator for the table.  Always False for unsorted tables."""
+        if not self.sorted_table:
+            return False
+        raw_sorting_score = self.tx._rpc.api.raw_sorting_score(self.schema.bucket.name, self.schema.name, self.schema.tx.txid, self.name)
+        return bool(raw_sorting_score >> SORTING_SCORE_BITS)
+
+    def sorting_score(self) -> int:
+        """Sorting score for the table.  Always 0 for unsorted tables."""
+        if not self.sorted_table:
+            return 0
+        raw_sorting_score = self.tx._rpc.api.raw_sorting_score(self.schema.bucket.name, self.schema.name, self.schema.tx.txid, self.name)
+        return raw_sorting_score & ((1 << SORTING_SCORE_BITS) - 1)
+
 
 @dataclass
 class Projection:
@@ -649,7 +730,8 @@ class Projection:
 
 def _parse_projection_info(projection_info, table: "Table"):
     log.info("Projection info %s", str(projection_info))
-    stats = TableStats(num_rows=projection_info.num_rows, size_in_bytes=projection_info.size_in_bytes)
+    stats = TableStats(num_rows=projection_info.num_rows, size_in_bytes=projection_info.size_in_bytes,
+                       sorting_score=0, write_amplification=0, acummulative_row_inserition_count=0)
     return Projection(name=projection_info.name, table=table, stats=stats, handle=int(projection_info.handle))
 
 

vastdb/tests/test_imports.py

@@ -6,11 +6,27 @@ import pyarrow.parquet as pq
 import pytest
 
 from vastdb import util
-from vastdb.errors import ImportFilesError, InternalServerError, InvalidArgument
+from vastdb.config import ImportConfig
+from vastdb.errors import (
+    ImportFilesError,
+    InternalServerError,
+    InvalidArgument,
+    NotSupportedVersion,
+)
 
 log = logging.getLogger(__name__)
 
 
+@pytest.fixture
+def zip_import_session(session):
+    with session.transaction() as tx:
+        try:
+            tx._rpc.features.check_zip_import()
+            return session
+        except NotSupportedVersion:
+            pytest.skip("Skipped because this test requires version 5.3.1")
+
+
 def test_parallel_imports(session, clean_bucket_name, s3):
     num_rows = 1000
     num_files = 53
@@ -54,6 +70,59 @@ def test_parallel_imports(session, clean_bucket_name, s3):
         assert len(object_names) == len(objects_name['ObjectName'])
 
 
+def test_zip_imports(zip_import_session, clean_bucket_name, s3):
+    num_rows = 10
+    num_files = 5
+    files = []
+    ids = [i for i in range(num_rows)]
+    symbols = [chr(c) for c in range(ord('a'), ord('a') + num_rows)]
+    for i in range(num_files):
+        ds = {'id': ids,
+              'symbol': symbols,
+              f'feature{i}': [i * 10 + k for k in range(num_rows)]}
+        table = pa.Table.from_pydict(ds)
+        with NamedTemporaryFile() as f:
+            pq.write_table(table, f.name)
+            pname = f'prq{i}'
+            s3.put_object(Bucket=clean_bucket_name, Key=pname, Body=f)
+            files.append(f'/{clean_bucket_name}/{pname}')
+
+    with zip_import_session.transaction() as tx:
+        b = tx.bucket(clean_bucket_name)
+        s = b.create_schema('s1')
+        t = s.create_table('t1', pa.schema([('vastdb_rowid', pa.int64()), ('id', pa.int64()), ('symbol', pa.string())]))
+        columns = pa.schema([
+            ('vastdb_rowid', pa.int64()),
+            ('id', pa.int64()),
+            ('symbol', pa.string()),
+        ])
+        ext_row_ids = [10 + i for i in range(num_rows)]
+        arrow_table = pa.table(schema=columns, data=[
+            ext_row_ids,
+            ids,
+            symbols,
+        ])
+        row_ids_array = t.insert(arrow_table)
+        row_ids = row_ids_array.to_pylist()
+        assert row_ids == ext_row_ids
+
+    with zip_import_session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).schema('s1')
+        t = s.table('t1')
+        log.info("Starting import of %d files", num_files)
+        config = ImportConfig()
+        config.key_names = ['id', 'symbol']
+        t.import_files(files, config=config)
+
+    with zip_import_session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).schema('s1')
+        t = s.table('t1')
+        arrow_table = t.select(columns=['feature0']).read_all()
+        assert arrow_table.num_rows == num_rows
+        log.debug(f"table schema={t.arrow_schema}")
+        assert len(t.arrow_schema) == 8
+
+
 def test_create_table_from_files(session, clean_bucket_name, s3):
     datasets = [
         {'num': [0],

vastdb/tests/test_tables.py

@@ -3,6 +3,7 @@ import decimal
 import logging
 import random
 import threading
+import time
 from contextlib import closing
 from tempfile import NamedTemporaryFile
 
@@ -13,6 +14,8 @@ import pyarrow.parquet as pq
 import pytest
 from requests.exceptions import HTTPError
 
+from vastdb.errors import BadRequest
+
 from .. import errors
 from ..table import INTERNAL_ROW_ID, QueryConfig
 from .util import prepare_data
@@ -20,6 +23,16 @@ from .util import prepare_data
 log = logging.getLogger(__name__)
 
 
+@pytest.fixture
+def elysium_session(session):
+    with session.transaction() as tx:
+        try:
+            tx._rpc.features.check_elysium()
+            return session
+        except errors.NotSupportedVersion:
+            pytest.skip("Skipped because this test requires version 5.3.5 with Elysium")
+
+
 def test_tables(session, clean_bucket_name):
     columns = pa.schema([
         ('a', pa.int64()),
@@ -990,3 +1003,207 @@ def test_multiple_contains_clauses(session, clean_bucket_name):
         for pred in failed_preds:
             with pytest.raises(NotImplementedError):
                 t.select(predicate=pred(t)).read_all()
+
+
+def test_tables_elysium(elysium_session, clean_bucket_name):
+    columns = pa.schema([
+        ('a', pa.int8()),
+        ('b', pa.int32()),
+        ('c', pa.int16()),
+    ])
+    expected = pa.table(schema=columns, data=[
+        [1, 2, 3],
+        [111111, 222222, 333333],
+        [111, 222, 333],
+    ])
+    sorting = [2, 1]
+    with prepare_data(elysium_session, clean_bucket_name, 's', 't', expected, sorting_key=sorting) as t:
+        sorted_columns = t.sorted_columns()
+        assert sorted_columns[0].name == 'c'
+        assert sorted_columns[1].name == 'b'
+
+
+# Fails because of a known issue: ORION-240102
+# def test_enable_elysium(session, clean_bucket_name):
+#     columns = pa.schema([
+#         ('a', pa.int8()),
+#         ('b', pa.int32()),
+#         ('c', pa.int16()),
+#     ])
+#     expected = pa.table(schema=columns, data=[
+#         [1,2,3],
+#         [111111,222222,333333],
+#         [111, 222, 333],
+#     ])
+#     sorting = [2, 1]
+#     with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
+#         sorted_columns = t.sorted_columns()
+#         assert len(sorted_columns) == 0
+#         t.add_sorting_key(sorting)
+#         time.sleep(10)
+#         sorted_columns = t.sorted_columns()
+#         assert len(sorted_columns) == 2
+#         assert sorted_columns[0].name == 'c'
+#         assert sorted_columns[1].name == 'b'
+
+
+def test_elysium_tx(elysium_session, clean_bucket_name):
+    columns = pa.schema([
+        ('a', pa.int8()),
+        ('b', pa.int32()),
+        ('c', pa.int16()),
+    ])
+    arrow_table = pa.table(schema=columns, data=[
+        [1, 2, 3],
+        [111111, 222222, 333333],
+        [111, 222, 333],
+    ])
+    sorting = [2, 1]
+    schema_name = 's'
+    table_name = 't'
+    with elysium_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()
+        assert row_ids == list(range(arrow_table.num_rows))
+        sorted_columns = t.sorted_columns()
+        assert len(sorted_columns) == 0
+        t.add_sorting_key(sorting)
+
+    with elysium_session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).schema(schema_name)
+        t = s.table(table_name)
+        sorted_columns = t.sorted_columns()
+        assert len(sorted_columns) == 2
+        assert sorted_columns[0].name == 'c'
+        assert sorted_columns[1].name == 'b'
+        t.drop()
+        s.drop()
+
+
+def test_elysium_double_enable(elysium_session, clean_bucket_name):
+    columns = pa.schema([
+        ('a', pa.int8()),
+        ('b', pa.int32()),
+        ('c', pa.int16()),
+    ])
+    expected = pa.table(schema=columns, data=[
+        [1, 2, 3],
+        [111111, 222222, 333333],
+        [111, 222, 333],
+    ])
+    sorting = [2, 1]
+    with pytest.raises(BadRequest):
+        with prepare_data(elysium_session, clean_bucket_name, 's', 't', expected, sorting_key=sorting) as t:
+            sorted_columns = t.sorted_columns()
+            assert sorted_columns[0].name == 'c'
+            assert sorted_columns[1].name == 'b'
+            t.add_sorting_key(sorting)
+
+
+def test_elysium_update_table_tx(elysium_session, clean_bucket_name):
+    columns = pa.schema([
+        ('a', pa.int64()),
+        ('b', pa.float32()),
+        ('s', pa.utf8()),
+    ])
+    arrow_table = pa.table(schema=columns, data=[
+        [111, 222, 333],
+        [0.5, 1.5, 2.5],
+        ['a', 'bb', 'ccc'],
+    ])
+    sorting = [2, 1]
+    schema_name = 's'
+    table_name = 't'
+    with elysium_session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).create_schema(schema_name)
+        t = s.create_table(table_name, arrow_table.schema, sorting_key=sorting)
+        row_ids_array = t.insert(arrow_table)
+        row_ids = row_ids_array.to_pylist()
+        assert row_ids == list(range(arrow_table.num_rows))
+        sorted_columns = t.sorted_columns()
+        assert sorted_columns[0].name == 's'
+        assert sorted_columns[1].name == 'b'
+
+    with elysium_session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).schema(schema_name)
+        t = s.table(table_name)
+        sorted_columns = t.sorted_columns()
+        assert sorted_columns[0].name == 's'
+        assert sorted_columns[1].name == 'b'
+
+        actual = t.select(columns=['a', 'b'], predicate=(t['a'] == 222), internal_row_id=True).read_all()
+        column_index = actual.column_names.index('a')
+        column_field = actual.field(column_index)
+        new_data = pc.add(actual.column('a'), 2000)
+        update_table = actual.set_column(column_index, column_field, new_data)
+
+        t.update(update_table, columns=['a'])
+        actual = t.select(columns=['a', 'b']).read_all()
+        assert actual.to_pydict() == {
+            'a': [111, 2222, 333],
+            'b': [0.5, 1.5, 2.5]
+        }
+
+        actual = t.select(columns=['a', 'b'], predicate=(t['a'] != 2222), internal_row_id=True).read_all()
+        column_index = actual.column_names.index('a')
+        column_field = actual.field(column_index)
+        new_data = pc.divide(actual.column('a'), 10)
+        update_table = actual.set_column(column_index, column_field, new_data)
+
+        t.update(update_table.to_batches()[0], columns=['a'])
+        actual = t.select(columns=['a', 'b']).read_all()
+        assert actual.to_pydict() == {
+            'a': [11, 2222, 33],
+            'b': [0.5, 1.5, 2.5]
+        }
+
+        actual = t.select(columns=['a', 'b'], predicate=(t['a'] < 222), internal_row_id=True).read_all()
+        column_index = actual.column_names.index('a')
+        column_field = actual.field(column_index)
+        new_data = pc.divide(actual.column('a'), 10)
+        delete_rows = actual.set_column(column_index, column_field, new_data)
+
+        t.delete(delete_rows)
+        actual = t.select(columns=['a', 'b']).read_all()
+        assert actual.to_pydict() == {
+            'a': [2222],
+            'b': [1.5]
+        }
+
+
+def test_elysium_splits(elysium_session, clean_bucket_name):
+    columns = pa.schema([
+        ('a', pa.int32())
+    ])
+
+    data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    data = data * 10000
+    arrow_table = pa.table(schema=columns, data=[data])
+
+    config = QueryConfig()
+    config.rows_per_split = 1000
+
+    sorting = [0]
+    schema_name = 's'
+    table_name = 't'
+
+    with elysium_session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).create_schema(schema_name)
+        t = s.create_table(table_name, arrow_table.schema, sorting_key=sorting)
+        row_ids_array = t.insert(arrow_table)
+        row_ids = row_ids_array.to_pylist()
+        assert row_ids == list(range(arrow_table.num_rows))
+        sorted_columns = t.sorted_columns()
+        assert sorted_columns[0].name == 'a'
+
+    time.sleep(300)
+    with elysium_session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).schema(schema_name)
+        t = s.table(table_name)
+        sorted_columns = t.sorted_columns()
+        assert sorted_columns[0].name == 'a'
+
+        actual = t.select(columns=['a'], predicate=(t['a'] == 1), config=config).read_all()
+        assert len(actual) == 10000

vastdb/tests/util.py

@@ -5,10 +5,10 @@ log = logging.getLogger(__name__)
 
 
 @contextmanager
-def prepare_data(session, clean_bucket_name, schema_name, table_name, arrow_table):
+def prepare_data(session, clean_bucket_name, schema_name, table_name, arrow_table, sorting_key=[]):
     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 = s.create_table(table_name, arrow_table.schema, sorting_key=sorting_key)
         row_ids_array = t.insert(arrow_table)
         row_ids = row_ids_array.to_pylist()
         assert row_ids == list(range(arrow_table.num_rows))

{vast_flatbuf → vastdb/vast_flatbuf}/org/apache/arrow/computeir/flatbuf/Aggregate.py

@@ -32,7 +32,7 @@ class Aggregate(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from vast_flatbuf.org.apache.arrow.computeir.flatbuf.RelId import RelId
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.RelId import RelId
             obj = RelId()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -44,7 +44,7 @@ class Aggregate(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from vast_flatbuf.org.apache.arrow.computeir.flatbuf.Relation import Relation
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.Relation import Relation
             obj = Relation()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -59,7 +59,7 @@ class Aggregate(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from vast_flatbuf.org.apache.arrow.computeir.flatbuf.Expression import Expression
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.Expression import Expression
             obj = Expression()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -98,7 +98,7 @@ class Aggregate(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from vast_flatbuf.org.apache.arrow.computeir.flatbuf.Grouping import Grouping
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.Grouping import Grouping
             obj = Grouping()
             obj.Init(self._tab.Bytes, x)
             return obj

{vast_flatbuf → vastdb/vast_flatbuf}/org/apache/arrow/computeir/flatbuf/Call.py

@@ -41,7 +41,7 @@ class Call(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from vast_flatbuf.org.apache.arrow.computeir.flatbuf.Expression import Expression
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.Expression import Expression
             obj = Expression()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -69,7 +69,7 @@ class Call(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from vast_flatbuf.org.apache.arrow.computeir.flatbuf.SortKey import SortKey
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.SortKey import SortKey
             obj = SortKey()
             obj.Init(self._tab.Bytes, x)
             return obj

{vast_flatbuf → vastdb/vast_flatbuf}/org/apache/arrow/computeir/flatbuf/CaseFragment.py

@@ -30,7 +30,7 @@ class CaseFragment(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from vast_flatbuf.org.apache.arrow.computeir.flatbuf.Expression import Expression
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.Expression import Expression
             obj = Expression()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -41,7 +41,7 @@ class CaseFragment(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from vast_flatbuf.org.apache.arrow.computeir.flatbuf.Expression import Expression
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.Expression import Expression
             obj = Expression()
             obj.Init(self._tab.Bytes, x)
             return obj

{vast_flatbuf → vastdb/vast_flatbuf}/org/apache/arrow/computeir/flatbuf/Cast.py

@@ -31,7 +31,7 @@ class Cast(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from vast_flatbuf.org.apache.arrow.computeir.flatbuf.Expression import Expression
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.Expression import Expression
             obj = Expression()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -47,7 +47,7 @@ class Cast(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from vast_flatbuf.org.apache.arrow.flatbuf.Field import Field
+            from vastdb.vast_flatbuf.org.apache.arrow.flatbuf.Field import Field
             obj = Field()
             obj.Init(self._tab.Bytes, x)
             return obj