mbtiles 0.17.2

A simple low-level MbTiles access and processing library, with some tile format detection and other relevant heuristics.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

#![allow(clippy::unwrap_used)]
use futures::{StreamExt as _, TryStreamExt as _};
use martin_tile_utils::{Tile, TileCoord};
use mbtiles::{MbtError, Mbtiles, create_metadata_table};
use sqlx::{Executor as _, SqliteConnection, query};

fn coord_key(coord: &TileCoord) -> (u8, u32, u32) {
    let TileCoord { z, x, y } = *coord;
    (z, x, y)
}

fn tile_key(tile: &Tile) -> (u8, u32, u32) {
    coord_key(&tile.0)
}

async fn new(rows: &[&str]) -> (Mbtiles, SqliteConnection) {
    let mbtiles = Mbtiles::new(":memory:").unwrap();
    let mut conn = mbtiles.open().await.unwrap();
    create_metadata_table(&mut conn, false).await.unwrap();

    conn.execute(
        "CREATE TABLE tiles (
             zoom_level integer,
             tile_column integer,
             tile_row integer,
             tile_data blob,
             PRIMARY KEY(zoom_level, tile_column, tile_row));",
    )
    .await
    .unwrap();

    for row in rows {
        let sql = format!(
            "INSERT INTO tiles (zoom_level, tile_column, tile_row, tile_data)
            VALUES ({row});"
        );
        query(&sql).execute(&mut conn).await.expect(&sql);
    }

    (mbtiles, conn)
}

#[tokio::test(flavor = "current_thread")]
async fn mbtiles_stream_tiles() {
    let (mbtiles, mut conn) = new(&[
        // Note that `y`-coordinates are inverted.
        "1, 0, 1, CAST('tl' AS BLOB)",
        "1, 1, 0, CAST('br' AS BLOB)",
        "2, 0, 0, NULL",
    ])
    .await;

    {
        let mut coords: Vec<TileCoord> = mbtiles
            .stream_coords(&mut conn)
            .try_collect()
            .await
            .expect("Failed to collect tile coords");

        // Iteration order is not guaranteed.
        coords.sort_by_key(coord_key);

        assert_eq!(
            coords,
            [
                TileCoord { z: 1, x: 0, y: 0 },
                TileCoord { z: 1, x: 1, y: 1 },
                TileCoord { z: 2, x: 0, y: 3 },
            ]
        );
        // counter test: mbtiles must contain all tiles
        let mbt_type = mbtiles.detect_type(&mut conn).await.unwrap();
        for coord in coords {
            assert!(
                mbtiles
                    .contains(&mut conn, mbt_type, coord.z, coord.x, coord.y)
                    .await
                    .unwrap()
            );
        }
        assert!(
            !mbtiles
                .contains(&mut conn, mbt_type, 0, 0, 0)
                .await
                .unwrap()
        );
    }

    {
        let mut tiles: Vec<Tile> = mbtiles
            .stream_tiles(&mut conn)
            .try_collect()
            .await
            .expect("Failed to collect tiles");

        tiles.sort_by_key(tile_key);

        assert_eq!(
            tiles,
            [
                (TileCoord { z: 1, x: 0, y: 0 }, Some(b"tl".to_vec())),
                (TileCoord { z: 1, x: 1, y: 1 }, Some(b"br".to_vec())),
                (TileCoord { z: 2, x: 0, y: 3 }, None),
            ]
        );

        // counter test: mbtiles must contain all tiles
        let mbt_type = mbtiles.detect_type(&mut conn).await.unwrap();
        for (coord, _) in tiles {
            assert!(
                mbtiles
                    .contains(&mut conn, mbt_type, coord.z, coord.x, coord.y)
                    .await
                    .unwrap()
            );
        }
        assert!(
            !mbtiles
                .contains(&mut conn, mbt_type, 0, 0, 0)
                .await
                .unwrap()
        );
    }
}

#[tokio::test(flavor = "current_thread")]
async fn mbtiles_stream_errors() {
    let (mbtiles, mut conn) = new(&[
        // Note that `y`-coordinates are inverted.
        // `4` is an invalid value for `x` at `z = 2`. A valid range is `0..=3`.
        "2, 4, 0, NULL",
    ])
    .await;

    {
        let mut stream = mbtiles.stream_coords(&mut conn);
        match stream.next().await {
            Some(Err(MbtError::InvalidTileIndex(..))) => {}
            _ => panic!("Unexpected value returned from stream!"),
        }
    }

    // Counter test: mbtiles must contain all tiles
    // the re-inverted y coordinate yielding 4 would be -1.
    // This is impossible to achieve without overflows.
    let mbt_type = mbtiles.detect_type(&mut conn).await.unwrap();
    for y in 0..=20 {
        assert!(
            !mbtiles
                .contains(&mut conn, mbt_type, 2, y, 0)
                .await
                .unwrap()
        );
    }
}