Groonga - fulltext search engine.

[Groonga-commit] groonga/grnxx at 29ea410 [master] Add null_score to MergerOptions. (#69)

susumu.yata null+****@clear*****
Thu Sep 25 13:53:40 JST 2014

• Previous message: [Groonga-commit] droonga/droonga-http-server at 486ddab [master] Cache the resolved path
• Next message: [Groonga-commit] groonga/grnxx at 9d21ec6 [master] Update tests for Merger. (#69)
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

susumu.yata	2014-09-25 13:53:40 +0900 (Thu, 25 Sep 2014)

  New Revision: 29ea41024d5c71f22fc228d5ec16ac4112b32843
  https://github.com/groonga/grnxx/commit/29ea41024d5c71f22fc228d5ec16ac4112b32843

  Message:
    Add null_score to MergerOptions. (#69)

  Modified files:
    include/grnxx/types/options.hpp
    lib/grnxx/merger.cpp
    lib/grnxx/types.cpp

  Modified: include/grnxx/types/options.hpp (+3 -0)
===================================================================
--- include/grnxx/types/options.hpp    2014-09-25 12:24:48 +0900 (34a8192)
+++ include/grnxx/types/options.hpp    2014-09-25 13:53:40 +0900 (e5a4247)
@@ -63,6 +63,9 @@ struct MergerOptions {
   // How to merge scores.
   MergerOperatorType operator_type;
 
+  // This value is used when a corresponding record does not exist.
+  Float null_score;
+
   // The first "offset" records are skipped (default: 0).
   Int offset;
 

  Modified: lib/grnxx/merger.cpp (+96 -49)
===================================================================
--- lib/grnxx/merger.cpp    2014-09-25 12:24:48 +0900 (632043a)
+++ lib/grnxx/merger.cpp    2014-09-25 13:53:40 +0900 (47ca119)
@@ -166,15 +166,20 @@ class OrMerger : public Merger {
   Array<Record> *input_records_2_;
   Array<Record> *output_records_;
   MergerOperatorType operator_type_;
+  Float null_score_;
   Int offset_;
   Int limit_;
 
-  OrMerger(MergerOperatorType operator_type, Int offset, Int limit)
+  OrMerger(MergerOperatorType operator_type,
+           Float null_score,
+           Int offset,
+           Int limit)
       : Merger(),
         input_records_1_(nullptr),
         input_records_2_(nullptr),
         output_records_(nullptr),
         operator_type_(operator_type),
+        null_score_(null_score),
         offset_(offset),
         limit_(limit) {}
 };
@@ -183,6 +188,7 @@ unique_ptr<Merger> OrMerger::create(Error *error,
                                     const MergerOptions &options) {
   unique_ptr<Merger> merger(
       new (nothrow) OrMerger(options.operator_type,
+                             options.null_score,
                              options.offset,
                              options.limit));
   if (!merger) {
@@ -231,32 +237,32 @@ bool OrMerger::finish(Error *error) {
     if (it == filter.end()) {
       switch (operator_type) {
         case PLUS_MERGER_OPERATOR: {
-          record.score = stream_records->get_score(i);
+          record.score = stream_records->get_score(i) + null_score_;
           break;
         }
         case MINUS_MERGER_OPERATOR: {
-          record.score = stream_records->get_score(i);
-          if (!stream_is_1) {
-            record.score = -record.score;
+          if (stream_is_1) {
+            record.score = stream_records->get_score(i) - null_score_;
+          } else {
+            record.score = null_score_ - stream_records->get_score(i);
           }
           break;
         }
         case MULTIPLICATION_MERGER_OPERATOR: {
-          // TODO: I'm not sure if stream_records->get_score(i) should be used?
-          record.score = 0.0;
+          record.score = stream_records->get_score(i) * null_score_;
           break;
         }
         case LHS_MERGER_OPERATOR: {
           if (stream_is_1) {
             record.score = stream_records->get_score(i);
           } else {
-            record.score = 0.0;
+            record.score = null_score_;
           }
           break;
         }
         case RHS_MERGER_OPERATOR: {
           if (stream_is_1) {
-            record.score = 0.0;
+            record.score = null_score_;
           } else {
             record.score = stream_records->get_score(i);
           }
@@ -316,28 +322,30 @@ bool OrMerger::finish(Error *error) {
   for (auto it : filter) {
     switch (operator_type) {
       case PLUS_MERGER_OPERATOR: {
+        it.second += null_score_;
         break;
       }
       case MINUS_MERGER_OPERATOR: {
         if (stream_is_1) {
-          it.second = -it.second;
+          it.second = null_score_ - it.second;
+        } else {
+          it.second -= null_score_;
         }
         break;
       }
       case MULTIPLICATION_MERGER_OPERATOR: {
-        // TODO: I'm not sure if it.second should be used?
-        it.second = 0.0;
+        it.second *= null_score_;
         break;
       }
       case LHS_MERGER_OPERATOR: {
         if (stream_is_1) {
-          it.second = 0.0;
+          it.second = null_score_;
         }
         break;
       }
       case RHS_MERGER_OPERATOR: {
         if (!stream_is_1) {
-          it.second = 0.0;
+          it.second = null_score_;
         }
         break;
       }
@@ -386,15 +394,20 @@ class XorMerger : public Merger {
   Array<Record> *input_records_2_;
   Array<Record> *output_records_;
   MergerOperatorType operator_type_;
+  Float null_score_;
   Int offset_;
   Int limit_;
 
-  XorMerger(MergerOperatorType operator_type, Int offset, Int limit)
+  XorMerger(MergerOperatorType operator_type,
+            Float null_score,
+            Int offset,
+            Int limit)
       : Merger(),
         input_records_1_(nullptr),
         input_records_2_(nullptr),
         output_records_(nullptr),
         operator_type_(operator_type),
+        null_score_(null_score),
         offset_(offset),
         limit_(limit) {}
 };
@@ -403,6 +416,7 @@ unique_ptr<Merger> XorMerger::create(Error *error,
                                      const MergerOptions &options) {
   unique_ptr<Merger> merger(
       new (nothrow) XorMerger(options.operator_type,
+                              options.null_score,
                               options.offset,
                               options.limit));
   if (!merger) {
@@ -453,32 +467,32 @@ bool XorMerger::finish(Error *error) {
       record.row_id = stream_records->get_row_id(i);
       switch (operator_type) {
         case PLUS_MERGER_OPERATOR: {
-          record.score = stream_records->get_score(i);
+          record.score = stream_records->get_score(i) + null_score_;
           break;
         }
         case MINUS_MERGER_OPERATOR: {
-          record.score = stream_records->get_score(i);
-          if (!stream_is_1) {
-            record.score = -record.score;
+          if (stream_is_1) {
+            record.score = stream_records->get_score(i) - null_score_;
+          } else {
+            record.score = null_score_ - stream_records->get_score(i);
           }
           break;
         }
         case MULTIPLICATION_MERGER_OPERATOR: {
-          // TODO: I'm not sure if stream_records->get_score(i) should be used?
-          record.score = 0.0;
+          record.score = stream_records->get_score(i) * null_score_;
           break;
         }
         case LHS_MERGER_OPERATOR: {
           if (stream_is_1) {
             record.score = stream_records->get_score(i);
           } else {
-            record.score = 0.0;
+            record.score = null_score_;
           }
           break;
         }
         case RHS_MERGER_OPERATOR: {
           if (stream_is_1) {
-            record.score = 0.0;
+            record.score = null_score_;
           } else {
             record.score = stream_records->get_score(i);
           }
@@ -498,28 +512,30 @@ bool XorMerger::finish(Error *error) {
   for (auto it : filter) {
     switch (operator_type) {
       case PLUS_MERGER_OPERATOR: {
+        it.second += null_score_;
         break;
       }
       case MINUS_MERGER_OPERATOR: {
         if (stream_is_1) {
-          it.second = -it.second;
+          it.second = null_score_ - it.second;
+        } else {
+          it.second -= null_score_;
         }
         break;
       }
       case MULTIPLICATION_MERGER_OPERATOR: {
-        // TODO: I'm not sure if it.second should be used?
-        it.second = 0.0;
+        it.second *= null_score_;
         break;
       }
       case LHS_MERGER_OPERATOR: {
         if (stream_is_1) {
-          it.second = 0.0;
+          it.second = null_score_;
         }
         break;
       }
       case RHS_MERGER_OPERATOR: {
         if (!stream_is_1) {
-          it.second = 0.0;
+          it.second = null_score_;
         }
         break;
       }
@@ -568,15 +584,20 @@ class MinusMerger : public Merger {
   Array<Record> *input_records_2_;
   Array<Record> *output_records_;
   MergerOperatorType operator_type_;
+  Float null_score_;
   Int offset_;
   Int limit_;
 
-  MinusMerger(MergerOperatorType operator_type, Int offset, Int limit)
+  MinusMerger(MergerOperatorType operator_type,
+              Float null_score,
+              Int offset,
+              Int limit)
       : Merger(),
         input_records_1_(nullptr),
         input_records_2_(nullptr),
         output_records_(nullptr),
         operator_type_(operator_type),
+        null_score_(null_score),
         offset_(offset),
         limit_(limit) {}
 };
@@ -585,6 +606,7 @@ unique_ptr<Merger> MinusMerger::create(Error *error,
                                        const MergerOptions &options) {
   unique_ptr<Merger> merger(
       new (nothrow) MinusMerger(options.operator_type,
+                                options.null_score,
                                 options.offset,
                                 options.limit));
   if (!merger) {
@@ -634,19 +656,25 @@ bool MinusMerger::finish(Error *error) {
       }
       Record record = stream_records->get(i);
       switch (operator_type) {
-        case PLUS_MERGER_OPERATOR:
+        case PLUS_MERGER_OPERATOR: {
+          record.score += null_score_;
+          break;
+        }
         case MINUS_MERGER_OPERATOR: {
+          record.score -= null_score_;
           break;
         }
         case MULTIPLICATION_MERGER_OPERATOR: {
-          // TODO: I'm not sure if it.second should be used?
-          record.score = 0.0;
+          record.score *= null_score_;
           break;
         }
         case LHS_MERGER_OPERATOR: {
           break;
         }
-        case RHS_MERGER_OPERATOR:
+        case RHS_MERGER_OPERATOR: {
+          record.score = null_score_;
+          break;
+        }
         case ZERO_MERGER_OPERATOR: {
           record.score = 0.0;
           break;
@@ -668,23 +696,25 @@ bool MinusMerger::finish(Error *error) {
       record.row_id = it.first;
       switch (operator_type) {
         case PLUS_MERGER_OPERATOR: {
-          record.score = it.second;
+          record.score = it.second + null_score_;
           break;
         }
         case MINUS_MERGER_OPERATOR: {
-          record.score = it.second;
+          record.score = it.second - null_score_;
           break;
         }
         case MULTIPLICATION_MERGER_OPERATOR: {
-          // TODO: I'm not sure if it.second should be used?
-          record.score = 0.0;
+          record.score = it.second * null_score_;
           break;
         }
         case LHS_MERGER_OPERATOR: {
           record.score = it.second;
           break;
         }
-        case RHS_MERGER_OPERATOR:
+        case RHS_MERGER_OPERATOR: {
+          record.score = null_score_;
+          break;
+        }
         case ZERO_MERGER_OPERATOR: {
           record.score = 0.0;
           break;
@@ -731,15 +761,20 @@ class LhsMerger : public Merger {
   Array<Record> *input_records_2_;
   Array<Record> *output_records_;
   MergerOperatorType operator_type_;
+  Float null_score_;
   Int offset_;
   Int limit_;
 
-  LhsMerger(MergerOperatorType operator_type, Int offset, Int limit)
+  LhsMerger(MergerOperatorType operator_type,
+            Float null_score,
+            Int offset,
+            Int limit)
       : Merger(),
         input_records_1_(nullptr),
         input_records_2_(nullptr),
         output_records_(nullptr),
         operator_type_(operator_type),
+        null_score_(null_score),
         offset_(offset),
         limit_(limit) {}
 };
@@ -748,6 +783,7 @@ unique_ptr<Merger> LhsMerger::create(Error *error,
                                      const MergerOptions &options) {
   unique_ptr<Merger> merger(
       new (nothrow) LhsMerger(options.operator_type,
+                              options.null_score,
                               options.offset,
                               options.limit));
   if (!merger) {
@@ -807,19 +843,25 @@ bool LhsMerger::finish(Error *error) {
       }
     } else {
       switch (operator_type) {
-        case PLUS_MERGER_OPERATOR:
+        case PLUS_MERGER_OPERATOR: {
+          record.score += null_score_;
+          break;
+        }
         case MINUS_MERGER_OPERATOR: {
+          record.score -= null_score_;
           break;
         }
         case MULTIPLICATION_MERGER_OPERATOR: {
-          // TODO: I'm not sure if it->second should be used?
-          record.score = 0.0;
+          record.score *= null_score_;
           break;
         }
         case LHS_MERGER_OPERATOR: {
           break;
         }
-        case RHS_MERGER_OPERATOR:
+        case RHS_MERGER_OPERATOR: {
+          record.score = null_score_;
+          break;
+        }
         case ZERO_MERGER_OPERATOR: {
           record.score = 0.0;
           break;
@@ -867,15 +909,20 @@ class RhsMerger : public Merger {
   Array<Record> *input_records_2_;
   Array<Record> *output_records_;
   MergerOperatorType operator_type_;
+  Float null_score_;
   Int offset_;
   Int limit_;
 
-  RhsMerger(MergerOperatorType operator_type, Int offset, Int limit)
+  RhsMerger(MergerOperatorType operator_type,
+            Float null_score,
+            Int offset,
+            Int limit)
       : Merger(),
         input_records_1_(nullptr),
         input_records_2_(nullptr),
         output_records_(nullptr),
         operator_type_(operator_type),
+        null_score_(null_score),
         offset_(offset),
         limit_(limit) {}
 };
@@ -884,6 +931,7 @@ unique_ptr<Merger> RhsMerger::create(Error *error,
                                      const MergerOptions &options) {
   unique_ptr<Merger> merger(
       new (nothrow) RhsMerger(options.operator_type,
+                              options.null_score,
                               options.offset,
                               options.limit));
   if (!merger) {
@@ -946,20 +994,19 @@ bool RhsMerger::finish(Error *error) {
     } else {
       switch (operator_type) {
         case PLUS_MERGER_OPERATOR: {
-          record.score = input_records_2_->get_score(i);
+          record.score = null_score_ + input_records_2_->get_score(i);
           break;
         }
         case MINUS_MERGER_OPERATOR: {
-          record.score = -input_records_2_->get_score(i);
+          record.score = null_score_ - input_records_2_->get_score(i);
           break;
         }
         case MULTIPLICATION_MERGER_OPERATOR: {
-          // TODO: I'm not sure if input_records_2_->get_score(i) should be used?
-          record.score = 0.0;
+          record.score = null_score_ * input_records_2_->get_score(i);
           break;
         }
         case LHS_MERGER_OPERATOR: {
-          record.score = 0.0;
+          record.score = null_score_;
           break;
         }
         case RHS_MERGER_OPERATOR: {

  Modified: lib/grnxx/types.cpp (+1 -0)
===================================================================
--- lib/grnxx/types.cpp    2014-09-25 12:24:48 +0900 (636a24e)
+++ lib/grnxx/types.cpp    2014-09-25 13:53:40 +0900 (5661d9e)
@@ -63,6 +63,7 @@ SorterOptions::SorterOptions()
 MergerOptions::MergerOptions()
     : type(AND_MERGER),
       operator_type(PLUS_MERGER_OPERATOR),
+      null_score(0.0),
       offset(0),
       limit(numeric_limits<Int>::max()) {}
 
-------------- next part --------------
HTML����������������������������...
Download 

• Previous message: [Groonga-commit] droonga/droonga-http-server at 486ddab [master] Cache the resolved path
• Next message: [Groonga-commit] groonga/grnxx at 9d21ec6 [master] Update tests for Merger. (#69)
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]