This SPARQL query efficiently identifies nodes within a knowledge graph that possess a specific property whose value conforms to a given regular expression pattern. It's particularly useful for searching and filtering en...

The query selects distinct nodes (`?node`) that have a property `ex:hasName` whose value (`?name`) matches a regular expression. The `FILTER regex(?name, "^[Pp]ro-", "i")` clause is the core of the pattern matching. It checks if the string bound to `?name` starts with 'Pro-' or 'pro-' (case-insensitive due to the 'i' flag). The time complexity is generally linear with respect to the number of triples involving the `ex:hasName` property, as the engine needs to iterate through these and apply the regex. Space complexity is minimal, mainly for storing the matched nodes. The correctness is guaranteed by the precise semantics of SPARQL's `FILTER` and `regex` functions, which perform standard regular expression matching.

SELECT all distinct nodes. FOR EACH node: IF the node has a property 'hasName' AND its value matches the pattern 'starts with "Pro-" (case-insensitive): ADD the node to the result set. RETURN the result set.

This SPARQL query efficiently retrieves all direct and indirect ancestors of a specified node in a hierarchical graph structure. It utilizes SPARQL 1.1's powerful property path syntax, specifically inverse property paths...

The query finds all ancestors of `?targetNode` by using the inverse property path `^ex:parent` combined with the Kleene star quantifier `*`. The pattern `?ancestor (^ex:parent)* ?targetNode` means that `?targetNode` is reachable from `?ancestor` by traversing zero or more `ex:parent` relationships in reverse. The `SELECT DISTINCT` clause ensures that each unique ancestor is listed only once, even if multiple paths exist. The `FILTER (?ancestor != ?targetNode)` clause is crucial to exclude the target node itself from the results, as the `*` quantifier includes the zero-step case. The query terminates even in the presence of cycles because the set of nodes and relationships is finite, and the property path mechanism explores all reachable reverse paths. Time complexity is dependent on the graph structure and SPARQL engine optimization, potentially exploring many paths, but is bounded. Space complexity is minimal, primarily for storing results and intermediate traversal states.

Define TARGET_NODE. Find all nodes, ?ancestor, such that TARGET_NODE is reachable from ?ancestor by traversing zero or more 'parent' relationships in reverse. Exclude TARGET_NODE itself from the results. Return distinct...

This SPARQL query efficiently finds all nodes that are reachable from a specified starting node within a maximum number of hops (N). It utilizes SPARQL 1.1's property path syntax with a variable quantifier to control the...

The query selects distinct nodes (`?reachableNode`) that are reachable from `?startNode` by traversing zero or more (`*`) edges of type `ex:connects`, up to a maximum of `?maxHops` steps. The property path `ex:connects*?maxHops` is the core mechanism for limiting the graph traversal. When `?maxHops` is 0, the pattern correctly matches only `?startNode`. For `?maxHops > 0`, it explores all paths up to that length. The `DISTINCT` keyword ensures each node is listed only once. Time complexity is dependent on the graph's structure and the SPARQL engine's optimization, but the `*?maxHops` quantifier prevents infinite loops in cyclic graphs. Space complexity is minimal, storing the results.

Define START_NODE and maximum hops N. Find all nodes REACHABLE_NODE such that REACHABLE_NODE is connected to START_NODE by traversing zero or more 'connects' edges, up to a maximum of N steps. Return distinct REACHABLE_N...

This SPARQL query is designed to precisely count the number of distinct paths of a specific length, K, between two given nodes in a graph. It leverages SPARQL 1.1's property path syntax with a variable quantifier `{K}` t...

The query counts distinct paths of exactly length K between `?startNode` and `?endNode`. It uses `BIND` to set the start node, end node, and path length `?k`. A `UNION` clause handles two cases: for K=0, it checks if `?startNode` equals `?endNode`; for K>0, it uses the property path `?startNode ex:next{?k} ?endNode`. Each successful match of the property path represents a distinct path of length K. The `COUNT(*)` aggregate function then counts all such matches. The `{?k}` quantifier ensures exact length and prevents infinite loops in cyclic graphs. Time complexity is highly dependent on the graph's structure and the SPARQL engine's optimization for property paths, potentially exploring many paths. Space complexity is minimal, mainly for storing results. Correctness is ensured by the precise definition of property path quantifiers and the aggregation function.

Define START_NODE, END_NODE, and path length K. Initialize path count to 0. If K is 0: If START_NODE is equal to END_NODE: Increment path count by 1. Else (K > 0): Find all sequences of nodes forming a path of exactly K...

This SPARQL query is designed to find all distinct pairs of nodes in a graph that are connected by a path of exactly a specified length, K. It leverages SPARQL's property path capabilities, specifically the quantifier `{...

The query uses SPARQL 1.1's property path syntax, specifically the quantifier `{K}`, to find paths of exactly K steps. The `SELECT DISTINCT` clause ensures that each unique pair of start and end nodes is returned only once. A `UNION` block is employed to correctly handle the edge case where K=0, requiring the start and end nodes to be identical. For K > 0, the `ex:next{?k}` pattern traverses exactly ?k edges of type `ex:next`. The time complexity is highly dependent on the SPARQL engine's optimization and the graph's structure; in the worst case, it can be exponential if not optimized, but efficient engines can prune the search space significantly. Space complexity is generally low, primarily for storing the results and intermediate path states. The correctness relies on the precise definition of property paths and quantifiers in SPARQL 1.1, ensuring that exactly K steps are taken. Edge cases like K=0 and disconnected components are handled by the query structure.

Define K as the target path length. Define START_NODE and END_NODE (optional, for filtering). If K is 0: Find all pairs where START_NODE equals END_NODE. Else (K > 0): Find all pairs (START_NODE, END_NODE) such that ther...

This SPARQL query performs a basic but essential graph pattern matching operation to retrieve all triples that have a predefined predicate URI and a specific literal value for the object. It's a foundational query for ex...

The query selects all triples `(?subject, ?predicate, ?object)` where `?predicate` is bound to a specific URI (e.g., `ex:hasLabel`) and `?object` is bound to a specific literal value (e.g., 'Example Resource' as an `xsd:string`). The `BIND` statements are used here for demonstration; in a typical application, these values would be directly in the query or passed as parameters. The core is the triple pattern `?subject ?predicate ?object`, which acts as a filter on the graph's triples. The `SELECT` clause then returns the subject of each matching triple, along with the bound predicate and object. This query is highly efficient, often leveraging indexes for direct triple lookup. Its time complexity is typically constant or logarithmic with respect to the number of triples, depending on the index structure. Space complexity is minimal, storing only the results.

Define the target PREDICATE_URI. Define the target OBJECT_LITERAL. Find all triples (SUBJECT, PREDICATE_URI, OBJECT_LITERAL). Return the SUBJECT of each found triple, along with the PREDICATE_URI and OBJECT_LITERAL.