WIP: ODBC

Author: georgestagg

ggsql-jupyter/src/connection.rs

@@ -65,7 +65,8 @@ fn list_catalogs(reader: &dyn Reader) -> Result<Vec<ObjectSchema>, String> {
 
     let col = df
         .column("catalog_name")
-        .map_err(|e| format!("Missing catalog_name column: {}", e))?;
+        .or_else(|_| df.column("name"))
+        .map_err(|e| format!("Missing catalog_name/name column: {}", e))?;
 
     let mut catalogs = Vec::new();
     for i in 0..df.height() {
@@ -88,7 +89,8 @@ fn list_schemas(reader: &dyn Reader, catalog: &str) -> Result<Vec<ObjectSchema>,
 
     let col = df
         .column("schema_name")
-        .map_err(|e| format!("Missing schema_name column: {}", e))?;
+        .or_else(|_| df.column("name"))
+        .map_err(|e| format!("Missing schema_name/name column: {}", e))?;
 
     let mut schemas = Vec::new();
     for i in 0..df.height() {
@@ -115,10 +117,12 @@ fn list_tables(
 
     let name_col = df
         .column("table_name")
-        .map_err(|e| format!("Missing table_name column: {}", e))?;
+        .or_else(|_| df.column("name"))
+        .map_err(|e| format!("Missing table_name/name column: {}", e))?;
     let type_col = df
         .column("table_type")
-        .map_err(|e| format!("Missing table_type column: {}", e))?;
+        .or_else(|_| df.column("kind"))
+        .map_err(|e| format!("Missing table_type/kind column: {}", e))?;
 
     let mut objects = Vec::new();
     for i in 0..df.height() {

src/reader/odbc.rs

@@ -38,12 +38,7 @@ pub enum OdbcVariant {
 impl super::SqlDialect for OdbcDialect {
     fn sql_list_catalogs(&self) -> String {
         match self.variant {
-            OdbcVariant::Snowflake => {
-                "SELECT database_name AS catalog_name \
-                 FROM snowflake.information_schema.databases \
-                 ORDER BY database_name"
-                    .into()
-            }
+            OdbcVariant::Snowflake => "SHOW DATABASES".into(),
             _ => {
                 "SELECT DISTINCT catalog_name FROM information_schema.schemata \
                  ORDER BY catalog_name"
@@ -53,17 +48,13 @@ impl super::SqlDialect for OdbcDialect {
     }
 
     fn sql_list_schemas(&self, catalog: &str) -> String {
-        let catalog = catalog.replace('\'', "''");
         match self.variant {
             OdbcVariant::Snowflake => {
                 let catalog_ident = catalog.replace('"', "\"\"");
-                format!(
-                    "SELECT schema_name \
-                     FROM \"{catalog_ident}\".information_schema.schemata \
-                     ORDER BY schema_name"
-                )
+                format!("SHOW SCHEMAS IN DATABASE \"{catalog_ident}\"")
             }
             _ => {
+                let catalog = catalog.replace('\'', "''");
                 format!(
                     "SELECT DISTINCT schema_name FROM information_schema.schemata \
                      WHERE catalog_name = '{catalog}' ORDER BY schema_name"
@@ -73,19 +64,17 @@ impl super::SqlDialect for OdbcDialect {
     }
 
     fn sql_list_tables(&self, catalog: &str, schema: &str) -> String {
-        let schema = schema.replace('\'', "''");
         match self.variant {
             OdbcVariant::Snowflake => {
                 let catalog_ident = catalog.replace('"', "\"\"");
+                let schema_ident = schema.replace('"', "\"\"");
                 format!(
-                    "SELECT table_name, table_type \
-                     FROM \"{catalog_ident}\".information_schema.tables \
-                     WHERE table_schema = '{schema}' \
-                     ORDER BY table_name"
+                    "SHOW OBJECTS IN SCHEMA \"{catalog_ident}\".\"{schema_ident}\""
                 )
             }
             _ => {
                 let catalog = catalog.replace('\'', "''");
+                let schema = schema.replace('\'', "''");
                 format!(
                     "SELECT DISTINCT table_name, table_type FROM information_schema.tables \
                      WHERE table_catalog = '{catalog}' AND table_schema = '{schema}' \
@@ -96,20 +85,19 @@ impl super::SqlDialect for OdbcDialect {
     }
 
     fn sql_list_columns(&self, catalog: &str, schema: &str, table: &str) -> String {
-        let schema = schema.replace('\'', "''");
-        let table = table.replace('\'', "''");
         match self.variant {
             OdbcVariant::Snowflake => {
                 let catalog_ident = catalog.replace('"', "\"\"");
+                let schema_ident = schema.replace('"', "\"\"");
+                let table_ident = table.replace('"', "\"\"");
                 format!(
-                    "SELECT column_name, data_type \
-                     FROM \"{catalog_ident}\".information_schema.columns \
-                     WHERE table_schema = '{schema}' AND table_name = '{table}' \
-                     ORDER BY ordinal_position"
+                    "SHOW COLUMNS IN TABLE \"{catalog_ident}\".\"{schema_ident}\".\"{table_ident}\""
                 )
             }
             _ => {
                 let catalog = catalog.replace('\'', "''");
+                let schema = schema.replace('\'', "''");
+                let table = table.replace('\'', "''");
                 format!(
                     "SELECT column_name, data_type FROM information_schema.columns \
                      WHERE table_catalog = '{catalog}' AND table_schema = '{schema}' \