[Groonga-commit] groonga/grnxx at 546598d [master] Add MinusMerger. (#66)

Back to archive index

susumu.yata null+****@clear*****
Wed Sep 24 10:43:26 JST 2014


susumu.yata	2014-09-24 10:43:26 +0900 (Wed, 24 Sep 2014)

  New Revision: 546598dff34df22e85061fe2e1e1344624343f08
  https://github.com/groonga/grnxx/commit/546598dff34df22e85061fe2e1e1344624343f08

  Message:
    Add MinusMerger. (#66)

  Modified files:
    lib/grnxx/merger.cpp

  Modified: lib/grnxx/merger.cpp (+153 -2)
===================================================================
--- lib/grnxx/merger.cpp    2014-09-22 17:47:43 +0900 (bcd51ec)
+++ lib/grnxx/merger.cpp    2014-09-24 10:43:26 +0900 (bbb18ff)
@@ -328,6 +328,152 @@ bool OrMerger::finish(Error *error) {
   return true;
 }
 
+// -- XorMerger --
+
+// TODO
+
+// -- MinusMerger --
+
+class MinusMerger : public Merger {
+ public:
+  ~MinusMerger() {}
+
+  static unique_ptr<Merger> create(Error *error, const MergerOptions &options);
+
+  bool reset(Error *error,
+             Array<Record> *input_records_1,
+             Array<Record> *input_records_2,
+             Array<Record> *output_records);
+
+  bool finish(Error *error);
+
+ private:
+  Array<Record> *input_records_1_;
+  Array<Record> *input_records_2_;
+  Array<Record> *output_records_;
+  MergerOperatorType operator_type_;
+  Int offset_;
+  Int limit_;
+
+  MinusMerger(MergerOperatorType operator_type, Int offset, Int limit)
+      : Merger(),
+        input_records_1_(nullptr),
+        input_records_2_(nullptr),
+        output_records_(nullptr),
+        operator_type_(operator_type),
+        offset_(offset),
+        limit_(limit) {}
+};
+
+unique_ptr<Merger> MinusMerger::create(Error *error,
+                                       const MergerOptions &options) {
+  unique_ptr<Merger> merger(
+      new (nothrow) MinusMerger(options.operator_type,
+                                options.offset,
+                                options.limit));
+  if (!merger) {
+    GRNXX_ERROR_SET(error, NO_MEMORY, "Memory allocation failed");
+    return nullptr;
+  }
+  return merger;
+}
+
+bool MinusMerger::reset(Error *,
+                        Array<Record> *input_records_1,
+                        Array<Record> *input_records_2,
+                        Array<Record> *output_records) {
+  input_records_1_ = input_records_1;
+  input_records_2_ = input_records_2;
+  output_records_ = output_records;
+  return true;
+}
+
+bool MinusMerger::finish(Error *error) {
+  // Create a hash table from the smaller input.
+  Array<Record> *filter_records;
+  Array<Record> *stream_records;
+  if (input_records_1_->size() < input_records_2_->size()) {
+    filter_records = input_records_1_;
+    stream_records = input_records_2_;
+  } else {
+    filter_records = input_records_2_;
+    stream_records = input_records_1_;
+  }
+  std::unordered_map<Int, Float> filter;
+  for (Int i = 0; i < filter_records->size(); ++i) try {
+    filter[filter_records->get_row_id(i)] = filter_records->get_score(i);
+  } catch (...) {
+    GRNXX_ERROR_SET(error, NO_MEMORY, "Memory allocation failed");
+    return false;
+  }
+
+  // Filter the stream (the larger input) with the hash table.
+  const MergerOperatorType operator_type = operator_type_;
+  const bool stream_is_1 = stream_records == input_records_1_;
+  for (Int i = 0; i < stream_records->size(); ++i) {
+    auto it = filter.find(stream_records->get_row_id(i));
+    if (it != filter.end()) {
+      filter.erase(it);
+    }
+  }
+
+  for (auto it : filter) {
+    Record record;
+    record.row_id = it.first;
+    switch (operator_type) {
+      case PLUS_MERGER_OPERATOR: {
+        break;
+      }
+      case MINUS_MERGER_OPERATOR: {
+        record.score = stream_is_1 ? -it.second : it.second;
+        break;
+      }
+      case MULTIPLICATION_MERGER_OPERATOR: {
+        // TODO: I'm not sure if it.second should be used?
+        record.score = 0.0;
+        break;
+      }
+      case LHS_MERGER_OPERATOR: {
+        record.score = stream_is_1 ? 0.0 : it.second;
+        break;
+      }
+      case RHS_MERGER_OPERATOR: {
+        record.score = stream_is_1 ? it.second : 0.0;
+        break;
+      }
+      case ZERO_MERGER_OPERATOR: {
+        record.score = 0.0;
+        break;
+      }
+    }
+    if (!output_records_->push_back(error, record)) {
+      return false;
+    }
+  }
+
+  // Remove out-of-range records.
+  if (offset_ > 0) {
+    for (Int i = offset_; i < output_records_->size(); ++i) {
+      output_records_->set(i - offset_, output_records_->get(i));
+    }
+    output_records_->resize(nullptr, output_records_->size() - offset_);
+  }
+  if (limit_ < output_records_->size()) {
+    output_records_->resize(nullptr, limit_);
+  }
+  input_records_1_->clear();
+  input_records_2_->clear();
+  return true;
+}
+
+// -- LhsMerger --
+
+// TODO
+
+// -- RhsMerger --
+
+// TODO
+
 // -- Merger --
 
 Merger::Merger() {}
@@ -342,8 +488,13 @@ unique_ptr<Merger> Merger::create(Error *error, const MergerOptions &options) {
     case OR_MERGER: {
       return OrMerger::create(error, options);
     }
-    case XOR_MERGER:
-    case MINUS_MERGER:
+    case XOR_MERGER: {
+      GRNXX_ERROR_SET(error, NOT_SUPPORTED_YET, "Not supported yet");
+      return nullptr;
+    }
+    case MINUS_MERGER: {
+      return MinusMerger::create(error, options);
+    }
     case LHS_MERGER:
     case RHS_MERGER: {
       GRNXX_ERROR_SET(error, NOT_SUPPORTED_YET, "Not supported yet");
-------------- next part --------------
HTML����������������������������...
Download 



More information about the Groonga-commit mailing list
Back to archive index