JoinHashTableInterface.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/JoinHashTable/HashJoinRuntime.h"

Include dependency graph for JoinHashTableInterface.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	FailedToFetchColumn
class	FailedToJoinOnVirtualColumn
struct	HashJoinMatchingSet
struct	DecodedJoinHashBufferEntry
class	JoinHashTableInterface

Typedefs
using	DecodedJoinHashBufferSet = std::set< DecodedJoinHashBufferEntry >
using	InnerOuter = std::pair< const Analyzer::ColumnVar *, const Analyzer::Expr * >

Functions
std::ostream &	operator<< (std::ostream &os, const DecodedJoinHashBufferEntry &e)
std::ostream &	operator<< (std::ostream &os, const DecodedJoinHashBufferSet &s)
std::shared_ptr< Analyzer::ColumnVar >	getSyntheticColumnVar (std::string_view table, std::string_view column, int rte_idx, Executor *executor)

Typedef Documentation

DecodedJoinHashBufferSet

using DecodedJoinHashBufferSet = std::set<DecodedJoinHashBufferEntry>

Definition at line 81 of file JoinHashTableInterface.h.

InnerOuter

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

Definition at line 83 of file JoinHashTableInterface.h.

Function Documentation

getSyntheticColumnVar()

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

Definition at line 547 of file JoinHashTableInterface.cpp.

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

Referenced by JoinHashTableInterface::getHashTypeString(), and JoinHashTableInterface::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:

operator<<() [1/2]

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

Definition at line 254 of file JoinHashTableInterface.cpp.

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

Referenced by JoinHashTableInterface::getHashTypeString().

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

Here is the caller graph for this function:

operator<<() [2/2]

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

Definition at line 280 of file JoinHashTableInterface.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;
}