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

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

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

@@ -33,7 +33,7 @@ class ConditionalCase(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.CaseFragment import CaseFragment
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.CaseFragment import CaseFragment
             obj = CaseFragment()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -61,7 +61,7 @@ class ConditionalCase(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/Filter.py

@@ -32,7 +32,7 @@ class Filter(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 Filter(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
@@ -58,7 +58,7 @@ class Filter(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         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/Grouping.py

@@ -33,7 +33,7 @@ class Grouping(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

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

@@ -32,7 +32,7 @@ class Join(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 Join(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
@@ -56,7 +56,7 @@ class Join(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         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
@@ -70,7 +70,7 @@ class Join(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
         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/KeyValue.py

@@ -29,7 +29,7 @@ class KeyValue(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.Literal import Literal
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.Literal import Literal
             obj = Literal()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -40,7 +40,7 @@ class KeyValue(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.Literal import Literal
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.Literal import Literal
             obj = Literal()
             obj.Init(self._tab.Bytes, x)
             return obj

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

@@ -32,7 +32,7 @@ class Limit(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 Limit(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

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

@@ -31,7 +31,7 @@ class ListLiteral(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.Literal import Literal
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.Literal import Literal
             obj = Literal()
             obj.Init(self._tab.Bytes, x)
             return obj

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

@@ -48,7 +48,7 @@ class Literal(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         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

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

@@ -33,7 +33,7 @@ class LiteralColumn(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.Literal import Literal
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.Literal import Literal
             obj = Literal()
             obj.Init(self._tab.Bytes, x)
             return obj

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

@@ -32,7 +32,7 @@ class LiteralRelation(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
@@ -46,7 +46,7 @@ class LiteralRelation(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.LiteralColumn import LiteralColumn
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.LiteralColumn import LiteralColumn
             obj = LiteralColumn()
             obj.Init(self._tab.Bytes, x)
             return obj

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

@@ -31,7 +31,7 @@ class MapKey(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

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

@@ -31,7 +31,7 @@ class MapLiteral(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.KeyValue import KeyValue
+            from vastdb.vast_flatbuf.org.apache.arrow.computeir.flatbuf.KeyValue import KeyValue
             obj = KeyValue()
             obj.Init(self._tab.Bytes, x)
             return obj

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

@@ -32,7 +32,7 @@ class OrderBy(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 OrderBy(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 OrderBy(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