rusqlite-gpkg 0.0.8

GeoPackage reader/writer built on top of rusqlite
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

use crate::error::GpkgError;
use crate::types::ColumnType;

#[inline]
pub(crate) fn geometry_type_to_str(geometry_type: wkb::reader::GeometryType) -> &'static str {
    match geometry_type {
        wkb::reader::GeometryType::GeometryCollection => "GEOMETRYCOLLECTION",
        wkb::reader::GeometryType::Point => "POINT",
        wkb::reader::GeometryType::LineString => "LINESTRING",
        wkb::reader::GeometryType::Polygon => "POLYGON",
        wkb::reader::GeometryType::MultiPoint => "MULTIPOINT",
        wkb::reader::GeometryType::MultiLineString => "MULTILINESTRING",
        wkb::reader::GeometryType::MultiPolygon => "MULTIPOLYGON",
        _ => unreachable!(),
    }
}

#[inline]
pub(crate) fn geometry_type_from_str(
    geometry_type_str: &str,
) -> Result<wkb::reader::GeometryType, GpkgError> {
    let s = geometry_type_str;
    if s.eq_ignore_ascii_case("GEOMETRY") || s.eq_ignore_ascii_case("GEOMETRYCOLLECTION") {
        Ok(wkb::reader::GeometryType::GeometryCollection)
    } else if s.eq_ignore_ascii_case("POINT") {
        Ok(wkb::reader::GeometryType::Point)
    } else if s.eq_ignore_ascii_case("LINESTRING") {
        Ok(wkb::reader::GeometryType::LineString)
    } else if s.eq_ignore_ascii_case("POLYGON") {
        Ok(wkb::reader::GeometryType::Polygon)
    } else if s.eq_ignore_ascii_case("MULTIPOINT") {
        Ok(wkb::reader::GeometryType::MultiPoint)
    } else if s.eq_ignore_ascii_case("MULTILINESTRING") {
        Ok(wkb::reader::GeometryType::MultiLineString)
    } else if s.eq_ignore_ascii_case("MULTIPOLYGON") {
        Ok(wkb::reader::GeometryType::MultiPolygon)
    } else {
        Err(GpkgError::UnsupportedGeometryType(
            geometry_type_str.to_string(),
        ))
    }
}

#[inline]
pub(crate) fn dimension_to_zm(dimension: wkb::reader::Dimension) -> (i8, i8) {
    match dimension {
        wkb::reader::Dimension::Xy => (0, 0),
        wkb::reader::Dimension::Xyz => (1, 0),
        wkb::reader::Dimension::Xym => (0, 1),
        wkb::reader::Dimension::Xyzm => (1, 1),
    }
}

#[inline]
pub(crate) fn dimension_from_zm(z: i8, m: i8) -> Result<wkb::reader::Dimension, GpkgError> {
    match (z, m) {
        (0, 0) => Ok(wkb::reader::Dimension::Xy),
        (1, 0) => Ok(wkb::reader::Dimension::Xyz),
        (0, 1) => Ok(wkb::reader::Dimension::Xym),
        (1, 1) => Ok(wkb::reader::Dimension::Xyzm),
        // Note: the spec says z and m are
        //
        //   0: z/m values prohibited
        //   1: z/m values mandatory
        //   2: z/m values optional
        //
        // but I don't know how 2 can be handled, just treat as an invalid value
        _ => Err(GpkgError::InvalidDimension { z, m }),
    }
}

#[inline]
pub(crate) fn column_type_to_str(column_type: ColumnType) -> &'static str {
    match column_type {
        ColumnType::Integer => "INTEGER",
        ColumnType::Double => "DOUBLE",
        ColumnType::Varchar => "TEXT",
        ColumnType::Boolean => "BOOLEAN",
        ColumnType::Geometry => "GEOMETRY",
        ColumnType::Blob => "BLOB",
        ColumnType::Date => "DATE",
        ColumnType::Datetime => "DATETIME",
    }
}

#[inline]
pub(crate) fn column_type_from_str(column_type_str: &str) -> Option<ColumnType> {
    let s = column_type_str;
    if s.eq_ignore_ascii_case("TINYINT")
        || s.eq_ignore_ascii_case("SMALLINT")
        || s.eq_ignore_ascii_case("MEDIUMINT")
        || s.eq_ignore_ascii_case("INT")
        || s.eq_ignore_ascii_case("INTEGER")
    {
        Some(ColumnType::Integer)
    } else if s.eq_ignore_ascii_case("DOUBLE")
        || s.eq_ignore_ascii_case("FLOAT")
        || s.eq_ignore_ascii_case("REAL")
    {
        Some(ColumnType::Double)
    } else if s.eq_ignore_ascii_case("TEXT") {
        Some(ColumnType::Varchar)
    } else if s.eq_ignore_ascii_case("BOOLEAN") {
        Some(ColumnType::Boolean)
    } else if s.eq_ignore_ascii_case("DATE") {
        Some(ColumnType::Date)
    } else if s.eq_ignore_ascii_case("DATETIME") {
        Some(ColumnType::Datetime)
    } else if s.eq_ignore_ascii_case("BLOB") {
        Some(ColumnType::Blob)
    } else if s.eq_ignore_ascii_case("GEOMETRY")
        || s.eq_ignore_ascii_case("POINT")
        || s.eq_ignore_ascii_case("LINESTRING")
        || s.eq_ignore_ascii_case("POLYGON")
        || s.eq_ignore_ascii_case("MULTIPOINT")
        || s.eq_ignore_ascii_case("MULTILINESTRING")
        || s.eq_ignore_ascii_case("MULTIPOLYGON")
        || s.eq_ignore_ascii_case("GEOMETRYCOLLECTION")
    {
        Some(ColumnType::Geometry)
    } else {
        None
    }
}