polyglot-sql 0.3.4__tar.gz → 0.3.5__tar.gz

{polyglot_sql-0.3.4 → polyglot_sql-0.3.5}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.3.4"
+version = "0.3.5"
 dependencies = [
  "criterion",
  "once_cell",
@@ -621,7 +621,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.3.4"
+version = "0.3.5"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -631,11 +631,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.3.4"
+version = "0.3.5"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.3.4"
+version = "0.3.5"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.3.4"
+version = "0.3.5"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.3.4 → polyglot_sql-0.3.5}/Cargo.toml

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

{polyglot_sql-0.3.4 → polyglot_sql-0.3.5}/PKG-INFO

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

{polyglot_sql-0.3.4 → polyglot_sql-0.3.5}/crates/polyglot-sql/Cargo.toml

@@ -83,7 +83,7 @@ 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.3.4", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.3.5", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.3.4 → polyglot_sql-0.3.5}/crates/polyglot-sql/src/dialects/mod.rs

@@ -161,7 +161,7 @@ use crate::error::Result;
 use crate::expressions::{Expression, Function, FunctionBody, Identifier, Null};
 use crate::generator::{Generator, GeneratorConfig};
 use crate::parser::Parser;
-use crate::tokens::{Token, Tokenizer, TokenizerConfig};
+use crate::tokens::{Token, TokenType, Tokenizer, TokenizerConfig};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::{Arc, LazyLock, RwLock};
@@ -3750,6 +3750,11 @@ impl Dialect {
         pretty: bool,
     ) -> Result<Vec<String>> {
         let target = target_dialect.dialect_type;
+        if matches!(self.dialect_type, DialectType::PostgreSQL)
+            && matches!(target, DialectType::SQLite)
+        {
+            self.reject_pgvector_distance_operators_for_sqlite(sql)?;
+        }
         let expressions = self.parse(sql)?;
         let generic_identity =
             self.dialect_type == DialectType::Generic && target == DialectType::Generic;
@@ -4063,6 +4068,14 @@ impl Dialect {
                 let normalized =
                     Self::cross_dialect_normalize(normalized, self.dialect_type, target)?;
 
+                let normalized = if matches!(self.dialect_type, DialectType::PostgreSQL)
+                    && matches!(target, DialectType::SQLite)
+                {
+                    Self::normalize_postgres_to_sqlite_types(normalized)?
+                } else {
+                    normalized
+                };
+
                 // For DuckDB target from BigQuery source: wrap UNNEST of struct arrays in
                 // (SELECT UNNEST(..., max_depth => 2)) subquery
                 // Must run BEFORE unnest_alias_to_column_alias since it changes alias structure
@@ -4222,6 +4235,77 @@ impl Dialect {
 // Transpile-only methods: cross-dialect normalization and helpers
 #[cfg(feature = "transpile")]
 impl Dialect {
+    fn reject_pgvector_distance_operators_for_sqlite(&self, sql: &str) -> Result<()> {
+        let tokens = self.tokenize(sql)?;
+        for (i, token) in tokens.iter().enumerate() {
+            if token.token_type == TokenType::NullsafeEq {
+                return Err(crate::error::Error::unsupported(
+                    "PostgreSQL pgvector cosine distance operator <=>",
+                    "SQLite",
+                ));
+            }
+            if token.token_type == TokenType::Lt
+                && tokens
+                    .get(i + 1)
+                    .is_some_and(|token| token.token_type == TokenType::Tilde)
+                && tokens
+                    .get(i + 2)
+                    .is_some_and(|token| token.token_type == TokenType::Gt)
+            {
+                return Err(crate::error::Error::unsupported(
+                    "PostgreSQL pgvector Hamming distance operator <~>",
+                    "SQLite",
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    fn normalize_postgres_to_sqlite_types(expr: Expression) -> Result<Expression> {
+        fn sqlite_type(dt: crate::expressions::DataType) -> crate::expressions::DataType {
+            use crate::expressions::DataType;
+
+            match dt {
+                DataType::Bit { .. } => DataType::Int {
+                    length: None,
+                    integer_spelling: true,
+                },
+                DataType::TextWithLength { .. } => DataType::Text,
+                DataType::VarChar { .. } => DataType::Text,
+                DataType::Char { .. } => DataType::Text,
+                DataType::Timestamp { timezone: true, .. } => DataType::Text,
+                DataType::Custom { name } => {
+                    let base = name
+                        .split_once('(')
+                        .map_or(name.as_str(), |(base, _)| base)
+                        .trim();
+                    if base.eq_ignore_ascii_case("TSVECTOR")
+                        || base.eq_ignore_ascii_case("TIMESTAMPTZ")
+                        || base.eq_ignore_ascii_case("TIMESTAMP WITH TIME ZONE")
+                        || base.eq_ignore_ascii_case("NVARCHAR")
+                        || base.eq_ignore_ascii_case("NCHAR")
+                    {
+                        DataType::Text
+                    } else {
+                        DataType::Custom { name }
+                    }
+                }
+                _ => dt,
+            }
+        }
+
+        transform_recursive(expr, &|e| match e {
+            Expression::DataType(dt) => Ok(Expression::DataType(sqlite_type(dt))),
+            Expression::CreateTable(mut ct) => {
+                for column in &mut ct.columns {
+                    column.data_type = sqlite_type(column.data_type.clone());
+                }
+                Ok(Expression::CreateTable(ct))
+            }
+            _ => Ok(e),
+        })
+    }
+
     /// For DuckDB target: when FROM clause contains RANGE(n), replace
     /// `(ROW_NUMBER() OVER (ORDER BY 1 NULLS FIRST) - 1)` with `range` in select expressions.
     /// This handles SEQ1/2/4/8 → RANGE transpilation from Snowflake.

{polyglot_sql-0.3.4 → polyglot_sql-0.3.5}/crates/polyglot-sql/src/dialects/sqlite.rs

@@ -5,7 +5,8 @@
 use super::{DialectImpl, DialectType};
 use crate::error::Result;
 use crate::expressions::{
-    AggFunc, BinaryFunc, BinaryOp, Case, Cast, CeilFunc, Expression, Function, LikeOp, UnaryFunc,
+    AggFunc, BinaryFunc, BinaryOp, Case, Cast, CeilFunc, DataType, DateTimeField, DateTruncFunc,
+    Expression, ExtractFunc, Function, LikeOp, Literal, TrimFunc, TrimPosition, UnaryFunc,
     VarArgFunc,
 };
 use crate::generator::GeneratorConfig;
@@ -138,6 +139,46 @@ impl DialectImpl for SQLiteDialect {
                 Ok(Expression::Pragma(p))
             }
 
+            // PostgreSQL DATE '...' literals are not SQLite syntax.
+            Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Date(_)) => {
+                let Literal::Date(date) = lit.as_ref() else {
+                    unreachable!()
+                };
+                Ok(Self::string_literal(date))
+            }
+
+            // SQLite scalar MIN/MAX are multi-argument equivalents of LEAST/GREATEST.
+            Expression::Least(f) => Ok(Self::function("MIN", f.expressions)),
+            Expression::Greatest(f) => Ok(Self::function("MAX", f.expressions)),
+
+            // PostgreSQL EXTRACT(...) lowers to SQLite strftime() for common units.
+            Expression::Extract(f) => Self::transform_extract(*f),
+
+            // PostgreSQL DATE_TRUNC(...) lowers to date/strftime() for common units.
+            Expression::DateTrunc(f) => Self::transform_date_trunc(*f),
+
+            // SQLite uses comma-call SUBSTRING/SUBSTR syntax, not SQL-standard FROM/FOR.
+            Expression::Substring(mut f) => {
+                f.from_for_syntax = false;
+                Ok(Expression::Substring(f))
+            }
+
+            // SQLite supports LTRIM/RTRIM/TRIM(str, chars), not TRIM(LEADING ... FROM ...).
+            Expression::Trim(f) => Ok(Self::transform_trim(*f)),
+
+            // Strip PostgreSQL's default public schema in SQLite DDL.
+            Expression::CreateTable(mut ct)
+                if ct
+                    .name
+                    .schema
+                    .as_ref()
+                    .is_some_and(|schema| schema.name.eq_ignore_ascii_case("public"))
+                    && ct.name.catalog.is_none() =>
+            {
+                ct.name.schema = None;
+                Ok(Expression::CreateTable(ct))
+            }
+
             // Generic function transformations
             Expression::Function(f) => self.transform_function(*f),
 
@@ -177,6 +218,122 @@ impl DialectImpl for SQLiteDialect {
 }
 
 impl SQLiteDialect {
+    fn function(name: &str, args: Vec<Expression>) -> Expression {
+        Expression::Function(Box::new(Function::new(name.to_string(), args)))
+    }
+
+    fn string_literal(value: &str) -> Expression {
+        Expression::Literal(Box::new(Literal::String(value.to_string())))
+    }
+
+    fn strftime(format: &str, expr: Expression) -> Expression {
+        Expression::Function(Box::new(Function::new(
+            "STRFTIME".to_string(),
+            vec![Self::string_literal(format), expr],
+        )))
+    }
+
+    fn cast(expr: Expression, to: DataType) -> Expression {
+        Expression::Cast(Box::new(Cast {
+            this: expr,
+            to,
+            trailing_comments: Vec::new(),
+            double_colon_syntax: false,
+            format: None,
+            default: None,
+            inferred_type: None,
+        }))
+    }
+
+    fn sqlite_int_type() -> DataType {
+        DataType::Int {
+            length: None,
+            integer_spelling: true,
+        }
+    }
+
+    fn sqlite_real_type() -> DataType {
+        DataType::Float {
+            precision: None,
+            scale: None,
+            real_spelling: true,
+        }
+    }
+
+    fn transform_extract(f: ExtractFunc) -> Result<Expression> {
+        let strftime_format = match &f.field {
+            DateTimeField::Year => "%Y",
+            DateTimeField::Month => "%m",
+            DateTimeField::Day => "%d",
+            DateTimeField::Hour => "%H",
+            DateTimeField::Minute => "%M",
+            DateTimeField::Second => "%f",
+            DateTimeField::DayOfWeek => "%w",
+            DateTimeField::DayOfYear => "%j",
+            DateTimeField::Epoch => "%s",
+            _ => return Ok(Expression::Extract(Box::new(f))),
+        };
+        let target_type = if matches!(f.field, DateTimeField::Epoch | DateTimeField::Second) {
+            Self::sqlite_real_type()
+        } else {
+            Self::sqlite_int_type()
+        };
+        Ok(Self::cast(
+            Self::strftime(strftime_format, f.this),
+            target_type,
+        ))
+    }
+
+    fn transform_date_trunc(f: DateTruncFunc) -> Result<Expression> {
+        match &f.unit {
+            DateTimeField::Day => Ok(Self::function("DATE", vec![f.this])),
+            DateTimeField::Hour => Ok(Self::strftime("%Y-%m-%d %H:00:00", f.this)),
+            DateTimeField::Minute => Ok(Self::strftime("%Y-%m-%d %H:%M:00", f.this)),
+            DateTimeField::Second => Ok(Self::strftime("%Y-%m-%d %H:%M:%S", f.this)),
+            DateTimeField::Month => Ok(Self::strftime("%Y-%m-01", f.this)),
+            DateTimeField::Year => Ok(Self::strftime("%Y-01-01", f.this)),
+            _ => Ok(Expression::DateTrunc(Box::new(f))),
+        }
+    }
+
+    fn datetime_field_from_expr(expr: &Expression) -> Option<DateTimeField> {
+        let unit = match expr {
+            Expression::Literal(lit) => match lit.as_ref() {
+                Literal::String(s) => s.as_str(),
+                _ => return None,
+            },
+            Expression::Identifier(id) => id.name.as_str(),
+            Expression::Var(v) => v.this.as_str(),
+            Expression::Column(col) if col.table.is_none() => col.name.name.as_str(),
+            _ => return None,
+        };
+        match unit.to_ascii_lowercase().as_str() {
+            "year" | "yyyy" | "yy" => Some(DateTimeField::Year),
+            "month" | "mon" | "mm" => Some(DateTimeField::Month),
+            "day" | "dd" => Some(DateTimeField::Day),
+            "hour" | "hours" | "h" | "hh" | "hr" | "hrs" => Some(DateTimeField::Hour),
+            "minute" | "minutes" | "mi" | "min" | "mins" => Some(DateTimeField::Minute),
+            "second" | "seconds" | "s" | "sec" | "secs" | "ss" => Some(DateTimeField::Second),
+            "dow" | "dayofweek" | "dw" => Some(DateTimeField::DayOfWeek),
+            "doy" | "dayofyear" | "dy" => Some(DateTimeField::DayOfYear),
+            "epoch" => Some(DateTimeField::Epoch),
+            _ => None,
+        }
+    }
+
+    fn transform_trim(f: TrimFunc) -> Expression {
+        let function_name = match f.position {
+            TrimPosition::Leading => "LTRIM",
+            TrimPosition::Trailing => "RTRIM",
+            TrimPosition::Both => "TRIM",
+        };
+        let mut args = vec![f.this];
+        if let Some(characters) = f.characters {
+            args.push(characters);
+        }
+        Expression::Function(Box::new(Function::new(function_name.to_string(), args)))
+    }
+
     /// Check if an expression is already a CAST to a float type
     fn is_float_cast(expr: &Expression) -> bool {
         if let Expression::Cast(cast) = expr {
@@ -299,6 +456,18 @@ impl SQLiteDialect {
                 Function::new("EDITDIST3".to_string(), f.args),
             ))),
 
+            // PostgreSQL-compatible scalar/JSON rewrites.
+            "LEAST" if !f.args.is_empty() => Ok(Self::function("MIN", f.args)),
+            "GREATEST" if !f.args.is_empty() => Ok(Self::function("MAX", f.args)),
+            "JSON_BUILD_ARRAY" => Ok(Self::function("JSON_ARRAY", f.args)),
+            "JSON_BUILD_OBJECT" => Ok(Self::function("JSON_OBJECT", f.args)),
+            "JSON_AGG" | "JSONB_AGG" if f.args.len() == 1 => {
+                Ok(Self::function("JSON_GROUP_ARRAY", f.args))
+            }
+            "JSON_OBJECT_AGG" if f.args.len() == 2 => {
+                Ok(Self::function("JSON_GROUP_OBJECT", f.args))
+            }
+
             // GETDATE -> CURRENT_TIMESTAMP
             "GETDATE" => Ok(Expression::CurrentTimestamp(
                 crate::expressions::CurrentTimestamp {
@@ -328,10 +497,7 @@ impl SQLiteDialect {
             )))),
 
             // SUBSTRING is native to SQLite (keep as-is)
-            "SUBSTRING" => Ok(Expression::Function(Box::new(Function::new(
-                "SUBSTRING".to_string(),
-                f.args,
-            )))),
+            "SUBSTRING" => Ok(Self::function("SUBSTRING", f.args)),
 
             // STRING_AGG -> GROUP_CONCAT in SQLite
             "STRING_AGG" if !f.args.is_empty() => Ok(Expression::Function(Box::new(
@@ -344,6 +510,28 @@ impl SQLiteDialect {
                 f.args,
             )))),
 
+            "DATE_PART" if f.args.len() == 2 => {
+                let mut args = f.args;
+                let unit = args.remove(0);
+                let expr = args.remove(0);
+                if let Some(field) = Self::datetime_field_from_expr(&unit) {
+                    Self::transform_extract(ExtractFunc { this: expr, field })
+                } else {
+                    Ok(Self::function("DATE_PART", vec![unit, expr]))
+                }
+            }
+
+            "DATE_TRUNC" if f.args.len() == 2 => {
+                let mut args = f.args;
+                let unit = args.remove(0);
+                let expr = args.remove(0);
+                if let Some(unit) = Self::datetime_field_from_expr(&unit) {
+                    Self::transform_date_trunc(DateTruncFunc { this: expr, unit })
+                } else {
+                    Ok(Self::function("DATE_TRUNC", vec![unit, expr]))
+                }
+            }
+
             // DATEDIFF(a, b, unit_string) -> JULIANDAY arithmetic for SQLite
             "DATEDIFF" | "DATE_DIFF" if f.args.len() == 3 => {
                 let mut args = f.args;
@@ -534,6 +722,14 @@ impl SQLiteDialect {
                 f.args,
             )))),
 
+            "JSON_AGG" | "JSONB_AGG" if f.args.len() == 1 => {
+                Ok(Self::function("JSON_GROUP_ARRAY", f.args))
+            }
+
+            "JSON_OBJECT_AGG" if f.args.len() == 2 => {
+                Ok(Self::function("JSON_GROUP_OBJECT", f.args))
+            }
+
             // Pass through everything else
             _ => Ok(Expression::AggregateFunction(f)),
         }

{polyglot_sql-0.3.4 → polyglot_sql-0.3.5}/crates/polyglot-sql/src/parser.rs

@@ -4882,8 +4882,9 @@ impl Parser {
             } else {
                 return Err(self.parse_error("Expected identifier after ${"));
             }
-        } else if self.check(TokenType::String) {
+        } else if self.check(TokenType::String) || self.check(TokenType::DollarString) {
             // DuckDB allows string literals as table names: SELECT * FROM 'x.y'
+            // Snowflake JDBC uses dollar-quoted strings for stage paths: SELECT $1 FROM $$@%"table"/$$
             // Convert to a quoted identifier
             let string_token = self.advance();
             let table_name = Identifier {
@@ -22741,9 +22742,14 @@ impl Parser {
                 while self.check(TokenType::Slash) {
                     self.skip(); // consume /
                     stage_path.push('/');
-                    if (self.check(TokenType::Var)
+                    // Use `while` (not `if`) because a single path segment between slashes
+                    // may consist of multiple tokens — e.g., a UUID like `c8b31cea-a6d1-4413`
+                    // tokenizes as Identifier("c8b31cea") + Dash + Identifier("a6d1") + Dash + Number(4413).
+                    while (self.check(TokenType::Var)
                         || self.check_keyword()
-                        || self.is_identifier_token())
+                        || self.is_identifier_token()
+                        || self.check(TokenType::Number)
+                        || self.check(TokenType::Dash))
                         && !self.check_next(TokenType::Eq)
                     {
                         stage_path.push_str(&self.advance().text);
@@ -22790,10 +22796,14 @@ impl Parser {
             while self.check(TokenType::Slash) {
                 self.skip(); // consume /
                 stage_path.push('/');
-                // Get path segment but don't consume if followed by = (that's a parameter)
-                if (self.check(TokenType::Var)
+                // Use `while` (not `if`) because a single path segment between slashes
+                // may consist of multiple tokens — e.g., a UUID like `c8b31cea-a6d1-4413`
+                // tokenizes as Identifier("c8b31cea") + Dash + Identifier("a6d1") + Dash + Number(4413).
+                while (self.check(TokenType::Var)
                     || self.check_keyword()
-                    || self.is_identifier_token())
+                    || self.is_identifier_token()
+                    || self.check(TokenType::Number)
+                    || self.check(TokenType::Dash))
                     && !self.check_next(TokenType::Eq)
                 {
                     stage_path.push_str(&self.advance().text);
@@ -22828,9 +22838,14 @@ impl Parser {
             while self.check(TokenType::Slash) {
                 self.skip(); // consume /
                 stage_path.push('/');
-                if (self.check(TokenType::Var)
+                // Use `while` (not `if`) because a single path segment between slashes
+                // may consist of multiple tokens — e.g., a UUID like `c8b31cea-a6d1-4413`
+                // tokenizes as Identifier("c8b31cea") + Dash + Identifier("a6d1") + Dash + Number(4413).
+                while (self.check(TokenType::Var)
                     || self.check_keyword()
-                    || self.is_identifier_token())
+                    || self.is_identifier_token()
+                    || self.check(TokenType::Number)
+                    || self.check(TokenType::Dash))
                     && !self.check_next(TokenType::Eq)
                 {
                     stage_path.push_str(&self.advance().text);
@@ -22863,9 +22878,11 @@ impl Parser {
                     break;
                 }
                 // Stop at ? (placeholder for stage destination), quoted string
-                // (e.g., '@SYSTEM$BIND/...'), or semicolon
+                // (e.g., '@SYSTEM$BIND/...'), dollar-quoted string (e.g., $$@%"table"$$),
+                // or semicolon
                 if self.check(TokenType::Parameter)
                     || self.check(TokenType::String)
+                    || self.check(TokenType::DollarString)
                     || self.check(TokenType::Semicolon)
                 {
                     break;
@@ -22876,11 +22893,11 @@ impl Parser {
             (source_parts.join(""), false)
         };
 
-        // Parse target stage (@stage_name, ? placeholder, or quoted '@stage')
+        // Parse target stage (@stage_name, ? placeholder, quoted '@stage', or dollar-quoted $$@%"stage"$$)
         let target = if self.match_token(TokenType::Parameter) {
             Expression::Placeholder(Placeholder { index: None })
-        } else if self.check(TokenType::String) {
-            // Quoted stage: '@SYSTEM$BIND/path'
+        } else if self.check(TokenType::String) || self.check(TokenType::DollarString) {
+            // Quoted stage: '@SYSTEM$BIND/path' or $$@%"table"$$
             let tok = self.advance();
             Expression::Literal(Box::new(Literal::String(tok.text.clone())))
         } else {

polyglot_sql-0.3.5/crates/polyglot-sql/tests/postgres_sqlite_regression.rs

@@ -0,0 +1,155 @@
+use polyglot_sql::{transpile, DialectType, Error};
+
+fn pg_to_sqlite(sql: &str) -> String {
+    transpile(sql, DialectType::PostgreSQL, DialectType::SQLite)
+        .expect("PostgreSQL to SQLite transpilation should succeed")
+        .join("; ")
+}
+
+#[test]
+fn postgres_to_sqlite_rewrites_scalar_json_and_dates() {
+    let cases = [
+        ("SELECT LEAST(a, b) FROM t", "SELECT MIN(a, b) FROM t"),
+        ("SELECT GREATEST(a, b) FROM t", "SELECT MAX(a, b) FROM t"),
+        (
+            "SELECT JSON_AGG(name) FROM t",
+            "SELECT JSON_GROUP_ARRAY(name) FROM t",
+        ),
+        (
+            "SELECT JSONB_AGG(name) FROM t",
+            "SELECT JSON_GROUP_ARRAY(name) FROM t",
+        ),
+        (
+            "SELECT JSON_OBJECT_AGG(k, v) FROM t",
+            "SELECT JSON_GROUP_OBJECT(k, v) FROM t",
+        ),
+        (
+            "SELECT JSON_BUILD_OBJECT('id', id, 'name', name) FROM t",
+            "SELECT JSON_OBJECT('id', id, 'name', name) FROM t",
+        ),
+        (
+            "SELECT JSON_BUILD_ARRAY(a, b, c) FROM t",
+            "SELECT JSON_ARRAY(a, b, c) FROM t",
+        ),
+        (
+            "SELECT DATE_PART('year', ts) FROM t",
+            "SELECT CAST(STRFTIME('%Y', ts) AS INTEGER) FROM t",
+        ),
+        (
+            "SELECT DATE_PART('hour', ts) FROM t",
+            "SELECT CAST(STRFTIME('%H', ts) AS INTEGER) FROM t",
+        ),
+        (
+            "SELECT DATE_PART('minute', ts) FROM t",
+            "SELECT CAST(STRFTIME('%M', ts) AS INTEGER) FROM t",
+        ),
+        (
+            "SELECT DATE_PART('second', ts) FROM t",
+            "SELECT CAST(STRFTIME('%f', ts) AS REAL) FROM t",
+        ),
+        (
+            "SELECT DATE_PART('dow', ts) FROM t",
+            "SELECT CAST(STRFTIME('%w', ts) AS INTEGER) FROM t",
+        ),
+        (
+            "SELECT DATE_PART('doy', ts) FROM t",
+            "SELECT CAST(STRFTIME('%j', ts) AS INTEGER) FROM t",
+        ),
+        (
+            "SELECT DATE_PART('epoch', ts) FROM t",
+            "SELECT CAST(STRFTIME('%s', ts) AS REAL) FROM t",
+        ),
+        (
+            "SELECT EXTRACT(YEAR FROM ts) FROM t",
+            "SELECT CAST(STRFTIME('%Y', ts) AS INTEGER) FROM t",
+        ),
+        (
+            "SELECT EXTRACT(HOUR FROM ts) FROM t",
+            "SELECT CAST(STRFTIME('%H', ts) AS INTEGER) FROM t",
+        ),
+        (
+            "SELECT EXTRACT(MINUTE FROM ts) FROM t",
+            "SELECT CAST(STRFTIME('%M', ts) AS INTEGER) FROM t",
+        ),
+        (
+            "SELECT EXTRACT(SECOND FROM ts) FROM t",
+            "SELECT CAST(STRFTIME('%f', ts) AS REAL) FROM t",
+        ),
+        (
+            "SELECT EXTRACT(DOW FROM ts) FROM t",
+            "SELECT CAST(STRFTIME('%w', ts) AS INTEGER) FROM t",
+        ),
+        (
+            "SELECT EXTRACT(DOY FROM ts) FROM t",
+            "SELECT CAST(STRFTIME('%j', ts) AS INTEGER) FROM t",
+        ),
+        (
+            "SELECT EXTRACT(EPOCH FROM ts) FROM t",
+            "SELECT CAST(STRFTIME('%s', ts) AS REAL) FROM t",
+        ),
+        (
+            "SELECT DATE_TRUNC('month', ts) FROM t",
+            "SELECT STRFTIME('%Y-%m-01', ts) FROM t",
+        ),
+        (
+            "SELECT DATE_TRUNC('hour', ts) FROM t",
+            "SELECT STRFTIME('%Y-%m-%d %H:00:00', ts) FROM t",
+        ),
+        (
+            "SELECT DATE_TRUNC('minute', ts) FROM t",
+            "SELECT STRFTIME('%Y-%m-%d %H:%M:00', ts) FROM t",
+        ),
+        (
+            "SELECT DATE_TRUNC('second', ts) FROM t",
+            "SELECT STRFTIME('%Y-%m-%d %H:%M:%S', ts) FROM t",
+        ),
+        (
+            "SELECT DATE_TRUNC('day', ts) FROM t",
+            "SELECT DATE(ts) FROM t",
+        ),
+    ];
+
+    for (sql, expected) in cases {
+        assert_eq!(pg_to_sqlite(sql), expected, "input: {sql}");
+    }
+}
+
+#[test]
+fn postgres_to_sqlite_rewrites_common_syntax_and_types() {
+    let cases = [
+        (
+            "SELECT SUBSTRING(str FROM 2 FOR 5) FROM t",
+            "SELECT SUBSTRING(str, 2, 5) FROM t",
+        ),
+        (
+            "SELECT TRIM(LEADING 'x' FROM str) FROM t",
+            "SELECT LTRIM(str, 'x') FROM t",
+        ),
+        ("SELECT DATE '2023-01-01'", "SELECT '2023-01-01'"),
+        (
+            "CREATE TABLE public.t (id INT, name TEXT)",
+            "CREATE TABLE t (id INTEGER, name TEXT)",
+        ),
+        (
+            "CREATE TABLE t (flag BIT, label NVARCHAR(100), doc TSVECTOR)",
+            "CREATE TABLE t (flag INTEGER, label TEXT, doc TEXT)",
+        ),
+        (
+            "CREATE TABLE t (data JSONB, ts TIMESTAMPTZ)",
+            "CREATE TABLE t (data JSON, ts TEXT)",
+        ),
+    ];
+
+    for (sql, expected) in cases {
+        assert_eq!(pg_to_sqlite(sql), expected, "input: {sql}");
+    }
+}
+
+#[test]
+fn postgres_to_sqlite_rejects_pgvector_distance_operators() {
+    for sql in ["SELECT a <=> b FROM t", "SELECT a <~> b FROM t"] {
+        let err = transpile(sql, DialectType::PostgreSQL, DialectType::SQLite)
+            .expect_err("pgvector distance operators have no SQLite equivalent");
+        assert!(matches!(err, Error::Unsupported { .. }), "{err}");
+    }
+}