literal.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#pragma once
 
#include <compare>
#include <memory>
#include <string>
#include <variant>
#include <vector>
 
#include "iceberg/iceberg_export.h"
#include "iceberg/result.h"
#include "iceberg/type.h"
#include "iceberg/util/decimal.h"
#include "iceberg/util/formattable.h"
#include "iceberg/util/int128.h"
#include "iceberg/util/uuid.h"
 
namespace iceberg {
 
class ICEBERG_EXPORT Literal : public util::Formattable {
 public:
  struct BelowMin {
    bool operator==(const BelowMin&) const = default;
    std::strong_ordering operator<=>(const BelowMin&) const = default;
  };
 
  struct AboveMax {
    bool operator==(const AboveMax&) const = default;
    std::strong_ordering operator<=>(const AboveMax&) const = default;
  };
  using Value = std::variant<std::monostate,  // for null
                             bool,            // for boolean
                             int32_t,         // for int, date
                             int64_t,         // for long, timestamp, timestamp_tz, time
                             float,           // for float
                             double,          // for double
                             std::string,     // for string
                             std::vector<uint8_t>,  // for binary, fixed
                             ::iceberg::Decimal,    // for decimal
                             Uuid,                  // for uuid
                             BelowMin, AboveMax>;
 
  static Literal Boolean(bool value);
  static Literal Int(int32_t value);
  static Literal Date(int32_t value);
  static Literal Long(int64_t value);
  static Literal Time(int64_t value);
  static Literal Timestamp(int64_t value);
  static Literal TimestampTz(int64_t value);
  static Literal Float(float value);
  static Literal Double(double value);
  static Literal String(std::string value);
  static Literal UUID(Uuid value);
  static Literal Binary(std::vector<uint8_t> value);
  static Literal Fixed(std::vector<uint8_t> value);
 
  static Literal Decimal(int128_t value, int32_t precision, int32_t scale);
 
  static Literal Null(std::shared_ptr<PrimitiveType> type) {
    return {Value{std::monostate{}}, std::move(type)};
  }
 
  static Result<Literal> Deserialize(std::span<const uint8_t> data,
                                     std::shared_ptr<PrimitiveType> type);
 
  Result<std::vector<uint8_t>> Serialize() const;
 
  const std::shared_ptr<PrimitiveType>& type() const;
 
  const Value& value() const { return value_; }
 
  Result<Literal> CastTo(const std::shared_ptr<PrimitiveType>& target_type) const;
 
  bool operator==(const Literal& other) const;
 
  std::partial_ordering operator<=>(const Literal& other) const;
 
  bool IsAboveMax() const;
 
  bool IsBelowMin() const;
 
  bool IsNull() const;
 
  bool IsNaN() const;
 
  std::string ToString() const override;
 
 private:
  Literal(Value value, std::shared_ptr<PrimitiveType> type);
 
  friend class Conversions;
  friend class LiteralCaster;
 
  Value value_;
  std::shared_ptr<PrimitiveType> type_;
};
 
struct ICEBERG_EXPORT LiteralValueHash {
  std::size_t operator()(const Literal::Value& value) const noexcept;
};
 
struct ICEBERG_EXPORT LiteralHash {
  std::size_t operator()(const Literal& value) const noexcept {
    return LiteralValueHash{}(value.value());
  }
};
 
template <TypeId type_id>
struct LiteralTraits {
  using ValueType = void;
};
 
#define DEFINE_LITERAL_TRAIT(TYPE_ID, VALUE_TYPE) \
  template <>                                     \
  struct LiteralTraits<TypeId::TYPE_ID> {         \
    using ValueType = VALUE_TYPE;                 \
  };
 
DEFINE_LITERAL_TRAIT(kBoolean, bool)
DEFINE_LITERAL_TRAIT(kInt, int32_t)
DEFINE_LITERAL_TRAIT(kDate, int32_t)
DEFINE_LITERAL_TRAIT(kLong, int64_t)
DEFINE_LITERAL_TRAIT(kTime, int64_t)
DEFINE_LITERAL_TRAIT(kTimestamp, int64_t)
DEFINE_LITERAL_TRAIT(kTimestampTz, int64_t)
DEFINE_LITERAL_TRAIT(kFloat, float)
DEFINE_LITERAL_TRAIT(kDouble, double)
DEFINE_LITERAL_TRAIT(kDecimal, Decimal)
DEFINE_LITERAL_TRAIT(kString, std::string)
DEFINE_LITERAL_TRAIT(kUuid, Uuid)
DEFINE_LITERAL_TRAIT(kBinary, std::vector<uint8_t>)
DEFINE_LITERAL_TRAIT(kFixed, std::vector<uint8_t>)
 
#undef DEFINE_LITERAL_TRAIT
 
}  // namespace iceberg