Refactor: migration to sqlparser-rs instead of sea-query

Cargo.toml

@@ -16,51 +16,29 @@ crate-type = ["cdylib", "rlib"]
 [profile.dev]
 lto = true
 panic = "unwind"
-strip = true
+strip = false
 
 [profile.release]
 codegen-units = 1
 debug = false
 incremental = false
 lto = true
-panic = "unwind"
-strip = true
+panic = "abort"
+strip = false
 
 [dependencies]
-pyo3 = { version = "0.28", default-features = false, features = ["macros", "extension-module", "chrono", "uuid", "rust_decimal", "generate-import-lib"] }
-pgvector = { version = "~0.4", default-features = false }
+pyo3 = { version = "0.29", default-features = false, features = ["macros", "experimental-inspect", "chrono"] }
+parking_lot = { version = "0.12", default-features = false }
+sqlparser = { version = "0.62", default-features = false, features = ["recursive", "recursive-protection", "visitor"] }
+arcstr = { version = "1.2" }
+chrono = { version = "0.4", default-features = false, features = ["clock"] }
 ipnetwork = { version = "0.20", default-features = false }
 mac_address = { version = "1.1", default-features = false }
-uuid = { version = "1.18.1", default-features = false, features = ["v4"] }
-chrono = { version = "0.4.27", default-features = false, features = ["clock"] }
-serde_json = { version = "1", default-features = false, features = ["std"] }
-rust_decimal = { version = "1.38.0", default-features = false }
-indexmap = { version = "2.12.0", default-features = false, features = ["std"]}
-parking_lot = { version = "0.12.4", default-features = false }
-
-[dependencies.sea-query]
-version = "0.32.7"
-default-features = false
-features = [
-    "backend-mysql",
-    "backend-postgres",
-    "backend-sqlite",
-    "thread-safe",
-    "with-chrono",
-    "with-json",
-    "with-rust_decimal",
-    "with-uuid",
-    "with-ipnetwork",
-    "with-mac_address",
-    "postgres-array",
-    "postgres-interval",
-    "postgres-vector",
-    "hashable-value"
-]
 
 [features]
-default = ["optimize"]
-optimize = []
+default = ["extension-module", "experimental-inspect"]
+extension-module = ["pyo3/extension-module"]
+experimental-inspect = ["pyo3/experimental-inspect"]
 
 [lints.clippy]
 dbg_macro = "warn"

rapidquery/__init__.py

@@ -5,56 +5,4 @@
 prioritizes both performance and ease of use.
 """
 
-from ._lib import common as common
-from ._lib import mysql as mysql
-from ._lib import postgres as postgres
-from ._lib import query as query
-from ._lib import schema as schema
-from ._lib import sqlite as sqlite
-from ._lib import sqltypes as sqltypes
-
-# Export .common
-Column = common.Column
-ColumnRef = common.ColumnRef
-Expr = common.Expr
-ForeignKey = common.ForeignKey
-Func = common.Func
-TableName = common.TableName
-Value = common.Value
-all = common.all
-any = common.any
-not_ = common.not_
-
-# Export .query
-CaseStatement = query.CaseStatement
-DeleteStatement = query.DeleteStatement
-Frame = query.Frame
-InsertStatement = query.InsertStatement
-OnConflict = query.OnConflict
-Ordering = query.Ordering
-QueryStatement = query.QueryStatement
-Returning = query.Returning
-SelectLabel = query.SelectLabel
-SelectStatement = query.SelectStatement
-UpdateStatement = query.UpdateStatement
-WindowStatement = query.WindowStatement
-WithClause = query.WithClause
-WithQuery = query.WithQuery
-
-# Export .schema
-AlterTable = schema.AlterTable
-AlterTableAddColumnOption = schema.AlterTableAddColumnOption
-AlterTableAddForeignKeyOption = schema.AlterTableAddForeignKeyOption
-AlterTableBaseOption = schema.AlterTableBaseOption
-AlterTableDropColumnOption = schema.AlterTableDropColumnOption
-AlterTableDropForeignKeyOption = schema.AlterTableDropForeignKeyOption
-AlterTableModifyColumnOption = schema.AlterTableModifyColumnOption
-AlterTableRenameColumnOption = schema.AlterTableRenameColumnOption
-DropIndex = schema.DropIndex
-DropTable = schema.DropTable
-Index = schema.Index
-IndexColumn = schema.IndexColumn
-RenameTable = schema.RenameTable
-SchemaStatement = schema.SchemaStatement
-Table = schema.Table
-TruncateTable = schema.TruncateTable
+from . import _lib as _lib

rapidquery/_lib/__init__.pyi

@@ -2,22 +2,5 @@
 RapidQuery core which is written in Rust.
 """
 
-from __future__ import annotations
-
-from . import common as common
-from . import mysql as mysql
-from . import postgres as postgres
-from . import query as query
-from . import schema as schema
-from . import sqlite as sqlite
-from . import sqltypes as sqltypes
-
-__all__ = [
-    "sqltypes",
-    "schema",
-    "query",
-    "common",
-    "sqlite",
-    "postgres",
-    "mysql",
-]
+from _typeshed import Incomplete
+def __getattr__(name: str) -> Incomplete: ...

rapidquery/_lib/ast/data_type.pyi

@@ -0,0 +1,158 @@
+from rapidquery._lib.dialect import BigQueryDialect, DatabricksDialect, DuckDbDialect, HiveDialect, MsSqlDialect, MySqlDialect, OracleDialect, PostgreSqlDialect, RedshiftDialect, SQLiteDialect, SnowflakeDialect, SparkDialect, TeradataDialect
+from typing import Any, Callable, final
+
+@final
+class ArraySerializer:
+    """
+    Serializes a Python `list`/`tuple` by serializing each element with `element`
+    and wrapping in `ARRAY[...]`.
+    """
+    def __new__(cls, /, element: 'ArraySerializer' |'BitSerializer' |'BooleanSerializer' |'BytesSerializer' |'DateSerializer' |'DatetimeSerializer' |'FloatSerializer' |'InetSerializer' |'IntegerSerializer' |'JSONSerializer' |'MacAddressSerializer' |'StringSerializer' |'TimeSerializer' |'UnspecifiedSerializer' |'UuidSerializer' |Callable[[BigQueryDialect |DatabricksDialect |DuckDbDialect |HiveDialect |MsSqlDialect |MySqlDialect |OracleDialect |PostgreSqlDialect |RedshiftDialect |SnowflakeDialect |SparkDialect |SQLiteDialect |TeradataDialect, str], str]) -> ArraySerializer: ...
+
+@final
+class BitSerializer:
+    """
+    Serializes a bit string given as a `str` of `0`/`1` (e.g. `"1010"`) into a
+    `B'1010'` literal.
+    """
+    def __new__(cls, /) -> BitSerializer: ...
+
+@final
+class BooleanSerializer:
+    def __new__(cls, /) -> BooleanSerializer: ...
+
+@final
+class BytesSerializer:
+    """
+    Serializes a `uuid.UUID` (or 36-char `str`) as a quoted literal.
+    """
+    def __new__(cls, /) -> BytesSerializer: ...
+
+@final
+class DataType:
+    """
+    Reperesents a SQL data type. It includes a name, and a serializer.
+
+    The name of a SQL data type can be any string; it is not limited to a set of predefined values.
+    Additionally, the serializer for each data type is fully customizable.
+    """
+    def __new__(cls, /, name: str, serializer: 'ArraySerializer' |'BitSerializer' |'BooleanSerializer' |'BytesSerializer' |'DateSerializer' |'DatetimeSerializer' |'FloatSerializer' |'InetSerializer' |'IntegerSerializer' |'JSONSerializer' |'MacAddressSerializer' |'StringSerializer' |'TimeSerializer' |'UnspecifiedSerializer' |'UuidSerializer' |Callable[[BigQueryDialect |DatabricksDialect |DuckDbDialect |HiveDialect |MsSqlDialect |MySqlDialect |OracleDialect |PostgreSqlDialect |RedshiftDialect |SnowflakeDialect |SparkDialect |SQLiteDialect |TeradataDialect, str], str] |None = None) -> DataType:
+        """
+        Creates a new SQL data type.
+
+        Args:
+            name: The name of a data type. it is not limited to a set of predefined values.
+            serializer: The `serializer` is used whenever a Python object needs to be converted
+                        into a valid SQL value during query construction. This is commonly required
+                        when setting default values, inserting data, or generating other SQL statements.
+                        You can use one of the built-in serializers (we provide ready-to-use
+                        serializers for most common data types), or you can create and register your
+                        own custom serializer. This parameter is optional. However, it is strongly
+                        recommended to always specify it explicitly. If you do not provide a serializer,
+                        the `DataType` will attempt to automatically detect and assign one based on the
+                        `name`. If no suitable serializer is found, it will fall back to `UnspecifiedSerializer`.
+        """
+    def __repr__(self, /) -> str: ...
+    @property
+    def name(self, /) -> str:
+        """
+        Returns data type name.
+        """
+    def serialize(self, /, dialect: BigQueryDialect |DatabricksDialect |DuckDbDialect |HiveDialect |MsSqlDialect |MySqlDialect |OracleDialect |PostgreSqlDialect |RedshiftDialect |SnowflakeDialect |SparkDialect |SQLiteDialect |TeradataDialect |type[BigQueryDialect] |type[DatabricksDialect] |type[DuckDbDialect] |type[HiveDialect] |type[MsSqlDialect] |type[MySqlDialect] |type[OracleDialect] |type[PostgreSqlDialect] |type[RedshiftDialect] |type[SnowflakeDialect] |type[SparkDialect] |type[SQLiteDialect] |type[TeradataDialect], value: Any) -> str:
+        """
+        Uses configured serializer to serialize `value` to SQL, depend on the specified `dialect`.
+        """
+    @property
+    def serializer(self, /) -> Any:
+        """
+        Returns data type serializer.
+        """
+
+@final
+class DateSerializer:
+    """
+    `datetime.date` -> `'YYYY-MM-DD'`.
+    """
+    def __new__(cls, /) -> DateSerializer: ...
+
+@final
+class DatetimeSerializer:
+    """
+    `datetime.datetime` -> `'YYYY-MM-DD HH:MM:SS[.ffffff][+HH:MM]'`.
+
+    `int`/`float` are treated as a UTC epoch and accepted too.
+    """
+    def __new__(cls, /) -> DatetimeSerializer: ...
+
+@final
+class FloatSerializer:
+    """
+    Serializes Python `float`, `int`, `decimal.Decimal`, or numeric `str` as a
+    bare numeric literal.
+
+    `Decimal`/`str`/`int` go through their exact text form (no precision loss);
+    only a real `float` is formatted from the f64. Non-finite floats are rejected.
+    """
+    def __new__(cls, /) -> FloatSerializer: ...
+
+@final
+class InetSerializer:
+    """
+    `str` (or `ipaddress.*`) -> quoted literal. Validated as IPv4/IPv6 network.
+    """
+    def __new__(cls, /) -> InetSerializer: ...
+
+@final
+class IntegerSerializer:
+    """
+    Serializes any Python `int` as a bare decimal literal.
+
+    Uses `str(int)` so arbitrary precision (beyond i64/u64) is preserved - one
+    serializer genuinely covers TINYINT through BIGINT and the unsigned variants.
+    """
+    def __new__(cls, /) -> IntegerSerializer: ...
+
+@final
+class JSONSerializer:
+    """
+    Serializes any JSON-encodable Python object via `json.dumps`, then wraps the
+    result as a quoted string literal.
+    """
+    def __new__(cls, /) -> JSONSerializer: ...
+
+@final
+class MacAddressSerializer:
+    """
+    `str` -> quoted literal. Validated as a MAC address.
+    """
+    def __new__(cls, /) -> MacAddressSerializer: ...
+
+@final
+class StringSerializer:
+    """
+    Serializes a Python `str` (or `enum.Enum` whose value is a str) as a quoted,
+    escaped string literal: `"LIKE"` -> `'LIKE'`.
+    """
+    def __new__(cls, /) -> StringSerializer: ...
+
+@final
+class TimeSerializer:
+    """
+    `datetime.time` -> `'HH:MM:SS[.ffffff]'`.
+    """
+    def __new__(cls, /) -> TimeSerializer: ...
+
+@final
+class UnspecifiedSerializer:
+    """
+    When you don't know about data type, you can use this. Uses values' `__str__` method
+    and return it as a serialized SQL value.
+    """
+    def __new__(cls, /) -> UnspecifiedSerializer: ...
+
+@final
+class UuidSerializer:
+    """
+    Serializes a `uuid.UUID` (or 36-char `str`) as a quoted literal.
+    """
+    def __new__(cls, /) -> UuidSerializer: ...