expression.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 <string>
 
#include "iceberg/iceberg_export.h"
#include "iceberg/result.h"
#include "iceberg/type_fwd.h"
#include "iceberg/util/formattable.h"
#include "iceberg/util/macros.h"
 
namespace iceberg {
 
class ICEBERG_EXPORT Expression : public util::Formattable {
 public:
  enum class Operation {
    kTrue,
    kFalse,
    kIsNull,
    kNotNull,
    kIsNan,
    kNotNan,
    kLt,
    kLtEq,
    kGt,
    kGtEq,
    kEq,
    kNotEq,
    kIn,
    kNotIn,
    kNot,
    kAnd,
    kOr,
    kStartsWith,
    kNotStartsWith,
    kCount,
    kCountNull,
    kCountStar,
    kMax,
    kMin
  };
 
  virtual ~Expression() = default;
 
  virtual Operation op() const = 0;
 
  virtual Result<std::shared_ptr<Expression>> Negate() const {
    return NotSupported("Expression cannot be negated");
  }
 
  virtual bool Equals(const Expression& other) const {
    // only bound predicates can be equivalent
    return false;
  }
 
  std::string ToString() const override { return "Expression"; }
 
  virtual bool is_unbound_predicate() const { return false; }
  virtual bool is_bound_predicate() const { return false; }
  virtual bool is_unbound_aggregate() const { return false; }
  virtual bool is_bound_aggregate() const { return false; }
};
 
class ICEBERG_EXPORT True : public Expression {
 public:
  static const std::shared_ptr<True>& Instance();
 
  Operation op() const override { return Operation::kTrue; }
 
  std::string ToString() const override { return "true"; }
 
  Result<std::shared_ptr<Expression>> Negate() const override;
 
  bool Equals(const Expression& other) const override {
    return other.op() == Operation::kTrue;
  }
 
 private:
  constexpr True() = default;
};
 
class ICEBERG_EXPORT False : public Expression {
 public:
  static const std::shared_ptr<False>& Instance();
 
  Operation op() const override { return Operation::kFalse; }
 
  std::string ToString() const override { return "false"; }
 
  Result<std::shared_ptr<Expression>> Negate() const override;
 
  bool Equals(const Expression& other) const override {
    return other.op() == Operation::kFalse;
  }
 
 private:
  constexpr False() = default;
};
 
class ICEBERG_EXPORT And : public Expression {
 public:
  static Result<std::unique_ptr<And>> Make(std::shared_ptr<Expression> left,
                                           std::shared_ptr<Expression> right);
 
  template <typename... Args>
  static Result<std::shared_ptr<Expression>> MakeFolded(std::shared_ptr<Expression> left,
                                                        std::shared_ptr<Expression> right,
                                                        Args&&... args)
    requires std::conjunction_v<std::is_same<Args, std::shared_ptr<Expression>>...>
  {
    if constexpr (sizeof...(args) == 0) {
      if (left->op() == Expression::Operation::kFalse ||
          right->op() == Expression::Operation::kFalse) {
        return False::Instance();
      }
 
      if (left->op() == Expression::Operation::kTrue) {
        return right;
      }
 
      if (right->op() == Expression::Operation::kTrue) {
        return left;
      }
 
      return And::Make(std::move(left), std::move(right));
    } else {
      ICEBERG_ASSIGN_OR_THROW(auto and_expr,
                              And::Make(std::move(left), std::move(right)));
 
      return And::MakeFolded(std::move(and_expr), std::forward<Args>(args)...);
    }
  }
 
  const std::shared_ptr<Expression>& left() const { return left_; }
 
  const std::shared_ptr<Expression>& right() const { return right_; }
 
  Operation op() const override { return Operation::kAnd; }
 
  std::string ToString() const override;
 
  Result<std::shared_ptr<Expression>> Negate() const override;
 
  bool Equals(const Expression& other) const override;
 
 private:
  And(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right);
 
  std::shared_ptr<Expression> left_;
  std::shared_ptr<Expression> right_;
};
 
class ICEBERG_EXPORT Or : public Expression {
 public:
  static Result<std::unique_ptr<Or>> Make(std::shared_ptr<Expression> left,
                                          std::shared_ptr<Expression> right);
 
  template <typename... Args>
  static Result<std::shared_ptr<Expression>> MakeFolded(std::shared_ptr<Expression> left,
                                                        std::shared_ptr<Expression> right,
                                                        Args&&... args)
    requires std::conjunction_v<std::is_same<Args, std::shared_ptr<Expression>>...>
  {
    if constexpr (sizeof...(args) == 0) {
      if (left->op() == Expression::Operation::kTrue ||
          right->op() == Expression::Operation::kTrue) {
        return True::Instance();
      }
 
      if (left->op() == Expression::Operation::kFalse) {
        return right;
      }
 
      if (right->op() == Expression::Operation::kFalse) {
        return left;
      }
 
      return Or::Make(std::move(left), std::move(right));
    } else {
      ICEBERG_ASSIGN_OR_THROW(auto or_expr, Or::Make(std::move(left), std::move(right)));
 
      return Or::MakeFolded(std::move(or_expr), std::forward<Args>(args)...);
    }
  }
 
  const std::shared_ptr<Expression>& left() const { return left_; }
 
  const std::shared_ptr<Expression>& right() const { return right_; }
 
  Operation op() const override { return Operation::kOr; }
 
  std::string ToString() const override;
 
  Result<std::shared_ptr<Expression>> Negate() const override;
 
  bool Equals(const Expression& other) const override;
 
 private:
  Or(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right);
 
  std::shared_ptr<Expression> left_;
  std::shared_ptr<Expression> right_;
};
 
class ICEBERG_EXPORT Not : public Expression {
 public:
  static Result<std::unique_ptr<Not>> Make(std::shared_ptr<Expression> child);
 
  static Result<std::shared_ptr<Expression>> MakeFolded(
      std::shared_ptr<Expression> child);
 
  const std::shared_ptr<Expression>& child() const { return child_; }
 
  Operation op() const override { return Operation::kNot; }
 
  std::string ToString() const override;
 
  Result<std::shared_ptr<Expression>> Negate() const override;
 
  bool Equals(const Expression& other) const override;
 
 private:
  explicit Not(std::shared_ptr<Expression> child);
 
  std::shared_ptr<Expression> child_;
};
 
ICEBERG_EXPORT std::string_view ToString(Expression::Operation op);
 
ICEBERG_EXPORT Result<Expression::Operation> Negate(Expression::Operation op);
 
template <typename B>
class ICEBERG_EXPORT Unbound {
 public:
  virtual Result<std::shared_ptr<B>> Bind(const Schema& schema,
                                          bool case_sensitive) const = 0;
 
  Result<std::shared_ptr<B>> Bind(const Schema& schema) const;
 
  virtual std::shared_ptr<class NamedReference> reference() = 0;
};
 
class ICEBERG_EXPORT Bound {
 public:
  virtual ~Bound();
 
  virtual Result<Literal> Evaluate(const StructLike& data) const = 0;
 
  virtual std::shared_ptr<class BoundReference> reference() = 0;
};
 
}  // namespace iceberg