HashJoin.h File Reference

#include <llvm/IR/Value.h>
#include <cstdint>
#include <set>
#include <string>
#include "Analyzer/Analyzer.h"
#include "DataMgr/Allocators/ThrustAllocator.h"
#include "QueryEngine/ColumnarResults.h"
#include "QueryEngine/CompilationOptions.h"
#include "QueryEngine/Descriptors/RowSetMemoryOwner.h"
#include "QueryEngine/ExpressionRange.h"
#include "QueryEngine/InputMetadata.h"
#include "QueryEngine/JoinHashTable/HashTable.h"
#include "QueryEngine/JoinHashTable/Runtime/HashJoinRuntime.h"
#include "StringOps/StringOpInfo.h"

Include dependency graph for HashJoin.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	TooManyHashEntries
class	TableMustBeReplicated
class	HashJoinFail
class	NeedsOneToManyHash
class	FailedToFetchColumn
class	FailedToJoinOnVirtualColumn
class	OverlapsHashTableTooBig
struct	ColumnsForDevice
struct	HashJoinMatchingSet
struct	CompositeKeyInfo
class	HashJoin

Typedefs
using	InnerOuter = std::pair< const Analyzer::ColumnVar *, const Analyzer::Expr * >
using	InnerOuterStringOpInfos = std::pair< std::vector< StringOps_Namespace::StringOpInfo >, std::vector< StringOps_Namespace::StringOpInfo >>

Enumerations
enum	InnerQualDecision { InnerQualDecision::IGNORE = 0, InnerQualDecision::UNKNOWN, InnerQualDecision::LHS, InnerQualDecision::RHS }

Functions
std::ostream &	operator<< (std::ostream &os, InnerQualDecision const decision)
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::ostream &	operator<< (std::ostream &os, const std::vector< InnerOuterStringOpInfos > &inner_outer_string_op_infos_pairs)
std::string	toString (const InnerOuterStringOpInfos &inner_outer_string_op_infos)
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, Executor *executor)
size_t	get_shard_count (const Analyzer::BinOper *join_condition, const Executor *executor)
size_t	get_shard_count (std::pair< const Analyzer::ColumnVar *, const Analyzer::Expr * > equi_pair, const Executor *executor)

Typedef Documentation

using InnerOuter = std::pair<const Analyzer::ColumnVar*, const Analyzer::Expr*>

Definition at line 95 of file HashJoin.h.

using InnerOuterStringOpInfos = std::pair<std::vector<StringOps_Namespace::StringOpInfo>, std::vector<StringOps_Namespace::StringOpInfo>>

Definition at line 97 of file HashJoin.h.

Enumeration Type Documentation

enum InnerQualDecision

strong

Enumerator
IGNORE
UNKNOWN
LHS
RHS

Definition at line 52 of file HashJoin.h.

{ IGNORE = 0, UNKNOWN, LHS, RHS };

Function Documentation

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

Definition at line 1045 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->getCatalog(), 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:

size_t get_shard_count	(	std::pair< const Analyzer::ColumnVar *, const Analyzer::Expr * >	equi_pair,
		const Executor *	executor
	)

Definition at line 111 of file PerfectJoinHashTable.cpp.

References CHECK, and anonymous_namespace{PerfectJoinHashTable.cpp}::shard_count_less_or_equal_device_count().

                              {
  const auto inner_col = equi_pair.first;
  const auto outer_col = dynamic_cast<const Analyzer::ColumnVar*>(equi_pair.second);
  if (!outer_col || inner_col->get_table_id() < 0 || outer_col->get_table_id() < 0) {
    return 0;
  }
  if (outer_col->get_rte_idx()) {
    return 0;
  }
  if (inner_col->get_type_info() != outer_col->get_type_info()) {
    return 0;
  }
  const auto catalog = executor->getCatalog();
  const auto inner_td = catalog->getMetadataForTable(inner_col->get_table_id());
  CHECK(inner_td);
  const auto outer_td = catalog->getMetadataForTable(outer_col->get_table_id());
  CHECK(outer_td);
  if (inner_td->shardedColumnId == 0 || outer_td->shardedColumnId == 0 ||
      inner_td->nShards != outer_td->nShards) {
    return 0;
  }
  if (!shard_count_less_or_equal_device_count(inner_td->tableId, executor)) {
    return 0;
  }
  // The two columns involved must be the ones on which the tables have been sharded on.
  return (inner_td->shardedColumnId == inner_col->get_column_id() &&
          outer_td->shardedColumnId == outer_col->get_column_id()) ||
                 (outer_td->shardedColumnId == inner_col->get_column_id() &&
                  inner_td->shardedColumnId == inner_col->get_column_id())
             ? inner_td->nShards
             : 0;
}

Here is the call graph for this function:

std::shared_ptr<Analyzer::ColumnVar> getSyntheticColumnVar	(	std::string_view	table,
		std::string_view	column,
		int	rte_idx,
		Executor *	executor
	)

Definition at line 555 of file HashJoin.cpp.

References CHECK, kLINESTRING, kMULTIPOLYGON, kPOINT, and kPOLYGON.

Referenced by HashJoin::getSyntheticInstance().

                                                                               {
  auto catalog = executor->getCatalog();
  CHECK(catalog);

  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, tmeta->tableId, cmeta->columnId, rte_idx);
  return cv;
}

Here is the caller graph for this function:

std::ostream& operator<< ( std::ostream &  os, InnerQualDecision const  decision  )

inline

Definition at line 55 of file HashJoin.h.

                                                                                {
  constexpr char const* strings[]{"IGNORE", "UNKNOWN", "LHS", "RHS"};
  return os << strings[static_cast<int>(decision)];
}

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;
}

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();
}