struct_like_set.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 <memory>
#include <memory_resource>
#include <unordered_set>
#include <vector>
 
#include "iceberg/iceberg_export.h"
#include "iceberg/result.h"
#include "iceberg/row/struct_like.h"
#include "iceberg/type_fwd.h"
 
namespace iceberg {
 
ICEBERG_EXPORT Result<bool> StructLikeEqual(const StructLike& lhs, const StructLike& rhs);
 
template <bool kValidate = true>
class ICEBERG_TEMPLATE_CLASS_EXPORT StructLikeSet {
 public:
  static constexpr size_t kDefaultArenaInitialSize = 64 * 1024;
 
  explicit StructLikeSet(const StructType& type,
                         size_t arena_initial_size = kDefaultArenaInitialSize);
 
  ~StructLikeSet();
 
  Status Insert(const StructLike& row);
 
  Result<bool> Contains(const StructLike& row) const;
 
  bool IsEmpty() const;
 
  size_t Size() const;
 
 private:
  struct KeyHash {
    using is_transparent = void;
    size_t operator()(const std::unique_ptr<StructLike>& p) const noexcept;
    size_t operator()(const StructLike& s) const noexcept;
  };
 
  struct KeyEqual {
    using is_transparent = void;
    bool operator()(const std::unique_ptr<StructLike>& lhs,
                    const std::unique_ptr<StructLike>& rhs) const noexcept;
    bool operator()(const StructLike& lhs,
                    const std::unique_ptr<StructLike>& rhs) const noexcept;
    bool operator()(const std::unique_ptr<StructLike>& lhs,
                    const StructLike& rhs) const noexcept;
  };
 
  Result<std::unique_ptr<StructLike>> MakeArenaRow(const StructLike& row) const;
 
  Result<Scalar> DeepCopyScalar(const Scalar& scalar) const;
 
  std::string_view CopyToArena(std::string_view src) const;
 
  std::vector<std::shared_ptr<Type>> field_types_;
  mutable std::pmr::monotonic_buffer_resource arena_;
  std::unordered_set<std::unique_ptr<StructLike>, KeyHash, KeyEqual> set_;
};
 
extern template class ICEBERG_EXTERN_TEMPLATE_CLASS_EXPORT StructLikeSet<true>;
extern template class ICEBERG_EXTERN_TEMPLATE_CLASS_EXPORT StructLikeSet<false>;
 
}  // namespace iceberg