django-ormql 0.0.0__py3-none-any.whl

django_ormql/__init__.py

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

django_ormql/columns.py

@@ -0,0 +1,194 @@
+import copy
+import inspect
+
+from django.db.models import F, Expression, OuterRef, Subquery
+from django.db.models.expressions import ResolvedOuterRef
+from django.utils import tree
+from django.utils.module_loading import import_string
+
+from django_ormql.exceptions import QueryNotSupported
+
+
+class BaseColumn:
+    def __init__(self, **kwargs):
+        self.source = kwargs.get("source")
+        self._nullable = kwargs.get("nullable")
+        self.enum_options = kwargs.get("enum_options", None)
+
+    def bind(self, field_name, parent):
+        self.field_name = field_name
+        self.parent = parent
+        if self.source is None:
+            self.source = field_name
+
+    def resolve_column_path(self, remaining_path):
+        return F(self.source)
+
+    @property
+    def sql_type(self):
+        return ""
+
+    @property
+    def nullable(self):
+        return self._nullable
+
+    @nullable.setter
+    def nullable(self, v):
+        self._nullable = v
+
+
+class IntColumn(BaseColumn):
+    sql_type = "INT"
+
+
+class FloatColumn(BaseColumn):
+    sql_type = "FLOAT"
+
+
+class BooleanColumn(BaseColumn):
+    sql_type = "BOOLEAN"
+
+
+class TextColumn(BaseColumn):
+    sql_type = "TEXT"
+
+
+class DateColumn(BaseColumn):
+    sql_type = "DATE"
+
+
+class DateTimeColumn(BaseColumn):
+    sql_type = "DATETIME"
+
+
+class TimeColumn(BaseColumn):
+    sql_type = "TIME"
+
+
+class DurationColumn(BaseColumn):
+    sql_type = "DURATION"
+
+
+class DecimalColumn(BaseColumn):
+    sql_type = "DECIMAL"
+
+
+class JsonColumn(BaseColumn):
+    sql_type = "JSONB"
+
+
+class ModelColumn(BaseColumn):
+    # Fallback if no type matches
+    pass
+
+
+class ForeignKeyColumn(BaseColumn):
+    def __init__(self, related_table, **kwargs):
+        self.related_table = related_table
+        super().__init__(**kwargs)
+
+    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
+        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)
+        elif isinstance(expr, tuple) and len(expr) == 2:
+            # kwarg of Q()
+            return f"{prefix}__{expr[0]}", expr[1]
+        elif isinstance(expr, OuterRef):
+            return OuterRef(f"{prefix}__{expr.name}")
+        elif isinstance(expr, ResolvedOuterRef):
+            return ResolvedOuterRef(f"{prefix}__{expr.name}")
+        elif isinstance(expr, F):
+            return F(f"{prefix}__{expr.name}")
+        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):
+        from .tables import ModelTable
+
+        super().bind(field_name, parent)
+        if self.related_table == "self":
+            self.related_table = parent.__class__
+        elif isinstance(self.related_table, str):
+            if "." in self.related_table:
+                self.related_table = import_string(self.related_table)
+            else:
+                self.related_table = getattr(
+                    inspect.getmodule(parent), self.related_table
+                )
+        elif not issubclass(self.related_table, ModelTable):
+            raise TypeError("Related field does not point to table")
+
+    def resolve_column_path(self, remaining_path):
+        if len(remaining_path) > 20:
+            raise QueryNotSupported("Upper limit of JOINs reached.")
+        rt = self.related_table(is_related=True)
+        if remaining_path:
+            related_field = rt.resolve_column_path(remaining_path)
+
+            if isinstance(related_field, ResolvedOuterRef):
+                return ResolvedOuterRef("__".join([self.source, related_field.name]))
+
+            elif isinstance(related_field, F):
+                return F("__".join([self.source, related_field.name]))
+
+            elif isinstance(related_field, (Expression, tree.Node)):
+                return self._prefix_expression(related_field, self.source)
+
+            elif isinstance(related_field, Subquery):
+                expr = related_field.copy()
+                expr.query.where = self._prefix_expression(
+                    related_field.query.where, self.source
+                )
+                return expr
+
+            else:
+                raise TypeError(f"Unexpected type {type(related_field)}")
+        else:
+            return F("__".join([self.source, "pk"]))
+
+
+class GeneratedColumn(BaseColumn):
+    nullable = True
+
+    def __init__(self, expr, **kwargs):
+        self.expr = expr
+        super().__init__(**kwargs)
+
+    def resolve_column_path(self, remaining_path):
+        return self.expr
+
+
+def get_column_kwargs(model_field):
+    """
+    Creates a default instance of a basic non-relational field.
+    """
+    kwargs = {}
+
+    # The following will only be used by ModelField classes.
+    # Gets removed for everything else.
+    kwargs["model_field"] = model_field
+
+    if model_field.null:
+        kwargs["nullable"] = True
+
+    return kwargs

django_ormql/db_func.py

@@ -0,0 +1,161 @@
+from django.core.exceptions import FieldError
+from django.db.models import Func, fields, Value, ExpressionWrapper, Case, Subquery
+
+
+class Equal(Func):
+    arg_joiner = " = "
+    arity = 2
+    function = ""
+    conditional = True
+
+
+class NotEqual(Func):
+    arg_joiner = " != "
+    arity = 2
+    function = ""
+    conditional = True
+
+
+class GreaterThan(Func):
+    arg_joiner = " > "
+    arity = 2
+    function = ""
+
+
+class GreaterEqualThan(Func):
+    arg_joiner = " >= "
+    arity = 2
+    function = ""
+
+
+class LowerEqualThan(Func):
+    arg_joiner = " <= "
+    arity = 2
+    function = ""
+
+
+class LowerThan(Func):
+    arg_joiner = " < "
+    arity = 2
+    function = ""
+
+
+class Is(Func):
+    arg_joiner = " IS "
+    arity = 2
+    function = ""
+
+
+class Like(Func):
+    arg_joiner = " LIKE "
+    arity = 2
+    function = ""
+
+
+class NumericResolveMixin:
+    def _resolve_output_field(self):
+        # Auto-resolve of INT*DECIMAL to DECIMAL etc
+        source_types = set(
+            type(source) for source in self.get_source_fields() if source is not None
+        )
+        if len(source_types) == 1:
+            return list(source_types)[0]()
+        elif source_types == {fields.DecimalField, fields.IntegerField}:
+            return fields.DecimalField(
+                max_digits=max(
+                    f.max_digits
+                    for f in self.get_source_fields()
+                    if isinstance(f, fields.DecimalField)
+                ),
+                decimal_places=max(
+                    f.decimal_places
+                    for f in self.get_source_fields()
+                    if isinstance(f, fields.DecimalField)
+                ),
+            )
+        elif source_types == {fields.FloatField, fields.IntegerField}:
+            return fields.FloatField()
+        elif source_types == {fields.FloatField, fields.DecimalField}:
+            return fields.DecimalField(
+                max_digits=max(
+                    f.max_digits
+                    for f in self.get_source_fields()
+                    if isinstance(f, fields.DecimalField)
+                ),
+                decimal_places=max(
+                    f.decimal_places
+                    for f in self.get_source_fields()
+                    if isinstance(f, fields.DecimalField)
+                ),
+            )
+        elif source_types == {
+            fields.FloatField,
+            fields.DecimalField,
+            fields.IntegerField,
+        }:
+            return fields.DecimalField(
+                max_digits=max(
+                    f.max_digits
+                    for f in self.get_source_fields()
+                    if isinstance(f, fields.DecimalField)
+                ),
+                decimal_places=max(
+                    f.decimal_places
+                    for f in self.get_source_fields()
+                    if isinstance(f, fields.DecimalField)
+                ),
+            )
+        else:
+            raise FieldError(
+                "Expression contains mixed types: %s."
+                % ", ".join(t.__name__ for t in source_types)
+            )
+
+
+class Add(NumericResolveMixin, Func):
+    arg_joiner = " + "
+    arity = 2
+    function = ""
+
+
+class Sub(NumericResolveMixin, Func):
+    arg_joiner = " - "
+    arity = 2
+    function = ""
+
+
+class Mul(NumericResolveMixin, Func):
+    arg_joiner = " * "
+    arity = 2
+    function = ""
+
+
+class Div(NumericResolveMixin, Func):
+    arg_joiner = " / "
+    arity = 2
+    function = ""
+
+    def __init__(self, *expressions, output_field=None, **extra):
+        # We never want integer division
+        super().__init__(
+            expressions[0],
+            ExpressionWrapper(
+                expressions[1] * Value(1.0), output_field=fields.FloatField()
+            ),
+            output_field=output_field,
+            **extra,
+        )
+
+
+class Mod(NumericResolveMixin, Func):
+    arg_joiner = " %% "
+    arity = 2
+    function = ""
+
+
+class NumericAwareCase(NumericResolveMixin, Case):
+    pass
+
+
+class AutoTypedSubquery(Subquery):
+    pass

django_ormql/engine.py

@@ -0,0 +1,26 @@
+import datetime
+
+from .query import Query
+
+
+class QueryEngine:
+    def __init__(self):
+        self.tables = {}
+
+    def register_table(self, table):
+        self.tables[table.Meta.name] = table
+
+    def query(
+        self,
+        query,
+        placeholders=None,
+        timezone=datetime.timezone.utc,
+        default_limit=None,
+    ):
+        return Query(
+            query,
+            self.tables,
+            placeholders,
+            timezone,
+            default_limit,
+        ).evaluate()

django_ormql/exceptions.py

@@ -0,0 +1,6 @@
+class QueryError(Exception):
+    pass
+
+
+class QueryNotSupported(QueryError):
+    pass

django_ormql/model_utils.py

@@ -0,0 +1,260 @@
+"""
+Vendored from https://github.com/encode/django-rest-framework
+
+Copyright © 2011-present, [Encode OSS Ltd](https://www.encode.io/).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+
+import inspect
+from collections import namedtuple
+from typing import MutableMapping
+
+
+class BindingDict(MutableMapping):
+    """
+    This dict-like object is used to store fields on a serializer.
+
+    This ensures that whenever fields are added to the serializer we call
+    `field.bind()` so that the `field_name` and `parent` attributes
+    can be set correctly.
+    """
+
+    def __init__(self, serializer):
+        self.serializer = serializer
+        self.fields = {}
+
+    def __setitem__(self, key, field):
+        self.fields[key] = field
+        field.bind(field_name=key, parent=self.serializer)
+
+    def __getitem__(self, key):
+        return self.fields[key]
+
+    def __delitem__(self, key):
+        del self.fields[key]
+
+    def __iter__(self):
+        return iter(self.fields)
+
+    def __len__(self):
+        return len(self.fields)
+
+    def __repr__(self):
+        return dict.__repr__(self.fields)
+
+
+class ClassLookupDict:
+    """
+    Takes a dictionary with classes as keys.
+    Lookups against this object will traverses the object's inheritance
+    hierarchy in method resolution order, and returns the first matching value
+    from the dictionary or raises a KeyError if nothing matches.
+    """
+
+    def __init__(self, mapping):
+        self.mapping = mapping
+
+    def __getitem__(self, key):
+        if hasattr(key, "_proxy_class"):
+            # Deal with proxy classes. Ie. BoundField behaves as if it
+            # is a Field instance when using ClassLookupDict.
+            base_class = key._proxy_class
+        else:
+            base_class = key.__class__
+
+        for cls in inspect.getmro(base_class):
+            if cls in self.mapping:
+                return self.mapping[cls]
+        raise KeyError("Class %s not found in lookup." % base_class.__name__)
+
+    def __setitem__(self, key, value):
+        self.mapping[key] = value
+
+
+FieldInfo = namedtuple(
+    "FieldInfo",
+    [
+        "pk",  # Model field instance
+        "fields",  # Dict of field name -> model field instance
+        "forward_relations",  # Dict of field name -> RelationInfo
+        "reverse_relations",  # Dict of field name -> RelationInfo
+        "fields_and_pk",  # Shortcut for 'pk' + 'fields'
+        "relations",  # Shortcut for 'forward_relations' + 'reverse_relations'
+    ],
+)
+
+RelationInfo = namedtuple(
+    "RelationInfo",
+    [
+        "model_field",
+        "related_model",
+        "to_many",
+        "to_field",
+        "has_through_model",
+        "reverse",
+    ],
+)
+
+
+def is_abstract_model(model):
+    """
+    Given a model class, returns a boolean True if it is abstract and False if it is not.
+    """
+    return (
+        hasattr(model, "_meta")
+        and hasattr(model._meta, "abstract")
+        and model._meta.abstract
+    )
+
+
+def _get_pk(opts):
+    pk = opts.pk
+    rel = pk.remote_field
+
+    while rel and rel.parent_link:
+        # If model is a child via multi-table inheritance, use parent's pk.
+        pk = pk.remote_field.model._meta.pk
+        rel = pk.remote_field
+
+    return pk
+
+
+def _get_fields(opts):
+    fields = {}
+    for field in [
+        field for field in opts.fields if field.serialize and not field.remote_field
+    ]:
+        fields[field.name] = field
+
+    return fields
+
+
+def _get_to_field(field):
+    return getattr(field, "to_fields", None) and field.to_fields[0]
+
+
+def _merge_fields_and_pk(pk, fields):
+    fields_and_pk = {"pk": pk, pk.name: pk}
+    fields_and_pk.update(fields)
+
+    return fields_and_pk
+
+
+def _merge_relationships(forward_relations, reverse_relations):
+    return {**forward_relations, **reverse_relations}
+
+
+def _get_forward_relationships(opts):
+    """
+    Returns a dict of field names to `RelationInfo`.
+    """
+    forward_relations = {}
+    for field in [
+        field for field in opts.fields if field.serialize and field.remote_field
+    ]:
+        forward_relations[field.name] = RelationInfo(
+            model_field=field,
+            related_model=field.remote_field.model,
+            to_many=False,
+            to_field=_get_to_field(field),
+            has_through_model=False,
+            reverse=False,
+        )
+
+    # Deal with forward many-to-many relationships.
+    for field in [field for field in opts.many_to_many if field.serialize]:
+        forward_relations[field.name] = RelationInfo(
+            model_field=field,
+            related_model=field.remote_field.model,
+            to_many=True,
+            # manytomany do not have to_fields
+            to_field=None,
+            has_through_model=(not field.remote_field.through._meta.auto_created),
+            reverse=False,
+        )
+
+    return forward_relations
+
+
+def _get_reverse_relationships(opts):
+    """
+    Returns a dict of field names to `RelationInfo`.
+    """
+    reverse_relations = {}
+    all_related_objects = [r for r in opts.related_objects if not r.field.many_to_many]
+    for relation in all_related_objects:
+        accessor_name = relation.get_accessor_name()
+        reverse_relations[accessor_name] = RelationInfo(
+            model_field=None,
+            related_model=relation.related_model,
+            to_many=relation.field.remote_field.multiple,
+            to_field=_get_to_field(relation.field),
+            has_through_model=False,
+            reverse=True,
+        )
+
+    # Deal with reverse many-to-many relationships.
+    all_related_many_to_many_objects = [
+        r for r in opts.related_objects if r.field.many_to_many
+    ]
+    for relation in all_related_many_to_many_objects:
+        accessor_name = relation.get_accessor_name()
+        reverse_relations[accessor_name] = RelationInfo(
+            model_field=None,
+            related_model=relation.related_model,
+            to_many=True,
+            # manytomany do not have to_fields
+            to_field=None,
+            has_through_model=(
+                (getattr(relation.field.remote_field, "through", None) is not None)
+                and not relation.field.remote_field.through._meta.auto_created
+            ),
+            reverse=True,
+        )
+
+    return reverse_relations
+
+
+def get_field_info(model):
+    """
+    Given a model class, returns a `FieldInfo` instance, which is a
+    `namedtuple`, containing metadata about the various field types on the model
+    including information about their relationships.
+    """
+    opts = model._meta.concrete_model._meta
+
+    pk = _get_pk(opts)
+    fields = _get_fields(opts)
+    forward_relations = _get_forward_relationships(opts)
+    reverse_relations = _get_reverse_relationships(opts)
+    fields_and_pk = _merge_fields_and_pk(pk, fields)
+    relationships = _merge_relationships(forward_relations, reverse_relations)
+
+    return FieldInfo(
+        pk, fields, forward_relations, reverse_relations, fields_and_pk, relationships
+    )