Struct GpkgLayer 

pub struct GpkgLayer {
    pub layer_name: String,
    pub geometry_column: String,
    pub primary_key_column: String,
    pub geometry_type: GeometryType,
    pub geometry_dimension: Dimension,
    pub srs_id: u32,
    pub property_columns: Vec<ColumnSpec>,
    /* private fields */
}

A GeoPackage layer with geometry metadata and column specs.

Fields

layer_name: String

geometry_column: String

primary_key_column: String

geometry_type: GeometryType

geometry_dimension: Dimension

srs_id: u32

property_columns: Vec<ColumnSpec>

Implementations

impl GpkgLayer

pub fn features(&self) -> Result<Vec<GpkgFeature>>

Return all the features in the layer.

Example:

use rusqlite_gpkg::Gpkg;

let gpkg = Gpkg::open_read_only("data/example.gpkg")?;
let layer = gpkg.get_layer("points")?;
for feature in layer.features()? {
    let _id = feature.id();
    let _geom = feature.geometry()?;
}

Why does this return a vector instead of an iterator?

I was hoping we could avoid allocation here, but it seems rusqlite’s API requires allocation.

pub fn features_batch<'a>( &'a self, batch_size: u32, ) -> Result<GpkgFeatureBatchIterator<'a>>

Return an iterator that yields features in batches.

This is intended for large layers where allocating a single Vec<GpkgFeature> could be expensive. Each iterator item is a Vec<GpkgFeature> with up to batch_size features.

Example:

use rusqlite_gpkg::Gpkg;

let gpkg = Gpkg::open_read_only("data/example.gpkg")?;
let layer = gpkg.get_layer("points")?;
for batch in layer.features_batch(100)? {
    let features = batch?;
    for feature in features {
        let _id = feature.id();
        let _geom = feature.geometry()?;
    }
}

pub fn truncate(&self) -> Result<usize>

Remove all rows from the layer.

Example:

use rusqlite_gpkg::Gpkg;

let gpkg = Gpkg::open("data/example.gpkg")?;
let layer = gpkg.get_layer("points")?;
layer.truncate()?;

pub fn insert<'p, G, P>(&self, geometry: G, properties: P) -> Result<()>

where G: GeometryTrait<T = f64>, P: IntoIterator<Item = &'p Value>,

Insert a feature with geometry and ordered property values.

Example:

use geo_types::Point;
use rusqlite_gpkg::{Gpkg, params};

let gpkg = Gpkg::open("data/example.gpkg")?;
let layer = gpkg.get_layer("points")?;

layer.insert(Point::new(1.0, 2.0), params!["alpha", 1])?;

pub fn update<'p, G, P>( &self, geometry: G, properties: P, id: i64, ) -> Result<()>

where G: GeometryTrait<T = f64>, P: IntoIterator<Item = &'p Value>,

Update the feature with geometry and ordered property values.

Example:

use geo_types::Point;
use rusqlite_gpkg::{Gpkg, params};

let gpkg = Gpkg::open("data/example.gpkg")?;
let layer = gpkg.get_layer("points")?;
layer.update(Point::new(3.0, 4.0), params!["beta", false], 1)?;

Trait Implementations

impl Debug for GpkgLayer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.