feat: Prod Promotion -- v0.3.0

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "pg_analytics"
 description = "Postgres for analytics, powered by DuckDB"
-version = "0.2.4"
+version = "0.3.0"
 edition = "2021"
 license = "PostgreSQL"
 

sql/pg_analytics--0.2.4--0.3.0.sql

@@ -0,0 +1 @@
+\echo Use "ALTER EXTENSION pg_analytics UPDATE TO '0.3.0'" to load this file. \quit

src/api/duckdb.rs

@@ -11,6 +11,18 @@ type DuckdbSettingsRow = (
     Option<String>,
 );
 
+type DuckdbExtensionsRow = (
+    Option<String>,
+    Option<bool>,
+    Option<bool>,
+    Option<String>,
+    Option<String>,
+    Option<String>,
+    Option<String>,
+    Option<String>,
+    Option<String>,
+);
+
 #[pg_extern]
 pub fn duckdb_execute(query: &str) {
     connection::execute(query, []).unwrap_or_else(|err| panic!("error executing query: {err:?}"));
@@ -52,3 +64,61 @@ fn duckdb_settings_impl() -> Result<Vec<DuckdbSettingsRow>> {
         .map(|row| row.unwrap())
         .collect::<Vec<DuckdbSettingsRow>>())
 }
+
+#[allow(clippy::type_complexity)]
+#[pg_extern]
+pub fn duckdb_extensions() -> iter::TableIterator<
+    'static,
+    (
+        name!(extension_name, Option<String>),
+        name!(loaded, Option<bool>),
+        name!(installed, Option<bool>),
+        name!(install_path, Option<String>),
+        name!(description, Option<String>),
+        name!(aliases, Option<String>),
+        name!(extension_version, Option<String>),
+        name!(install_mode, Option<String>),
+        name!(installed_from, Option<String>),
+    ),
+> {
+    let rows = duckdb_extensions_impl().unwrap_or_else(|e| {
+        panic!("{}", e);
+    });
+    iter::TableIterator::new(rows)
+}
+
+#[inline]
+fn duckdb_extensions_impl() -> Result<Vec<DuckdbExtensionsRow>> {
+    let conn = unsafe { &*connection::get_global_connection().get() };
+    let mut stmt = conn.prepare(
+        "SELECT
+            extension_name,
+            loaded,
+            installed,
+            install_path,
+            description,
+            aliases::varchar,
+            extension_version,
+            install_mode,
+            installed_from
+        FROM
+            duckdb_extensions();",
+    )?;
+
+    Ok(stmt
+        .query_map([], |row| {
+            Ok((
+                row.get::<_, Option<String>>(0)?,
+                row.get::<_, Option<bool>>(1)?,
+                row.get::<_, Option<bool>>(2)?,
+                row.get::<_, Option<String>>(3)?,
+                row.get::<_, Option<String>>(4)?,
+                row.get::<_, Option<String>>(5)?,
+                row.get::<_, Option<String>>(6)?,
+                row.get::<_, Option<String>>(7)?,
+                row.get::<_, Option<String>>(8)?,
+            ))
+        })?
+        .map(|row| row.unwrap())
+        .collect::<Vec<DuckdbExtensionsRow>>())
+}

src/hooks/utility.rs

@@ -55,7 +55,9 @@ pub async fn process_utility_hook(
 ) -> Result<()> {
     let stmt_type = unsafe { (*pstmt.utilityStmt).type_ };
 
-    if !is_support_utility(stmt_type) {
+    // IsPostmasterEnvironment is false when it is false in a standalone process (bootstrap or
+    // standalone backend).
+    if !is_support_utility(stmt_type) || unsafe { !pg_sys::IsPostmasterEnvironment } {
         prev_hook(
             pstmt,
             query_string,

src/hooks/utility/view.rs

@@ -83,14 +83,16 @@ pub fn view_query(
             if (*planned_stmt).commandType != pg_sys::CmdType::CMD_SELECT
                 || !is_duckdb_query(&query_relations)
             {
-                fallback_warning!("Some relations are not in DuckDB");
                 return Ok(true);
             }
         }
     }
 
     // Push down the view creation query to DuckDB
     set_search_path_by_pg()?;
-    execute(query_string.to_str()?, [])?;
+    if let Err(e) = execute(query_string.to_str()?, []) {
+        fallback_warning!(e.to_string());
+    }
+
     Ok(true)
 }

src/schema/cell.rs

@@ -327,6 +327,118 @@ where
     }
 }
 
+pub trait GetListValue
+where
+    Self: Array + AsArray,
+{
+    fn get_list_value(&self, index: usize) -> Result<Option<datum::JsonB>> {
+        let downcast_array = self.as_list::<i32>();
+
+        if downcast_array.nulls().is_some() && downcast_array.is_null(index) {
+            return Ok(None);
+        }
+
+        match downcast_array.value_type() {
+            DataType::Boolean => {
+                let list_array: ArrayRef = Arc::new(downcast_array.clone());
+                let values = list_array
+                    .get_primitive_list_value::<BooleanArray, Option<bool>>(index)?
+                    .map_or(vec![], |arr| {
+                        arr.into_iter()
+                            .map(|opt| opt.map_or(Value::Null, Value::from))
+                            .collect()
+                    });
+                Ok(Some(datum::JsonB(Value::Array(values))))
+            }
+            DataType::Int8 => {
+                let list_array: ArrayRef = Arc::new(downcast_array.clone());
+                let values = list_array
+                    .get_primitive_list_value::<Int8Array, Option<i8>>(index)?
+                    .map_or(vec![], |arr| {
+                        arr.into_iter()
+                            .map(|opt| opt.map_or(Value::Null, |v| Value::Number(Number::from(v))))
+                            .collect()
+                    });
+                Ok(Some(datum::JsonB(Value::Array(values))))
+            }
+            DataType::Int16 => {
+                let list_array: ArrayRef = Arc::new(downcast_array.clone());
+                let values = list_array
+                    .get_primitive_list_value::<Int16Array, Option<i16>>(index)?
+                    .map_or(vec![], |arr| {
+                        arr.into_iter()
+                            .map(|opt| opt.map_or(Value::Null, |v| Value::Number(Number::from(v))))
+                            .collect()
+                    });
+                Ok(Some(datum::JsonB(Value::Array(values))))
+            }
+            DataType::Int32 => {
+                let list_array: ArrayRef = Arc::new(downcast_array.clone());
+                let values = list_array
+                    .get_primitive_list_value::<Int32Array, Option<i32>>(index)?
+                    .map_or(vec![], |arr| {
+                        arr.into_iter()
+                            .map(|opt| opt.map_or(Value::Null, |v| Value::Number(Number::from(v))))
+                            .collect()
+                    });
+                Ok(Some(datum::JsonB(Value::Array(values))))
+            }
+            DataType::Int64 => {
+                let list_array: ArrayRef = Arc::new(downcast_array.clone());
+                let values = list_array
+                    .get_primitive_list_value::<Int64Array, Option<i64>>(index)?
+                    .map_or(vec![], |arr| {
+                        arr.into_iter()
+                            .map(|opt| opt.map_or(Value::Null, |v| Value::Number(Number::from(v))))
+                            .collect()
+                    });
+                Ok(Some(datum::JsonB(Value::Array(values))))
+            }
+            DataType::Utf8 => {
+                let list_array: ArrayRef = Arc::new(downcast_array.clone());
+                let values = list_array
+                    .get_string_list_value(index)?
+                    .map_or(vec![], |arr| {
+                        arr.into_iter()
+                            .map(|opt| opt.map_or(Value::Null, Value::String))
+                            .collect()
+                    });
+                Ok(Some(datum::JsonB(Value::Array(values))))
+            }
+            DataType::LargeUtf8 => {
+                let list_array: ArrayRef = Arc::new(downcast_array.clone());
+                let mut values = vec![];
+                for i in 0..list_array.len() {
+                    let string_value = list_array
+                        .get_primitive_value::<LargeStringArray>(i)?
+                        .map_or(Value::Null, |v| Value::String(v.to_string()));
+                    values.push(string_value);
+                }
+                Ok(Some(datum::JsonB(Value::Array(values))))
+            }
+            DataType::Struct(_) => {
+                let list_array = downcast_array.value(index);
+                let mut values = vec![];
+                for i in 0..list_array.len() {
+                    let struct_value = list_array.get_struct_value(i)?.map_or(Value::Null, |v| v.0);
+                    values.push(struct_value);
+                }
+                Ok(Some(datum::JsonB(Value::Array(values))))
+            }
+            DataType::List(_) => {
+                let list_array = downcast_array.value(index);
+                let mut values = vec![];
+                for i in 0..list_array.len() {
+                    let list_value = list_array.get_list_value(i)?.map_or(Value::Null, |v| v.0);
+                    values.push(list_value);
+                }
+                Ok(Some(datum::JsonB(Value::Array(values))))
+            }
+            unsupported => bail!("List with {:?} types are not yet supported", unsupported),
+        }
+    }
+}
+
 pub trait GetDecimalValue
 where
     Self: Array + AsArray,
@@ -559,6 +671,7 @@ where
         + GetIntervalDayTimeValue
         + GetIntervalMonthDayNanoValue
         + GetIntervalYearMonthValue
+        + GetListValue
         + GetPrimitiveValue
         + GetPrimitiveListValue
         + GetStringListValue
@@ -1040,6 +1153,13 @@ where
                         None => Ok(None),
                     }
                 }
+                DataType::List(_) => match self.get_list_value(index)? {
+                    Some(value) => {
+                        let json_value: serde_json::Value = serde_json::to_value(value)?;
+                        Ok(Some(Cell::Json(datum::Json(json_value))))
+                    }
+                    None => Ok(None),
+                },
                 unsupported => Err(DataTypeError::DataTypeMismatch(
                     name.to_string(),
                     unsupported.clone(),
@@ -1068,6 +1188,10 @@ where
                         None => Ok(None),
                     }
                 }
+                DataType::List(_) => match self.get_list_value(index)? {
+                    Some(value) => Ok(Some(Cell::JsonB(value))),
+                    None => Ok(None),
+                },
                 unsupported => Err(DataTypeError::DataTypeMismatch(
                     name.to_string(),
                     unsupported.clone(),
@@ -1266,6 +1390,7 @@ impl GetDecimalValue for ArrayRef {}
 impl GetIntervalDayTimeValue for ArrayRef {}
 impl GetIntervalMonthDayNanoValue for ArrayRef {}
 impl GetIntervalYearMonthValue for ArrayRef {}
+impl GetListValue for ArrayRef {}
 impl GetPrimitiveValue for ArrayRef {}
 impl GetPrimitiveListValue for ArrayRef {}
 impl GetStringListValue for ArrayRef {}

tests/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "tests"
 description = "Test suite for pg_analytics"
-version = "0.2.4"
+version = "0.3.0"
 edition = "2021"
 license = "PostgreSQL"