OutputBufferInitialization.cpp File Reference

#include "OutputBufferInitialization.h"
#include "BufferCompaction.h"
#include "Descriptors/QueryMemoryDescriptor.h"
#include "TypePunning.h"
#include "../Analyzer/Analyzer.h"

Include dependency graph for OutputBufferInitialization.cpp:

Go to the source code of this file.

Functions
std::vector< int64_t >	init_agg_val_vec (const std::vector< TargetInfo > &targets, const QueryMemoryDescriptor &query_mem_desc)
std::pair< int64_t, int64_t >	inline_int_max_min (const size_t byte_width)
std::pair< uint64_t, uint64_t >	inline_uint_max_min (const size_t byte_width)
int64_t	get_agg_initial_val (const SQLAgg agg, const SQLTypeInfo &ti, const bool enable_compaction, const unsigned min_byte_width_to_compact)
std::vector< int64_t >	init_agg_val_vec (const std::vector< Analyzer::Expr * > &targets, const std::list< std::shared_ptr< Analyzer::Expr >> &quals, const QueryMemoryDescriptor &query_mem_desc)
const Analyzer::Expr *	agg_arg (const Analyzer::Expr *expr)
bool	constrained_not_null (const Analyzer::Expr *expr, const std::list< std::shared_ptr< Analyzer::Expr >> &quals)

Variables
bool	g_bigint_count

Function Documentation

const Analyzer::Expr* agg_arg

(

const Analyzer::Expr *

expr

)

Definition at line 296 of file OutputBufferInitialization.cpp.

References Analyzer::AggExpr::get_arg().

Referenced by TargetExprCodegen::codegen(), TargetExprCodegen::codegenAggregate(), get_compact_type(), anonymous_namespace{GroupByAndAggregate.cpp}::get_keyless_info(), target_info::get_target_info_impl(), init_agg_val_vec(), TargetExprCodegenBuilder::operator()(), and set_compact_type().

                                                      {
  const auto agg_expr = dynamic_cast<const Analyzer::AggExpr*>(expr);
  return agg_expr ? agg_expr->get_arg() : nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool constrained_not_null	(	const Analyzer::Expr *	expr,
		const std::list< std::shared_ptr< Analyzer::Expr >> &	quals
	)

Definition at line 301 of file OutputBufferInitialization.cpp.

References kISNOTNULL, kISNULL, and kNOT.

Referenced by anonymous_namespace{GroupByAndAggregate.cpp}::get_keyless_info(), init_agg_val_vec(), and TargetExprCodegenBuilder::operator()().

                                                                             {
  for (const auto& qual : quals) {
    auto uoper = std::dynamic_pointer_cast<Analyzer::UOper>(qual);
    if (!uoper) {
      continue;
    }
    bool is_negated{false};
    if (uoper->get_optype() == kNOT) {
      uoper = std::dynamic_pointer_cast<Analyzer::UOper>(uoper->get_own_operand());
      is_negated = true;
    }
    if (uoper && (uoper->get_optype() == kISNOTNULL ||
                  (is_negated && uoper->get_optype() == kISNULL))) {
      if (*uoper->get_own_operand() == *expr) {
        return true;
      }
    }
  }
  return false;
}

Here is the caller graph for this function:

int64_t get_agg_initial_val	(	const SQLAgg	agg,
		const SQLTypeInfo &	ti,
		const bool	enable_compaction,
		const unsigned	min_byte_width_to_compact
	)

Definition at line 126 of file OutputBufferInitialization.cpp.

References CHECK, compact_byte_width(), get_bit_width(), SQLTypeInfo::get_logical_size(), SQLTypeInfo::get_notnull(), inline_fp_null_val(), inline_int_null_val(), SQLTypeInfo::is_fp(), SQLTypeInfo::is_string(), kAPPROX_COUNT_DISTINCT, kAPPROX_QUANTILE, kAVG, kCOUNT, kCOUNT_IF, kMAX, kMIN, kMODE, kSAMPLE, kSINGLE_VALUE, kSUM, and kSUM_IF.

Referenced by anonymous_namespace{TargetExprBuilder.cpp}::get_initial_agg_val(), anonymous_namespace{GroupByAndAggregate.cpp}::get_keyless_info(), and init_agg_val_vec().

                                                                      {
  CHECK(!ti.is_string() || (shared::is_any<kSINGLE_VALUE, kSAMPLE, kMODE>(agg))) << agg;
  const auto byte_width =
      enable_compaction
          ? compact_byte_width(static_cast<unsigned>(get_bit_width(ti) >> 3),
                               unsigned(min_byte_width_to_compact))
          : sizeof(int64_t);
  CHECK(ti.get_logical_size() < 0 ||
        byte_width >= static_cast<unsigned>(ti.get_logical_size()));
  switch (agg) {
    case kSUM:
    case kSUM_IF: {
      if (!ti.get_notnull()) {
        if (ti.is_fp()) {
          switch (byte_width) {
            case 4: {
              const float null_float = inline_fp_null_val(ti);
              return *reinterpret_cast<const int32_t*>(may_alias_ptr(&null_float));
            }
            case 8: {
              const double null_double = inline_fp_null_val(ti);
              return *reinterpret_cast<const int64_t*>(may_alias_ptr(&null_double));
            }
            default:
              CHECK(false);
          }
        } else {
          return inline_int_null_val(ti);
        }
      }
      switch (byte_width) {
        case 4: {
          const float zero_float{0.};
          return ti.is_fp()
                     ? *reinterpret_cast<const int32_t*>(may_alias_ptr(&zero_float))
                     : 0;
        }
        case 8: {
          const double zero_double{0.};
          return ti.is_fp()
                     ? *reinterpret_cast<const int64_t*>(may_alias_ptr(&zero_double))
                     : 0;
        }
        default:
          CHECK(false);
      }
    }
    case kAVG:
    case kCOUNT:
    case kCOUNT_IF:
    case kAPPROX_COUNT_DISTINCT:
      return 0;
    case kAPPROX_QUANTILE:
    case kMODE:
      return {};  // Init value is a pointer set elsewhere.
    case kMIN: {
      switch (byte_width) {
        case 1: {
          CHECK(!ti.is_fp());
          return ti.get_notnull() ? std::numeric_limits<int8_t>::max()
                                  : inline_int_null_val(ti);
        }
        case 2: {
          CHECK(!ti.is_fp());
          return ti.get_notnull() ? std::numeric_limits<int16_t>::max()
                                  : inline_int_null_val(ti);
        }
        case 4: {
          const float max_float = std::numeric_limits<float>::max();
          const float null_float =
              ti.is_fp() ? static_cast<float>(inline_fp_null_val(ti)) : 0.;
          return ti.is_fp()
                     ? (ti.get_notnull()
                            ? *reinterpret_cast<const int32_t*>(may_alias_ptr(&max_float))
                            : *reinterpret_cast<const int32_t*>(
                                  may_alias_ptr(&null_float)))
                     : (ti.get_notnull() ? std::numeric_limits<int32_t>::max()
                                         : inline_int_null_val(ti));
        }
        case 8: {
          const double max_double = std::numeric_limits<double>::max();
          const double null_double{ti.is_fp() ? inline_fp_null_val(ti) : 0.};
          return ti.is_fp() ? (ti.get_notnull() ? *reinterpret_cast<const int64_t*>(
                                                      may_alias_ptr(&max_double))
                                                : *reinterpret_cast<const int64_t*>(
                                                      may_alias_ptr(&null_double)))
                            : (ti.get_notnull() ? std::numeric_limits<int64_t>::max()
                                                : inline_int_null_val(ti));
        }
        default:
          CHECK(false);
      }
    }
    case kSINGLE_VALUE:
    case kSAMPLE:
    case kMAX: {
      switch (byte_width) {
        case 1: {
          CHECK(!ti.is_fp());
          return ti.get_notnull() ? std::numeric_limits<int8_t>::min()
                                  : inline_int_null_val(ti);
        }
        case 2: {
          CHECK(!ti.is_fp());
          return ti.get_notnull() ? std::numeric_limits<int16_t>::min()
                                  : inline_int_null_val(ti);
        }
        case 4: {
          const float min_float = -std::numeric_limits<float>::max();
          const float null_float =
              ti.is_fp() ? static_cast<float>(inline_fp_null_val(ti)) : 0.;
          return (ti.is_fp())
                     ? (ti.get_notnull()
                            ? *reinterpret_cast<const int32_t*>(may_alias_ptr(&min_float))
                            : *reinterpret_cast<const int32_t*>(
                                  may_alias_ptr(&null_float)))
                     : (ti.get_notnull() ? std::numeric_limits<int32_t>::min()
                                         : inline_int_null_val(ti));
        }
        case 8: {
          const double min_double = -std::numeric_limits<double>::max();
          const double null_double{ti.is_fp() ? inline_fp_null_val(ti) : 0.};
          return ti.is_fp() ? (ti.get_notnull() ? *reinterpret_cast<const int64_t*>(
                                                      may_alias_ptr(&min_double))
                                                : *reinterpret_cast<const int64_t*>(
                                                      may_alias_ptr(&null_double)))
                            : (ti.get_notnull() ? std::numeric_limits<int64_t>::min()
                                                : inline_int_null_val(ti));
        }
        default:
          CHECK(false);
      }
    }
    default:
      abort();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<int64_t> init_agg_val_vec	(	const std::vector< TargetInfo > &	targets,
		const QueryMemoryDescriptor &	query_mem_desc
	)

Definition at line 26 of file OutputBufferInitialization.cpp.

References CHECK_GT, CHECK_LT, get_agg_initial_val(), get_compact_type(), QueryMemoryDescriptor::getCompactByteWidth(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), QueryMemoryDescriptor::getSlotCount(), QueryMemoryDescriptor::isGroupBy(), QueryMemoryDescriptor::isLogicalSizedColumnsAllowed(), kAVG, kENCODING_NONE, kSAMPLE, and takes_float_argument().

Referenced by init_agg_val_vec().

                                                                                   {
  std::vector<int64_t> agg_init_vals;
  agg_init_vals.reserve(query_mem_desc.getSlotCount());
  const bool is_group_by{query_mem_desc.isGroupBy()};
  for (size_t target_idx = 0, agg_col_idx = 0; target_idx < targets.size();
       ++target_idx, ++agg_col_idx) {
    CHECK_LT(agg_col_idx, query_mem_desc.getSlotCount());
    const auto agg_info = targets[target_idx];
    const auto& agg_ti = agg_info.sql_type;
    if (!agg_info.is_agg || agg_info.agg_kind == kSAMPLE) {
      if (agg_info.agg_kind == kSAMPLE && agg_ti.is_string() &&
          agg_ti.get_compression() != kENCODING_NONE) {
        agg_init_vals.push_back(
            get_agg_initial_val(agg_info.agg_kind,
                                agg_ti,
                                is_group_by,
                                query_mem_desc.getCompactByteWidth()));
        continue;
      }
      if (query_mem_desc.getPaddedSlotWidthBytes(agg_col_idx) > 0) {
        agg_init_vals.push_back(0);
      }
      if (agg_info.is_varlen_projection) {
        continue;
      }
      if (agg_ti.is_array() ||
          (agg_ti.is_string() && agg_ti.get_compression() == kENCODING_NONE)) {
        agg_init_vals.push_back(0);
      }
      if (agg_ti.is_geometry()) {
        agg_init_vals.push_back(0);
        for (auto i = 1; i < agg_ti.get_physical_coord_cols(); ++i) {
          agg_init_vals.push_back(0);
          agg_init_vals.push_back(0);
        }
      }
      continue;
    }
    CHECK_GT(query_mem_desc.getPaddedSlotWidthBytes(agg_col_idx), 0);
    const bool float_argument_input = takes_float_argument(agg_info);
    const auto chosen_bytes = query_mem_desc.isLogicalSizedColumnsAllowed()
                                  ? query_mem_desc.getPaddedSlotWidthBytes(agg_col_idx)
                                  : query_mem_desc.getCompactByteWidth();
    auto init_ti = get_compact_type(agg_info);
    if (!is_group_by) {
      init_ti.set_notnull(false);
    }
    agg_init_vals.push_back(
        get_agg_initial_val(agg_info.agg_kind,
                            init_ti,
                            is_group_by || float_argument_input,
                            (float_argument_input ? sizeof(float) : chosen_bytes)));
    if (kAVG == agg_info.agg_kind) {
      ++agg_col_idx;
      agg_init_vals.push_back(0);
    }
  }
  return agg_init_vals;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<int64_t> init_agg_val_vec	(	const std::vector< Analyzer::Expr * > &	targets,
		const std::list< std::shared_ptr< Analyzer::Expr >> &	quals,
		const QueryMemoryDescriptor &	query_mem_desc
	)

Definition at line 267 of file OutputBufferInitialization.cpp.

References agg_arg(), constrained_not_null(), g_bigint_count, get_target_info(), QueryMemoryDescriptor::getQueryDescriptionType(), QueryMemoryDescriptor::getSlotCount(), init_agg_val_vec(), heavyai::NonGroupedAggregate, and set_notnull().

                                                 {
  std::vector<TargetInfo> target_infos;
  target_infos.reserve(targets.size());
  const auto agg_col_count = query_mem_desc.getSlotCount();
  for (size_t target_idx = 0, agg_col_idx = 0;
       target_idx < targets.size() && agg_col_idx < agg_col_count;
       ++target_idx, ++agg_col_idx) {
    const auto target_expr = targets[target_idx];
    auto target = get_target_info(target_expr, g_bigint_count);
    auto arg_expr = agg_arg(target_expr);
    if (arg_expr) {
      if (query_mem_desc.getQueryDescriptionType() ==
              QueryDescriptionType::NonGroupedAggregate &&
          target.is_agg &&
          shared::is_any<kMIN, kMAX, kSUM, kSUM_IF, kAVG, kAPPROX_QUANTILE, kMODE>(
              target.agg_kind)) {
        set_notnull(target, false);
      } else if (constrained_not_null(arg_expr, quals)) {
        set_notnull(target, true);
      }
    }
    target_infos.push_back(target);
  }
  return init_agg_val_vec(target_infos, query_mem_desc);
}

Here is the call graph for this function:

std::pair<int64_t, int64_t> inline_int_max_min

(

const size_t

byte_width

)

Definition at line 87 of file OutputBufferInitialization.cpp.

Referenced by CgenState::inlineIntMaxMin(), and SqliteMemDatabase::runSelect().

                                                                      {
  switch (byte_width) {
    case 1:
      return std::make_pair(std::numeric_limits<int8_t>::max(),
                            std::numeric_limits<int8_t>::min());
    case 2:
      return std::make_pair(std::numeric_limits<int16_t>::max(),
                            std::numeric_limits<int16_t>::min());
    case 4:
      return std::make_pair(std::numeric_limits<int32_t>::max(),
                            std::numeric_limits<int32_t>::min());
    case 8:
      return std::make_pair(std::numeric_limits<int64_t>::max(),
                            std::numeric_limits<int64_t>::min());
    default:
      abort();
  }
}

Here is the caller graph for this function:

std::pair<uint64_t, uint64_t> inline_uint_max_min

(

const size_t

byte_width

)

Definition at line 106 of file OutputBufferInitialization.cpp.

Referenced by CgenState::inlineIntMaxMin().

                                                                         {
  switch (byte_width) {
    case 1:
      return std::make_pair(std::numeric_limits<uint8_t>::max(),
                            std::numeric_limits<uint8_t>::min());
    case 2:
      return std::make_pair(std::numeric_limits<uint16_t>::max(),
                            std::numeric_limits<uint16_t>::min());
    case 4:
      return std::make_pair(std::numeric_limits<uint32_t>::max(),
                            std::numeric_limits<uint32_t>::min());
    case 8:
      return std::make_pair(std::numeric_limits<uint64_t>::max(),
                            std::numeric_limits<uint64_t>::min());
    default:
      abort();
  }
}

Here is the caller graph for this function:

Variable Documentation

bool g_bigint_count

Definition at line 54 of file GroupByAndAggregate.cpp.