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����������������������������...下載
