Add to_filter_id_array and and_scalar methods.

include/filter.h

@@ -2,10 +2,14 @@
 
 #include <string>
 #include <map>
+#include <field.h>
 #include "posting_list.h"
 #include "index.h"
 
 class Index;
+struct filter_node_t;
+struct reference_filter_result_t;
+struct filter_result_t;
 
 class filter_result_iterator_t {
 private:
@@ -52,9 +56,9 @@ public:
 
     explicit filter_result_iterator_t(const std::string collection_name,
                                       Index const* const index, filter_node_t const* const filter_node) :
-                                      collection_name(collection_name),
-                                      index(index),
-                                      filter_node(filter_node) {
+            collection_name(collection_name),
+            index(index),
+            filter_node(filter_node) {
         if (filter_node == nullptr) {
             is_valid = false;
             return;
@@ -143,4 +147,10 @@ public:
 
     /// Returns to the initial state of the iterator.
     void reset();
+
+    /// Iterates and collects all the filter ids into filter_array.
+    /// \return size of the filter array
+    uint32_t to_filter_id_array(uint32_t*& filter_array);
+
+    uint32_t and_scalar(const uint32_t* A, const uint32_t& lenA, uint32_t*& results);
 };

src/filter.cpp

@@ -594,3 +594,48 @@ void filter_result_iterator_t::reset() {
         return;
     }
 }
+
+uint32_t filter_result_iterator_t::to_filter_id_array(uint32_t*& filter_array) {
+    if (!valid()) {
+        return 0;
+    }
+
+    std::vector<uint32_t> filter_ids;
+    do {
+        filter_ids.push_back(seq_id);
+        next();
+    } while (valid());
+
+    filter_array = new uint32_t[filter_ids.size()];
+    std::copy(filter_ids.begin(), filter_ids.end(), filter_array);
+
+    return filter_ids.size();
+}
+
+uint32_t filter_result_iterator_t::and_scalar(const uint32_t* A, const uint32_t& lenA, uint32_t*& results) {
+    if (!valid()) {
+        return 0;
+    }
+
+    std::vector<uint32_t> filter_ids;
+    for (uint32_t i = 0; i < lenA; i++) {
+        auto result = valid(A[i]);
+
+        if (result == -1) {
+            break;
+        }
+
+        if (result == 1) {
+            filter_ids.push_back(A[i]);
+        }
+    }
+
+    if (filter_ids.empty()) {
+        return 0;
+    }
+
+    results = new uint32_t[filter_ids.size()];
+    std::copy(filter_ids.begin(), filter_ids.end(), results);
+
+    return filter_ids.size();
+}

test/filter_test.cpp

@@ -377,4 +377,43 @@ TEST_F(FilterTest, FilterTreeIterator) {
     ASSERT_FALSE(iter_move_assignment_test.valid());
 
     delete filter_tree_root;
+    filter_tree_root = nullptr;
+    filter_op = filter::parse_filter_query("tags: gold", coll->get_schema(), store, doc_id_prefix,
+                                                filter_tree_root);
+    ASSERT_TRUE(filter_op.ok());
+
+    auto iter_to_array_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+    ASSERT_TRUE(iter_to_array_test.init_status().ok());
+
+    uint32_t* filter_ids = nullptr;
+    uint32_t filter_ids_length;
+
+    filter_ids_length = iter_to_array_test.to_filter_id_array(filter_ids);
+    ASSERT_EQ(3, filter_ids_length);
+
+    expected = {0, 2, 4};
+    for (uint32_t i = 0; i < filter_ids_length; i++) {
+        ASSERT_EQ(expected[i], filter_ids[i]);
+    }
+    ASSERT_FALSE(iter_to_array_test.valid());
+
+    delete filter_ids;
+
+    auto iter_and_scalar_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+    ASSERT_TRUE(iter_and_scalar_test.init_status().ok());
+
+    uint32_t a_ids[6] = {0, 1, 3, 4, 5, 6};
+    uint32_t* and_result = nullptr;
+    uint32_t and_result_length;
+    and_result_length = iter_and_scalar_test.and_scalar(a_ids, 6, and_result);
+    ASSERT_EQ(2, and_result_length);
+
+    expected = {0, 4};
+    for (uint32_t i = 0; i < and_result_length; i++) {
+        ASSERT_EQ(expected[i], and_result[i]);
+    }
+    ASSERT_FALSE(iter_and_test.valid());
+
+    delete and_result;
+    delete filter_tree_root;
 }