sqlobjects 1.2.4__tar.gz → 1.2.5__tar.gz

{sqlobjects-1.2.4 → sqlobjects-1.2.5}/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 1.2.5 (2026-03-06)
+
+### Fix
+
+- **examples,docs**: fix PGVECTOR type definition and documentation errors
+- **types**: fix JSON/JSONB field containment query generating wrong SQL
+
 ## 1.2.4 (2026-02-28)
 
 ### Fix

{sqlobjects-1.2.4/sqlobjects.egg-info → sqlobjects-1.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlobjects
-Version: 1.2.4
+Version: 1.2.5
 Summary: Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>

{sqlobjects-1.2.4 → sqlobjects-1.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlobjects"
-version = "1.2.4"
+version = "1.2.5"
 description = "Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading"
 readme = "README.md"
 license = "MIT"

{sqlobjects-1.2.4 → sqlobjects-1.2.5}/sqlobjects/expressions/function.py

@@ -147,6 +147,8 @@ class FunctionExpression:
     for building complex database expressions.
     """
 
+    is_clause_element = False  # prevent __getattr__ from proxying this to expression.is_clause_element
+
     if TYPE_CHECKING:
         # Inherit all method hints for IDE support
         def __new__(cls, *args, **kwargs) -> "FunctionExpression & _FunctionMethods": ...  # type: ignore

{sqlobjects-1.2.4 → sqlobjects-1.2.5}/sqlobjects/expressions/mixins.py

@@ -247,9 +247,25 @@ class ColumnAttributeFunctionMixin(FunctionMixin):
         def extract(self, field: str) -> "FunctionExpression": ...
         def date_trunc(self, precision: str) -> "FunctionExpression": ...
 
-        # JSON methods
-        def extract_path(self, path) -> "FunctionExpression": ...
-        def extract_text(self, path) -> "FunctionExpression": ...
+        # JSON methods (MySQL json type)
+        def json_extract(self, path: str) -> "FunctionExpression": ...
+        def json_unquote(self, path: str) -> "FunctionExpression": ...
+        def json_contains(self, other, path: str | None = None) -> "FunctionExpression": ...
+        def json_contains_path(self, *paths: str, match: str = "one") -> "FunctionExpression": ...
+        def json_length(self, path: str | None = None) -> "FunctionExpression": ...
+        def json_keys(self, path: str | None = None) -> "FunctionExpression": ...
+        def json_overlaps(self, other) -> "FunctionExpression": ...
+        def json_search(self, value: str, match: str = "one", path: str | None = None) -> "FunctionExpression": ...
+        def json_type(self) -> "FunctionExpression": ...
+
+        # JSONB methods (PostgreSQL jsonb type)
+        def contained_by(self, other) -> "FunctionExpression": ...
+        def has_key(self, other) -> "FunctionExpression": ...
+        def has_all(self, other) -> "FunctionExpression": ...
+        def has_any(self, other) -> "FunctionExpression": ...
+        def path_exists(self, other) -> "FunctionExpression": ...
+        def path_match(self, other) -> "FunctionExpression": ...
+        def delete_path(self, array) -> "FunctionExpression": ...
 
         # Common methods (all types)
         def sum(self) -> "FunctionExpression": ...

{sqlobjects-1.2.4 → sqlobjects-1.2.5}/sqlobjects/fields/types/comparators.py

@@ -323,13 +323,62 @@ class DateTimeComparator(ComparatorMixin, DateTime.Comparator):  # type: ignore[
 
 
 class JSONComparator(ComparatorMixin, JSON.Comparator):  # type: ignore[reportIncompatibleMethodOverride]
-    """JSON type comparator with JSON extraction and manipulation methods."""
+    """MySQL JSON type comparator. For PostgreSQL, use jsonb type instead."""
 
-    def extract_path(self, path) -> FunctionExpression:
-        return FunctionExpression(func.json_extract_path(self, path))
+    def json_extract(self, path: str) -> FunctionExpression:
+        """JSON_EXTRACT(col, path) - e.g. json_extract('$.name')"""
+        return FunctionExpression(func.json_extract(self, path))
 
-    def extract_text(self, path) -> FunctionExpression:
-        return FunctionExpression(func.json_extract_path_text(self, path))
+    def json_unquote(self, path: str) -> FunctionExpression:
+        """JSON_UNQUOTE(JSON_EXTRACT(col, path)) - returns unquoted string value"""
+        return FunctionExpression(func.json_unquote(func.json_extract(self, path)))
+
+    def json_contains(self, other, path: str | None = None) -> FunctionExpression:
+        """JSON_CONTAINS(col, val[, path]) - check if JSON contains value"""
+        import json
+
+        from sqlalchemy import literal
+
+        value = [other] if not isinstance(other, (list, dict)) else other
+        json_val = literal(json.dumps(value))
+        if path is not None:
+            return FunctionExpression(func.json_contains(self, json_val, path))
+        return FunctionExpression(func.json_contains(self, json_val))
+
+    def json_contains_path(self, *paths: str, match: str = "one") -> FunctionExpression:
+        """JSON_CONTAINS_PATH(col, 'one'|'all', path, ...) - check if path(s) exist"""
+        return FunctionExpression(func.json_contains_path(self, match, *paths))
+
+    def json_length(self, path: str | None = None) -> FunctionExpression:
+        """JSON_LENGTH(col[, path]) - array/object length"""
+        if path is not None:
+            return FunctionExpression(func.json_length(self, path))
+        return FunctionExpression(func.json_length(self))
+
+    def json_keys(self, path: str | None = None) -> FunctionExpression:
+        """JSON_KEYS(col[, path]) - return all keys as JSON array"""
+        if path is not None:
+            return FunctionExpression(func.json_keys(self, path))
+        return FunctionExpression(func.json_keys(self))
+
+    def json_overlaps(self, other) -> FunctionExpression:
+        """JSON_OVERLAPS(col, val) - check if two JSON documents share any key-value pairs (MySQL 8.0+)"""
+        import json
+
+        from sqlalchemy import literal
+
+        value = other if isinstance(other, str) else json.dumps(other)
+        return FunctionExpression(func.json_overlaps(self, literal(value)))
+
+    def json_search(self, value: str, match: str = "one", path: str | None = None) -> FunctionExpression:
+        """JSON_SEARCH(col, 'one'|'all', val[, path]) - find path of value"""
+        if path is not None:
+            return FunctionExpression(func.json_search(self, match, value, None, path))
+        return FunctionExpression(func.json_search(self, match, value))
+
+    def json_type(self) -> FunctionExpression:
+        """JSON_TYPE(col) - return JSON value type as string"""
+        return FunctionExpression(func.json_type(self))
 
 
 class BooleanComparator(ComparatorMixin, Boolean.Comparator):  # type: ignore[reportIncompatibleMethodOverride]

{sqlobjects-1.2.4 → sqlobjects-1.2.5}/sqlobjects/fields/types/registry.py

@@ -1,9 +1,10 @@
 import inspect
 from typing import Any, Callable, NotRequired, TypedDict
 
+from sqlalchemy.dialects.mysql import JSON
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.sql.sqltypes import (
     ARRAY,
-    JSON,
     BigInteger,
     Boolean,
     Date,
@@ -344,14 +345,15 @@ class TypeRegistry:
             (Interval, "interval", DateTimeComparator, [], {}),
             (LargeBinary, "binary", DefaultComparator, ["bytes"], {}),
             (Uuid, "uuid", StringComparator, [], {}),
-            (JSON, "json", JSONComparator, ["dict"], {}),
         ]
 
-        # Special types
+        # Special types: dialect-specific or non-standard types
         special_types = [
-            (ARRAY, "array", DefaultComparator, [], {}),
+            (ARRAY, "array", DefaultComparator, [], {}),  # PostgreSQL only
             (Enum, "enum", DefaultComparator, [], {}),
             (Auto, "auto", DefaultComparator, [], {}),
+            (JSON, "json", JSONComparator, ["dict"], {}),  # MySQL: contains -> JSON_CONTAINS
+            (JSONB, "jsonb", JSONB.Comparator, [], {}),  # PostgreSQL: contains -> @>
         ]
 
         for field_type, name, comparator, aliases, defaults in builtin_types + special_types:

{sqlobjects-1.2.4 → sqlobjects-1.2.5/sqlobjects.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlobjects
-Version: 1.2.4
+Version: 1.2.5
 Summary: Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>