defmodule RedisGraph.QueryResult do
@moduledoc """
A QueryResult is responsible for processing the data that was returned by RedisGraph.
https://redis.io/docs/stack/graph/design/result_structure/
The resulting struct contains the result set header and records,
statistics about the query executed, and referential lists of entity
identifiers, specifically labels, property keys, and relationship types.
The labels refer to the `labels` attribute in Node entities
in the graph, The property keys are the keys found in any Node or Relationship
property maps. The relationship types are the `type` attributes of
Relationship entities in the graph.
## Example
```elixir
alias RedisGraph.Graph
# Create a connection using Redix
{:ok, conn} = Redix.start_link("redis://localhost:6379")
# Create a graph
graph = Graph.new(%{name: "imdb"})
# Create queries and send them to RedisGraph
create_query = "CREATE (a:actor {name: 'Hugh Jackman'})-[:act]->(m:movie {title:'Wolverine'}) RETURN a"
{:ok, _query_result} = RedisGraph.query(conn, graph.name, create_query)
match_query = "MATCH (a:actor {name: 'Hugh Jackman'})-[:act]->(m:movie {title:'Wolverine'}) RETURN a"
{:ok, query_result} = RedisGraph.query(conn, graph.name, match_query)
# Show the resulting statistics
IO.inspect(query_result.statistics)
# Query result statistics
%{
"Labels added" => nil,
"Nodes created" => nil,
"Nodes deleted" => nil,
"Properties set" => nil,
"Query internal execution time" => "0.228669",
"Relationships created" => nil,
"Relationships deleted" => nil
}
```
"""
alias RedisGraph.Relationship
alias RedisGraph.Node
@labels_added "Labels added"
@labels_removed "Labels removed"
@nodes_created "Nodes created"
@nodes_deleted "Nodes deleted"
@properties_set "Properties set"
@properties_removed "Properties removed"
@relationships_created "Relationships created"
@relationships_deleted "Relationships deleted"
@indices_created "Indices created"
@indices_deleted "Indices deleted"
@query_internal_execution_time "Query internal execution time"
@graph_removed_internal_execution_time "Graph removed, internal execution time"
@value_type %{
VALUE_UNKNOWN: 0,
VALUE_NULL: 1,
VALUE_STRING: 2,
VALUE_INTEGER: 3,
VALUE_BOOLEAN: 4,
VALUE_DOUBLE: 5,
VALUE_ARRAY: 6,
VALUE_EDGE: 7,
VALUE_NODE: 8,
VALUE_PATH: 9,
VALUE_MAP: 10,
VALUE_POINT: 11
}
@type t() :: %__MODULE__{
conn: pid(),
graph_name: String.t(),
raw_result_set: list(any()) | String.t(),
header: list(atom()),
result_set: list(list(any())),
statistics: %{String.t() => String.t()},
labels: %{number() => String.t()},
property_keys: %{number() => String.t()},
relationship_types: %{number() => String.t()}
}
@enforce_keys [:conn, :graph_name, :raw_result_set]
defstruct [
:conn,
:graph_name,
:raw_result_set,
:header,
:result_set,
:statistics,
:labels,
:property_keys,
:relationship_types
]
@doc """
Create a new QueryResult from a map.
Pass a map with a connection, graph name, and raw RedisGraph result/response.
The raw result is the output of the function `Redix.command/2`.
This function is invoked by the `RedisGraph.command/2` function.
The functions `RedisGraph.query/3`, `RedisGraph.delete/2` and `RedisGraph.call_procedure/5`
will also return a new `RedisGraph.QueryResult`.
"""
@spec new(map()) :: t()
def new(map) do
s = struct(__MODULE__, map)
process_raw_result(s)
end
# Process result for GRAPH.QUERY
@spec process_raw_result(t()) :: t()
defp process_raw_result(%{raw_result_set: result} = query_result) when is_list(result) do
if length(result) == 1 do
%{query_result | statistics: parse_statistics(Enum.at(result, 0))}
else
%{
parse_results(query_result)
| statistics: parse_statistics(Enum.at(result, -1))
}
end
end
# Process result for GRAPH.DELETE
defp process_raw_result(%{raw_result_set: result} = query_result) when is_binary(result) do
%{query_result | statistics: parse_statistics(result)}
end
@doc "Return a boolean indicating emptiness of a QueryResult."
@spec is_empty(t()) :: boolean()
def is_empty(query_result) do
if is_nil(query_result.result_set) or Enum.empty?(query_result.result_set) do
true
else
false
end
end
@spec parse_statistics(list(any()) | String.t()) :: map()
defp parse_statistics(raw_statistics) when is_list(raw_statistics) do
stats = [
@labels_added,
@labels_removed,
@nodes_created,
@nodes_deleted,
@properties_set,
@properties_removed,
@relationships_created,
@relationships_deleted,
@indices_created,
@indices_deleted,
@query_internal_execution_time
]
stats
|> Enum.map(fn s -> {s, get_value(s, raw_statistics)} end)
|> Enum.into(%{})
end
defp parse_statistics(raw_statistics) when is_binary(raw_statistics) do
%{
@graph_removed_internal_execution_time =>
extract_value(@graph_removed_internal_execution_time, raw_statistics)
}
end
defp get_value(stat, [raw_statistic | raw_statistics]) do
case extract_value(stat, raw_statistic) do
nil -> get_value(stat, raw_statistics)
value -> value
end
end
defp get_value(_stat, []) do
nil
end
defp extract_value(stat, raw_statistic) do
if String.contains?(raw_statistic, stat) do
raw_statistic
|> String.split(": ")
|> Enum.at(1)
|> String.split(" ")
|> Enum.at(0)
else
nil
end
end
@spec parse_header(t()) :: list(atom())
defp parse_header(%{raw_result_set: [header | _tail]} = _query_result) do
header |> Enum.map(fn h -> Enum.at(h, 1) |> String.to_atom() end)
end
@spec fetch_metadata(t()) :: t()
defp fetch_metadata(%{conn: conn, graph_name: name} = query_result) do
labels = parse_procedure_call(RedisGraph.call_procedure_raw(conn, name, "db.labels"))
property_keys =
parse_procedure_call(RedisGraph.call_procedure_raw(conn, name, "db.propertyKeys"))
relationship_types =
parse_procedure_call(RedisGraph.call_procedure_raw(conn, name, "db.relationshipTypes"))
%{
query_result
| labels: labels,
property_keys: property_keys,
relationship_types: relationship_types
}
end
defp parse_procedure_call(response) do
case response do
{:ok, result} ->
[_columns_array, records_array, _metadata_array] = result
# e.g. of records_array -- [ [[_value_type, element]], [[_value_type, element]] ]
Enum.with_index(records_array, fn [[_value_type, element] | _], index ->
{index, element}
end)
|> Enum.into(%{})
{:error, reason} ->
raise reason
end
end
@spec parse_results(t()) :: t()
defp parse_results(%{raw_result_set: [header | _tail]} = query_result) do
query_result = fetch_metadata(query_result)
if length(header) > 0 do
header = parse_header(query_result)
%{
query_result
| header: header,
result_set: parse_records(query_result)
}
else
query_result
end
end
@spec parse_records(t()) :: list(any)
defp parse_records(%{raw_result_set: [_header | [records_array | _statistics]]} = query_result) do
Enum.map(records_array, &parse_row(query_result, &1))
end
@spec parse_row(t(), list(any())) :: list(any())
defp parse_row(%{raw_result_set: [header | _tail]} = query_result, row) do
Stream.with_index(row)
|> Enum.map(fn {cell, index} ->
[column_type, alias] = header |> Enum.at(index)
parse_cell(query_result, cell, column_type, String.to_atom(alias))
end)
end
# https://redis.io/docs/stack/graph/design/client_spec/
@spec parse_cell(t(), list(any()), number(), atom() | nil) :: Node.t()
defp parse_cell(query_result, cell, column_type \\ 1, alias \\ nil)
defp parse_cell(query_result, cell, 1, alias) do
[value_type | [value]] = cell
cond do
value_type == @value_type[:VALUE_NODE] ->
parse_node(query_result, value, alias)
value_type == @value_type[:VALUE_EDGE] ->
parse_relationship(query_result, value, alias)
value_type == @value_type[:VALUE_NULL] || value_type == @value_type[:VALUE_INTEGER] ||
value_type == @value_type[:VALUE_STRING] ->
value
value_type == @value_type[:VALUE_BOOLEAN] ->
if(value == "true", do: true, else: false)
value_type == @value_type[:VALUE_DOUBLE] ->
String.to_float(value)
value_type == @value_type[:VALUE_ARRAY] ->
Enum.map(value, fn inner_value -> parse_cell(query_result, inner_value) end)
value_type == @value_type[:VALUE_PATH] ||
value_type == @value_type[:VALUE_MAP] || value_type == @value_type[:VALUE_POINT] ->
"will be implemented in future"
true ->
"unknown value type"
end
end
# Unused, retained for client compatibility.
defp parse_cell(query_result, cell, 2, alias) do
parse_node(query_result, cell, alias)
end
# Unused, retained for client compatibility.
defp parse_cell(query_result, cell, 3, alias) do
parse_relationship(query_result, cell, alias)
end
@spec parse_node(t(), list(any()), atom()) :: Node.t()
defp parse_node(query_result, cell, alias) do
[node_id | [label_indexes | [properties]]] = cell
Node.new(%{
id: node_id,
alias: alias,
labels: parse_labels(query_result, label_indexes),
properties: parse_entity_properties(query_result, properties)
})
end
@spec parse_relationship(t(), list(any()), atom()) :: Relationship.t()
defp parse_relationship(query_result, cell, alias) do
[relationship_id | [relation_index | [src_node_id | [dest_node_id | [properties]]]]] = cell
Relationship.new(%{
id: relationship_id,
alias: alias,
type: parse_relationship_type(query_result, relation_index),
src_node: src_node_id,
dest_node: dest_node_id,
properties: parse_entity_properties(query_result, properties)
})
end
@spec parse_labels(t(), list(number())) :: list()
defp parse_labels(query_result, label_indexes) do
Enum.map(label_indexes, fn label_id -> Map.get(query_result.labels, label_id) end)
end
@spec parse_relationship_type(t(), list(number())) :: String.t()
defp parse_relationship_type(query_result, relationship_type_index) do
Map.get(query_result.relationship_types, relationship_type_index)
end
@spec parse_entity_properties(t(), list(number())) :: list()
defp parse_entity_properties(query_result, properties) do
Enum.map(properties, fn [property_id | cell] ->
{:"#{Map.get(query_result.property_keys, property_id)}", parse_cell(query_result, cell, 1)}
end)
|> Enum.into(%{})
end
@doc "Transform the results_set from QueryResult into a list of maps as records."
@spec results_to_maps(t()) :: list(map())
def results_to_maps(%{header: header, result_set: records} = _query_result) do
records
|> Enum.map(fn record ->
record
|> Enum.with_index()
|> Enum.map(fn {v, idx} -> {Enum.at(header, idx), v} end)
|> Enum.into(%{})
end)
end
defp get_stat(query_result, stat) do
Map.get(query_result.statistics, stat)
end
@doc "Get the `labels added` quantity from a QueryResult."
@spec labels_added(t()) :: String.t()
def labels_added(query_result) do
get_stat(query_result, @labels_added)
end
@doc "Get the `labels removed` quantity from a QueryResult."
@spec labels_removed(t()) :: String.t()
def labels_removed(query_result) do
get_stat(query_result, @labels_removed)
end
@doc "Get the `nodes created` quantity from a QueryResult."
@spec nodes_created(t()) :: String.t()
def nodes_created(query_result) do
get_stat(query_result, @nodes_created)
end
@doc "Get the `nodes deleted` quantity from a QueryResult."
@spec nodes_deleted(t()) :: String.t()
def nodes_deleted(query_result) do
get_stat(query_result, @nodes_deleted)
end
@doc "Get the `properties set` quantity from a QueryResult."
@spec properties_set(t()) :: String.t()
def properties_set(query_result) do
get_stat(query_result, @properties_set)
end
@doc "Get the `properties removed` quantity from a QueryResult."
@spec properties_removed(t()) :: String.t()
def properties_removed(query_result) do
get_stat(query_result, @properties_removed)
end
@doc "Get the `relationships created` quantity from a QueryResult."
@spec relationships_created(t()) :: String.t()
def relationships_created(query_result) do
get_stat(query_result, @relationships_created)
end
@doc "Get the `relationships deleted` quantity from a QueryResult."
@spec relationships_deleted(t()) :: String.t()
def relationships_deleted(query_result) do
get_stat(query_result, @relationships_deleted)
end
@doc "Get the `indices created` quantity from a QueryResult."
@spec indices_created(t()) :: String.t()
def indices_created(query_result) do
get_stat(query_result, @indices_created)
end
@doc "Get the `indices deleted` quantity from a QueryResult."
@spec indices_deleted(t()) :: String.t()
def indices_deleted(query_result) do
get_stat(query_result, @indices_deleted)
end
@doc "Get the `query internal execution time` (ms) from a QueryResult."
@spec query_internal_execution_time(t()) :: String.t()
def query_internal_execution_time(query_result) do
get_stat(query_result, @query_internal_execution_time)
end
end
