schema.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 <cstdint>
#include <optional>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "iceberg/iceberg_export.h"
#include "iceberg/result.h"
#include "iceberg/schema_field.h"
#include "iceberg/type.h"
#include "iceberg/util/lazy.h"
#include "iceberg/util/string_util.h"
 
namespace iceberg {
 
class SchemaCache;
 
class ICEBERG_EXPORT Schema : public StructType {
 public:
  static constexpr int32_t kInitialSchemaId = 0;
  static constexpr int32_t kInitialColumnId = 0;
  static constexpr int32_t kInvalidColumnId = -1;
 
  static constexpr std::string_view kAllColumns = "*";
 
  explicit Schema(std::vector<SchemaField> fields, int32_t schema_id = kInitialSchemaId);
 
  static Result<std::unique_ptr<Schema>> Make(std::vector<SchemaField> fields,
                                              int32_t schema_id,
                                              std::vector<int32_t> identifier_field_ids);
 
  static Result<std::unique_ptr<Schema>> Make(
      std::vector<SchemaField> fields, int32_t schema_id,
      const std::vector<std::string>& identifier_field_names);
 
  static Status ValidateIdentifierFields(
      int32_t field_id, const Schema& schema,
      const std::unordered_map<int32_t, int32_t>& id_to_parent);
 
  static const std::shared_ptr<Schema>& EmptySchema();
 
  int32_t schema_id() const;
 
  std::string ToString() const override;
 
  Result<std::optional<std::reference_wrapper<const SchemaField>>> FindFieldByName(
      std::string_view name, bool case_sensitive = true) const;
 
  Result<std::optional<std::reference_wrapper<const SchemaField>>> FindFieldById(
      int32_t field_id) const;
 
  Result<std::optional<std::string_view>> FindColumnNameById(int32_t field_id) const;
 
  Result<std::unique_ptr<StructLikeAccessor>> GetAccessorById(int32_t field_id) const;
 
  Result<std::unique_ptr<Schema>> Select(std::span<const std::string> names,
                                         bool case_sensitive = true) const;
 
  Result<std::unique_ptr<Schema>> Project(
      const std::unordered_set<int32_t>& field_ids) const;
 
  const std::vector<int32_t>& IdentifierFieldIds() const;
 
  Result<std::vector<std::string>> IdentifierFieldNames() const;
 
  Result<int32_t> HighestFieldId() const;
 
  bool SameSchema(const Schema& other) const;
 
  Status Validate(int32_t format_version) const;
 
  friend bool operator==(const Schema& lhs, const Schema& rhs) { return lhs.Equals(rhs); }
 
 private:
  using StructType::Equals;
  bool Equals(const Schema& other) const;
 
  const int32_t schema_id_;
  // Field IDs that uniquely identify rows in the table.
  std::vector<int32_t> identifier_field_ids_;
  // Cache for schema mappings to facilitate fast lookups.
  std::unique_ptr<SchemaCache> cache_;
};
 
// Cache for schema mappings to facilitate fast lookups.
class ICEBERG_EXPORT SchemaCache {
 public:
  explicit SchemaCache(const Schema* schema) : schema_(schema) {}
 
  using IdToFieldMap =
      std::unordered_map<int32_t, std::reference_wrapper<const SchemaField>>;
  using IdToFieldMapRef = std::reference_wrapper<const IdToFieldMap>;
 
  struct NameIdMap {
    std::unordered_map<std::string, int32_t, StringHash, std::equal_to<>> name_to_id;
 
    std::unordered_map<int32_t, std::string> id_to_name;
  };
  using NameIdMapRef = std::reference_wrapper<const NameIdMap>;
 
  using LowercaseNameToIdMap =
      std::unordered_map<std::string, int32_t, StringHash, std::equal_to<>>;
  using LowercaseNameToIdMapRef = std::reference_wrapper<const LowercaseNameToIdMap>;
 
  using IdToPositionPathMap = std::unordered_map<int32_t, std::vector<size_t>>;
  using IdToPositionPathMapRef = std::reference_wrapper<const IdToPositionPathMap>;
 
  Result<IdToFieldMapRef> GetIdToFieldMap() const;
  Result<NameIdMapRef> GetNameIdMap() const;
  Result<LowercaseNameToIdMapRef> GetLowercaseNameToIdMap() const;
  Result<IdToPositionPathMapRef> GetIdToPositionPathMap() const;
  Result<int32_t> GetHighestFieldId() const;
 
 private:
  static Result<IdToFieldMap> InitIdToFieldMap(const Schema* schema);
  static Result<NameIdMap> InitNameIdMap(const Schema* schema);
  static Result<LowercaseNameToIdMap> InitLowerCaseNameToIdMap(const Schema* schema);
  static Result<IdToPositionPathMap> InitIdToPositionPath(const Schema* schema);
  static Result<int32_t> InitHighestFieldId(const Schema* schema);
 
  const Schema* schema_;
  // Mapping from field id to field.
  Lazy<InitIdToFieldMap> id_to_field_;
  // Mapping from field name to field id.
  Lazy<InitNameIdMap> name_id_map_;
  // Mapping from lowercased field name to field id.
  Lazy<InitLowerCaseNameToIdMap> lowercase_name_to_id_;
  // Mapping from field id to (nested) position path to access the field.
  Lazy<InitIdToPositionPath> id_to_position_path_;
  // Highest field ID in the schema.
  Lazy<InitHighestFieldId> highest_field_id_;
};
 
}  // namespace iceberg