django-ormql 0.0.0__tar.gz → 0.0.1__tar.gz

{django_ormql-0.0.0/django_ormql.egg-info → django_ormql-0.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-ormql
-Version: 0.0.0
+Version: 0.0.1
 Summary: ORMQL is a library that allows adding a reporting DSL (that is loosely based on SQL) to your Django project.
 Author-email: Raphael Michel <mail@raphaelmichel.de>
 License-Expression: Apache-2.0
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sqlglot[c]==29.0.1
+Requires-Dist: sqlglot[c]==30.0.3
 Provides-Extra: dev
 Requires-Dist: pytest==9.*; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"

django_ormql-0.0.1/django_ormql/__init__.py

@@ -0,0 +1 @@
+version = "0.0.1"

{django_ormql-0.0.0 → django_ormql-0.0.1}/django_ormql/columns.py

@@ -1,8 +1,7 @@
-import copy
 import inspect
 
 from django.db.models import F, Expression, OuterRef, Subquery
-from django.db.models.expressions import ResolvedOuterRef
+from django.db.models.expressions import ResolvedOuterRef, When
 from django.utils import tree
 from django.utils.module_loading import import_string
 
@@ -22,6 +21,10 @@ class BaseColumn:
             self.source = field_name
 
     def resolve_column_path(self, remaining_path):
+        if remaining_path:
+            raise QueryNotSupported(
+                f"Column '{self.field_name}' is not a related field"
+            )
         return F(self.source)
 
     @property
@@ -89,22 +92,31 @@ class ForeignKeyColumn(BaseColumn):
 
     def _prefix_expression(self, expr, prefix):
         if isinstance(expr, tree.Node):
-            new_expr = expr.create(connector=expr.connector, negated=expr.negated)
             children = []
             for e in expr.children:
                 e = self._prefix_expression(e, prefix)
                 if isinstance(e, F):
                     e = F(f"{prefix}__{expr}")
                 children.append(e)
-            new_expr.children = children
-            return new_expr
+            expr = expr.create(
+                children=children, connector=expr.connector, negated=expr.negated
+            )
+        elif isinstance(expr, When):
+            # Only django-native expression with Q-object-style kwargs
+            args, kwargs = expr._constructor_args
+            args = [self._prefix_expression(a, prefix) for a in args]
+            kwargs = {
+                f"{prefix}__{k}" if k != "then" else k: self._prefix_expression(
+                    e, prefix
+                )
+                for k, e in kwargs.items()
+            }
+            expr = When(*args, **kwargs)
         elif isinstance(expr, Expression):
-            source_expressions = []
-            for e in expr.get_source_expressions():
-                e = self._prefix_expression(e, prefix)
-                source_expressions.append(e)
-            expr = copy.deepcopy(expr)
-            expr.set_source_expressions(source_expressions)
+            args, kwargs = expr._constructor_args
+            args = [self._prefix_expression(a, prefix) for a in args]
+            kwargs = {k: self._prefix_expression(e, prefix) for k, e in kwargs.items()}
+            expr = type(expr)(*args, **kwargs)
         elif isinstance(expr, tuple) and len(expr) == 2:
             # kwarg of Q()
             return f"{prefix}__{expr[0]}", expr[1]
@@ -117,9 +129,6 @@ class ForeignKeyColumn(BaseColumn):
         elif isinstance(expr, Subquery):
             expr = expr.copy()
             expr.query.where = self._prefix_expression(expr.query.where, self.source)
-            return expr
-        else:
-            raise TypeError(f"Unexpected type {expr!r}")
         return expr
 
     def bind(self, field_name, parent):

{django_ormql-0.0.0 → django_ormql-0.0.1}/django_ormql/db_func.py

@@ -1,5 +1,6 @@
 from django.core.exceptions import FieldError
 from django.db.models import Func, fields, Value, ExpressionWrapper, Case, Subquery
+from django.db.models.functions import ConcatPair, Concat
 
 
 class Equal(Func):
@@ -52,14 +53,24 @@ class Like(Func):
     function = ""
 
 
-class NumericResolveMixin:
+class TypeResolveMixin:
     def _resolve_output_field(self):
-        # Auto-resolve of INT*DECIMAL to DECIMAL etc
+        # Auto-resolve of INT*DECIMAL to DECIMAL etc, TEXT and VARCHAR, etc.
         source_types = set(
             type(source) for source in self.get_source_fields() if source is not None
         )
+        text_types = {
+            fields.CharField,
+            fields.TextField,
+            fields.URLField,
+            fields.EmailField,
+            fields.SlugField,
+        }
+        print("sources", source_types)
         if len(source_types) == 1:
             return list(source_types)[0]()
+        elif all(s in text_types for s in source_types):
+            return fields.TextField()
         elif source_types == {fields.DecimalField, fields.IntegerField}:
             return fields.DecimalField(
                 max_digits=max(
@@ -112,25 +123,25 @@ class NumericResolveMixin:
             )
 
 
-class Add(NumericResolveMixin, Func):
+class Add(TypeResolveMixin, Func):
     arg_joiner = " + "
     arity = 2
     function = ""
 
 
-class Sub(NumericResolveMixin, Func):
+class Sub(TypeResolveMixin, Func):
     arg_joiner = " - "
     arity = 2
     function = ""
 
 
-class Mul(NumericResolveMixin, Func):
+class Mul(TypeResolveMixin, Func):
     arg_joiner = " * "
     arity = 2
     function = ""
 
 
-class Div(NumericResolveMixin, Func):
+class Div(TypeResolveMixin, Func):
     arg_joiner = " / "
     arity = 2
     function = ""
@@ -147,15 +158,33 @@ class Div(NumericResolveMixin, Func):
         )
 
 
-class Mod(NumericResolveMixin, Func):
+class Mod(TypeResolveMixin, Func):
     arg_joiner = " %% "
     arity = 2
     function = ""
 
 
-class NumericAwareCase(NumericResolveMixin, Case):
+class NumericAwareCase(TypeResolveMixin, Case):
     pass
 
 
 class AutoTypedSubquery(Subquery):
     pass
+
+
+class PatchedConcatPair(TypeResolveMixin, ConcatPair):
+    pass
+
+
+class PatchedConcat(Concat):
+    def _paired(self, expressions):
+        # wrap pairs of expressions in successive concat functions
+        # exp = [a, b, c, d]
+        # -> ConcatPair(a, ConcatPair(b, ConcatPair(c, d))))
+        if len(expressions) == 2:
+            return PatchedConcatPair(*expressions)
+        return PatchedConcatPair(expressions[0], self._paired(expressions[1:]))
+
+
+def _patch_func(cls):
+    return type(f"Patched{cls.__name__}", (TypeResolveMixin, cls), {})

{django_ormql-0.0.0 → django_ormql-0.0.1}/django_ormql/query.py

@@ -1,6 +1,7 @@
 import logging
 
 from django.conf import settings
+from django.core.exceptions import FieldError
 from django.db import models
 from django.db.models import (
     F,
@@ -18,9 +19,10 @@ from django.db.models.fields.json import KeyTransform
 from django.db.models.functions import Cast
 from sqlglot import parse_one, Dialect, Tokenizer, TokenType, Generator, ParseError
 from sqlglot import expressions
+from sqlglot.errors import ANSI_UNDERLINE, ANSI_RESET
 
 from . import db_func
-from .db_func import NumericAwareCase
+from .db_func import NumericAwareCase, _patch_func
 from .exceptions import QueryNotSupported, QueryError
 
 logger = logging.getLogger(__name__)
@@ -134,20 +136,20 @@ aggregate_nodes = {
 }
 
 function_nodes = {
-    expressions.Coalesce: functions.Coalesce,
-    expressions.Concat: functions.Concat,
-    expressions.Greatest: functions.Greatest,
-    expressions.Least: functions.Least,
-    expressions.Abs: functions.Abs,
-    expressions.Ceil: functions.Ceil,
-    expressions.Floor: functions.Floor,
-    expressions.Mod: functions.Mod,
-    expressions.Left: functions.Left,
-    expressions.Right: functions.Right,
-    expressions.Length: functions.Length,
-    expressions.Lower: functions.Lower,
-    expressions.Upper: functions.Upper,
-    expressions.SubstringIndex: functions.StrIndex,
+    expressions.Coalesce: _patch_func(functions.Coalesce),
+    expressions.Concat: db_func.PatchedConcatPair,
+    expressions.Greatest: _patch_func(functions.Greatest),
+    expressions.Least: _patch_func(functions.Least),
+    expressions.Abs: _patch_func(functions.Abs),
+    expressions.Ceil: _patch_func(functions.Ceil),
+    expressions.Floor: _patch_func(functions.Floor),
+    expressions.Mod: _patch_func(functions.Mod),
+    expressions.Left: _patch_func(functions.Left),
+    expressions.Right: _patch_func(functions.Right),
+    expressions.Length: _patch_func(functions.Length),
+    expressions.Lower: _patch_func(functions.Lower),
+    expressions.Upper: _patch_func(functions.Upper),
+    expressions.SubstringIndex: _patch_func(functions.StrIndex),
 }
 
 types = {
@@ -672,6 +674,9 @@ class Query:
 
         qs = table.base_qs
 
+        if parent_table_stack:
+            qs = qs.order_by()
+
         if root.args.get("where"):
             qs = qs.filter(
                 self._where_to_django(
@@ -812,26 +817,24 @@ class Query:
             if order_by:
                 qs = qs.order_by(*order_by)
 
-            if root.args.get("offset") and root.args.get("limit"):
-                if not isinstance(root.args["limit"].expression, expressions.Literal):
-                    raise QueryNotSupported("LIMIT may only contain literal numbers")
-                if not isinstance(root.args["offset"].expression, expressions.Literal):
+            offset = root.args.get("offset")
+            limit = root.args.get("limit")
+            if offset:
+                if not isinstance(offset.expression, expressions.Literal):
                     raise QueryNotSupported("OFFSET may only contain literal numbers")
-                offset = int(root.args["offset"].expression.this)
-                limit = int(root.args["limit"].expression.this)
-                qs = qs[offset : offset + limit]
-            elif root.args.get("limit"):
-                if not isinstance(root.args["limit"].expression, expressions.Literal):
+                offset = int(offset.expression.this)
+
+            if limit:
+                if not isinstance(limit.expression, expressions.Literal):
                     raise QueryNotSupported("LIMIT may only contain literal numbers")
                 limit = int(root.args["limit"].expression.this)
-                qs = qs[:limit]
-            elif root.args.get("offset"):
-                if not isinstance(root.args["offset"].expression, expressions.Literal):
-                    raise QueryNotSupported("OFFSET may only contain literal numbers")
-                offset = int(root.args["offset"].expression.this)
-                qs = qs[offset:]
-            elif self.default_limit and not parent_table_stack:
-                qs = qs[: self.default_limit]
+            else:
+                limit = self.default_limit
+
+            if offset is not None and limit is not None:
+                qs = qs[offset : offset + limit]
+            elif offset is not None or limit is not None:
+                qs = qs[offset:limit]
 
         return qs, values_names
 
@@ -839,7 +842,8 @@ class Query:
         try:
             ast = parse_one(self.sql, dialect=OrmqlDialect)
         except ParseError as e:
-            raise QueryNotSupported(str(e)) from e
+            msg = str(e).replace(ANSI_UNDERLINE, "").replace(ANSI_RESET, "")
+            raise QueryNotSupported(msg) from e
 
         if settings.DEBUG:
             print(f"Parsed statement: {ast!r}")
@@ -851,13 +855,20 @@ class Query:
             qs, values_names = self._select_to_qs(ast, [])
         except QueryError:
             raise
+        except FieldError as e:
+            raise QueryError("Invalid combination of types") from e
         except Exception as e:
             raise QueryError("Query parsing failed") from e
 
         if isinstance(qs, dict):
             yield {values_names[k]: v for k, v in qs.items()}
         else:
-            if settings.DEBUG:
-                print(f"Generated statement: {qs.query!s}")
-            for row in qs:
-                yield {values_names[k]: v for k, v in row.items() if k in values_names}
+            try:
+                if settings.DEBUG:
+                    print(f"Generated statement: {qs.query!s}")
+                for row in qs:
+                    yield {
+                        values_names[k]: v for k, v in row.items() if k in values_names
+                    }
+            except (FieldError, ValueError) as e:
+                raise QueryError("Invalid combination of types") from e

{django_ormql-0.0.0 → django_ormql-0.0.1/django_ormql.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-ormql
-Version: 0.0.0
+Version: 0.0.1
 Summary: ORMQL is a library that allows adding a reporting DSL (that is loosely based on SQL) to your Django project.
 Author-email: Raphael Michel <mail@raphaelmichel.de>
 License-Expression: Apache-2.0
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sqlglot[c]==29.0.1
+Requires-Dist: sqlglot[c]==30.0.3
 Provides-Extra: dev
 Requires-Dist: pytest==9.*; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"

{django_ormql-0.0.0 → django_ormql-0.0.1}/django_ormql.egg-info/requires.txt

@@ -1,4 +1,4 @@
-sqlglot[c]==29.0.1
+sqlglot[c]==30.0.3
 
 [dev]
 pytest==9.*

{django_ormql-0.0.0 → django_ormql-0.0.1}/pyproject.toml

@@ -24,7 +24,7 @@ classifiers = [
 ]
 requires-python = ">=3.10"
 dependencies = [
-    "sqlglot[c]==29.0.1",
+    "sqlglot[c]==30.0.3",
 ]
 dynamic = ["version"]
 

django_ormql-0.0.0/django_ormql/__init__.py

@@ -1 +0,0 @@
-version = "0.0.0"