# pgr_drivingDistance¶

pgr_drivingDistance - Returns the driving distance from a start node.

Boost Graph Inside

Availability

• Version 2.1.0:

• Signature change pgr_drivingDistance(single vertex)

• New Official pgr_drivingDistance(multiple vertices)

• Version 2.0.0:

• Official pgr_drivingDistance(single vertex)

Support

## Description¶

Using the Dijkstra algorithm, extracts all the nodes that have costs less than or equal to the value distance. The edges extracted will conform to the corresponding spanning tree.

## Signatures¶

Summary

pgr_drivingDistance(edges_sql, start_vid,  distance [, directed])
pgr_drivingDistance(edges_sql, start_vids, distance [, directed] [, equicost])
RETURNS SET OF (seq, [start_vid,] node, edge, cost, agg_cost)


Using defaults

pgr_drivingDistance(edges_sql, start_vid, distance)
RETURNS SET OF (seq, node, edge, cost, agg_cost)

Example

TBD

### Single Vertex¶

pgr_drivingDistance(edges_sql, start_vid, distance [, directed])
RETURNS SET OF (seq, node, edge, cost, agg_cost)

Example

TBD

### Multiple Vertices¶

pgr_drivingDistance(edges_sql, start_vids, distance, [, directed] [, equicost])
RETURNS SET OF (seq, start_vid, node, edge, cost, agg_cost)

Example

TBD

## Parameters¶

Column

Type

Description

edges_sql

TEXT

SQL query as described above.

start_vid

BIGINT

Identifier of the starting vertex.

start_vids

ARRAY[ANY-INTEGER]

Array of identifiers of the starting vertices.

distance

FLOAT

Upper limit for the inclusion of the node in the result.

directed

BOOLEAN

(optional). When false the graph is considered as Undirected. Default is true which considers the graph as Directed.

equicost

BOOLEAN

(optional). When true the node will only appear in the closest start_vid list. Default is false which resembles several calls using the single starting point signatures. Tie brakes are arbitrary.

## Inner 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

## Result Columns¶

Returns set of (seq [, start_v], node, edge, cost, agg_cost)

Column

Type

Description

seq

INTEGER

Sequential value starting from 1.

start_vid

INTEGER

Identifier of the starting vertex.

node

BIGINT

Identifier of the node in the path within the limits from start_vid.

edge

BIGINT

Identifier of the edge used to arrive to node. 0 when the node is the start_vid.

cost

FLOAT

Cost to traverse edge.

agg_cost

FLOAT

Aggregate cost from start_vid to node.

Example

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_drivingDistance(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, 3
);
seq | node | edge | cost | agg_cost
-----+------+------+------+----------
1 |    2 |   -1 |    0 |        0
2 |    1 |    1 |    1 |        1
3 |    5 |    4 |    1 |        1
4 |    6 |    8 |    1 |        2
5 |    8 |    7 |    1 |        2
6 |   10 |   10 |    1 |        2
7 |    7 |    6 |    1 |        3
8 |    9 |    9 |    1 |        3
9 |   11 |   12 |    1 |        3
10 |   13 |   14 |    1 |        3
(10 rows)

SELECT * FROM pgr_drivingDistance(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
13, 3
);
seq | node | edge | cost | agg_cost
-----+------+------+------+----------
1 |   13 |   -1 |    0 |        0
2 |   10 |   14 |    1 |        1
3 |    5 |   10 |    1 |        2
4 |   11 |   12 |    1 |        2
5 |    2 |    4 |    1 |        3
6 |    6 |    8 |    1 |        3
7 |    8 |    7 |    1 |        3
8 |   12 |   13 |    1 |        3
(8 rows)

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

SELECT * FROM pgr_drivingDistance(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
array[2,13], 3, equicost:=true
);
seq | from_v | node | edge | cost | agg_cost
-----+--------+------+------+------+----------
1 |      2 |    2 |   -1 |    0 |        0
2 |      2 |    1 |    1 |    1 |        1
3 |      2 |    5 |    4 |    1 |        1
4 |      2 |    6 |    8 |    1 |        2
5 |      2 |    8 |    7 |    1 |        2
6 |      2 |    7 |    6 |    1 |        3
7 |      2 |    9 |    9 |    1 |        3
8 |     13 |   13 |   -1 |    0 |        0
9 |     13 |   10 |   14 |    1 |        1
10 |     13 |   11 |   12 |    1 |        2
11 |     13 |   12 |   13 |    1 |        3
(11 rows)


Example

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_drivingDistance(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
2, 3, false
);
seq | node | edge | cost | agg_cost
-----+------+------+------+----------
1 |    2 |   -1 |    0 |        0
2 |    1 |    1 |    1 |        1
3 |    3 |    2 |    1 |        1
4 |    5 |    4 |    1 |        1
5 |    4 |    3 |    1 |        2
6 |    6 |    8 |    1 |        2
7 |    8 |    7 |    1 |        2
8 |   10 |   10 |    1 |        2
9 |    7 |    6 |    1 |        3
10 |    9 |   16 |    1 |        3
11 |   11 |   12 |    1 |        3
12 |   13 |   14 |    1 |        3
(12 rows)

SELECT * FROM pgr_drivingDistance(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
13, 3, false
);
seq | node | edge | cost | agg_cost
-----+------+------+------+----------
1 |   13 |   -1 |    0 |        0
2 |   10 |   14 |    1 |        1
3 |    5 |   10 |    1 |        2
4 |   11 |   12 |    1 |        2
5 |    2 |    4 |    1 |        3
6 |    6 |    8 |    1 |        3
7 |    8 |    7 |    1 |        3
8 |   12 |   13 |    1 |        3
(8 rows)

SELECT * FROM pgr_drivingDistance(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
array[2,13], 3, false
);
seq | from_v | node | edge | cost | agg_cost
-----+--------+------+------+------+----------
1 |      2 |    2 |   -1 |    0 |        0
2 |      2 |    1 |    1 |    1 |        1
3 |      2 |    3 |    2 |    1 |        1
4 |      2 |    5 |    4 |    1 |        1
5 |      2 |    4 |    3 |    1 |        2
6 |      2 |    6 |    8 |    1 |        2
7 |      2 |    8 |    7 |    1 |        2
8 |      2 |   10 |   10 |    1 |        2
9 |      2 |    7 |    6 |    1 |        3
10 |      2 |    9 |   16 |    1 |        3
11 |      2 |   11 |   12 |    1 |        3
12 |      2 |   13 |   14 |    1 |        3
13 |     13 |   13 |   -1 |    0 |        0
14 |     13 |   10 |   14 |    1 |        1
15 |     13 |    5 |   10 |    1 |        2
16 |     13 |   11 |   12 |    1 |        2
17 |     13 |    2 |    4 |    1 |        3
18 |     13 |    6 |    8 |    1 |        3
19 |     13 |    8 |    7 |    1 |        3
20 |     13 |   12 |   13 |    1 |        3
(20 rows)

SELECT * FROM pgr_drivingDistance(
'SELECT id, source, target, cost, reverse_cost FROM edge_table',
array[2,13], 3, false, equicost:=true
);
seq | from_v | node | edge | cost | agg_cost
-----+--------+------+------+------+----------
1 |      2 |    2 |   -1 |    0 |        0
2 |      2 |    1 |    1 |    1 |        1
3 |      2 |    3 |    2 |    1 |        1
4 |      2 |    5 |    4 |    1 |        1
5 |      2 |    4 |    3 |    1 |        2
6 |      2 |    6 |    8 |    1 |        2
7 |      2 |    8 |    7 |    1 |        2
8 |      2 |    7 |    6 |    1 |        3
9 |      2 |    9 |   16 |    1 |        3
10 |     13 |   13 |   -1 |    0 |        0
11 |     13 |   10 |   14 |    1 |        1
12 |     13 |   11 |   12 |    1 |        2
13 |     13 |   12 |   13 |    1 |        3
(13 rows)


Example

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_drivingDistance(
'SELECT id, source, target, cost FROM edge_table',
2, 3
);
seq | node | edge | cost | agg_cost
-----+------+------+------+----------
1 |    2 |   -1 |    0 |        0
2 |    5 |    4 |    1 |        1
3 |    6 |    8 |    1 |        2
4 |   10 |   10 |    1 |        2
5 |    9 |    9 |    1 |        3
6 |   11 |   11 |    1 |        3
7 |   13 |   14 |    1 |        3
(7 rows)

SELECT * FROM pgr_drivingDistance(
'SELECT id, source, target, cost FROM edge_table',
13, 3
);
seq | node | edge | cost | agg_cost
-----+------+------+------+----------
1 |   13 |   -1 |    0 |        0
(1 row)

SELECT * FROM pgr_drivingDistance(
'SELECT id, source, target, cost FROM edge_table',
array[2,13], 3
);
seq | from_v | node | edge | cost | agg_cost
-----+--------+------+------+------+----------
1 |      2 |    2 |   -1 |    0 |        0
2 |      2 |    5 |    4 |    1 |        1
3 |      2 |    6 |    8 |    1 |        2
4 |      2 |   10 |   10 |    1 |        2
5 |      2 |    9 |    9 |    1 |        3
6 |      2 |   11 |   11 |    1 |        3
7 |      2 |   13 |   14 |    1 |        3
8 |     13 |   13 |   -1 |    0 |        0
(8 rows)

SELECT * FROM pgr_drivingDistance(
'SELECT id, source, target, cost FROM edge_table',
array[2,13], 3, equicost:=true
);
seq | from_v | node | edge | cost | agg_cost
-----+--------+------+------+------+----------
1 |      2 |    2 |   -1 |    0 |        0
2 |      2 |    5 |    4 |    1 |        1
3 |      2 |    6 |    8 |    1 |        2
4 |      2 |   10 |   10 |    1 |        2
5 |      2 |    9 |    9 |    1 |        3
6 |      2 |   11 |   11 |    1 |        3
7 |     13 |   13 |   -1 |    0 |        0
(7 rows)


Example

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_drivingDistance(
'SELECT id, source, target, cost FROM edge_table',
2, 3, false
);
seq | node | edge | cost | agg_cost
-----+------+------+------+----------
1 |    2 |   -1 |    0 |        0
2 |    1 |    1 |    1 |        1
3 |    5 |    4 |    1 |        1
4 |    6 |    8 |    1 |        2
5 |    8 |    7 |    1 |        2
6 |   10 |   10 |    1 |        2
7 |    3 |    5 |    1 |        3
8 |    7 |    6 |    1 |        3
9 |    9 |    9 |    1 |        3
10 |   11 |   12 |    1 |        3
11 |   13 |   14 |    1 |        3
(11 rows)

SELECT * FROM pgr_drivingDistance(
'SELECT id, source, target, cost FROM edge_table',
13, 3, false
);
seq | node | edge | cost | agg_cost
-----+------+------+------+----------
1 |   13 |   -1 |    0 |        0
2 |   10 |   14 |    1 |        1
3 |    5 |   10 |    1 |        2
4 |   11 |   12 |    1 |        2
5 |    2 |    4 |    1 |        3
6 |    6 |    8 |    1 |        3
7 |    8 |    7 |    1 |        3
8 |   12 |   13 |    1 |        3
(8 rows)

SELECT * FROM pgr_drivingDistance(
'SELECT id, source, target, cost FROM edge_table',
array[2,13], 3, false
);
seq | from_v | node | edge | cost | agg_cost
-----+--------+------+------+------+----------
1 |      2 |    2 |   -1 |    0 |        0
2 |      2 |    1 |    1 |    1 |        1
3 |      2 |    5 |    4 |    1 |        1
4 |      2 |    6 |    8 |    1 |        2
5 |      2 |    8 |    7 |    1 |        2
6 |      2 |   10 |   10 |    1 |        2
7 |      2 |    3 |    5 |    1 |        3
8 |      2 |    7 |    6 |    1 |        3
9 |      2 |    9 |    9 |    1 |        3
10 |      2 |   11 |   12 |    1 |        3
11 |      2 |   13 |   14 |    1 |        3
12 |     13 |   13 |   -1 |    0 |        0
13 |     13 |   10 |   14 |    1 |        1
14 |     13 |    5 |   10 |    1 |        2
15 |     13 |   11 |   12 |    1 |        2
16 |     13 |    2 |    4 |    1 |        3
17 |     13 |    6 |    8 |    1 |        3
18 |     13 |    8 |    7 |    1 |        3
19 |     13 |   12 |   13 |    1 |        3
(19 rows)

SELECT * FROM pgr_drivingDistance(
'SELECT id, source, target, cost FROM edge_table',
array[2,13], 3, false, equicost:=true
);
seq | from_v | node | edge | cost | agg_cost
-----+--------+------+------+------+----------
1 |      2 |    2 |   -1 |    0 |        0
2 |      2 |    1 |    1 |    1 |        1
3 |      2 |    5 |    4 |    1 |        1
4 |      2 |    6 |    8 |    1 |        2
5 |      2 |    8 |    7 |    1 |        2
6 |      2 |    3 |    5 |    1 |        3
7 |      2 |    7 |    6 |    1 |        3
8 |      2 |    9 |    9 |    1 |        3
9 |     13 |   13 |   -1 |    0 |        0
10 |     13 |   10 |   14 |    1 |        1
11 |     13 |   11 |   12 |    1 |        2
12 |     13 |   12 |   13 |    1 |        3
(12 rows)