vastdb 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

vastdb/errors.py

@@ -71,6 +71,10 @@ class ServiceUnavailable(HttpError):
     pass
 
 
+class Slowdown(ServiceUnavailable):
+    pass
+
+
 class UnexpectedError(HttpError):
     pass
 
@@ -97,6 +101,10 @@ class MissingTransaction(Missing):
     pass
 
 
+class MissingRowIdColumn(Missing):
+    pass
+
+
 class NotSupported(Exception):
     pass
 
@@ -163,6 +171,12 @@ class NotSupportedVersion(NotSupported):
     version: str
 
 
+def handle_unavailable(**kwargs):
+    if kwargs['code'] == 'SlowDown':
+        raise Slowdown(**kwargs)
+    raise ServiceUnavailable(**kwargs)
+
+
 ERROR_TYPES_MAP = {
     HttpStatus.BAD_REQUEST: BadRequest,
     HttpStatus.FOBIDDEN: Forbidden,
@@ -172,7 +186,7 @@ ERROR_TYPES_MAP = {
     HttpStatus.CONFLICT: Conflict,
     HttpStatus.INTERNAL_SERVER_ERROR: InternalServerError,
     HttpStatus.NOT_IMPLEMENTED: NotImplemented,
-    HttpStatus.SERVICE_UNAVAILABLE: ServiceUnavailable,
+    HttpStatus.SERVICE_UNAVAILABLE: handle_unavailable,
 }
 
 
@@ -205,4 +219,4 @@ def from_response(res: requests.Response):
     log.warning("RPC failed: %s", kwargs)
     status = HttpStatus(res.status_code)
     error_type = ERROR_TYPES_MAP.get(status, UnexpectedError)
-    return error_type(**kwargs)
+    return error_type(**kwargs)  # type: ignore

vastdb/internal_commands.py

@@ -130,46 +130,13 @@ def get_unit_to_flatbuff_time_unit(type):
 class Predicate:
     def __init__(self, schema: 'pa.Schema', expr: ibis.expr.types.BooleanColumn):
         self.schema = schema
+        index = itertools.count()  # used to generate leaf column positions for VAST QueryData RPC
+        # Arrow schema contains the top-level columns, where each column may include multiple subfields
+        # We use DFS is used to enumerate all the sub-columns, using `index` as an ID allocator
+        nodes = [FieldNode(field, index) for field in schema]
+        self.nodes_map = {node.field.name: node for node in nodes}
         self.expr = expr
 
-    def get_field_indexes(self, field: 'pa.Field', field_name_per_index: list) -> None:
-        field_name_per_index.append(field.name)
-
-        if isinstance(field.type, pa.StructType):
-            flat_fields = field.flatten()
-        elif isinstance(field.type, pa.MapType):
-            flat_fields = [pa.field(f'{field.name}.entries', pa.struct([field.type.key_field, field.type.item_field]))]
-        elif isinstance(field.type, pa.ListType):
-            flat_fields = [pa.field(f'{field.name}.{field.type.value_field.name}', field.type.value_field.type)]
-        else:
-            return
-
-        for flat_field in flat_fields:
-            self.get_field_indexes(flat_field, field_name_per_index)
-
-    @property
-    def field_name_per_index(self):
-        if self._field_name_per_index is None:
-            _field_name_per_index = []
-            for field in self.schema:
-                self.get_field_indexes(field, _field_name_per_index)
-            self._field_name_per_index = {field: index for index, field in enumerate(_field_name_per_index)}
-        return self._field_name_per_index
-
-    def get_projections(self, builder: 'flatbuffers.builder.Builder', field_names: Optional[List[str]] = None):
-        if field_names is None:
-            field_names = self.field_name_per_index.keys()
-        projection_fields = []
-        for field_name in field_names:
-            fb_field_index.Start(builder)
-            fb_field_index.AddPosition(builder, self.field_name_per_index[field_name])
-            offset = fb_field_index.End(builder)
-            projection_fields.append(offset)
-        fb_source.StartProjectionVector(builder, len(projection_fields))
-        for offset in reversed(projection_fields):
-            builder.PrependUOffsetTRelative(offset)
-        return builder.EndVector()
-
     def serialize(self, builder: 'flatbuffers.builder.Builder'):
         from ibis.expr.operations.generic import (
             IsNull,
@@ -178,6 +145,7 @@ class Predicate:
         )
         from ibis.expr.operations.logical import (
             And,
+            Between,
             Equals,
             Greater,
             GreaterEqual,
@@ -200,10 +168,9 @@ class Predicate:
             IsNull: self.build_is_null,
             Not: self.build_is_not_null,
             StringContains: self.build_match_substring,
+            Between: self.build_between,
         }
 
-        positions_map = dict((f.name, index) for index, f in enumerate(self.schema))  # TODO: BFS
-
         self.builder = builder
 
         offsets = []
@@ -237,6 +204,9 @@ class Predicate:
                             raise NotImplementedError(self.expr)
                         column, = not_arg.args
                         literals = (None,)
+                    elif builder_func == self.build_between:
+                        column, lower, upper = inner_op.args
+                        literals = (None,)
                     else:
                         column, arg = inner_op.args
                         if isinstance(arg, tuple):
@@ -256,12 +226,19 @@ class Predicate:
                     elif prev_field_name != field_name:
                         raise NotImplementedError(self.expr)
 
-                    column_offset = self.build_column(position=positions_map[field_name])
+                    node = self.nodes_map[field_name]
+                    # TODO: support predicate pushdown for leaf nodes (ORION-160338)
+                    if node.children:
+                        raise NotImplementedError(node.field)  # no predicate pushdown for nested columns
+                    column_offset = self.build_column(position=node.index)
                     field = self.schema.field(field_name)
                     for literal in literals:
                         args_offsets = [column_offset]
                         if literal is not None:
                             args_offsets.append(self.build_literal(field=field, value=literal.value))
+                        if builder_func == self.build_between:
+                            args_offsets.append(self.build_literal(field=field, value=lower.value))
+                            args_offsets.append(self.build_literal(field=field, value=upper.value))
 
                         inner_offsets.append(builder_func(*args_offsets))
 
@@ -556,6 +533,13 @@ class Predicate:
     def build_match_substring(self, column: int, literal: int):
         return self.build_function('match_substring', column, literal)
 
+    def build_between(self, column: int, lower: int, upper: int):
+        offsets = [
+            self.build_greater_equal(column, lower),
+            self.build_less_equal(column, upper),
+        ]
+        return self.build_and(offsets)
+
 
 class FieldNodesState:
     def __init__(self) -> None:
@@ -824,12 +808,13 @@ class VastdbApi:
         return prefix
 
     def _fill_common_headers(self, txid=0, client_tags=[], version_id=1):
-        common_headers = {'tabular-txid': str(txid), 'tabular-api-version-id': str(version_id),
-                          'tabular-client-name': 'tabular-api'}
-        for tag in client_tags:
-            common_headers['tabular-client-tags-%d' % client_tags.index(tag)] = tag
+        common_headers = {
+            'tabular-txid': str(txid),
+            'tabular-api-version-id': str(version_id),
+            'tabular-client-name': 'tabular-api'
+        }
 
-        return common_headers
+        return common_headers | {f'tabular-client-tags-{index}': tag for index, tag in enumerate(client_tags)}
 
     def _check_res(self, res, cmd="", expected_retvals=[]):
         if exc := errors.from_response(res):
@@ -937,8 +922,7 @@ class VastdbApi:
             res_headers = res.headers
             next_key = int(res_headers['tabular-next-key'])
             is_truncated = res_headers['tabular-is-truncated'] == 'true'
-            flatbuf = b''.join(res.iter_content(chunk_size=128))
-            lists = list_schemas.GetRootAs(flatbuf)
+            lists = list_schemas.GetRootAs(res.content)
             bucket_name = lists.BucketName().decode()
             if not bucket.startswith(bucket_name):
                 raise ValueError(f'bucket: {bucket} did not start from {bucket_name}')
@@ -961,8 +945,7 @@ class VastdbApi:
         res = self.session.get(self._api_prefix(bucket=bucket, command="list", url_params=url_params), headers={}, stream=True)
         self._check_res(res, "list_snapshots")
 
-        out = b''.join(res.iter_content(chunk_size=128))
-        xml_str = out.decode()
+        xml_str = res.content.decode()
         xml_dict = xmltodict.parse(xml_str)
         list_res = xml_dict['ListBucketResult']
         is_truncated = list_res['IsTruncated'] == 'true'
@@ -1044,8 +1027,7 @@ class VastdbApi:
         res = self.session.get(self._api_prefix(bucket=bucket, schema=schema, table=name, command="stats", url_params=url_params), headers=headers)
         self._check_res(res, "get_table_stats", expected_retvals)
 
-        flatbuf = b''.join(res.iter_content(chunk_size=128))
-        stats = get_table_stats.GetRootAs(flatbuf)
+        stats = get_table_stats.GetRootAs(res.content)
         num_rows = stats.NumRows()
         size_in_bytes = stats.SizeInBytes()
         is_external_rowid_alloc = stats.IsExternalRowidAlloc()
@@ -1144,8 +1126,7 @@ class VastdbApi:
             res_headers = res.headers
             next_key = int(res_headers['tabular-next-key'])
             is_truncated = res_headers['tabular-is-truncated'] == 'true'
-            flatbuf = b''.join(res.iter_content(chunk_size=128))
-            lists = list_tables.GetRootAs(flatbuf)
+            lists = list_tables.GetRootAs(res.content)
             bucket_name = lists.BucketName().decode()
             schema_name = lists.SchemaName().decode()
             if not bucket.startswith(bucket_name):  # ignore snapshot name
@@ -1273,11 +1254,7 @@ class VastdbApi:
             next_key = int(res_headers['tabular-next-key'])
             is_truncated = res_headers['tabular-is-truncated'] == 'true'
             count = int(res_headers['tabular-list-count'])
-            columns = []
-            if not count_only:
-                schema_buf = b''.join(res.iter_content(chunk_size=128))
-                schema_out = pa.ipc.open_stream(schema_buf).schema
-                columns = schema_out
+            columns = [] if count_only else pa.ipc.open_stream(res.content).schema
 
             return columns, next_key, is_truncated, count
 
@@ -1578,8 +1555,7 @@ class VastdbApi:
         headers['Content-Length'] = str(len(record_batch))
         res = self.session.post(self._api_prefix(bucket=bucket, schema=schema, table=table, command="rows"),
                                 data=record_batch, headers=headers, stream=True)
-        self._check_res(res, "insert_rows", expected_retvals)
-        res.raw.read()  # flush the response
+        return self._check_res(res, "insert_rows", expected_retvals)
 
     def update_rows(self, bucket, schema, table, record_batch, txid=0, client_tags=[], expected_retvals=[]):
         """
@@ -1678,8 +1654,7 @@ class VastdbApi:
         res = self.session.get(self._api_prefix(bucket=bucket, schema=schema, table=table, command="projection-stats", url_params=url_params),
                                headers=headers)
         if res.status_code == 200:
-            flatbuf = b''.join(res.iter_content(chunk_size=128))
-            stats = get_projection_table_stats.GetRootAs(flatbuf)
+            stats = get_projection_table_stats.GetRootAs(res.content)
             num_rows = stats.NumRows()
             size_in_bytes = stats.SizeInBytes()
             dirty_blocks_percentage = stats.DirtyBlocksPercentage()
@@ -1765,8 +1740,7 @@ class VastdbApi:
             next_key = int(res_headers['tabular-next-key'])
             is_truncated = res_headers['tabular-is-truncated'] == 'true'
             count = int(res_headers['tabular-list-count'])
-            flatbuf = b''.join(res.iter_content(chunk_size=128))
-            lists = list_projections.GetRootAs(flatbuf)
+            lists = list_projections.GetRootAs(res.content)
             bucket_name = lists.BucketName().decode()
             schema_name = lists.SchemaName().decode()
             table_name = lists.TableName().decode()
@@ -1813,13 +1787,8 @@ class VastdbApi:
             next_key = int(res_headers['tabular-next-key'])
             is_truncated = res_headers['tabular-is-truncated'] == 'true'
             count = int(res_headers['tabular-list-count'])
-            columns = []
-            if not count_only:
-                schema_buf = b''.join(res.iter_content(chunk_size=128))
-                schema_out = pa.ipc.open_stream(schema_buf).schema
-                for f in schema_out:
-                    columns.append([f.name, f.type, f.metadata])
-                #   sort_type = f.metadata[b'VAST:sort_type'].decode()
+            columns = [] if count_only else [[f.name, f.type, f.metadata] for f in
+                                             pa.ipc.open_stream(res.content).schema]
 
             return columns, next_key, is_truncated, count
 
@@ -2107,6 +2076,13 @@ class QueryDataRequest:
         self.response_parser = response_parser
 
 
+def get_response_schema(schema: 'pa.Schema' = pa.schema([]), field_names: Optional[List[str]] = None):
+    if field_names is None:
+        field_names = [field.name for field in schema]
+
+    return pa.schema([schema.field(name) for name in field_names])
+
+
 def build_query_data_request(schema: 'pa.Schema' = pa.schema([]), predicate: ibis.expr.types.BooleanColumn = None, field_names: Optional[List[str]] = None):
     builder = flatbuffers.Builder(1024)
 
@@ -2127,13 +2103,11 @@ def build_query_data_request(schema: 'pa.Schema' = pa.schema([]), predicate: ibi
     filter_obj = predicate.serialize(builder)
 
     parser = QueryDataParser(schema)
-    fields_map = {node.field.name: node.field for node in parser.nodes}
     leaves_map = {node.field.name: [leaf.index for leaf in node._iter_leaves()] for node in parser.nodes}
 
-    if field_names is None:
-        field_names = [field.name for field in schema]
+    response_schema = get_response_schema(schema, field_names)
+    field_names = [field.name for field in response_schema]
 
-    response_schema = pa.schema([fields_map[name] for name in field_names])
     projection_fields = []
     for field_name in field_names:
         # TODO: only root-level projection pushdown is supported (i.e. no support for SELECT s.x FROM t)

vastdb/session.py

@@ -26,11 +26,16 @@ class Features:
         if self.vast_version < (5, 2):
             raise errors.NotSupportedVersion("import_table requires 5.2+", self.vast_version)
 
+    def check_return_row_ids(self):
+        """Check if insert/update/delete can return the row_ids."""
+        if self.vast_version < (5, 1):
+            raise errors.NotSupportedVersion("return_row_ids requires 5.1+", self.vast_version)
+
 
 class Session:
     """VAST database session."""
 
-    def __init__(self, access=None, secret=None, endpoint=None):
+    def __init__(self, access=None, secret=None, endpoint=None, ssl_verify=True):
         """Connect to a VAST Database endpoint, using specified credentials."""
         if access is None:
             access = os.environ['AWS_ACCESS_KEY_ID']
@@ -39,7 +44,7 @@ class Session:
         if endpoint is None:
             endpoint = os.environ['AWS_S3_ENDPOINT_URL']
 
-        self.api = internal_commands.VastdbApi(endpoint, access, secret)
+        self.api = internal_commands.VastdbApi(endpoint, access, secret, ssl_verify=ssl_verify)
         version_tuple = tuple(int(part) for part in self.api.vast_version.split('.'))
         self.features = Features(version_tuple)
         self.s3 = boto3.client('s3',

vastdb/table.py

@@ -7,10 +7,12 @@ import queue
 from dataclasses import dataclass, field
 from math import ceil
 from threading import Event
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
+import backoff
 import ibis
 import pyarrow as pa
+import requests
 
 from . import errors, internal_commands, schema, util
 
@@ -18,10 +20,14 @@ log = logging.getLogger(__name__)
 
 
 INTERNAL_ROW_ID = "$row_id"
+INTERNAL_ROW_ID_FIELD = pa.field(INTERNAL_ROW_ID, pa.uint64())
+
 MAX_ROWS_PER_BATCH = 512 * 1024
 # for insert we need a smaller limit due to response amplification
 # for example insert of 512k uint8 result in 512k*8bytes response since row_ids are uint64
 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)
 
 
 @dataclass
@@ -34,19 +40,45 @@ class TableStats:
     endpoints: Tuple[str, ...] = ()
 
 
+RETRIABLE_ERRORS = (
+    errors.Slowdown,
+    requests.exceptions.ConnectionError,
+)
+
+
 @dataclass
 class QueryConfig:
     """Query execution configiration."""
 
+    # allows server-side parallel processing by issuing multiple reads concurrently for a single RPC
     num_sub_splits: int = 4
+
+    # used to split the table into disjoint subsets of rows, to be processed concurrently using multiple RPCs
     num_splits: int = 1
+
+    # each endpoint will be handled by a separate worker thread
+    # a single endpoint can be specified more than once to benefit from multithreaded execution
     data_endpoints: Optional[List[str]] = None
+
+    # a subsplit fiber will finish after sending this number of rows back to the client
     limit_rows_per_sub_split: int = 128 * 1024
+
+    # each fiber will read the following number of rowgroups coninuously before skipping
+    # in order to use semi-sorted projections this value must be 8
     num_row_groups_per_sub_split: int = 8
+
+    # can be disabled for benchmarking purposes
     use_semi_sorted_projections: bool = True
+
+    # used to estimate the number of splits, given the table rows' count
     rows_per_split: int = 4000000
+
+    # used for worker threads' naming
     query_id: str = ""
 
+    # allows retrying QueryData when the server is overloaded
+    backoff_func: Any = field(default=backoff.on_exception(backoff.expo, RETRIABLE_ERRORS, max_tries=10))
+
 
 @dataclass
 class ImportConfig:
@@ -72,7 +104,8 @@ class SelectSplitState:
         Can be called repeatedly, to allow pagination.
         """
         while not self.done:
-            response = api.query_data(
+            query_with_backoff = self.config.backoff_func(api.query_data)
+            response = query_with_backoff(
                             bucket=self.table.bucket.name,
                             schema=self.table.schema.name,
                             table=self.table.name,
@@ -263,7 +296,7 @@ class Table:
         return TableStats(**stats_tuple._asdict())
 
     def select(self, columns: Optional[List[str]] = None,
-               predicate: ibis.expr.types.BooleanColumn = None,
+               predicate: Union[ibis.expr.types.BooleanColumn, ibis.common.deferred.Deferred] = None,
                config: Optional[QueryConfig] = None,
                *,
                internal_row_id: bool = False) -> pa.RecordBatchReader:
@@ -291,11 +324,20 @@ class Table:
 
         query_schema = self.arrow_schema
         if internal_row_id:
-            queried_fields = [pa.field(INTERNAL_ROW_ID, pa.uint64())]
+            queried_fields = [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)
 
+        if predicate is True:
+            predicate = None
+        if predicate is False:
+            response_schema = internal_commands.get_response_schema(schema=query_schema, field_names=columns)
+            return pa.RecordBatchReader.from_batches(response_schema, [])
+
+        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)
+
         query_data_request = internal_commands.build_query_data_request(
             schema=query_schema,
             predicate=predicate,
@@ -385,27 +427,68 @@ class Table:
 
         return pa.RecordBatchReader.from_batches(query_data_request.response_schema, batches_iterator())
 
-    def insert(self, rows: pa.RecordBatch) -> pa.RecordBatch:
+    def insert_in_column_batches(self, rows: pa.RecordBatch):
+        """Split the RecordBatch into max_columns that can be inserted in single RPC.
+
+        Insert first MAX_COLUMN_IN_BATCH columns and get the row_ids. Then loop on the rest of the columns and
+        update in groups of MAX_COLUMN_IN_BATCH.
+        """
+        column_record_batch = pa.RecordBatch.from_arrays([_combine_chunks(rows.column(i)) for i in range(0, MAX_COLUMN_IN_BATCH)],
+                                                         schema=pa.schema([rows.schema.field(i) for i in range(0, MAX_COLUMN_IN_BATCH)]))
+        row_ids = self.insert(rows=column_record_batch)  # type: ignore
+
+        columns_names = [field.name for field in rows.schema]
+        columns = list(rows.schema)
+        arrays = [_combine_chunks(rows.column(i)) for i in range(len(rows.schema))]
+        for start in range(MAX_COLUMN_IN_BATCH, len(rows.schema), MAX_COLUMN_IN_BATCH):
+            end = start + MAX_COLUMN_IN_BATCH if start + MAX_COLUMN_IN_BATCH < len(rows.schema) else len(rows.schema)
+            columns_name_chunk = columns_names[start:end]
+            columns_chunks = columns[start:end]
+            arrays_chunks = arrays[start:end]
+            columns_chunks.append(INTERNAL_ROW_ID_FIELD)
+            arrays_chunks.append(row_ids.to_pylist())
+            column_record_batch = pa.RecordBatch.from_arrays(arrays_chunks, schema=pa.schema(columns_chunks))
+            self.update(rows=column_record_batch, columns=columns_name_chunk)
+        return row_ids
+
+    def insert(self, rows: pa.RecordBatch):
         """Insert a RecordBatch into this table."""
         if self._imports_table:
             raise errors.NotSupportedCommand(self.bucket.name, self.schema.name, self.name)
-        serialized_slices = util.iter_serialized_slices(rows, MAX_INSERT_ROWS_PER_PATCH)
-        for slice in serialized_slices:
-            self.tx._rpc.api.insert_rows(self.bucket.name, self.schema.name, self.name, record_batch=slice,
-                                               txid=self.tx.txid)
+        try:
+            row_ids = []
+            serialized_slices = util.iter_serialized_slices(rows, MAX_INSERT_ROWS_PER_PATCH)
+            for slice in serialized_slices:
+                res = self.tx._rpc.api.insert_rows(self.bucket.name, self.schema.name, self.name, record_batch=slice,
+                                                   txid=self.tx.txid)
+                (batch,) = pa.RecordBatchStreamReader(res.raw)
+                row_ids.append(batch[INTERNAL_ROW_ID])
+            try:
+                self.tx._rpc.features.check_return_row_ids()
+            except errors.NotSupportedVersion:
+                return  # type: ignore
+            return pa.chunked_array(row_ids)
+        except errors.TooWideRow:
+            self.tx._rpc.features.check_return_row_ids()
+            return self.insert_in_column_batches(rows)
 
     def update(self, rows: Union[pa.RecordBatch, pa.Table], columns: Optional[List[str]] = None) -> None:
         """Update a subset of cells in this table.
 
-        Row IDs are specified using a special field (named "$row_id" of uint64 type).
+        Row IDs are specified using a special field (named "$row_id" of uint64 type) - this function assume that this
+        special field is part of arguments.
 
         A subset of columns to be updated can be specified via the `columns` argument.
         """
         if self._imports_table:
             raise errors.NotSupportedCommand(self.bucket.name, self.schema.name, self.name)
+        try:
+            rows_chunk = rows[INTERNAL_ROW_ID]
+        except KeyError:
+            raise errors.MissingRowIdColumn
         if columns is not None:
             update_fields = [(INTERNAL_ROW_ID, pa.uint64())]
-            update_values = [_combine_chunks(rows[INTERNAL_ROW_ID])]
+            update_values = [_combine_chunks(rows_chunk)]
             for col in columns:
                 update_fields.append(rows.field(col))
                 update_values.append(_combine_chunks(rows[col]))
@@ -424,8 +507,14 @@ class Table:
 
         Row IDs are specified using a special field (named "$row_id" of uint64 type).
         """
+        if self._imports_table:
+            raise errors.NotSupportedCommand(self.bucket.name, self.schema.name, self.name)
+        try:
+            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())]),
-                                         data=[_combine_chunks(rows[INTERNAL_ROW_ID])])
+                                         data=[_combine_chunks(rows_chunk)])
 
         serialized_slices = util.iter_serialized_slices(delete_rows_rb, MAX_ROWS_PER_BATCH)
         for slice in serialized_slices:

vastdb/tests/test_nested.py

@@ -1,11 +1,15 @@
+import functools
 import itertools
+import operator
 
 import pyarrow as pa
+import pyarrow.compute as pc
+import pytest
 
 from .util import prepare_data
 
 
-def test_nested(session, clean_bucket_name):
+def test_nested_select(session, clean_bucket_name):
     columns = pa.schema([
         ('l', pa.list_(pa.int8())),
         ('m', pa.map_(pa.utf8(), pa.float64())),
@@ -26,3 +30,73 @@ def test_nested(session, clean_bucket_name):
             for cols in itertools.permutations(names, n):
                 actual = pa.Table.from_batches(t.select(columns=cols))
                 assert actual == expected.select(cols)
+
+
+def test_nested_filter(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())])),
+        ('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}, None, {'x': 2, 'y': 3}, {'x': None, 'y': 4}],
+        [None, 1, 2, 3],
+    ])
+
+    with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
+        actual = pa.Table.from_batches(t.select())
+        assert actual == expected
+
+        names = list('xyzw')
+        for n in range(1, len(names) + 1):
+            for cols in itertools.permutations(names, n):
+                ibis_predicate = functools.reduce(
+                    operator.and_,
+                    (t[col] > 2 for col in cols))
+                actual = pa.Table.from_batches(t.select(predicate=ibis_predicate), t.arrow_schema)
+
+                arrow_predicate = functools.reduce(
+                    operator.and_,
+                    (pc.field(col) > 2 for col in cols))
+                assert actual == expected.filter(arrow_predicate)
+
+
+def test_nested_unsupported_filter(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())])),
+        ('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}, None, {'x': 2, 'y': 3}, {'x': None, 'y': 4}],
+        [None, 1, 2, 3],
+    ])
+
+    with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
+
+        with pytest.raises(NotImplementedError):
+            list(t.select(predicate=(t['l'].isnull())))
+
+        with pytest.raises(NotImplementedError):
+            list(t.select(predicate=(t['m'].isnull())))
+
+        with pytest.raises(NotImplementedError):
+            list(t.select(predicate=(t['s'].isnull())))

vastdb/tests/test_tables.py

@@ -7,6 +7,7 @@ import time
 from contextlib import closing
 from tempfile import NamedTemporaryFile
 
+import ibis
 import pyarrow as pa
 import pyarrow.compute as pc
 import pyarrow.parquet as pq
@@ -71,6 +72,16 @@ def test_tables(session, clean_bucket_name):
         }
 
 
+def test_insert_wide_row(session, clean_bucket_name):
+    columns = pa.schema([pa.field(f's{i}', pa.utf8()) for i in range(500)])
+    data = [['a' * 10**4] for i in range(500)]
+    expected = pa.table(schema=columns, data=data)
+
+    with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
+        actual = pa.Table.from_batches(t.select())
+        assert actual == expected
+
+
 def test_exists(session, clean_bucket_name):
     with session.transaction() as tx:
         s = tx.bucket(clean_bucket_name).create_schema('s1')
@@ -205,46 +216,47 @@ def test_types(session, clean_bucket_name):
         [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:
+    with prepare_data(session, clean_bucket_name, 's', 't', expected) as table:
         def select(predicate):
-            return pa.Table.from_batches(t.select(predicate=predicate))
+            return pa.Table.from_batches(table.select(predicate=predicate))
 
         assert select(None) == expected
-        assert select(t['tb'] == False) == expected.filter(pc.field('tb') == False)  # noqa: E712
-        assert select(t['a1'] == 2) == expected.filter(pc.field('a1') == 2)
-        assert select(t['a2'] == 2000) == expected.filter(pc.field('a2') == 2000)
-        assert select(t['a4'] == 222111122) == expected.filter(pc.field('a4') == 222111122)
-        assert select(t['b'] == 1.5) == expected.filter(pc.field('b') == 1.5)
-        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")
+        for t in [table, ibis._]:
+            assert select(t['tb'] == False) == expected.filter(pc.field('tb') == False)  # noqa: E712
+            assert select(t['a1'] == 2) == expected.filter(pc.field('a1') == 2)
+            assert select(t['a2'] == 2000) == expected.filter(pc.field('a2') == 2000)
+            assert select(t['a4'] == 222111122) == expected.filter(pc.field('a4') == 222111122)
+            assert select(t['b'] == 1.5) == expected.filter(pc.field('b') == 1.5)
+            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")
 
-        date_literal = dt.date(2024, 4, 10)
-        assert select(t['date'] == date_literal) == expected.filter(pc.field('date') == date_literal)
+            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)
+            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, 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['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)
+            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)
+            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, 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['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)
+            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):
@@ -260,57 +272,63 @@ def test_filters(session, clean_bucket_name):
         ['a', 'bb', 'ccc', None, 'xyz'],
     ])
 
-    with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
+    with prepare_data(session, clean_bucket_name, 's', 't', expected) as table:
         def select(predicate):
-            return pa.Table.from_batches(t.select(predicate=predicate), t.arrow_schema)
+            return pa.Table.from_batches(table.select(predicate=predicate), table.arrow_schema)
 
         assert select(None) == expected
-
-        assert select(t['a'] > 222) == expected.filter(pc.field('a') > 222)
-        assert select(t['a'] < 222) == expected.filter(pc.field('a') < 222)
-        assert select(t['a'] == 222) == expected.filter(pc.field('a') == 222)
-        assert select(t['a'] != 222) == expected.filter(pc.field('a') != 222)
-        assert select(t['a'] <= 222) == expected.filter(pc.field('a') <= 222)
-        assert select(t['a'] >= 222) == expected.filter(pc.field('a') >= 222)
-
-        assert select(t['b'] > 1.5) == expected.filter(pc.field('b') > 1.5)
-        assert select(t['b'] < 1.5) == expected.filter(pc.field('b') < 1.5)
-        assert select(t['b'] == 1.5) == expected.filter(pc.field('b') == 1.5)
-        assert select(t['b'] != 1.5) == expected.filter(pc.field('b') != 1.5)
-        assert select(t['b'] <= 1.5) == expected.filter(pc.field('b') <= 1.5)
-        assert select(t['b'] >= 1.5) == expected.filter(pc.field('b') >= 1.5)
-
-        assert select(t['s'] > 'bb') == expected.filter(pc.field('s') > 'bb')
-        assert select(t['s'] < 'bb') == expected.filter(pc.field('s') < 'bb')
-        assert select(t['s'] == 'bb') == expected.filter(pc.field('s') == 'bb')
-        assert select(t['s'] != 'bb') == expected.filter(pc.field('s') != 'bb')
-        assert select(t['s'] <= 'bb') == expected.filter(pc.field('s') <= 'bb')
-        assert select(t['s'] >= 'bb') == expected.filter(pc.field('s') >= 'bb')
-
-        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['b'] < 2.5)) == expected.filter((pc.field('a') > 111) & (pc.field('b') < 2.5))
-        assert select((t['a'] > 111) & (t['a'] < 333)) == expected.filter((pc.field('a') > 111) & (pc.field('a') < 333))
-
-        assert select((t['a'] > 111) | (t['a'] < 333)) == expected.filter((pc.field('a') > 111) | (pc.field('a') < 333))
-        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['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'))
-        assert select((t['s'].isnull()) & (t['b'] == 3.5))  == expected.filter((pc.field('s').is_null()) & (pc.field('b') == 3.5))
-
-        assert select(~t['s'].isnull()) == expected.filter(~pc.field('s').is_null())
-        assert select(t['s'].contains('b')) == expected.filter(pc.field('s') == 'bb')
-        assert select(t['s'].contains('y')) == expected.filter(pc.field('s') == 'xyz')
-
-        assert select(t['a'].isin([555])) == expected.filter(pc.field('a').isin([555]))
-        assert select(t['a'].isin([111, 222, 999])) == expected.filter(pc.field('a').isin([111, 222, 999]))
-        assert select((t['a'] == 111) | t['a'].isin([333, 444]) | (t['a'] > 600)) == expected.filter((pc.field('a') == 111) | pc.field('a').isin([333, 444]) | (pc.field('a') > 600))
-
-        with pytest.raises(NotImplementedError):
-            select(t['a'].isin([]))
+        assert select(True) == expected
+        assert select(False) == pa.Table.from_batches([], schema=columns)
+
+        for t in [table, ibis._]:
+            assert select(t['a'].between(222, 444)) == expected.filter((pc.field('a') >= 222) & (pc.field('a') <= 444))
+            assert select((t['a'].between(222, 444)) & (t['b'] > 2.5)) == expected.filter((pc.field('a') >= 222) & (pc.field('a') <= 444) & (pc.field('b') > 2.5))
+
+            assert select(t['a'] > 222) == expected.filter(pc.field('a') > 222)
+            assert select(t['a'] < 222) == expected.filter(pc.field('a') < 222)
+            assert select(t['a'] == 222) == expected.filter(pc.field('a') == 222)
+            assert select(t['a'] != 222) == expected.filter(pc.field('a') != 222)
+            assert select(t['a'] <= 222) == expected.filter(pc.field('a') <= 222)
+            assert select(t['a'] >= 222) == expected.filter(pc.field('a') >= 222)
+
+            assert select(t['b'] > 1.5) == expected.filter(pc.field('b') > 1.5)
+            assert select(t['b'] < 1.5) == expected.filter(pc.field('b') < 1.5)
+            assert select(t['b'] == 1.5) == expected.filter(pc.field('b') == 1.5)
+            assert select(t['b'] != 1.5) == expected.filter(pc.field('b') != 1.5)
+            assert select(t['b'] <= 1.5) == expected.filter(pc.field('b') <= 1.5)
+            assert select(t['b'] >= 1.5) == expected.filter(pc.field('b') >= 1.5)
+
+            assert select(t['s'] > 'bb') == expected.filter(pc.field('s') > 'bb')
+            assert select(t['s'] < 'bb') == expected.filter(pc.field('s') < 'bb')
+            assert select(t['s'] == 'bb') == expected.filter(pc.field('s') == 'bb')
+            assert select(t['s'] != 'bb') == expected.filter(pc.field('s') != 'bb')
+            assert select(t['s'] <= 'bb') == expected.filter(pc.field('s') <= 'bb')
+            assert select(t['s'] >= 'bb') == expected.filter(pc.field('s') >= 'bb')
+
+            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['b'] < 2.5)) == expected.filter((pc.field('a') > 111) & (pc.field('b') < 2.5))
+            assert select((t['a'] > 111) & (t['a'] < 333)) == expected.filter((pc.field('a') > 111) & (pc.field('a') < 333))
+
+            assert select((t['a'] > 111) | (t['a'] < 333)) == expected.filter((pc.field('a') > 111) | (pc.field('a') < 333))
+            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['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'))
+            assert select((t['s'].isnull()) & (t['b'] == 3.5))  == expected.filter((pc.field('s').is_null()) & (pc.field('b') == 3.5))
+
+            assert select(~t['s'].isnull()) == expected.filter(~pc.field('s').is_null())
+            assert select(t['s'].contains('b')) == expected.filter(pc.field('s') == 'bb')
+            assert select(t['s'].contains('y')) == expected.filter(pc.field('s') == 'xyz')
+
+            assert select(t['a'].isin([555])) == expected.filter(pc.field('a').isin([555]))
+            assert select(t['a'].isin([111, 222, 999])) == expected.filter(pc.field('a').isin([111, 222, 999]))
+            assert select((t['a'] == 111) | t['a'].isin([333, 444]) | (t['a'] > 600)) == expected.filter((pc.field('a') == 111) | pc.field('a').isin([333, 444]) | (pc.field('a') > 600))
+
+            with pytest.raises(NotImplementedError):
+                select(t['a'].isin([]))
 
 
 def test_parquet_export(session, clean_bucket_name):
@@ -331,7 +349,8 @@ def test_parquet_export(session, clean_bucket_name):
             ['a', 'b'],
         ])
         expected = pa.Table.from_batches([rb])
-        t.insert(rb)
+        rb = t.insert(rb)
+        assert rb.to_pylist() == [0, 1]
         actual = pa.Table.from_batches(t.select())
         assert actual == expected
 

vastdb/tests/util.py

@@ -9,7 +9,9 @@ def prepare_data(session, clean_bucket_name, schema_name, table_name, arrow_tabl
     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)
+        row_ids_array = t.insert(arrow_table)
+        row_ids = row_ids_array.to_pylist()
+        assert row_ids == list(range(arrow_table.num_rows))
         yield t
         t.drop()
         s.drop()

vastdb/transaction.py

@@ -63,7 +63,7 @@ class Transaction:
         except botocore.exceptions.ClientError as e:
             log.warning("res: %s", e.response)
             if e.response['Error']['Code'] == '404':
-                raise errors.MissingBucket(name)
+                raise errors.MissingBucket(name) from e
             raise
         return bucket.Bucket(name, self)
 

{vastdb-0.1.3.dist-info → vastdb-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vastdb
-Version: 0.1.3
+Version: 0.1.5
 Summary: VAST Data SDK
 Home-page: https://github.com/vast-data/vastdb_sdk
 Author: VAST DATA
@@ -25,6 +25,7 @@ Requires-Dist: ibis-framework ==8.0.0
 Requires-Dist: pyarrow
 Requires-Dist: requests
 Requires-Dist: xmltodict
+Requires-Dist: backoff ==2.2.1
 
 
 `vastdb` is a Python-based SDK designed for interacting

{vastdb-0.1.3.dist-info → vastdb-0.1.5.dist-info}/RECORD

@@ -151,27 +151,27 @@ vast_flatbuf/tabular/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 vastdb/__init__.py,sha256=cMJtZuJ0IL9aKyM3DUWqTCzuP1H1MXXVivKKE1-q0DY,292
 vastdb/bucket.py,sha256=4rPEm9qlPTg7ccWO6VGmd4LKb8w-BDhJYwzXGjn03sc,3566
 vastdb/conftest.py,sha256=pKpo_46Vq4QHzTDQAFxasrVhnZ2V2L-y6IMLxojxaFM,2132
-vastdb/errors.py,sha256=vKWoq1yXrHyafMWwJgW_sQkSxQYxlI1JbTVCLz5Xi9Y,3793
-vastdb/internal_commands.py,sha256=ZD2YXYvZ3lJWYzZU0oHtv8G3lNtDQUF0e8yg8813Xt4,99575
+vastdb/errors.py,sha256=fj8IlPnGi1lbJWIl1-8MSjLavL9bYQ-YUoboWbXCo54,4047
+vastdb/internal_commands.py,sha256=kIdkLHabW8r4-GSygGl1Gdrr4puxD79WPO8Jkx8aszg,98490
 vastdb/schema.py,sha256=ql4TPB1W_FQ_BHov3CKHI8JX3krXMlcKWz7dTrjpQ1w,3346
-vastdb/session.py,sha256=ciYS8Je2cRpuaAEE6Wjk79VsW0KAPdnRB2cqfxFCjis,2323
-vastdb/table.py,sha256=xnSTWUUa0QHzXC5MUQWsGT1fsG8yAgMLy3nrgSH4j5Q,25661
-vastdb/transaction.py,sha256=g8YTcYnsNPIhB2udbHyT5RIFB5kHnBLJcvV2CWRICwI,2845
+vastdb/session.py,sha256=UTaz1Fh3u71Bnay2r6IyCHNMDrAszbzjnwylPURzhsk,2603
+vastdb/table.py,sha256=1ikj6toITImFowI2WHiimmqSiObmTfAohCdWC89q71Y,30031
+vastdb/transaction.py,sha256=u4pJBLooZQ_YGjsRgEWVL6RPAlt3lgm5oOpPHzPcayM,2852
 vastdb/util.py,sha256=rs7nLL2Qz-OVEZDSVIqAvS-uETMq-zxQs5jBksB5-JA,4276
 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/test_duckdb.py,sha256=KDuv4PrjGEwChCGHG36xNT2JiFlBOt6K3DQ3L06Kq-A,1913
 vastdb/tests/test_imports.py,sha256=48kbJKsa_MrEXcBYQUbUDr1e9wzjG4FHQ7C3wUEQfXA,5705
-vastdb/tests/test_nested.py,sha256=3kejEvtSqV0LrUgb1QglRjrlxnKI4_AXTFw2nE7Q520,951
+vastdb/tests/test_nested.py,sha256=FHYMmaKYvqVh0NvsocUFLr2LDVlSfXZYgqUSopWOSM0,3512
 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=qoHTLX51D-0S4bMxdCpRh9gaYQd-BkZdT_agGOwFwTM,1739
-vastdb/tests/test_tables.py,sha256=joeEQ30TwKBQc-2N_qGIdviZVnQr4rs6thlNsy5s_og,26672
+vastdb/tests/test_tables.py,sha256=Q3N5P-7mOPVcfAFEfpAzomqkyCJ5gKZmfE4SUW5jehk,27859
 vastdb/tests/test_util.py,sha256=owRAU3TCKMq-kz54NRdA5wX2O_bZIHqG5ucUR77jm5k,1046
-vastdb/tests/util.py,sha256=NaCzKymEGy1xuiyMxyt2_0frKVfVk9iGrFwLf3GHjTI,435
-vastdb-0.1.3.dist-info/LICENSE,sha256=obffan7LYrq7hLHNrY7vHcn2pKUTBUYXMKu-VOAvDxU,11333
-vastdb-0.1.3.dist-info/METADATA,sha256=3h3JttUxw9oMMsxV_CVG_LMYwhgegsS9-b4gZkihrM0,1319
-vastdb-0.1.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-vastdb-0.1.3.dist-info/top_level.txt,sha256=Vsj2MKtlhPg0J4so64slQtnwjhgoPmJgcG-6YcVAwVc,20
-vastdb-0.1.3.dist-info/RECORD,,
+vastdb/tests/util.py,sha256=dpRJYbboDnlqL4qIdvScpp8--5fxRUBIcIYitrfcj9o,555
+vastdb-0.1.5.dist-info/LICENSE,sha256=obffan7LYrq7hLHNrY7vHcn2pKUTBUYXMKu-VOAvDxU,11333
+vastdb-0.1.5.dist-info/METADATA,sha256=NJzrnkyfPs4lliFamaEdJy2elLYLzYJtlCxEMRSiLtg,1350
+vastdb-0.1.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+vastdb-0.1.5.dist-info/top_level.txt,sha256=Vsj2MKtlhPg0J4so64slQtnwjhgoPmJgcG-6YcVAwVc,20
+vastdb-0.1.5.dist-info/RECORD,,