expression.h

/* Copyright (c) 2021 OceanBase and/or its affiliates. All rights reserved.
miniob is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
         http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details. */
 
//
// Created by Wangyunlai on 2022/07/05.
//
 
#pragma once
 
#include "common/lang/string.h"
#include "common/lang/memory.h"
#include "common/lang/unordered_set.h"
#include "common/value.h"
#include "storage/field/field.h"
#include "sql/expr/aggregator.h"
#include "storage/common/chunk.h"
 
class Tuple;
 
enum class ExprType
{
  NONE,
  STAR,                 
  UNBOUND_FIELD,        
  UNBOUND_AGGREGATION,  
 
  FIELD,        
  VALUE,        
  CAST,         
  COMPARISON,   
  CONJUNCTION,  
  ARITHMETIC,   
  AGGREGATION,  
};
 
class Expression
{
public:
  Expression() = default;
 
  virtual ~Expression() = default;
 
  virtual unique_ptr<Expression> copy() const = 0;
 
  virtual bool equal(const Expression &other) const { return false; }
  virtual RC get_value(const Tuple &tuple, Value &value) const = 0;
 
  virtual RC try_get_value(Value &value) const { return RC::UNIMPLEMENTED; }
 
  virtual RC get_column(Chunk &chunk, Column &column) { return RC::UNIMPLEMENTED; }
 
  virtual ExprType type() const = 0;
 
  virtual AttrType value_type() const = 0;
 
  virtual int value_length() const { return -1; }
 
  virtual const char *name() const { return name_.c_str(); }
  virtual void        set_name(string name) { name_ = name; }
 
  virtual int  pos() const { return pos_; }
  virtual void set_pos(int pos) { pos_ = pos; }
 
  virtual RC eval(Chunk &chunk, vector<uint8_t> &select) { return RC::UNIMPLEMENTED; }
 
protected:
  int pos_ = -1;
 
private:
  string name_;
};
 
class StarExpr : public Expression
{
public:
  StarExpr() : table_name_() {}
  StarExpr(const char *table_name) : table_name_(table_name) {}
  virtual ~StarExpr() = default;
 
  unique_ptr<Expression> copy() const override { return make_unique<StarExpr>(table_name_.c_str()); }
 
  ExprType type() const override { return ExprType::STAR; }
  AttrType value_type() const override { return AttrType::UNDEFINED; }
 
  RC get_value(const Tuple &tuple, Value &value) const override { return RC::UNIMPLEMENTED; }  // 不需要实现
 
  const char *table_name() const { return table_name_.c_str(); }
 
private:
  string table_name_;
};
 
class UnboundFieldExpr : public Expression
{
public:
  UnboundFieldExpr(const string &table_name, const string &field_name)
      : table_name_(table_name), field_name_(field_name)
  {}
 
  virtual ~UnboundFieldExpr() = default;
 
  unique_ptr<Expression> copy() const override { return make_unique<UnboundFieldExpr>(table_name_, field_name_); }
 
  ExprType type() const override { return ExprType::UNBOUND_FIELD; }
  AttrType value_type() const override { return AttrType::UNDEFINED; }
 
  RC get_value(const Tuple &tuple, Value &value) const override { return RC::INTERNAL; }
 
  const char *table_name() const { return table_name_.c_str(); }
  const char *field_name() const { return field_name_.c_str(); }
 
private:
  string table_name_;
  string field_name_;
};
 
class FieldExpr : public Expression
{
public:
  FieldExpr() = default;
  FieldExpr(const Table *table, const FieldMeta *field) : field_(table, field) {}
  FieldExpr(const Field &field) : field_(field) {}
 
  virtual ~FieldExpr() = default;
 
  bool equal(const Expression &other) const override;
 
  unique_ptr<Expression> copy() const override { return make_unique<FieldExpr>(field_); }
 
  ExprType type() const override { return ExprType::FIELD; }
  AttrType value_type() const override { return field_.attr_type(); }
  int      value_length() const override { return field_.meta()->len(); }
 
  Field &field() { return field_; }
 
  const Field &field() const { return field_; }
 
  const char *table_name() const { return field_.table_name(); }
  const char *field_name() const { return field_.field_name(); }
 
  RC get_column(Chunk &chunk, Column &column) override;
 
  RC get_value(const Tuple &tuple, Value &value) const override;
 
private:
  Field field_;
};
 
class ValueExpr : public Expression
{
public:
  ValueExpr() = default;
  explicit ValueExpr(const Value &value) : value_(value) {}
 
  virtual ~ValueExpr() = default;
 
  bool equal(const Expression &other) const override;
 
  unique_ptr<Expression> copy() const override { return make_unique<ValueExpr>(value_); }
 
  RC get_value(const Tuple &tuple, Value &value) const override;
  RC get_column(Chunk &chunk, Column &column) override;
  RC try_get_value(Value &value) const override
  {
    value = value_;
    return RC::SUCCESS;
  }
 
  ExprType type() const override { return ExprType::VALUE; }
  AttrType value_type() const override { return value_.attr_type(); }
  int      value_length() const override { return value_.length(); }
 
  void         get_value(Value &value) const { value = value_; }
  const Value &get_value() const { return value_; }
 
private:
  Value value_;
};
 
class CastExpr : public Expression
{
public:
  CastExpr(unique_ptr<Expression> child, AttrType cast_type);
  virtual ~CastExpr();
 
  unique_ptr<Expression> copy() const override { return make_unique<CastExpr>(child_->copy(), cast_type_); }
 
  ExprType type() const override { return ExprType::CAST; }
 
  RC get_value(const Tuple &tuple, Value &value) const override;
 
  RC try_get_value(Value &value) const override;
 
  AttrType value_type() const override { return cast_type_; }
 
  unique_ptr<Expression> &child() { return child_; }
 
private:
  RC cast(const Value &value, Value &cast_value) const;
 
private:
  unique_ptr<Expression> child_;      
  AttrType               cast_type_;  
};
 
class ComparisonExpr : public Expression
{
public:
  ComparisonExpr(CompOp comp, unique_ptr<Expression> left, unique_ptr<Expression> right);
  virtual ~ComparisonExpr();
 
  ExprType type() const override { return ExprType::COMPARISON; }
  RC       get_value(const Tuple &tuple, Value &value) const override;
  AttrType value_type() const override { return AttrType::BOOLEANS; }
  CompOp   comp() const { return comp_; }
 
  unique_ptr<Expression> copy() const override
  {
    return make_unique<ComparisonExpr>(comp_, left_->copy(), right_->copy());
  }
 
  RC eval(Chunk &chunk, vector<uint8_t> &select) override;
 
  unique_ptr<Expression> &left() { return left_; }
  unique_ptr<Expression> &right() { return right_; }
 
  RC try_get_value(Value &value) const override;
 
  RC compare_value(const Value &left, const Value &right, bool &value) const;
 
  template <typename T>
  RC compare_column(const Column &left, const Column &right, vector<uint8_t> &result) const;
 
private:
  CompOp                 comp_;
  unique_ptr<Expression> left_;
  unique_ptr<Expression> right_;
};
 
class ConjunctionExpr : public Expression
{
public:
  enum class Type
  {
    AND,
    OR
  };
 
public:
  ConjunctionExpr(Type type, vector<unique_ptr<Expression>> &children);
  virtual ~ConjunctionExpr() = default;
 
  unique_ptr<Expression> copy() const override
  {
    vector<unique_ptr<Expression>> children;
    for (auto &child : children_) {
      children.emplace_back(child->copy());
    }
    return make_unique<ConjunctionExpr>(conjunction_type_, children);
  }
 
  ExprType type() const override { return ExprType::CONJUNCTION; }
  AttrType value_type() const override { return AttrType::BOOLEANS; }
  RC       get_value(const Tuple &tuple, Value &value) const override;
 
  Type conjunction_type() const { return conjunction_type_; }
 
  vector<unique_ptr<Expression>> &children() { return children_; }
 
private:
  Type                           conjunction_type_;
  vector<unique_ptr<Expression>> children_;
};
 
class ArithmeticExpr : public Expression
{
public:
  enum class Type
  {
    ADD,
    SUB,
    MUL,
    DIV,
    NEGATIVE,
  };
 
public:
  ArithmeticExpr(Type type, Expression *left, Expression *right);
  ArithmeticExpr(Type type, unique_ptr<Expression> left, unique_ptr<Expression> right);
  virtual ~ArithmeticExpr() = default;
 
  unique_ptr<Expression> copy() const override
  {
    if (right_) {
      return make_unique<ArithmeticExpr>(arithmetic_type_, left_->copy(), right_->copy());
    } else {
      return make_unique<ArithmeticExpr>(arithmetic_type_, left_->copy(), nullptr);
    }
  }
 
  bool     equal(const Expression &other) const override;
  ExprType type() const override { return ExprType::ARITHMETIC; }
 
  AttrType value_type() const override;
  int      value_length() const override
  {
    if (!right_) {
      return left_->value_length();
    }
    return 4;  // sizeof(float) or sizeof(int)
  };
 
  RC get_value(const Tuple &tuple, Value &value) const override;
 
  RC get_column(Chunk &chunk, Column &column) override;
 
  RC try_get_value(Value &value) const override;
 
  Type arithmetic_type() const { return arithmetic_type_; }
 
  unique_ptr<Expression> &left() { return left_; }
  unique_ptr<Expression> &right() { return right_; }
 
private:
  RC calc_value(const Value &left_value, const Value &right_value, Value &value) const;
 
  RC calc_column(const Column &left_column, const Column &right_column, Column &column) const;
 
  template <bool LEFT_CONSTANT, bool RIGHT_CONSTANT>
  RC execute_calc(const Column &left, const Column &right, Column &result, Type type, AttrType attr_type) const;
 
private:
  Type                   arithmetic_type_;
  unique_ptr<Expression> left_;
  unique_ptr<Expression> right_;
};
 
class UnboundAggregateExpr : public Expression
{
public:
  UnboundAggregateExpr(const char *aggregate_name, Expression *child);
  UnboundAggregateExpr(const char *aggregate_name, unique_ptr<Expression> child);
  virtual ~UnboundAggregateExpr() = default;
 
  ExprType type() const override { return ExprType::UNBOUND_AGGREGATION; }
 
  unique_ptr<Expression> copy() const override
  {
    return make_unique<UnboundAggregateExpr>(aggregate_name_.c_str(), child_->copy());
  }
 
  const char *aggregate_name() const { return aggregate_name_.c_str(); }
 
  unique_ptr<Expression> &child() { return child_; }
 
  RC       get_value(const Tuple &tuple, Value &value) const override { return RC::INTERNAL; }
  AttrType value_type() const override { return child_->value_type(); }
 
private:
  string                 aggregate_name_;
  unique_ptr<Expression> child_;
};
 
class AggregateExpr : public Expression
{
public:
  enum class Type
  {
    COUNT,
    SUM,
    AVG,
    MAX,
    MIN,
  };
 
public:
  AggregateExpr(Type type, Expression *child);
  AggregateExpr(Type type, unique_ptr<Expression> child);
  virtual ~AggregateExpr() = default;
 
  bool equal(const Expression &other) const override;
 
  unique_ptr<Expression> copy() const override { return make_unique<AggregateExpr>(aggregate_type_, child_->copy()); }
 
  ExprType type() const override { return ExprType::AGGREGATION; }
 
  AttrType value_type() const override { return child_->value_type(); }
  int      value_length() const override { return child_->value_length(); }
 
  RC get_value(const Tuple &tuple, Value &value) const override;
 
  RC get_column(Chunk &chunk, Column &column) override;
 
  Type aggregate_type() const { return aggregate_type_; }
 
  unique_ptr<Expression> &child() { return child_; }
 
  const unique_ptr<Expression> &child() const { return child_; }
 
  unique_ptr<Aggregator> create_aggregator() const;
 
public:
  static RC type_from_string(const char *type_str, Type &type);
 
private:
  Type                   aggregate_type_;
  unique_ptr<Expression> child_;
};