omlish 0.0.0.dev268__py3-none-any.whl → 0.0.0.dev270__py3-none-any.whl

omlish/sql/queries/base.py

@@ -1,3 +1,4 @@
+import types
 import typing as ta
 
 from ... import dataclasses as dc
@@ -13,8 +14,118 @@ Value: ta.TypeAlias = ta.Any
 ##
 
 
-class Node(dc.Frozen, lang.Abstract, cache_hash=True):
-    pass
+class NodeComparisonTypeError(TypeError):
+    def __init__(self, cls: type['Node'], *args: ta.Any) -> None:
+        super().__init__(
+            'Query node types are not comparable or hashable - this would be a common source of confusion when '
+            'constructing query filters',
+            cls,
+            *args,
+        )
+
+
+class Node(
+    dc.Frozen,
+    lang.Abstract,
+    eq=False,
+    confer=frozenset([
+        *dc.get_metaclass_params(dc.Frozen).confer,
+        'eq',
+    ]),
+):
+    @ta.final
+    def __hash__(self) -> ta.NoReturn:
+        raise NodeComparisonTypeError(type(self))
+
+    @ta.final
+    def __eq__(self, other) -> ta.NoReturn:
+        raise NodeComparisonTypeError(type(self))
+
+    @ta.final
+    def __ne__(self, other) -> ta.NoReturn:
+        raise NodeComparisonTypeError(type(self))
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class _Fields:
+        cmp_fields: ta.Sequence[str]
+        hash_fields: ta.Sequence[str]
+
+    __node_fields__: ta.ClassVar[tuple[str, ...]]
+
+    @classmethod
+    def _fields(cls) -> _Fields:
+        try:
+            return cls.__dict__['__node_fields__']
+        except KeyError:
+            pass
+
+        dc_info = dc.reflect(cls)
+        fields = Node._Fields(
+            cmp_fields=tuple(f.name for f in dc_info.instance_fields if f.compare),
+            hash_fields=tuple(f.name for f in dc_info.instance_fields if (f.compare if f.hash is None else f.hash)),
+        )
+
+        setattr(cls, '__node_fields__', fields)
+        return fields
+
+    _hash: ta.ClassVar[int]
+
+    def hash(self) -> int:
+        try:
+            return self._hash
+        except AttributeError:
+            pass
+
+        h = hash(tuple(getattr(self, f) for f in self._fields().hash_fields))
+        object.__setattr__(self, '_hash', h)
+        return h
+
+    def eq(self, other: 'Node') -> bool | types.NotImplementedType:
+        if self is other:
+            return True
+
+        def rec(l, r):
+            if l.__class__ is not r.__class__:
+                return NotImplemented
+
+            if isinstance(l, lang.BUILTIN_SCALAR_ITERABLE_TYPES):
+                return l == r
+
+            elif isinstance(l, ta.Mapping):
+                ks = set(l)
+                if set(r) != ks:
+                    return False
+                for k, lv in l.items():
+                    rv = r[k]
+                    if (ret := rec(lv, rv)) is not True:
+                        return ret
+                return True
+
+            elif isinstance(l, ta.Sequence):
+                if len(l) != len(r):
+                    return False
+                for le, re in zip(l, r):
+                    if (ret := rec(le, re)) is not True:
+                        return ret
+                return True
+
+            elif isinstance(l, Node):
+                return l.eq(r)
+
+            else:
+                return l == r
+
+        for f in self._fields().cmp_fields:
+            lf = getattr(self, f)
+            rf = getattr(other, f)
+            if (ret := rec(lf, rf)) is not True:
+                return ret
+        return True
+
+
+##
 
 
 class Builder(lang.Abstract):

omlish/sql/queries/exprs.py

@@ -2,6 +2,7 @@
 TODO:
  - case
  - cast / ::
+ - explicit null? already wrapped in non-null Literal node
 """
 import typing as ta
 
@@ -13,6 +14,9 @@ from .names import CanName
 from .names import Name
 from .names import NameBuilder
 from .names import NameLike
+from .params import CanParam
+from .params import Param
+from .params import ParamBuilder
 
 
 ##
@@ -36,14 +40,21 @@ class NameExpr(Expr, lang.Final):
     n: Name
 
 
+#
+
+
+class ParamExpr(Expr, lang.Final):
+    p: Param
+
+
 ##
 
 
 CanLiteral: ta.TypeAlias = Literal | Value
-CanExpr: ta.TypeAlias = Expr | CanName | CanLiteral
+CanExpr: ta.TypeAlias = Expr | CanParam | CanName | CanLiteral
 
 
-class ExprBuilder(NameBuilder):
+class ExprBuilder(ParamBuilder, NameBuilder):
     def literal(self, o: CanLiteral) -> Literal:
         if isinstance(o, Literal):
             return o
@@ -61,6 +72,8 @@ class ExprBuilder(NameBuilder):
     def expr(self, o: CanExpr) -> Expr:
         if isinstance(o, Expr):
             return o
+        elif isinstance(o, Param):
+            return ParamExpr(o)
         elif isinstance(o, (NameLike, IdentLike)):
             return NameExpr(self.name(o))
         else:

omlish/sql/queries/inserts.py

@@ -2,6 +2,7 @@ import typing as ta
 
 from ... import dataclasses as dc
 from ... import lang
+from .base import Node
 from .exprs import CanExpr
 from .exprs import Expr
 from .exprs import ExprBuilder
@@ -17,7 +18,7 @@ from .stmts import Stmt
 ##
 
 
-class Values(dc.Frozen, lang.Final):
+class Values(Node, lang.Final):
     vs: ta.Sequence[Expr] = dc.xfield(coerce=tuple)
 
 

omlish/sql/queries/marshal.py

@@ -20,6 +20,7 @@ from .multi import MultiKind
 from .relations import JoinKind
 from .relations import Relation
 from .selects import Select
+from .selects import SelectItem
 from .stmts import Stmt
 from .unary import UnaryOp
 from .unary import UnaryOps
@@ -64,29 +65,42 @@ def _install_standard_marshalling() -> None:
         (BinaryOp, BinaryOps),
         (UnaryOp, UnaryOps),
     ]:
-        msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.TypeMapMarshalerFactory({ty: OpMarshalerUnmarshaler(ty, ns)})]
-        msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.TypeMapUnmarshalerFactory({ty: OpMarshalerUnmarshaler(ty, ns)})]
+        msh.install_standard_factories(
+            msh.TypeMapMarshalerFactory({ty: OpMarshalerUnmarshaler(ty, ns)}),
+            msh.TypeMapUnmarshalerFactory({ty: OpMarshalerUnmarshaler(ty, ns)}),
+        )
 
     ets = [
         JoinKind,
         MultiKind,
     ]
-    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.TypeMapMarshalerFactory({t: LowerEnumMarshaler(t) for t in ets})]
-    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.TypeMapUnmarshalerFactory({t: LowerEnumMarshaler(t) for t in ets})]
+    msh.install_standard_factories(
+        msh.TypeMapMarshalerFactory({t: LowerEnumMarshaler(t) for t in ets}),
+        msh.TypeMapUnmarshalerFactory({t: LowerEnumMarshaler(t) for t in ets}),
+    )
 
     for cls in [
         Expr,
         Node,
         Relation,
+        SelectItem,
         Stmt,
     ]:
-        p = msh.polymorphism_from_subclasses(cls, naming=msh.Naming.SNAKE)
-        msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.PolymorphismMarshalerFactory(p)]
-        msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.PolymorphismUnmarshalerFactory(p)]
+        p = msh.polymorphism_from_subclasses(
+            cls,
+            naming=msh.Naming.SNAKE,
+            strip_suffix='auto',
+        )
+        msh.install_standard_factories(
+            msh.PolymorphismMarshalerFactory(p),
+            msh.PolymorphismUnmarshalerFactory(p),
+        )
 
     insert_data_impls = msh.Impls([
         msh.Impl(Values, 'values'),
         msh.Impl(Select, 'select'),
     ])
-    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.PolymorphismUnionMarshalerFactory(insert_data_impls)]
-    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.PolymorphismUnionUnmarshalerFactory(insert_data_impls)]
+    msh.install_standard_factories(
+        msh.PolymorphismUnionMarshalerFactory(insert_data_impls),
+        msh.PolymorphismUnionUnmarshalerFactory(insert_data_impls),
+    )

omlish/sql/queries/params.py

@@ -1,14 +1,15 @@
 import typing as ta
 
+from ... import dataclasses as dc
 from ... import lang
 from .base import Builder
-from .exprs import Expr
 
 
 ##
 
 
-class Param(Expr, lang.Final):
+@dc.dataclass(frozen=True)
+class Param(lang.Final):
     n: str | None = None
 
     def __repr__(self) -> str:

omlish/sql/queries/rendering.py

@@ -29,6 +29,7 @@ from .binary import BinaryOp
 from .binary import BinaryOps
 from .exprs import Literal
 from .exprs import NameExpr
+from .exprs import ParamExpr
 from .idents import Ident
 from .inserts import Insert
 from .inserts import Values
@@ -39,8 +40,9 @@ from .params import Param
 from .relations import Join
 from .relations import JoinKind
 from .relations import Table
+from .selects import AllSelectItem
+from .selects import ExprSelectItem
 from .selects import Select
-from .selects import SelectItem
 from .unary import Unary
 from .unary import UnaryOp
 from .unary import UnaryOps
@@ -149,8 +151,8 @@ class StdRenderer(Renderer):
         return self.render(o.n)
 
     @Renderer.render.register
-    def render_param(self, o: Param) -> tp.Part:
-        return self._params_preparer.add(o.n if o.n is not None else id(o))
+    def render_param_expr(self, o: ParamExpr) -> tp.Part:
+        return self.render(o.p)
 
     # idents
 
@@ -201,6 +203,12 @@ class StdRenderer(Renderer):
             out.append(self.render(i))
         return tp.Concat(out)
 
+    # params
+
+    @Renderer.render.register
+    def render_param(self, o: Param) -> tp.Part:
+        return self._params_preparer.add(o.n if o.n is not None else id(o))
+
     # relations
 
     @Renderer.render.register
@@ -235,7 +243,11 @@ class StdRenderer(Renderer):
     # selects
 
     @Renderer.render.register
-    def render_select_item(self, o: SelectItem) -> tp.Part:
+    def render_all_select_item(self, o: AllSelectItem) -> tp.Part:
+        return '*'
+
+    @Renderer.render.register
+    def render_expr_select_item(self, o: ExprSelectItem) -> tp.Part:
         return [
             self.render(o.v),
             *(['as', self.render(o.a)] if o.a is not None else []),

omlish/sql/queries/selects.py

@@ -16,11 +16,22 @@ from .stmts import Stmt
 ##
 
 
-class SelectItem(Node, lang.Final):
+class SelectItem(Node, lang.Abstract):
+    pass
+
+
+class AllSelectItem(SelectItem, lang.Final):
+    pass
+
+
+class ExprSelectItem(SelectItem, lang.Final):
     v: Expr
     a: Ident | None = dc.xfield(None, repr_fn=dc.opt_repr)
 
 
+##
+
+
 class Select(Stmt, lang.Final):
     items: ta.Sequence[SelectItem] = dc.xfield(coerce=tuple)
     from_: Relation | None = dc.xfield(None, repr_fn=dc.opt_repr)
@@ -31,11 +42,15 @@ CanSelectItem: ta.TypeAlias = SelectItem | CanExpr
 
 
 class SelectBuilder(RelationBuilder, ExprBuilder):
+    @property
+    def star(self) -> AllSelectItem:
+        return AllSelectItem()
+
     def select_item(self, o: CanSelectItem) -> SelectItem:
         if isinstance(o, SelectItem):
             return o
         else:
-            return SelectItem(self.expr(o))
+            return ExprSelectItem(self.expr(o))
 
     def select(
             self,

omlish/sql/tabledefs/marshal.py

@@ -6,8 +6,10 @@ from .elements import Element
 
 def _install_poly(cls: type) -> None:
     p = msh.polymorphism_from_subclasses(cls, naming=msh.Naming.SNAKE)
-    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.PolymorphismMarshalerFactory(p)]
-    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.PolymorphismUnmarshalerFactory(p)]
+    msh.install_standard_factories(
+        msh.PolymorphismMarshalerFactory(p),
+        msh.PolymorphismUnmarshalerFactory(p),
+    )
 
 
 @lang.static_init

{omlish-0.0.0.dev268.dist-info → omlish-0.0.0.dev270.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev268
+Version: 0.0.0.dev270
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause