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

vastdb/bench/test_perf.py

@@ -0,0 +1,29 @@
+import logging
+import time
+
+import pyarrow as pa
+import pytest
+
+from vastdb import util
+from vastdb.table import ImportConfig, QueryConfig
+
+log = logging.getLogger(__name__)
+
+
+@pytest.mark.benchmark
+def test_bench(session, clean_bucket_name, parquets_path, crater_path):
+    files = [str(parquets_path/f) for f in (parquets_path.glob('**/*.pq'))]
+
+    with session.transaction() as tx:
+        b = tx.bucket(clean_bucket_name)
+        s = b.create_schema('s1')
+        t = util.create_table_from_files(s, 't1', files, config=ImportConfig(import_concurrency=8))
+        config = QueryConfig(num_splits=8, num_sub_splits=4)
+        s = time.time()
+        pa_table = pa.Table.from_batches(t.select(columns=['sid'], predicate=t['sid'] == 10033007, config=config))
+        e = time.time()
+        log.info("'SELECT sid from TABLE WHERE sid = 10033007' returned in %s seconds.", e-s)
+        if crater_path:
+            with open(f'{crater_path}/bench_results', 'a') as f:
+                f.write(f"'SELECT sid FROM TABLE WHERE sid = 10033007' returned in {e-s} seconds")
+        assert pa_table.num_rows == 255_075

vastdb/bucket.py

@@ -4,10 +4,10 @@ VAST S3 buckets can be used to create Database schemas and tables.
 It is possible to list and access VAST snapshots generated over a bucket.
 """
 
-from . import errors, schema, transaction
-
-from dataclasses import dataclass
 import logging
+from dataclasses import dataclass
+
+from . import errors, schema, transaction
 
 log = logging.getLogger(__name__)
 
@@ -27,18 +27,26 @@ class Bucket:
     name: str
     tx: "transaction.Transaction"
 
-    def create_schema(self, path: str) -> "schema.Schema":
+    def create_schema(self, path: str, fail_if_exists=True) -> "schema.Schema":
         """Create a new schema (a container of tables) under this bucket."""
+        if current := self.schema(path, fail_if_missing=False):
+            if fail_if_exists:
+                raise errors.SchemaExists(self.name, path)
+            else:
+                return current
         self.tx._rpc.api.create_schema(self.name, path, txid=self.tx.txid)
         log.info("Created schema: %s", path)
         return self.schema(path)
 
-    def schema(self, path: str) -> "schema.Schema":
+    def schema(self, path: str, fail_if_missing=True) -> "schema.Schema":
         """Get a specific schema (a container of tables) under this bucket."""
         s = self.schemas(path)
         log.debug("schema: %s", s)
         if not s:
-            raise errors.MissingSchema(self.name, path)
+            if fail_if_missing:
+                raise errors.MissingSchema(self.name, path)
+            else:
+                return None
         assert len(s) == 1, f"Expected to receive only a single schema, but got: {len(s)}. ({s})"
         log.debug("Found schema: %s", s[0].name)
         return s[0]

vastdb/{tests/conftest.py → conftest.py}

@@ -1,15 +1,19 @@
-import vastdb
+import os
+from pathlib import Path
 
-import pytest
 import boto3
-import os
+import pytest
+
+import vastdb
 
 
 def pytest_addoption(parser):
-    parser.addoption("--tabular-bucket-name", help="Name of the S3 bucket with Tabular enabled", default = "vastdb")
-    parser.addoption("--tabular-access-key", help="Access key with Tabular permissions (AWS_ACCESS_KEY_ID)", default = os.environ.get("AWS_ACCESS_KEY_ID", None))
-    parser.addoption("--tabular-secret-key", help="Secret key with Tabular permissions (AWS_SECRET_ACCESS_KEY)" , default = os.environ.get("AWS_SECRET_ACCESS_KEY", None))
-    parser.addoption("--tabular-endpoint-url", help="Tabular server endpoint", default = "http://localhost:9090")
+    parser.addoption("--tabular-bucket-name", help="Name of the S3 bucket with Tabular enabled", default="vastdb")
+    parser.addoption("--tabular-access-key", help="Access key with Tabular permissions (AWS_ACCESS_KEY_ID)", default=os.environ.get("AWS_ACCESS_KEY_ID", None))
+    parser.addoption("--tabular-secret-key", help="Secret key with Tabular permissions (AWS_SECRET_ACCESS_KEY)", default=os.environ.get("AWS_SECRET_ACCESS_KEY", None))
+    parser.addoption("--tabular-endpoint-url", help="Tabular server endpoint", default="http://localhost:9090")
+    parser.addoption("--data-path", help="Data files location", default=None)
+    parser.addoption("--crater-path", help="Save benchmark results in a dedicated location", default=None)
 
 
 @pytest.fixture(scope="session")
@@ -44,3 +48,13 @@ def s3(request):
         aws_access_key_id=request.config.getoption("--tabular-access-key"),
         aws_secret_access_key=request.config.getoption("--tabular-secret-key"),
         endpoint_url=request.config.getoption("--tabular-endpoint-url"))
+
+
+@pytest.fixture(scope="function")
+def parquets_path(request):
+    return Path(request.config.getoption("--data-path"))
+
+
+@pytest.fixture(scope="function")
+def crater_path(request):
+    return request.config.getoption("--crater-path")

vastdb/errors.py

@@ -1,9 +1,9 @@
 import logging
-import requests
 import xml.etree.ElementTree
-
-from enum import Enum
 from dataclasses import dataclass
+from enum import Enum
+
+import requests
 
 
 class HttpStatus(Enum):
@@ -114,6 +114,23 @@ class MissingProjection(Missing):
     projection: str
 
 
+class Exists(Exception):
+    pass
+
+
+@dataclass
+class SchemaExists(Exists):
+    bucket: str
+    schema: str
+
+
+@dataclass
+class TableExists(Exists):
+    bucket: str
+    schema: str
+    table: str
+
+
 ERROR_TYPES_MAP = {
     HttpStatus.BAD_REQUEST: BadRequest,
     HttpStatus.FOBIDDEN: Forbidden,

vastdb/internal_commands.py

@@ -1,26 +1,23 @@
+import itertools
+import json
 import logging
+import math
+import re
 import struct
 import urllib.parse
 from collections import defaultdict, namedtuple
-from datetime import datetime
 from enum import Enum
-from typing import Union, Optional, Iterator
-import ibis
-import xmltodict
-import math
-from functools import cmp_to_key
-import pyarrow.parquet as pq
+from ipaddress import IPv4Address, IPv6Address
+from typing import Iterator, Optional, Union
+
 import flatbuffers
+import ibis
 import pyarrow as pa
+import pyarrow.parquet as pq
 import requests
-import json
-import itertools
-from aws_requests_auth.aws_auth import AWSRequestsAuth
 import urllib3
-import re
-
-from . import errors
-from ipaddress import IPv4Address, IPv6Address
+import xmltodict
+from aws_requests_auth.aws_auth import AWSRequestsAuth
 
 import vast_flatbuf.org.apache.arrow.computeir.flatbuf.BinaryLiteral as fb_binary_lit
 import vast_flatbuf.org.apache.arrow.computeir.flatbuf.BooleanLiteral as fb_bool_lit
@@ -32,10 +29,10 @@ import vast_flatbuf.org.apache.arrow.computeir.flatbuf.FieldIndex as fb_field_in
 import vast_flatbuf.org.apache.arrow.computeir.flatbuf.FieldRef as fb_field_ref
 import vast_flatbuf.org.apache.arrow.computeir.flatbuf.Float32Literal as fb_float32_lit
 import vast_flatbuf.org.apache.arrow.computeir.flatbuf.Float64Literal as fb_float64_lit
+import vast_flatbuf.org.apache.arrow.computeir.flatbuf.Int8Literal as fb_int8_lit
 import vast_flatbuf.org.apache.arrow.computeir.flatbuf.Int16Literal as fb_int16_lit
 import vast_flatbuf.org.apache.arrow.computeir.flatbuf.Int32Literal as fb_int32_lit
 import vast_flatbuf.org.apache.arrow.computeir.flatbuf.Int64Literal as fb_int64_lit
-import vast_flatbuf.org.apache.arrow.computeir.flatbuf.Int8Literal as fb_int8_lit
 import vast_flatbuf.org.apache.arrow.computeir.flatbuf.Literal as fb_literal
 import vast_flatbuf.org.apache.arrow.computeir.flatbuf.Relation as fb_relation
 import vast_flatbuf.org.apache.arrow.computeir.flatbuf.RelationImpl as rel_impl
@@ -48,38 +45,47 @@ import vast_flatbuf.org.apache.arrow.flatbuf.Bool as fb_bool
 import vast_flatbuf.org.apache.arrow.flatbuf.Date as fb_date
 import vast_flatbuf.org.apache.arrow.flatbuf.Decimal as fb_decimal
 import vast_flatbuf.org.apache.arrow.flatbuf.Field as fb_field
+import vast_flatbuf.org.apache.arrow.flatbuf.FixedSizeBinary as fb_fixed_size_binary
 import vast_flatbuf.org.apache.arrow.flatbuf.FloatingPoint as fb_floating_point
 import vast_flatbuf.org.apache.arrow.flatbuf.Int as fb_int
-import vast_flatbuf.org.apache.arrow.flatbuf.Schema as fb_schema
-import vast_flatbuf.org.apache.arrow.flatbuf.Time as fb_time
-import vast_flatbuf.org.apache.arrow.flatbuf.Struct_ as fb_struct
 import vast_flatbuf.org.apache.arrow.flatbuf.List as fb_list
 import vast_flatbuf.org.apache.arrow.flatbuf.Map as fb_map
-import vast_flatbuf.org.apache.arrow.flatbuf.FixedSizeBinary as fb_fixed_size_binary
+import vast_flatbuf.org.apache.arrow.flatbuf.Schema as fb_schema
+import vast_flatbuf.org.apache.arrow.flatbuf.Struct_ as fb_struct
+import vast_flatbuf.org.apache.arrow.flatbuf.Time as fb_time
 import vast_flatbuf.org.apache.arrow.flatbuf.Timestamp as fb_timestamp
 import vast_flatbuf.org.apache.arrow.flatbuf.Utf8 as fb_utf8
 import vast_flatbuf.tabular.AlterColumnRequest as tabular_alter_column
+import vast_flatbuf.tabular.AlterProjectionTableRequest as tabular_alter_projection
 import vast_flatbuf.tabular.AlterSchemaRequest as tabular_alter_schema
 import vast_flatbuf.tabular.AlterTableRequest as tabular_alter_table
-import vast_flatbuf.tabular.AlterProjectionTableRequest as tabular_alter_projection
+import vast_flatbuf.tabular.Column as tabular_projecion_column
+import vast_flatbuf.tabular.ColumnType as tabular_proj_column_type
+import vast_flatbuf.tabular.CreateProjectionRequest as tabular_create_projection
 import vast_flatbuf.tabular.CreateSchemaRequest as tabular_create_schema
 import vast_flatbuf.tabular.ImportDataRequest as tabular_import_data
 import vast_flatbuf.tabular.S3File as tabular_s3_file
-import vast_flatbuf.tabular.CreateProjectionRequest as tabular_create_projection
-import vast_flatbuf.tabular.Column as tabular_projecion_column
-import vast_flatbuf.tabular.ColumnType as tabular_proj_column_type
-
 from vast_flatbuf.org.apache.arrow.computeir.flatbuf.Deref import Deref
-from vast_flatbuf.org.apache.arrow.computeir.flatbuf.ExpressionImpl import ExpressionImpl
+from vast_flatbuf.org.apache.arrow.computeir.flatbuf.ExpressionImpl import (
+    ExpressionImpl,
+)
 from vast_flatbuf.org.apache.arrow.computeir.flatbuf.LiteralImpl import LiteralImpl
 from vast_flatbuf.org.apache.arrow.flatbuf.DateUnit import DateUnit
 from vast_flatbuf.org.apache.arrow.flatbuf.TimeUnit import TimeUnit
 from vast_flatbuf.org.apache.arrow.flatbuf.Type import Type
+from vast_flatbuf.tabular.GetProjectionTableStatsResponse import (
+    GetProjectionTableStatsResponse as get_projection_table_stats,
+)
+from vast_flatbuf.tabular.GetTableStatsResponse import (
+    GetTableStatsResponse as get_table_stats,
+)
+from vast_flatbuf.tabular.ListProjectionsResponse import (
+    ListProjectionsResponse as list_projections,
+)
 from vast_flatbuf.tabular.ListSchemasResponse import ListSchemasResponse as list_schemas
 from vast_flatbuf.tabular.ListTablesResponse import ListTablesResponse as list_tables
-from vast_flatbuf.tabular.GetTableStatsResponse import GetTableStatsResponse as get_table_stats
-from vast_flatbuf.tabular.GetProjectionTableStatsResponse import GetProjectionTableStatsResponse as get_projection_table_stats
-from vast_flatbuf.tabular.ListProjectionsResponse import ListProjectionsResponse as list_projections
+
+from . import errors
 
 UINT64_MAX = 18446744073709551615
 
@@ -122,13 +128,6 @@ def get_unit_to_flatbuff_time_unit(type):
     return unit_to_flatbuff_time_unit[type]
 
 class Predicate:
-    unit_to_epoch = {
-        'ns': 1_000_000,
-        'us': 1_000,
-        'ms': 1,
-        's': 0.001
-    }
-
     def __init__(self, schema: 'pa.Schema', expr: ibis.expr.types.BooleanColumn):
         self.schema = schema
         self.expr = expr
@@ -173,8 +172,18 @@ class Predicate:
         return builder.EndVector()
 
     def serialize(self, builder: 'flatbuffers.builder.Builder'):
-        from ibis.expr.operations.generic import TableColumn, Literal, IsNull
-        from ibis.expr.operations.logical import Greater, GreaterEqual, Less, LessEqual, Equals, NotEquals, And, Or, Not
+        from ibis.expr.operations.generic import IsNull, Literal, TableColumn
+        from ibis.expr.operations.logical import (
+            And,
+            Equals,
+            Greater,
+            GreaterEqual,
+            Less,
+            LessEqual,
+            Not,
+            NotEquals,
+            Or,
+        )
         from ibis.expr.operations.strings import StringContains
 
         builder_map = {
@@ -403,7 +412,7 @@ class Predicate:
             field_type = fb_utf8.End(self.builder)
 
             value = self.builder.CreateString(value)
-        elif field.type.equals(pa.date32()):  # pa.date64()
+        elif field.type.equals(pa.date32()):  # pa.date64() is not supported
             literal_type = fb_date32_lit
             literal_impl = LiteralImpl.DateLiteral
 
@@ -411,37 +420,49 @@ class Predicate:
             fb_date.Start(self.builder)
             fb_date.AddUnit(self.builder, DateUnit.DAY)
             field_type = fb_date.End(self.builder)
-
-            start_date = datetime.fromtimestamp(0).date()
-            date_delta = value - start_date
-            value = date_delta.days
+            value, = pa.array([value], field.type).cast(pa.int32()).to_pylist()
         elif isinstance(field.type, pa.TimestampType):
             literal_type = fb_timestamp_lit
             literal_impl = LiteralImpl.TimestampLiteral
 
+            if field.type.equals(pa.timestamp('s')):
+                unit = TimeUnit.SECOND
+            if field.type.equals(pa.timestamp('ms')):
+                unit = TimeUnit.MILLISECOND
+            if field.type.equals(pa.timestamp('us')):
+                unit = TimeUnit.MICROSECOND
+            if field.type.equals(pa.timestamp('ns')):
+                unit = TimeUnit.NANOSECOND
+
             field_type_type = Type.Timestamp
             fb_timestamp.Start(self.builder)
-            fb_timestamp.AddUnit(self.builder, get_unit_to_flatbuff_time_unit(field.type.unit))
+            fb_timestamp.AddUnit(self.builder, unit)
             field_type = fb_timestamp.End(self.builder)
-
-            value = int(int(value) * self.unit_to_epoch[field.type.unit])
-        elif field.type.equals(pa.time32('s')) or field.type.equals(pa.time32('ms')) or field.type.equals(pa.time64('us')) or field.type.equals(pa.time64('ns')):
-
+            value, = pa.array([value], field.type).cast(pa.int64()).to_pylist()
+        elif isinstance(field.type, (pa.Time32Type, pa.Time64Type)):
             literal_type = fb_time_lit
             literal_impl = LiteralImpl.TimeLiteral
 
-            field_type_str = str(field.type)
-            start = field_type_str.index('[')
-            end = field_type_str.index(']')
-            unit = field_type_str[start + 1:end]
+            if field.type.equals(pa.time32('s')):
+                target_type = pa.int32()
+                unit = TimeUnit.SECOND
+            if field.type.equals(pa.time32('ms')):
+                target_type = pa.int32()
+                unit = TimeUnit.MILLISECOND
+            if field.type.equals(pa.time64('us')):
+                target_type = pa.int64()
+                unit = TimeUnit.MICROSECOND
+            if field.type.equals(pa.time64('ns')):
+                target_type = pa.int64()
+                unit = TimeUnit.NANOSECOND
 
             field_type_type = Type.Time
             fb_time.Start(self.builder)
             fb_time.AddBitWidth(self.builder, field.type.bit_width)
-            fb_time.AddUnit(self.builder, get_unit_to_flatbuff_time_unit(unit))
+            fb_time.AddUnit(self.builder, unit)
             field_type = fb_time.End(self.builder)
 
-            value = int(value) * self.unit_to_epoch[unit]
+            value, = pa.array([value], field.type).cast(target_type).to_pylist()
         elif field.type.equals(pa.bool_()):
             literal_type = fb_bool_lit
             literal_impl = LiteralImpl.BooleanLiteral
@@ -558,8 +579,6 @@ class FieldNode:
         # will be set during by the parser (see below)
         self.buffers = None # a list of Arrow buffers (https://arrow.apache.org/docs/format/Columnar.html#buffer-listing-for-each-layout)
         self.length = None # each array must have it's length specified (https://arrow.apache.org/docs/python/generated/pyarrow.Array.html#pyarrow.Array.from_buffers)
-        self.is_projected = False
-        self.projected_field = self.field
 
     def _iter_to_root(self) -> Iterator['FieldNode']:
         yield self
@@ -580,15 +599,13 @@ class FieldNode:
             for child in self.children:
                 yield from child._iter_leaves()
 
-    def _iter_projected_leaves(self) -> Iterator['FieldNode']:
+    def _iter_leaves(self) -> Iterator['FieldNode']:
         """Generate only leaf nodes (i.e. columns having scalar types)."""
         if not self.children:
-            if self.is_projected:
-                yield self
+            yield self
         else:
             for child in self.children:
-                if child.is_projected:
-                    yield from child._iter_projected_leaves()
+                yield from child._iter_leaves()
 
     def debug_log(self, level=0):
         """Recursively dump this node state to log."""
@@ -625,27 +642,17 @@ class FieldNode:
 
     def build(self) -> pa.Array:
         """Construct an Arrow array from the collected buffers (recursively)."""
-        children = self.children and [node.build() for node in self.children if node.is_projected]
-        _logger.debug('build: self.field.name=%s, self.projected_field.type=%s, self.length=%s, self.buffers=%s children=%s',
-                      self.field.name, self.projected_field.type, self.length, self.buffers, children)
-        result = pa.Array.from_buffers(self.projected_field.type, self.length, buffers=self.buffers, children=children)
+        children = self.children and [node.build() for node in self.children]
+        result = pa.Array.from_buffers(self.type, self.length, buffers=self.buffers, children=children)
         if self.debug:
             _logger.debug('%s result=%s', self.field, result)
         return result
 
-    def build_projected_field(self):
-        if isinstance(self.type, pa.StructType):
-            [child.build_projected_field() for child in self.children if child.is_projected]
-            self.projected_field = pa.field(self.field.name,
-                                            pa.struct([child.projected_field for child in self.children if child.is_projected]),
-                                            self.field.nullable,
-                                            self.field.metadata)
 
 class QueryDataParser:
     """Used to parse VAST QueryData RPC response."""
-    def __init__(self, arrow_schema: pa.Schema, *, debug=False, projection_positions=None):
+    def __init__(self, arrow_schema: pa.Schema, *, debug=False):
         self.arrow_schema = arrow_schema
-        self.projection_positions = projection_positions
         index = itertools.count() # used to generate leaf column positions for VAST QueryData RPC
         self.nodes = [FieldNode(field, index, debug=debug) for field in arrow_schema]
         self.debug = debug
@@ -653,24 +660,15 @@ class QueryDataParser:
             for node in self.nodes:
                 node.debug_log()
         self.leaves = [leaf for node in self.nodes for leaf in node._iter_leaves()]
-        self.mark_projected_nodes()
-        [node.build_projected_field() for node in self.nodes]
-        self.projected_leaves = [leaf for node in self.nodes for leaf in node._iter_projected_leaves()]
 
         self.leaf_offset = 0
 
-    def mark_projected_nodes(self):
-        for leaf in self.leaves:
-            if self.projection_positions is None or leaf.index in self.projection_positions:
-                for node in leaf._iter_to_root():
-                    node.is_projected = True
-
     def parse(self, column: pa.Array):
         """Parse a single column response from VAST (see FieldNode.set for details)"""
-        if not self.leaf_offset < len(self.projected_leaves):
+        if not self.leaf_offset < len(self.leaves):
             raise ValueError(f'self.leaf_offset: {self.leaf_offset} are not < '
                              f'than len(self.leaves): {len(self.leaves)}')
-        leaf = self.projected_leaves[self.leaf_offset]
+        leaf = self.leaves[self.leaf_offset]
 
         # A column response may be sent in multiple chunks, therefore we need to combine
         # it into a single chunk to allow reconstruction using `Array.from_buffers()`.
@@ -691,32 +689,19 @@ class QueryDataParser:
 
         self.leaf_offset += 1
 
-    def build(self, output_field_names=None) -> Optional[pa.Table]:
+    def build(self) -> Optional[pa.Table]:
         """Try to build the resulting Table object (if all columns were parsed)"""
-        if self.projection_positions is not None:
-            if self.leaf_offset < len(self.projection_positions):
-                return None
-        else:
-            if self.leaf_offset < len(self.leaves):
-                return None
+        if self.leaf_offset < len(self.leaves):
+            return None
 
         if self.debug:
             for node in self.nodes:
                 node.debug_log()
 
-        # sort resulting table according to the output field names
-        projected_nodes = [node for node in self.nodes if node.is_projected]
-        if output_field_names is not None:
-            def key_func(projected_node):
-                return output_field_names.index(projected_node.field.name)
-            sorted_projected_nodes = sorted(projected_nodes, key=key_func)
-        else:
-            sorted_projected_nodes = projected_nodes
-
         result = pa.Table.from_arrays(
-            arrays=[node.build() for node in sorted_projected_nodes],
-            schema = pa.schema([node.projected_field for node in sorted_projected_nodes]))
-        result.validate(full=True) # does expensive validation checks only if debug is enabled
+            arrays=[node.build() for node in self.nodes],
+            schema=self.arrow_schema)
+        result.validate(full=self.debug) # does expensive validation checks only if debug is enabled
         return result
 
 def _iter_nested_arrays(column: pa.Array) -> Iterator[pa.Array]:
@@ -1661,7 +1646,8 @@ class VastdbApi:
                                 data=record_batch, headers=headers)
         return self._check_res(res, "update_rows", expected_retvals)
 
-    def delete_rows(self, bucket, schema, table, record_batch, txid=0, client_tags=[], expected_retvals=[]):
+    def delete_rows(self, bucket, schema, table, record_batch, txid=0, client_tags=[], expected_retvals=[],
+                    delete_from_imports_table=False):
         """
         DELETE /mybucket/myschema/mytable?rows HTTP/1.1
         Content-Length: ContentLength
@@ -1673,8 +1659,10 @@ class VastdbApi:
         """
         headers = self._fill_common_headers(txid=txid, client_tags=client_tags)
         headers['Content-Length'] = str(len(record_batch))
-        res = self.session.delete(self._api_prefix(bucket=bucket, schema=schema, table=table, command="rows"),
-                               data=record_batch, headers=headers)
+        url_params = {'sub-table': IMPORTED_OBJECTS_TABLE_NAME} if delete_from_imports_table else {}
+
+        res = self.session.delete(self._api_prefix(bucket=bucket, schema=schema, table=table, command="rows", url_params=url_params),
+                                  data=record_batch, headers=headers)
         return self._check_res(res, "delete_rows", expected_retvals)
 
     def create_projection(self, bucket, schema, table, name, columns, txid=0, client_tags=[], expected_retvals=[]):
@@ -1943,18 +1931,16 @@ def parse_query_data_response(conn, schema, stream_ids=None, start_row_ids=None,
     """
     if start_row_ids is None:
         start_row_ids = {}
-    projection_positions = schema.projection_positions
-    arrow_schema = schema.arrow_schema
-    output_field_names = schema.output_field_names
-    _logger.debug(f'projection_positions={projection_positions} len(arrow_schema)={len(arrow_schema)} arrow_schema={arrow_schema}')
-    is_empty_projection = (len(projection_positions) == 0)
-    parsers = defaultdict(lambda: QueryDataParser(arrow_schema, debug=debug, projection_positions=projection_positions))  # {stream_id: QueryDataParser}
+
+    is_empty_projection = (len(schema) == 0)
+    parsers = defaultdict(lambda: QueryDataParser(schema, debug=debug))  # {stream_id: QueryDataParser}
+
     for stream_id, next_row_id, table in _iter_query_data_response_columns(conn, stream_ids):
         parser = parsers[stream_id]
         for column in table.columns:
             parser.parse(column)
 
-        parsed_table = parser.build(output_field_names)
+        parsed_table = parser.build()
         if parsed_table is not None:  # when we got all columns (and before starting a new "select_rows" cycle)
             parsers.pop(stream_id)
             if is_empty_projection:  # VAST returns an empty RecordBatch, with the correct rows' count
@@ -2042,7 +2028,7 @@ def get_field_type(builder: flatbuffers.Builder, field: pa.Field):
         fb_utf8.Start(builder)
         field_type = fb_utf8.End(builder)
 
-    elif field.type.equals(pa.date32()):  # pa.date64()
+    elif field.type.equals(pa.date32()):  # pa.date64() is not supported
         field_type_type = Type.Date
         fb_date.Start(builder)
         fb_date.AddUnit(builder, DateUnit.DAY)
@@ -2155,12 +2141,6 @@ def build_field(builder: flatbuffers.Builder, f: pa.Field, name: str):
     return fb_field.End(builder)
 
 
-class VastDBResponseSchema:
-    def __init__(self, arrow_schema, projection_positions, output_field_names):
-        self.arrow_schema = arrow_schema
-        self.projection_positions = projection_positions
-        self.output_field_names = output_field_names
-
 class QueryDataRequest:
     def __init__(self, serialized, response_schema):
         self.serialized = serialized
@@ -2187,31 +2167,17 @@ def build_query_data_request(schema: 'pa.Schema' = pa.schema([]), predicate: ibi
     filter_obj = predicate.serialize(builder)
 
     parser = QueryDataParser(schema)
-    leaves_map = {}
-    for node in parser.nodes:
-        for descendent in node._iter_nodes():
-            if descendent.parent and isinstance(descendent.parent.type, (pa.ListType, pa.MapType)):
-                continue
-            iter_from_root = reversed(list(descendent._iter_to_root()))
-            descendent_full_name = '.'.join([n.field.name for n in iter_from_root])
-            descendent_leaves = [leaf.index for leaf in descendent._iter_leaves()]
-            leaves_map[descendent_full_name] = descendent_leaves
-
-    output_field_names = None
+    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]
-    else:
-        output_field_names  = [f.split('.')[0] for f in field_names]
-        # sort projected field_names according to positions to maintain ordering according to the schema
-        def compare_field_names_by_pos(field_name1, field_name2):
-            return leaves_map[field_name1][0]-leaves_map[field_name2][0]
-        field_names = sorted(field_names, key=cmp_to_key(compare_field_names_by_pos))
 
+    response_schema = pa.schema([fields_map[name] for name in field_names])
     projection_fields = []
-    projection_positions = []
     for field_name in field_names:
+        # TODO: only root-level projection pushdown is supported (i.e. no support for SELECT s.x FROM t)
         positions = leaves_map[field_name]
-        projection_positions.extend(positions)
         for leaf_position in positions:
             fb_field_index.Start(builder)
             fb_field_index.AddPosition(builder, leaf_position)
@@ -2222,8 +2188,6 @@ def build_query_data_request(schema: 'pa.Schema' = pa.schema([]), predicate: ibi
         builder.PrependUOffsetTRelative(offset)
     projection = builder.EndVector()
 
-    response_schema = VastDBResponseSchema(schema, projection_positions, output_field_names=output_field_names)
-
     fb_source.Start(builder)
     fb_source.AddName(builder, source_name)
     fb_source.AddSchema(builder, schema_obj)

vastdb/schema.py

@@ -4,12 +4,12 @@ VAST S3 buckets can be used to create Database schemas and tables.
 It is possible to list and access VAST snapshots generated over a bucket.
 """
 
-from . import bucket, errors, schema, table
+import logging
+from dataclasses import dataclass
 
 import pyarrow as pa
 
-from dataclasses import dataclass
-import logging
+from . import bucket, errors, schema, table
 
 log = logging.getLogger(__name__)
 
@@ -26,17 +26,25 @@ class Schema:
         """VAST transaction used for this schema."""
         return self.bucket.tx
 
-    def create_table(self, table_name: str, columns: pa.Schema) -> "table.Table":
+    def create_table(self, table_name: str, columns: pa.Schema, fail_if_exists=True) -> "table.Table":
         """Create a new table under this schema."""
+        if current := self.table(table_name, fail_if_missing=False):
+            if fail_if_exists:
+                raise errors.TableExists(self.bucket.name, self.name, table_name)
+            else:
+                return current
         self.tx._rpc.api.create_table(self.bucket.name, self.name, table_name, columns, txid=self.tx.txid)
         log.info("Created table: %s", table_name)
         return self.table(table_name)
 
-    def table(self, name: str) -> "table.Table":
+    def table(self, name: str, fail_if_missing=True) -> "table.Table":
         """Get a specific table under this schema."""
         t = self.tables(table_name=name)
         if not t:
-            raise errors.MissingTable(self.bucket.name, self.name, name)
+            if fail_if_missing:
+                raise errors.MissingTable(self.bucket.name, self.name, name)
+            else:
+                return None
         assert len(t) == 1, f"Expected to receive only a single table, but got: {len(t)}. tables: {t}"
         log.debug("Found table: %s", t[0])
         return t[0]

vastdb/session.py

@@ -7,12 +7,11 @@ For more details see:
 - [Tabular identity policy with the proper permissions](https://support.vastdata.com/s/article/UUID-14322b60-d6a2-89ac-3df0-3dfbb6974182)
 """
 
-from . import internal_commands
-from . import transaction
+import os
 
 import boto3
 
-import os
+from . import internal_commands, transaction
 
 
 class Session:

vastdb/table.py

@@ -1,19 +1,22 @@
-from . import errors, schema
-from .internal_commands import build_query_data_request, parse_query_data_response, \
-    TABULAR_INVALID_ROW_ID, VastdbApi
-
-import pyarrow as pa
-import ibis
-
 import concurrent.futures
+import logging
+import os
 import queue
-from threading import Event
-from math import ceil
-
 from dataclasses import dataclass, field
+from math import ceil
+from threading import Event
 from typing import List, Union
-import logging
-import os
+
+import ibis
+import pyarrow as pa
+
+from . import errors, schema
+from .internal_commands import (
+    TABULAR_INVALID_ROW_ID,
+    VastdbApi,
+    build_query_data_request,
+    parse_query_data_response,
+)
 
 log = logging.getLogger(__name__)
 
@@ -327,7 +330,7 @@ class Table:
                         if record_batches_queue.get() is None:
                             tasks_running -= 1
 
-        return pa.RecordBatchReader.from_batches(query_data_request.response_schema.arrow_schema, batches_iterator())
+        return pa.RecordBatchReader.from_batches(query_data_request.response_schema, batches_iterator())
 
     def _combine_chunks(self, col):
         if hasattr(col, "combine_chunks"):

vastdb/tests/test_imports.py

@@ -1,14 +1,12 @@
-import pytest
-
-from tempfile import NamedTemporaryFile
 import logging
+from tempfile import NamedTemporaryFile
 
 import pyarrow as pa
 import pyarrow.parquet as pq
+import pytest
 
-from vastdb.errors import InvalidArgument, ImportFilesError
 from vastdb import util
-
+from vastdb.errors import ImportFilesError, InvalidArgument
 
 log = logging.getLogger(__name__)
 

vastdb/tests/test_nested.py

@@ -0,0 +1,28 @@
+import itertools
+
+import pyarrow as pa
+
+from .util import prepare_data
+
+
+def test_nested(session, clean_bucket_name):
+    columns = pa.schema([
+        ('l', pa.list_(pa.int8())),
+        ('m', pa.map_(pa.utf8(), pa.float64())),
+        ('s', pa.struct([('x', pa.int16()), ('y', pa.int32())])),
+    ])
+    expected = pa.table(schema=columns, data=[
+        [[1], [], [2, 3], None],
+        [None, {'a': 2.5}, {'b': 0.25, 'c': 0.025}, {}],
+        [{'x': 1, 'y': None}, None, {'x': 2, 'y': 3}, {'x': None, 'y': 4}],
+    ])
+
+    with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
+        actual = pa.Table.from_batches(t.select())
+        assert actual == expected
+
+        names = [f.name for f in columns]
+        for n in range(len(names) + 1):
+            for cols in itertools.permutations(names, n):
+                actual = pa.Table.from_batches(t.select(columns=cols))
+                assert actual == expected.select(cols)

vastdb/tests/test_projections.py

@@ -1,6 +1,7 @@
-import pyarrow as pa
 import logging
 
+import pyarrow as pa
+
 log = logging.getLogger(__name__)
 
 def test_basic_projections(session, clean_bucket_name):

vastdb/tests/test_sanity.py

@@ -1,15 +1,14 @@
-from http.server import HTTPServer, BaseHTTPRequestHandler
-from itertools import cycle
+import contextlib
 import logging
 import threading
-import contextlib
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from itertools import cycle
 
 import pytest
 import requests
 
 import vastdb
 
-
 log = logging.getLogger(__name__)
 
 

vastdb/tests/test_schemas.py

@@ -1,5 +1,7 @@
 import pytest
 
+from .. import errors
+
 
 def test_schemas(session, clean_bucket_name):
     with session.transaction() as tx:
@@ -19,6 +21,22 @@ def test_schemas(session, clean_bucket_name):
         assert b.schemas() == []
 
 
+def test_exists(session, clean_bucket_name):
+    with session.transaction() as tx:
+        b = tx.bucket(clean_bucket_name)
+        assert b.schemas() == []
+
+        s = b.create_schema('s1')
+
+        assert b.schemas() == [s]
+        with pytest.raises(errors.SchemaExists):
+            b.create_schema('s1')
+
+        assert b.schemas() == [s]
+        assert b.create_schema('s1', fail_if_exists=False) == s
+        assert b.schemas() == [s]
+
+
 def test_commits_and_rollbacks(session, clean_bucket_name):
     with session.transaction() as tx:
         b = tx.bucket(clean_bucket_name)

vastdb/tests/test_tables.py

@@ -1,41 +1,25 @@
-import duckdb
-import pytest
-import threading
+import datetime as dt
+import decimal
+import logging
 import random
+import threading
+from contextlib import closing
+from tempfile import NamedTemporaryFile
+
+import duckdb
 import pyarrow as pa
 import pyarrow.compute as pc
 import pyarrow.parquet as pq
-import decimal
-import datetime as dt
-
-from tempfile import NamedTemporaryFile
-from contextlib import contextmanager, closing
-
+import pytest
 from requests.exceptions import HTTPError
-import logging
 
-from ..table import INTERNAL_ROW_ID, QueryConfig
 from .. import errors
-
+from ..table import INTERNAL_ROW_ID, QueryConfig
+from .util import prepare_data
 
 log = logging.getLogger(__name__)
 
 
-@contextmanager
-def prepare_data(session, clean_bucket_name, schema_name, table_name, arrow_table):
-    with session.transaction() as tx:
-        s = tx.bucket(clean_bucket_name).create_schema(schema_name)
-        t = s.create_table(table_name, arrow_table.schema)
-        row_ids_array = t.insert(arrow_table)
-        row_ids = row_ids_array.to_pylist()
-        log.debug("row_ids=%s" % row_ids)
-        assert row_ids == list(range(arrow_table.num_rows))
-        yield t
-        t.drop()
-        s.drop()
-
-log = logging.getLogger(__name__)
-
 def test_tables(session, clean_bucket_name):
     columns = pa.schema([
         ('a', pa.int64()),
@@ -86,6 +70,28 @@ def test_tables(session, clean_bucket_name):
             's': ['ccc']
         }
 
+
+def test_exists(session, clean_bucket_name):
+    with session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).create_schema('s1')
+        assert s.tables() == []
+
+        t = s.create_table('t', pa.schema([('x', pa.int64())]))
+
+        assert s.tables() == [t]
+        with pytest.raises(errors.TableExists):
+            s.create_table('t', pa.schema([('x', pa.int64())]))
+
+        assert s.tables() == [t]
+        assert s.create_table('t', pa.schema([('x', pa.int64())]), fail_if_exists=False) == t
+        assert s.tables() == [t]
+        assert s.create_table('t', pa.schema([('y', pa.int64())]), fail_if_exists=False) == t
+        assert s.tables() == [t]
+        assert s.create_table('t', pa.schema([('x', pa.int64())]), fail_if_exists=False) == t
+        assert s.tables() == [t]
+
+
+
 def test_update_table(session, clean_bucket_name):
     columns = pa.schema([
         ('a', pa.int64()),
@@ -169,7 +175,14 @@ def test_types(session, clean_bucket_name):
         ('d', pa.decimal128(7, 3)),
         ('bin', pa.binary()),
         ('date', pa.date32()),
-        ('ts' ,pa.timestamp('s')),
+        ('t0', pa.time32('s')),
+        ('t3', pa.time32('ms')),
+        ('t6', pa.time64('us')),
+        ('t9', pa.time64('ns')),
+        ('ts0' ,pa.timestamp('s')),
+        ('ts3' ,pa.timestamp('ms')),
+        ('ts6' ,pa.timestamp('us')),
+        ('ts9' ,pa.timestamp('ns')),
     ])
 
     expected = pa.table(schema=columns, data=[
@@ -181,9 +194,17 @@ def test_types(session, clean_bucket_name):
         ["a", "v", "s"],
         [decimal.Decimal('110.52'), decimal.Decimal('231.15'), decimal.Decimal('3332.44')],
         [b"\x01\x02", b"\x01\x05", b"\x01\x07"],
-        [dt.datetime.now().date(), dt.datetime.now().date(), dt.datetime.now().date()],
-        [dt.datetime.fromtimestamp(10000), dt.datetime.fromtimestamp(100), dt.datetime.fromtimestamp(0)]
+        [dt.date(2024, 4, 10), dt.date(2024, 4, 11), dt.date(2024, 4, 12)],
+        [dt.time(12, 34, 56), dt.time(12, 34, 57), dt.time(12, 34, 58)],
+        [dt.time(12, 34, 56, 789000), dt.time(12, 34, 57, 789000), dt.time(12, 34, 58, 789000)],
+        [dt.time(12, 34, 56, 789789), dt.time(12, 34, 57, 789789), dt.time(12, 34, 58, 789789)],
+        [dt.time(12, 34, 56, 789789), dt.time(12, 34, 57, 789789), dt.time(12, 34, 58, 789789)],
+        [dt.datetime(2024, 4, 10, 12, 34, 56), dt.datetime(2025, 4, 10, 12, 34, 56), dt.datetime(2026, 4, 10, 12, 34, 56)],
+        [dt.datetime(2024, 4, 10, 12, 34, 56, 789000), dt.datetime(2025, 4, 10, 12, 34, 56, 789000), dt.datetime(2026, 4, 10, 12, 34, 56, 789000)],
+        [dt.datetime(2024, 4, 10, 12, 34, 56, 789789), dt.datetime(2025, 4, 10, 12, 34, 56, 789789), dt.datetime(2026, 4, 10, 12, 34, 56, 789789)],
+        [dt.datetime(2024, 4, 10, 12, 34, 56, 789789), dt.datetime(2025, 4, 10, 12, 34, 56, 789789), dt.datetime(2026, 4, 10, 12, 34, 56, 789789)],
     ])
+
     with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
         def select(predicate):
             return pa.Table.from_batches(t.select(predicate=predicate))
@@ -197,7 +218,33 @@ def test_types(session, clean_bucket_name):
         assert select(t['s'] == "v") == expected.filter(pc.field('s') == "v")
         assert select(t['d'] == 231.15) == expected.filter(pc.field('d') == 231.15)
         assert select(t['bin'] == b"\x01\x02") == expected.filter(pc.field('bin') == b"\x01\x02")
-        assert select(t['date'] == dt.datetime.now().date()) == expected.filter(pc.field('date') == dt.datetime.now().date())
+
+        date_literal = dt.date(2024, 4, 10)
+        assert select(t['date'] == date_literal) == expected.filter(pc.field('date') == date_literal)
+
+        time_literal = dt.time(12, 34, 56)
+        assert select(t['t0'] == time_literal) == expected.filter(pc.field('t0') == time_literal)
+
+        time_literal = dt.time(12, 34, 56, 789000)
+        assert select(t['t3'] == time_literal) == expected.filter(pc.field('t3') == time_literal)
+
+        time_literal = dt.time(12, 34, 56, 789789)
+        assert select(t['t6'] == time_literal) == expected.filter(pc.field('t6') == time_literal)
+
+        time_literal = dt.time(12, 34, 56, 789789)
+        assert select(t['t9'] == time_literal) == expected.filter(pc.field('t9') == time_literal)
+
+        ts_literal = dt.datetime(2024, 4, 10, 12, 34, 56)
+        assert select(t['ts0'] == ts_literal) == expected.filter(pc.field('ts0') == ts_literal)
+
+        ts_literal = dt.datetime(2024, 4, 10, 12, 34, 56, 789000)
+        assert select(t['ts3'] == ts_literal) == expected.filter(pc.field('ts3') == ts_literal)
+
+        ts_literal = dt.datetime(2024, 4, 10, 12, 34, 56, 789789)
+        assert select(t['ts6'] == ts_literal) == expected.filter(pc.field('ts6') == ts_literal)
+
+        ts_literal = dt.datetime(2024, 4, 10, 12, 34, 56, 789789)
+        assert select(t['ts9'] == ts_literal) == expected.filter(pc.field('ts9') == ts_literal)
 
 
 def test_filters(session, clean_bucket_name):

vastdb/tests/util.py

@@ -0,0 +1,18 @@
+import logging
+from contextlib import contextmanager
+
+log = logging.getLogger(__name__)
+
+
+@contextmanager
+def prepare_data(session, clean_bucket_name, schema_name, table_name, arrow_table):
+    with session.transaction() as tx:
+        s = tx.bucket(clean_bucket_name).create_schema(schema_name)
+        t = s.create_table(table_name, arrow_table.schema)
+        row_ids_array = t.insert(arrow_table)
+        row_ids = row_ids_array.to_pylist()
+        log.debug("row_ids=%s" % row_ids)
+        assert row_ids == list(range(arrow_table.num_rows))
+        yield t
+        t.drop()
+        s.drop()

vastdb/transaction.py

@@ -6,13 +6,12 @@ A transcation is used as a context manager, since every Database-related operati
         tx.bucket("bucket").create_schema("schema")
 """
 
-from . import bucket, errors, session
+import logging
+from dataclasses import dataclass
 
 import botocore
 
-from dataclasses import dataclass
-import logging
-
+from . import bucket, errors, session
 
 log = logging.getLogger(__name__)
 

vastdb/util.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vastdb
-Version: 0.1.0
+Version: 0.1.1
 Summary: VAST Data SDK
 Home-page: https://github.com/vast-data/vastdb_sdk
 Author: VAST DATA

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

@@ -149,23 +149,27 @@ vast_flatbuf/tabular/S3File.py,sha256=KC9c2oS5-JXwTTriUVFdjOvRG0B54Cq9kviSDZY3NI
 vast_flatbuf/tabular/VipRange.py,sha256=_BJd1RRZAcK76T9vlsHzXKYVsPVaz6WTEAqStMQCAUQ,2069
 vast_flatbuf/tabular/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vastdb/__init__.py,sha256=GY30IfZQApfl7HfcFmfTzFpx48oHgQIrDcUQCiTnxpo,206
-vastdb/bucket.py,sha256=Xbgn5Ns7veBL4oKH7EaSj4SxTPDRlicl9Saaz_39ZsU,2526
-vastdb/errors.py,sha256=mveQ2O0fLKOS51V9k5Y-HwY8Y1XiYdE9aJ9j0wlltWQ,3119
-vastdb/internal_commands.py,sha256=FR4rkr-sRvqMc-Y5hW7APOPa41a8d7L8DNJ2ROHRaFM,104441
-vastdb/schema.py,sha256=TbgqaUqAraj43vKCyVQNUSOMuJdw2Y4M06svs5jpcPo,2836
-vastdb/session.py,sha256=qgjT9rt1yUr4GyHOZRsVGFj3HYBoHFAEdczi_R26O8o,1731
-vastdb/table.py,sha256=p0uE0Gw9hen7hLTx9xC_MbxTaG6ZhZEFieaenUnbyUY,20442
-vastdb/transaction.py,sha256=jleiVmg4iui2q1GqMFsPo5GZRNtIa5NzGLFVooBbzkQ,1797
-vastdb/util.py,sha256=pBw4ywNJfkvKik-T7ZKPrWBoZOqGns-WsSZkG7HHa2I,2908
+vastdb/bucket.py,sha256=5J8KBdRViaz5bZ8WEPggQj7DfJaIhY7CqpoWP6reaDo,2854
+vastdb/conftest.py,sha256=pKpo_46Vq4QHzTDQAFxasrVhnZ2V2L-y6IMLxojxaFM,2132
+vastdb/errors.py,sha256=wCJp70QyBW8US2KMwhB6e5ZnKRft4GiN8jyJ36f1Yuo,3315
+vastdb/internal_commands.py,sha256=rmxOjIq229gsxFFZ4nKXwVIFJcu8WR1DVsE-91w4-BY,101564
+vastdb/schema.py,sha256=x9Yn4tFTFkSpJbQqpqlecKUSOK214XsRLdOUrNW0jzM,3192
+vastdb/session.py,sha256=VZOFGZbAdr5Tl4cp88VRQYnR4Q16UNuYjSmX_QPW1II,1718
+vastdb/table.py,sha256=eALN5YpUfDFqZNF_lp6lZD5RJkBKqp5Mlc6hpwGI8Rg,20443
+vastdb/transaction.py,sha256=2I5k81YvcgDsp07BrAWkmXf41qUP6m88Y40rFfuIKvI,1796
+vastdb/util.py,sha256=VR0UJ1D0WUpqS5edG_mkxDZYZJ_qqce8y7iJOvqeyWE,2974
+vastdb/bench/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vastdb/bench/test_perf.py,sha256=X7BIo60L5Oj7H-56e8pDFtXY9rNLerkywKexXWiqvrY,1111
 vastdb/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vastdb/tests/conftest.py,sha256=VLqImQ1XMr1FLCLCqZpgv8wMjNskfYAtMp-qjZFBqWo,1694
-vastdb/tests/test_imports.py,sha256=OhkbuhTeLgD4I6Vbub-B7wQo-G37TlXoHVQhGCLz9Wo,5035
-vastdb/tests/test_projections.py,sha256=PRi1Jf__95fsL9ZCQ_s2PtszWIO5FIFbniiL6FnV18M,1253
-vastdb/tests/test_sanity.py,sha256=gijOWK4ymGhVRHkf0ecHibVlaJxl92RinPdFUwWj1OQ,2959
-vastdb/tests/test_schemas.py,sha256=YX0lF8FbXzNCNVUAxq3g0L0OCjGq1OwkQaNaBtzDe4Q,1253
-vastdb/tests/test_tables.py,sha256=qnDRBtOPh9qcV4O3kB6xF4WJFj3B3WX2RAmUzkzl05g,23634
-vastdb-0.1.0.dist-info/LICENSE,sha256=obffan7LYrq7hLHNrY7vHcn2pKUTBUYXMKu-VOAvDxU,11333
-vastdb-0.1.0.dist-info/METADATA,sha256=pCY34hVZGzoB51SyIgrzrtxDaOXC_2DGOQbafZdOmQg,1331
-vastdb-0.1.0.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
-vastdb-0.1.0.dist-info/top_level.txt,sha256=Vsj2MKtlhPg0J4so64slQtnwjhgoPmJgcG-6YcVAwVc,20
-vastdb-0.1.0.dist-info/RECORD,,
+vastdb/tests/test_imports.py,sha256=fDUjO5U-5i4QTIMoNnSSW4X_ZnOStLbx0mJkNq2pj9Q,5033
+vastdb/tests/test_nested.py,sha256=3kejEvtSqV0LrUgb1QglRjrlxnKI4_AXTFw2nE7Q520,951
+vastdb/tests/test_projections.py,sha256=0ZiFya6rzGvnKOrdb1xxxv-BEerNmiK_ymfZM6eIvvw,1254
+vastdb/tests/test_sanity.py,sha256=kaOmZWDGBc-XhZ8eFQ3sks2Mo9De8q41Z5pqYWzJsHM,2958
+vastdb/tests/test_schemas.py,sha256=8ZlEvnU7Fyg-TDQDxD65GAql4rU8R2_SFWVGrdv564o,1721
+vastdb/tests/test_tables.py,sha256=o_JPqr2GX1DDpPB4Zq4E1YPFgmlsiXyVe1S3TcCjF-w,26226
+vastdb/tests/util.py,sha256=_euE3fKJqgNssT9gVxlcHjdE61mnsNQcwDPzn1tTe9g,597
+vastdb-0.1.1.dist-info/LICENSE,sha256=obffan7LYrq7hLHNrY7vHcn2pKUTBUYXMKu-VOAvDxU,11333
+vastdb-0.1.1.dist-info/METADATA,sha256=e84OEOXS09DEXniHJAU2aeK80-1h2rIZmYNBCMLa1AM,1331
+vastdb-0.1.1.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+vastdb-0.1.1.dist-info/top_level.txt,sha256=Vsj2MKtlhPg0J4so64slQtnwjhgoPmJgcG-6YcVAwVc,20
+vastdb-0.1.1.dist-info/RECORD,,