Add Snowflake support in database handling and enhance logging

- Introduced Snowflake as a supported database in the enum and related logic.
- Updated SQL table creation to include Snowflake-specific syntax.
- Enhanced logging for file modification checks in both local and database contexts.

Author: lovasoa

src/filesystem.rs

@@ -45,6 +45,10 @@ impl FileSystem {
     ) -> anyhow::Result<bool> {
         let local_path = self.safe_local_path(app_state, path, priviledged)?;
         let local_result = file_modified_since_local(&local_path, since).await;
+        log::trace!(
+            "Local file {} modified since {since:?} ? {local_result:?}",
+            local_path.display()
+        );
         match (local_result, &self.db_fs_queries) {
             (Ok(modified), _) => Ok(modified),
             (Err(e), Some(db_fs)) if e.kind() == ErrorKind::NotFound => {
@@ -212,6 +216,7 @@ impl DbFsQueries {
         match dbms {
             SupportedDatabase::Mssql => "CREATE TABLE sqlpage_files(path NVARCHAR(255) NOT NULL PRIMARY KEY, contents VARBINARY(MAX), last_modified DATETIME2(3) NOT NULL DEFAULT CURRENT_TIMESTAMP);",
             SupportedDatabase::Postgres => "CREATE TABLE IF NOT EXISTS sqlpage_files(path VARCHAR(255) NOT NULL PRIMARY KEY, contents BYTEA, last_modified TIMESTAMP DEFAULT CURRENT_TIMESTAMP);",
+            SupportedDatabase::Snowflake => "CREATE TABLE IF NOT EXISTS sqlpage_files(path VARCHAR(255) NOT NULL PRIMARY KEY, contents VARBINARY, last_modified TIMESTAMP DEFAULT CURRENT_TIMESTAMP);",
             _ => "CREATE TABLE IF NOT EXISTS sqlpage_files(path VARCHAR(255) NOT NULL PRIMARY KEY, contents BLOB, last_modified TIMESTAMP DEFAULT CURRENT_TIMESTAMP);",
         }
     }
@@ -278,16 +283,20 @@ impl DbFsQueries {
             self.was_modified.sql(),
             (since, path)
         );
-        query
+        let was_modified_i32 = query
             .fetch_optional(&app_state.db.connection)
             .await
-            .map(|modified| modified == Some((1,)))
             .with_context(|| {
                 format!(
                     "Unable to check when {} was last modified in the database",
                     path.display()
                 )
-            })
+            })?;
+        log::trace!(
+            "DB File {} was modified result: {was_modified_i32:?}",
+            path.display()
+        );
+        Ok(was_modified_i32 == Some((1,)))
     }
 
     async fn read_file(&self, app_state: &AppState, path: &Path) -> anyhow::Result<Vec<u8>> {
@@ -345,6 +354,7 @@ async fn test_sql_file_read_utf8() -> anyhow::Result<()> {
     let db = &state.db;
     let conn = &db.connection;
     conn.execute("DROP TABLE IF EXISTS sqlpage_files").await?;
+    log::debug!("Creating table sqlpage_files: {create_table_sql}");
     conn.execute(create_table_sql).await?;
 
     let dbms = db.info.kind;

src/webserver/database/mod.rs

@@ -22,6 +22,7 @@ pub enum SupportedDatabase {
     Postgres,
     MySql,
     Mssql,
+    Snowflake,
     Generic,
 }
 
@@ -34,6 +35,7 @@ impl SupportedDatabase {
             "postgres" | "postgresql" => Self::Postgres,
             "mysql" | "mariadb" => Self::MySql,
             "mssql" | "sql server" | "microsoft sql server" => Self::Mssql,
+            "snowflake" => Self::Snowflake,
             _ => Self::Generic,
         }
     }
@@ -46,6 +48,7 @@ impl SupportedDatabase {
             Self::Postgres => "PostgreSQL",
             Self::MySql => "MySQL",
             Self::Mssql => "Microsoft SQL Server",
+            Self::Snowflake => "Snowflake",
             Self::Generic => "Generic",
         }
     }

src/webserver/database/sql.rs

@@ -15,7 +15,9 @@ use sqlparser::ast::{
     SelectFlavor, SelectItem, Set, SetExpr, Spanned, Statement, Value, ValueWithSpan, Visit,
     VisitMut, Visitor, VisitorMut,
 };
-use sqlparser::dialect::{Dialect, MsSqlDialect, MySqlDialect, PostgreSqlDialect, SQLiteDialect};
+use sqlparser::dialect::{
+    Dialect, MsSqlDialect, MySqlDialect, PostgreSqlDialect, SQLiteDialect, SnowflakeDialect,
+};
 use sqlparser::parser::{Parser, ParserError};
 use sqlparser::tokenizer::Token::{self, SemiColon, EOF};
 use sqlparser::tokenizer::{TokenWithSpan, Tokenizer};
@@ -248,6 +250,7 @@ fn dialect_for_db(dbms: SupportedDatabase) -> Box<dyn Dialect> {
         SupportedDatabase::Mssql => Box::new(MsSqlDialect {}),
         SupportedDatabase::MySql => Box::new(MySqlDialect {}),
         SupportedDatabase::Sqlite => Box::new(SQLiteDialect {}),
+        SupportedDatabase::Snowflake => Box::new(SnowflakeDialect {}),
     }
 }
 
@@ -1137,15 +1140,15 @@ mod test {
     ];
 
     fn create_test_db_info(database_type: SupportedDatabase) -> DbInfo {
-        let (dbms_name, kind) = match database_type {
-            SupportedDatabase::Postgres => ("PostgreSQL".to_string(), AnyKind::Postgres),
-            SupportedDatabase::Mssql => ("Microsoft SQL Server".to_string(), AnyKind::Mssql),
-            SupportedDatabase::MySql => ("MySQL".to_string(), AnyKind::MySql),
-            SupportedDatabase::Sqlite => ("SQLite".to_string(), AnyKind::Sqlite),
-            SupportedDatabase::Generic => ("Generic".to_string(), AnyKind::Postgres), // fallback
+        let kind = match database_type {
+            SupportedDatabase::Postgres => AnyKind::Postgres,
+            SupportedDatabase::Mssql => AnyKind::Mssql,
+            SupportedDatabase::MySql => AnyKind::MySql,
+            SupportedDatabase::Sqlite => AnyKind::Sqlite,
+            _ => AnyKind::Odbc,
         };
         DbInfo {
-            dbms_name,
+            dbms_name: database_type.display_name().to_string(),
             database_type,
             kind,
         }