TEST_F(MergeReceiveExecutorTest, singlePartitionBigOffsetTest)
{
    std::vector<int> values;
    values.push_back(0);
    values.push_back(1);
    values.push_back(1);
    values.push_back(2);

    std::vector<TableTuple> tuples;
    std::vector<int64_t> partitionTupleCounts;

    boost::scoped_ptr<char> cleaner(
        addPartitionData(values, tuples, partitionTupleCounts));

    std::vector<SortDirectionType> dirs(1, SORT_DIRECTION_TYPE_ASC);
    AbstractExecutor::TupleComparer comp(getSortKeys(), dirs);
    int limit = -1;
    int offset = 10;
    AggregateExecutorBase* agg_exec = NULL;
    ProgressMonitorProxy* pmp = NULL;
    MergeReceiveExecutor::merge_sort(tuples,
                               partitionTupleCounts,
                               comp,
                               limit,
                               offset,
                               agg_exec,
                               getDstTempTable(),
                               pmp);
    ASSERT_EQ(0, getDstTempTable()->activeTupleCount());
}
示例#2
0
Int32 hive_tbl_desc::getNumOfSortCols()
{
  Int32 result = 0;
  hive_skey_desc *sk = getSortKeys();
  while (sk)
    {
      result++;
      sk = sk->next_;
    }
  return result;
}
TEST_F(MergeReceiveExecutorTest, multipleOverlapPartitionsTest)
{
    std::vector<int> values1;
    values1.push_back(10);
    values1.push_back(11);
    values1.push_back(11);
    values1.push_back(12);

    std::vector<int> values2;
    values2.push_back(1);
    values2.push_back(3);
    values2.push_back(4);
    values2.push_back(10);
    values2.push_back(11);
    values2.push_back(15);
    values2.push_back(20);
    values2.push_back(21);
    values2.push_back(25);

    std::vector<int> values3;
    values3.push_back(2);
    values3.push_back(4);
    values3.push_back(10);
    values3.push_back(12);
    values3.push_back(13);
    values3.push_back(15);

    std::vector<TableTuple> tuples;
    std::vector<int64_t> partitionTupleCounts;

    boost::scoped_ptr<char> cleaner1(
        addPartitionData(values1, tuples, partitionTupleCounts));
    boost::scoped_ptr<char> cleaner2(
        addPartitionData(values2, tuples, partitionTupleCounts));
    boost::scoped_ptr<char> cleaner3(
        addPartitionData(values3, tuples, partitionTupleCounts));

    std::vector<SortDirectionType> dirs(1, SORT_DIRECTION_TYPE_ASC);
    AbstractExecutor::TupleComparer comp(getSortKeys(), dirs);
    int limit = -1;
    int offset = 0;
    AggregateExecutorBase* agg_exec = NULL;
    ProgressMonitorProxy* pmp = NULL;
    MergeReceiveExecutor::merge_sort(tuples,
                               partitionTupleCounts,
                               comp,
                               limit,
                               offset,
                               agg_exec,
                               getDstTempTable(),
                               pmp);
    validateResults(comp, tuples);
}
示例#4
0
Int32 hive_tbl_desc::getSortColNum(const char* name)
{
  Int32 num = 0;

  hive_skey_desc * desc = getSortKeys();
  while (desc)
    {
      if (strcmp(name, desc->name_) == 0)
        {
          return num;
        }
      
      num++;
      desc = desc->next_;
    }

  return -1;
}