pgRouting

https://docs.pgrouting.org
Admin
pgRouting extends PostGIS and PostgreSQL to provide geospatial routing, shortest path algorithms,...
Tokens:211,666
Snippets:1,842
Trust Score:9.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Setup Data for pgr_vrpOneDepot

Source: https://docs.pgrouting.org/latest/en/pgr_vrpOneDepot.html

SQL script to create and populate the tables required for the pgr_vrpOneDepot example.

```sql
/* :file: This file is part of the pgRouting project.
:copyright: Copyright (c) 2013-2026 pgRouting developers
:license: Creative Commons Attribution-Share Alike 3.0 https://creativecommons.org/licenses/by-sa/3.0 */

DROP TABLE IF EXISTS solomon_100_RC_101 cascade;
CREATE TABLE solomon_100_RC_101 (
    id integer NOT NULL PRIMARY KEY,
    order_unit integer,
    open_time integer,
    close_time integer,
    service_time integer,
    x float8,
    y float8
);

INSERT INTO solomon_100_RC_101 (id, x, y, order_unit, open_time, close_time, service_time) VALUES
(1, 40.000000, 50.000000, 0, 0, 240, 0),
(2, 25.000000, 85.000000, 20, 145, 175, 10),
(3, 22.000000, 75.000000, 30, 50, 80, 10),
(4, 22.000000, 85.000000, 10, 109, 139, 10),
(5, 20.000000, 80.000000, 40, 141, 171, 10),
(6, 20.000000, 85.000000, 20, 41, 71, 10),
(7, 18.000000, 75.000000, 20, 95, 125, 10),
(8, 15.000000, 75.000000, 20, 79, 109, 10),
(9, 15.000000, 80.000000, 10, 91, 121, 10),
(10, 10.000000, 35.000000, 20, 91, 121, 10),
(11, 10.000000, 40.000000, 30, 119, 149, 10);

DROP TABLE IF EXISTS vrp_vehicles cascade;
CREATE TABLE vrp_vehicles (
    vehicle_id integer not null primary key,
    capacity integer,
    case_no integer
);

INSERT INTO vrp_vehicles (vehicle_id, capacity, case_no) VALUES
(1, 200, 5),
(2, 200, 5),
(3, 200, 5);

DROP TABLE IF EXISTS vrp_distance cascade;
WITH
the_matrix_info AS (
    SELECT A.id AS src_id, B.id AS dest_id, sqrt( (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)) AS cost
    FROM solomon_100_rc_101 AS A, solomon_100_rc_101 AS B WHERE A.id != B.id
)
SELECT src_id, dest_id, cost, cost AS distance, cost AS traveltime
INTO vrp_distance
FROM the_matrix_info;
```

--------------------------------

### Install documentation dependencies

Source: https://docs.pgrouting.org/latest/en/pgRouting-installation.html

Install tools required for building the pgRouting documentation.

```bash
sudo apt-get install -y  \
   python3-sphinx \
   python3-sphinx-bootstrap-theme \
   texlive \
   doxygen
```

--------------------------------

### Calculate Dominator Tree with Root Vertex 5

Source: https://docs.pgrouting.org/latest/en/pgr_lengauerTarjanDominatorTree.html

Example demonstrating the calculation of immediate dominators starting from vertex 5.

```sql
SELECT * FROM pgr_lengauertarjandominatortree(
  $$SELECT id,source,target,cost,reverse_cost FROM edges$$,
  5) ORDER BY vertex_id;
```

--------------------------------

### Create example edges table

Source: https://docs.pgrouting.org/latest/en/pgr_sloanOrdering.html

Sets up a table structure to store graph edges for the Sloan ordering example.

```sql
CREATE TABLE example_edges1 (
    id SERIAL PRIMARY KEY,
    source INTEGER,
    target INTEGER,
    cost DOUBLE PRECISION,
    reverse_cost DOUBLE PRECISION
);
```

--------------------------------

### Calculate paths with pgr_withPoints

Source: https://docs.pgrouting.org/latest/en/pgr_withPoints.html

This example demonstrates routing from a set of start points to a set of end points using the pgr_withPoints function.

```sql
SELECT * FROM pgr_withPoints(
  'SELECT id, source, target, cost, reverse_cost FROM edges ORDER BY id',
  'SELECT pid, edge_id, fraction, side from pointsOfInterest',
  ARRAY[5, -1], ARRAY[-2, -3, -6, 10, 11],
  'r', details => true);
```

--------------------------------

### Calculate Dominator Tree for Another Component

Source: https://docs.pgrouting.org/latest/en/pgr_lengauerTarjanDominatorTree.html

Example demonstrating the calculation of immediate dominators starting from vertex 13.

```sql
SELECT * FROM pgr_lengauertarjandominatortree(
  $$SELECT id,source,target,cost,reverse_cost FROM edges$$,
  13) ORDER BY vertex_id;
```

--------------------------------

### Combinations pgr_bdAstarCost Example

Source: https://docs.pgrouting.org/latest/en/pgr_bdAstarCost.html

Calculate costs using a combinations table to define specific start and end vertex pairs.

```sql
SELECT * FROM combinations;
```

```sql
SELECT * FROM pgr_bdAstarCost(
  'SELECT id, source, target, cost, reverse_cost, x1, y1, x2, y2
  FROM edges',
  'SELECT * FROM combinations',
  factor => 0.5
);
```

--------------------------------

### Combinations Query pgr_bdAstar Example

Source: https://docs.pgrouting.org/latest/en/pgr_bdAstar.html

Executes pgr_bdAstar using a combinations table to define the start and end vertex pairs.

```sql
SELECT * FROM pgr_bdAstar(
  'SELECT id, source, target, cost, reverse_cost, x1, y1, x2, y2
  FROM edges',
  'SELECT * FROM combinations',
  factor => 0.5
);
```

--------------------------------

### Insert data into example edges table

Source: https://docs.pgrouting.org/latest/en/pgr_sloanOrdering.html

Populates the example edges table with vertex connections for the Sloan ordering demonstration.

```sql
INSERT INTO example_edges1 (source, target, cost, reverse_cost) VALUES
(4, 7, 1, 1),
(7, 4, 1, 1),
(7, 9, 1, 1),
(9, 7, 1, 1),
(7, 0, 1, 1),
(0, 7, 1, 1),
(0, 2, 1, 1),
(2, 0, 1, 1),
(2, 5, 1, 1),
(5, 2, 1, 1),
(5, 9, 1, 1),
(9, 5, 1, 1),
(9, 8, 1, 1),
(8, 9, 1, 1),
(9, 1, 1, 1),
(1, 9, 1, 1),
(5, 1, 1, 1),
(1, 5, 1, 1),
(9, 6, 1, 1),
(6, 9, 1, 1),
(6, 3, 1, 1),
(3, 6, 1, 1),
(1, 3, 1, 1),
(3, 1, 1, 1);
```

--------------------------------

### Install compilation dependencies on Linux

Source: https://docs.pgrouting.org/latest/en/pgRouting-installation.html

Install essential build tools and libraries required to compile pgRouting.

```bash
sudo apt install \
   build-essential \
   libboost-graph-dev \
   postgresql-13 \
   postgresql-server-dev-13 \
   postgresql-13-postgis
```

--------------------------------

### Get 2 paths from 6 to 17

Source: https://docs.pgrouting.org/latest/en/pgr_KSP.html

Example of finding the 2 shortest paths between node 6 and node 17 on a directed graph.

```sql
SELECT * FROM pgr_KSP(
  'SELECT id, source, target, cost, reverse_cost FROM edges',
  6, 17, 2);
```

--------------------------------

### Install testing dependencies

Source: https://docs.pgrouting.org/latest/en/pgRouting-installation.html

Install tools required for running pgRouting tests.

```bash
sudo apt install \
   libtap-parser-sourcehandler-pgtap-perl
   postgresql-13-pgtap
```

--------------------------------

### Calculate paths with matching start and end vertices

Source: https://docs.pgrouting.org/latest/en/pgr_aStar.html

Demonstrates the output when the set of start vertices is identical to the set of end vertices.

```sql
SELECT * FROM pgr_aStar(
  'SELECT id, source, target, cost, reverse_cost, x1, y1, x2, y2
  FROM edges',
  ARRAY[7, 10, 15], ARRAY[7, 10, 15]);
 seq | path_seq | start_vid | end_vid | node | edge | cost | agg_cost
-----+----------+-----------+---------+------+------+------+----------
   1 |        1 |         7 |      10 |    7 |    8 |    1 |        0
   2 |        2 |         7 |      10 |   11 |    9 |    1 |        1
   3 |        3 |         7 |      10 |   16 |   16 |    1 |        2
   4 |        4 |         7 |      10 |   15 |    3 |    1 |        3
   5 |        5 |         7 |      10 |   10 |   -1 |    0 |        4
   6 |        1 |         7 |      15 |    7 |    8 |    1 |        0
   7 |        2 |         7 |      15 |   11 |    9 |    1 |        1
   8 |        3 |         7 |      15 |   16 |   16 |    1 |        2
   9 |        4 |         7 |      15 |   15 |   -1 |    0 |        3
  10 |        1 |        10 |       7 |   10 |    5 |    1 |        0
  11 |        2 |        10 |       7 |   11 |    8 |    1 |        1
  12 |        3 |        10 |       7 |    7 |   -1 |    0 |        2
  13 |        1 |        10 |      15 |   10 |    5 |    1 |        0
  14 |        2 |        10 |      15 |   11 |    9 |    1 |        1
  15 |        3 |        10 |      15 |   16 |   16 |    1 |        2
  16 |        4 |        10 |      15 |   15 |   -1 |    0 |        3
  17 |        1 |        15 |       7 |   15 |    3 |    1 |        0
  18 |        2 |        15 |       7 |   10 |    2 |    1 |        1
  19 |        3 |        15 |       7 |    6 |    4 |    1 |        2
  20 |        4 |        15 |       7 |    7 |   -1 |    0 |        3
  21 |        1 |        15 |      10 |   15 |    3 |    1 |        0
  22 |        2 |        15 |      10 |   10 |   -1 |    0 |        1
(22 rows)
```

--------------------------------

### Execute pgr_pickDeliverEuclidean

Source: https://docs.pgrouting.org/latest/en/pgr_pickDeliverEuclidean.html

Example query executing the pick and delivery optimization function.

```sql
SELECT * FROM pgr_pickDeliverEuclidean(
  $$SELECT id, demand,
       p_x, p_y, p_open, p_close, p_service,
       d_x, d_y, d_open, d_close, d_service
    FROM orders$$,
  $$SELECT id, capacity, start_x, start_y, start_open, start_close
    FROM vehicles$$);
 seq | vehicle_seq | vehicle_id | stop_seq | stop_type | order_id | cargo |  travel_time  | arrival_time  | wait_time | service_time | departure_time
-----+-------------+------------+----------+-----------+----------+-------+---------------+---------------+-----------+--------------+----------------
   1 |           1 |          1 |        1 |         1 |       -1 |     0 |             0 |             0 |         0 |            0 |              0
   2 |           1 |          1 |        2 |         2 |        3 |    30 |             1 |             1 |         1 |            3 |              5
   3 |           1 |          1 |        3 |         3 |        3 |     0 | 1.41421356237 | 6.41421356237 |         0 |            3 |  9.41421356237
   4 |           1 |          1 |        4 |         2 |        2 |    20 | 1.41421356237 | 10.8284271247 |         0 |            2 |  12.8284271247
   5 |           1 |          1 |        5 |         3 |        2 |     0 |             1 | 13.8284271247 |         0 |            3 |  16.8284271247
   6 |           1 |          1 |        6 |         6 |       -1 |     0 | 1.41421356237 | 18.2426406871 |         0 |            0 |  18.2426406871
   7 |           2 |          2 |        1 |         1 |       -1 |     0 |             0 |             0 |         0 |            0 |              0
   8 |           2 |          2 |        2 |         2 |        1 |    10 |             1 |             1 |         1 |            3 |              5
   9 |           2 |          2 |        3 |         3 |        1 |     0 |  2.2360679775 |  7.2360679775 |         0 |            3 |  10.2360679775
  10 |           2 |          2 |        4 |         6 |       -1 |     0 |             2 | 12.2360679775 |         0 |            0 |  12.2360679775
  11 |          -2 |          0 |        0 |        -1 |       -1 |    -1 | 11.4787086646 |            -1 |         2 |           17 |  30.4787086646
(11 rows)
```

--------------------------------

### Use identical start and end vertices

Source: https://docs.pgrouting.org/latest/en/pgr_bellmanFord.html

Demonstrates the output when the set of start vertices is identical to the set of end vertices.

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

--------------------------------

### pgr_KSP(Edges SQL, start vids, end vids, K, [options])

Source: https://docs.pgrouting.org/latest/en/pgr_KSP.html

Calculates the K-shortest paths between specified start and end vertices.

```APIDOC
## pgr_KSP(Edges SQL, start vids, end vids, K, [options])

### Description
Computes the K-shortest paths between multiple start and end vertices. Returns a set of records containing path information or an empty set if no paths are found.

### Parameters
- **Edges SQL** (string) - SQL query returning edge information (id, source, target, cost, reverse_cost).
- **start vids** (ARRAY) - Array of starting vertex IDs.
- **end vids** (ARRAY) - Array of ending vertex IDs.
- **K** (integer) - The number of shortest paths to find.
- **options** (ARRAY) - Optional parameters: [directed, heap_paths].

### Returns
- **seq** (integer) - Row sequence.
- **path_id** (integer) - Identifier for the path.
- **path_seq** (integer) - Sequence of the node within the path.
- **start_vid** (integer) - Starting vertex ID.
- **end_vid** (integer) - Ending vertex ID.
- **node** (integer) - Node ID.
- **edge** (integer) - Edge ID.
- **cost** (float) - Cost of the edge.
- **agg_cost** (float) - Aggregated cost along the path.

### Example
```sql
SELECT * FROM pgr_KSP(
  'select id, source, target, cost, reverse_cost from edges',
  ARRAY[6, 1], ARRAY[10, 17], 2);
```
```

--------------------------------

### pgr_KSP(Edges SQL, start vid, end vid, K, [options])

Source: https://docs.pgrouting.org/latest/en/pgr_KSP.html

Calculates the K shortest paths between a single start node and a single end node.

```APIDOC
## pgr_KSP(Edges SQL, start vid, end vid, K, [options])

### Description
Calculates the K shortest paths between a specified start node and end node using Yen's algorithm.

### Parameters
- **Edges SQL** (string) - Required - SQL query returning edge information (id, source, target, cost, reverse_cost).
- **start vid** (integer) - Required - The identifier of the starting node.
- **end vid** (integer) - Required - The identifier of the ending node.
- **K** (integer) - Required - The number of shortest paths to return.
- **options** (string) - Optional - Additional options such as 'directed' or 'heap_paths'.

### Response
Returns a set of rows with columns: (seq, path_id, path_seq, start_vid, end_vid, node, edge, cost, agg_cost).

### Example
```sql
SELECT * FROM pgr_KSP(
  'SELECT id, source, target, cost, reverse_cost FROM edges',
  6, 17, 2);
```
```

--------------------------------

### Verify extension versions

Source: https://docs.pgrouting.org/latest/en/pgRouting-installation.html

Check the installed versions of PostGIS and pgRouting.

```sql
SELECT PostGIS_full_version();
SELECT * FROM pgr_version();
```

--------------------------------

### Querying Sample Data

Source: https://docs.pgrouting.org/latest/en/pgr_lineGraphFull.html

Retrieves the subset of edges used for the transformation example.

```sql
SELECT id, source, target, cost, reverse_cost
FROM edges
WHERE id IN (4, 7, 8, 10);
```

--------------------------------

### Many to Many pgr_bdAstarCost Example

Source: https://docs.pgrouting.org/latest/en/pgr_bdAstarCost.html

Calculate the cost between multiple start and end vertices.

```sql
SELECT * FROM pgr_bdAstarCost(
  'SELECT id, source, target, cost, reverse_cost, x1, y1, x2, y2
  FROM edges',
  ARRAY[6, 8], ARRAY[10, 12],
  factor => 0.5
);
```

--------------------------------

### Get the segments of the crossing geometries

Source: https://docs.pgrouting.org/latest/en/pgr_separateTouching.html

Example usage of pgr_separateTouching to process edges from a table.

```sql
SELECT *
FROM pgr_separateTouching('SELECT id, geom FROM edges');
```

--------------------------------

### Prepare Sample Data

Source: https://docs.pgrouting.org/latest/en/allpairs-family.html

Commands to download OpenStreetMap data and initialize a PostgreSQL database with PostGIS and pgRouting extensions.

```bash
BBOX="-122.8,45.4,-122.5,45.6"
wget --progress=dot:mega -O "sampledata.osm"      "https://www.overpass-api.de/api/xapi?*[bbox=][@meta]"
```

```bash
createdb portland
psql -c "create extension postgis" portland
psql -c "create extension pgrouting" portland
osm2pgrouting -f sampledata.osm -d portland -s 0
```

--------------------------------

### Directed Graph Pathfinding Examples

Source: https://docs.pgrouting.org/latest/en/pgr_dijkstra.html

Demonstrates basic point-to-point pathfinding on directed graphs.

```sql
SELECT * FROM pgr_dijkstra(
  'SELECT id, source, target, cost FROM edges',
  6, 10
);
```

```sql
SELECT * FROM pgr_dijkstra(
  'SELECT id, source, target, cost FROM edges',
  6, 7
);
```

```sql
SELECT * FROM pgr_dijkstra(
  'SELECT id, source, target, cost FROM edges',
  12, 10
);
```

```sql
SELECT * FROM pgr_dijkstra(
  'SELECT id, source, target, cost FROM edges',
  12, 7
);
```

--------------------------------

### One to Many pgr_bdAstarCost Example

Source: https://docs.pgrouting.org/latest/en/pgr_bdAstarCost.html

Calculate the cost from a single start vertex to multiple end vertices.

```sql
SELECT * FROM pgr_bdAstarCost(
  'SELECT id, source, target, cost, reverse_cost, x1, y1, x2, y2
  FROM edges',
  6, ARRAY[10, 12],
  heuristic => 3, factor := 3.5
);
```

--------------------------------

### One to One example using pgr_KSP

Source: https://docs.pgrouting.org/latest/en/migration.html

Demonstrates the updated pgr_KSP output format compared to the legacy column enumeration.

```sql
SELECT * FROM pgr_KSP(
  $$SELECT id, source, target, cost, reverse_cost FROM edges$$,
  6, 17, 2);
 seq | path_id | path_seq | start_vid | end_vid | node | edge | cost | agg_cost
-----+---------+----------+-----------+---------+------+------+------+----------
   1 |       1 |        1 |         6 |      17 |    6 |    4 |    1 |        0
   2 |       1 |        2 |         6 |      17 |    7 |   10 |    1 |        1
   3 |       1 |        3 |         6 |      17 |    8 |   12 |    1 |        2
   4 |       1 |        4 |         6 |      17 |   12 |   13 |    1 |        3
   5 |       1 |        5 |         6 |      17 |   17 |   -1 |    0 |        4
   6 |       2 |        1 |         6 |      17 |    6 |    4 |    1 |        0
   7 |       2 |        2 |         6 |      17 |    7 |    8 |    1 |        1
   8 |       2 |        3 |         6 |      17 |   11 |    9 |    1 |        2
   9 |       2 |        4 |         6 |      17 |   16 |   15 |    1 |        3
  10 |       2 |        5 |         6 |      17 |   17 |   -1 |    0 |        4
(10 rows)
```

```sql
SELECT seq, path_id, path_seq, node, edge, cost, agg_cost FROM pgr_KSP(
  $$SELECT id, source, target, cost, reverse_cost FROM edges$$,
  6, 17, 2);
 seq | path_id | path_seq | node | edge | cost | agg_cost
-----+---------+----------+------+------+------+----------
   1 |       1 |        1 |    6 |    4 |    1 |        0
   2 |       1 |        2 |    7 |   10 |    1 |        1
   3 |       1 |        3 |    8 |   12 |    1 |        2
   4 |       1 |        4 |   12 |   13 |    1 |        3
   5 |       1 |        5 |   17 |   -1 |    0 |        4
   6 |       2 |        1 |    6 |    4 |    1 |        0
   7 |       2 |        2 |    7 |    8 |    1 |        1
   8 |       2 |        3 |   11 |    9 |    1 |        2
   9 |       2 |        4 |   16 |   15 |    1 |        3
  10 |       2 |        5 |   17 |   -1 |    0 |        4
(10 rows)
```

--------------------------------

### Compute MST with Single Root Vertex

Source: https://docs.pgrouting.org/latest/en/pgr_primBFS.html

Example of calculating the Minimum Spanning Tree starting from vertex 6.

```sql
SELECT * FROM pgr_primBFS(
  'SELECT id, source, target, cost, reverse_cost FROM edges ORDER BY id',
  6);
```

--------------------------------

### Undirected Graph Pathfinding Examples

Source: https://docs.pgrouting.org/latest/en/pgr_dijkstra.html

Demonstrates pathfinding on undirected graphs by setting the directed parameter to false.

```sql
SELECT * FROM pgr_dijkstra(
  'SELECT id, source, target, cost FROM edges',
  6, 10,
  false
);
```

```sql
SELECT * FROM pgr_dijkstra(
  'SELECT id, source, target, cost FROM edges',
  6, 7,
  false
);
```

```sql
SELECT * FROM pgr_dijkstra(
  'SELECT id, source, target, cost FROM edges',
  12, 10,
  false
);
```

--------------------------------

### Initialize pgRouting in PostgreSQL

Source: https://docs.pgrouting.org/doxygen

Create a new database and enable the pgRouting extension with cascading dependencies.

```sql
createdb mydatabase
psql mydatabase -c "CREATE EXTENSION pgrouting CASCADE"
```

--------------------------------

### Calculate bandwidth for undirected graph before optimization

Source: https://docs.pgrouting.org/latest/en/pgr_bandwidth.html

Example demonstrating the creation of an edge table and calculating its bandwidth before optimization.

```sql
CREATE TABLE my_edges1 (
    id SERIAL PRIMARY KEY,
    source INTEGER,
    target INTEGER,
    cost DOUBLE PRECISION,
    reverse_cost DOUBLE PRECISION
);
CREATE TABLE
/* -- q3 */
INSERT INTO my_edges1 (source, target, cost, reverse_cost) VALUES
(4, 7, 1, 1),
(7, 4, 1, 1),
(7, 9, 1, 1),
(9, 7, 1, 1),
(7, 0, 1, 1),
(0, 7, 1, 1),
(0, 2, 1, 1),
(2, 0, 1, 1),
(2, 5, 1, 1),
(5, 2, 1, 1),
(5, 9, 1, 1),
(9, 5, 1, 1),
(9, 8, 1, 1),
(8, 9, 1, 1),
(9, 1, 1, 1),
(1, 9, 1, 1),
(5, 1, 1, 1),
(1, 5, 1, 1),
(9, 6, 1, 1),
(6, 9, 1, 1),
(6, 3, 1, 1),
(3, 6, 1, 1),
(1, 3, 1, 1),
(3, 1, 1, 1);
INSERT 0 24
/* -- q4 */
SELECT * FROM pgr_bandwidth(
    'SELECT id, source, target, cost, reverse_cost FROM my_edges1'
);
```

--------------------------------

### Many to Many pgr_bdAstar Example

Source: https://docs.pgrouting.org/latest/en/pgr_bdAstar.html

Calculates paths from a set of start vertices to a set of end vertices on a directed graph.

```sql
SELECT * FROM pgr_bdAstar(
  'SELECT id, source, target, cost, reverse_cost, x1, y1, x2, y2
  FROM edges',
  ARRAY[6, 8], ARRAY[10, 12],
  factor => 0.5
);
```

--------------------------------

### Prepare the pgRouting database

Source: https://docs.pgrouting.org/latest/en/pgRouting-concepts.html

Commands to create a new database and enable the pgRouting extension.

```bash
$ createdb wiki
$ psql wiki
wiki =# CREATE EXTENSION pgRouting CASCADE;
```

--------------------------------

### Directed Graph Advanced Query Examples

Source: https://docs.pgrouting.org/latest/en/pgr_dijkstra.html

Demonstrates advanced pathfinding using arrays for multiple start/end nodes and custom combinations.

```sql
SELECT * FROM pgr_dijkstra(
  'SELECT id, source, target, cost FROM edges',
  6, ARRAY[10,7]
);
```

```sql
SELECT * FROM pgr_dijkstra(
  'SELECT id, source, target, cost FROM edges',
  ARRAY[6,12], 7
);
```

```sql
SELECT * FROM pgr_dijkstra(
  'SELECT id, source, target, cost FROM edges',
  ARRAY[6, 12], ARRAY[10,7]
);
```

```sql
SELECT * FROM pgr_dijkstra(
  'SELECT id, source, target, cost FROM edges',
  'SELECT * FROM (VALUES (6, 10), (6, 7), (12, 10)) AS combinations (source, target)'
);
```

--------------------------------

### Many to One pgr_bdAstarCost Example

Source: https://docs.pgrouting.org/latest/en/pgr_bdAstarCost.html

Calculate the cost from multiple start vertices to a single end vertex on an undirected graph.

```sql
SELECT * FROM pgr_bdAstarCost(
  'SELECT id, source, target, cost, reverse_cost, x1, y1, x2, y2
  FROM edges',
  ARRAY[6, 8], 10,
  false, heuristic => 4
);
```

--------------------------------

### Calculate bandwidth for undirected graph after optimization

Source: https://docs.pgrouting.org/latest/en/pgr_bandwidth.html

Example demonstrating the creation of an edge table and calculating its bandwidth after optimization.

```sql
CREATE TABLE my_edges2 (
    id SERIAL PRIMARY KEY,
    source INTEGER,
    target INTEGER,
    cost DOUBLE PRECISION,
    reverse_cost DOUBLE PRECISION
);
CREATE TABLE
/* -- q6 */
INSERT INTO my_edges2 (source, target, cost, reverse_cost) VALUES
(0, 1, 1, 1),
(1, 0, 1, 1),
(1, 3, 1, 1),
(3, 1, 1, 1),
(1, 2, 1, 1),
(2, 1, 1, 1),
(2, 4, 1, 1),
(4, 2, 1, 1),
(4, 8, 1, 1),
(8, 4, 1, 1),
(8, 3, 1, 1),
(3, 8, 1, 1),
(3, 5, 1, 1),
(5, 3, 1, 1),
(3, 6, 1, 1),
(6, 3, 1, 1),
(3, 7, 1, 1),
(7, 3, 1, 1),
(8, 7, 1, 1),
(7, 8, 1, 1),
(6, 9, 1, 1),
(9, 6, 1, 1),
(7, 9, 1, 1),
(9, 7, 1, 1);
INSERT 0 24
/* -- q7 */
SELECT * FROM pgr_bandwidth(
    'SELECT id, source, target, cost, reverse_cost FROM my_edges2'
);
```

--------------------------------

### One to One pgr_bdAstarCost Example

Source: https://docs.pgrouting.org/latest/en/pgr_bdAstarCost.html

Calculate the cost from a single start vertex to a single end vertex on a directed graph.

```sql
SELECT * FROM pgr_bdAstarCost(
  'SELECT id, source, target, cost, reverse_cost, x1, y1, x2, y2
  FROM edges',
  6, 12,
  directed => true, heuristic => 2
);
```

--------------------------------

### Simulate path calculation with pgr_withPointsVia

Source: https://docs.pgrouting.org/latest/en/pgr_trspVia_withPoints.html

Demonstrates the underlying path calculation logic using pgr_withPointsVia.

```sql
SELECT * FROM pgr_withPointsVia(
  $$SELECT id, source, target, cost, reverse_cost FROM edges ORDER BY id$$,
  $$SELECT pid, edge_id, side, fraction FROM pointsOfInterest$$,
  ARRAY[-6, 15, -5]);
```

--------------------------------

### One to One example using pgr_edgeDisjointPaths

Source: https://docs.pgrouting.org/latest/en/migration.html

Shows the migration of pgr_edgeDisjointPaths output by comparing the new format with the legacy column selection.

```sql
SELECT * FROM pgr_edgeDisjointPaths(
  'SELECT id, source, target, cost, reverse_cost FROM edges',
  11, 12);
 seq | path_id | path_seq | start_vid | end_vid | node | edge | cost | agg_cost
-----+---------+----------+-----------+---------+------+------+------+----------
   1 |       1 |        1 |        11 |      12 |   11 |    8 |    1 |        0
   2 |       1 |        2 |        11 |      12 |    7 |   10 |    1 |        1
   3 |       1 |        3 |        11 |      12 |    8 |   12 |    1 |        2
   4 |       1 |        4 |        11 |      12 |   12 |   -1 |    0 |        3
   5 |       2 |        1 |        11 |      12 |   11 |   11 |    1 |        0
   6 |       2 |        2 |        11 |      12 |   12 |   -1 |    0 |        1
(6 rows)
```

```sql
SELECT seq, path_id, path_seq, node, edge, cost, agg_cost
FROM pgr_edgeDisjointPaths(
  'SELECT id, source, target, cost, reverse_cost FROM edges',
  11, 12);
 seq | path_id | path_seq | node | edge | cost | agg_cost
-----+---------+----------+------+------+------+----------
   1 |       1 |        1 |   11 |    8 |    1 |        0
   2 |       1 |        2 |    7 |   10 |    1 |        1
   3 |       1 |        3 |    8 |   12 |    1 |        2
   4 |       1 |        4 |   12 |   -1 |    0 |        3
   5 |       2 |        1 |   11 |   11 |    1 |        0
   6 |       2 |        2 |   12 |   -1 |    0 |        1
(6 rows)
```

--------------------------------

### Compute MST with Multiple Root Vertices

Source: https://docs.pgrouting.org/latest/en/pgr_primBFS.html

Example of calculating the Minimum Spanning Tree starting from vertices 9 and 6 with a maximum depth constraint of 3.

```sql
SELECT * FROM pgr_primBFS(
  'SELECT id, source, target, cost, reverse_cost FROM edges ORDER BY id',
  ARRAY[9, 6], max_depth => 3);
```

--------------------------------

### Calculate K-Shortest Paths for Multiple Vertices

Source: https://docs.pgrouting.org/latest/en/pgr_KSP.html

This example demonstrates how to find the 2 shortest paths between vertices {6, 1} and {10, 17} on a directed graph.

```sql
SELECT * FROM pgr_KSP(
  'select id, source, target, cost, reverse_cost from edges',
  ARRAY[6, 1], ARRAY[10, 17], 2);
```

--------------------------------

### Execute pgr_KSP query

Source: https://docs.pgrouting.org/latest/en/pgr_KSP.html

Example query demonstrating the usage of pgr_KSP with an edges table and a combinations table to find the 2 shortest paths for each pair.

```sql
SELECT * FROM pgr_KSP(
  'SELECT id, source, target, cost, reverse_cost FROM edges',
  'SELECT source, target FROM combinations', 2);
 seq | path_id | path_seq | start_vid | end_vid | node | edge | cost | agg_cost
-----+---------+----------+-----------+---------+------+------+------+----------
   1 |       1 |        1 |         5 |       6 |    5 |    1 |    1 |        0
   2 |       1 |        2 |         5 |       6 |    6 |   -1 |    0 |        1
   3 |       2 |        1 |         5 |      10 |    5 |    1 |    1 |        0
   4 |       2 |        2 |         5 |      10 |    6 |    4 |    1 |        1
   5 |       2 |        3 |         5 |      10 |    7 |    8 |    1 |        2
   6 |       2 |        4 |         5 |      10 |   11 |    9 |    1 |        3
   7 |       2 |        5 |         5 |      10 |   16 |   16 |    1 |        4
   8 |       2 |        6 |         5 |      10 |   15 |    3 |    1 |        5
   9 |       2 |        7 |         5 |      10 |   10 |   -1 |    0 |        6
  10 |       3 |        1 |         5 |      10 |    5 |    1 |    1 |        0
  11 |       3 |        2 |         5 |      10 |    6 |    4 |    1 |        1
  12 |       3 |        3 |         5 |      10 |    7 |   10 |    1 |        2
  13 |       3 |        4 |         5 |      10 |    8 |   12 |    1 |        3
  14 |       3 |        5 |         5 |      10 |   12 |   13 |    1 |        4
  15 |       3 |        6 |         5 |      10 |   17 |   15 |    1 |        5
  16 |       3 |        7 |         5 |      10 |   16 |   16 |    1 |        6
  17 |       3 |        8 |         5 |      10 |   15 |    3 |    1 |        7
  18 |       3 |        9 |         5 |      10 |   10 |   -1 |    0 |        8
  19 |       4 |        1 |         6 |       5 |    6 |    1 |    1 |        0
  20 |       4 |        2 |         6 |       5 |    5 |   -1 |    0 |        1
  21 |       5 |        1 |         6 |      15 |    6 |    4 |    1 |        0
  22 |       5 |        2 |         6 |      15 |    7 |    8 |    1 |        1
  23 |       5 |        3 |         6 |      15 |   11 |    9 |    1 |        2
  24 |       5 |        4 |         6 |      15 |   16 |   16 |    1 |        3
  25 |       5 |        5 |         6 |      15 |   15 |   -1 |    0 |        4
  26 |       6 |        1 |         6 |      15 |    6 |    4 |    1 |        0
  27 |       6 |        2 |         6 |      15 |    7 |   10 |    1 |        1
  28 |       6 |        3 |         6 |      15 |    8 |   12 |    1 |        2
  29 |       6 |        4 |         6 |      15 |   12 |   13 |    1 |        3
  30 |       6 |        5 |         6 |      15 |   17 |   15 |    1 |        4
  31 |       6 |        6 |         6 |      15 |   16 |   16 |    1 |        5
  32 |       6 |        7 |         6 |      15 |   15 |   -1 |    0 |        6
(32 rows)
```

--------------------------------

### Duplicate Identifier Example 2

Source: https://docs.pgrouting.org/latest/en/pgr_TSPeuclidean.html

Example of how the function handles different coordinates for the same identifier.

```sql
2, 3.5, 1.0
2, 3.6, 1.1
```
Tokens:
Raw