OSDN -- オープンソース・ソフトウェアの開発とダウンロード
日本語の翻訳状況 translation status for ja

[Groonga-commit] groonga/grnxx at 6ec305f [master] Replace RecordSet with Array<Record>. (#33)

アーカイブの一覧に戻る

susumu.yata null+****@clear*****
Fri Aug 8 17:42:47 JST 2014 

susumu.yata	2014-08-08 17:42:47 +0900 (Fri, 08 Aug 2014)

  New Revision: 6ec305faf9d185a2743d635bc38a6d2715d71d08
  https://github.com/groonga/grnxx/commit/6ec305faf9d185a2743d635bc38a6d2715d71d08

  Message:
    Replace RecordSet with Array<Record>. (#33)
    
    RecordSubset is replaced with ArrayRef<Record>.
    push_back() is an alternative to append().
    ref() is an alternative to subset().

  Removed files:
    include/grnxx/record.hpp
    lib/grnxx/record.cpp
  Modified files:
    include/grnxx/Makefile.am
    include/grnxx/array.hpp
    include/grnxx/cursor.hpp
    include/grnxx/expression.hpp
    include/grnxx/sorter.hpp
    include/grnxx/types.hpp
    lib/grnxx/Makefile.am
    lib/grnxx/expression.cpp
    lib/grnxx/expression2.cpp
    lib/grnxx/sorter.cpp
    lib/grnxx/table.cpp
    test/test_grnxx.cpp

  Modified: include/grnxx/Makefile.am (+0 -1)
===================================================================
--- include/grnxx/Makefile.am    2014-08-08 13:01:48 +0900 (b8591d0)
+++ include/grnxx/Makefile.am    2014-08-08 17:42:47 +0900 (a83e849)
@@ -8,7 +8,6 @@ pkginclude_HEADERS =	\
 	expression.hpp	\
 	index.hpp	\
 	library.hpp	\
-	record.hpp	\
 	sorter.hpp	\
 	table.hpp	\
 	types.hpp

  Modified: include/grnxx/array.hpp (+187 -0)
===================================================================
--- include/grnxx/array.hpp    2014-08-08 13:01:48 +0900 (193a630)
+++ include/grnxx/array.hpp    2014-08-08 17:42:47 +0900 (664e6fa)
@@ -64,6 +64,10 @@ class Array {
     return *this;
   }
 
+  operator ArrayRef<T>() const {
+    return ref();
+  }
+
   ArrayRef<T> ref(Int offset = 0) const {
     return ArrayRef<T>(const_cast<T *>(data()) + offset, size() - offset);
   }
@@ -294,6 +298,10 @@ class Array<Bool> {
     return *this;
   }
 
+  operator ArrayRef<Bool>() const {
+    return ref();
+  }
+
   ArrayRef<Bool> ref(Int offset = 0) const {
     return ArrayRef<Bool>(const_cast<uint64_t *>(blocks()),
                           offset, size() - offset);
@@ -408,6 +416,185 @@ class Array<Bool> {
   Int size_;
 };
 
+template <>
+class ArrayRef<Record> {
+ public:
+  ArrayRef() = default;
+  ArrayRef(Record *records, Int size) : records_(records), size_(size) {}
+  ArrayRef(const ArrayRef &) = default;
+
+  ArrayRef &operator=(const ArrayRef &) = default;
+
+  ArrayRef ref(Int offset = 0) const {
+    return ArrayRef(records_ + offset, size_ - offset);
+  }
+  ArrayRef ref(Int offset, Int size) const {
+    return ArrayRef(records_ + offset, size);
+  }
+
+  Record get(Int i) const {
+    return records_[i];
+  }
+  Int get_row_id(Int i) const {
+    return records_[i].row_id;
+  }
+  Float get_score(Int i) const {
+    return records_[i].score;
+  }
+  void set(Int i, Record record) {
+    records_[i] = record;
+  }
+  void set_row_id(Int i, Int row_id) {
+    records_[i].row_id = row_id;
+  }
+  void set_score(Int i, Float score) {
+    records_[i].score = score;
+  }
+
+  Record operator[](Int i) const {
+    return records_[i];
+  }
+
+  Int size() const {
+    return size_;
+  }
+
+  void swap(Int i, Int j) {
+    std::swap(records_[i], records_[j]);
+  }
+
+ private:
+  Record *records_;
+  Int size_;
+};
+
+template <>
+class Array<Record> {
+ public:
+  Array() : records_() {}
+  ~Array() {}
+
+  Array(Array &&array) : records_(std::move(array.records_)) {}
+
+  Array &operator=(Array &&array) {
+    records_ = std::move(array.records_);
+    return *this;
+  }
+
+  operator ArrayRef<Record>() const {
+    return ref();
+  }
+
+  ArrayRef<Record> ref(Int offset = 0) const {
+    return ArrayRef<Record>(
+        const_cast<Record *>(records_.data()) + offset, size() - offset);
+  }
+  ArrayRef<Record> ref(Int offset, Int size) const {
+    return ArrayRef<Record>(
+        const_cast<Record *>(records_.data()) + offset, size);
+  }
+
+  Record get(Int i) const {
+    return records_[i];
+  }
+  Int get_row_id(Int i) const {
+    return records_[i].row_id;
+  }
+  Float get_score(Int i) const {
+    return records_[i].score;
+  }
+  void set(Int i, Record record) {
+    records_[i] = record;
+  }
+  void set_row_id(Int i, Int row_id) {
+    records_[i].row_id = row_id;
+  }
+  void set_score(Int i, Float score) {
+    records_[i].score = score;
+  }
+
+  Record operator[](Int i) const {
+    return records_[static_cast<size_t>(i)];
+  }
+
+  Record front() const {
+    return records_.front();
+  }
+
+  Record back() const {
+    return records_.back();
+  }
+
+  Int size() const {
+    return static_cast<Int>(records_.size());
+  }
+  Int capacity() const {
+    return static_cast<Int>(records_.capacity());
+  }
+
+  bool reserve(Error *error, Int new_size) try {
+    records_.reserve(new_size);
+    return true;
+  } catch (...) {
+    ArrayErrorReporter::report_memory_error(error);
+    return false;
+  }
+
+  bool resize(Error *error, Int new_size) try {
+    records_.resize(new_size);
+    return true;
+  } catch (...) {
+    ArrayErrorReporter::report_memory_error(error);
+    return false;
+  }
+  bool resize(Error *error, Int new_size, Record record) try {
+    records_.resize(new_size, record);
+    return true;
+  } catch (...) {
+    ArrayErrorReporter::report_memory_error(error);
+    return false;
+  }
+
+  bool shrink_to_fit(Error *error) try {
+    records_.shrink_to_fit();
+    return true;
+  } catch (...) {
+    ArrayErrorReporter::report_memory_error(error);
+    return false;
+  }
+
+  void clear() {
+    records_.clear();
+  }
+
+  void erase(Int i) {
+    records_.erase(records_.begin() + i);
+  }
+
+  bool push_back(Error *error, Record record) try {
+    records_.push_back(record);
+    return true;
+  } catch (...) {
+    ArrayErrorReporter::report_memory_error(error);
+    return false;
+  }
+  void pop_back() {
+    records_.pop_back();
+  }
+
+  // TODO: For testing.
+  Record *data() const {
+    return const_cast<Record *>(records_.data());
+  }
+
+  void swap(Int i, Int j) {
+    std::swap(records_[i], records_[j]);
+  }
+
+ private:
+  std::vector<Record> records_;
+};
+
 }  // namespace grnxx
 
 #endif  // GRNXX_ARRAY_HPP

  Modified: include/grnxx/cursor.hpp (+5 -5)
===================================================================
--- include/grnxx/cursor.hpp    2014-08-08 13:01:48 +0900 (6dd7339)
+++ include/grnxx/cursor.hpp    2014-08-08 17:42:47 +0900 (496a4dc)
@@ -1,6 +1,7 @@
 #ifndef GRNXX_CURSOR_HPP
 #define GRNXX_CURSOR_HPP
 
+#include "grnxx/array.hpp"
 #include "grnxx/types.hpp"
 
 namespace grnxx {
@@ -16,23 +17,22 @@ class Cursor {
 
   // Read the next records.
   //
-  // Reads at most "max_count" records and stores the records into
-  // "*record_set".
+  // Reads at most "max_count" records and stores the records into "*records".
   //
   // On success, returns the number of records read.
   // On failure, returns -1 and stores error information into "*error" if
   // "error" != nullptr.
   virtual Int read(Error *error,
                    Int max_count,
-                   RecordSet *record_set) = 0;
+                   Array<Record> *records) = 0;
 
   // Read all the remaining records.
   //
   // On success, returns the number of records read.
   // On failure, returns -1 and stores error information into "*error" if
   // "error" != nullptr.
-  virtual Int read_all(Error *error, RecordSet *record_set) {
-    return read(error, numeric_limits<Int>::max(), record_set);
+  virtual Int read_all(Error *error, Array<Record> *records) {
+    return read(error, numeric_limits<Int>::max(), records);
   }
 
  protected:

  Modified: include/grnxx/expression.hpp (+5 -5)
===================================================================
--- include/grnxx/expression.hpp    2014-08-08 13:01:48 +0900 (d103ced)
+++ include/grnxx/expression.hpp    2014-08-08 17:42:47 +0900 (abefb44)
@@ -89,7 +89,7 @@ class Expression {
   // Returns true on success.
   // On failure, returns false and stores error information into "*error" if
   // "error" != nullptr.
-  bool filter(Error *error, RecordSet *record_set, Int offset = 0);
+  bool filter(Error *error, Array<Record> *records, Int offset = 0);
 
   // Adjust scores of records.
   //
@@ -100,7 +100,7 @@ class Expression {
   // Returns true on success.
   // On failure, returns false and stores error information into "*error" if
   // "error" != nullptr.
-  bool adjust(Error *error, RecordSet *record_set, Int offset = 0);
+  bool adjust(Error *error, Array<Record> *records, Int offset = 0);
 
   // Evaluate the expression.
   //
@@ -113,7 +113,7 @@ class Expression {
   // "error" != nullptr.
   template <typename T>
   bool evaluate(Error *error,
-                const RecordSubset &record_set,
+                const ArrayRef<Record> &records,
                 Array<T> *results);
 
   // Evaluate the expression.
@@ -128,7 +128,7 @@ class Expression {
   // "error" != nullptr.
   template <typename T>
   bool evaluate(Error *error,
-                const RecordSubset &record_set,
+                const ArrayRef<Record> &records,
                 ArrayRef<T> *results);
 
  private:
@@ -139,7 +139,7 @@ class Expression {
 
   template <typename T>
   bool evaluate_block(Error *error,
-                      const RecordSubset &record_set,
+                      const ArrayRef<Record> &records,
                       ArrayRef<T> *results);
 };
 

  Deleted: include/grnxx/record.hpp (+0 -163) 100644
===================================================================
--- include/grnxx/record.hpp    2014-08-08 13:01:48 +0900 (cbd01e5)
+++ /dev/null
@@ -1,163 +0,0 @@
-#ifndef GRNXX_RECORD_HPP
-#define GRNXX_RECORD_HPP
-
-#include "grnxx/array.hpp"
-#include "grnxx/types.hpp"
-
-namespace grnxx {
-
-struct Record {
-  Int row_id;
-  Float score;
-
-  Record() = default;
-  Record(Int row_id, Float score) : row_id(row_id), score(score) {}
-};
-
-class RecordSubset {
- public:
-  RecordSubset() = default;
-  RecordSubset(const RecordSubset &) = default;
-
-  RecordSubset &operator=(const RecordSubset &) = default;
-
-  // Return the number of records.
-  Int size() const {
-    return size_;
-  }
-
-  // Return the subset.
-  RecordSubset subset(Int offset = 0) const {
-    return RecordSubset(records_ + offset, size_ - offset);
-  }
-  // Return the subset.
-  RecordSubset subset(Int offset, Int size) const {
-    return RecordSubset(records_ + offset, size);
-  }
-
-  // Return the "i"-th record.
-  Record get(Int i) const {
-    return records_[i];
-  }
-  // Return the row ID of the "i"-th record.
-  Int get_row_id(Int i) const {
-    return records_[i].row_id;
-  }
-  // Return the score of the "i"-th record.
-  Float get_score(Int i) const {
-    return records_[i].score;
-  }
-
-  // Set the "i"-th record.
-  void set(Int i, Record record) {
-    records_[i] = record;
-  }
-  // Set the row ID of the "i"-th record.
-  void set_row_id(Int i, Int row_id) {
-    records_[i].row_id = row_id;
-  }
-  // Set the score of the "i"-th record.
-  void set_score(Int i, Float score) {
-    records_[i].score = score;
-  }
-
-  // Swap the "i"-th record and the "j"-th record.
-  void swap(Int i, Int j) {
-    Record temporary_record = get(i);
-    set(i, get(j));
-    set(j, temporary_record);
-  }
-
- private:
-  Record *records_;
-  Int size_;
-
-  RecordSubset(Record *records, Int size) : records_(records), size_(size) {}
-
-  friend class RecordSet;
-};
-
-class RecordSet {
- public:
-  RecordSet() : records_() {}
-  ~RecordSet() {}
-
-  // Return the number of records.
-  Int size() const {
-    return static_cast<Int>(records_.size());
-  }
-
-  // Append a record.
-  //
-  // Returns true on success.
-  // On failure, returns false and stores error information into "*error" if
-  // "error" != nullptr.
-  bool append(Error *error, const Record &record) {
-    return records_.push_back(error, record);
-  }
-
-  // Return a subset.
-  RecordSubset subset(Int offset = 0) const {
-    return RecordSubset(const_cast<Record *>(&records_[offset]),
-                        records_.size() - offset);
-  }
-  // Return a subset.
-  RecordSubset subset(Int offset, Int size) const {
-    return RecordSubset(const_cast<Record *>(&records_[offset]),
-                        records_.size());
-  }
-
-  // Return a subset.
-  operator RecordSubset() const {
-    return subset();
-  }
-
-  // If "i" is invalid, the result of the following functions is undefined.
-
-  // Return the "i"-th record.
-  Record get(Int i) const {
-    return records_[i];
-  }
-  // Return the row ID of the "i"-th record.
-  Int get_row_id(Int i) const {
-    return records_[i].row_id;
-  }
-  // Return the score of the "i"-th record.
-  Float get_score(Int i) const {
-    return records_[i].score;
-  }
-
-  // Set the "i"-th record.
-  void set(Int i, Record record) {
-    records_[i] = record;
-  }
-  // Set the row ID of the "i"-th record.
-  void set_row_id(Int i, Int row_id) {
-    records_[i].row_id = row_id;
-  }
-  // Set the score of the "i"-th record.
-  void set_score(Int i, Float score) {
-    records_[i].score = score;
-  }
-
-  // Resize the set.
-  //
-  // Returns true on success.
-  // On failure, returns false and stores error information into "*error" if
-  // "error" != nullptr.
-  bool resize(Error *error, Int size) {
-    return records_.resize(error, size);
-  }
-
-  // Clear all the records.
-  void clear() {
-    records_.clear();
-  }
-
- private:
-  Array<Record> records_;
-};
-
-}  // namespace grnxx
-
-#endif  // GRNXX_RECORD_HPP

  Modified: include/grnxx/sorter.hpp (+3 -3)
===================================================================
--- include/grnxx/sorter.hpp    2014-08-08 13:01:48 +0900 (420d378)
+++ include/grnxx/sorter.hpp    2014-08-08 17:42:47 +0900 (f6b7131)
@@ -38,7 +38,7 @@ class Sorter {
   // On success, returns true.
   // On failure, returns false and stores error information into "*error" if
   // "error" != nullptr.
-  bool reset(Error *error, RecordSet *record_set);
+  bool reset(Error *error, Array<Record> *records);
 
   // Progress sorting.
   //
@@ -64,11 +64,11 @@ class Sorter {
   // On success, returns true.
   // On failure, returns false and stores error information into "*error" if
   // "error" != nullptr.
-  bool sort(Error *error, RecordSet *record_set);
+  bool sort(Error *error, Array<Record> *records);
 
  private:
   unique_ptr<SorterNode> head_;
-  RecordSet *record_set_;
+  Array<Record> *records_;
   Int offset_;
   Int limit_;
 

  Modified: include/grnxx/types.hpp (+8 -2)
===================================================================
--- include/grnxx/types.hpp    2014-08-08 13:01:48 +0900 (51c042b)
+++ include/grnxx/types.hpp    2014-08-08 17:42:47 +0900 (adff2b1)
@@ -346,6 +346,14 @@ constexpr Int NULL_ROW_ID = 0;
 constexpr Int MIN_ROW_ID  = 1;
 constexpr Int MAX_ROW_ID  = (Int(1) << 40) - 1;
 
+struct Record {
+  Int row_id;
+  Float score;
+
+  Record() = default;
+  Record(Int row_id, Float score) : row_id(row_id), score(score) {}
+};
+
 enum IndexType {
   TREE_INDEX,
   HASH_INDEX
@@ -402,8 +410,6 @@ struct SorterOptions {
 // Database temporary object types.
 class Datum;
 class Cursor;
-class RecordSubset;
-class RecordSet;
 class Expression;
 class ExpressionNode;
 class ExpressionBuilder;

  Modified: lib/grnxx/Makefile.am (+0 -1)
===================================================================
--- lib/grnxx/Makefile.am    2014-08-08 13:01:48 +0900 (f967a52)
+++ lib/grnxx/Makefile.am    2014-08-08 17:42:47 +0900 (285c21d)
@@ -18,7 +18,6 @@ libgrnxx_la_SOURCES =			\
 	index.cpp			\
 	library.cpp			\
 	name.cpp			\
-	record.cpp			\
 	sorter.cpp			\
 	table.cpp			\
 	types.cpp

  Modified: lib/grnxx/expression.cpp (+147 -150)
===================================================================
--- lib/grnxx/expression.cpp    2014-08-08 13:01:48 +0900 (9814f07)
+++ lib/grnxx/expression.cpp    2014-08-08 17:42:47 +0900 (8bdbb79)
@@ -3,7 +3,6 @@
 #include "grnxx/column_impl.hpp"
 #include "grnxx/datum.hpp"
 #include "grnxx/error.hpp"
-#include "grnxx/record.hpp"
 #include "grnxx/table.hpp"
 
 #include <iostream>  // For debugging.
@@ -41,8 +40,8 @@ class ExpressionNode {
   // On failure, returns false and stores error information into "*error" if
   // "error" != nullptr.
   virtual bool filter(Error *error,
-                      const RecordSubset &input_records,
-                      RecordSubset *output_records) = 0;
+                      const ArrayRef<Record> &input_records,
+                      ArrayRef<Record> *output_records) = 0;
 
   // Adjust scores of records.
   //
@@ -52,7 +51,7 @@ class ExpressionNode {
   // Returns true on success.
   // On failure, returns false and stores error information into "*error" if
   // "error" != nullptr.
-  virtual bool adjust(Error *error, RecordSubset *record_set) = 0;
+  virtual bool adjust(Error *error, ArrayRef<Record> *records) = 0;
 
   // Evaluate the expression subtree.
   //
@@ -61,7 +60,7 @@ class ExpressionNode {
   // Returns true on success.
   // On failure, returns false and stores error information into "*error" if
   // "error" != nullptr.
-  virtual bool evaluate(Error *error, const RecordSubset &record_set) = 0;
+  virtual bool evaluate(Error *error, const ArrayRef<Record> &records) = 0;
 };
 
 namespace {
@@ -77,11 +76,11 @@ class Node : public ExpressionNode {
   }
 
   virtual bool filter(Error *error,
-                      const RecordSubset &input_records,
-                      RecordSubset *output_records);
-  virtual bool adjust(Error *error, RecordSubset *record_set);
+                      const ArrayRef<Record> &input_records,
+                      ArrayRef<Record> *output_records);
+  virtual bool adjust(Error *error, ArrayRef<Record> *records);
 
-  virtual bool evaluate(Error *error, const RecordSubset &record_set) = 0;
+  virtual bool evaluate(Error *error, const ArrayRef<Record> &records) = 0;
 
   T get(Int i) const {
     return values_[i];
@@ -93,8 +92,8 @@ class Node : public ExpressionNode {
 
 template <typename T>
 bool Node<T>::filter(Error *error,
-                     const RecordSubset &input_records,
-                     RecordSubset *output_records) {
+                     const ArrayRef<Record> &input_records,
+                     ArrayRef<Record> *output_records) {
   // Only Node<Bool> supports filter().
   GRNXX_ERROR_SET(error, INVALID_OPERATION, "Invalid operation");
   return false;
@@ -102,8 +101,8 @@ bool Node<T>::filter(Error *error,
 
 template <>
 bool Node<Bool>::filter(Error *error,
-                        const RecordSubset &input_records,
-                        RecordSubset *output_records) {
+                        const ArrayRef<Record> &input_records,
+                        ArrayRef<Record> *output_records) {
   if (!evaluate(error, input_records)) {
     return false;
   }
@@ -114,25 +113,24 @@ bool Node<Bool>::filter(Error *error,
       ++dest;
     }
   }
-  *output_records = output_records->subset(0, dest);
+  *output_records = output_records->ref(0, dest);
   return true;
 }
 
 template <typename T>
-bool Node<T>::adjust(Error *error,
-                     RecordSubset *record_set) {
+bool Node<T>::adjust(Error *error, ArrayRef<Record> *records) {
   // Only Node<Float> supports adjust().
   GRNXX_ERROR_SET(error, INVALID_OPERATION, "Invalid operation");
   return false;
 }
 
 template <>
-bool Node<Float>::adjust(Error *error, RecordSubset *record_set) {
-  if (!evaluate(error, *record_set)) {
+bool Node<Float>::adjust(Error *error, ArrayRef<Record> *records) {
+  if (!evaluate(error, *records)) {
     return false;
   }
-  for (Int i = 0; i < record_set->size(); ++i) {
-    record_set->set_score(i, values_[i]);
+  for (Int i = 0; i < records->size(); ++i) {
+    records->set_score(i, values_[i]);
   }
   return true;
 }
@@ -149,19 +147,19 @@ class DatumNode : public Node<T> {
     return DATUM_NODE;
   }
 
-  bool evaluate(Error *error, const RecordSubset &record_set);
+  bool evaluate(Error *error, const ArrayRef<Record> &records);
 
  private:
   T datum_;
 };
 
 template <typename T>
-bool DatumNode<T>::evaluate(Error *error, const RecordSubset &record_set) {
-  if (static_cast<size_t>(record_set.size()) <= this->values_.size()) {
+bool DatumNode<T>::evaluate(Error *error, const ArrayRef<Record> &records) {
+  if (static_cast<size_t>(records.size()) <= this->values_.size()) {
     // The buffer is already filled and there is nothing to do.
     return true;
   }
-  return this->values_.resize(error, record_set.size(), datum_);
+  return this->values_.resize(error, records.size(), datum_);
 }
 
 template <>
@@ -176,18 +174,18 @@ class DatumNode<Text> : public Node<Text> {
     return DATUM_NODE;
   }
 
-  bool evaluate(Error *error, const RecordSubset &record_set);
+  bool evaluate(Error *error, const ArrayRef<Record> &records);
 
  private:
   std::string datum_;
 };
 
-bool DatumNode<Text>::evaluate(Error *error, const RecordSubset &record_set) {
-  if (static_cast<size_t>(record_set.size()) <= this->values_.size()) {
+bool DatumNode<Text>::evaluate(Error *error, const ArrayRef<Record> &records) {
+  if (static_cast<size_t>(records.size()) <= this->values_.size()) {
     // The buffer is already filled and there is nothing to do.
     return true;
   }
-  return this->values_.resize(error, record_set.size(),
+  return this->values_.resize(error, records.size(),
                               Text(datum_.data(), datum_.size()));
 }
 
@@ -202,12 +200,12 @@ class RowIDNode : public Node<Int> {
     return ROW_ID_NODE;
   }
 
-  bool evaluate(Error *error, const RecordSubset &record_set) {
-    if (!this->values_.resize(error, record_set.size())) {
+  bool evaluate(Error *error, const ArrayRef<Record> &records) {
+    if (!this->values_.resize(error, records.size())) {
       return false;
     }
-    for (Int i = 0; i < record_set.size(); ++i) {
-      this->values_[i] = record_set.get_row_id(i);
+    for (Int i = 0; i < records.size(); ++i) {
+      this->values_[i] = records.get_row_id(i);
     }
     return true;
   }
@@ -224,12 +222,12 @@ class ScoreNode : public Node<Float> {
     return SCORE_NODE;
   }
 
-  bool evaluate(Error *error, const RecordSubset &record_set) {
-    if (!this->values_.resize(error, record_set.size())) {
+  bool evaluate(Error *error, const ArrayRef<Record> &records) {
+    if (!this->values_.resize(error, records.size())) {
       return false;
     }
-    for (Int i = 0; i < record_set.size(); ++i) {
-      this->values_[i] = record_set.get_score(i);
+    for (Int i = 0; i < records.size(); ++i) {
+      this->values_[i] = records.get_score(i);
     }
     return true;
   }
@@ -249,12 +247,12 @@ class ColumnNode : public Node<T> {
     return COLUMN_NODE;
   }
 
-  bool evaluate(Error *error, const RecordSubset &record_set) {
-    if (!this->values_.resize(error, record_set.size())) {
+  bool evaluate(Error *error, const ArrayRef<Record> &records) {
+    if (!this->values_.resize(error, records.size())) {
       return false;
     }
-    for (Int i = 0; i < record_set.size(); ++i) {
-      this->values_.set(i, column_->get(record_set.get_row_id(i)));
+    for (Int i = 0; i < records.size(); ++i) {
+      this->values_.set(i, column_->get(records.get_row_id(i)));
     }
     return true;
   }
@@ -307,7 +305,7 @@ class UnaryNode : public Node<typename T::Result> {
     return OPERATOR_NODE;
   }
 
-  bool evaluate(Error *error, const RecordSubset &record_set);
+  bool evaluate(Error *error, const ArrayRef<Record> &records);
 
  private:
   Operator operator_;
@@ -315,15 +313,15 @@ class UnaryNode : public Node<typename T::Result> {
 };
 
 template <typename T>
-bool UnaryNode<T>::evaluate(Error *error, const RecordSubset &record_set) {
-  if (!this->values_.resize(error, record_set.size())) {
+bool UnaryNode<T>::evaluate(Error *error, const ArrayRef<Record> &records) {
+  if (!this->values_.resize(error, records.size())) {
     GRNXX_ERROR_SET(error, NO_MEMORY, "Memory allocation failed");
     return false;
   }
-  if (!arg_->evaluate(error, record_set)) {
+  if (!arg_->evaluate(error, records)) {
     return false;
   }
-  for (Int i = 0; i < record_set.size(); ++i) {
+  for (Int i = 0; i < records.size(); ++i) {
     this->values_[i] = operator_(arg_->get(i));
   }
   return true;
@@ -494,7 +492,7 @@ class BinaryNode : public Node<typename Op::Result> {
     return OPERATOR_NODE;
   }
 
-  bool evaluate(Error *error, const RecordSubset &record_set);
+  bool evaluate(Error *error, const ArrayRef<Record> &records);
 
  private:
   Op operator_;
@@ -503,16 +501,16 @@ class BinaryNode : public Node<typename Op::Result> {
 };
 
 template <typename Op>
-bool BinaryNode<Op>::evaluate(Error *error, const RecordSubset &record_set) {
-  if (!this->values_.resize(error, record_set.size())) {
+bool BinaryNode<Op>::evaluate(Error *error, const ArrayRef<Record> &records) {
+  if (!this->values_.resize(error, records.size())) {
     GRNXX_ERROR_SET(error, NO_MEMORY, "Memory allocation failed");
     return false;
   }
-  if (!lhs_->evaluate(error, record_set) ||
-      !rhs_->evaluate(error, record_set)) {
+  if (!lhs_->evaluate(error, records) ||
+      !rhs_->evaluate(error, records)) {
     return false;
   }
-  for (Int i = 0; i < record_set.size(); ++i) {
+  for (Int i = 0; i < records.size(); ++i) {
     this->values_.set(i, operator_(lhs_->get(i), rhs_->get(i)));
   }
   return true;
@@ -525,7 +523,7 @@ class LogicalAndNode : public Node<Bool> {
       : Node<Bool>(),
         lhs_(static_cast<Node<Bool> *>(lhs.release())),
         rhs_(static_cast<Node<Bool> *>(rhs.release())),
-        temp_record_set_() {}
+        temp_records_() {}
   virtual ~LogicalAndNode() {}
 
   NodeType node_type() const {
@@ -533,45 +531,45 @@ class LogicalAndNode : public Node<Bool> {
   }
 
   bool filter(Error *error,
-              const RecordSubset &input_records,
-              RecordSubset *output_records);
+              const ArrayRef<Record> &input_records,
+              ArrayRef<Record> *output_records);
 
-  bool evaluate(Error *error, const RecordSubset &record_set);
+  bool evaluate(Error *error, const ArrayRef<Record> &records);
 
  private:
   unique_ptr<Node<Bool>> lhs_;
   unique_ptr<Node<Bool>> rhs_;
-  RecordSet temp_record_set_;
+  Array<Record> temp_records_;
 };
 
 bool LogicalAndNode::filter(Error *error,
-                            const RecordSubset &input_records,
-                            RecordSubset *output_records) {
+                            const ArrayRef<Record> &input_records,
+                            ArrayRef<Record> *output_records) {
   return lhs_->filter(error, input_records, output_records) &&
          rhs_->filter(error, *output_records, output_records);
 }
 
-bool LogicalAndNode::evaluate(Error *error, const RecordSubset &record_set) {
-  if (!this->values_.resize(error, record_set.size())) {
+bool LogicalAndNode::evaluate(Error *error, const ArrayRef<Record> &records) {
+  if (!this->values_.resize(error, records.size())) {
     return false;
   }
-  if (!lhs_->evaluate(error, record_set)) {
+  if (!lhs_->evaluate(error, records)) {
     return false;
   }
   // False records must not be evaluated for the 2nd argument.
-  temp_record_set_.clear();
-  for (Int i = 0; i < record_set.size(); ++i) {
+  temp_records_.clear();
+  for (Int i = 0; i < records.size(); ++i) {
     if (lhs_->get(i)) {
-      if (!temp_record_set_.append(error, record_set.get(i))) {
+      if (!temp_records_.push_back(error, records.get(i))) {
         return false;
       }
     }
   }
-  if (!rhs_->evaluate(error, temp_record_set_)) {
+  if (!rhs_->evaluate(error, temp_records_)) {
     return false;
   }
   Int j = 0;
-  for (Int i = 0; i < record_set.size(); ++i) {
+  for (Int i = 0; i < records.size(); ++i) {
     this->values_.set(i, lhs_->get(i) ? rhs_->get(j++) : false);
   }
   return true;
@@ -584,8 +582,8 @@ class LogicalOrNode : public Node<Bool> {
       : Node<Bool>(),
         lhs_(static_cast<Node<Bool> *>(lhs.release())),
         rhs_(static_cast<Node<Bool> *>(rhs.release())),
-        left_record_set_(),
-        right_record_set_() {}
+        left_records_(),
+        right_records_() {}
   virtual ~LogicalOrNode() {}
 
   NodeType node_type() const {
@@ -593,43 +591,43 @@ class LogicalOrNode : public Node<Bool> {
   }
 
   bool filter(Error *error,
-              const RecordSubset &input_records,
-              RecordSubset *output_records);
+              const ArrayRef<Record> &input_records,
+              ArrayRef<Record> *output_records);
 
-  bool evaluate(Error *error, const RecordSubset &record_set);
+  bool evaluate(Error *error, const ArrayRef<Record> &records);
 
  private:
   unique_ptr<Node<Bool>> lhs_;
   unique_ptr<Node<Bool>> rhs_;
-  RecordSet left_record_set_;
-  RecordSet right_record_set_;
+  Array<Record> left_records_;
+  Array<Record> right_records_;
 };
 
 bool LogicalOrNode::filter(Error *error,
-                           const RecordSubset &input_records,
-                           RecordSubset *output_records) {
+                           const ArrayRef<Record> &input_records,
+                           ArrayRef<Record> *output_records) {
   // Make a copy of the given record set and apply the left-filter to it.
-  if (!left_record_set_.resize(error, input_records.size())) {
+  if (!left_records_.resize(error, input_records.size())) {
     return false;
   }
   for (Int i = 0; i < input_records.size(); ++i) {
-    left_record_set_.set(i, input_records.get(i));
+    left_records_.set(i, input_records.get(i));
   }
-  RecordSubset left_record_subset = left_record_set_.subset();
-  if (!lhs_->filter(error, left_record_subset, &left_record_subset)) {
+  ArrayRef<Record> left_record_ref = left_records_;
+  if (!lhs_->filter(error, left_record_ref, &left_record_ref)) {
     return false;
   }
-  if (!left_record_set_.resize(error, left_record_subset.size())) {
+  if (!left_records_.resize(error, left_record_ref.size())) {
     return false;
   }
-  if (left_record_set_.size() == 0) {
+  if (left_records_.size() == 0) {
     // There are no left-true records.
     return rhs_->filter(error, input_records, output_records);
-  } else if (left_record_set_.size() == input_records.size()) {
+  } else if (left_records_.size() == input_records.size()) {
     // There are no left-false records.
     // This means that all the records pass through the filter.
     if (&input_records != output_records) {
-      *output_records = output_records->subset(0, input_records.size());
+      *output_records = output_records->ref(0, input_records.size());
       for (Int i = 0; i < input_records.size(); ++i) {
         output_records->set(i, input_records.get(i));
       }
@@ -638,41 +636,40 @@ bool LogicalOrNode::filter(Error *error,
   }
 
   // Enumerate left-false records and apply the right-filter to it.
-  if (!right_record_set_.resize(error,
-                                input_records.size() -
-                                left_record_set_.size())) {
+  if (!right_records_.resize(error,
+                             input_records.size() - left_records_.size())) {
     return false;
   }
   Int left_count = 0;
   Int right_count = 0;
   for (Int i = 0; i < input_records.size(); ++i) {
     if (input_records.get_row_id(i) ==
-        left_record_set_.get_row_id((left_count))) {
+        left_records_.get_row_id((left_count))) {
       ++left_count;
     } else {
-      right_record_set_.set(right_count, input_records.get(i));
+      right_records_.set(right_count, input_records.get(i));
       ++right_count;
     }
   }
-  RecordSubset right_record_subset = right_record_set_.subset();
-  if (!rhs_->filter(error, right_record_subset, &right_record_subset)) {
+  ArrayRef<Record> right_record_ref = right_records_;
+  if (!rhs_->filter(error, right_record_ref, &right_record_ref)) {
     return false;
   }
-  if (!right_record_set_.resize(error, right_record_subset.size())) {
+  if (!right_records_.resize(error, right_record_ref.size())) {
     return false;
   }
-  if (right_record_set_.size() == 0) {
+  if (right_records_.size() == 0) {
     // There are no right-true records.
-    *output_records = output_records->subset(0, left_record_set_.size());
+    *output_records = output_records->ref(0, left_records_.size());
     for (Int i = 0; i < output_records->size(); ++i) {
-      output_records->set(i, left_record_set_.get(i));
+      output_records->set(i, left_records_.get(i));
     }
     return true;
-  } else if (right_record_set_.size() == right_count) {
+  } else if (right_records_.size() == right_count) {
     // There are no right-false records.
     // This means that all the records pass through the filter.
     if (&input_records != output_records) {
-      *output_records = output_records->subset(0, input_records.size());
+      *output_records = output_records->ref(0, input_records.size());
       for (Int i = 0; i < input_records.size(); ++i) {
         output_records->set(i, input_records.get(i));
       }
@@ -681,8 +678,8 @@ bool LogicalOrNode::filter(Error *error,
   }
 
   // Append sentinels.
-  if (!left_record_set_.append(error, Record(NULL_ROW_ID, 0.0)) ||
-      !right_record_set_.append(error, Record(NULL_ROW_ID, 0.0))) {
+  if (!left_records_.push_back(error, Record(NULL_ROW_ID, 0.0)) ||
+      !right_records_.push_back(error, Record(NULL_ROW_ID, 0.0))) {
     return false;
   }
 
@@ -691,41 +688,41 @@ bool LogicalOrNode::filter(Error *error,
   right_count = 0;
   for (Int i = 0; i < input_records.size(); ++i) {
     if (input_records.get_row_id(i) ==
-        left_record_set_.get_row_id(left_count)) {
+        left_records_.get_row_id(left_count)) {
       output_records->set(left_count + right_count, input_records.get(i));
       ++left_count;
     } else if (input_records.get_row_id(i) ==
-               right_record_set_.get_row_id(right_count)) {
+               right_records_.get_row_id(right_count)) {
       output_records->set(left_count + right_count, input_records.get(i));
       ++right_count;
     }
   }
-  *output_records = output_records->subset(0, left_count + right_count);
+  *output_records = output_records->ref(0, left_count + right_count);
   return true;
 }
 
-bool LogicalOrNode::evaluate(Error *error, const RecordSubset &record_set) {
+bool LogicalOrNode::evaluate(Error *error, const ArrayRef<Record> &records) {
   // TODO: This logic should be tested.
-  if (!this->values_.resize(error, record_set.size())) {
+  if (!this->values_.resize(error, records.size())) {
     return false;
   }
-  if (!lhs_->evaluate(error, record_set)) {
+  if (!lhs_->evaluate(error, records)) {
     return false;
   }
   // True records must not be evaluated for the 2nd argument.
-  left_record_set_.clear();
-  for (Int i = 0; i < record_set.size(); ++i) {
+  left_records_.clear();
+  for (Int i = 0; i < records.size(); ++i) {
     if (!lhs_->get(i)) {
-      if (!left_record_set_.append(error, record_set.get(i))) {
+      if (!left_records_.push_back(error, records.get(i))) {
         return false;
       }
     }
   }
-  if (!rhs_->evaluate(error, left_record_set_)) {
+  if (!rhs_->evaluate(error, left_records_)) {
     return false;
   }
   Int j = 0;
-  for (Int i = 0; i < record_set.size(); ++i) {
+  for (Int i = 0; i < records.size(); ++i) {
     this->values_.set(i, lhs_->get(i) ? true : rhs_->get(j++));
   }
   return true;
@@ -753,102 +750,102 @@ DataType Expression::data_type() const {
   return root_->data_type();
 }
 
-bool Expression::filter(Error *error, RecordSet *record_set, Int offset) {
-  RecordSubset input_subset = record_set->subset(offset);
-  RecordSubset output_subset = record_set->subset(offset);
-  while (input_subset.size() > block_size()) {
-    RecordSubset input_block = input_subset.subset(0, block_size());
-    if (input_subset.size() == output_subset.size()) {
+bool Expression::filter(Error *error, Array<Record> *records, Int offset) {
+  ArrayRef<Record> input_ref = records->ref(offset);
+  ArrayRef<Record> output_ref = records->ref(offset);
+  while (input_ref.size() > block_size()) {
+    ArrayRef<Record> input_block = input_ref.ref(0, block_size());
+    if (input_ref.size() == output_ref.size()) {
       if (!root_->filter(error, input_block, &input_block)) {
         return false;
       }
-      input_subset = input_subset.subset(block_size());
-      output_subset = output_subset.subset(input_block.size());
+      input_ref = input_ref.ref(block_size());
+      output_ref = output_ref.ref(input_block.size());
     } else {
-      RecordSubset output_block = output_subset;
+      ArrayRef<Record> output_block = output_ref;
       if (!root_->filter(error, input_block, &output_block)) {
         return false;
       }
-      input_subset = input_subset.subset(block_size());
-      output_subset = output_subset.subset(output_block.size());
+      input_ref = input_ref.ref(block_size());
+      output_ref = output_ref.ref(output_block.size());
     }
   }
-  RecordSubset output_block = output_subset;
-  if (!root_->filter(error, input_subset, &output_block)) {
+  ArrayRef<Record> output_block = output_ref;
+  if (!root_->filter(error, input_ref, &output_block)) {
     return false;
   }
-  output_subset = output_subset.subset(output_block.size());
-  return record_set->resize(error, record_set->size() - output_subset.size());
+  output_ref = output_ref.ref(output_block.size());
+  return records->resize(error, records->size() - output_ref.size());
 }
 
-bool Expression::adjust(Error *error, RecordSet *record_set, Int offset) {
-  RecordSubset subset = record_set->subset(offset);
-  while (subset.size() > block_size()) {
-    RecordSubset block = subset.subset(0, block_size());
+bool Expression::adjust(Error *error, Array<Record> *records, Int offset) {
+  ArrayRef<Record> ref = records->ref(offset);
+  while (ref.size() > block_size()) {
+    ArrayRef<Record> block = ref.ref(0, block_size());
     if (!root_->adjust(error, &block)) {
       return false;
     }
-    subset = subset.subset(block_size());
+    ref = ref.ref(block_size());
   }
-  return root_->adjust(error, &subset);
+  return root_->adjust(error, &ref);
 }
 
 template <typename T>
 bool Expression::evaluate(Error *error,
-                          const RecordSubset &record_set,
+                          const ArrayRef<Record> &records,
                           Array<T> *results) {
   if (TypeTraits<T>::data_type() != data_type()) {
     GRNXX_ERROR_SET(error, INVALID_ARGUMENT, "Invalid data type");
     return false;
   }
-  if (!results->resize(error, record_set.size())) {
+  if (!results->resize(error, records.size())) {
     return false;
   }
-  ArrayRef<T> ref = results->ref();
-  return evaluate(error, record_set, &ref);
+  ArrayRef<T> ref = *results;
+  return evaluate(error, records, &ref);
 }
 
 template bool Expression::evaluate(Error *error,
-                                   const RecordSubset &record_set,
+                                   const ArrayRef<Record> &records,
                                    Array<Bool> *results);
 template bool Expression::evaluate(Error *error,
-                                   const RecordSubset &record_set,
+                                   const ArrayRef<Record> &records,
                                    Array<Int> *results);
 template bool Expression::evaluate(Error *error,
-                                   const RecordSubset &record_set,
+                                   const ArrayRef<Record> &records,
                                    Array<Float> *results);
 template bool Expression::evaluate(Error *error,
-                                   const RecordSubset &record_set,
+                                   const ArrayRef<Record> &records,
                                    Array<Time> *results);
 template bool Expression::evaluate(Error *error,
-                                   const RecordSubset &record_set,
+                                   const ArrayRef<Record> &records,
                                    Array<GeoPoint> *results);
 template bool Expression::evaluate(Error *error,
-                                   const RecordSubset &record_set,
+                                   const ArrayRef<Record> &records,
                                    Array<Text> *results);
 
 template <typename T>
 bool Expression::evaluate(Error *error,
-                          const RecordSubset &record_set,
+                          const ArrayRef<Record> &records,
                           ArrayRef<T> *results) {
   if (TypeTraits<T>::data_type() != data_type()) {
     GRNXX_ERROR_SET(error, INVALID_ARGUMENT, "Invalid data type");
     return false;
   }
-  if (record_set.size() != results->size()) {
+  if (records.size() != results->size()) {
     GRNXX_ERROR_SET(error, INVALID_ARGUMENT, "Size conflict: "
                     "#records = %" PRIi64 ", #results = %" PRIi64,
-                    record_set.size(), results->size());
+                    records.size(), results->size());
     return false;
   }
-  RecordSubset input = record_set;
+  ArrayRef<Record> input = records;
   ArrayRef<T> output = *results;
   while (input.size() > block_size()) {
-    RecordSubset subset = input.subset(0, block_size());
-    if (!evaluate_block(error, subset, &output)) {
+    ArrayRef<Record> ref = input.ref(0, block_size());
+    if (!evaluate_block(error, ref, &output)) {
       return false;
     }
-    input = input.subset(block_size());
+    input = input.ref(block_size());
     output = output.ref(block_size());
   }
   return evaluate_block(error, input, &output);
@@ -860,13 +857,13 @@ Expression::Expression(const Table *table, unique_ptr<ExpressionNode> &&root)
 
 template <typename T>
 bool Expression::evaluate_block(Error *error,
-                                const RecordSubset &record_set,
+                                const ArrayRef<Record> &records,
                                 ArrayRef<T> *results) {
   Node<T> *node = static_cast<Node<T> *>(root_.get());
-  if (!node->evaluate(error, record_set)) {
+  if (!node->evaluate(error, records)) {
     return false;
   }
-  for (Int i = 0; i < record_set.size(); ++i) {
+  for (Int i = 0; i < records.size(); ++i) {
     results->set(i, node->get(i));
   }
   return true;

  Modified: lib/grnxx/expression2.cpp (+84 -86)
===================================================================
--- lib/grnxx/expression2.cpp    2014-08-08 13:01:48 +0900 (79967f4)
+++ lib/grnxx/expression2.cpp    2014-08-08 17:42:47 +0900 (6ae7db1)
@@ -3,7 +3,6 @@
 #include "grnxx/column_impl.hpp"
 #include "grnxx/datum.hpp"
 #include "grnxx/error.hpp"
-#include "grnxx/record.hpp"
 #include "grnxx/table.hpp"
 
 #include <iostream>  // For debugging.
@@ -42,12 +41,12 @@ class Node {
   // On failure, returns false and stores error information into "*error" if
   // "error" != nullptr.
   virtual bool filter(Error *error,
-                      const RecordSubset &input_records,
-                      RecordSubset *output_records) = 0;
+                      const ArrayRef<Record> &input_records,
+                      ArrayRef<Record> *output_records) = 0;
   // TODO
 //  virtual bool filter(Error *error,
-//                      const RecordSubset &input_records,
-//                      RecordSet *output_records) = 0;
+//                      const ArrayRef<Record> &input_records,
+//                      Array<Record> *output_records) = 0;
 
   // Adjust scores of records.
   //
@@ -57,7 +56,7 @@ class Node {
   // Returns true on success.
   // On failure, returns false and stores error information into "*error" if
   // "error" != nullptr.
-  virtual bool adjust(Error *error, RecordSubset *records) = 0;
+  virtual bool adjust(Error *error, ArrayRef<Record> *records) = 0;
 };
 
 // -- TypedNode --
@@ -75,9 +74,9 @@ class TypedNode : public Node {
   }
 
   virtual bool filter(Error *error,
-                      const RecordSubset &input_records,
-                      RecordSubset *output_records);
-  virtual bool adjust(Error *error, RecordSubset *records);
+                      const ArrayRef<Record> &input_records,
+                      ArrayRef<Record> *output_records);
+  virtual bool adjust(Error *error, ArrayRef<Record> *records);
 
   // Evaluate the expression subtree.
   //
@@ -87,14 +86,14 @@ class TypedNode : public Node {
   // On failure, returns false and stores error information into "*error" if
   // "error" != nullptr.
   virtual bool evaluate(Error *error,
-                        const RecordSubset &records,
+                        const ArrayRef<Record> &records,
                         ArrayRef<Value> *results) = 0;
 };
 
 template <typename T>
 bool TypedNode<T>::filter(Error *error,
-                          const RecordSubset &input_records,
-                          RecordSubset *output_records) {
+                          const ArrayRef<Record> &input_records,
+                          ArrayRef<Record> *output_records) {
   // Only TypedNode<Bool> supports filter().
   GRNXX_ERROR_SET(error, INVALID_OPERATION, "Invalid operation");
   return false;
@@ -102,14 +101,14 @@ bool TypedNode<T>::filter(Error *error,
 
 template <>
 bool TypedNode<Bool>::filter(Error *error,
-                             const RecordSubset &input_records,
-                             RecordSubset *output_records) {
+                             const ArrayRef<Record> &input_records,
+                             ArrayRef<Record> *output_records) {
   // TODO: This implementation should be overridden by derived classes.
   Array<Bool> results;
   if (!results.resize(error, input_records.size())) {
     return false;
   }
-  ArrayRef<Bool> results_ref = results.ref();
+  ArrayRef<Bool> results_ref = results;
   if (!evaluate(error, input_records, &results_ref)) {
     return false;
   }
@@ -120,26 +119,26 @@ bool TypedNode<Bool>::filter(Error *error,
       ++count;
     }
   }
-  *output_records = output_records->subset(0, count);
+  *output_records = output_records->ref(0, count);
   return true;
 }
 
 template <typename T>
 bool TypedNode<T>::adjust(Error *error,
-                          RecordSubset *records) {
+                          ArrayRef<Record> *records) {
   // Only TypedNode<Float> supports adjust().
   GRNXX_ERROR_SET(error, INVALID_OPERATION, "Invalid operation");
   return false;
 }
 
 template <>
-bool TypedNode<Float>::adjust(Error *error, RecordSubset *records) {
+bool TypedNode<Float>::adjust(Error *error, ArrayRef<Record> *records) {
   // TODO: This implementation should be overridden by derived classes.
   Array<Float> scores;
   if (!scores.resize(error, records->size())) {
     return false;
   }
-  ArrayRef<Float> scores_ref = scores.ref();
+  ArrayRef<Float> scores_ref = scores;
   if (!evaluate(error, *records, &scores_ref)) {
     return false;
   }
@@ -165,7 +164,7 @@ class DatumNode : public TypedNode<T> {
   }
 
   bool evaluate(Error *error,
-                const RecordSubset &records,
+                const ArrayRef<Record> &records,
                 ArrayRef<Value> *results);
 
  private:
@@ -174,7 +173,7 @@ class DatumNode : public TypedNode<T> {
 
 template <typename T>
 bool DatumNode<T>::evaluate(Error *error,
-                            const RecordSubset &records,
+                            const ArrayRef<Record> &records,
                             ArrayRef<Value> *results) {
   for (Int i = 0; i < records.size(); ++i) {
     (*results)[i] = datum_;
@@ -196,10 +195,10 @@ class DatumNode<Bool> : public TypedNode<Bool> {
   }
 
   bool filter(Error *error,
-              const RecordSubset &input_records,
-              RecordSubset *output_records);
+              const ArrayRef<Record> &input_records,
+              ArrayRef<Record> *output_records);
   bool evaluate(Error *error,
-                const RecordSubset &records,
+                const ArrayRef<Record> &records,
                 ArrayRef<Bool> *results);
 
  private:
@@ -207,8 +206,8 @@ class DatumNode<Bool> : public TypedNode<Bool> {
 };
 
 bool DatumNode<Bool>::filter(Error *error,
-                             const RecordSubset &input_records,
-                             RecordSubset *output_records) {
+                             const ArrayRef<Record> &input_records,
+                             ArrayRef<Record> *output_records) {
   if (datum_) {
     if (&input_records != output_records) {
       for (Int i = 0; i < input_records.size(); ++i) {
@@ -216,13 +215,13 @@ bool DatumNode<Bool>::filter(Error *error,
       }
     }
   } else {
-    *output_records = output_records->subset(0, 0);
+    *output_records = output_records->ref(0, 0);
   }
   return true;
 }
 
 bool DatumNode<Bool>::evaluate(Error *error,
-                               const RecordSubset &records,
+                               const ArrayRef<Record> &records,
                                ArrayRef<Bool> *results) {
   // TODO: Fill results per 64 bits.
   for (Int i = 0; i < records.size(); ++i) {
@@ -244,16 +243,16 @@ class DatumNode<Float> : public TypedNode<Float> {
     return DATUM_NODE;
   }
 
-  bool adjust(Error *error, RecordSubset *records);
+  bool adjust(Error *error, ArrayRef<Record> *records);
   bool evaluate(Error *error,
-                const RecordSubset &records,
+                const ArrayRef<Record> &records,
                 ArrayRef<Float> *results);
 
  private:
   Float datum_;
 };
 
-bool DatumNode<Float>::adjust(Error *error, RecordSubset *records) {
+bool DatumNode<Float>::adjust(Error *error, ArrayRef<Record> *records) {
   for (Int i = 0; i < records->size(); ++i) {
     records->set_score(i, datum_);
   }
@@ -261,7 +260,7 @@ bool DatumNode<Float>::adjust(Error *error, RecordSubset *records) {
 }
 
 bool DatumNode<Float>::evaluate(Error *error,
-                                const RecordSubset &records,
+                                const ArrayRef<Record> &records,
                                 ArrayRef<Float> *results) {
   for (Int i = 0; i < records.size(); ++i) {
     (*results)[i] = datum_;
@@ -284,7 +283,7 @@ class DatumNode<Text> : public TypedNode<Text> {
   }
 
   bool evaluate(Error *error,
-                const RecordSubset &records,
+                const ArrayRef<Record> &records,
                 ArrayRef<Text> *results);
 
  private:
@@ -292,7 +291,7 @@ class DatumNode<Text> : public TypedNode<Text> {
 };
 
 bool DatumNode<Text>::evaluate(Error *error,
-                               const RecordSubset &records,
+                               const ArrayRef<Record> &records,
                                ArrayRef<Text> *results) {
   Text datum = Text(datum_.data(), datum_.size());
   for (Int i = 0; i < records.size(); ++i) {
@@ -315,12 +314,12 @@ class RowIDNode : public TypedNode<Int> {
   }
 
   bool evaluate(Error *error,
-                const RecordSubset &records,
+                const ArrayRef<Record> &records,
                 ArrayRef<Int> *results);
 };
 
 bool RowIDNode::evaluate(Error *error,
-                         const RecordSubset &records,
+                         const ArrayRef<Record> &records,
                          ArrayRef<Int> *results) {
   for (Int i = 0; i < records.size(); ++i) {
     (*results)[i] = records.get_row_id(i);
@@ -340,19 +339,19 @@ class ScoreNode : public TypedNode<Float> {
     return SCORE_NODE;
   }
 
-  bool adjust(Error *error, RecordSubset *records);
+  bool adjust(Error *error, ArrayRef<Record> *records);
   bool evaluate(Error *error,
-                const RecordSubset &records,
+                const ArrayRef<Record> &records,
                 ArrayRef<Float> *results);
 };
 
-bool ScoreNode::adjust(Error *error, RecordSubset *records) {
+bool ScoreNode::adjust(Error *error, ArrayRef<Record> *records) {
   // Nothing to do.
   return true;
 }
 
 bool ScoreNode::evaluate(Error *error,
-                         const RecordSubset &records,
+                         const ArrayRef<Record> &records,
                          ArrayRef<Float> *results) {
   for (Int i = 0; i < records.size(); ++i) {
     (*results)[i] = records.get_score(i);
@@ -376,7 +375,7 @@ class ColumnNode : public TypedNode<T> {
   }
 
   bool evaluate(Error *error,
-                const RecordSubset &records,
+                const ArrayRef<Record> &records,
                 ArrayRef<Value> *results);
 
  private:
@@ -385,7 +384,7 @@ class ColumnNode : public TypedNode<T> {
 
 template <typename T>
 bool ColumnNode<T>::evaluate(Error *error,
-                             const RecordSubset &records,
+                             const ArrayRef<Record> &records,
                              ArrayRef<Value> *results) {
   for (Int i = 0; i < records.size(); ++i) {
     (*results)[i] = column_->get(records.get_row_id(i));
@@ -407,10 +406,10 @@ class ColumnNode<Bool> : public TypedNode<Bool> {
   }
 
   bool filter(Error *error,
-              const RecordSubset &input_records,
-              RecordSubset *output_records);
+              const ArrayRef<Record> &input_records,
+              ArrayRef<Record> *output_records);
   bool evaluate(Error *error,
-                const RecordSubset &records,
+                const ArrayRef<Record> &records,
                 ArrayRef<Bool> *results);
 
  private:
@@ -418,8 +417,8 @@ class ColumnNode<Bool> : public TypedNode<Bool> {
 };
 
 bool ColumnNode<Bool>::filter(Error *error,
-                              const RecordSubset &input_records,
-                              RecordSubset *output_records) {
+                              const ArrayRef<Record> &input_records,
+                              ArrayRef<Record> *output_records) {
   Int dest = 0;
   for (Int i = 0; i < input_records.size(); ++i) {
     if (column_->get(input_records.get_row_id(i))) {
@@ -427,12 +426,12 @@ bool ColumnNode<Bool>::filter(Error *error,
       ++dest;
     }
   }
-  *output_records = output_records->subset(0, dest);
+  *output_records = output_records->ref(0, dest);
   return true;
 }
 
 bool ColumnNode<Bool>::evaluate(Error *error,
-                                const RecordSubset &records,
+                                const ArrayRef<Record> &records,
                                 ArrayRef<Bool> *results) {
   for (Int i = 0; i < records.size(); ++i) {
     results->set(i, column_->get(records.get_row_id(i)));
@@ -453,16 +452,16 @@ class ColumnNode<Float> : public TypedNode<Float> {
     return COLUMN_NODE;
   }
 
-  bool adjust(Error *error, RecordSubset *records);
+  bool adjust(Error *error, ArrayRef<Record> *records);
   bool evaluate(Error *error,
-                const RecordSubset &records,
+                const ArrayRef<Record> &records,
                 ArrayRef<Float> *results);
 
  private:
   const ColumnImpl<Float> *column_;
 };
 
-bool ColumnNode<Float>::adjust(Error *error, RecordSubset *records) {
+bool ColumnNode<Float>::adjust(Error *error, ArrayRef<Record> *records) {
   for (Int i = 0; i < records->size(); ++i) {
     records->set_score(i, column_->get(records->get_row_id(i)));
   }
@@ -470,7 +469,7 @@ bool ColumnNode<Float>::adjust(Error *error, RecordSubset *records) {
 }
 
 bool ColumnNode<Float>::evaluate(Error *error,
-                                 const RecordSubset &records,
+                                 const ArrayRef<Record> &records,
                                  ArrayRef<Float> *results) {
   for (Int i = 0; i < records.size(); ++i) {
     (*results)[i] = column_->get(records.get_row_id(i));
@@ -501,7 +500,7 @@ class OperatorNode : public TypedNode<T> {
 // On failure, returns false and stores error information into "*error" if
 // "error" != nullptr.
 template <typename T>
-bool fill_node_arg_values(Error *error, const RecordSubset &records,
+bool fill_node_arg_values(Error *error, const ArrayRef<Record> &records,
                           TypedNode<T> *arg, Array<T> *arg_values) {
   Int old_size = arg_values->size();
   if (old_size < records.size()) {
@@ -513,7 +512,7 @@ bool fill_node_arg_values(Error *error, const RecordSubset &records,
     case DATUM_NODE: {
       if (old_size < records.size()) {
         ArrayRef<T> ref = arg_values->ref(old_size);
-        if (!arg->evaluate(error, records.subset(old_size), &ref)) {
+        if (!arg->evaluate(error, records.ref(old_size), &ref)) {
           return false;
         }
       }
@@ -547,7 +546,7 @@ class UnaryNode : public OperatorNode<T> {
   unique_ptr<TypedNode<Arg>> arg_;
   Array<Arg> arg_values_;
 
-  bool fill_arg_values(Error *error, const RecordSubset &records) {
+  bool fill_arg_values(Error *error, const ArrayRef<Record> &records) {
     return fill_node_arg_values(error, records, arg_.get(), &arg_values_);
   }
 };
@@ -563,19 +562,19 @@ class LogicalNotNode : public UnaryNode<Bool, Bool> {
         temp_records_() {}
 
   bool filter(Error *error,
-              const RecordSubset &input_records,
-              RecordSubset *output_records);
+              const ArrayRef<Record> &input_records,
+              ArrayRef<Record> *output_records);
   bool evaluate(Error *error,
-                const RecordSubset &records,
+                const ArrayRef<Record> &records,
                 ArrayRef<Bool> *results);
 
  private:
-  RecordSet temp_records_;
+  Array<Record> temp_records_;
 };
 
 bool LogicalNotNode::filter(Error *error,
-                            const RecordSubset &input_records,
-                            RecordSubset *output_records) {
+                            const ArrayRef<Record> &input_records,
+                            ArrayRef<Record> *output_records) {
   // Create a copy of "input_records" and then apply a filter to it.
   // Then, appends a sentinel to the end of the result.
   if (!temp_records_.resize(error, input_records.size() + 1)) {
@@ -584,29 +583,28 @@ bool LogicalNotNode::filter(Error *error,
   for (Int i = 0; i < input_records.size(); ++i) {
     temp_records_.set(i, input_records.get(i));
   }
-  RecordSubset subset = temp_records_.subset();
-  if (!arg_->filter(error, subset, &subset)) {
+  ArrayRef<Record> ref = temp_records_;
+  if (!arg_->filter(error, ref, &ref)) {
     return false;
   }
-  temp_records_.set_row_id(subset.size(), NULL_ROW_ID);
+  temp_records_.set_row_id(ref.size(), NULL_ROW_ID);
 
-  // Extract records which appear in "input_records" and don't appear in
-  // "subset".
+  // Extract records which appear in "input_records" and don't appear in "ref".
   Int count = 0;
   for (Int i = 0, j = 0; i < input_records.size(); ++i) {
-    if (input_records.get_row_id(i) == subset.get_row_id(j)) {
+    if (input_records.get_row_id(i) == ref.get_row_id(j)) {
       continue;
     }
     output_records->set(count, input_records.get(i));
     ++count;
     ++j;
   }
-  *output_records = output_records->subset(0, count);
+  *output_records = output_records->ref(0, count);
   return true;
 }
 
 bool LogicalNotNode::evaluate(Error *error,
-                              const RecordSubset &records,
+                              const ArrayRef<Record> &records,
                               ArrayRef<Bool> *results) {
   if (!arg_->evaluate(error, records, results)) {
     return false;
@@ -629,16 +627,16 @@ class BitwiseNotNode : public UnaryNode<Bool, Bool> {
       : UnaryNode<Bool, Bool>(std::move(arg)) {}
 
   bool filter(Error *error,
-              const RecordSubset &input_records,
-              RecordSubset *output_records);
+              const ArrayRef<Record> &input_records,
+              ArrayRef<Record> *output_records);
   bool evaluate(Error *error,
-                const RecordSubset &records,
+                const ArrayRef<Record> &records,
                 ArrayRef<Bool> *results);
 };
 
 bool BitwiseNotNode::filter(Error *error,
-                            const RecordSubset &input_records,
-                            RecordSubset *output_records) {
+                            const ArrayRef<Record> &input_records,
+                            ArrayRef<Record> *output_records) {
   if (!fill_arg_values(error, input_records)) {
     return false;
   }
@@ -649,12 +647,12 @@ bool BitwiseNotNode::filter(Error *error,
       ++count;
     }
   }
-  *output_records = output_records->subset(0, count);
+  *output_records = output_records->ref(0, count);
   return true;
 }
 
 bool BitwiseNotNode::evaluate(Error *error,
-                              const RecordSubset &records,
+                              const ArrayRef<Record> &records,
                               ArrayRef<Bool> *results) {
   if (!arg_->evaluate(error, records, results)) {
     return false;
@@ -697,10 +695,10 @@ class BinaryNode : public OperatorNode<T> {
   Array<Arg1> arg1_values_;
   Array<Arg2> arg2_values_;
 
-  bool fill_arg1_values(Error *error, const RecordSubset &records) {
+  bool fill_arg1_values(Error *error, const ArrayRef<Record> &records) {
     return fill_node_arg_values(error, records, arg1_.get(), &arg1_values_);
   }
-  bool fill_arg2_values(Error *error, const RecordSubset &records) {
+  bool fill_arg2_values(Error *error, const ArrayRef<Record> &records) {
     return fill_node_arg_values(error, records, arg2_.get(), &arg2_values_);
   }
 };
@@ -718,25 +716,25 @@ class LogicalAndNode : public BinaryNode<Bool, Bool, Bool> {
         temp_records_() {}
 
   bool filter(Error *error,
-              const RecordSubset &input_records,
-              RecordSubset *output_records);
+              const ArrayRef<Record> &input_records,
+              ArrayRef<Record> *output_records);
   bool evaluate(Error *error,
-                const RecordSubset &records,
+                const ArrayRef<Record> &records,
                 ArrayRef<Bool> *results);
 
  private:
-  RecordSet temp_records_;
+  Array<Record> temp_records_;
 };
 
 bool LogicalAndNode::filter(Error *error,
-                            const RecordSubset &input_records,
-                            RecordSubset *output_records) {
+                            const ArrayRef<Record> &input_records,
+                            ArrayRef<Record> *output_records) {
   return arg1_->filter(error, input_records, output_records) &&
          arg2_->filter(error, *output_records, output_records);
 }
 
 bool LogicalAndNode::evaluate(Error *error,
-                              const RecordSubset &records,
+                              const ArrayRef<Record> &records,
                               ArrayRef<Bool> *results) {
   // TODO
   return false;

  Deleted: lib/grnxx/record.cpp (+0 -7) 100644
===================================================================
--- lib/grnxx/record.cpp    2014-08-08 13:01:48 +0900 (3f90fe5)
+++ /dev/null
@@ -1,7 +0,0 @@
-#include "grnxx/record.hpp"
-
-#include "grnxx/error.hpp"
-
-namespace grnxx {
-
-}  // namespace

  Modified: lib/grnxx/sorter.cpp (+34 -35)
===================================================================
--- lib/grnxx/sorter.cpp    2014-08-08 13:01:48 +0900 (5043ae6)
+++ lib/grnxx/sorter.cpp    2014-08-08 17:42:47 +0900 (a185fd4)
@@ -4,7 +4,6 @@
 
 #include "grnxx/error.hpp"
 #include "grnxx/expression.hpp"
-#include "grnxx/record.hpp"
 
 namespace grnxx {
 
@@ -42,7 +41,7 @@ class SorterNode {
   // On failure, returns false and stores error information into "*error" if
   // "error" != nullptr.
   virtual bool sort(Error *error,
-                    RecordSubset subset,
+                    ArrayRef<Record> ref,
                     Int begin,
                     Int end) = 0;
 
@@ -109,7 +108,7 @@ class Node : public SorterNode {
         prior_to_() {}
   ~Node() {}
 
-  bool sort(Error *error, RecordSubset records, Int begin, Int end);
+  bool sort(Error *error, ArrayRef<Record> records, Int begin, Int end);
 
  private:
   SortOrder order_;
@@ -119,20 +118,20 @@ class Node : public SorterNode {
   // Sort records with ternary quick sort.
   //
   // Switches to insertion sort when the sorting range becomes small enough.
-  bool quick_sort(RecordSubset records, Value *values,
+  bool quick_sort(ArrayRef<Record> records, Value *values,
                   Int begin, Int end);
 
   // Sort records with insertion sort.
   //
   // Insertion sort should be used when there few records.
-  bool insertion_sort(RecordSubset records, Value *values);
+  bool insertion_sort(ArrayRef<Record> records, Value *values);
 
   // Choose the pivot and move it to the front.
-  void move_pivot_first(RecordSubset records, Value *values);
+  void move_pivot_first(ArrayRef<Record> records, Value *values);
 };
 
 template <typename T>
-bool Node<T>::sort(Error *error, RecordSubset records, Int begin, Int end) {
+bool Node<T>::sort(Error *error, ArrayRef<Record> records, Int begin, Int end) {
   if (!order_.expression->evaluate(error, records, &values_)) {
     return false;
   }
@@ -141,7 +140,7 @@ bool Node<T>::sort(Error *error, RecordSubset records, Int begin, Int end) {
 }
 
 template <typename T>
-bool Node<T>::quick_sort(RecordSubset records, Value *values,
+bool Node<T>::quick_sort(ArrayRef<Record> records, Value *values,
                          Int begin, Int end) {
   // Use ternary quick sort if there are enough records.
   //
@@ -208,7 +207,7 @@ bool Node<T>::quick_sort(RecordSubset records, Value *values,
         Int next_begin = (begin < left) ? 0 : (begin - left);
         Int next_end = ((end > right) ? right : end) - left;
         if (!this->next_->sort(this->error_,
-                               records.subset(left, right - left),
+                               records.ref(left, right - left),
                                next_begin, next_end)) {
           return false;
         }
@@ -223,14 +222,14 @@ bool Node<T>::quick_sort(RecordSubset records, Value *values,
     if (left < (records.size() - right)) {
       if ((begin < left) && (left >= 2)) {
         Int next_end = (end < left) ? end : left;
-        if (!quick_sort(records.subset(0, left), values, begin, next_end)) {
+        if (!quick_sort(records.ref(0, left), values, begin, next_end)) {
           return false;
         }
       }
       if (end <= right) {
         return true;
       }
-      records = records.subset(right);
+      records = records.ref(right);
       values += right;
       begin -= right;
       if (begin < 0) {
@@ -241,7 +240,7 @@ bool Node<T>::quick_sort(RecordSubset records, Value *values,
       if ((end > right) && ((records.size() - right) >= 2)) {
         Int next_begin = (begin < right) ? 0 : (begin - right);
         Int next_end = end - right;
-        if (!quick_sort(records.subset(right),
+        if (!quick_sort(records.ref(right),
                         values + right, next_begin, next_end)) {
           return false;
         }
@@ -249,7 +248,7 @@ bool Node<T>::quick_sort(RecordSubset records, Value *values,
       if (begin >= left) {
         return true;
       }
-      records = records.subset(0, left);
+      records = records.ref(0, left);
       if (end > left) {
         end = left;
       }
@@ -263,7 +262,7 @@ bool Node<T>::quick_sort(RecordSubset records, Value *values,
 }
 
 template <typename T>
-bool Node<T>::insertion_sort(RecordSubset records, Value *values) {
+bool Node<T>::insertion_sort(ArrayRef<Record> records, Value *values) {
   for (Int i = 1; i < records.size(); ++i) {
     for (Int j = i; j > 0; --j) {
       if (prior_to_(values[j], values[j - 1])) {
@@ -282,7 +281,7 @@ bool Node<T>::insertion_sort(RecordSubset records, Value *values) {
       if (values[i] != values[begin]) {
         if ((i - begin) >= 2) {
           if (!this->next_->sort(this->error_,
-                                 records.subset(begin, i - begin),
+                                 records.ref(begin, i - begin),
                                  0, i - begin)) {
             return false;
           }
@@ -292,7 +291,7 @@ bool Node<T>::insertion_sort(RecordSubset records, Value *values) {
     }
     if ((records.size() - begin) >= 2) {
       if (!this->next_->sort(this->error_,
-                             records.subset(begin),
+                             records.ref(begin),
                              0, records.size() - begin)) {
         return false;
       }
@@ -302,7 +301,7 @@ bool Node<T>::insertion_sort(RecordSubset records, Value *values) {
 }
 
 template <typename T>
-void Node<T>::move_pivot_first(RecordSubset records, Value *values) {
+void Node<T>::move_pivot_first(ArrayRef<Record> records, Value *values) {
   // Choose the median from values[1], values[1 / size], and values[size - 2].
   // The reason why not using values[0] and values[size - 1] is to avoid the
   // worst case which occurs when the records are sorted in reverse order.
@@ -365,7 +364,7 @@ class BoolNode : public SorterNode {
         is_prior_() {}
   ~BoolNode() {}
 
-  bool sort(Error *error, RecordSubset records, Int begin, Int end);
+  bool sort(Error *error, ArrayRef<Record> records, Int begin, Int end);
 
  private:
   SortOrder order_;
@@ -374,7 +373,7 @@ class BoolNode : public SorterNode {
 };
 
 template <typename T>
-bool BoolNode<T>::sort(Error *error, RecordSubset records,
+bool BoolNode<T>::sort(Error *error, ArrayRef<Record> records,
                        Int begin, Int end) {
   if (!order_.expression->evaluate(error, records, &values_)) {
     return false;
@@ -400,7 +399,7 @@ bool BoolNode<T>::sort(Error *error, RecordSubset records,
   if (this->next_) {
     // Apply the next sort condition if blocks contain 2 or more records.
     if ((left >= 2) && (begin < left)) {
-      if (!this->next_->sort(error, records.subset(0, left),
+      if (!this->next_->sort(error, records.ref(0, left),
                              begin, (end < left) ? end : left)) {
         return false;
       }
@@ -412,7 +411,7 @@ bool BoolNode<T>::sort(Error *error, RecordSubset records,
         begin -= left;
       }
       end -= left;
-      if (!this->next_->sort(error, records.subset(left), begin, end)) {
+      if (!this->next_->sort(error, records.ref(left), begin, end)) {
         return false;
       }
     }
@@ -547,8 +546,8 @@ unique_ptr<Sorter> Sorter::create(
   return sorter;
 }
 
-bool Sorter::reset(Error *error, RecordSet *record_set) {
-  record_set_ = record_set;
+bool Sorter::reset(Error *error, Array<Record> *records) {
+  records_ = records;
   return true;
 }
 
@@ -558,41 +557,41 @@ bool Sorter::progress(Error *error) {
 }
 
 bool Sorter::finish(Error *error) {
-  if (!record_set_) {
+  if (!records_) {
     // Nothing to do.
     return true;
   }
-  if ((offset_ >= record_set_->size()) || (limit_ <= 0)) {
-    record_set_->clear();
+  if ((offset_ >= records_->size()) || (limit_ <= 0)) {
+    records_->clear();
     return true;
   }
   Int begin = offset_;
   Int end;
-  if (limit_ <= (record_set_->size() - offset_)) {
+  if (limit_ <= (records_->size() - offset_)) {
     end = offset_ + limit_;
   } else {
-    end = record_set_->size();
+    end = records_->size();
   }
-  if (record_set_->size() <= 1) {
+  if (records_->size() <= 1) {
     return true;
   }
-  if (!head_->sort(error, record_set_->subset(), begin, end)) {
+  if (!head_->sort(error, records_->ref(), begin, end)) {
     return false;
   }
   for (Int i = begin, j = 0; i < end; ++i, ++j) {
-    record_set_->set(j, record_set_->get(i));
+    records_->set(j, records_->get(i));
   }
-  record_set_->resize(nullptr, end - begin);
+  records_->resize(nullptr, end - begin);
   return true;
 }
 
-bool Sorter::sort(Error *error, RecordSet *record_set) {
-  return reset(error, record_set) && finish(error);
+bool Sorter::sort(Error *error, Array<Record> *records) {
+  return reset(error, records) && finish(error);
 }
 
 Sorter::Sorter()
     : head_(),
-      record_set_(nullptr),
+      records_(nullptr),
       offset_(0),
       limit_(0) {}
 

  Modified: lib/grnxx/table.cpp (+12 -13)
===================================================================
--- lib/grnxx/table.cpp    2014-08-08 13:01:48 +0900 (09322ee)
+++ lib/grnxx/table.cpp    2014-08-08 17:42:47 +0900 (cde7c01)
@@ -4,7 +4,6 @@
 #include "grnxx/cursor.hpp"
 #include "grnxx/db.hpp"
 #include "grnxx/error.hpp"
-#include "grnxx/record.hpp"
 
 #include <iostream>  // For debug.
 
@@ -18,7 +17,7 @@ class TableCursor : public Cursor {
 
   ~TableCursor() {}
 
-  Int read(Error *error, Int max_count, RecordSet *record_set);
+  Int read(Error *error, Int max_count, Array<Record> *records);
 
   // -- Internal API --
 
@@ -32,10 +31,10 @@ class TableCursor : public Cursor {
                                         const CursorOptions &options);
 
   // Read records in regular order.
-  Int regular_read(Error *error, Int max_count, RecordSet *record_set);
+  Int regular_read(Error *error, Int max_count, Array<Record> *records);
 
   // Read records in reverse order.
-  Int reverse_read(Error *error, Int max_count, RecordSet *record_set);
+  Int reverse_read(Error *error, Int max_count, Array<Record> *records);
 
  private:
   Int offset_left_;
@@ -46,16 +45,16 @@ class TableCursor : public Cursor {
   explicit TableCursor(const Table *table);
 };
 
-Int TableCursor::read(Error *error, Int max_count, RecordSet *record_set) {
+Int TableCursor::read(Error *error, Int max_count, Array<Record> *records) {
   if (max_count <= 0) {
     return 0;
   }
   switch (order_type_) {
     case REGULAR_ORDER: {
-      return regular_read(error, max_count, record_set);
+      return regular_read(error, max_count, records);
     }
     case REVERSE_ORDER: {
-      return reverse_read(error, max_count, record_set);
+      return reverse_read(error, max_count, records);
     }
     default: {
       GRNXX_ERROR_SET(error, BROKEN, "Broken cursor");
@@ -102,7 +101,7 @@ TableCursor::TableCursor(const Table *table)
 
 Int TableCursor::regular_read(Error *error,
                               Int max_count,
-                              RecordSet *record_set) {
+                              Array<Record> *records) {
   // TODO: If possible, the buffer should be expanded outside the loop in order
   //       to remove size check and buffer expansion inside the loop.
   //       However, note that max_count can be extremely large for reading all
@@ -132,7 +131,7 @@ Int TableCursor::regular_read(Error *error,
       count = limit_left_;
     }
     for (Int i = 0; i < count; ++i) {
-      if (!record_set->append(error, Record(next_row_id_, 0.0))) {
+      if (!records->push_back(error, Record(next_row_id_, 0.0))) {
         return -1;
       }
       ++next_row_id_;
@@ -149,7 +148,7 @@ Int TableCursor::regular_read(Error *error,
         --offset_left_;
         ++next_row_id_;
       } else {
-        if (!record_set->append(error, Record(next_row_id_, 0.0))) {
+        if (!records->push_back(error, Record(next_row_id_, 0.0))) {
           return -1;
         }
         --limit_left_;
@@ -166,7 +165,7 @@ Int TableCursor::regular_read(Error *error,
 
 Int TableCursor::reverse_read(Error *error,
                               Int max_count,
-                              RecordSet *record_set) {
+                              Array<Record> *records) {
   // TODO: If possible, the buffer should be expanded outside the loop in order
   //       to remove size check and buffer expansion inside the loop.
   //       However, note that max_count can be extremely large for reading all
@@ -196,7 +195,7 @@ Int TableCursor::reverse_read(Error *error,
       count = limit_left_;
     }
     for (Int i = 0; i < count; ++i) {
-      if (!record_set->append(error, Record(next_row_id_, 0.0))) {
+      if (!records->push_back(error, Record(next_row_id_, 0.0))) {
         return -1;
       }
       --next_row_id_;
@@ -213,7 +212,7 @@ Int TableCursor::reverse_read(Error *error,
         --offset_left_;
         --next_row_id_;
       } else {
-        if (!record_set->append(error, Record(next_row_id_, 0.0))) {
+        if (!records->push_back(error, Record(next_row_id_, 0.0))) {
           return -1;
         }
         --limit_left_;

  Modified: test/test_grnxx.cpp (+155 -156)
===================================================================
--- test/test_grnxx.cpp    2014-08-08 13:01:48 +0900 (e203b44)
+++ test/test_grnxx.cpp    2014-08-08 17:42:47 +0900 (6768b6c)
@@ -25,7 +25,6 @@
 #include "grnxx/db.hpp"
 #include "grnxx/error.hpp"
 #include "grnxx/expression.hpp"
-#include "grnxx/record.hpp"
 #include "grnxx/sorter.hpp"
 #include "grnxx/table.hpp"
 
@@ -189,19 +188,19 @@ void test_table() {
   assert(cursor);
 
   // カーソルからレコードを読み出す．
-  grnxx::RecordSet record_set;
-  assert(cursor->read(&error, 0, &record_set) == 0);
+  grnxx::Array<grnxx::Record> records;
+  assert(cursor->read(&error, 0, &records) == 0);
 
-  assert(cursor->read(&error, 1, &record_set) == 1);
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 1);
+  assert(cursor->read(&error, 1, &records) == 1);
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 1);
 
-  assert(cursor->read(&error, 2, &record_set) == 1);
-  assert(record_set.size() == 2);
-  assert(record_set.get(0).row_id == 1);
-  assert(record_set.get(1).row_id == 3);
+  assert(cursor->read(&error, 2, &records) == 1);
+  assert(records.size() == 2);
+  assert(records.get(0).row_id == 1);
+  assert(records.get(1).row_id == 3);
 
-  record_set.clear();
+  records.clear();
 
   // 行 ID 降順のカーソルを作成する．
   grnxx::CursorOptions cursor_options;
@@ -209,24 +208,24 @@ void test_table() {
   cursor = table->create_cursor(&error, cursor_options);
   assert(cursor);
 
-  assert(cursor->read_all(&error, &record_set) == 2);
-  assert(record_set.size() == 2);
-  assert(record_set.get(0).row_id == 3);
-  assert(record_set.get(1).row_id == 1);
+  assert(cursor->read_all(&error, &records) == 2);
+  assert(records.size() == 2);
+  assert(records.get(0).row_id == 3);
+  assert(records.get(1).row_id == 1);
 
-  record_set.clear();
+  records.clear();
 
   cursor = table->create_cursor(&error, cursor_options);
   assert(cursor);
 
-  assert(cursor->read(&error, 1, &record_set) == 1);
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 3);
+  assert(cursor->read(&error, 1, &records) == 1);
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 3);
 
-  assert(cursor->read(&error, 2, &record_set) == 1);
-  assert(record_set.size() == 2);
-  assert(record_set.get(0).row_id == 3);
-  assert(record_set.get(1).row_id == 1);
+  assert(cursor->read(&error, 2, &records) == 1);
+  assert(records.size() == 2);
+  assert(records.get(0).row_id == 3);
+  assert(records.get(1).row_id == 1);
 }
 
 void test_bitmap() {
@@ -439,13 +438,13 @@ void test_expression() {
   assert(expression);
 
   // 恒真式のフィルタにかけても変化しないことを確認する．
-  grnxx::RecordSet record_set;
+  grnxx::Array<grnxx::Record> records;
   auto cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 2);
 
   // 演算子を含む恒真式を作成する．
   assert(builder->push_datum(&error, grnxx::Int(100)));
@@ -454,8 +453,8 @@ void test_expression() {
   expression = builder->release(&error);
   assert(expression);
 
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 2);
 
   // "BoolColumn" という名前のカラムに格納されている値を返すだけの式を作成する．
   assert(builder->push_column(&error, "BoolColumn"));
@@ -463,14 +462,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 2);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // "IntColumn" という名前のカラムに格納されている値が 123 のときだけ
   // 真になる式を作成する．
@@ -481,14 +480,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 1);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 1);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // "IntColumn" という名前のカラムに格納されている値が 123 でないときだけ
   // 真になる式を作成する．
@@ -499,14 +498,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 2);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 大小関係による比較を試す．
   assert(builder->push_column(&error, "IntColumn"));
@@ -516,14 +515,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 1);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 1);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 大小関係による比較を試す．
   assert(builder->push_column(&error, "TextColumn"));
@@ -533,14 +532,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 1);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 1);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 大小関係による比較を試す．
   assert(builder->push_column(&error, "TextColumn"));
@@ -550,14 +549,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 2);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 大小関係による比較を試す．
   assert(builder->push_column(&error, "IntColumn"));
@@ -567,14 +566,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 2);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 論理演算を試す．
   assert(builder->push_column(&error, "FloatColumn"));
@@ -586,14 +585,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 2);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 論理演算を試す．
   assert(builder->push_datum(&error, grnxx::Bool(false)));
@@ -603,14 +602,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 2);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 符号（+）を試す．
   assert(builder->push_column(&error, "IntColumn"));
@@ -621,14 +620,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 1);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 1);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 符号（-）を試す．
   assert(builder->push_column(&error, "IntColumn"));
@@ -639,14 +638,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 2);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 型変換（整数）を試す．
   assert(builder->push_column(&error, "FloatColumn"));
@@ -657,13 +656,13 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 2);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 型変換（浮動小数点数）を試す．
   assert(builder->push_column(&error, "IntColumn"));
@@ -674,14 +673,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 1);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 1);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // ビット論理積を試す．
   assert(builder->push_column(&error, "IntColumn"));
@@ -693,14 +692,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 2);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // ビット論理和を試す．
   assert(builder->push_column(&error, "IntColumn"));
@@ -712,14 +711,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 1);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 1);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // ビット排他的論理和を試す．
   assert(builder->push_column(&error, "IntColumn"));
@@ -731,14 +730,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 1);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 1);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 加算を試す．
   assert(builder->push_column(&error, "IntColumn"));
@@ -750,14 +749,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 1);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 1);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 減算を試す．
   assert(builder->push_column(&error, "FloatColumn"));
@@ -769,14 +768,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 2);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 乗算を試す．
   assert(builder->push_column(&error, "IntColumn"));
@@ -788,14 +787,14 @@ void test_expression() {
   assert(expression);
 
   // フィルタとして使ったときの結果を確認する．
-  assert(expression->filter(&error, &record_set));
-  assert(record_set.size() == 1);
-  assert(record_set.get(0).row_id == 2);
+  assert(expression->filter(&error, &records));
+  assert(records.size() == 1);
+  assert(records.get(0).row_id == 2);
 
-  record_set.clear();
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // スコア計算を試す．
   assert(builder->push_column(&error, "_score"));
@@ -805,17 +804,17 @@ void test_expression() {
   assert(expression);
 
   // スコア調整に使ったときの結果を確認する．
-  assert(expression->adjust(&error, &record_set));
-  assert(record_set.size() == 2);
-  assert(record_set.get(0).row_id == 1);
-  assert(record_set.get(0).score == 1.0);
-  assert(record_set.get(1).row_id == 2);
-  assert(record_set.get(1).score == 1.0);
-
-  record_set.clear();
+  assert(expression->adjust(&error, &records));
+  assert(records.size() == 2);
+  assert(records.get(0).row_id == 1);
+  assert(records.get(0).score == 1.0);
+  assert(records.get(1).row_id == 2);
+  assert(records.get(1).score == 1.0);
+
+  records.clear();
   cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) == 2);
+  assert(cursor->read_all(&error, &records) == 2);
 
   // 評価結果を取り出す．
   assert(builder->push_column(&error, "IntColumn"));
@@ -826,7 +825,7 @@ void test_expression() {
 
   // 評価結果を確認する．
   grnxx::Array<grnxx::Int> result_set;
-  assert(expression->evaluate(&error, record_set, &result_set));
+  assert(expression->evaluate(&error, records, &result_set));
   assert(result_set.size() == 2);
   assert(result_set[0] == 223);
   assert(result_set[1] == 556);
@@ -864,12 +863,12 @@ void test_sorter() {
     assert(int_column->set(&error, row_id, int_values[i]));
   }
 
-  grnxx::RecordSet record_set;
+  grnxx::Array<grnxx::Record> records;
   auto cursor = table->create_cursor(&error);
   assert(cursor);
-  assert(cursor->read_all(&error, &record_set) ==
+  assert(cursor->read_all(&error, &records) ==
          static_cast<grnxx::Int>(int_values.size()));
-  assert(record_set.size() == static_cast<grnxx::Int>(int_values.size()));
+  assert(records.size() == static_cast<grnxx::Int>(int_values.size()));
 
   // BoolColumn 昇順，行 ID 昇順に整列する．
   grnxx::Array<grnxx::SortOrder> orders;
@@ -889,12 +888,12 @@ void test_sorter() {
   auto sorter = grnxx::Sorter::create(&error, std::move(orders));
   assert(sorter);
 
-  assert(sorter->sort(&error, &record_set));
-  assert(record_set.size() == static_cast<grnxx::Int>(int_values.size()));
+  assert(sorter->sort(&error, &records));
+  assert(records.size() == static_cast<grnxx::Int>(int_values.size()));
 
-  for (grnxx::Int i = 1; i < record_set.size(); ++i) {
-    grnxx::Int lhs_id = record_set.get_row_id(i - 1) - 1;
-    grnxx::Int rhs_id = record_set.get_row_id(i) - 1;
+  for (grnxx::Int i = 1; i < records.size(); ++i) {
+    grnxx::Int lhs_id = records.get_row_id(i - 1) - 1;
+    grnxx::Int rhs_id = records.get_row_id(i) - 1;
     grnxx::Bool lhs_value = bool_values[lhs_id];
     grnxx::Bool rhs_value = bool_values[rhs_id];
     assert(!lhs_value || rhs_value);
@@ -921,12 +920,12 @@ void test_sorter() {
   sorter = grnxx::Sorter::create(&error, std::move(orders));
   assert(sorter);
 
-  assert(sorter->sort(&error, &record_set));
-  assert(record_set.size() == static_cast<grnxx::Int>(int_values.size()));
+  assert(sorter->sort(&error, &records));
+  assert(records.size() == static_cast<grnxx::Int>(int_values.size()));
 
-  for (grnxx::Int i = 1; i < record_set.size(); ++i) {
-    grnxx::Int lhs_id = record_set.get_row_id(i - 1) - 1;
-    grnxx::Int rhs_id = record_set.get_row_id(i) - 1;
+  for (grnxx::Int i = 1; i < records.size(); ++i) {
+    grnxx::Int lhs_id = records.get_row_id(i - 1) - 1;
+    grnxx::Int rhs_id = records.get_row_id(i) - 1;
     grnxx::Bool lhs_value = bool_values[lhs_id];
     grnxx::Bool rhs_value = bool_values[rhs_id];
     assert(lhs_value || !rhs_value);
@@ -950,12 +949,12 @@ void test_sorter() {
   sorter = grnxx::Sorter::create(&error, std::move(orders));
   assert(sorter);
 
-  assert(sorter->sort(&error, &record_set));
-  assert(record_set.size() == static_cast<grnxx::Int>(int_values.size()));
+  assert(sorter->sort(&error, &records));
+  assert(records.size() == static_cast<grnxx::Int>(int_values.size()));
 
-  for (grnxx::Int i = 1; i < record_set.size(); ++i) {
-    grnxx::Int lhs_id = record_set.get_row_id(i - 1) - 1;
-    grnxx::Int rhs_id = record_set.get_row_id(i) - 1;
+  for (grnxx::Int i = 1; i < records.size(); ++i) {
+    grnxx::Int lhs_id = records.get_row_id(i - 1) - 1;
+    grnxx::Int rhs_id = records.get_row_id(i) - 1;
     grnxx::Int lhs_value = int_values[lhs_id];
     grnxx::Int rhs_value = int_values[rhs_id];
     assert(lhs_value <= rhs_value);
@@ -981,12 +980,12 @@ void test_sorter() {
   sorter = grnxx::Sorter::create(&error, std::move(orders));
   assert(sorter);
 
-  assert(sorter->sort(&error, &record_set));
-  assert(record_set.size() == static_cast<grnxx::Int>(int_values.size()));
+  assert(sorter->sort(&error, &records));
+  assert(records.size() == static_cast<grnxx::Int>(int_values.size()));
 
-  for (grnxx::Int i = 1; i < record_set.size(); ++i) {
-    grnxx::Int lhs_id = record_set.get_row_id(i - 1) - 1;
-    grnxx::Int rhs_id = record_set.get_row_id(i) - 1;
+  for (grnxx::Int i = 1; i < records.size(); ++i) {
+    grnxx::Int lhs_id = records.get_row_id(i - 1) - 1;
+    grnxx::Int rhs_id = records.get_row_id(i) - 1;
     grnxx::Int lhs_value = int_values[lhs_id];
     grnxx::Int rhs_value = int_values[rhs_id];
     assert(lhs_value >= rhs_value);


More information about the Groonga-commit mailing list
アーカイブの一覧に戻る