udf-internal.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_UDF_UDF_INTERNAL_H
#define IMPALA_UDF_UDF_INTERNAL_H

#include <boost/cstdint.hpp>
#include <map>
#include <string>
#include <string.h>
#include <vector>

#include "udf/udf.h"

namespace impala {

class FreePool;
class MemPool;
class RuntimeState;

class FunctionContextImpl {
 public:
  static impala_udf::FunctionContext* CreateContext(RuntimeState* state, MemPool* pool,
      const impala_udf::FunctionContext::TypeDesc& return_type,
      const std::vector<impala_udf::FunctionContext::TypeDesc>& arg_types,
      int varargs_buffer_size = 0, bool debug = false);

  static impala_udf::FunctionContext* CreateContext(RuntimeState* state, MemPool* pool,
      const impala_udf::FunctionContext::TypeDesc& intermediate_type,
      const impala_udf::FunctionContext::TypeDesc& return_type,
      const std::vector<impala_udf::FunctionContext::TypeDesc>& arg_types,
      int varargs_buffer_size = 0, bool debug = false);

  FunctionContextImpl(impala_udf::FunctionContext* parent);

  void Close();

  impala_udf::FunctionContext* Clone(MemPool* pool);

  uint8_t* AllocateLocal(int byte_size);

  void FreeLocalAllocations();

  void SetConstantArgs(const std::vector<impala_udf::AnyVal*>& constant_args);

  uint8_t* varargs_buffer() { return varargs_buffer_; }

  std::vector<impala_udf::AnyVal*>* staging_input_vals() { return &staging_input_vals_; }

  bool debug() { return debug_; }
  bool closed() { return closed_; }

  int64_t num_updates() const { return num_updates_; }
  int64_t num_removes() const { return num_removes_; }
  void set_num_updates(int64_t n) { num_updates_ = n; }
  void set_num_removes(int64_t n) { num_removes_ = n; }
  void IncrementNumUpdates(int64_t n = 1) { num_updates_ += n; }
  void IncrementNumRemoves(int64_t n = 1) { num_removes_ += n; }

  static const char* LLVM_FUNCTIONCONTEXT_NAME;

  RuntimeState* state() { return state_; }

 private:
  friend class impala_udf::FunctionContext;

  //
  uint8_t* varargs_buffer_;
  int varargs_buffer_size_;

  impala_udf::FunctionContext* context_;

  FreePool* pool_;

  RuntimeState* state_;

  bool debug_;

  impala_udf::FunctionContext::ImpalaVersion version_;

  std::string error_msg_;

  int64_t num_warnings_;

  int64_t num_updates_;
  int64_t num_removes_;

  std::map<uint8_t*, int> allocations_;
  std::vector<uint8_t*> local_allocations_;

  void* thread_local_fn_state_;
  void* fragment_local_fn_state_;

  int64_t external_bytes_tracked_;

  impala_udf::FunctionContext::TypeDesc intermediate_type_;

  impala_udf::FunctionContext::TypeDesc return_type_;

  std::vector<impala_udf::FunctionContext::TypeDesc> arg_types_;

  std::vector<impala_udf::AnyVal*> constant_args_;

  std::vector<impala_udf::AnyVal*> staging_input_vals_;

  bool closed_;
};

}

#endif