types.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
// Copyright 2026 Johnson Ogundeji
#pragma once
 
#include <cstdint>
#include <string>
#include <type_traits>
#include <vector>
 
namespace signet::forge {
 
 
enum class PhysicalType : int32_t {
    BOOLEAN              = 0,  
    INT32                = 1,  
    INT64                = 2,  
    INT96                = 3,  
    FLOAT                = 4,  
    DOUBLE               = 5,  
    BYTE_ARRAY           = 6,  
    FIXED_LEN_BYTE_ARRAY = 7   
};
 
// Windows <mmsystem.h> defines TIME_MS as a macro — undefine to avoid collision.
#ifdef TIME_MS
#undef TIME_MS
#endif
 
enum class LogicalType : int32_t {
    NONE       = 0,   
    STRING     = 1,   
    ENUM       = 2,   
    UUID       = 3,   
    DATE       = 4,   
    TIME_MS    = 5,   
    TIME_US    = 6,   
    TIME_NS    = 7,   
    TIMESTAMP_MS = 8, 
    TIMESTAMP_US = 9, 
    TIMESTAMP_NS = 10,
    DECIMAL    = 11,  
    JSON       = 12,  
    BSON       = 13,  
    FLOAT16    = 14,  
    FLOAT32_VECTOR = 100,
};
 
enum class ConvertedType : int32_t {
    NONE             = -1, 
    UTF8             = 0,  
    MAP              = 1,  
    MAP_KEY_VALUE    = 2,  
    LIST             = 3,  
    ENUM             = 4,  
    DECIMAL          = 5,  
    DATE             = 6,  
    TIME_MILLIS      = 7,  
    TIME_MICROS      = 8,  
    TIMESTAMP_MILLIS = 9,  
    TIMESTAMP_MICROS = 10, 
    UINT_8           = 11, 
    UINT_16          = 12, 
    UINT_32          = 13, 
    UINT_64          = 14, 
    INT_8            = 15, 
    INT_16           = 16, 
    INT_32           = 17, 
    INT_64           = 18, 
    JSON             = 19, 
    BSON             = 20, 
    INTERVAL         = 21  
};
 
enum class Encoding : int32_t {
    PLAIN                  = 0, 
    PLAIN_DICTIONARY       = 2, 
    RLE                    = 3, 
    BIT_PACKED             = 4, 
    DELTA_BINARY_PACKED    = 5, 
    DELTA_LENGTH_BYTE_ARRAY = 6, 
    DELTA_BYTE_ARRAY       = 7, 
    RLE_DICTIONARY         = 8, 
    BYTE_STREAM_SPLIT      = 9  
};
 
enum class Compression : int32_t {
    UNCOMPRESSED = 0, 
    SNAPPY       = 1, 
    GZIP         = 2, 
    LZO          = 3, 
    BROTLI       = 4, 
    LZ4          = 5, 
    ZSTD         = 6, 
    LZ4_RAW      = 7  
};
 
enum class PageType : int32_t {
    DATA_PAGE       = 0, 
    INDEX_PAGE      = 1, 
    DICTIONARY_PAGE = 2, 
    DATA_PAGE_V2    = 3  
};
 
// Windows <sal.h> defines OPTIONAL as a SAL annotation macro — undefine.
#ifdef OPTIONAL
#undef OPTIONAL
#endif
enum class Repetition : int32_t {
    REQUIRED = 0, 
    OPTIONAL = 1, 
    REPEATED = 2  
};
 
struct ColumnDescriptor {
    std::string   name;           
    PhysicalType  physical_type;  
    LogicalType   logical_type   = LogicalType::NONE;     
    Repetition    repetition     = Repetition::REQUIRED;  
    int32_t       type_length    = -1;  
    int32_t       precision      = -1;  
    int32_t       scale          = -1;  
};
 
template <typename T> struct parquet_type_of;
 
template <> struct parquet_type_of<bool>        { static constexpr PhysicalType value = PhysicalType::BOOLEAN; };
template <> struct parquet_type_of<int32_t>     { static constexpr PhysicalType value = PhysicalType::INT32; };
template <> struct parquet_type_of<int64_t>     { static constexpr PhysicalType value = PhysicalType::INT64; };
template <> struct parquet_type_of<float>        { static constexpr PhysicalType value = PhysicalType::FLOAT; };
template <> struct parquet_type_of<double>       { static constexpr PhysicalType value = PhysicalType::DOUBLE; };
template <> struct parquet_type_of<std::string>  { static constexpr PhysicalType value = PhysicalType::BYTE_ARRAY; };
 
template <typename T>
inline constexpr PhysicalType parquet_type_of_v = parquet_type_of<T>::value;
 
template <PhysicalType PT> struct native_type_of;
 
template <> struct native_type_of<PhysicalType::BOOLEAN>    { using type = bool; };
template <> struct native_type_of<PhysicalType::INT32>      { using type = int32_t; };
template <> struct native_type_of<PhysicalType::INT64>      { using type = int64_t; };
template <> struct native_type_of<PhysicalType::FLOAT>      { using type = float; };
template <> struct native_type_of<PhysicalType::DOUBLE>     { using type = double; };
template <> struct native_type_of<PhysicalType::BYTE_ARRAY> { using type = std::string; };
 
template <PhysicalType PT>
using native_type_of_t = typename native_type_of<PT>::type;
 
inline constexpr int32_t PARQUET_VERSION = 2;
inline constexpr const char* SIGNET_CREATED_BY = "SignetStack signet-forge version 0.1.0";
inline constexpr uint32_t PARQUET_MAGIC           = 0x31524150;
inline constexpr uint32_t PARQUET_MAGIC_ENCRYPTED = 0x45524150;
 
struct ColumnWriteStats {
    std::string column_name;                              
    PhysicalType physical_type   = PhysicalType::BYTE_ARRAY; 
    Encoding    encoding         = Encoding::PLAIN;       
    Compression compression      = Compression::UNCOMPRESSED; 
    int64_t     uncompressed_bytes = 0;                   
    int64_t     compressed_bytes   = 0;                   
    int64_t     num_values       = 0;                     
    int64_t     null_count       = 0;                     
};
 
struct WriteStats {
    int64_t file_size_bytes          = 0;   
    int64_t total_rows               = 0;   
    int64_t total_row_groups         = 0;   
    int64_t total_uncompressed_bytes = 0;   
    int64_t total_compressed_bytes   = 0;   
    double  compression_ratio        = 1.0; 
    double  bytes_per_row            = 0.0; 
 
    std::vector<ColumnWriteStats> columns;  
};
 
struct ColumnFileStats {
    std::string   column_name;                               
    PhysicalType  physical_type    = PhysicalType::BYTE_ARRAY; 
    LogicalType   logical_type     = LogicalType::NONE;      
    Compression   compression      = Compression::UNCOMPRESSED; 
    int64_t       uncompressed_bytes = 0;                    
    int64_t       compressed_bytes   = 0;                    
    int64_t       num_values       = 0;                      
    int64_t       null_count       = 0;                      
    bool          has_bloom_filter = false;                   
    bool          has_page_index   = false;                   
};
 
struct FileStats {
    int64_t     file_size_bytes    = 0;   
    int64_t     total_rows         = 0;   
    int64_t     num_row_groups     = 0;   
    int64_t     num_columns        = 0;   
    std::string created_by;               
    double      compression_ratio  = 1.0; 
    double      bytes_per_row      = 0.0; 
 
    std::vector<ColumnFileStats> columns; 
};
 
} // namespace signet::forge