67 shortest path bounded

.gitignore

@@ -6,3 +6,4 @@ duckdb_unittest_tempdir/
 testext
 test/python/__pycache__/
 .Rhistory
+.vscode

duckpgq/src/duckpgq/functions/scalar/iterativelength.cpp

@@ -8,26 +8,36 @@
 namespace duckdb {
 
 static bool IterativeLength(int64_t v_size, int64_t *v, vector<int64_t> &e,
+                            vector<vector<unordered_set<int64_t>>> &parents_v,
                             vector<std::bitset<LANE_LIMIT>> &seen,
                             vector<std::bitset<LANE_LIMIT>> &visit,
                             vector<std::bitset<LANE_LIMIT>> &next) {
   bool change = false;
   for (auto i = 0; i < v_size; i++) {
     next[i] = 0;
   }
-  for (auto i = 0; i < v_size; i++) {
-    if (visit[i].any()) {
-      for (auto offset = v[i]; offset < v[i + 1]; offset++) {
-        auto n = e[offset];
-        next[n] = next[n] | visit[i];
+
+  for (auto lane = 0; lane < LANE_LIMIT; lane++) {
+    for (auto i = 0; i < v_size; i++) {
+      if (visit[i][lane]) {
+        for (auto offset = v[i]; offset < v[i + 1]; offset++) {
+          auto n = e[offset];
+          if (seen[n][lane] == false || parents_v[i][lane].find(n) == parents_v[i][lane].end()) {
+            parents_v[n][lane] = parents_v[i][lane];
+            parents_v[n][lane].insert(i);
+            next[n][lane] = true;
+          }
+        }
       }
     }
   }
+
   for (auto i = 0; i < v_size; i++) {
-    next[i] = next[i] & ~seen[i];
+    // next[i] = next[i] & ~seen[i];
     seen[i] = seen[i] | next[i];
     change |= next[i].any();
   }
+
   return change;
 }
 
@@ -74,6 +84,16 @@ static void IterativeLengthFunction(DataChunk &args, ExpressionState &state,
   auto src_data = (int64_t *)vdata_src.data;
   auto dst_data = (int64_t *)vdata_dst.data;
 
+  // get lowerbound and upperbound
+  auto &lower_bound = args.data[4];
+  auto &upper_bound = args.data[5];
+  UnifiedVectorFormat vdata_lower_bound;
+  UnifiedVectorFormat vdata_upper_bound;
+  lower_bound.ToUnifiedFormat(args.size(), vdata_lower_bound);
+  upper_bound.ToUnifiedFormat(args.size(), vdata_upper_bound);
+  auto lower_bound_data = (int64_t *)vdata_lower_bound.data;
+  auto upper_bound_data = (int64_t *)vdata_upper_bound.data;
+
   ValidityMask &result_validity = FlatVector::Validity(result);
 
   // create result vector
@@ -84,6 +104,7 @@ static void IterativeLengthFunction(DataChunk &args, ExpressionState &state,
   vector<std::bitset<LANE_LIMIT>> seen(v_size);
   vector<std::bitset<LANE_LIMIT>> visit1(v_size);
   vector<std::bitset<LANE_LIMIT>> visit2(v_size);
+  vector<vector<unordered_set<int64_t>>> parents_v(v_size, std::vector<unordered_set<int64_t>>(LANE_LIMIT));
 
   // maps lane to search number
   short lane_to_num[LANE_LIMIT];
@@ -110,11 +131,13 @@ static void IterativeLengthFunction(DataChunk &args, ExpressionState &state,
         int64_t dst_pos = vdata_dst.sel->get_index(search_num);
         if (!vdata_src.validity.RowIsValid(src_pos)) {
           result_validity.SetInvalid(search_num);
-          result_data[search_num] = (uint64_t)-1; /* no path */
+          result_data[search_num] = (int64_t)-1; /* no path */
         } else if (src_data[src_pos] == dst_data[dst_pos]) {
           result_data[search_num] =
-              (uint64_t)0; // path of length 0 does not require a search
+              (int64_t)0; // path of length 0 does not require a search
         } else {
+          result_data[search_num] = (int64_t)-1; /* initialize to no path */
+          seen[src_data[src_pos]][lane] = true;
           visit1[src_data[src_pos]][lane] = true;
           lane_to_num[lane] = search_num; // active lane
           active++;
@@ -125,23 +148,45 @@ static void IterativeLengthFunction(DataChunk &args, ExpressionState &state,
 
     // make passes while a lane is still active
     for (int64_t iter = 1; active; iter++) {
-      if (!IterativeLength(v_size, v, e, seen, (iter & 1) ? visit1 : visit2,
-                           (iter & 1) ? visit2 : visit1)) {
-        break;
-      }
+      // if (!IterativeLength(v_size, v, e, seen, (iter & 1) ? visit1 : visit2,
+      //                      (iter & 1) ? visit2 : visit1)) {
+      //   break;
+      // }
+      bool stop = !IterativeLength(v_size, v, e, parents_v, seen, (iter & 1) ? visit1 : visit2,
+                                   (iter & 1) ? visit2 : visit1);
       // detect lanes that finished
       for (int64_t lane = 0; lane < LANE_LIMIT; lane++) {
         int64_t search_num = lane_to_num[lane];
         if (search_num >= 0) { // active lane
           int64_t dst_pos = vdata_dst.sel->get_index(search_num);
-          if (seen[dst_data[dst_pos]][lane]) {
-            result_data[search_num] =
-                iter;               /* found at iter => iter = path length */
+          if (seen[dst_data[dst_pos]][lane]){
+
+            // check if the path length is within bounds
+            // bound vector is either a constant or a flat vector
+            if (lower_bound.GetVectorType() == VectorType::CONSTANT_VECTOR ? 
+                iter < lower_bound_data[0] : iter < lower_bound_data[dst_pos]) {
+              // when reach the destination too early, treat destination as null
+              // looks like the graph does not have that vertex
+              seen[dst_data[dst_pos]][lane] = false;
+              (iter & 1) ? visit2[dst_data[dst_pos]][lane] = false
+                         : visit1[dst_data[dst_pos]][lane] = false;
+              continue;
+            } else if (upper_bound.GetVectorType() == VectorType::CONSTANT_VECTOR ? 
+                iter > upper_bound_data[0] : iter > upper_bound_data[dst_pos]) {
+              result_validity.SetInvalid(search_num);
+              result_data[search_num] = (int64_t)-1; /* no path */
+            } else {
+              result_data[search_num] =
+                  iter;               /* found at iter => iter = path length */
+            }
             lane_to_num[lane] = -1; // mark inactive
             active--;
           }
         }
       }
+      if (stop) {
+        break;
+      }
     }
 
     // no changes anymore: any still active searches have no path
@@ -160,6 +205,7 @@ static void IterativeLengthFunction(DataChunk &args, ExpressionState &state,
 CreateScalarFunctionInfo DuckPGQFunctions::GetIterativeLengthFunction() {
   auto fun = ScalarFunction("iterativelength",
                             {LogicalType::INTEGER, LogicalType::BIGINT,
+                             LogicalType::BIGINT, LogicalType::BIGINT,
                              LogicalType::BIGINT, LogicalType::BIGINT},
                             LogicalType::BIGINT, IterativeLengthFunction,
                             IterativeLengthFunctionData::IterativeLengthBind);