struct_like.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 <functional>
#include <memory>
#include <span>
#include <string_view>
#include <variant>
#include <vector>
 
#include "iceberg/expression/literal.h"
#include "iceberg/result.h"
#include "iceberg/type_fwd.h"
#include "iceberg/util/decimal.h"
 
namespace iceberg {
 
using Scalar = std::variant<std::monostate,  // for null
                            bool,            // for boolean
                            int32_t,         // for int, date
                            int64_t,  // for long, timestamp, timestamp_tz, and time
                            float,    // for float
                            double,   // for double
                            std::string_view,  // for non-owned string, binary and fixed
                            Decimal,           // for decimal
                            std::shared_ptr<StructLike>,  // for struct
                            std::shared_ptr<ArrayLike>,   // for list
                            std::shared_ptr<MapLike>>;    // for map
 
Result<Scalar> LiteralToScalar(const Literal& literal);
 
class ICEBERG_EXPORT StructLike {
 public:
  virtual ~StructLike() = default;
 
  virtual Result<Scalar> GetField(size_t pos) const = 0;
 
  virtual size_t num_fields() const = 0;
};
 
class ICEBERG_EXPORT ArrayLike {
 public:
  virtual ~ArrayLike() = default;
 
  virtual Result<Scalar> GetElement(size_t pos) const = 0;
 
  virtual size_t size() const = 0;
};
 
class ICEBERG_EXPORT MapLike {
 public:
  virtual ~MapLike() = default;
 
  virtual Result<Scalar> GetKey(size_t pos) const = 0;
 
  virtual Result<Scalar> GetValue(size_t pos) const = 0;
 
  virtual size_t size() const = 0;
};
 
class ICEBERG_EXPORT StructLikeAccessor {
 public:
  explicit StructLikeAccessor(std::shared_ptr<Type> type,
                              std::span<const size_t> position_path,
                              std::vector<bool> is_optional);
 
  // Deep-path accessors capture this, so the object must keep a stable address.
  StructLikeAccessor(const StructLikeAccessor&) = delete;
  StructLikeAccessor& operator=(const StructLikeAccessor&) = delete;
  StructLikeAccessor(StructLikeAccessor&&) = delete;
  StructLikeAccessor& operator=(StructLikeAccessor&&) = delete;
 
  Result<Scalar> Get(const StructLike& struct_like) const {
    return accessor_(struct_like);
  }
 
  Result<Literal> GetLiteral(const StructLike& struct_like) const;
 
  const Type& type() const { return *type_; }
 
  const std::vector<size_t>& position_path() const { return position_path_; }
 
 private:
  std::shared_ptr<Type> type_;
  std::function<Result<Scalar>(const StructLike&)> accessor_;
  std::vector<size_t> position_path_;
  // One entry per position, including the leaf field.
  std::vector<bool> is_optional_;
};
 
}  // namespace iceberg