predicate.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 <unordered_set>
 
#include "iceberg/expression/expression.h"
#include "iceberg/expression/literal.h"
#include "iceberg/expression/term.h"
#include "iceberg/iceberg_export.h"
 
namespace iceberg {
 
template <TermType T>
class ICEBERG_EXPORT Predicate : public virtual Expression {
 public:
  ~Predicate() override;
 
  Expression::Operation op() const override { return operation_; }
 
  const std::shared_ptr<T>& term() const { return term_; }
 
 protected:
  Predicate(Expression::Operation op, std::shared_ptr<T> term);
 
  Expression::Operation operation_;
  std::shared_ptr<T> term_;
};
 
class ICEBERG_EXPORT UnboundPredicate : public virtual Expression,
                                        public Unbound<Expression> {
 public:
  ~UnboundPredicate() override = default;
 
  std::shared_ptr<const NamedReference> reference() const override = 0;
 
  Result<std::shared_ptr<Expression>> Bind(const Schema& schema,
                                           bool case_sensitive) const override = 0;
 
  Result<std::shared_ptr<Expression>> Negate() const override = 0;
 
  bool is_unbound_predicate() const override { return true; }
 
  virtual const Term& unbound_term() const = 0;
 
  virtual std::span<const Literal> literals() const = 0;
 
 protected:
  UnboundPredicate() = default;
};
 
template <typename B>
class ICEBERG_EXPORT UnboundPredicateImpl : public UnboundPredicate,
                                            public Predicate<UnboundTerm<B>> {
  using BASE = Predicate<UnboundTerm<B>>;
 
 public:
  static Result<std::unique_ptr<UnboundPredicateImpl<B>>> Make(
      Expression::Operation op, std::shared_ptr<UnboundTerm<B>> term);
 
  static Result<std::unique_ptr<UnboundPredicateImpl<B>>> Make(
      Expression::Operation op, std::shared_ptr<UnboundTerm<B>> term, Literal value);
 
  static Result<std::unique_ptr<UnboundPredicateImpl<B>>> Make(
      Expression::Operation op, std::shared_ptr<UnboundTerm<B>> term,
      std::vector<Literal> values);
 
  ~UnboundPredicateImpl() override;
 
  std::shared_ptr<const NamedReference> reference() const override {
    return BASE::term()->reference();
  }
 
  std::string ToString() const override;
 
  bool Equals(const Expression& other) const override;
 
  Result<std::shared_ptr<Expression>> Bind(const Schema& schema,
                                           bool case_sensitive) const override;
 
  Result<std::shared_ptr<Expression>> Negate() const override;
 
  const Term& unbound_term() const override { return *BASE::term(); }
 
  std::span<const Literal> literals() const override { return values_; }
 
 private:
  UnboundPredicateImpl(Expression::Operation op, std::shared_ptr<UnboundTerm<B>> term);
  UnboundPredicateImpl(Expression::Operation op, std::shared_ptr<UnboundTerm<B>> term,
                       Literal value);
  UnboundPredicateImpl(Expression::Operation op, std::shared_ptr<UnboundTerm<B>> term,
                       std::vector<Literal> values);
 
  Result<std::shared_ptr<Expression>> BindUnaryOperation(
      std::shared_ptr<B> bound_term) const;
  Result<std::shared_ptr<Expression>> BindLiteralOperation(
      std::shared_ptr<B> bound_term) const;
  Result<std::shared_ptr<Expression>> BindInOperation(
      std::shared_ptr<B> bound_term) const;
 
 private:
  std::vector<Literal> values_;
};
 
class ICEBERG_EXPORT BoundPredicate : public Predicate<BoundTerm>, public Bound {
 public:
  ~BoundPredicate() override;
 
  using Predicate<BoundTerm>::op;
 
  using Predicate<BoundTerm>::term;
 
  std::shared_ptr<BoundReference> reference() override { return term_->reference(); }
 
  Result<Literal> Evaluate(const StructLike& data) const override;
 
  bool is_bound_predicate() const override { return true; }
 
  virtual Result<bool> Test(const Literal& value) const = 0;
 
  enum class Kind : int8_t {
    // A unary predicate (tests for null, not-null, etc.).
    kUnary = 0,
    // A literal predicate (compares against a literal).
    kLiteral,
    // A set predicate (tests membership in a set).
    kSet,
  };
 
  virtual Kind kind() const = 0;
 
 protected:
  BoundPredicate(Expression::Operation op, std::shared_ptr<BoundTerm> term);
};
 
class ICEBERG_EXPORT BoundUnaryPredicate : public BoundPredicate {
 public:
  static Result<std::unique_ptr<BoundUnaryPredicate>> Make(
      Expression::Operation op, std::shared_ptr<BoundTerm> term);
 
  ~BoundUnaryPredicate() override;
 
  Result<bool> Test(const Literal& value) const override;
 
  Kind kind() const override { return Kind::kUnary; }
 
  std::string ToString() const override;
 
  Result<std::shared_ptr<Expression>> Negate() const override;
 
  bool Equals(const Expression& other) const override;
 
 private:
  BoundUnaryPredicate(Expression::Operation op, std::shared_ptr<BoundTerm> term);
};
 
class ICEBERG_EXPORT BoundLiteralPredicate : public BoundPredicate {
 public:
  static Result<std::unique_ptr<BoundLiteralPredicate>> Make(
      Expression::Operation op, std::shared_ptr<BoundTerm> term, Literal literal);
 
  ~BoundLiteralPredicate() override;
 
  const Literal& literal() const { return literal_; }
 
  Result<bool> Test(const Literal& value) const override;
 
  Kind kind() const override { return Kind::kLiteral; }
 
  std::string ToString() const override;
 
  Result<std::shared_ptr<Expression>> Negate() const override;
 
  bool Equals(const Expression& other) const override;
 
 private:
  BoundLiteralPredicate(Expression::Operation op, std::shared_ptr<BoundTerm> term,
                        Literal literal);
 
  Literal literal_;
};
 
class ICEBERG_EXPORT BoundSetPredicate : public BoundPredicate {
 public:
  using LiteralSet = std::unordered_set<Literal, LiteralHash>;
 
  static Result<std::unique_ptr<BoundSetPredicate>> Make(
      Expression::Operation op, std::shared_ptr<BoundTerm> term,
      std::span<const Literal> literals);
 
  static Result<std::unique_ptr<BoundSetPredicate>> Make(Expression::Operation op,
                                                         std::shared_ptr<BoundTerm> term,
                                                         LiteralSet value_set);
 
  ~BoundSetPredicate() override;
 
  const LiteralSet& literal_set() const { return value_set_; }
 
  Result<bool> Test(const Literal& value) const override;
 
  Kind kind() const override { return Kind::kSet; }
 
  std::string ToString() const override;
 
  Result<std::shared_ptr<Expression>> Negate() const override;
 
  bool Equals(const Expression& other) const override;
 
 private:
  BoundSetPredicate(Expression::Operation op, std::shared_ptr<BoundTerm> term,
                    std::span<const Literal> literals);
 
  BoundSetPredicate(Expression::Operation op, std::shared_ptr<BoundTerm> term,
                    LiteralSet value_set);
 
  LiteralSet value_set_;
};
 
}  // namespace iceberg