row-batch-list.h

Go to the documentation of this file.

// Copyright 2013 Cloudera Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.


#ifndef IMPALA_EXEC_ROW_BATCH_LIST_H
#define IMPALA_EXEC_ROW_BATCH_LIST_H

#include <vector>
#include <string>

#include "runtime/row-batch.h"
#include "common/logging.h" // for DCHECK
#include "util/debug-util.h"

namespace impala {

class TupleRow;
class RowDescriptor;
class MemPool;

class RowBatchList {
 public:
  RowBatchList() : total_num_rows_(0) { }

  class TupleRowIterator {
   public:
    TupleRowIterator() : list_(NULL), row_idx_(0) { }

    bool AtEnd() {
      return batch_it_ == list_->row_batches_.end();
    }

    TupleRow* GetRow() {
      DCHECK(!AtEnd());
      return (*batch_it_)->GetRow(row_idx_);
    }

    void Next() {
      if (batch_it_ == list_->row_batches_.end()) return;
      if (++row_idx_ == (*batch_it_)->num_rows()) {
        ++batch_it_;
        row_idx_ = 0;
      }
    }

   private:
    friend class RowBatchList;

    TupleRowIterator(RowBatchList* list)
      : list_(list),
        batch_it_(list->row_batches_.begin()),
        row_idx_(0) {
    }

    RowBatchList* list_;
    std::vector<RowBatch*>::iterator batch_it_;
    int64_t row_idx_;
  };

  void AddRowBatch(RowBatch* row_batch) {
    if (row_batch->num_rows() == 0) return;
    row_batches_.push_back(row_batch);
    total_num_rows_ += row_batch->num_rows();
  }

  void Reset() {
    row_batches_.clear();
    total_num_rows_ = 0;
  }

  std::string DebugString(const RowDescriptor& desc) {
    std::stringstream out;
    out << "RowBatchList(";
    out << "num_rows=" << total_num_rows_ << "; ";
    RowBatchList::TupleRowIterator it = Iterator();
    while (!it.AtEnd()) {
      out << " " << PrintRow(it.GetRow(), desc);
      it.Next();
    }
    out << " )";
    return out.str();
  }

  int64_t total_num_rows() { return total_num_rows_; }

  TupleRowIterator Iterator() {
    return TupleRowIterator(this);
  }

 private:
  friend class TupleRowIterator;

  std::vector<RowBatch*> row_batches_;

  int64_t total_num_rows_;
};

}

#endif