gqlite 1.8.1 → 1.8.2

data/ext/gqlitedb/src/tests/templates/ast.rs

@@ -27,6 +27,8 @@ pub(crate) fn simple_create_node() -> Statements
         variable: None,
         labels: LabelExpression::None,
         properties: None,
+
+        predicate: None,
       })],
     }
     .into(),
@@ -54,6 +56,8 @@ pub(crate) fn create_named_node() -> Statements
           }
           .into(),
         ),
+
+        predicate: None,
       })],
     }
     .into(),
@@ -106,6 +110,8 @@ pub(crate) fn create_named_node_double_return() -> Statements
           }
           .into(),
         ),
+
+        predicate: None,
       })],
     }
     .into(),
@@ -233,16 +239,19 @@ pub(crate) fn match_loop() -> Statements
           variable: Some(var_ids.create_variable_from_name("n")),
           labels: LabelExpression::None,
           properties: None,
+          predicate: None,
         },
         destination: NodePattern {
           variable: Some(var_ids.create_variable_from_name("n")),
           labels: LabelExpression::None,
           properties: None,
+          predicate: None,
         },
         labels: LabelExpression::None,
         properties: None,
         directivity: graphcore::EdgeDirectivity::Directed,
-        recursive_range: None,
+
+        predicate: None,
       })],
       where_expression: None,
       optional: false,
@@ -263,6 +272,8 @@ pub(crate) fn optional_match() -> Statements
         variable: Some(var_ids.create_variable_from_name("a")),
         labels: LabelExpression::None,
         properties: None,
+
+        predicate: None,
       })],
       where_expression: None,
       optional: true,
@@ -283,6 +294,8 @@ pub(crate) fn match_count() -> Statements
         variable: Some(var_ids.create_variable_from_name("a")),
         labels: LabelExpression::None,
         properties: None,
+
+        predicate: None,
       })],
       where_expression: None,
       optional: false,
@@ -322,6 +335,8 @@ pub(crate) fn aggregation() -> Statements
         variable: Some(var_ids.create_variable_from_name("n")),
         labels: LabelExpression::None,
         properties: None,
+
+        predicate: None,
       })],
       where_expression: None,
       optional: false,
@@ -400,6 +415,8 @@ pub(crate) fn match_with_vector_search(index_name: &str) -> Statements
         variable: Some(n.clone()),
         labels: LabelExpression::String("Doc".to_string()),
         properties: None,
+
+        predicate: None,
       })],
       where_expression: None,
       optional: false,
@@ -440,3 +457,269 @@ pub(crate) fn match_with_vector_search(index_name: &str) -> Statements
     .into(),
   ]
 }
+
+/// AST for `MATCH (a) ((n)-[:R]->(m)){1,3} (b) RETURN a, b`
+/// AST for `MATCH (a) ((n)-[:R]->(m)){1,3} (b) RETURN a, b`
+pub(crate) fn group_single_edge_range() -> Statements
+{
+  let var_ids = VariableIdentifiers::default();
+  let a = var_ids.create_variable_from_name("a");
+  let n = var_ids.create_variable_from_name("n");
+  let m = var_ids.create_variable_from_name("m");
+  let b = var_ids.create_variable_from_name("b");
+  let edge_anon = var_ids.create_variable_from_name("anonymous_4");
+  vec![
+    Match {
+      patterns: vec![Pattern::QuantifiedPath(QuantifiedPathPattern {
+        variable: None,
+        source: NodePattern {
+          variable: Some(a.clone()),
+          labels: LabelExpression::None,
+          properties: None,
+          predicate: None,
+        },
+        group: vec![Pattern::Edge(EdgePattern {
+          variable: Some(edge_anon),
+          source: NodePattern {
+            variable: Some(n),
+            labels: LabelExpression::None,
+            properties: None,
+            predicate: None,
+          },
+          destination: NodePattern {
+            variable: Some(m),
+            labels: LabelExpression::None,
+            properties: None,
+            predicate: None,
+          },
+          directivity: graphcore::EdgeDirectivity::Directed,
+          labels: LabelExpression::String("R".to_string()),
+          properties: None,
+          predicate: None,
+        })],
+        group_where: None,
+        path_where: None,
+        quantifier: Some(1..3),
+        destination: NodePattern {
+          variable: Some(b.clone()),
+          labels: LabelExpression::None,
+          properties: None,
+          predicate: None,
+        },
+        selector: PathSelector::All,
+      })],
+      where_expression: None,
+      optional: false,
+      search: None,
+    }
+    .into(),
+    Return {
+      all: false,
+      expressions: vec![
+        NamedExpression {
+          identifier: a.clone(),
+          expression: Variable { identifier: a }.into(),
+        },
+        NamedExpression {
+          identifier: b.clone(),
+          expression: Variable { identifier: b }.into(),
+        },
+      ],
+      modifiers: Modifiers {
+        distinct: false,
+        skip: None,
+        limit: None,
+        order_by: None,
+      },
+      where_expression: None,
+    }
+    .into(),
+  ]
+}
+
+/// AST for `MATCH (a) ((n)-[:R1]->(x)-[:R2]->(m)){1,3} (b) RETURN a, b`
+pub(crate) fn group_two_edges_range() -> Statements
+{
+  let var_ids = VariableIdentifiers::default();
+  let a = var_ids.create_variable_from_name("a");
+  let n = var_ids.create_variable_from_name("n");
+  let x = var_ids.create_variable_from_name("x");
+  let m = var_ids.create_variable_from_name("m");
+  let b = var_ids.create_variable_from_name("b");
+  let edge1_anon = var_ids.create_variable_from_name("anonymous_5");
+  let edge2_anon = var_ids.create_variable_from_name("anonymous_6");
+  vec![
+    Match {
+      patterns: vec![Pattern::QuantifiedPath(QuantifiedPathPattern {
+        variable: None,
+        source: NodePattern {
+          variable: Some(a.clone()),
+          labels: LabelExpression::None,
+          properties: None,
+          predicate: None,
+        },
+        group: vec![
+          Pattern::Edge(EdgePattern {
+            variable: Some(edge1_anon),
+            source: NodePattern {
+              variable: Some(n),
+              labels: LabelExpression::None,
+              properties: None,
+              predicate: None,
+            },
+            destination: NodePattern {
+              variable: Some(x.clone()),
+              labels: LabelExpression::None,
+              properties: None,
+              predicate: None,
+            },
+            directivity: graphcore::EdgeDirectivity::Directed,
+            labels: LabelExpression::String("R1".to_string()),
+            properties: None,
+            predicate: None,
+          }),
+          Pattern::Edge(EdgePattern {
+            variable: Some(edge2_anon),
+            source: NodePattern {
+              variable: Some(x),
+              labels: LabelExpression::None,
+              properties: None,
+              predicate: None,
+            },
+            destination: NodePattern {
+              variable: Some(m),
+              labels: LabelExpression::None,
+              properties: None,
+              predicate: None,
+            },
+            directivity: graphcore::EdgeDirectivity::Directed,
+            labels: LabelExpression::String("R2".to_string()),
+            properties: None,
+            predicate: None,
+          }),
+        ],
+        group_where: None,
+        path_where: None,
+        quantifier: Some(1..3),
+        destination: NodePattern {
+          variable: Some(b.clone()),
+          labels: LabelExpression::None,
+          properties: None,
+          predicate: None,
+        },
+        selector: PathSelector::All,
+      })],
+      where_expression: None,
+      optional: false,
+      search: None,
+    }
+    .into(),
+    Return {
+      all: false,
+      expressions: vec![
+        NamedExpression {
+          identifier: a.clone(),
+          expression: Variable { identifier: a }.into(),
+        },
+        NamedExpression {
+          identifier: b.clone(),
+          expression: Variable { identifier: b }.into(),
+        },
+      ],
+      modifiers: Modifiers {
+        distinct: false,
+        skip: None,
+        limit: None,
+        order_by: None,
+      },
+      where_expression: None,
+    }
+    .into(),
+  ]
+}
+
+/// AST for `MATCH p = SHORTEST 1 (a)-[:R]-+(b) RETURN a, b, length(p)`
+pub(crate) fn shortest_single_edge_full_return() -> Statements
+{
+  let var_ids = VariableIdentifiers::default();
+  let a = var_ids.create_variable_from_name("a");
+  let b = var_ids.create_variable_from_name("b");
+  let edge_anon = var_ids.create_variable_from_name("anonymous_2");
+  let p = var_ids.create_variable_from_name("p");
+  vec![
+    Match {
+      patterns: vec![Pattern::QuantifiedPath(QuantifiedPathPattern {
+        variable: Some(p.clone()),
+        source: NodePattern {
+          variable: Some(a.clone()),
+          labels: LabelExpression::None,
+          properties: None,
+          predicate: None,
+        },
+        group: vec![Pattern::Edge(EdgePattern {
+          variable: Some(edge_anon),
+          source: NodePattern {
+            variable: Some(a.clone()),
+            labels: LabelExpression::None,
+            properties: None,
+            predicate: None,
+          },
+          destination: NodePattern {
+            variable: Some(b.clone()),
+            labels: LabelExpression::None,
+            properties: None,
+            predicate: None,
+          },
+          directivity: graphcore::EdgeDirectivity::Undirected,
+          labels: LabelExpression::String("R".to_string()),
+          properties: None,
+          predicate: None,
+        })],
+        group_where: None,
+        path_where: None,
+        quantifier: Some(1..usize::MAX),
+        destination: NodePattern {
+          variable: Some(b.clone()),
+          labels: LabelExpression::None,
+          properties: None,
+          predicate: None,
+        },
+        selector: PathSelector::Shortest(Value { value: 1.into() }.into()),
+      })],
+      where_expression: None,
+      optional: false,
+      search: None,
+    }
+    .into(),
+    Return {
+      all: false,
+      expressions: vec![
+        NamedExpression {
+          identifier: a.clone(),
+          expression: Variable { identifier: a }.into(),
+        },
+        NamedExpression {
+          identifier: b.clone(),
+          expression: Variable { identifier: b }.into(),
+        },
+        NamedExpression {
+          identifier: var_ids.create_variable_from_name("length(p)"),
+          expression: FunctionCall {
+            name: "length".into(),
+            arguments: vec![Variable { identifier: p }.into()],
+            distinct: false,
+          }
+          .into(),
+        },
+      ],
+      modifiers: Modifiers {
+        distinct: false,
+        skip: None,
+        limit: None,
+        order_by: None,
+      },
+      where_expression: None,
+    }
+    .into(),
+  ]
+}

data/ext/gqlitedb/src/tests/templates/programs.rs

@@ -472,3 +472,309 @@ pub(crate) fn aggregation(function_manager: &functions::Manager) -> Program
     },
   ]
 }
+
+/// Program for `MATCH (a) ((n)-[:R]->(m)){1,3} (b) RETURN a, b`.
+/// Uses MatchQuantifiedPath since the group's inner nodes (n, m) differ
+/// from the outer anchors (a, b) - this is an explicit group pattern.
+pub(crate) fn group_single_edge_range() -> Program
+{
+  vec![
+    Block::Match {
+      blocks: vec![BlockMatch::MatchQuantifiedPath {
+        source_instructions: vec![
+          Instruction::Push {
+            value: ValueMap::default().into(),
+          },
+          Instruction::CreateNodeQuery { labels: vec![] },
+        ],
+        source_variable: Some(0),
+        source_filter: vec![],
+        destination_variable: Some(1),
+        destination_filter: vec![],
+        path_variable: None,
+        quantifier: 1..3,
+        group_instructions: vec![BlockMatch::MatchEdge {
+          instructions: vec![
+            Instruction::GetVariable { col_id: 2 },
+            Instruction::CreateNodeQuery { labels: vec![] },
+            Instruction::Push {
+              value: ValueMap::default().into(),
+            },
+            Instruction::CreateNodeQuery { labels: vec![] },
+            Instruction::Push {
+              value: ValueMap::default().into(),
+            },
+            Instruction::CreateEdgeQuery {
+              labels: vec!["R".into()],
+            },
+          ],
+          left_variable: None,
+          edge_variable: Some(4),
+          right_variable: Some(3),
+          path_variable: None,
+          filter: vec![],
+          directivity: EdgeDirectivity::Directed,
+          recursive_range: None,
+        }],
+        group_variables: vec![2, 4, 3],
+        group_terminal_variable: 3,
+        group_entry_variable: 2,
+        group_where_filter: None,
+        path_filter: None,
+        strategy: PathStrategy::Dfs,
+      }],
+      filter: vec![],
+      optional: false,
+      variables_size: create_variable_size(5, 0),
+    },
+    Block::Return {
+      variables: vec![
+        (
+          "a".into(),
+          RWExpression {
+            col_id: 0,
+            instructions: vec![Instruction::GetVariable { col_id: 0 }],
+            aggregations: Default::default(),
+          },
+        ),
+        (
+          "b".into(),
+          RWExpression {
+            col_id: 1,
+            instructions: vec![Instruction::GetVariable { col_id: 1 }],
+            aggregations: Default::default(),
+          },
+        ),
+      ],
+      filter: vec![],
+      modifiers: Modifiers {
+        limit: None,
+        skip: None,
+        order_by: vec![],
+        distinct: false,
+      },
+      variables_sizes: create_variable_size(5, 0),
+    },
+  ]
+}
+
+/// Program for `MATCH (a) ((n)-[:R1]->(x)-[:R2]->(m)){1,3} (b) RETURN a, b`.
+/// Two-edge group: compiler allocates edge columns (5, 6) for deduplication,
+/// and adds filter logic to second edge to prevent revisiting the same edge.
+pub(crate) fn group_two_edges_range() -> Program
+{
+  vec![
+    Block::Match {
+      blocks: vec![BlockMatch::MatchQuantifiedPath {
+        source_instructions: vec![
+          Instruction::Push {
+            value: ValueMap::default().into(),
+          },
+          Instruction::CreateNodeQuery { labels: vec![] },
+        ],
+        source_variable: Some(0),
+        source_filter: vec![],
+        destination_variable: Some(1),
+        destination_filter: vec![],
+        path_variable: None,
+        quantifier: 1..3,
+        group_instructions: vec![
+          BlockMatch::MatchEdge {
+            instructions: vec![
+              Instruction::GetVariable { col_id: 2 },
+              Instruction::CreateNodeQuery { labels: vec![] },
+              Instruction::Push {
+                value: ValueMap::default().into(),
+              },
+              Instruction::CreateNodeQuery { labels: vec![] },
+              Instruction::Push {
+                value: ValueMap::default().into(),
+              },
+              Instruction::CreateEdgeQuery {
+                labels: vec!["R1".into()],
+              },
+            ],
+            left_variable: None,
+            edge_variable: Some(4),
+            right_variable: Some(3),
+            path_variable: None,
+            filter: vec![],
+            directivity: EdgeDirectivity::Directed,
+            recursive_range: None,
+          },
+          BlockMatch::MatchEdge {
+            instructions: vec![
+              Instruction::GetVariable { col_id: 3 },
+              Instruction::CreateNodeQuery { labels: vec![] },
+              Instruction::Push {
+                value: ValueMap::default().into(),
+              },
+              Instruction::CreateNodeQuery { labels: vec![] },
+              Instruction::Push {
+                value: ValueMap::default().into(),
+              },
+              Instruction::CreateEdgeQuery {
+                labels: vec!["R2".into()],
+              },
+            ],
+            left_variable: None,
+            edge_variable: Some(6),
+            right_variable: Some(5),
+            path_variable: None,
+            filter: vec![
+              Instruction::Duplicate,
+              Instruction::GetVariable { col_id: 4 },
+              Instruction::NotEqualBinaryOperator,
+              Instruction::InverseRot3,
+              Instruction::AndBinaryOperator,
+              Instruction::Swap,
+            ],
+            directivity: EdgeDirectivity::Directed,
+            recursive_range: None,
+          },
+        ],
+        group_variables: vec![2, 4, 3, 3, 6, 5],
+        group_terminal_variable: 5,
+        group_entry_variable: 2,
+        group_where_filter: None,
+        path_filter: None,
+        strategy: PathStrategy::Dfs,
+      }],
+      filter: vec![],
+      optional: false,
+      variables_size: create_variable_size(7, 0),
+    },
+    Block::Return {
+      variables: vec![
+        (
+          "a".into(),
+          RWExpression {
+            col_id: 0,
+            instructions: vec![Instruction::GetVariable { col_id: 0 }],
+            aggregations: Default::default(),
+          },
+        ),
+        (
+          "b".into(),
+          RWExpression {
+            col_id: 1,
+            instructions: vec![Instruction::GetVariable { col_id: 1 }],
+            aggregations: Default::default(),
+          },
+        ),
+      ],
+      filter: vec![],
+      modifiers: Modifiers {
+        limit: None,
+        skip: None,
+        order_by: vec![],
+        distinct: false,
+      },
+      variables_sizes: create_variable_size(7, 0),
+    },
+  ]
+}
+
+/// Program for `MATCH p = SHORTEST 1 (a)-[:R]-+(b) RETURN a, b, length(p)`
+/// Shortest path uses BFS with stop condition. **KEY FINDING**: group_variables
+/// DOES include source/destination columns [1, 2] - this was the open question
+/// in WI721.
+pub(crate) fn shortest_single_edge_full_return(function_manager: &functions::Manager) -> Program
+{
+  vec![
+    Block::Match {
+      blocks: vec![BlockMatch::MatchQuantifiedPath {
+        source_instructions: vec![
+          Instruction::Push {
+            value: ValueMap::default().into(),
+          },
+          Instruction::CreateNodeQuery { labels: vec![] },
+        ],
+        source_variable: Some(1),
+        source_filter: vec![],
+        destination_variable: Some(2),
+        destination_filter: vec![],
+        path_variable: Some(0),
+        quantifier: 1..usize::MAX,
+        group_instructions: vec![BlockMatch::MatchEdge {
+          instructions: vec![
+            Instruction::GetVariable { col_id: 1 },
+            Instruction::CreateNodeQuery { labels: vec![] },
+            Instruction::Push {
+              value: ValueMap::default().into(),
+            },
+            Instruction::CreateNodeQuery { labels: vec![] },
+            Instruction::Push {
+              value: ValueMap::default().into(),
+            },
+            Instruction::CreateEdgeQuery {
+              labels: vec!["R".into()],
+            },
+          ],
+          left_variable: None,
+          edge_variable: Some(3),
+          right_variable: Some(2),
+          path_variable: None,
+          filter: vec![],
+          directivity: EdgeDirectivity::Undirected,
+          recursive_range: None,
+        }],
+        group_variables: vec![1, 3, 2],
+        group_terminal_variable: 2,
+        group_entry_variable: 1,
+        group_where_filter: None,
+        path_filter: None,
+        strategy: PathStrategy::Bfs {
+          stop_condition: StopCondition::Shortest(vec![Instruction::Push { value: 1.into() }]),
+        },
+      }],
+      filter: vec![],
+      optional: false,
+      variables_size: create_variable_size(4, 0),
+    },
+    Block::Return {
+      variables: vec![
+        (
+          "a".into(),
+          RWExpression {
+            col_id: 1,
+            instructions: vec![Instruction::GetVariable { col_id: 1 }],
+            aggregations: Default::default(),
+          },
+        ),
+        (
+          "b".into(),
+          RWExpression {
+            col_id: 2,
+            instructions: vec![Instruction::GetVariable { col_id: 2 }],
+            aggregations: Default::default(),
+          },
+        ),
+        (
+          "length(p)".into(),
+          RWExpression {
+            col_id: 4,
+            instructions: vec![
+              Instruction::GetVariable { col_id: 0 },
+              Instruction::FunctionCall {
+                function: function_manager
+                  .get_function::<error::CompileTimeError>("length")
+                  .unwrap(),
+                arguments_count: 1,
+              },
+            ],
+            aggregations: Default::default(),
+          },
+        ),
+      ],
+      filter: vec![],
+      modifiers: Modifiers {
+        limit: None,
+        skip: None,
+        order_by: vec![],
+        distinct: false,
+      },
+      variables_sizes: create_variable_size(5, 0),
+    },
+  ]
+}

data/ext/gqliterb/Cargo.toml

@@ -11,7 +11,6 @@ repository.workspace = true
 crate-type = ["cdylib"]
 
 [features]
-_cmake = []
 
 [dependencies]
 gqlitedb = { workspace = true, features = ["postgres", "redb", "sqlite"] }