polyglot-sql 0.6.0__tar.gz → 0.6.1__tar.gz

{polyglot_sql-0.6.0 → polyglot_sql-0.6.1}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.6.0"
+version = "0.6.1"
 dependencies = [
  "criterion",
  "once_cell",
@@ -623,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ast-derive"
-version = "0.6.0"
+version = "0.6.1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -632,7 +632,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.6.0"
+version = "0.6.1"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -642,11 +642,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.6.0"
+version = "0.6.1"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.6.0"
+version = "0.6.1"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -657,7 +657,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.6.0"
+version = "0.6.1"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.6.0 → polyglot_sql-0.6.1}/Cargo.toml

@@ -6,7 +6,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.6.0"
+version = "0.6.1"
 edition = "2021"
 license = "MIT"
 authors = ["polyglot contributors"]

{polyglot_sql-0.6.0 → polyglot_sql-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.6.0
+Version: 0.6.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyglot_sql-0.6.0 → polyglot_sql-0.6.1}/crates/polyglot-sql/Cargo.toml

@@ -100,14 +100,14 @@ function-catalog-all-dialects = [
 ]
 
 [dependencies]
-polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.6.1" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 stacker = { version = "0.1", optional = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.6.0", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.6.1", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.6.0 → polyglot_sql-0.6.1}/crates/polyglot-sql/README.md

@@ -25,7 +25,7 @@ By default, `polyglot-sql` enables the full public API. Parser-only consumers ca
 disable default features and opt into only the dialect parsers they need:
 
 ```toml
-polyglot-sql = { version = "0.6.0", default-features = false }
+polyglot-sql = { version = "0.6.1", default-features = false }
 ```
 
 ```toml

{polyglot_sql-0.6.0 → polyglot_sql-0.6.1}/crates/polyglot-sql/src/dialects/mod.rs

@@ -3415,6 +3415,12 @@ impl Dialect {
                     target,
                     opts,
                 )?;
+                Self::reject_postgres_tsql_strict_unknown_text_casts(
+                    &expr,
+                    self.dialect_type,
+                    target,
+                    opts,
+                )?;
 
                 // When source and target differ, first normalize the source dialect's
                 // AST constructs to standard SQL, so that the target dialect can handle them.
@@ -3704,7 +3710,7 @@ impl Dialect {
                         DialectType::PostgreSQL | DialectType::CockroachDB
                     ) && !matches!(target, DialectType::PostgreSQL | DialectType::CockroachDB)
                     {
-                        Self::normalize_postgres_type_function_casts(normalized)?
+                        Self::normalize_postgres_type_function_casts(normalized, target)?
                     } else {
                         normalized
                     };
@@ -3820,6 +3826,16 @@ impl Dialect {
                     normalized
                 };
 
+                let normalized = if matches!(
+                    self.dialect_type,
+                    DialectType::PostgreSQL | DialectType::CockroachDB
+                ) && matches!(target, DialectType::TSQL | DialectType::Fabric)
+                {
+                    Self::normalize_postgres_boolean_semantics_for_tsql(normalized)?
+                } else {
+                    normalized
+                };
+
                 // TSQL: Convert COUNT(*) -> COUNT_BIG(*) when source is not TSQL/Fabric
                 // Python sqlglot does this in the TSQL generator, but we can't do it there
                 // because it would break TSQL -> TSQL identity
@@ -4265,6 +4281,20 @@ impl Dialect {
                     Self::push_unsupported_diagnostic(&mut diagnostics, "PostgreSQL TO_TSVECTOR");
                 }
                 if matches!(target, DialectType::TSQL | DialectType::Fabric) {
+                    if let Some(composite_semantics) =
+                        Self::postgres_tsql_unsupported_composite_semantics(node)
+                    {
+                        Self::push_unsupported_diagnostic(
+                            &mut diagnostics,
+                            &format!("PostgreSQL {composite_semantics}"),
+                        );
+                    }
+                    if Self::node_is_postgres_unknown_cast(node) {
+                        Self::push_unsupported_diagnostic(
+                            &mut diagnostics,
+                            "PostgreSQL unresolved UNKNOWN casts",
+                        );
+                    }
                     if let Some(collation_name) =
                         Self::postgres_tsql_unsupported_collation_name(node)
                     {
@@ -4354,6 +4384,38 @@ impl Dialect {
         Ok(())
     }
 
+    fn reject_postgres_tsql_strict_unknown_text_casts(
+        expr: &Expression,
+        source: DialectType,
+        target: DialectType,
+        opts: &TranspileOptions,
+    ) -> Result<()> {
+        if !matches!(
+            opts.unsupported_level,
+            UnsupportedLevel::Raise | UnsupportedLevel::Immediate
+        ) || !matches!(source, DialectType::PostgreSQL | DialectType::CockroachDB)
+            || !matches!(target, DialectType::TSQL | DialectType::Fabric)
+        {
+            return Ok(());
+        }
+
+        if expr.dfs().any(|node| {
+            matches!(
+                node,
+                Expression::Cast(cast)
+                    if matches!(cast.to, DataType::Text)
+                        && Self::is_column_expr(&cast.this)
+            )
+        }) {
+            return Err(crate::error::Error::unsupported(
+                "PostgreSQL cast of a column with an unknown source type to text",
+                target.to_string(),
+            ));
+        }
+
+        Ok(())
+    }
+
     fn push_unsupported_diagnostic(diagnostics: &mut Vec<String>, message: &str) {
         if !diagnostics.iter().any(|existing| existing == message) {
             diagnostics.push(message.to_string());
@@ -4880,6 +4942,33 @@ impl Dialect {
         }
     }
 
+    fn postgres_tsql_unsupported_composite_semantics(expr: &Expression) -> Option<&'static str> {
+        match expr {
+            Expression::Tuple(_) | Expression::Struct(_) | Expression::StructFunc(_) => {
+                Some("row/composite values")
+            }
+            Expression::Function(function)
+                if !function.quoted && function.name.eq_ignore_ascii_case("ROW") =>
+            {
+                Some("row/composite values")
+            }
+            Expression::StructExtract(_) => Some("row/composite field access"),
+            Expression::Cast(cast) | Expression::TryCast(cast) | Expression::SafeCast(cast) if matches!(&cast.this, Expression::Star(star) if star.table.is_some()) => {
+                Some("qualified whole-row casts")
+            }
+            _ => None,
+        }
+    }
+
+    fn node_is_postgres_unknown_cast(expr: &Expression) -> bool {
+        match expr {
+            Expression::Cast(cast) | Expression::TryCast(cast) | Expression::SafeCast(cast) => {
+                normalization::is_postgres_unknown_type(&cast.to)
+            }
+            _ => false,
+        }
+    }
+
     fn postgres_tsql_unsupported_array_semantics(expr: &Expression) -> Option<&'static str> {
         match expr {
             Expression::Array(_) | Expression::ArrayFunc(_) => Some("array literals"),
@@ -5655,7 +5744,10 @@ impl Dialect {
         }
     }
 
-    fn normalize_postgres_type_function_casts(expr: Expression) -> Result<Expression> {
+    fn normalize_postgres_type_function_casts(
+        expr: Expression,
+        target: DialectType,
+    ) -> Result<Expression> {
         transform_recursive(expr, &|e| match e {
             Expression::Function(function) => {
                 let mut function = *function;
@@ -5667,7 +5759,7 @@ impl Dialect {
                 {
                     if let Some(to) = Self::postgres_type_function_data_type(&function.name) {
                         let this = function.args.remove(0);
-                        return Ok(Expression::Cast(Box::new(Cast {
+                        let cast = Cast {
                             this,
                             to,
                             trailing_comments: function.trailing_comments,
@@ -5675,7 +5767,14 @@ impl Dialect {
                             format: None,
                             default: None,
                             inferred_type: function.inferred_type,
-                        })));
+                        };
+                        return Ok(
+                            if matches!(target, DialectType::TSQL | DialectType::Fabric) {
+                                normalization::rewrite_postgres_float_to_integer_cast(cast)
+                            } else {
+                                Expression::Cast(Box::new(cast))
+                            },
+                        );
                     }
                 }
                 Ok(Expression::Function(Box::new(function)))
@@ -6069,7 +6168,82 @@ impl Dialect {
         Ok(Expression::Select(select))
     }
 
+    fn normalize_postgres_boolean_semantics_for_tsql(expr: Expression) -> Result<Expression> {
+        transform_recursive(expr, &|e| match e {
+            Expression::Function(function)
+                if function.args.len() == 2
+                    && (function.name.eq_ignore_ascii_case("BOOLEQ")
+                        || function.name.eq_ignore_ascii_case("BOOLNE")) =>
+            {
+                let is_equal = function.name.eq_ignore_ascii_case("BOOLEQ");
+                let mut args = function.args.into_iter();
+                let op = BinaryOp {
+                    left: args.next().expect("checked boolean operator arity"),
+                    right: args.next().expect("checked boolean operator arity"),
+                    left_comments: Vec::new(),
+                    operator_comments: Vec::new(),
+                    trailing_comments: function.trailing_comments,
+                    inferred_type: None,
+                };
+                if is_equal {
+                    Ok(Expression::Eq(Box::new(op)))
+                } else {
+                    Ok(Expression::Neq(Box::new(op)))
+                }
+            }
+            Expression::Cast(cast)
+                if matches!(cast.to, DataType::Text)
+                    && Self::is_known_postgres_boolean_expression(&cast.this) =>
+            {
+                Ok(Self::postgres_boolean_text_value(cast.this))
+            }
+            other => Ok(other),
+        })
+    }
+
+    fn is_known_postgres_boolean_expression(expr: &Expression) -> bool {
+        match expr {
+            Expression::Boolean(_) => true,
+            Expression::Cast(cast) => matches!(cast.to, DataType::Boolean),
+            Expression::Paren(paren) => Self::is_known_postgres_boolean_expression(&paren.this),
+            other => Self::is_tsql_boolean_value_expression(other),
+        }
+    }
+
+    fn postgres_boolean_text_value(predicate: Expression) -> Expression {
+        if let Expression::Boolean(boolean) = predicate {
+            return Expression::string(if boolean.value { "true" } else { "false" });
+        }
+
+        let false_predicate = Expression::Not(Box::new(crate::expressions::UnaryOp {
+            this: predicate.clone(),
+            inferred_type: None,
+        }));
+        Expression::Case(Box::new(crate::expressions::Case {
+            operand: None,
+            whens: vec![
+                (predicate, Expression::string("true")),
+                (false_predicate, Expression::string("false")),
+            ],
+            else_: Some(Expression::null()),
+            comments: Vec::new(),
+            inferred_type: None,
+        }))
+    }
+
     fn rewrite_tsql_boolean_scalar_value(expr: Expression) -> Result<Expression> {
+        if let Expression::Boolean(boolean) = expr {
+            return Ok(Expression::Cast(Box::new(Cast {
+                this: Expression::Boolean(boolean),
+                to: DataType::Boolean,
+                trailing_comments: Vec::new(),
+                double_colon_syntax: false,
+                format: None,
+                default: None,
+                inferred_type: None,
+            })));
+        }
+
         if Self::is_tsql_boolean_value_expression(&expr) {
             let predicate = Self::rewrite_tsql_boolean_predicate_context(expr)?;
             return Ok(Self::tsql_boolean_value_case(predicate));
@@ -6124,6 +6298,7 @@ impl Dialect {
                 Ok(Expression::SafeCast(cast))
             }
             Expression::Case(mut case) => {
+                let is_simple_case = case.operand.is_some();
                 if let Some(operand) = case.operand.take() {
                     case.operand = Some(Self::rewrite_tsql_boolean_scalar_value(operand)?);
                 }
@@ -6131,10 +6306,12 @@ impl Dialect {
                     .whens
                     .into_iter()
                     .map(|(condition, result)| {
-                        Ok((
-                            Self::rewrite_tsql_boolean_predicate_context(condition)?,
-                            Self::rewrite_tsql_boolean_scalar_value(result)?,
-                        ))
+                        let condition = if is_simple_case {
+                            Self::rewrite_tsql_boolean_scalar_value(condition)?
+                        } else {
+                            Self::rewrite_tsql_boolean_predicate_context(condition)?
+                        };
+                        Ok((condition, Self::rewrite_tsql_boolean_scalar_value(result)?))
                     })
                     .collect::<Result<Vec<_>>>()?;
                 if let Some(else_) = case.else_.take() {

{polyglot_sql-0.6.0 → polyglot_sql-0.6.1}/crates/polyglot-sql/src/dialects/normalization/mod.rs

@@ -21,6 +21,14 @@ struct NormalizationContext {
     target: DialectType,
 }
 
+pub(super) fn rewrite_postgres_float_to_integer_cast(cast: Cast) -> Expression {
+    types::rewrite_postgres_float_to_integer_cast(cast)
+}
+
+pub(super) fn is_postgres_unknown_type(data_type: &DataType) -> bool {
+    types::is_postgres_unknown_type(data_type)
+}
+
 enum RewriteOutcome {
     // No domain action was selected. The ordered fallback may still have
     // normalized the expression before returning it.
@@ -1399,11 +1407,33 @@ pub(super) fn normalize(
                 matches!(target, DialectType::DuckDB | DialectType::PostgreSQL);
 
             match &e {
+                Expression::Subquery(subquery)
+                    if matches!(target, DialectType::TSQL | DialectType::Fabric)
+                        && subquery.alias.is_some()
+                        && subquery.column_aliases.is_empty()
+                        && matches!(&subquery.this, Expression::Values(values) if !values.expressions.is_empty()) =>
+                {
+                    Action::Statements(
+                        statements::Action::EnsureValuesDerivedTableColumnAliases,
+                    )
+                }
+                Expression::Extract(_)
+                    if matches!(source, DialectType::PostgreSQL)
+                        && matches!(target, DialectType::TSQL | DialectType::Fabric)
+                        && temporal::is_postgres_time_date_part(&e) =>
+                {
+                    Action::Temporal(temporal::Action::PostgresTimeDatePartForTsql)
+                }
                 Expression::Function(f) => {
                     let name = f.name.to_ascii_uppercase();
                     // DuckDB json(x) is a synonym for CAST(x AS JSON) — parses a string.
                     // Map to JSON_PARSE(x) for Trino/Presto/Athena to preserve semantics.
-                    if name == "JSON"
+                    if matches!(source, DialectType::PostgreSQL)
+                        && matches!(target, DialectType::TSQL | DialectType::Fabric)
+                        && temporal::is_postgres_time_date_part(&e)
+                    {
+                        Action::Temporal(temporal::Action::PostgresTimeDatePartForTsql)
+                    } else if name == "JSON"
                         && f.args.len() == 1
                         && matches!(source, DialectType::DuckDB)
                         && matches!(
@@ -2136,11 +2166,21 @@ pub(super) fn normalize(
                 // because BigQuery's TIMESTAMP is really TIMESTAMPTZ, and
                 // DATETIME is the timezone-unaware type
                 Expression::Cast(ref c) => {
-                    if c.format.is_some()
+                    if matches!(source, DialectType::PostgreSQL)
+                        && matches!(target, DialectType::TSQL | DialectType::Fabric)
+                        && types::is_postgres_unknown_null_cast(c)
+                    {
+                        Action::Types(types::Action::PostgresUnknownNullCast)
+                    } else if c.format.is_some()
                         && (matches!(source, DialectType::BigQuery)
                             || matches!(source, DialectType::Teradata))
                     {
                         Action::Types(types::Action::BigQueryCastFormat)
+                    } else if matches!(source, DialectType::PostgreSQL)
+                        && matches!(target, DialectType::TSQL | DialectType::Fabric)
+                        && types::is_postgres_float_to_integer_cast(c)
+                    {
+                        Action::Types(types::Action::PostgresFloatToIntegerCast)
                     } else if matches!(target, DialectType::BigQuery)
                         && !matches!(source, DialectType::BigQuery)
                         && matches!(

{polyglot_sql-0.6.0 → polyglot_sql-0.6.1}/crates/polyglot-sql/src/dialects/normalization/statements.rs

@@ -6,6 +6,7 @@ use crate::expressions::*;
 #[derive(Debug)]
 pub(super) enum Action {
     SetToVariable,
+    EnsureValuesDerivedTableColumnAliases,
     AlterTableRenameStripSchema,
     TempTableHash,
     TablesampleReservoir,
@@ -400,6 +401,24 @@ pub(super) fn rewrite(
     let e = expression;
     let expression = (|| -> Result<Expression> {
         match action {
+            Action::EnsureValuesDerivedTableColumnAliases => {
+                if let Expression::Subquery(mut subquery) = e {
+                    let column_count = match &subquery.this {
+                        Expression::Values(values) => values
+                            .expressions
+                            .first()
+                            .map(|row| row.expressions.len())
+                            .unwrap_or(0),
+                        _ => 0,
+                    };
+                    subquery.column_aliases = (1..=column_count)
+                        .map(|index| Identifier::new(format!("column{index}")))
+                        .collect();
+                    Ok(Expression::Subquery(subquery))
+                } else {
+                    Ok(e)
+                }
+            }
             Action::SetToVariable => {
                 // For DuckDB: SET a = 1 -> SET VARIABLE a = 1
                 if let Expression::SetStatement(mut s) = e {

{polyglot_sql-0.6.0 → polyglot_sql-0.6.1}/crates/polyglot-sql/src/dialects/normalization/temporal.rs

@@ -5,6 +5,7 @@ use crate::expressions::*;
 
 #[derive(Debug)]
 pub(super) enum Action {
+    PostgresTimeDatePartForTsql,
     ConvertTimezoneToExpr,
     EpochConvert,
     EpochMsConvert,
@@ -50,6 +51,7 @@ pub(super) fn rewrite(
     let e = expression;
     let expression = (|| -> Result<Expression> {
         match action {
+            Action::PostgresTimeDatePartForTsql => rewrite_postgres_time_date_part_for_tsql(e),
             Action::ConvertTimezoneToExpr => {
                 // Convert Function("CONVERT_TIMEZONE", args) to Expression::ConvertTimezone
                 // This prevents Redshift's transform_expr from expanding 2-arg to 3-arg with 'UTC'
@@ -2695,6 +2697,173 @@ pub(super) fn rewrite(
     Ok(RewriteOutcome::Rewritten(expression))
 }
 
+#[derive(Debug, Clone, Copy)]
+enum PostgresTimeDatePart {
+    Second,
+    Millisecond,
+    Microsecond,
+    Epoch,
+}
+
+pub(super) fn is_postgres_time_date_part(expression: &Expression) -> bool {
+    postgres_time_date_part(expression).is_some()
+}
+
+fn postgres_time_date_part(expression: &Expression) -> Option<(PostgresTimeDatePart, Expression)> {
+    match expression {
+        Expression::Extract(extract) if is_time_value(&extract.this) => {
+            let field = match &extract.field {
+                DateTimeField::Second => PostgresTimeDatePart::Second,
+                DateTimeField::Millisecond => PostgresTimeDatePart::Millisecond,
+                DateTimeField::Microsecond => PostgresTimeDatePart::Microsecond,
+                DateTimeField::Epoch => PostgresTimeDatePart::Epoch,
+                _ => return None,
+            };
+            Some((field, extract.this.clone()))
+        }
+        Expression::Function(function)
+            if function.args.len() == 2
+                && matches!(
+                    function.name.to_ascii_uppercase().as_str(),
+                    "DATE_PART" | "DATEPART"
+                )
+                && is_time_value(&function.args[1]) =>
+        {
+            let field = postgres_time_date_part_name(&function.args[0])?;
+            Some((field, function.args[1].clone()))
+        }
+        _ => None,
+    }
+}
+
+fn postgres_time_date_part_name(expression: &Expression) -> Option<PostgresTimeDatePart> {
+    let name = match expression {
+        Expression::Literal(literal) => match literal.as_ref() {
+            Literal::String(name) => name.as_str(),
+            _ => return None,
+        },
+        Expression::Identifier(identifier) => identifier.name.as_str(),
+        Expression::Column(column) if column.table.is_none() => column.name.name.as_str(),
+        Expression::Cast(cast)
+            if matches!(
+                cast.to,
+                DataType::Text | DataType::TextWithLength { .. } | DataType::VarChar { .. }
+            ) =>
+        {
+            return postgres_time_date_part_name(&cast.this);
+        }
+        _ => return None,
+    };
+
+    match name.trim().to_ascii_uppercase().as_str() {
+        "SECOND" | "SECONDS" | "SEC" | "SECS" | "S" | "SS" => Some(PostgresTimeDatePart::Second),
+        "MILLISECOND" | "MILLISECONDS" | "MILLISEC" | "MILLISECS" | "MS" | "MSEC" | "MSECS" => {
+            Some(PostgresTimeDatePart::Millisecond)
+        }
+        "MICROSECOND" | "MICROSECONDS" | "MICROSEC" | "MICROSECS" | "US" | "USEC" | "USECS"
+        | "MCS" => Some(PostgresTimeDatePart::Microsecond),
+        "EPOCH" | "EPOCH_SECOND" | "EPOCH_SECONDS" => Some(PostgresTimeDatePart::Epoch),
+        _ => None,
+    }
+}
+
+fn is_time_value(expression: &Expression) -> bool {
+    let is_time_type = |data_type: &DataType| {
+        matches!(data_type, DataType::Time { .. })
+            || matches!(
+                data_type,
+                DataType::Custom { name }
+                    if name.eq_ignore_ascii_case("TIME") || name.to_ascii_uppercase().starts_with("TIME(")
+            )
+    };
+
+    match expression {
+        Expression::Cast(cast) | Expression::TryCast(cast) | Expression::SafeCast(cast) => {
+            is_time_type(&cast.to)
+        }
+        Expression::Literal(literal) => matches!(literal.as_ref(), Literal::Time(_)),
+        Expression::Paren(paren) => is_time_value(&paren.this),
+        Expression::Alias(alias) => is_time_value(&alias.this),
+        Expression::CurrentTime(_) | Expression::Localtime(_) => true,
+        other => other.inferred_type().is_some_and(is_time_type),
+    }
+}
+
+fn rewrite_postgres_time_date_part_for_tsql(expression: Expression) -> Result<Expression> {
+    let Some((field, value)) = postgres_time_date_part(&expression) else {
+        return Ok(expression);
+    };
+
+    let date_part = |name: &str, value: Expression| {
+        Expression::Function(Box::new(Function::new(
+            "DATEPART",
+            vec![Expression::Identifier(Identifier::new(name)), value],
+        )))
+    };
+    let decimal = |value: &str| Expression::Literal(Box::new(Literal::Number(value.to_string())));
+    let fractional_microseconds = date_part("MICROSECOND", value.clone());
+    let fractional_seconds = Expression::Div(Box::new(BinaryOp::new(
+        fractional_microseconds.clone(),
+        decimal("1000000.0"),
+    )));
+    let whole_seconds = date_part("SECOND", value.clone());
+
+    let rewritten = match field {
+        PostgresTimeDatePart::Second => {
+            Expression::Add(Box::new(BinaryOp::new(whole_seconds, fractional_seconds)))
+        }
+        PostgresTimeDatePart::Millisecond => {
+            let whole_milliseconds = Expression::Mul(Box::new(BinaryOp::new(
+                whole_seconds,
+                Expression::number(1000),
+            )));
+            let fractional_milliseconds = Expression::Div(Box::new(BinaryOp::new(
+                fractional_microseconds,
+                decimal("1000.0"),
+            )));
+            Expression::Add(Box::new(BinaryOp::new(
+                whole_milliseconds,
+                fractional_milliseconds,
+            )))
+        }
+        PostgresTimeDatePart::Microsecond => {
+            let whole_microseconds = Expression::Mul(Box::new(BinaryOp::new(
+                whole_seconds,
+                Expression::number(1_000_000),
+            )));
+            Expression::Add(Box::new(BinaryOp::new(
+                whole_microseconds,
+                fractional_microseconds,
+            )))
+        }
+        PostgresTimeDatePart::Epoch => {
+            let midnight = Expression::Cast(Box::new(Cast {
+                this: Expression::string("00:00:00"),
+                to: DataType::Time {
+                    precision: Some(6),
+                    timezone: false,
+                },
+                trailing_comments: Vec::new(),
+                double_colon_syntax: false,
+                format: None,
+                default: None,
+                inferred_type: None,
+            }));
+            let elapsed_seconds = Expression::Function(Box::new(Function::new(
+                "DATEDIFF",
+                vec![
+                    Expression::Identifier(Identifier::new("SECOND")),
+                    midnight,
+                    value,
+                ],
+            )));
+            Expression::Add(Box::new(BinaryOp::new(elapsed_seconds, fractional_seconds)))
+        }
+    };
+
+    Ok(rewritten)
+}
+
 pub(super) fn date_trunc_to_mysql(unit: &str, expr: &Expression) -> Result<Expression> {
     use crate::expressions::Function;
     match unit {