type.h

Go to the documentation of this file.

/*
 * 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 <array>
#include <cstdint>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "iceberg/iceberg_export.h"
#include "iceberg/result.h"
#include "iceberg/schema_field.h"
#include "iceberg/util/formattable.h"
#include "iceberg/util/lazy.h"
 
namespace iceberg {
 
class ICEBERG_EXPORT Type : public iceberg::util::Formattable {
 public:
  ~Type() override = default;
 
  virtual TypeId type_id() const = 0;
 
  virtual bool is_primitive() const = 0;
 
  virtual bool is_nested() const = 0;
 
  bool is_struct() const { return type_id() == TypeId::kStruct; }
 
  bool is_list() const { return type_id() == TypeId::kList; }
 
  bool is_map() const { return type_id() == TypeId::kMap; }
 
  bool is_variant() const { return type_id() == TypeId::kVariant; }
 
  friend bool operator==(const Type& lhs, const Type& rhs) { return lhs.Equals(rhs); }
 
 protected:
  virtual bool Equals(const Type& other) const = 0;
};
 
class ICEBERG_EXPORT PrimitiveType : public Type {
 public:
  bool is_primitive() const override { return true; }
  bool is_nested() const override { return false; }
};
 
class ICEBERG_EXPORT NestedType : public Type {
 public:
  bool is_primitive() const override { return false; }
  bool is_nested() const override { return true; }
 
  virtual std::span<const SchemaField> fields() const = 0;
  using SchemaFieldConstRef = std::reference_wrapper<const SchemaField>;
  virtual Result<std::optional<SchemaFieldConstRef>> GetFieldById(
      int32_t field_id) const = 0;
  virtual Result<std::optional<SchemaFieldConstRef>> GetFieldByIndex(
      int32_t index) const = 0;
  virtual Result<std::optional<SchemaFieldConstRef>> GetFieldByName(
      std::string_view name, bool case_sensitive) const = 0;
  Result<std::optional<SchemaFieldConstRef>> GetFieldByName(std::string_view name) const;
};
 
 
class ICEBERG_EXPORT StructType : public NestedType {
 public:
  constexpr static TypeId kTypeId = TypeId::kStruct;
  explicit StructType(std::vector<SchemaField> fields);
  ~StructType() override = default;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
  std::span<const SchemaField> fields() const override;
  Result<std::optional<SchemaFieldConstRef>> GetFieldById(
      int32_t field_id) const override;
  Result<std::optional<SchemaFieldConstRef>> GetFieldByIndex(
      int32_t index) const override;
  Result<std::optional<SchemaFieldConstRef>> GetFieldByName(
      std::string_view name, bool case_sensitive) const override;
  using NestedType::GetFieldByName;
 
  std::unique_ptr<Schema> ToSchema() const;
 
 protected:
  bool Equals(const Type& other) const override;
 
  static Result<std::unordered_map<int32_t, SchemaFieldConstRef>> InitFieldById(
      const StructType&);
  static Result<std::unordered_map<std::string_view, SchemaFieldConstRef>>
  InitFieldByName(const StructType&);
  static Result<std::unordered_map<std::string, SchemaFieldConstRef>>
  InitFieldByLowerCaseName(const StructType&);
 
  std::vector<SchemaField> fields_;
  Lazy<InitFieldById> field_by_id_;
  Lazy<InitFieldByName> field_by_name_;
  Lazy<InitFieldByLowerCaseName> field_by_lowercase_name_;
};
 
class ICEBERG_EXPORT ListType : public NestedType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kList;
  constexpr static const std::string_view kElementName = "element";
 
  static Result<std::unique_ptr<ListType>> Make(SchemaField element);
 
  explicit ListType(SchemaField element);
  ListType(int32_t field_id, std::shared_ptr<Type> type, bool optional);
  ~ListType() override = default;
 
  TypeId type_id() const override;
  const SchemaField& element() const;
  std::string ToString() const override;
 
  std::span<const SchemaField> fields() const override;
  Result<std::optional<SchemaFieldConstRef>> GetFieldById(
      int32_t field_id) const override;
  Result<std::optional<SchemaFieldConstRef>> GetFieldByIndex(
      int32_t index) const override;
  Result<std::optional<SchemaFieldConstRef>> GetFieldByName(
      std::string_view name, bool case_sensitive) const override;
  using NestedType::GetFieldByName;
 
 protected:
  bool Equals(const Type& other) const override;
 
  SchemaField element_;
};
 
class ICEBERG_EXPORT MapType : public NestedType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kMap;
  constexpr static const std::string_view kKeyName = "key";
  constexpr static const std::string_view kValueName = "value";
 
  static Result<std::unique_ptr<MapType>> Make(SchemaField key, SchemaField value);
 
  explicit MapType(SchemaField key, SchemaField value);
  ~MapType() override = default;
 
  const SchemaField& key() const;
  const SchemaField& value() const;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
  std::span<const SchemaField> fields() const override;
  Result<std::optional<SchemaFieldConstRef>> GetFieldById(
      int32_t field_id) const override;
  Result<std::optional<SchemaFieldConstRef>> GetFieldByIndex(
      int32_t index) const override;
  Result<std::optional<SchemaFieldConstRef>> GetFieldByName(
      std::string_view name, bool case_sensitive) const override;
  using NestedType::GetFieldByName;
 
 protected:
  bool Equals(const Type& other) const override;
 
  std::array<SchemaField, 2> fields_;
};
 
 
 
class ICEBERG_EXPORT VariantType : public Type {
 public:
  constexpr static const TypeId kTypeId = TypeId::kVariant;
 
  VariantType() = default;
  ~VariantType() override = default;
 
  bool is_primitive() const override { return false; }
  bool is_nested() const override { return false; }
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
 
 
class ICEBERG_EXPORT BooleanType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kBoolean;
 
  BooleanType() = default;
  ~BooleanType() override = default;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT IntType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kInt;
 
  IntType() = default;
  ~IntType() override = default;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT LongType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kLong;
 
  LongType() = default;
  ~LongType() override = default;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT FloatType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kFloat;
 
  FloatType() = default;
  ~FloatType() override = default;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT DoubleType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kDouble;
 
  DoubleType() = default;
  ~DoubleType() override = default;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT DecimalType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kDecimal;
  constexpr static const int32_t kMaxPrecision = 38;
 
  DecimalType(int32_t precision, int32_t scale);
  ~DecimalType() override = default;
 
  int32_t precision() const;
  int32_t scale() const;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
 
 private:
  int32_t precision_;
  int32_t scale_;
};
 
class ICEBERG_EXPORT DateType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kDate;
 
  DateType() = default;
  ~DateType() override = default;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT TimeType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kTime;
 
  TimeType() = default;
  ~TimeType() override = default;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT TimestampBase : public PrimitiveType {
 public:
  virtual bool is_zoned() const = 0;
  virtual TimeUnit time_unit() const = 0;
};
 
class ICEBERG_EXPORT TimestampType : public TimestampBase {
 public:
  constexpr static const TypeId kTypeId = TypeId::kTimestamp;
 
  TimestampType() = default;
  ~TimestampType() override = default;
 
  bool is_zoned() const override;
  TimeUnit time_unit() const override;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT TimestampTzType : public TimestampBase {
 public:
  constexpr static const TypeId kTypeId = TypeId::kTimestampTz;
 
  TimestampTzType() = default;
  ~TimestampTzType() override = default;
 
  bool is_zoned() const override;
  TimeUnit time_unit() const override;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT TimestampNsType : public TimestampBase {
 public:
  constexpr static const TypeId kTypeId = TypeId::kTimestampNs;
 
  TimestampNsType() = default;
  ~TimestampNsType() override = default;
 
  bool is_zoned() const override;
  TimeUnit time_unit() const override;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT TimestampTzNsType : public TimestampBase {
 public:
  constexpr static const TypeId kTypeId = TypeId::kTimestampTzNs;
 
  TimestampTzNsType() = default;
  ~TimestampTzNsType() override = default;
 
  bool is_zoned() const override;
  TimeUnit time_unit() const override;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT BinaryType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kBinary;
 
  BinaryType() = default;
  ~BinaryType() override = default;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT StringType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kString;
 
  StringType() = default;
  ~StringType() override = default;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT FixedType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kFixed;
 
  explicit FixedType(int32_t length);
  ~FixedType() override = default;
 
  int32_t length() const;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
 
 private:
  int32_t length_;
};
 
class ICEBERG_EXPORT UuidType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kUuid;
 
  UuidType() = default;
  ~UuidType() override = default;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT UnknownType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kUnknown;
 
  UnknownType() = default;
  ~UnknownType() override = default;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
};
 
class ICEBERG_EXPORT GeometryType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kGeometry;
  constexpr static std::string_view kDefaultCrs = "OGC:CRS84";
 
  static Result<std::unique_ptr<GeometryType>> Make();
  static Result<std::unique_ptr<GeometryType>> Make(std::string crs);
  ~GeometryType() override = default;
 
  std::string_view crs() const;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
 
 private:
  GeometryType() = default;
  explicit GeometryType(std::string crs);
 
  std::string crs_{kDefaultCrs};
};
 
class ICEBERG_EXPORT GeographyType : public PrimitiveType {
 public:
  constexpr static const TypeId kTypeId = TypeId::kGeography;
  constexpr static std::string_view kDefaultCrs = "OGC:CRS84";
  constexpr static EdgeAlgorithm kDefaultAlgorithm = EdgeAlgorithm::kSpherical;
 
  static Result<std::unique_ptr<GeographyType>> Make();
  static Result<std::unique_ptr<GeographyType>> Make(std::string crs);
  static Result<std::unique_ptr<GeographyType>> Make(std::string crs,
                                                     EdgeAlgorithm algorithm);
  ~GeographyType() override = default;
 
  std::string_view crs() const;
  EdgeAlgorithm algorithm() const;
 
  TypeId type_id() const override;
  std::string ToString() const override;
 
 protected:
  bool Equals(const Type& other) const override;
 
 private:
  GeographyType() = default;
  explicit GeographyType(std::string crs);
  GeographyType(std::string crs, EdgeAlgorithm algorithm);
 
  std::string crs_{kDefaultCrs};
  EdgeAlgorithm algorithm_{kDefaultAlgorithm};
};
 
 
 
ICEBERG_EXPORT const std::shared_ptr<BooleanType>& boolean();
ICEBERG_EXPORT const std::shared_ptr<IntType>& int32();
ICEBERG_EXPORT const std::shared_ptr<LongType>& int64();
ICEBERG_EXPORT const std::shared_ptr<FloatType>& float32();
ICEBERG_EXPORT const std::shared_ptr<DoubleType>& float64();
ICEBERG_EXPORT const std::shared_ptr<DateType>& date();
ICEBERG_EXPORT const std::shared_ptr<TimeType>& time();
ICEBERG_EXPORT const std::shared_ptr<TimestampType>& timestamp();
ICEBERG_EXPORT const std::shared_ptr<TimestampTzType>& timestamp_tz();
ICEBERG_EXPORT const std::shared_ptr<TimestampNsType>& timestamp_ns();
ICEBERG_EXPORT const std::shared_ptr<TimestampTzNsType>& timestamptz_ns();
ICEBERG_EXPORT const std::shared_ptr<BinaryType>& binary();
ICEBERG_EXPORT const std::shared_ptr<StringType>& string();
ICEBERG_EXPORT const std::shared_ptr<UuidType>& uuid();
ICEBERG_EXPORT const std::shared_ptr<UnknownType>& unknown();
ICEBERG_EXPORT const std::shared_ptr<VariantType>& variant();
ICEBERG_EXPORT const std::shared_ptr<GeometryType>& geometry();
ICEBERG_EXPORT const std::shared_ptr<GeographyType>& geography();
 
ICEBERG_EXPORT std::shared_ptr<DecimalType> decimal(int32_t precision, int32_t scale);
 
ICEBERG_EXPORT std::shared_ptr<FixedType> fixed(int32_t length);
 
ICEBERG_EXPORT std::shared_ptr<GeometryType> geometry(std::string crs);
 
ICEBERG_EXPORT std::shared_ptr<GeographyType> geography(std::string crs);
 
ICEBERG_EXPORT std::shared_ptr<GeographyType> geography(std::string crs,
                                                        EdgeAlgorithm algorithm);
 
ICEBERG_EXPORT std::shared_ptr<StructType> struct_(std::vector<SchemaField> fields);
 
ICEBERG_EXPORT std::shared_ptr<ListType> list(SchemaField element);
 
ICEBERG_EXPORT std::shared_ptr<MapType> map(SchemaField key, SchemaField value);
 
 
ICEBERG_EXPORT std::string_view ToString(TypeId id);
 
ICEBERG_EXPORT std::string_view ToString(EdgeAlgorithm algorithm);
 
ICEBERG_EXPORT Result<EdgeAlgorithm> EdgeAlgorithmFromString(std::string_view name);
 
}  // namespace iceberg