HashJoin.cpp File Reference

#include "QueryEngine/JoinHashTable/HashJoin.h"
#include "QueryEngine/CodeGenerator.h"
#include "QueryEngine/ColumnFetcher.h"
#include "QueryEngine/EquiJoinCondition.h"
#include "QueryEngine/Execute.h"
#include "QueryEngine/ExpressionRewrite.h"
#include "QueryEngine/JoinHashTable/BaselineJoinHashTable.h"
#include "QueryEngine/JoinHashTable/OverlapsJoinHashTable.h"
#include "QueryEngine/JoinHashTable/PerfectJoinHashTable.h"
#include "QueryEngine/RangeTableIndexVisitor.h"
#include "QueryEngine/RuntimeFunctions.h"
#include "QueryEngine/ScalarExprVisitor.h"
#include <sstream>

Include dependency graph for HashJoin.cpp:

Go to the source code of this file.

Classes
class	AllColumnVarsVisitor

Namespaces
	anonymous_namespace{HashJoin.cpp}

Functions
template<typename T >
std::string	anonymous_namespace{HashJoin.cpp}::toStringFlat (const HashJoin *hash_table, const ExecutorDeviceType device_type, const int device_id)
std::ostream &	operator<< (std::ostream &os, const DecodedJoinHashBufferEntry &e)
std::ostream &	operator<< (std::ostream &os, const DecodedJoinHashBufferSet &s)
std::ostream &	operator<< (std::ostream &os, const InnerOuterStringOpInfos &inner_outer_string_op_infos)
std::string	toString (const InnerOuterStringOpInfos &inner_outer_string_op_infos)
std::ostream &	operator<< (std::ostream &os, const std::vector< InnerOuterStringOpInfos > &inner_outer_string_op_infos_pairs)
std::string	toString (const std::vector< InnerOuterStringOpInfos > &inner_outer_string_op_infos_pairs)
std::shared_ptr < Analyzer::ColumnVar >	getSyntheticColumnVar (std::string_view table, std::string_view column, int rte_idx, const Catalog_Namespace::Catalog &catalog)
void	setupSyntheticCaching (std::set< const Analyzer::ColumnVar * > cvs, Executor *executor)
std::vector< InputTableInfo >	getSyntheticInputTableInfo (std::set< const Analyzer::ColumnVar * > cvs, Executor *executor)
InnerOuter	anonymous_namespace{HashJoin.cpp}::get_cols (const Analyzer::BinOper *qual_bin_oper, const TemporaryTables *temporary_tables)
size_t	get_shard_count (const Analyzer::BinOper *join_condition, const Executor *executor)

Variables
bool	g_enable_overlaps_hashjoin

Function Documentation

size_t get_shard_count	(	const Analyzer::BinOper *	join_condition,
		const Executor *	executor
	)

Definition at line 1048 of file HashJoin.cpp.

References anonymous_namespace{HashJoin.cpp}::get_cols(), and get_shard_count().

Referenced by get_shard_count(), BaselineJoinHashTable::getShardCountForCondition(), PerfectJoinHashTable::reify(), PerfectJoinHashTable::shardCount(), and Executor::skipFragmentPair().

                                                 {
  const Analyzer::ColumnVar* inner_col{nullptr};
  const Analyzer::Expr* outer_col{nullptr};
  std::shared_ptr<Analyzer::BinOper> redirected_bin_oper;
  try {
    std::tie(inner_col, outer_col) =
        get_cols(join_condition, executor->getTemporaryTables());
  } catch (...) {
    return 0;
  }
  if (!inner_col || !outer_col) {
    return 0;
  }
  return get_shard_count({inner_col, outer_col}, executor);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<Analyzer::ColumnVar> getSyntheticColumnVar	(	std::string_view	table,
		std::string_view	column,
		int	rte_idx,
		const Catalog_Namespace::Catalog &	catalog
	)

Definition at line 561 of file HashJoin.cpp.

References CHECK, Catalog_Namespace::Catalog::getDatabaseId(), Catalog_Namespace::Catalog::getMetadataForColumn(), Catalog_Namespace::Catalog::getMetadataForTable(), kLINESTRING, kMULTIPOLYGON, kPOINT, and kPOLYGON.

Referenced by HashJoin::getSyntheticInstance().

                                             {
  auto tmeta = catalog.getMetadataForTable(std::string(table));
  CHECK(tmeta);

  auto cmeta = catalog.getMetadataForColumn(tmeta->tableId, std::string(column));
  CHECK(cmeta);

  auto ti = cmeta->columnType;

  if (ti.is_geometry() && ti.get_type() != kPOINT) {
    int geoColumnId{0};
    switch (ti.get_type()) {
      case kLINESTRING: {
        geoColumnId = cmeta->columnId + 2;
        break;
      }
      case kPOLYGON: {
        geoColumnId = cmeta->columnId + 3;
        break;
      }
      case kMULTIPOLYGON: {
        geoColumnId = cmeta->columnId + 4;
        break;
      }
      default:
        CHECK(false);
    }
    cmeta = catalog.getMetadataForColumn(tmeta->tableId, geoColumnId);
    CHECK(cmeta);
    ti = cmeta->columnType;
  }

  auto cv = std::make_shared<Analyzer::ColumnVar>(
      ti,
      shared::ColumnKey{catalog.getDatabaseId(), tmeta->tableId, cmeta->columnId},
      rte_idx);
  return cv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector<InputTableInfo> getSyntheticInputTableInfo	(	std::set< const Analyzer::ColumnVar * >	cvs,
		Executor *	executor
	)

Definition at line 648 of file HashJoin.cpp.

References CHECK, and Catalog_Namespace::get_metadata_for_table().

Referenced by HashJoin::getSyntheticInstance().

                        {
  std::unordered_set<shared::TableKey> phys_table_ids;
  for (auto cv : cvs) {
    phys_table_ids.insert(cv->getTableKey());
  }

  // NOTE(sy): This vector ordering seems to work for now, but maybe we need to
  // review how rte_idx is assigned for ColumnVars. See for example Analyzer.h
  // and RelAlgExecutor.cpp and rte_idx there.
  std::vector<InputTableInfo> query_infos;
  query_infos.reserve(phys_table_ids.size());
  size_t i = 0;
  for (const auto& table_key : phys_table_ids) {
    auto td = Catalog_Namespace::get_metadata_for_table(table_key);
    CHECK(td);
    query_infos.push_back({table_key, td->fragmenter->getFragmentsForQuery()});
    ++i;
  }

  return query_infos;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::ostream& operator<<	(	std::ostream &	os,
		const DecodedJoinHashBufferEntry &	e
	)

Definition at line 126 of file HashJoin.cpp.

References DecodedJoinHashBufferEntry::key, and DecodedJoinHashBufferEntry::payload.

                                                                            {
  os << "  {{";
  bool first = true;
  for (auto k : e.key) {
    if (!first) {
      os << ",";
    } else {
      first = false;
    }
    os << k;
  }
  os << "}, ";
  os << "{";
  first = true;
  for (auto p : e.payload) {
    if (!first) {
      os << ", ";
    } else {
      first = false;
    }
    os << p;
  }
  os << "}}";
  return os;
}

std::ostream& operator<<	(	std::ostream &	os,
		const DecodedJoinHashBufferSet &	s
	)

Definition at line 152 of file HashJoin.cpp.

                                                                          {
  os << "{\n";
  bool first = true;
  for (auto e : s) {
    if (!first) {
      os << ",\n";
    } else {
      first = false;
    }
    os << e;
  }
  if (!s.empty()) {
    os << "\n";
  }
  os << "}\n";
  return os;
}

std::ostream& operator<<	(	std::ostream &	os,
		const InnerOuterStringOpInfos &	inner_outer_string_op_infos
	)

Definition at line 170 of file HashJoin.cpp.

                                                                                     {
  os << "(" << inner_outer_string_op_infos.first << ", "
     << inner_outer_string_op_infos.second << ")";
  return os;
}

std::ostream& operator<<	(	std::ostream &	os,
		const std::vector< InnerOuterStringOpInfos > &	inner_outer_string_op_infos_pairs
	)

Definition at line 183 of file HashJoin.cpp.

                                                                                 {
  os << "[";
  bool first_elem = true;
  for (const auto& inner_outer_string_op_infos : inner_outer_string_op_infos_pairs) {
    if (!first_elem) {
      os << ", ";
    }
    first_elem = false;
    os << inner_outer_string_op_infos;
  }
  os << "]";
  return os;
}

void setupSyntheticCaching	(	std::set< const Analyzer::ColumnVar * >	cvs,
		Executor *	executor
	)

Definition at line 632 of file HashJoin.cpp.

References PhysicalInput::table_id.

Referenced by HashJoin::getSyntheticInstance().

                                                                                     {
  std::unordered_set<shared::TableKey> phys_table_ids;
  for (auto cv : cvs) {
    phys_table_ids.insert(cv->getTableKey());
  }

  std::unordered_set<PhysicalInput> phys_inputs;
  for (auto cv : cvs) {
    const auto& column_key = cv->getColumnKey();
    phys_inputs.emplace(
        PhysicalInput{column_key.column_id, column_key.table_id, column_key.db_id});
  }

  executor->setupCaching(phys_inputs, phys_table_ids);
}

Here is the caller graph for this function:

std::string toString

(

const InnerOuterStringOpInfos &

inner_outer_string_op_infos

)

Definition at line 177 of file HashJoin.cpp.

                                                                               {
  std::ostringstream os;
  os << inner_outer_string_op_infos;
  return os.str();
}

std::string toString

(

const std::vector< InnerOuterStringOpInfos > &

inner_outer_string_op_infos_pairs

)

Definition at line 199 of file HashJoin.cpp.

                                                                                 {
  std::ostringstream os;
  os << inner_outer_string_op_infos_pairs;
  return os.str();
}

Variable Documentation

bool g_enable_overlaps_hashjoin

Definition at line 102 of file Execute.cpp.