expr-context.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_CONTEXT_H
#define IMPALA_EXPRS_EXPR_CONTEXT_H

#include <boost/scoped_ptr.hpp>

#include "common/status.h"
#include "exprs/expr-value.h"
#include "udf/udf.h"

using namespace impala_udf;

namespace impala {

class Expr;
class MemPool;
class MemTracker;
class RuntimeState;
class RowDescriptor;
class TColumnValue;
class TupleRow;

class ExprContext {
 public:
  ExprContext(Expr* root);
  ~ExprContext();

  Status Prepare(RuntimeState* state, const RowDescriptor& row_desc,
                 MemTracker* tracker);

  Status Open(RuntimeState* state);

  Status Clone(RuntimeState* state, ExprContext** new_context);

  void Close(RuntimeState* state);

  void* GetValue(TupleRow* row);

  void GetValue(TupleRow* row, bool as_ascii, TColumnValue* col_val);

  void PrintValue(TupleRow* row, std::string* str);
  void PrintValue(void* value, std::string* str);
  void PrintValue(void* value, std::stringstream* stream);
  void PrintValue(TupleRow* row, std::stringstream* stream);

  int Register(RuntimeState* state, const FunctionContext::TypeDesc& return_type,
               const std::vector<FunctionContext::TypeDesc>& arg_types,
               int varargs_buffer_size = 0);

  FunctionContext* fn_context(int i) {
    DCHECK_GE(i, 0);
    return fn_contexts_[i];
  }

  Expr* root() { return root_; }
  bool closed() { return closed_; }

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

  void FreeLocalAllocations();
  static void FreeLocalAllocations(const std::vector<ExprContext*>& ctxs);
  static void FreeLocalAllocations(const std::vector<FunctionContext*>& ctxs);

  static const char* LLVM_CLASS_NAME;

 private:
  friend class Expr;
  friend class HiveUdfCall;
  friend class ScalarFnCall;

  std::vector<FunctionContext*> fn_contexts_;

  FunctionContext** fn_contexts_ptr_;

  boost::scoped_ptr<MemPool> pool_;

  Expr* root_;

  ExprValue result_;

  bool is_clone_;
  bool prepared_;
  bool opened_;
  bool closed_;

  void* GetValue(Expr* e, TupleRow* row);
};

}

#endif