dbzero 0.3.2__tar.gz → 0.3.3__tar.gz

{dbzero-0.3.2 → dbzero-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbzero
-Version: 0.3.2
+Version: 0.3.3
 Summary: A state management system for Python 3.x that unifies your applications business logic, data persistence, and caching into a single, efficient layer.
 Author-Email: "DBZero Software sp. z o.o" <info@dbzero.io>
 License:                   GNU LESSER GENERAL PUBLIC LICENSE

{dbzero-0.3.2 → dbzero-0.3.3}/dbzero/setup.py

@@ -10,7 +10,7 @@ if sys.byteorder == 'big':
 
 setup(
     name='dbzero',
-    version='0.3.2',
+    version='0.3.3',
     description='DBZero community edition',
     packages=['dbzero'],
     python_requires='>=3.9',

{dbzero-0.3.2 → dbzero-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ['meson-python']
 
 [project]
 name = 'dbzero'
-version = '0.3.2'
+version = '0.3.3'
 description = 'A state management system for Python 3.x that unifies your applications business logic, data persistence, and caching into a single, efficient layer.'
 readme = 'README.md'
 requires-python = '>=3.9'

dbzero-0.3.3/python_tests/test_issues_16.py

@@ -0,0 +1,139 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+# Copyright (c) 2025 DBZero Software sp. z o.o.
+
+import os
+import subprocess
+import sys
+import textwrap
+
+
+def test_repeated_memo_graph_creation_with_tagged_shared_lookup_does_not_segfault(tmp_path):
+    """Regression for repeated memo graph construction with tagged shared lookup."""
+    script = textwrap.dedent(
+        f"""
+        from dataclasses import dataclass
+        from decimal import Decimal
+        from typing import Optional
+        import os
+
+        import dbzero as db0
+
+        db_path = {str(tmp_path / "db0")!r}
+        os.mkdir(db_path)
+        db0.init(db_path)
+        db0.open("p")
+
+        JobStatus = db0.enum("Issue16JobStatus", ["READY", "DONE"])
+
+        @db0.memo
+        @dataclass
+        class Pricing:
+            input_price_per_M: Optional[Decimal] = None
+            input_price_per_cached_M: Optional[Decimal] = None
+            output_price_per_M: Optional[Decimal] = None
+
+        @db0.memo(no_default_tags=True)
+        @dataclass
+        class Usage:
+            pricing: Pricing
+            context_bytes: int = 0
+            total_bytes_sent: int = 0
+            total_bytes_received: int = 0
+            total_input_tokens: int = 0
+            total_cached_tokens: int = 0
+            total_output_tokens: int = 0
+            total_reported_cost: Optional[float] = None
+
+        @db0.memo
+        class RuntimeState:
+            def __init__(self):
+                self.local_state = {{}}
+                self.console = []
+                self.exceptions = None
+                self.exit_status = None
+
+        @db0.memo
+        class Agent:
+            def __init__(self, role, metadata, tools):
+                self.role = role
+                self._metadata = metadata
+                self._tools = tools
+
+        @db0.memo
+        @dataclass
+        class JobDef:
+            agent: Agent
+            metadata: dict = None
+            job_params: dict = None
+            warmup_code: object = None
+
+            def __post_init__(self):
+                if self.agent is not None:
+                    db0.tags(self).add(self.agent)
+                if self.metadata is None:
+                    self.metadata = self.agent._metadata
+
+        @db0.memo
+        class Job:
+            def __init__(self, job_def, job_status=JobStatus.READY):
+                self.job_def = job_def
+                self.parent_job = None
+                if self.job_def.agent is not None:
+                    db0.tags(self).add(self.job_def.agent)
+                self.__job_status = None
+                self.set_status(job_status)
+                self.runtime_state = RuntimeState()
+                self.chat_log = []
+                self.awaited_result = None
+                self.next_instr_num = None
+                self.warmup_block_num = None
+                self.error = None
+                self.created_at = None
+                self.error_handlers = []
+                self.__last_difficulty = None
+                self.usage = Usage(pricing=self.current_pricing())
+                self.error = None
+                self.num_completions = None
+                self.__ext_ref = None
+                self.__pending_chat_log = []
+
+            def set_status(self, new_status):
+                if self.__job_status is not None:
+                    db0.tags(self).remove(self.__job_status)
+                db0.tags(self).add(new_status)
+                self.__job_status = new_status
+
+            def current_pricing(self):
+                existing = next(iter(db0.find(Pricing, "UNKNOWN", "test-model")), None)
+                if existing is not None:
+                    return existing
+                pricing = Pricing()
+                db0.tags(pricing).add(["UNKNOWN", "test-model", "USAGE"])
+                return pricing
+
+        def make_job():
+            agent = Agent("test", {{"MODEL": "test-model"}}, [])
+            job_def = JobDef(agent)
+            return Job(job_def)
+
+        make_job()
+        make_job()
+        db0.close()
+        """
+    )
+
+    env = os.environ.copy()
+    env["PYTHONDONTWRITEBYTECODE"] = "1"
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        check=False,
+        env=env,
+        text=True,
+        capture_output=True,
+    )
+
+    assert result.returncode == 0, (
+        f"subprocess exited with {result.returncode}\\n"
+        f"stdout:\\n{result.stdout}\\n"
+        f"stderr:\\n{result.stderr}"
+    )

dbzero-0.3.3/python_tests/test_issues_17.py

@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+# Copyright (c) 2025 DBZero Software sp. z o.o.
+
+from dataclasses import dataclass
+from itertools import product
+from typing import Optional
+
+import dbzero as db0
+
+
+@db0.memo(immutable=True, intern=True)
+@dataclass
+class Issue17PackedMask:
+    create: Optional[bool] = None
+    read: Optional[bool] = None
+    update: Optional[bool] = None
+    delete: Optional[bool] = None
+
+
+def test_interned_immutable_object_with_only_pack_2_fields_materializes(db0_fixture):
+    field_names = ("create", "read", "update", "delete")
+    values = (None, False, True)
+    seen_uuids = set()
+
+    for combination in product(values, repeat=len(field_names)):
+        kwargs = dict(zip(field_names, combination))
+
+        materialized = db0.materialized(Issue17PackedMask(**kwargs))
+        duplicate = db0.materialized(Issue17PackedMask(**kwargs))
+
+        assert tuple(getattr(materialized, name) for name in field_names) == combination
+        assert tuple(getattr(duplicate, name) for name in field_names) == combination
+        assert db0.uuid(duplicate) == db0.uuid(materialized)
+        seen_uuids.add(db0.uuid(materialized))
+
+    assert len(seen_uuids) == len(values) ** len(field_names)

{dbzero-0.3.2 → dbzero-0.3.3}/python_tests/test_memo_intern.py

@@ -5,6 +5,9 @@ import gc
 import random
 import time
 from dataclasses import dataclass
+from dataclasses import field
+from itertools import product
+from typing import Optional
 
 import pytest
 import dbzero as db0
@@ -92,6 +95,26 @@ class MemoInternWideObject:
             setattr(self, name, value)
 
 
+@db0.memo(immutable=True, intern=True)
+@dataclass
+class MemoInternOptionalBoolMask:
+    create: Optional[bool] = None
+    read: Optional[bool] = None
+    update: Optional[bool] = None
+    delete: Optional[bool] = None
+
+
+@db0.memo
+class MemoInternOptionalBoolRecord:
+    pass
+
+
+@db0.memo
+@dataclass
+class MemoInternOptionalBoolHolder:
+    access_map: dict[type, dict[str, MemoInternOptionalBoolMask]] = field(default_factory=dict)
+
+
 def make_intern_stress_payload(index, variant):
     address_items = [
         ("street", f"{index % 997} Intern Ave"),
@@ -159,6 +182,35 @@ def test_intern_flag_cannot_change_after_class_materialization(db0_fixture):
         db0.materialized(MemoNoLongerIntern("beta"))
 
 
+def test_interned_optional_bool_packed_field_combinations(db0_fixture):
+    field_names = ("create", "read", "update", "delete")
+    values = (None, False, True)
+    seen_uuids = set()
+
+    for combination in product(values, repeat=len(field_names)):
+        kwargs = dict(zip(field_names, combination))
+
+        materialized = db0.materialized(MemoInternOptionalBoolMask(**kwargs))
+        duplicate = db0.materialized(MemoInternOptionalBoolMask(**kwargs))
+
+        assert tuple(getattr(materialized, name) for name in field_names) == combination
+        assert tuple(getattr(duplicate, name) for name in field_names) == combination
+        assert db0.uuid(duplicate) == db0.uuid(materialized)
+        seen_uuids.add(db0.uuid(materialized))
+
+    assert len(seen_uuids) == len(values) ** len(field_names)
+
+
+def test_embedded_interned_optional_bool_fields_in_nested_map(db0_fixture):
+    mask = MemoInternOptionalBoolMask(read=True, update=False)
+
+    holder = MemoInternOptionalBoolHolder({MemoInternOptionalBoolRecord: {"name": mask}})
+
+    stored_mask = holder.access_map[MemoInternOptionalBoolRecord]["name"]
+    assert stored_mask.read is True
+    assert stored_mask.update is False
+
+
 def test_interned_object_can_reference_interned_immutable_instance(db0_fixture):
     leaf = MemoInternLeaf("nested")
 

{dbzero-0.3.2 → dbzero-0.3.3}/src/dbzero/core/collections/vector/v_sorted_vector.hpp

@@ -871,8 +871,8 @@ DB0_PACKED_END
         */
         bool updateExisting(const data_t &data, data_t *old_data = nullptr)
         {
-            auto it = (*this)->find(data);
-            if (it == (*this)->end()) {
+            auto it = find(data);
+            if (it == end()) {
                 return false;
             }
             
@@ -887,8 +887,8 @@ DB0_PACKED_END
 
         bool findOne(data_t &data) const
         {
-            auto it = (*this)->find(data);
-            if (it == (*this)->end()) {
+            auto it = find(data);
+            if (it == end()) {
                 return false;
             }
 

{dbzero-0.3.2 → dbzero-0.3.3}/src/dbzero/object_model/object/InternContent.cpp

@@ -158,6 +158,81 @@ namespace db0::object_model
             }
         }
 
+        constexpr std::uint32_t PACKED_FIELD_KEY_FLAG = 0x80000000u;
+        constexpr std::uint32_t PACKED_FIELD_KEY_INDEX_MASK = 0x003FFFFFu;
+
+        std::uint32_t makePackedFieldKey(std::uint32_t index, std::uint32_t offset)
+        {
+            assert(index <= PACKED_FIELD_KEY_INDEX_MASK);
+            assert(offset <= FieldID::MAX_OFFSET);
+            return PACKED_FIELD_KEY_FLAG | (index << 6) | offset;
+        }
+
+        bool unpackPackedFieldKey(
+            std::uint32_t key, std::uint32_t &index, std::uint32_t &offset
+        )
+        {
+            if ((key & PACKED_FIELD_KEY_FLAG) == 0) {
+                return false;
+            }
+            index = (key >> 6) & PACKED_FIELD_KEY_INDEX_MASK;
+            offset = key & FieldID::MAX_OFFSET;
+            return true;
+        }
+
+        bool makePackedFieldValue(std::uint32_t key, std::uint64_t packed_value, FieldValue &field)
+        {
+            switch (packed_value) {
+                case Value::NONE:
+                    field = {};
+                    field.m_index = key;
+                    field.m_kind = StorageClass::NONE;
+                    field.m_valid = true;
+                    return true;
+                case Value::FALSE:
+                    field = {};
+                    field.m_index = key;
+                    field.m_kind = StorageClass::BOOLEAN;
+                    field.m_value = Value(0);
+                    field.m_valid = true;
+                    return true;
+                case Value::TRUE:
+                    field = {};
+                    field.m_index = key;
+                    field.m_kind = StorageClass::BOOLEAN;
+                    field.m_value = Value(1);
+                    field.m_valid = true;
+                    return true;
+                case Value::DELETED:
+                    return false;
+                default:
+                    THROWF(db0::InternalException) << "Invalid PACK_2 intern content value: " << packed_value;
+                    return false;
+            }
+        }
+
+        template <typename EmitT>
+        void emitPackedFields(std::uint32_t index, Value value, EmitT emit)
+        {
+            auto store = lofi_store<2>::fromValue(value);
+            for (auto it = store.begin(); !it.isEnd(); ++it) {
+                FieldValue field;
+                if (makePackedFieldValue(makePackedFieldKey(index, it.getOffset()), *it, field)) {
+                    emit(field);
+                }
+            }
+        }
+
+        std::uint64_t countPackedFields(Value value)
+        {
+            std::uint64_t count = 0;
+            auto store = lofi_store<2>::fromValue(value);
+            for (auto it = store.begin(); !it.isEnd(); ++it) {
+                count += *it == Value::DELETED ? 0 : 1;
+            }
+            return count;
+        }
+
         int compareWithFixture(
             db0::swine_ptr<db0::Fixture> *fixture, const o_tuple_item &lhs, const o_tuple_item &rhs
         );
@@ -299,11 +374,20 @@ namespace db0::object_model
             {
                 std::uint64_t count = 0;
                 const auto &types = object.pos_vt().types();
+                const auto &values = object.pos_vt().values();
                 for (std::size_t i = 0; i < object.pos_vt().size(); ++i) {
-                    count += isFieldValue(types[i]) ? 1 : 0;
+                    if (types[i] == StorageClass::PACK_2) {
+                        count += countPackedFields(values[i]);
+                    } else {
+                        count += isFieldValue(types[i]) ? 1 : 0;
+                    }
                 }
                 for (const auto &value: object.index_vt().xvalues()) {
-                    count += isFieldValue(value.m_type) ? 1 : 0;
+                    if (value.m_type == StorageClass::PACK_2) {
+                        count += countPackedFields(value.m_value);
+                    } else {
+                        count += isFieldValue(value.m_type) ? 1 : 0;
+                    }
                 }
                 for (const auto &entry: object.field_map()) {
                     (void)entry;
@@ -320,10 +404,18 @@ namespace db0::object_model
                 auto indexVtData = initializer.getData(posVtData, posVtOffset);
 
                 for (std::size_t i = 0; i < posVtData.size(); ++i) {
-                    count += isFieldValue(posVtData.m_types[i]) ? 1 : 0;
+                    if (posVtData.m_types[i] == StorageClass::PACK_2) {
+                        count += countPackedFields(posVtData.m_values[i]);
+                    } else {
+                        count += isFieldValue(posVtData.m_types[i]) ? 1 : 0;
+                    }
                 }
                 for (auto value = indexVtData.first; value != indexVtData.second; ++value) {
-                    count += isFieldValue(value->m_type) ? 1 : 0;
+                    if (value->m_type == StorageClass::PACK_2) {
+                        count += countPackedFields(value->m_value);
+                    } else {
+                        count += isFieldValue(value->m_type) ? 1 : 0;
+                    }
                 }
                 for (const auto &value: initializer.objects()) {
                     count += !!value.m_object && value.m_storage_class != StorageClass::DELETED ? 1 : 0;
@@ -370,14 +462,20 @@ namespace db0::object_model
                 const auto &types = object.pos_vt().types();
                 const auto &values = object.pos_vt().values();
                 for (std::size_t i = 0; i < object.pos_vt().size(); ++i) {
-                    if (isFieldValue(types[i])) {
+                    if (types[i] == StorageClass::PACK_2) {
+                        emitPackedFields(
+                            static_cast<std::uint32_t>(object.pos_vt().offset() + i), values[i], emit
+                        );
+                    } else if (isFieldValue(types[i])) {
                         emit(makeField(
                             static_cast<std::uint32_t>(object.pos_vt().offset() + i), types[i], values[i]
                         ));
                     }
                 }
                 for (const auto &value: object.index_vt().xvalues()) {
-                    if (isFieldValue(value.m_type)) {
+                    if (value.m_type == StorageClass::PACK_2) {
+                        emitPackedFields(value.getIndex(), value.m_value, emit);
+                    } else if (isFieldValue(value.m_type)) {
                         emit(makeField(value.getIndex(), value.m_type, value.m_value));
                     }
                 }
@@ -395,7 +493,9 @@ namespace db0::object_model
                 auto indexVtData = initializer.getData(posVtData, posVtOffset);
 
                 for (std::size_t i = 0; i < posVtData.size(); ++i) {
-                    if (isFieldValue(posVtData.m_types[i])) {
+                    if (posVtData.m_types[i] == StorageClass::PACK_2) {
+                        emitPackedFields(static_cast<std::uint32_t>(posVtOffset + i), posVtData.m_values[i], emit);
+                    } else if (isFieldValue(posVtData.m_types[i])) {
                         emit(makeField(
                             static_cast<std::uint32_t>(posVtOffset + i),
                             posVtData.m_types[i], posVtData.m_values[i]
@@ -403,7 +503,9 @@ namespace db0::object_model
                     }
                 }
                 for (auto value = indexVtData.first; value != indexVtData.second; ++value) {
-                    if (isFieldValue(value->m_type)) {
+                    if (value->m_type == StorageClass::PACK_2) {
+                        emitPackedFields(value->getIndex(), value->m_value, emit);
+                    } else if (isFieldValue(value->m_type)) {
                         emit(makeField(value->getIndex(), value->m_type, value->m_value));
                     }
                 }
@@ -1086,11 +1188,20 @@ namespace db0::object_model
             {
                 std::uint64_t count = 0;
                 const auto &types = object.pos_vt().types();
+                const auto &values = object.pos_vt().values();
                 for (std::size_t i = 0; i < object.pos_vt().size(); ++i) {
-                    count += isFieldValue(types[i]) ? 1 : 0;
+                    if (types[i] == StorageClass::PACK_2) {
+                        count += countPackedFields(values[i]);
+                    } else {
+                        count += isFieldValue(types[i]) ? 1 : 0;
+                    }
                 }
                 for (const auto &value: object.index_vt().xvalues()) {
-                    count += isFieldValue(value.m_type) ? 1 : 0;
+                    if (value.m_type == StorageClass::PACK_2) {
+                        count += countPackedFields(value.m_value);
+                    } else {
+                        count += isFieldValue(value.m_type) ? 1 : 0;
+                    }
                 }
                 for (const auto &entry: object.field_map()) {
                     (void)entry;
@@ -1106,10 +1217,18 @@ namespace db0::object_model
                 unsigned int posVtOffset = 0;
                 auto indexVtData = initializer.getData(posVtData, posVtOffset);
                 for (std::size_t i = 0; i < posVtData.size(); ++i) {
-                    count += isFieldValue(posVtData.m_types[i]) ? 1 : 0;
+                    if (posVtData.m_types[i] == StorageClass::PACK_2) {
+                        count += countPackedFields(posVtData.m_values[i]);
+                    } else {
+                        count += isFieldValue(posVtData.m_types[i]) ? 1 : 0;
+                    }
                 }
                 for (auto value = indexVtData.first; value != indexVtData.second; ++value) {
-                    count += isFieldValue(value->m_type) ? 1 : 0;
+                    if (value->m_type == StorageClass::PACK_2) {
+                        count += countPackedFields(value->m_value);
+                    } else {
+                        count += isFieldValue(value->m_type) ? 1 : 0;
+                    }
                 }
                 for (const auto &value: initializer.objects()) {
                     count += !!value.m_object && value.m_storage_class != StorageClass::DELETED ? 1 : 0;
@@ -1211,6 +1330,34 @@ namespace db0::object_model
 
                 FieldValue find(std::uint32_t index) const
                 {
+                    std::uint32_t packed_index = 0;
+                    std::uint32_t packed_offset = 0;
+                    if (unpackPackedFieldKey(index, packed_index, packed_offset)) {
+                        std::pair<StorageClass, Value> value;
+                        if (m_object.pos_vt().find(packed_index, value)
+                            && value.first == StorageClass::PACK_2
+                            && lofi_store<2>::fromValue(value.second).isSet(packed_offset))
+                        {
+                            FieldValue field;
+                            if (makePackedFieldValue(
+                                index, lofi_store<2>::fromValue(value.second).get(packed_offset), field
+                            )) {
+                                return field;
+                            }
+                        }
+                        if (m_object.index_vt().find(packed_index, value)
+                            && value.first == StorageClass::PACK_2
+                            && lofi_store<2>::fromValue(value.second).isSet(packed_offset))
+                        {
+                            FieldValue field;
+                            if (makePackedFieldValue(
+                                index, lofi_store<2>::fromValue(value.second).get(packed_offset), field
+                            )) {
+                                return field;
+                            }
+                        }
+                        return {};
+                    }
                     std::pair<StorageClass, Value> value;
                     if (m_object.pos_vt().find(index, value) && InternComparator::isFieldValue(value.first)) {
                         return InternComparator::makeField(index, value.first, value.second);
@@ -1243,9 +1390,27 @@ namespace db0::object_model
 
                 FieldValue next()
                 {
+                    if (m_pendingPos < m_pendingFields.size()) {
+                        return m_pendingFields[m_pendingPos++];
+                    }
+                    m_pendingFields.clear();
+                    m_pendingPos = 0;
                     while (m_pos < m_posVtData.size()) {
                         auto pos = m_pos++;
-                        if (InternComparator::isFieldValue(m_posVtData.m_types[pos])) {
+                        if (m_posVtData.m_types[pos] == StorageClass::PACK_2) {
+                            m_pendingFields.clear();
+                            emitPackedFields(
+                                static_cast<std::uint32_t>(m_posVtOffset + pos),
+                                m_posVtData.m_values[pos],
+                                [&](const FieldValue &field) {
+                                    m_pendingFields.push_back(field);
+                                }
+                            );
+                            if (!m_pendingFields.empty()) {
+                                m_pendingPos = 1;
+                                return m_pendingFields[0];
+                            }
+                        } else if (InternComparator::isFieldValue(m_posVtData.m_types[pos])) {
                             return InternComparator::makeField(
                                 static_cast<std::uint32_t>(m_posVtOffset + pos),
                                 m_posVtData.m_types[pos], m_posVtData.m_values[pos]
@@ -1254,7 +1419,19 @@ namespace db0::object_model
                     }
                     while (m_indexValue != m_indexVtData.second) {
                         auto *value = m_indexValue++;
-                        if (InternComparator::isFieldValue(value->m_type)) {
+                        if (value->m_type == StorageClass::PACK_2) {
+                            m_pendingFields.clear();
+                            emitPackedFields(
+                                value->getIndex(), value->m_value,
+                                [&](const FieldValue &field) {
+                                    m_pendingFields.push_back(field);
+                                }
+                            );
+                            if (!m_pendingFields.empty()) {
+                                m_pendingPos = 1;
+                                return m_pendingFields[0];
+                            }
+                        } else if (InternComparator::isFieldValue(value->m_type)) {
                             return InternComparator::makeField(
                                 value->getIndex(), value->m_type, value->m_value
                             );
@@ -1278,6 +1455,8 @@ namespace db0::object_model
                 const XValue *m_indexValue = nullptr;
                 const std::vector<ImmutableObjectInitializer::ObjectValue> *m_objects = nullptr;
                 std::size_t m_objectPos = 0;
+                std::vector<FieldValue> m_pendingFields;
+                std::size_t m_pendingPos = 0;
             };
 
             int compareSequentialInitializerFields(
@@ -1315,14 +1494,20 @@ namespace db0::object_model
                 const auto &types = object.pos_vt().types();
                 const auto &values = object.pos_vt().values();
                 for (std::size_t i = 0; i < object.pos_vt().size(); ++i) {
-                    if (isFieldValue(types[i])) {
+                    if (types[i] == StorageClass::PACK_2) {
+                        emitPackedFields(
+                            static_cast<std::uint32_t>(object.pos_vt().offset() + i), values[i], emit
+                        );
+                    } else if (isFieldValue(types[i])) {
                         emit(makeField(
                             static_cast<std::uint32_t>(object.pos_vt().offset() + i), types[i], values[i]
                         ));
                     }
                 }
                 for (const auto &value: object.index_vt().xvalues()) {
-                    if (isFieldValue(value.m_type)) {
+                    if (value.m_type == StorageClass::PACK_2) {
+                        emitPackedFields(value.getIndex(), value.m_value, emit);
+                    } else if (isFieldValue(value.m_type)) {
                         emit(makeField(value.getIndex(), value.m_type, value.m_value));
                     }
                 }
@@ -1337,7 +1522,9 @@ namespace db0::object_model
                 unsigned int posVtOffset = 0;
                 auto indexVtData = initializer.getData(posVtData, posVtOffset);
                 for (std::size_t i = 0; i < posVtData.size(); ++i) {
-                    if (isFieldValue(posVtData.m_types[i])) {
+                    if (posVtData.m_types[i] == StorageClass::PACK_2) {
+                        emitPackedFields(static_cast<std::uint32_t>(posVtOffset + i), posVtData.m_values[i], emit);
+                    } else if (isFieldValue(posVtData.m_types[i])) {
                         emit(makeField(
                             static_cast<std::uint32_t>(posVtOffset + i),
                             posVtData.m_types[i], posVtData.m_values[i]
@@ -1345,7 +1532,9 @@ namespace db0::object_model
                     }
                 }
                 for (auto value = indexVtData.first; value != indexVtData.second; ++value) {
-                    if (isFieldValue(value->m_type)) {
+                    if (value->m_type == StorageClass::PACK_2) {
+                        emitPackedFields(value->getIndex(), value->m_value, emit);
+                    } else if (isFieldValue(value->m_type)) {
                         emit(makeField(value->getIndex(), value->m_type, value->m_value));
                     }
                 }