Add basic copying functionality

martin-mbtiles/src/bin/main.rs

@@ -2,7 +2,7 @@ use std::path::{Path, PathBuf};
 
 use anyhow::Result;
 use clap::{Parser, Subcommand};
-use martin_mbtiles::Mbtiles;
+use martin_mbtiles::{Mbtiles, TileCopier, TileCopierOptions};
 use sqlx::sqlite::SqliteConnectOptions;
 use sqlx::{Connection, SqliteConnection};
 
@@ -39,13 +39,26 @@ enum Commands {
     //     /// MBTiles file to modify
     //     file: PathBuf,
     // },
-    // /// Copy tiles from one mbtiles file to another.
-    // Copy {
-    //     /// MBTiles file to read from
-    //     src_file: PathBuf,
-    //     /// MBTiles file to write to
-    //     dst_file: PathBuf,
-    // },
+    /// Copy tiles from one mbtiles file to another.
+    #[command(name = "copy")]
+    Copy {
+        /// MBTiles file to read from
+        src_file: PathBuf,
+        /// MBTiles file to write to
+        dst_file: PathBuf,
+        /// Display detailed copying information
+        #[arg(short, long)]
+        verbose: bool,
+        /// Minimum zoom level to copy
+        #[arg(long)]
+        min_zoom: Option<u8>,
+        /// Maximum zoom level to copy
+        #[arg(long)]
+        max_zoom: Option<u8>,
+        /// List of zoom levels to copy; if provided, min-zoom and max-zoom will be ignored
+        #[arg(long, value_delimiter(','))]
+        zoom_levels: Vec<u8>,
+    },
 }
 
 #[tokio::main]
@@ -56,6 +69,27 @@ async fn main() -> Result<()> {
         Commands::MetaGetValue { file, key } => {
             meta_get_value(file.as_path(), &key).await?;
         }
+        Commands::Copy {
+            src_file,
+            dst_file,
+            verbose,
+            min_zoom,
+            max_zoom,
+            zoom_levels,
+        } => {
+            let mut tile_copier_options =
+                TileCopierOptions::new().verbose(verbose).zooms(zoom_levels);
+            if let Some(v) = min_zoom {
+                tile_copier_options = tile_copier_options.min_zoom(v);
+            };
+            if let Some(v) = max_zoom {
+                tile_copier_options = tile_copier_options.max_zoom(v);
+            };
+
+            let tile_copier = TileCopier::new(src_file, dst_file, tile_copier_options)?;
+
+            tile_copier.run().await?;
+        }
     }
 
     Ok(())

martin-mbtiles/src/errors.rs

@@ -13,11 +13,17 @@ pub enum MbtError {
     #[error("Inconsistent tile formats detected: {0} vs {1}")]
     InconsistentMetadata(TileInfo, TileInfo),
 
-    #[error("Invalid data storage format for MBTile file {0}")]
-    InvalidDataStorageFormat(String),
+    #[error("Invalid data format for MBTile file {0}")]
+    InvalidDataFormat(String),
+
+    #[error(r#"Filename "{0}" passed to SQLite must be valid UTF-8"#)]
+    InvalidFilenameType(PathBuf),
 
     #[error("No tiles found")]
     NoTilesFound,
+
+    #[error("The destination file {0} is non-empty")]
+    NonEmptyTargetFile(PathBuf),
 }
 
 pub type MbtResult<T> = Result<T, MbtError>;

martin-mbtiles/src/lib.rs

@@ -4,7 +4,9 @@ mod errors;
 mod mbtiles;
 mod mbtiles_pool;
 mod mbtiles_queries;
+mod tile_copier;
 
 pub use errors::MbtError;
 pub use mbtiles::{Mbtiles, Metadata};
 pub use mbtiles_pool::MbtilesPool;
+pub use tile_copier::{TileCopier, TileCopierOptions};

martin-mbtiles/src/mbtiles.rs

@@ -285,7 +285,7 @@ impl Mbtiles {
         } else if is_tile_tables_type(&mut *conn).await? {
             Ok(Type::TileTables)
         } else {
-            Err(MbtError::InvalidDataStorageFormat(self.filepath.clone()))
+            Err(MbtError::InvalidDataFormat(self.filepath.clone()))
         }
     }
 }
@@ -392,6 +392,6 @@ mod tests {
 
         let (mut conn, mbt) = open(":memory:").await;
         let res = mbt.detect_type(&mut conn).await;
-        assert!(matches!(res, Err(MbtError::InvalidDataStorageFormat(_))));
+        assert!(matches!(res, Err(MbtError::InvalidDataFormat(_))));
     }
 }

martin-mbtiles/src/tile_copier.rs

@@ -0,0 +1,202 @@
+extern crate core;
+
+use crate::errors::MbtResult;
+use crate::mbtiles::Type;
+use crate::{MbtError, Mbtiles};
+use sqlx::sqlite::SqliteConnectOptions;
+use sqlx::{query, Connection, Row, SqliteConnection};
+use std::collections::HashSet;
+use std::path::PathBuf;
+
+#[derive(Clone, Default, Debug)]
+pub struct TileCopierOptions {
+    zooms: HashSet<u8>,
+    min_zoom: Option<u8>,
+    max_zoom: Option<u8>,
+    //self.bbox = bbox
+    verbose: bool,
+}
+
+#[derive(Clone, Debug)]
+pub struct TileCopier {
+    src_mbtiles: Mbtiles,
+    dst_filepath: PathBuf,
+    options: TileCopierOptions,
+}
+
+impl TileCopierOptions {
+    pub fn new() -> Self {
+        Self {
+            zooms: HashSet::new(),
+            min_zoom: None,
+            max_zoom: None,
+            verbose: false,
+        }
+    }
+
+    pub fn zooms(mut self, zooms: Vec<u8>) -> Self {
+        for zoom in zooms {
+            self.zooms.insert(zoom);
+        }
+        self
+    }
+
+    pub fn min_zoom(mut self, min_zoom: u8) -> Self {
+        self.min_zoom = Some(min_zoom);
+        self
+    }
+
+    pub fn max_zoom(mut self, max_zoom: u8) -> Self {
+        self.max_zoom = Some(max_zoom);
+        self
+    }
+
+    pub fn verbose(mut self, verbose: bool) -> Self {
+        self.verbose = verbose;
+        self
+    }
+}
+impl TileCopier {
+    pub fn new(
+        src_filepath: PathBuf,
+        dst_filepath: PathBuf,
+        options: TileCopierOptions,
+    ) -> MbtResult<Self> {
+        Ok(TileCopier {
+            src_mbtiles: Mbtiles::new(src_filepath)?,
+            dst_filepath,
+            options,
+        })
+    }
+
+    pub async fn run(self) -> MbtResult<()> {
+        let opt = SqliteConnectOptions::new()
+            .read_only(true)
+            .filename(PathBuf::from(&self.src_mbtiles.filepath()));
+        let mut conn = SqliteConnection::connect_with(&opt).await?;
+        let storage_type = self.src_mbtiles.detect_type(&mut conn).await?;
+
+        let opt = SqliteConnectOptions::new()
+            .create_if_missing(true)
+            .filename(&self.dst_filepath);
+        let mut conn = SqliteConnection::connect_with(&opt).await?;
+
+        if query("SELECT 1 FROM sqlite_schema LIMIT 1")
+            .fetch_optional(&mut conn)
+            .await?
+            .is_some()
+        {
+            return Err(MbtError::NonEmptyTargetFile(self.dst_filepath.clone()));
+        }
+
+        query("PRAGMA page_size = 512").execute(&mut conn).await?;
+        query("VACUUM").execute(&mut conn).await?;
+
+        query("ATTACH DATABASE ? AS sourceDb")
+            .bind(self.src_mbtiles.filepath())
+            .execute(&mut conn)
+            .await?;
+
+        let schema = query("SELECT sql FROM sourceDb.sqlite_schema WHERE tbl_name IN ('metadata', 'tiles', 'map', 'images')")
+            .fetch_all(&mut conn)
+            .await?;
+
+        for row in &schema {
+            let row: String = row.get(0);
+            query(row.as_str()).execute(&mut conn).await?;
+        }
+
+        query("INSERT INTO metadata SELECT * FROM sourceDb.metadata")
+            .execute(&mut conn)
+            .await?;
+
+        match storage_type {
+            Type::TileTables => self.copy_standard_compliant_tiles(&mut conn).await,
+            Type::DeDuplicated => self.copy_deduplicated_tiles(&mut conn).await,
+        }
+    }
+
+    async fn copy_standard_compliant_tiles(&self, conn: &mut SqliteConnection) -> MbtResult<()> {
+        // TODO: Handle options
+        //  - bbox
+        //  - verbose
+        //  - zoom
+
+        self.run_query_with_options(
+            conn,
+            String::from("INSERT INTO tiles SELECT * FROM sourceDb.tiles"),
+        )
+        .await?;
+
+        Ok(())
+    }
+
+    async fn copy_deduplicated_tiles(&self, conn: &mut SqliteConnection) -> MbtResult<()> {
+        query("INSERT INTO map SELECT * FROM sourceDb.map")
+            .execute(&mut *conn)
+            .await?;
+
+        self.run_query_with_options(
+            conn,
+            String::from(
+                "INSERT INTO images
+                SELECT images.tile_data, images.tile_id
+                FROM sourceDb.images
+                  JOIN sourceDb.map
+                  ON images.tile_id = map.tile_id",
+            ),
+        )
+        .await?;
+
+        Ok(())
+    }
+
+    async fn run_query_with_options(
+        &self,
+        conn: &mut SqliteConnection,
+        mut sql: String,
+    ) -> MbtResult<()> {
+        let mut params: Vec<String> = vec![];
+
+        if !&self.options.zooms.is_empty() {
+            sql.push_str(
+                format!(
+                    " WHERE zoom_level IN ({})",
+                    vec!["?"; self.options.zooms.len()].join(",")
+                )
+                .as_str(),
+            );
+            for zoom_level in &self.options.zooms {
+                params.push(zoom_level.to_string());
+            }
+        } else if let Some(min_zoom) = &self.options.min_zoom {
+            if let Some(max_zoom) = &self.options.max_zoom {
+                sql.push_str(" WHERE zoom_level BETWEEN ? AND ?");
+
+                params.push(min_zoom.to_string());
+                params.push(max_zoom.to_string());
+            } else {
+                sql.push_str(" WHERE zoom_level >= ? ");
+
+                params.push(min_zoom.to_string());
+            }
+        } else if let Some(max_zoom) = &self.options.max_zoom {
+            sql.push_str(" WHERE zoom_level <= ? ");
+
+            params.push(max_zoom.to_string());
+        }
+
+        let mut query = query(sql.as_str());
+
+        for param in params {
+            query = query.bind(param);
+        }
+
+        query.execute(conn).await?;
+
+        Ok(())
+    }
+}
+
+// TODO: tests
+// TODO: documentation