pgr_dijkstra

 pgr_dijkstra  - Returns the shortest path(s) using Dijkstra algorithm. In particular, the Dijkstra algorithm implemented by Boost.Graph.

Availability

• Version 3.1.0

• New Proposed functions:

• pgr_dijkstra(combinations)

• Version 3.0.0

• Official functions

• Version 2.2.0

• New proposed functions:

• pgr_dijkstra(One to Many)

• pgr_dijkstra(Many to One)

• pgr_dijkstra(Many to Many)

• Version 2.1.0

• Signature change on pgr_dijkstra(One to One)

• Version 2.0.0

• Official pgr_dijkstra(One to One)

Description

Dijkstra’s algorithm, conceived by Dutch computer scientist Edsger Dijkstra in 1956. It is a graph search algorithm that solves the shortest path problem for a graph with non-negative edge path costs, producing a shortest path from a starting vertex (  start_vid  ) to an ending vertex (  end_vid  ). This implementation can be used with a directed graph and an undirected graph.

The main characteristics are:
• Process is done only on edges with positive costs.

• Values are returned when there is a path.

• When the starting vertex and ending vertex are the same, there is no path.

• The agg_cost the non included values (v, v) is 0

• When the starting vertex and ending vertex are the different and there is no path:

• The agg_cost the non included values (u, v) is $$\infty$$

• For optimization purposes, any duplicated value in the start_vids or end_vids are ignored.

• The returned values are ordered:

• start_vid ascending

• end_vid ascending

• Running time: $$O( start\_vids * (V \log V + E))$$

Signatures

Summary

pgr_dijkstra(Edges SQL, start_vid,  end_vid  [, directed])
pgr_dijkstra(Edges SQL, start_vid,  end_vids [, directed])
pgr_dijkstra(Edges SQL, start_vids, end_vid  [, directed])
pgr_dijkstra(Edges SQL, start_vids, end_vids [, directed])
pgr_dijkstra(Edges SQL, Combinations SQL [, directed])
RETURNS SET OF (seq, path_seq [, start_vid] [, end_vid], node, edge, cost, agg_cost)
OR EMPTY SET


Using defaults

pgr_dijkstra(Edges SQL, start_vid, end_vid)
RETURNS SET OF (seq, path_seq, node, edge, cost, agg_cost) or EMPTY SET

Example :

From vertex $$2$$ to vertex $$3$$ on a directed graph

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, 3
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1     2     4     1         0
2         2     5     8     1         1
3         3     6     9     1         2
4         4     9    16     1         3
5         5     4     3     1         4
6         6     3    -1     0         5
(6 rows)



One to One

pgr_dijkstra(Edges SQL, start_vid,  end_vid  [, directed])
RETURNS SET OF (seq, path_seq, node, edge, cost, agg_cost)
OR EMPTY SET

Example :

From vertex $$2$$ to vertex $$3$$ on an undirected graph

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, 3,
FALSE
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1     2     2     1         0
2         2     3    -1     0         1
(2 rows)



One to many

pgr_dijkstra(Edges SQL, start_vid, end_vids, [, directed])
RETURNS SET OF (seq, path_seq, end_vid, node, edge, cost, agg_cost)
OR EMPTY SET

Example :

From vertex $$2$$ to vertices $$\{3, 5\}$$ on an undirected graph

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
2, ARRAY[3,5],
FALSE
);
seq  path_seq  end_vid  node  edge  cost  agg_cost
-----+----------+---------+------+------+------+----------
1         1        3     2     4     1         0
2         2        3     5     8     1         1
3         3        3     6     5     1         2
4         4        3     3    -1     0         3
5         1        5     2     4     1         0
6         2        5     5    -1     0         1
(6 rows)



Many to One

pgr_dijkstra(Edges SQL, start_vids, end_vid, [, directed])
RETURNS SET OF (seq, path_seq, start_vid, node, edge, cost, agg_cost)
OR EMPTY SET

Example :

From vertices $$\{2, 11\}$$ to vertex $$5$$ on a directed graph

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
ARRAY[2,11], 5
);
seq  path_seq  start_vid  node  edge  cost  agg_cost
-----+----------+-----------+------+------+------+----------
1         1          2     2     4     1         0
2         2          2     5    -1     0         1
3         1         11    11    13     1         0
4         2         11    12    15     1         1
5         3         11     9     9     1         2
6         4         11     6     8     1         3
7         5         11     5    -1     0         4
(7 rows)



Many to Many

pgr_dijkstra(Edges SQL, start_vids, end_vids, [, directed])
RETURNS SET OF (seq, path_seq, start_vid, end_vid, node, edge, cost, agg_cost)
OR EMPTY SET

Example :

From vertices $$\{2, 11\}$$ to vertices $$\{3, 5\}$$ on an undirected graph

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
ARRAY[2,11], ARRAY[3,5],
FALSE
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        3     2     2     1         0
2         2          2        3     3    -1     0         1
3         1          2        5     2     4     1         0
4         2          2        5     5    -1     0         1
5         1         11        3    11    11     1         0
6         2         11        3     6     5     1         1
7         3         11        3     3    -1     0         2
8         1         11        5    11    11     1         0
9         2         11        5     6     8     1         1
10         3         11        5     5    -1     0         2
(10 rows)



Combinations

pgr_dijkstra(Edges SQL, Combinations SQL, end_vids, [, directed])
RETURNS SET OF (seq, path_seq, start_vid, end_vid, node, edge, cost, agg_cost)
OR EMPTY SET

Example :

Using a combinations table on an undirected graph

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
'SELECT * FROM combinations_table',
FALSE
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          1        2     1     1     1         0
2         2          1        2     2    -1     0         1
3         1          1        4     1     1     1         0
4         2          1        4     2     2     1         1
5         3          1        4     3     3     1         2
6         4          1        4     4    -1     0         3
7         1          2        1     2     1     1         0
8         2          2        1     1    -1     0         1
9         1          2        4     2     2     1         0
10         2          2        4     3     3     1         1
11         3          2        4     4    -1     0         2
(11 rows)



Parameters

Parameter

Type

Default

Description

Edges SQL

 TEXT 

Edges query as described below

Combinations SQL

 TEXT 

Combinations query as described below

start_vid

 BIGINT 

Identifier of the starting vertex of the path.

start_vids

 ARRAY[BIGINT] 

Array of identifiers of starting vertices.

end_vid

 BIGINT 

Identifier of the ending vertex of the path.

end_vids

 ARRAY[BIGINT] 

Array of identifiers of ending vertices.

directed

 BOOLEAN 

 true 

• When  true  Graph is considered Directed

• When  false  the graph is considered as Undirected .

Inner queries

Edges query

Column

Type

Default

Description

id

 ANY-INTEGER 

Identifier of the edge.

source

 ANY-INTEGER 

Identifier of the first end point vertex of the edge.

target

 ANY-INTEGER 

Identifier of the second end point vertex of the edge.

cost

 ANY-NUMERICAL 

Weight of the edge (source, target)

• When negative: edge (source, target) does not exist, therefore it’s not part of the graph.

reverse_cost

 ANY-NUMERICAL 

-1

Weight of the edge (target, source) ,

• When negative: edge (target, source) does not exist, therefore it’s not part of the graph.

Where:

ANY-INTEGER :

SMALLINT, INTEGER, BIGINT

ANY-NUMERICAL :

SMALLINT, INTEGER, BIGINT, REAL, FLOAT

Combinations query

Column

Type

Default

Description

source

 ANY-INTEGER 

Identifier of the first end point vertex of the edge.

target

 ANY-INTEGER 

Identifier of the second end point vertex of the edge.

Where:

ANY-INTEGER :

SMALLINT, INTEGER, BIGINT

Return Columns

Returns set of  (seq, path_id, path_seq [, start_vid] [, end_vid], node, edge, cost, agg_cost) 

Column

Type

Description

seq

 INT 

Sequential value starting from 1 .

path_id

 INT 

Path identifier. Has value 1 for the first of a path. Used when there are multiple paths for the same  start_vid  to  end_vid  combination.

path_seq

 INT 

Relative position in the path. Has value 1 for the beginning of a path.

start_vid

 BIGINT 

Identifier of the starting vertex. Returned when multiple starting vetrices are in the query.

end_vid

 BIGINT 

Identifier of the ending vertex. Returned when multiple ending vertices are in the query.

node

 BIGINT 

Identifier of the node in the path from  start_vid  to  end_vid  .

edge

 BIGINT 

Identifier of the edge used to go from  node  to the next node in the path sequence.  -1  for the last node of the path.

cost

 FLOAT 

Cost to traverse from  node  using  edge  to the next node in the path sequence.

agg_cost

 FLOAT 

Aggregate cost from  start_v  to  node  .

The examples of this section are based on the Sample Data network.

The examples include combinations from starting vertices 2 and 11 to ending vertices 3 and 5 in a directed and undirected graph with and with out reverse_cost.

Examples :

For queries marked as  directed  with  cost  and  reverse_cost  columns

The examples in this section use the following Network for queries marked as directed and cost and reverse_cost columns are used

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, 3
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1     2     4     1         0
2         2     5     8     1         1
3         3     6     9     1         2
4         4     9    16     1         3
5         5     4     3     1         4
6         6     3    -1     0         5
(6 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, 5
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1     2     4     1         0
2         2     5    -1     0         1
(2 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, ARRAY[3,5]
);
seq  path_seq  end_vid  node  edge  cost  agg_cost
-----+----------+---------+------+------+------+----------
1         1        3     2     4     1         0
2         2        3     5     8     1         1
3         3        3     6     9     1         2
4         4        3     9    16     1         3
5         5        3     4     3     1         4
6         6        3     3    -1     0         5
7         1        5     2     4     1         0
8         2        5     5    -1     0         1
(8 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
11, 3
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1    11    13     1         0
2         2    12    15     1         1
3         3     9    16     1         2
4         4     4     3     1         3
5         5     3    -1     0         4
(5 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
11, 5
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1    11    13     1         0
2         2    12    15     1         1
3         3     9     9     1         2
4         4     6     8     1         3
5         5     5    -1     0         4
(5 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
ARRAY[2,11], 5
);
seq  path_seq  start_vid  node  edge  cost  agg_cost
-----+----------+-----------+------+------+------+----------
1         1          2     2     4     1         0
2         2          2     5    -1     0         1
3         1         11    11    13     1         0
4         2         11    12    15     1         1
5         3         11     9     9     1         2
6         4         11     6     8     1         3
7         5         11     5    -1     0         4
(7 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
ARRAY[2, 11], ARRAY[3,5]
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        3     2     4     1         0
2         2          2        3     5     8     1         1
3         3          2        3     6     9     1         2
4         4          2        3     9    16     1         3
5         5          2        3     4     3     1         4
6         6          2        3     3    -1     0         5
7         1          2        5     2     4     1         0
8         2          2        5     5    -1     0         1
9         1         11        3    11    13     1         0
10         2         11        3    12    15     1         1
11         3         11        3     9    16     1         2
12         4         11        3     4     3     1         3
13         5         11        3     3    -1     0         4
14         1         11        5    11    13     1         0
15         2         11        5    12    15     1         1
16         3         11        5     9     9     1         2
17         4         11        5     6     8     1         3
18         5         11        5     5    -1     0         4
(18 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
'SELECT * FROM (VALUES (2, 3), (2, 5), (11, 3), (11, 5)) AS combinations (source, target)'
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        3     2     4     1         0
2         2          2        3     5     8     1         1
3         3          2        3     6     9     1         2
4         4          2        3     9    16     1         3
5         5          2        3     4     3     1         4
6         6          2        3     3    -1     0         5
7         1          2        5     2     4     1         0
8         2          2        5     5    -1     0         1
9         1         11        3    11    13     1         0
10         2         11        3    12    15     1         1
11         3         11        3     9    16     1         2
12         4         11        3     4     3     1         3
13         5         11        3     3    -1     0         4
14         1         11        5    11    13     1         0
15         2         11        5    12    15     1         1
16         3         11        5     9     9     1         2
17         4         11        5     6     8     1         3
18         5         11        5     5    -1     0         4
(18 rows)


Examples :

For queries marked as  undirected  with  cost  and  reverse_cost  columns

The examples in this section use the following Network for queries marked as undirected and cost and reverse_cost columns are used

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, 3,
FALSE
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1     2     2     1         0
2         2     3    -1     0         1
(2 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, 5,
FALSE
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1     2     4     1         0
2         2     5    -1     0         1
(2 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
11, 3,
FALSE
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1    11    11     1         0
2         2     6     5     1         1
3         3     3    -1     0         2
(3 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
11, 5,
FALSE
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1    11    11     1         0
2         2     6     8     1         1
3         3     5    -1     0         2
(3 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
ARRAY[2,11], 5,
FALSE
);
seq  path_seq  start_vid  node  edge  cost  agg_cost
-----+----------+-----------+------+------+------+----------
1         1          2     2     4     1         0
2         2          2     5    -1     0         1
3         1         11    11    12     1         0
4         2         11    10    10     1         1
5         3         11     5    -1     0         2
(5 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, ARRAY[3,5],
FALSE
);
seq  path_seq  end_vid  node  edge  cost  agg_cost
-----+----------+---------+------+------+------+----------
1         1        3     2     2     1         0
2         2        3     3    -1     0         1
3         1        5     2     4     1         0
4         2        5     5    -1     0         1
(4 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
ARRAY[2, 11], ARRAY[3,5],
FALSE
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        3     2     2     1         0
2         2          2        3     3    -1     0         1
3         1          2        5     2     4     1         0
4         2          2        5     5    -1     0         1
5         1         11        3    11    11     1         0
6         2         11        3     6     5     1         1
7         3         11        3     3    -1     0         2
8         1         11        5    11    11     1         0
9         2         11        5     6     8     1         1
10         3         11        5     5    -1     0         2
(10 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
'SELECT * FROM (VALUES (2, 3), (2, 5), (11, 3), (11, 5)) AS combinations (source, target)',
FALSE
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        3     2     2     1         0
2         2          2        3     3    -1     0         1
3         1          2        5     2     4     1         0
4         2          2        5     5    -1     0         1
5         1         11        3    11    11     1         0
6         2         11        3     6     5     1         1
7         3         11        3     3    -1     0         2
8         1         11        5    11    11     1         0
9         2         11        5     6     8     1         1
10         3         11        5     5    -1     0         2
(10 rows)


Examples :

For queries marked as  directed  with  cost  column

The examples in this section use the following Network for queries marked as directed and only cost column is used

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
2, 3
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
(0 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
2, 5
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1     2     4     1         0
2         2     5    -1     0         1
(2 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
11, 3
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
(0 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
11, 5
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
(0 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
ARRAY[2,11], 5
);
seq  path_seq  start_vid  node  edge  cost  agg_cost
-----+----------+-----------+------+------+------+----------
1         1          2     2     4     1         0
2         2          2     5    -1     0         1
(2 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
2, ARRAY[3,5]
);
seq  path_seq  end_vid  node  edge  cost  agg_cost
-----+----------+---------+------+------+------+----------
1         1        5     2     4     1         0
2         2        5     5    -1     0         1
(2 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
ARRAY[2, 11], ARRAY[3,5]
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        5     2     4     1         0
2         2          2        5     5    -1     0         1
(2 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
'SELECT * FROM (VALUES (2, 3), (2, 5), (11, 3), (11, 5)) AS combinations (source, target)'
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        5     2     4     1         0
2         2          2        5     5    -1     0         1
(2 rows)


Examples :

For queries marked as  undirected  with  cost  column

The examples in this section use the following Network for queries marked as undirected and only cost column is used

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
2, 3,
FALSE
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1     2     4     1         0
2         2     5     8     1         1
3         3     6     5     1         2
4         4     3    -1     0         3
(4 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
2, 5,
FALSE
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1     2     4     1         0
2         2     5    -1     0         1
(2 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
11, 3,
FALSE
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1    11    11     1         0
2         2     6     5     1         1
3         3     3    -1     0         2
(3 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
11, 5,
FALSE
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1    11    11     1         0
2         2     6     8     1         1
3         3     5    -1     0         2
(3 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
ARRAY[2,11], 5,
FALSE
);
seq  path_seq  start_vid  node  edge  cost  agg_cost
-----+----------+-----------+------+------+------+----------
1         1          2     2     4     1         0
2         2          2     5    -1     0         1
3         1         11    11    12     1         0
4         2         11    10    10     1         1
5         3         11     5    -1     0         2
(5 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
2, ARRAY[3,5],
FALSE
);
seq  path_seq  end_vid  node  edge  cost  agg_cost
-----+----------+---------+------+------+------+----------
1         1        3     2     4     1         0
2         2        3     5     8     1         1
3         3        3     6     5     1         2
4         4        3     3    -1     0         3
5         1        5     2     4     1         0
6         2        5     5    -1     0         1
(6 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
ARRAY[2, 11], ARRAY[3,5],
FALSE
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        3     2     4     1         0
2         2          2        3     5     8     1         1
3         3          2        3     6     5     1         2
4         4          2        3     3    -1     0         3
5         1          2        5     2     4     1         0
6         2          2        5     5    -1     0         1
7         1         11        3    11    11     1         0
8         2         11        3     6     5     1         1
9         3         11        3     3    -1     0         2
10         1         11        5    11    11     1         0
11         2         11        5     6     8     1         1
12         3         11        5     5    -1     0         2
(12 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM edge_table',
'SELECT * FROM (VALUES (2, 3), (2, 5), (11, 3), (11, 5)) AS combinations (source, target)',
FALSE
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        3     2     4     1         0
2         2          2        3     5     8     1         1
3         3          2        3     6     5     1         2
4         4          2        3     3    -1     0         3
5         1          2        5     2     4     1         0
6         2          2        5     5    -1     0         1
7         1         11        3    11    11     1         0
8         2         11        3     6     5     1         1
9         3         11        3     3    -1     0         2
10         1         11        5    11    11     1         0
11         2         11        5     6     8     1         1
12         3         11        5     5    -1     0         2
(12 rows)



Equvalences between signatures

Examples :

For queries marked as  directed  with  cost  and  reverse_cost  columns

The examples in this section use the following:

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, 3,
TRUE
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1     2     4     1         0
2         2     5     8     1         1
3         3     6     9     1         2
4         4     9    16     1         3
5         5     4     3     1         4
6         6     3    -1     0         5
(6 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2,3
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1     2     4     1         0
2         2     5     8     1         1
3         3     6     9     1         2
4         4     9    16     1         3
5         5     4     3     1         4
6         6     3    -1     0         5
(6 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, ARRAY[3],
TRUE
);
seq  path_seq  end_vid  node  edge  cost  agg_cost
-----+----------+---------+------+------+------+----------
1         1        3     2     4     1         0
2         2        3     5     8     1         1
3         3        3     6     9     1         2
4         4        3     9    16     1         3
5         5        3     4     3     1         4
6         6        3     3    -1     0         5
(6 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, ARRAY[3]
);
seq  path_seq  end_vid  node  edge  cost  agg_cost
-----+----------+---------+------+------+------+----------
1         1        3     2     4     1         0
2         2        3     5     8     1         1
3         3        3     6     9     1         2
4         4        3     9    16     1         3
5         5        3     4     3     1         4
6         6        3     3    -1     0         5
(6 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
ARRAY[2], ARRAY[3],
TRUE
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        3     2     4     1         0
2         2          2        3     5     8     1         1
3         3          2        3     6     9     1         2
4         4          2        3     9    16     1         3
5         5          2        3     4     3     1         4
6         6          2        3     3    -1     0         5
(6 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
ARRAY[2], ARRAY[3]
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        3     2     4     1         0
2         2          2        3     5     8     1         1
3         3          2        3     6     9     1         2
4         4          2        3     9    16     1         3
5         5          2        3     4     3     1         4
6         6          2        3     3    -1     0         5
(6 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
'SELECT * FROM (VALUES(2, 3)) AS combinations (source, target)'
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        3     2     4     1         0
2         2          2        3     5     8     1         1
3         3          2        3     6     9     1         2
4         4          2        3     9    16     1         3
5         5          2        3     4     3     1         4
6         6          2        3     3    -1     0         5
(6 rows)


Examples :

For queries marked as  undirected  with  cost  and  reverse_cost  columns

The examples in this section use the following:

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, 3,
FALSE
);
seq  path_seq  node  edge  cost  agg_cost
-----+----------+------+------+------+----------
1         1     2     2     1         0
2         2     3    -1     0         1
(2 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, ARRAY[3],
FALSE
);
seq  path_seq  end_vid  node  edge  cost  agg_cost
-----+----------+---------+------+------+------+----------
1         1        3     2     2     1         0
2         2        3     3    -1     0         1
(2 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
ARRAY[2], 3,
FALSE
);
seq  path_seq  start_vid  node  edge  cost  agg_cost
-----+----------+-----------+------+------+------+----------
1         1          2     2     2     1         0
2         2          2     3    -1     0         1
(2 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
ARRAY[2], ARRAY[3],
FALSE
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        3     2     2     1         0
2         2          2        3     3    -1     0         1
(2 rows)

SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
'SELECT * FROM (VALUES(2, 3)) AS combinations (source, target)',
FALSE
);
seq  path_seq  start_vid  end_vid  node  edge  cost  agg_cost
-----+----------+-----------+---------+------+------+------+----------
1         1          2        3     2     2     1         0
2         2          2        3     3    -1     0         1
(2 rows)