schema.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
// Copyright 2026 Johnson Ogundeji
#pragma once
 
#include "signet/types.hpp"
 
#include <optional>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <unordered_set>
#include <vector>
 
// Windows <sal.h> defines OPTIONAL as a SAL annotation macro — undefine.
#ifdef OPTIONAL
#undef OPTIONAL
#endif
 
namespace signet::forge {
 
 
template <typename T>
struct Column {
    std::string name;  
    LogicalType logical_type = LogicalType::NONE;  
 
    Column(std::string n) : name(std::move(n)) {
        apply_default_logical_type();
    }
 
    Column(std::string n, LogicalType lt) : name(std::move(n)), logical_type(lt) {
        if (logical_type == LogicalType::NONE) {
            apply_default_logical_type();
        }
    }
 
    [[nodiscard]] ColumnDescriptor to_descriptor() const {
        ColumnDescriptor cd;
        cd.name          = name;
        cd.physical_type = parquet_type_of_v<T>;
        cd.logical_type  = logical_type;
        return cd;
    }
 
private:
    void apply_default_logical_type() {
        if constexpr (std::is_same_v<T, std::string>) {
            if (logical_type == LogicalType::NONE) {
                logical_type = LogicalType::STRING;
            }
        }
    }
};
 
class Schema;  // Forward declaration.
 
class SchemaBuilder {
public:
    explicit SchemaBuilder(std::string name) : name_(std::move(name)) {}
 
    template <typename T>
    SchemaBuilder& column(std::string col_name,
                          LogicalType logical_type = LogicalType::NONE) {
        ColumnDescriptor cd;
        cd.name          = std::move(col_name);
        cd.physical_type = parquet_type_of_v<T>;
        cd.logical_type  = logical_type;
 
        // Default std::string → STRING if no explicit logical type
        if constexpr (std::is_same_v<T, std::string>) {
            if (cd.logical_type == LogicalType::NONE) {
                cd.logical_type = LogicalType::STRING;
            }
        }
 
        columns_.push_back(std::move(cd));
        return *this;
    }
 
    template <typename T>
    SchemaBuilder& column(std::string col_name,
                          LogicalType logical_type,
                          Repetition repetition) {
        ColumnDescriptor cd;
        cd.name          = std::move(col_name);
        cd.physical_type = parquet_type_of_v<T>;
        cd.logical_type  = logical_type;
        cd.repetition    = repetition;
 
        if constexpr (std::is_same_v<T, std::string>) {
            if (cd.logical_type == LogicalType::NONE) {
                cd.logical_type = LogicalType::STRING;
            }
        }
 
        columns_.push_back(std::move(cd));
        return *this;
    }
 
    template <typename T>
    SchemaBuilder& optional_column(std::string col_name,
                                   LogicalType logical_type = LogicalType::NONE) {
        return column<T>(std::move(col_name), logical_type, Repetition::OPTIONAL);
    }
 
    SchemaBuilder& raw_column(ColumnDescriptor cd) {
        columns_.push_back(std::move(cd));
        return *this;
    }
 
    [[nodiscard]] Schema build();
 
private:
    std::string                  name_;
    std::vector<ColumnDescriptor> columns_;
};
 
class Schema {
public:
    Schema() = default;
 
    Schema(std::string name, std::vector<ColumnDescriptor> columns)
        : name_(std::move(name)), columns_(std::move(columns)) {}
 
    template <typename... Cols>
    [[nodiscard]] static Schema build(std::string name, Cols&&... cols) {
        std::vector<ColumnDescriptor> descs;
        descs.reserve(sizeof...(Cols));
        (descs.push_back(std::forward<Cols>(cols).to_descriptor()), ...);
        return Schema(std::move(name), std::move(descs));
    }
 
    [[nodiscard]] static SchemaBuilder builder(std::string name) {
        return SchemaBuilder(std::move(name));
    }
 
    // -- Accessors -------------------------------------------------------------
 
    [[nodiscard]] const std::string& name() const { return name_; }
 
    [[nodiscard]] size_t num_columns() const { return columns_.size(); }
 
    [[nodiscard]] const ColumnDescriptor& column(size_t index) const {
        if (index >= columns_.size()) {
            throw std::out_of_range("Schema::column: index "
                + std::to_string(index) + " out of range (num_columns="
                + std::to_string(columns_.size()) + ")");
        }
        return columns_[index];
    }
 
    [[nodiscard]] const std::vector<ColumnDescriptor>& columns() const {
        return columns_;
    }
 
    [[nodiscard]] std::optional<size_t> find_column(const std::string& col_name) const {
        for (size_t i = 0; i < columns_.size(); ++i) {
            if (columns_[i].name == col_name) {
                return i;
            }
        }
        return std::nullopt;
    }
 
    [[nodiscard]] bool operator==(const Schema& other) const {
        if (name_ != other.name_ || columns_.size() != other.columns_.size()) {
            return false;
        }
        for (size_t i = 0; i < columns_.size(); ++i) {
            const auto& a = columns_[i];
            const auto& b = other.columns_[i];
            if (a.name != b.name ||
                a.physical_type != b.physical_type ||
                a.logical_type != b.logical_type ||
                a.repetition != b.repetition ||
                a.type_length != b.type_length) {
                return false;
            }
        }
        return true;
    }
 
    [[nodiscard]] bool operator!=(const Schema& other) const {
        return !(*this == other);
    }
 
private:
    std::string                   name_;     
    std::vector<ColumnDescriptor> columns_;  
};
 
// ---------------------------------------------------------------------------
// SchemaBuilder::build() — defined after Schema is complete
// ---------------------------------------------------------------------------
inline Schema SchemaBuilder::build() {
    // Detect duplicate column names at build time
    std::unordered_set<std::string> seen;
    seen.reserve(columns_.size());
    for (const auto& cd : columns_) {
        if (!seen.insert(cd.name).second) {
            throw std::invalid_argument(
                "Schema::build: duplicate column name '" + cd.name + "'");
        }
    }
    return Schema(std::move(name_), std::move(columns_));
}
 
} // namespace signet::forge