ernie-renderer 0.2.0.dev20__tar.gz → 0.2.0.dev21__tar.gz

{ernie_renderer-0.2.0.dev20 → ernie_renderer-0.2.0.dev21}/CMakeLists.txt

@@ -15,7 +15,7 @@ project(
 )
 
 # Pre-release suffix such as .dev12, written by CI.
-set(ERNIE_VERSION_SUFFIX ".dev20" CACHE STRING "Pre-release suffix of Ernie's version")
+set(ERNIE_VERSION_SUFFIX ".dev21" CACHE STRING "Pre-release suffix of Ernie's version")
 set(ERNIE_VERSION "${PROJECT_VERSION}${ERNIE_VERSION_SUFFIX}")
 
 option(ERNIE_BUILD_TESTS "Build Ernie's tests" OFF)

{ernie_renderer-0.2.0.dev20 → ernie_renderer-0.2.0.dev21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev20
+Version: 0.2.0.dev21
 Summary: Efficient Renderer for Natural and Interplanetary Environments: a physically based, spectral Vulkan ray tracer
 Author: Alex Maietta
 License-Expression: BSD-3-Clause

{ernie_renderer-0.2.0.dev20 → ernie_renderer-0.2.0.dev21}/ernie/device/vulkan_devices.cpp

@@ -2,11 +2,11 @@
 /// @file vulkan_devices.cpp
 /// @brief Lists Vulkan devices through a short-lived instance.
 #include "ernie/device/vulkan_devices.h"
+#include "ernie/util/algorithm.h"
 
 #include <volk.h>
 
 #include <algorithm>
-#include <iterator>
 #include <stdexcept>
 #include <string_view>
 
@@ -107,10 +107,7 @@ std::vector<VulkanDeviceInfo> ListVulkanDevices() {
     std::vector<VkPhysicalDevice> devices(count);
     vkEnumeratePhysicalDevices(instance.Get(), &count, devices.data());
 
-    std::vector<VulkanDeviceInfo> infos;
-    infos.reserve(devices.size());
-    std::ranges::transform(devices, std::back_inserter(infos), ReadDeviceInfo);
-    return infos;
+    return Map(devices, ReadDeviceInfo);
 }
 
 const char* ToString(VulkanDeviceType type) {

ernie_renderer-0.2.0.dev21/ernie/scene/CMakeLists.txt

@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: BSD-3-Clause
+add_library(
+    ernie_scene
+    OBJECT
+    path.cpp
+    schema.cpp
+    scene.cpp
+    storage.cpp
+    view.cpp
+    xform.cpp
+    schemas/geom.cpp
+    schemas/registry.cpp
+)
+target_link_libraries(ernie_scene PUBLIC ernie_physics ernie_io PRIVATE ernie_build_options)

ernie_renderer-0.2.0.dev21/ernie/scene/convert.h

@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file convert.h
+/// @brief Conversions between `Value`s and column elements.
+#pragma once
+
+#include "ernie/scene/storage.h"
+#include "ernie/scene/value.h"
+#include "ernie/util/algorithm.h"
+
+#include <cmath>
+#include <optional>
+#include <type_traits>
+#include <vector>
+
+namespace ernie {
+
+/// @return A number of any width, or none.
+inline std::optional<double> ToNumber(const Value& value) {
+    if (const auto* d = value.Get<double>()) {
+        return *d;
+    }
+    if (const auto* f = value.Get<float>()) {
+        return *f;
+    }
+    if (const auto* i = value.Get<int>()) {
+        return *i;
+    }
+    return std::nullopt;
+}
+
+/// @return A vector of N doubles from one of floats, doubles or (for two) ints, or none.
+template <glm::length_t N> std::optional<glm::vec<N, double>> ToVector(const Value& value) {
+    if (const auto* d = value.Get<glm::vec<N, double>>()) {
+        return *d;
+    }
+    if (const auto* f = value.Get<glm::vec<N, float>>()) {
+        return glm::vec<N, double>(*f);
+    }
+    if constexpr (N == 2) {
+        if (const auto* i = value.Get<glm::ivec2>()) {
+            return glm::dvec2(*i);
+        }
+    }
+    return std::nullopt;
+}
+
+/// @return The numbers of a number, or the components of a vector; none for other values.
+inline std::vector<double> ToNumbers(const Value& value) {
+    if (const std::optional<double> number = ToNumber(value)) {
+        return {*number};
+    }
+    const auto components = [](const auto& vector) {
+        std::vector<double> numbers(static_cast<std::size_t>(vector.length()));
+        for (glm::length_t i = 0; i < vector.length(); ++i) {
+            numbers[static_cast<std::size_t>(i)] = vector[i];
+        }
+        return numbers;
+    };
+    if (const auto v = ToVector<2>(value)) {
+        return components(*v);
+    }
+    if (const auto v = ToVector<3>(value)) {
+        return components(*v);
+    }
+    if (const auto v = ToVector<4>(value)) {
+        return components(*v);
+    }
+    return {};
+}
+
+/// @return `value` as a column element, interning tokens and paths; none if it is another kind.
+template <typename T> std::optional<T> ToElement(PathTable& paths, const Value& value) {
+    if constexpr (std::is_same_v<T, std::uint8_t>) {
+        if (const auto* b = value.Get<bool>()) {
+            return static_cast<std::uint8_t>(*b);
+        }
+        if (const auto* i = value.Get<int>(); i && (*i == 0 || *i == 1)) {
+            return static_cast<std::uint8_t>(*i);
+        }
+    } else if constexpr (std::is_same_v<T, std::int32_t>) {
+        if (const std::optional<double> n = ToNumber(value); n && std::trunc(*n) == *n) {
+            return static_cast<std::int32_t>(*n);
+        }
+    } else if constexpr (std::is_same_v<T, double>) {
+        return ToNumber(value);
+    } else if constexpr (std::is_same_v<T, glm::dvec2> || std::is_same_v<T, glm::dvec3> ||
+                         std::is_same_v<T, glm::dvec4>) {
+        return ToVector<T::length()>(value);
+    } else if constexpr (std::is_same_v<T, glm::dquat>) {
+        if (const auto* q = value.Get<glm::dquat>()) {
+            return *q;
+        }
+    } else if constexpr (std::is_same_v<T, glm::dmat4>) {
+        if (const auto* m = value.Get<glm::dmat4>()) {
+            return *m;
+        }
+    } else if constexpr (std::is_same_v<T, Token>) {
+        if (const auto* text = value.Get<std::string>()) {
+            return paths.Names().Intern(*text);
+        }
+    } else if constexpr (std::is_same_v<T, Target>) {
+        if (const auto* path = value.Get<Path>()) {
+            return Target{path->IsEmpty() ? kNoPath : paths.Intern(*path)};
+        }
+    } else if constexpr (std::is_same_v<T, std::vector<Target>>) {
+        if (const auto* path = value.Get<Path>()) {
+            return std::vector<Target>{{paths.Intern(*path)}};
+        }
+        if (const auto* list = value.Get<std::vector<Path>>()) {
+            return Map(*list, [&](const Path& path) { return Target{paths.Intern(path)}; });
+        }
+    } else if constexpr (std::is_same_v<T, std::vector<float>>) {
+        if (const auto* floats = value.Get<std::vector<float>>()) {
+            return *floats;
+        }
+        if (const std::optional<double> n = ToNumber(value)) {
+            return std::vector<float>{static_cast<float>(*n)};
+        }
+    } else if constexpr (std::is_same_v<T, std::vector<Token>>) {
+        if (const auto* texts = value.Get<std::vector<std::string>>()) {
+            return Map(*texts, [&](const std::string& text) { return paths.Names().Intern(text); });
+        }
+        // An empty list, as Python and JSON pass one.
+        if (const auto* floats = value.Get<std::vector<float>>(); floats && floats->empty()) {
+            return std::vector<Token>{};
+        }
+    }
+    return std::nullopt;
+}
+
+/// @return A column element as a `Value`; tensors have none.
+template <typename T> Value ToValue(const PathTable& paths, const T& element) {
+    if constexpr (std::is_same_v<T, std::uint8_t>) {
+        return element != 0;
+    } else if constexpr (std::is_same_v<T, std::int32_t>) {
+        return static_cast<int>(element);
+    } else if constexpr (std::is_same_v<T, Token>) {
+        return std::string(paths.Names().Text(element));
+    } else if constexpr (std::is_same_v<T, Target>) {
+        return element.path == kNoPath ? Path() : paths.ToPath(element.path);
+    } else if constexpr (std::is_same_v<T, std::vector<Target>>) {
+        return Map(element, [&](const Target& target) { return paths.ToPath(target.path); });
+    } else if constexpr (std::is_same_v<T, std::vector<Token>>) {
+        return Map(element, [&](Token token) { return std::string(paths.Names().Text(token)); });
+    } else if constexpr (std::is_same_v<T, Tensor>) {
+        return Value();
+    } else {
+        return element;
+    }
+}
+
+/// @return The column type an undeclared attribute's first value makes, or none.
+inline std::optional<ColumnType> InferColumnType(const Value& value) {
+    return std::visit(
+        [](const auto& v) -> std::optional<ColumnType> {
+            using V = std::decay_t<decltype(v)>;
+            if constexpr (std::is_same_v<V, bool>) {
+                return ColumnType::Bool;
+            } else if constexpr (std::is_same_v<V, int>) {
+                return ColumnType::Int;
+            } else if constexpr (std::is_same_v<V, float> || std::is_same_v<V, double>) {
+                return ColumnType::Double;
+            } else if constexpr (std::is_same_v<V, glm::ivec2> || std::is_same_v<V, glm::vec2> ||
+                                 std::is_same_v<V, glm::dvec2>) {
+                return ColumnType::Vec2;
+            } else if constexpr (std::is_same_v<V, glm::vec3> || std::is_same_v<V, glm::dvec3>) {
+                return ColumnType::Vec3;
+            } else if constexpr (std::is_same_v<V, glm::vec4> || std::is_same_v<V, glm::dvec4>) {
+                return ColumnType::Vec4;
+            } else if constexpr (std::is_same_v<V, glm::dquat>) {
+                return ColumnType::Quat;
+            } else if constexpr (std::is_same_v<V, glm::dmat4>) {
+                return ColumnType::Matrix;
+            } else if constexpr (std::is_same_v<V, std::string>) {
+                return ColumnType::TokenValue;
+            } else if constexpr (std::is_same_v<V, Path>) {
+                return ColumnType::Relationship;
+            } else if constexpr (std::is_same_v<V, std::vector<Path>>) {
+                return ColumnType::Relationships;
+            } else if constexpr (std::is_same_v<V, std::vector<float>>) {
+                return ColumnType::FloatArray;
+            } else if constexpr (std::is_same_v<V, std::vector<std::string>>) {
+                return ColumnType::TokenArray;
+            } else {
+                return std::nullopt;
+            }
+        },
+        value.Raw());
+}
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev20 → ernie_renderer-0.2.0.dev21}/ernie/scene/path.h

@@ -113,6 +113,13 @@ class PathTable {
     PathId NextSibling(PathId id) const {
         return nodes_[id].nextSibling;
     }
+    /// Calls `visit(child)` for each child of `id`, in the order they were added.
+    template <typename Visit> void ForEachChild(PathId id, const Visit& visit) const {
+        for (PathId child = nodes_[id].firstChild; child != kNoPath;
+             child = nodes_[child].nextSibling) {
+            visit(child);
+        }
+    }
     /// @return Whether `id` is `ancestor` or lies below it.
     bool HasPrefix(PathId id, PathId ancestor) const;
 

ernie_renderer-0.2.0.dev21/ernie/scene/scene.cpp

@@ -0,0 +1,324 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file scene.cpp
+/// @brief Prims, attributes, transforms and bounds over the columnar store.
+#include "ernie/scene/scene.h"
+
+#include "ernie/scene/convert.h"
+#include "ernie/scene/schemas/geom.h"
+#include "ernie/scene/tokens.h"
+#include "ernie/scene/xform.h"
+
+#include <algorithm>
+#include <stdexcept>
+#include <string>
+
+namespace ernie {
+namespace {
+
+/// @return A column layout holding `fallback` in unauthored rows.
+ColumnLayout MakeLayout(PathTable& paths, const AttributeDef& def) {
+    const AttributeId attribute = paths.Names().Intern(def.name);
+    return WithColumnType(def.type, [&]<typename T>(std::type_identity<T>) {
+        if constexpr (std::is_same_v<T, Tensor>) {
+            return ColumnLayout::Of<T>(attribute);
+        } else {
+            return ColumnLayout::Of<T>(attribute, ToElement<T>(paths, def.fallback).value_or(T{}));
+        }
+    });
+}
+
+std::string Describe(const Scene& scene, PrimId prim) {
+    const std::string_view type = scene.TypeName(prim);
+    return "'" + scene.PrimPath(prim).String() + "'" +
+           (type.empty() ? std::string() : " (" + std::string(type) + ")");
+}
+
+}  // namespace
+
+Scene::Scene()
+    : invisible_(store_.Tokens().Intern(tokens::kInvisible)),
+      defaultPurpose_(store_.Tokens().Intern(tokens::kDefault)) {
+    BucketFor(nullptr);
+}
+
+PrimId Scene::Define(const Path& path, std::string_view type) {
+    if (path.IsEmpty() || path.IsRoot()) {
+        throw std::invalid_argument("Cannot define the prim at '" + path.String() + "'");
+    }
+    const SchemaDef* schema = type.empty() ? nullptr : FindSchema(type);
+    if (!type.empty() && (schema == nullptr || schema->kind != SchemaKind::Concrete)) {
+        throw std::invalid_argument("Cannot define '" + path.String() + "' as '" +
+                                    std::string(type) + "', which is no prim type");
+    }
+    PathTable& paths = store_.Paths();
+    const PathId id = paths.Intern(path);
+    for (PathId above = paths.Parent(id); above != kRootPath; above = paths.Parent(above)) {
+        if (!store_.Find(above)) {
+            store_.Define(above, 0);
+        }
+    }
+    const BucketId bucket = BucketFor(schema);
+    if (const std::optional<PrimId> existing = store_.Find(id)) {
+        store_.Move(*existing, bucket);
+        return *existing;
+    }
+    return store_.Define(id, bucket);
+}
+
+bool Scene::Remove(const Path& path) {
+    if (path.IsRoot()) {
+        throw std::invalid_argument("Cannot remove the root prim");
+    }
+    const std::optional<PathId> id = store_.Paths().Find(path);
+    if (!id || !store_.Find(*id)) {
+        return false;
+    }
+    std::vector<PathId> pending{*id};
+    while (!pending.empty()) {
+        const PathId next = pending.back();
+        pending.pop_back();
+        if (const std::optional<PrimId> prim = store_.Find(next)) {
+            store_.Remove(*prim);
+        }
+        store_.Paths().ForEachChild(next, [&](PathId child) { pending.push_back(child); });
+    }
+    return true;
+}
+
+std::optional<PrimId> Scene::Find(const Path& path) const {
+    const std::optional<PathId> id = store_.Paths().Find(path);
+    return id ? store_.Find(*id) : std::nullopt;
+}
+
+Path Scene::PrimPath(PrimId prim) const {
+    return store_.Paths().ToPath(store_.PrimPath(prim));
+}
+
+std::string_view Scene::TypeName(PrimId prim) const {
+    const SchemaDef* schema = Schema(prim);
+    return schema != nullptr ? schema->name : std::string_view();
+}
+
+const SchemaDef* Scene::Schema(PrimId prim) const {
+    return buckets_[store_.PrimBucket(prim)].schema;
+}
+
+std::vector<Path> Scene::Children(const Path& path) const {
+    std::vector<Path> children;
+    const PathTable& paths = store_.Paths();
+    if (const std::optional<PathId> id = path.IsRoot() ? kRootPath : paths.Find(path)) {
+        paths.ForEachChild(*id, [&](PathId child) {
+            if (store_.Find(child)) {
+                children.push_back(paths.ToPath(child));
+            }
+        });
+    }
+    return children;
+}
+
+std::vector<Path> Scene::Prims(std::string_view type) const {
+    const SchemaDef* base = type.empty() ? nullptr : FindSchema(type);
+    if (!type.empty() && base == nullptr) {
+        throw std::invalid_argument("'" + std::string(type) + "' is no prim type");
+    }
+    std::vector<Path> prims;
+    for (BucketId bucket = 0; bucket < buckets_.size(); ++bucket) {
+        const SchemaDef* schema = buckets_[bucket].schema;
+        if (base == nullptr || (schema != nullptr && schema->IsA(*base))) {
+            for (const PrimId prim : store_.GetBucket(bucket).prims) {
+                prims.push_back(PrimPath(prim));
+            }
+        }
+    }
+    std::ranges::sort(prims);
+    return prims;
+}
+
+void Scene::Set(PrimId prim, std::string_view attribute, const Value& value) {
+    const AttributeId token = store_.Tokens().Intern(attribute);
+    const AttributeDef* def = Declared(prim, token);
+    if (def != nullptr) {
+        Validate(*def, value, PrimPath(prim));
+    }
+    const ColumnType type = def != nullptr ? def->type : TypeForUndeclared(prim, attribute, value);
+    WithColumnType(type, [&]<typename T>(std::type_identity<T>) {
+        std::optional<T> element = ToElement<T>(store_.Paths(), value);
+        if (!element) {
+            throw std::invalid_argument(Describe(*this, prim) + ": '" + std::string(attribute) +
+                                        "' takes another type of value");
+        }
+        store_.Set(prim, token, std::move(*element));
+    });
+}
+
+void Scene::Set(const Path& path, std::string_view attribute, const Value& value) {
+    Set(Require(path), attribute, value);
+}
+
+std::optional<Value> Scene::Get(PrimId prim, std::string_view attribute) const {
+    const Column* column = AuthoredColumn(prim, attribute);
+    if (column == nullptr) {
+        return std::nullopt;
+    }
+    return WithColumnType(column->values->Type(), [&]<typename T>(std::type_identity<T>) {
+        const auto values = store_.Read<T>(store_.PrimBucket(prim), column->attribute);
+        return ToValue(store_.Paths(), values[store_.PrimRow(prim)]);
+    });
+}
+
+std::optional<Value> Scene::Get(const Path& path, std::string_view attribute) const {
+    return Get(Require(path), attribute);
+}
+
+bool Scene::Clear(PrimId prim, std::string_view attribute) {
+    const Column* column = AuthoredColumn(prim, attribute);
+    if (column != nullptr) {
+        store_.Clear(prim, column->attribute);
+    }
+    return column != nullptr;
+}
+
+bool Scene::IsAuthored(PrimId prim, std::string_view attribute) const {
+    return AuthoredColumn(prim, attribute) != nullptr;
+}
+
+std::vector<std::string> Scene::Attributes(const Path& path) const {
+    const PrimId prim = Require(path);
+    std::vector<std::string> names;
+    for (const Column& column : store_.GetBucket(store_.PrimBucket(prim)).columns) {
+        if (column.authored.Test(store_.PrimRow(prim))) {
+            names.emplace_back(store_.Tokens().Text(column.attribute));
+        }
+    }
+    return names;
+}
+
+glm::dmat4 Scene::LocalTransform(PrimId prim) const {
+    const SchemaDef* schema = Schema(prim);
+    const bool xformable = schema != nullptr && schema->IsA(Xformable::Definition());
+    return xformable ? ComposeXformOps(*this, prim) : glm::dmat4(1.0);
+}
+
+glm::dmat4 Scene::WorldTransform(PrimId prim) const {
+    glm::dmat4 world = LocalTransform(prim);
+    const PathTable& paths = store_.Paths();
+    for (PathId above = paths.Parent(store_.PrimPath(prim));
+         above != kRootPath && !ResetsXformStack(*this, prim); above = paths.Parent(above)) {
+        prim = *store_.Find(above);
+        world = LocalTransform(prim) * world;
+    }
+    return world;
+}
+
+std::optional<Box> Scene::Extent(PrimId prim) const {
+    const SchemaDef* schema = Schema(prim);
+    const ExtentRule rule = schema != nullptr ? schema->Extent() : kNoExtent;
+    if (rule.kind != ExtentRule::Kind::Computed) {
+        return std::nullopt;
+    }
+    const std::uint32_t row = store_.PrimRow(prim);
+    Box extent;
+    rule.compute({store_, store_.PrimBucket(prim)}, {row, row + 1}, std::span(&extent, 1));
+    return extent;
+}
+
+Box Scene::WorldBounds(const Path& path) const {
+    const PrimId prim = Require(path);
+    const PathId id = store_.PrimPath(prim);
+    const PathId parent = store_.Paths().Parent(id);
+    const glm::dmat4 above =
+        parent == kRootPath ? glm::dmat4(1.0) : WorldTransform(*store_.Find(parent));
+    Box bounds;
+    AddTo(bounds, id, above);
+    return bounds;
+}
+
+void Scene::AddTo(Box& bounds, PathId path, const glm::dmat4& parent) const {
+    const PrimId prim = *store_.Find(path);
+    if (LeavesOutOfBounds(prim)) {
+        return;
+    }
+    const glm::dmat4 local = LocalTransform(prim);
+    const glm::dmat4 world = ResetsXformStack(*this, prim) ? local : parent * local;
+    if (const std::optional<Box> extent = Extent(prim)) {
+        bounds.Extend(extent->Transformed(world));
+    }
+    store_.Paths().ForEachChild(path, [&](PathId child) {
+        if (store_.Find(child)) {
+            AddTo(bounds, child, world);
+        }
+    });
+}
+
+PrimId Scene::Require(const Path& path) const {
+    const std::optional<PrimId> prim = Find(path);
+    if (!prim) {
+        throw std::invalid_argument("No prim at '" + path.String() + "'");
+    }
+    return *prim;
+}
+
+BucketId Scene::BucketFor(const SchemaDef* schema) {
+    if (const auto found = bucketBySchema_.find(schema); found != bucketBySchema_.end()) {
+        return found->second;
+    }
+    PathTable& paths = store_.Paths();
+    BucketSchema entry{schema, {}};
+    std::vector<ColumnLayout> layout;
+    for (const AttributeDef* def :
+         schema != nullptr ? schema->AllAttributes() : std::vector<const AttributeDef*>{}) {
+        layout.push_back(MakeLayout(paths, *def));
+        entry.declared.emplace(layout.back().attribute, def);
+    }
+    const Token type = paths.Names().Intern(schema != nullptr ? schema->name : "");
+    const BucketId bucket = store_.AddBucket({type, {}}, layout);
+    buckets_.resize(std::max<std::size_t>(buckets_.size(), bucket + 1));
+    buckets_[bucket] = std::move(entry);
+    bucketBySchema_.emplace(schema, bucket);
+    return bucket;
+}
+
+bool Scene::LeavesOutOfBounds(PrimId prim) const {
+    const auto token = [&](std::string_view attribute) -> std::optional<Token> {
+        const Column* column = AuthoredColumn(prim, attribute);
+        return column ? std::optional(store_.Read<Token>(store_.PrimBucket(prim),
+                                                         column->attribute)[store_.PrimRow(prim)])
+                      : std::nullopt;
+    };
+    // Purpose is inherited, so a subtree under another purpose is left out whole.
+    const std::optional<Token> purpose = token(Imageable::kPurpose);
+    return token(Imageable::kVisibility) == invisible_ || (purpose && *purpose != defaultPurpose_);
+}
+
+const Column* Scene::AuthoredColumn(PrimId prim, std::string_view attribute) const {
+    const std::optional<Token> token = store_.Tokens().Find(attribute);
+    const Column* column = token ? store_.GetBucket(store_.PrimBucket(prim)).Find(*token) : nullptr;
+    return column != nullptr && column->authored.Test(store_.PrimRow(prim)) ? column : nullptr;
+}
+
+const AttributeDef* Scene::Declared(PrimId prim, AttributeId attribute) const {
+    const auto& declared = buckets_[store_.PrimBucket(prim)].declared;
+    const auto found = declared.find(attribute);
+    return found != declared.end() ? found->second : nullptr;
+}
+
+ColumnType Scene::TypeForUndeclared(PrimId prim, std::string_view attribute,
+                                    const Value& value) const {
+    const SchemaDef* schema = Schema(prim);
+    if (schema != nullptr && !schema->IsOpen(attribute)) {
+        throw std::invalid_argument(Describe(*this, prim) + " has no attribute '" +
+                                    std::string(attribute) + "'");
+    }
+    const Token token = *store_.Tokens().Find(attribute);
+    if (const Column* column = store_.GetBucket(store_.PrimBucket(prim)).Find(token)) {
+        return column->values->Type();
+    }
+    const std::optional<ColumnType> type = InferColumnType(value);
+    if (!type) {
+        throw std::invalid_argument(Describe(*this, prim) + ": '" + std::string(attribute) +
+                                    "' takes no empty value");
+    }
+    return *type;
+}
+
+}  // namespace ernie