WindowFunctionContext Class Reference

#include <WindowContext.h>

Collaboration diagram for WindowFunctionContext:

Classes
struct	AggregateState

Public Types
using	Comparator = std::function< bool(const int64_t lhs, const int64_t rhs)>

Public Member Functions
	WindowFunctionContext (const Analyzer::WindowFunction *window_func, const std::shared_ptr< JoinHashTableInterface > &partitions, const size_t elem_count, const ExecutorDeviceType device_type)
	WindowFunctionContext (const WindowFunctionContext &)=delete
WindowFunctionContext &	operator= (const WindowFunctionContext &)=delete
	~WindowFunctionContext ()
void	addOrderColumn (const int8_t *column, const Analyzer::ColumnVar *col_var, const std::vector< std::shared_ptr< Chunk_NS::Chunk >> &chunks_owner)
void	compute ()
const Analyzer::WindowFunction *	getWindowFunction () const
const int8_t *	output () const
const int64_t *	aggregateState () const
const int64_t *	aggregateStateCount () const
int64_t	aggregateStatePendingOutputs () const
const int8_t *	partitionStart () const
const int8_t *	partitionEnd () const
size_t	elementCount () const
void	setRowNumber (llvm::Value *row_number)
llvm::Value *	getRowNumber () const

Private Member Functions
void	computePartition (int64_t *output_for_partition_buff, const size_t partition_size, const size_t off, const Analyzer::WindowFunction *window_func, const std::function< bool(const int64_t lhs, const int64_t rhs)> &comparator)
void	fillPartitionStart ()
void	fillPartitionEnd ()
const int32_t *	payload () const
const int32_t *	offsets () const
const int32_t *	counts () const
size_t	partitionCount () const

Static Private Member Functions
static Comparator	makeComparator (const Analyzer::ColumnVar *col_var, const int8_t *partition_values, const int32_t *partition_indices, const bool nulls_first)

Private Attributes
const Analyzer::WindowFunction *	window_func_
std::vector< std::vector < std::shared_ptr < Chunk_NS::Chunk > > >	order_columns_owner_
std::vector< const int8_t * >	order_columns_
std::shared_ptr < JoinHashTableInterface >	partitions_
size_t	elem_count_
int8_t *	output_
int8_t *	partition_start_
int8_t *	partition_end_
AggregateState	aggregate_state_
const ExecutorDeviceType	device_type_

Detailed Description

Definition at line 64 of file WindowContext.h.

Member Typedef Documentation

using WindowFunctionContext::Comparator = std::function<bool(const int64_t lhs, const int64_t rhs)>

Definition at line 115 of file WindowContext.h.

Constructor & Destructor Documentation

WindowFunctionContext::WindowFunctionContext	(	const Analyzer::WindowFunction *	window_func,
		const std::shared_ptr< JoinHashTableInterface > &	partitions,
		const size_t	elem_count,
		const ExecutorDeviceType	device_type
	)

Definition at line 27 of file WindowContext.cpp.

    : window_func_(window_func)
    , partitions_(partitions)
    , elem_count_(elem_count)
    , output_(nullptr)
    , partition_start_(nullptr)
    , partition_end_(nullptr)
    , device_type_(device_type) {}

WindowFunctionContext::WindowFunctionContext ( const WindowFunctionContext &  )

delete

WindowFunctionContext::~WindowFunctionContext

(

)

Definition at line 40 of file WindowContext.cpp.

References output_, partition_end_, and partition_start_.

                                              {
  free(output_);
  free(partition_start_);
  free(partition_end_);
}

Member Function Documentation

void WindowFunctionContext::addOrderColumn	(	const int8_t *	column,
		const Analyzer::ColumnVar *	col_var,
		const std::vector< std::shared_ptr< Chunk_NS::Chunk >> &	chunks_owner
	)

Definition at line 46 of file WindowContext.cpp.

References order_columns_, and order_columns_owner_.

                                                                 {
  order_columns_owner_.push_back(chunks_owner);
  order_columns_.push_back(column);
}

const int64_t * WindowFunctionContext::aggregateState

(

)

const

Definition at line 487 of file WindowContext.cpp.

References aggregate_state_, CHECK(), Analyzer::WindowFunction::getKind(), WindowFunctionContext::AggregateState::val, window_func_, and window_function_is_aggregate().

                                                           {
  CHECK(window_function_is_aggregate(window_func_->getKind()));
  return &aggregate_state_.val;
}

Here is the call graph for this function:

const int64_t * WindowFunctionContext::aggregateStateCount

(

)

const

Definition at line 492 of file WindowContext.cpp.

References aggregate_state_, CHECK(), WindowFunctionContext::AggregateState::count, Analyzer::WindowFunction::getKind(), window_func_, and window_function_is_aggregate().

                                                                {
  CHECK(window_function_is_aggregate(window_func_->getKind()));
  return &aggregate_state_.count;
}

Here is the call graph for this function:

int64_t WindowFunctionContext::aggregateStatePendingOutputs

(

)

const

Definition at line 497 of file WindowContext.cpp.

References aggregate_state_, CHECK(), Analyzer::WindowFunction::getKind(), WindowFunctionContext::AggregateState::outputs, window_func_, and window_function_is_aggregate().

                                                                  {
  CHECK(window_function_is_aggregate(window_func_->getKind()));
  return reinterpret_cast<int64_t>(&aggregate_state_.outputs);
}

Here is the call graph for this function:

void WindowFunctionContext::compute

(

)

Definition at line 399 of file WindowContext.cpp.

References CHECK(), CHECK_EQ, checked_malloc(), computePartition(), counts(), elem_count_, fillPartitionEnd(), fillPartitionStart(), Analyzer::WindowFunction::getCollation(), Analyzer::WindowFunction::getKind(), Analyzer::WindowFunction::getOrderKeys(), makeComparator(), offsets(), order_columns_, output_, partitionCount(), payload(), window_func_, anonymous_namespace{WindowContext.cpp}::window_function_buffer_element_size(), window_function_is_aggregate(), window_function_is_value(), and window_function_requires_peer_handling().

                                    {
  CHECK(!output_);
  output_ = static_cast<int8_t*>(checked_malloc(
      elem_count_ * window_function_buffer_element_size(window_func_->getKind())));
  if (window_function_is_aggregate(window_func_->getKind())) {
    fillPartitionStart();
    if (window_function_requires_peer_handling(window_func_)) {
      fillPartitionEnd();
    }
  }
  std::unique_ptr<int64_t[]> scratchpad(new int64_t[elem_count_]);
  int64_t off = 0;
  for (size_t i = 0; i < partitionCount(); ++i) {
    auto partition_size = counts()[i];
    if (partition_size == 0) {
      continue;
    }
    auto output_for_partition_buff = scratchpad.get() + offsets()[i];
    std::iota(output_for_partition_buff,
              output_for_partition_buff + partition_size,
              int64_t(0));
    std::vector<Comparator> comparators;
    const auto& order_keys = window_func_->getOrderKeys();
    const auto& collation = window_func_->getCollation();
    CHECK_EQ(order_keys.size(), collation.size());
    for (size_t order_column_idx = 0; order_column_idx < order_columns_.size();
         ++order_column_idx) {
      auto order_column_buffer = order_columns_[order_column_idx];
      const auto order_col =
          dynamic_cast<const Analyzer::ColumnVar*>(order_keys[order_column_idx].get());
      CHECK(order_col);
      const auto& order_col_collation = collation[order_column_idx];
      const auto asc_comparator = makeComparator(order_col,
                                                 order_column_buffer,
                                                 payload() + offsets()[i],
                                                 order_col_collation.nulls_first);
      auto comparator = asc_comparator;
      if (order_col_collation.is_desc) {
        comparator = [asc_comparator](const int64_t lhs, const int64_t rhs) {
          return asc_comparator(rhs, lhs);
        };
      }
      comparators.push_back(comparator);
    }
    const auto col_tuple_comparator = [&comparators](const int64_t lhs,
                                                     const int64_t rhs) {
      for (const auto& comparator : comparators) {
        if (comparator(lhs, rhs)) {
          return true;
        }
      }
      return false;
    };
    std::sort(output_for_partition_buff,
              output_for_partition_buff + partition_size,
              col_tuple_comparator);
    computePartition(output_for_partition_buff,
                     partition_size,
                     off,
                     window_func_,
                     col_tuple_comparator);
    if (window_function_is_value(window_func_->getKind()) ||
        window_function_is_aggregate(window_func_->getKind())) {
      off += partition_size;
    }
  }
  if (window_function_is_value(window_func_->getKind()) ||
      window_function_is_aggregate(window_func_->getKind())) {
    CHECK_EQ(static_cast<size_t>(off), elem_count_);
  }
  auto output_i64 = reinterpret_cast<int64_t*>(output_);
  if (window_function_is_aggregate(window_func_->getKind())) {
    std::copy(scratchpad.get(), scratchpad.get() + elem_count_, output_i64);
  } else {
    for (size_t i = 0; i < elem_count_; ++i) {
      output_i64[payload()[i]] = scratchpad[i];
    }
  }
}

Here is the call graph for this function:

void WindowFunctionContext::computePartition ( int64_t *  output_for_partition_buff, const size_t  partition_size, const size_t  off, const Analyzer::WindowFunction *  window_func, const std::function< bool(const int64_t lhs, const int64_t rhs)> &  comparator  )

private

Definition at line 641 of file WindowContext.cpp.

References anonymous_namespace{WindowContext.cpp}::apply_first_value_to_partition(), anonymous_namespace{WindowContext.cpp}::apply_lag_to_partition(), anonymous_namespace{WindowContext.cpp}::apply_last_value_to_partition(), anonymous_namespace{WindowContext.cpp}::apply_permutation_to_partition(), run_benchmark_import::args, AVG, CHECK_EQ, COUNT, CUME_DIST, DENSE_RANK, FIRST_VALUE, anonymous_namespace{WindowContext.cpp}::get_int_constant_from_expr(), anonymous_namespace{WindowContext.cpp}::get_lag_or_lead_argument(), Analyzer::WindowFunction::getArgs(), Analyzer::WindowFunction::getKind(), anonymous_namespace{WindowContext.cpp}::index_to_cume_dist(), anonymous_namespace{WindowContext.cpp}::index_to_dense_rank(), anonymous_namespace{WindowContext.cpp}::index_to_ntile(), anonymous_namespace{WindowContext.cpp}::index_to_partition_end(), anonymous_namespace{WindowContext.cpp}::index_to_percent_rank(), anonymous_namespace{WindowContext.cpp}::index_to_rank(), anonymous_namespace{WindowContext.cpp}::index_to_row_number(), LAG, LAST_VALUE, LEAD, MAX, MIN, NTILE, partitionEnd(), payload(), PERCENT_RANK, RANK, ROW_NUMBER, sql_window_function_to_str(), SUM, and window_function_requires_peer_handling().

Referenced by compute().

                                                                               {
  switch (window_func->getKind()) {
    case SqlWindowFunctionKind::ROW_NUMBER: {
      const auto row_numbers =
          index_to_row_number(output_for_partition_buff, partition_size);
      std::copy(row_numbers.begin(), row_numbers.end(), output_for_partition_buff);
      break;
    }
    case SqlWindowFunctionKind::RANK: {
      const auto rank =
          index_to_rank(output_for_partition_buff, partition_size, comparator);
      std::copy(rank.begin(), rank.end(), output_for_partition_buff);
      break;
    }
    case SqlWindowFunctionKind::DENSE_RANK: {
      const auto dense_rank =
          index_to_dense_rank(output_for_partition_buff, partition_size, comparator);
      std::copy(dense_rank.begin(), dense_rank.end(), output_for_partition_buff);
      break;
    }
    case SqlWindowFunctionKind::PERCENT_RANK: {
      const auto percent_rank =
          index_to_percent_rank(output_for_partition_buff, partition_size, comparator);
      std::copy(percent_rank.begin(),
                percent_rank.end(),
                reinterpret_cast<double*>(may_alias_ptr(output_for_partition_buff)));
      break;
    }
    case SqlWindowFunctionKind::CUME_DIST: {
      const auto cume_dist =
          index_to_cume_dist(output_for_partition_buff, partition_size, comparator);
      std::copy(cume_dist.begin(),
                cume_dist.end(),
                reinterpret_cast<double*>(may_alias_ptr(output_for_partition_buff)));
      break;
    }
    case SqlWindowFunctionKind::NTILE: {
      const auto& args = window_func->getArgs();
      CHECK_EQ(args.size(), size_t(1));
      const auto n = get_int_constant_from_expr(args.front().get());
      const auto ntile = index_to_ntile(output_for_partition_buff, partition_size, n);
      std::copy(ntile.begin(), ntile.end(), output_for_partition_buff);
      break;
    }
    case SqlWindowFunctionKind::LAG:
    case SqlWindowFunctionKind::LEAD: {
      const auto lag_or_lead = get_lag_or_lead_argument(window_func);
      const auto partition_row_offsets = payload() + off;
      apply_lag_to_partition(
          lag_or_lead, partition_row_offsets, output_for_partition_buff, partition_size);
      break;
    }
    case SqlWindowFunctionKind::FIRST_VALUE: {
      const auto partition_row_offsets = payload() + off;
      apply_first_value_to_partition(
          partition_row_offsets, output_for_partition_buff, partition_size);
      break;
    }
    case SqlWindowFunctionKind::LAST_VALUE: {
      const auto partition_row_offsets = payload() + off;
      apply_last_value_to_partition(
          partition_row_offsets, output_for_partition_buff, partition_size);
      break;
    }
    case SqlWindowFunctionKind::AVG:
    case SqlWindowFunctionKind::MIN:
    case SqlWindowFunctionKind::MAX:
    case SqlWindowFunctionKind::SUM:
    case SqlWindowFunctionKind::COUNT: {
      const auto partition_row_offsets = payload() + off;
      if (window_function_requires_peer_handling(window_func)) {
        index_to_partition_end(
            partitionEnd(), off, output_for_partition_buff, partition_size, comparator);
      }
      apply_permutation_to_partition(
          output_for_partition_buff, partition_row_offsets, partition_size);
      break;
    }
    default: {
      throw std::runtime_error("Window function not supported yet: " +
                               sql_window_function_to_str(window_func->getKind()));
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const int32_t * WindowFunctionContext::counts ( ) const

private

Definition at line 784 of file WindowContext.cpp.

References device_type_, and partitions_.

Referenced by compute(), fillPartitionEnd(), fillPartitionStart(), and partitionCount().

                                                   {
  return reinterpret_cast<const int32_t*>(
      partitions_->getJoinHashBuffer(device_type_, 0) + partitions_->countBufferOff());
}

Here is the caller graph for this function:

size_t WindowFunctionContext::elementCount

(

)

const

Definition at line 510 of file WindowContext.cpp.

References elem_count_.

                                                 {
  return elem_count_;
}

void WindowFunctionContext::fillPartitionEnd ( )

private

Definition at line 750 of file WindowContext.cpp.

References agg_count_distinct_bitmap(), Bitmap, checked_calloc(), counts(), CPU, elem_count_, partition_end_, and partitionCount().

Referenced by compute().

                                             {
  CountDistinctDescriptor partition_start_bitmap{CountDistinctImplType::Bitmap,
                                                 0,
                                                 static_cast<int64_t>(elem_count_),
                                                 false,
                                                 ExecutorDeviceType::CPU,
                                                 1};
  partition_end_ = static_cast<int8_t*>(
      checked_calloc(partition_start_bitmap.bitmapPaddedSizeBytes(), 1));
  ssize_t partition_count = partitionCount();
  std::vector<size_t> partition_offsets(partition_count);
  std::partial_sum(counts(), counts() + partition_count, partition_offsets.begin());
  auto partition_end_handle = reinterpret_cast<int64_t>(partition_end_);
  for (ssize_t i = 0; i < partition_count - 1; ++i) {
    if (partition_offsets[i] == 0) {
      continue;
    }
    agg_count_distinct_bitmap(&partition_end_handle, partition_offsets[i] - 1, 0);
  }
  if (elem_count_) {
    agg_count_distinct_bitmap(&partition_end_handle, elem_count_ - 1, 0);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WindowFunctionContext::fillPartitionStart ( )

private

Definition at line 731 of file WindowContext.cpp.

References agg_count_distinct_bitmap(), Bitmap, checked_calloc(), counts(), CPU, elem_count_, partition_start_, and partitionCount().

Referenced by compute().

                                               {
  CountDistinctDescriptor partition_start_bitmap{CountDistinctImplType::Bitmap,
                                                 0,
                                                 static_cast<int64_t>(elem_count_),
                                                 false,
                                                 ExecutorDeviceType::CPU,
                                                 1};
  partition_start_ = static_cast<int8_t*>(
      checked_calloc(partition_start_bitmap.bitmapPaddedSizeBytes(), 1));
  ssize_t partition_count = partitionCount();
  std::vector<size_t> partition_offsets(partition_count);
  std::partial_sum(counts(), counts() + partition_count, partition_offsets.begin());
  auto partition_start_handle = reinterpret_cast<int64_t>(partition_start_);
  agg_count_distinct_bitmap(&partition_start_handle, 0, 0);
  for (ssize_t i = 0; i < partition_count - 1; ++i) {
    agg_count_distinct_bitmap(&partition_start_handle, partition_offsets[i], 0);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * WindowFunctionContext::getRowNumber

(

)

const

Definition at line 518 of file WindowContext.cpp.

References aggregate_state_, and WindowFunctionContext::AggregateState::row_number.

                                                     {
  return aggregate_state_.row_number;
}

const Analyzer::WindowFunction * WindowFunctionContext::getWindowFunction

(

)

const

Definition at line 479 of file WindowContext.cpp.

References window_func_.

Referenced by Executor::codegenWindowFunction().

                                                                             {
  return window_func_;
}

Here is the caller graph for this function:

std::function< bool(const int64_t lhs, const int64_t rhs)> WindowFunctionContext::makeComparator ( const Analyzer::ColumnVar *  col_var, const int8_t *  partition_values, const int32_t *  partition_indices, const bool  nulls_first  )

staticprivate

Definition at line 577 of file WindowContext.cpp.

References logger::FATAL, Analyzer::Expr::get_type_info(), kDOUBLE, kFLOAT, and LOG.

Referenced by compute().

                                                              {
  const auto& ti = col_var->get_type_info();
  if (ti.is_integer() || ti.is_decimal() || ti.is_time() || ti.is_boolean()) {
    switch (ti.get_size()) {
      case 8: {
        return [order_column_buffer, nulls_first, partition_indices, &ti](
                   const int64_t lhs, const int64_t rhs) {
          return integer_comparator<int64_t>(
              order_column_buffer, ti, partition_indices, lhs, rhs, nulls_first);
        };
      }
      case 4: {
        return [order_column_buffer, nulls_first, partition_indices, &ti](
                   const int64_t lhs, const int64_t rhs) {
          return integer_comparator<int32_t>(
              order_column_buffer, ti, partition_indices, lhs, rhs, nulls_first);
        };
      }
      case 2: {
        return [order_column_buffer, nulls_first, partition_indices, &ti](
                   const int64_t lhs, const int64_t rhs) {
          return integer_comparator<int16_t>(
              order_column_buffer, ti, partition_indices, lhs, rhs, nulls_first);
        };
      }
      case 1: {
        return [order_column_buffer, nulls_first, partition_indices, &ti](
                   const int64_t lhs, const int64_t rhs) {
          return integer_comparator<int8_t>(
              order_column_buffer, ti, partition_indices, lhs, rhs, nulls_first);
        };
      }
      default: {
        LOG(FATAL) << "Invalid type size: " << ti.get_size();
      }
    }
  }
  if (ti.is_fp()) {
    switch (ti.get_type()) {
      case kFLOAT: {
        return [order_column_buffer, nulls_first, partition_indices, &ti](
                   const int64_t lhs, const int64_t rhs) {
          return fp_comparator<float, int32_t>(
              order_column_buffer, ti, partition_indices, lhs, rhs, nulls_first);
        };
      }
      case kDOUBLE: {
        return [order_column_buffer, nulls_first, partition_indices, &ti](
                   const int64_t lhs, const int64_t rhs) {
          return fp_comparator<double, int64_t>(
              order_column_buffer, ti, partition_indices, lhs, rhs, nulls_first);
        };
      }
      default: {
        LOG(FATAL) << "Invalid float type";
      }
    }
  }
  throw std::runtime_error("Type not supported yet");
}

Here is the call graph for this function:

Here is the caller graph for this function:

const int32_t * WindowFunctionContext::offsets ( ) const

private

Definition at line 779 of file WindowContext.cpp.

References device_type_, and partitions_.

Referenced by compute(), and partitionCount().

                                                    {
  return reinterpret_cast<const int32_t*>(
      partitions_->getJoinHashBuffer(device_type_, 0) + partitions_->offsetBufferOff());
}

Here is the caller graph for this function:

WindowFunctionContext& WindowFunctionContext::operator= ( const WindowFunctionContext &  )

delete

const int8_t * WindowFunctionContext::output

(

)

const

Definition at line 483 of file WindowContext.cpp.

References output_.

Referenced by CodeGenerator::codegenWindowPosition().

                                                  {
  return output_;
}

Here is the caller graph for this function:

size_t WindowFunctionContext::partitionCount ( ) const

private

Definition at line 789 of file WindowContext.cpp.

References CHECK_GE, counts(), and offsets().

Referenced by compute(), fillPartitionEnd(), and fillPartitionStart().

                                                   {
  const auto partition_count = counts() - offsets();
  CHECK_GE(partition_count, 0);
  return partition_count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const int8_t * WindowFunctionContext::partitionEnd

(

)

const

Definition at line 506 of file WindowContext.cpp.

References partition_end_.

Referenced by computePartition().

                                                        {
  return partition_end_;
}

Here is the caller graph for this function:

const int8_t * WindowFunctionContext::partitionStart

(

)

const

Definition at line 502 of file WindowContext.cpp.

References partition_start_.

                                                          {
  return partition_start_;
}

const int32_t * WindowFunctionContext::payload ( ) const

private

Definition at line 774 of file WindowContext.cpp.

References device_type_, and partitions_.

Referenced by compute(), and computePartition().

                                                    {
  return reinterpret_cast<const int32_t*>(
      partitions_->getJoinHashBuffer(device_type_, 0) + partitions_->payloadBufferOff());
}

Here is the caller graph for this function:

void WindowFunctionContext::setRowNumber

(

llvm::Value *

row_number

)

Definition at line 514 of file WindowContext.cpp.

References aggregate_state_, and WindowFunctionContext::AggregateState::row_number.

Referenced by CodeGenerator::codegenWindowPosition().

                                                              {
  aggregate_state_.row_number = row_number;
}

Here is the caller graph for this function:

Member Data Documentation

AggregateState WindowFunctionContext::aggregate_state_

private

Definition at line 168 of file WindowContext.h.

Referenced by aggregateState(), aggregateStateCount(), aggregateStatePendingOutputs(), getRowNumber(), and setRowNumber().

const ExecutorDeviceType WindowFunctionContext::device_type_

private

Definition at line 169 of file WindowContext.h.

Referenced by counts(), offsets(), and payload().

size_t WindowFunctionContext::elem_count_

private

Definition at line 158 of file WindowContext.h.

Referenced by compute(), elementCount(), fillPartitionEnd(), and fillPartitionStart().

std::vector<const int8_t*> WindowFunctionContext::order_columns_

private

Definition at line 154 of file WindowContext.h.

Referenced by addOrderColumn(), and compute().

std::vector<std::vector<std::shared_ptr<Chunk_NS::Chunk> > > WindowFunctionContext::order_columns_owner_

private

Definition at line 152 of file WindowContext.h.

Referenced by addOrderColumn().

int8_t* WindowFunctionContext::output_

private

Definition at line 160 of file WindowContext.h.

Referenced by compute(), output(), and ~WindowFunctionContext().

int8_t* WindowFunctionContext::partition_end_

private

Definition at line 166 of file WindowContext.h.

Referenced by fillPartitionEnd(), partitionEnd(), and ~WindowFunctionContext().

int8_t* WindowFunctionContext::partition_start_

private

Definition at line 163 of file WindowContext.h.

Referenced by fillPartitionStart(), partitionStart(), and ~WindowFunctionContext().

std::shared_ptr<JoinHashTableInterface> WindowFunctionContext::partitions_

private

Definition at line 156 of file WindowContext.h.

Referenced by counts(), offsets(), and payload().

const Analyzer::WindowFunction* WindowFunctionContext::window_func_

private

Definition at line 150 of file WindowContext.h.

Referenced by aggregateState(), aggregateStateCount(), aggregateStatePendingOutputs(), compute(), and getWindowFunction().

---

The documentation for this class was generated from the following files:

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/WindowContext.h
• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/WindowContext.cpp