expr.h

Go to the documentation of this file.

// Copyright 2012 Cloudera Inc.
//
// Licensed 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.


//
//
//
//
//
//
//
//
//
//
//
//

#ifndef IMPALA_EXPRS_EXPR_H
#define IMPALA_EXPRS_EXPR_H

#include <string>
#include <vector>

#include "common/status.h"
#include "impala-ir/impala-ir-functions.h"
#include "runtime/descriptors.h"
#include "runtime/decimal-value.h"
#include "runtime/lib-cache.h"
#include "runtime/raw-value.h"
#include "runtime/tuple.h"
#include "runtime/tuple-row.h"
#include "runtime/string-value.h"
#include "runtime/timestamp-value.h"
#include "udf/udf.h"

using namespace impala_udf;

namespace llvm {
  class BasicBlock;
  class Function;
  class Type;
  class Value;
};

namespace impala {

class Expr;
class IsNullExpr;
class LlvmCodeGen;
class ObjectPool;
class RowDescriptor;
class RuntimeState;
class TColumnValue;
class TExpr;
class TExprNode;

class Expr {
 public:
  virtual ~Expr();

  virtual BooleanVal GetBooleanVal(ExprContext* context, TupleRow*);
  virtual TinyIntVal GetTinyIntVal(ExprContext* context, TupleRow*);
  virtual SmallIntVal GetSmallIntVal(ExprContext* context, TupleRow*);
  virtual IntVal GetIntVal(ExprContext* context, TupleRow*);
  virtual BigIntVal GetBigIntVal(ExprContext* context, TupleRow*);
  virtual FloatVal GetFloatVal(ExprContext* context, TupleRow*);
  virtual DoubleVal GetDoubleVal(ExprContext* context, TupleRow*);
  virtual StringVal GetStringVal(ExprContext* context, TupleRow*);
  virtual TimestampVal GetTimestampVal(ExprContext* context, TupleRow*);
  virtual DecimalVal GetDecimalVal(ExprContext* context, TupleRow*);

  int output_scale() const { return output_scale_; }

  void AddChild(Expr* expr) { children_.push_back(expr); }
  Expr* GetChild(int i) const { return children_[i]; }
  int GetNumChildren() const { return children_.size(); }

  const ColumnType& type() const { return type_; }
  bool is_slotref() const { return is_slotref_; }

  const std::vector<Expr*>& children() const { return children_; }

  virtual bool IsConstant() const;

  virtual int GetSlotIds(std::vector<SlotId>* slot_ids) const;

  static Status CreateExprTree(ObjectPool* pool, const TExpr& texpr, ExprContext** ctx);

  static Status CreateExprTrees(ObjectPool* pool, const std::vector<TExpr>& texprs,
      std::vector<ExprContext*>* ctxs);

  static Status Prepare(const std::vector<ExprContext*>& ctxs, RuntimeState* state,
                        const RowDescriptor& row_desc, MemTracker* tracker);

  static Status Open(const std::vector<ExprContext*>& ctxs, RuntimeState* state);

  static Status Clone(const std::vector<ExprContext*>& ctxs, RuntimeState* state,
                      std::vector<ExprContext*>* new_ctxs);

  static void Close(const std::vector<ExprContext*>& ctxs, RuntimeState* state);

  static Expr* CreateLiteral(ObjectPool* pool, const ColumnType& type, void* data);

  static Expr* CreateLiteral(ObjectPool* pool, const ColumnType& type,
      const std::string&);

  static int ComputeResultsLayout(const std::vector<Expr*>& exprs,
      std::vector<int>* offsets, int* var_result_begin);
  static int ComputeResultsLayout(const std::vector<ExprContext*>& ctxs,
      std::vector<int>* offsets, int* var_result_begin);

  //
  virtual Status GetCodegendComputeFn(RuntimeState* state, llvm::Function** fn) = 0;

  virtual AnyVal* GetConstVal(ExprContext* context);

  virtual std::string DebugString() const;
  static std::string DebugString(const std::vector<Expr*>& exprs);
  static std::string DebugString(const std::vector<ExprContext*>& ctxs);

  static void InitBuiltinsDummy();

  static const char* LLVM_CLASS_NAME;

 protected:
  friend class AggFnEvaluator;
  friend class CastExpr;
  friend class ComputeFunctions;
  friend class DecimalFunctions;
  friend class DecimalLliteral;
  friend class DecimalOperators;
  friend class MathFunctions;
  friend class StringFunctions;
  friend class TimestampFunctions;
  friend class ConditionalFunctions;
  friend class UtilityFunctions;
  friend class CaseExpr;
  friend class InPredicate;
  friend class FunctionCall;
  friend class ScalarFnCall;

  Expr(const ColumnType& type, bool is_slotref = false);
  Expr(const TExprNode& node, bool is_slotref = false);

  //
  virtual Status Prepare(RuntimeState* state, const RowDescriptor& row_desc,
                         ExprContext* context);

  //
  virtual Status Open(RuntimeState* state, ExprContext* context,
      FunctionContext::FunctionStateScope scope = FunctionContext::FRAGMENT_LOCAL);

  //
  virtual void Close(RuntimeState* state, ExprContext* context,
      FunctionContext::FunctionStateScope scope = FunctionContext::FRAGMENT_LOCAL);

  LibCache::LibCacheEntry* cache_entry_;

  TFunction fn_;

  const bool is_slotref_;
  const ColumnType type_;
  std::vector<Expr*> children_;
  int output_scale_;

  int context_index_;

  llvm::Function* ir_compute_fn_;

  boost::scoped_ptr<AnyVal> constant_val_;

  FunctionContext* RegisterFunctionContext(
      ExprContext* ctx, RuntimeState* state, int varargs_buffer_size = 0);

  llvm::Function* CreateIrFunctionPrototype(LlvmCodeGen* codegen, const std::string& name,
                                            llvm::Value* (*args)[2]);

  //
  Status GetCodegendComputeFnWrapper(RuntimeState* state, llvm::Function** fn);

  llvm::Function* GetStaticGetValWrapper(ColumnType type, LlvmCodeGen* codegen);

  std::string DebugString(const std::string& expr_name) const {
    std::stringstream out;
    out << expr_name << "(" << Expr::DebugString() << ")";
    return out.str();
  }

 private:
  friend class ExprContext;
  friend class ExprTest;

  static Status CreateExpr(ObjectPool* pool, const TExprNode& texpr_node, Expr** expr);

  static Status CreateTreeFromThrift(ObjectPool* pool,
      const std::vector<TExprNode>& nodes, Expr* parent, int* node_idx,
      Expr** root_expr, ExprContext** ctx);

  //
  static BooleanVal GetBooleanVal(Expr* expr, ExprContext* context, TupleRow* row);
  static TinyIntVal GetTinyIntVal(Expr* expr, ExprContext* context, TupleRow* row);
  static SmallIntVal GetSmallIntVal(Expr* expr, ExprContext* context, TupleRow* row);
  static IntVal GetIntVal(Expr* expr, ExprContext* context, TupleRow* row);
  static BigIntVal GetBigIntVal(Expr* expr, ExprContext* context, TupleRow* row);
  static FloatVal GetFloatVal(Expr* expr, ExprContext* context, TupleRow* row);
  static DoubleVal GetDoubleVal(Expr* expr, ExprContext* context, TupleRow* row);
  static StringVal GetStringVal(Expr* expr, ExprContext* context, TupleRow* row);
  static TimestampVal GetTimestampVal(Expr* expr, ExprContext* context, TupleRow* row);
  static DecimalVal GetDecimalVal(Expr* expr, ExprContext* context, TupleRow* row);
};

}

#endif