omlish 0.0.0.dev73__tar.gz → 0.0.0.dev74__tar.gz

{omlish-0.0.0.dev73/omlish.egg-info → omlish-0.0.0.dev74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev73
+Version: 0.0.0.dev74
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev73 → omlish-0.0.0.dev74}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev73'
-__revision__ = '1fa2fcb99d4ea871fe3f5aa5c094ae37d0b1090c'
+__version__ = '0.0.0.dev74'
+__revision__ = '002d07c8f9579e6b60584c9b2c6c05cd6b7219af'
 
 
 #

{omlish-0.0.0.dev73 → omlish-0.0.0.dev74}/omlish/dataclasses/impl/fields.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - point validate / check exceptions to lambdas
+"""
 import dataclasses as dc
 import types
 import typing as ta

{omlish-0.0.0.dev73 → omlish-0.0.0.dev74}/omlish/dataclasses/impl/metaclass.py

@@ -108,7 +108,11 @@ class DataMeta(abc.ABCMeta):
 
 
 # @ta.dataclass_transform(field_specifiers=(field,))  # FIXME: ctor
-class Data(metaclass=DataMeta):
+class Data(
+    eq=False,
+    order=False,
+    metaclass=DataMeta,
+):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
@@ -125,6 +129,8 @@ class Data(metaclass=DataMeta):
 class Frozen(
     Data,
     frozen=True,
+    eq=False,
+    order=False,
     confer=frozenset([
         'frozen',
         'cache_hash',

{omlish-0.0.0.dev73 → omlish-0.0.0.dev74}/omlish/marshal/enums.py

@@ -28,7 +28,7 @@ class EnumMarshalerFactory(MarshalerFactory):
     def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
         ty = check.isinstance(rty, type)
         check.state(issubclass(ty, enum.Enum))
-        return EnumMarshaler(ty)
+        return EnumMarshaler(ty)  # noqa
 
 
 @dc.dataclass(frozen=True)

{omlish-0.0.0.dev73 → omlish-0.0.0.dev74}/omlish/sql/queries/__init__.py

@@ -11,6 +11,10 @@ from .binary import (  # noqa
     BinaryOps,
 )
 
+from .building import (  # noqa
+    StdBuilder,
+)
+
 from .exprs import (  # noqa
     CanExpr,
     CanLiteral,
@@ -18,6 +22,7 @@ from .exprs import (  # noqa
     ExprBuilder,
     Literal,
     NameExpr,
+    Param,
 )
 
 from .idents import (  # noqa
@@ -29,8 +34,7 @@ from .idents import (  # noqa
 from .multi import (  # noqa
     Multi,
     MultiBuilder,
-    MultiOp,
-    MultiOps,
+    MultiKind,
 )
 
 from .names import (  # noqa
@@ -39,6 +43,10 @@ from .names import (  # noqa
     NameBuilder,
 )
 
+from .ops import (  # noqa
+    OpKind,
+)
+
 from .relations import (  # noqa
     CanRelation,
     CanTable,
@@ -47,6 +55,12 @@ from .relations import (  # noqa
     Table,
 )
 
+from .rendering import (  # noqa
+    Renderer,
+    StdRenderer,
+    render,
+)
+
 from .selects import (  # noqa
     CanRelation,
     Select,
@@ -54,10 +68,6 @@ from .selects import (  # noqa
     SelectItem,
 )
 
-from .std import (  # noqa
-    StdBuilder,
-)
-
 from .stmts import (  # noqa
     CanExpr,
     ExprStmt,
@@ -77,3 +87,11 @@ from .unary import (  # noqa
 
 
 Q = StdBuilder()
+
+
+##
+
+
+from ...lang.imports import _register_conditional_import  # noqa
+
+_register_conditional_import('...marshal', '.marshal', __package__)

omlish-0.0.0.dev74/omlish/sql/queries/binary.py

@@ -0,0 +1,95 @@
+"""
+TODO:
+ - in_
+ - like
+  - no this is a dedicated node, escape / negation in grammar
+"""
+from ... import check
+from ... import dataclasses as dc
+from ... import lang
+from .exprs import CanExpr
+from .exprs import Expr
+from .exprs import ExprBuilder
+from .ops import OpKind
+
+
+##
+
+
+class BinaryOp(dc.Frozen, lang.Final, eq=False):
+    name: str
+    kind: OpKind
+
+
+class BinaryOps(lang.Namespace):
+    EQ = BinaryOp('eq', OpKind.CMP)
+    NE = BinaryOp('ne', OpKind.CMP)
+    LT = BinaryOp('lt', OpKind.CMP)
+    LE = BinaryOp('le', OpKind.CMP)
+    GT = BinaryOp('gt', OpKind.CMP)
+    GE = BinaryOp('ge', OpKind.CMP)
+
+    ADD = BinaryOp('add', OpKind.ARITH)
+    SUB = BinaryOp('sub', OpKind.ARITH)
+    MUL = BinaryOp('mul', OpKind.ARITH)
+    DIV = BinaryOp('div', OpKind.ARITH)
+    MOD = BinaryOp('mod', OpKind.ARITH)
+
+    CONCAT = BinaryOp('concat', OpKind.STR)
+
+
+class Binary(Expr, lang.Final):
+    op: BinaryOp
+    l: Expr
+    r: Expr
+
+
+class BinaryBuilder(ExprBuilder):
+    def binary(self, op: BinaryOp, *es: CanExpr) -> Expr:
+        check.not_empty(es)
+        l = self.expr(es[0])
+        for r in es[1:]:
+            l = Binary(op, l, self.expr(r))
+        return l
+
+    #
+
+    def eq(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.EQ, *es)
+
+    def ne(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.NE, *es)
+
+    def lt(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.LT, *es)
+
+    def le(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.LE, *es)
+
+    def gt(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.GT, *es)
+
+    def ge(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.GE, *es)
+
+    #
+
+    def add(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.ADD, *es)
+
+    def sub(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.SUB, *es)
+
+    def mul(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.MUL, *es)
+
+    def div(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.DIV, *es)
+
+    def mod(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.MOD, *es)
+
+    #
+
+    def concat(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.CONCAT, *es)

{omlish-0.0.0.dev73 → omlish-0.0.0.dev74}/omlish/sql/queries/exprs.py

@@ -1,3 +1,8 @@
+"""
+TODO:
+ - case
+ - cast / ::
+"""
 import typing as ta
 
 from ... import lang
@@ -24,6 +29,24 @@ class NameExpr(Expr, lang.Final):
     n: Name
 
 
+class Param(Expr, lang.Final):
+    n: str | None = None
+
+    def __repr__(self) -> str:
+        if self.n is not None:
+            return f'{self.__class__.__name__}({self.n!r})'
+        else:
+            return f'{self.__class__.__name__}(@{hex(id(self))[2:]})'
+
+    def __eq__(self, other):
+        if not isinstance(other, Param):
+            return False
+        if self.n is None and other.n is None:
+            return self is other
+        else:
+            return self.n == other.n
+
+
 CanLiteral: ta.TypeAlias = Literal | Value
 CanExpr: ta.TypeAlias = Expr | CanName | CanLiteral
 
@@ -41,6 +64,8 @@ class ExprBuilder(NameBuilder):
     def l(self, o: CanLiteral) -> Literal:  # noqa
         return self.literal(o)
 
+    #
+
     def expr(self, o: CanExpr) -> Expr:
         if isinstance(o, Expr):
             return o
@@ -52,3 +77,12 @@ class ExprBuilder(NameBuilder):
     @ta.final
     def e(self, o: CanExpr) -> Expr:
         return self.expr(o)
+
+    #
+
+    def param(self, n: str | None = None) -> Param:
+        return Param(n)
+
+    @ta.final
+    def p(self, n: str | None = None) -> Param:
+        return self.param(n)

omlish-0.0.0.dev74/omlish/sql/queries/marshal.py

@@ -0,0 +1,74 @@
+import enum
+import typing as ta
+
+from ... import cached
+from ... import check
+from ... import collections as col
+from ... import dataclasses as dc
+from ... import lang
+from ... import marshal as msh
+from .base import Node
+from .binary import BinaryOp
+from .binary import BinaryOps
+from .exprs import Expr
+from .multi import MultiKind
+from .relations import Relation
+from .stmts import Stmt
+from .unary import UnaryOp
+from .unary import UnaryOps
+
+
+@dc.dataclass(frozen=True)
+class OpMarshalerUnmarshaler(msh.Marshaler, msh.Unmarshaler):
+    ty: type
+    ns: type[lang.Namespace]
+
+    @cached.property
+    @dc.init
+    def by_name(self) -> ta.Mapping[str, ta.Any]:
+        return col.make_map(((o.name, o) for _, o in self.ns), strict=True)
+
+    def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
+        return check.isinstance(o, self.ty).name  # type: ignore  # noqa
+
+    def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
+        return self.by_name[check.isinstance(v, str)]
+
+
+@dc.dataclass(frozen=True)
+class LowerEnumMarshaler(msh.Marshaler, msh.Unmarshaler):
+    ty: type[enum.Enum]
+
+    @cached.property
+    @dc.init
+    def by_name(self) -> ta.Mapping[str, ta.Any]:
+        return col.make_map(((o.name.lower(), o) for o in self.ty), strict=True)
+
+    def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
+        return o.name.lower()
+
+    def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
+        return self.by_name[check.isinstance(v, str).lower()]
+
+
+@lang.static_init
+def _install_standard_marshalling() -> None:
+    for ty, ns in [
+        (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.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.TypeMapMarshalerFactory({MultiKind: LowerEnumMarshaler(MultiKind)})]
+    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.TypeMapUnmarshalerFactory({MultiKind: LowerEnumMarshaler(MultiKind)})]  # noqa
+
+    for cls in [
+        Expr,
+        Node,
+        Relation,
+        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)]

{omlish-0.0.0.dev73 → omlish-0.0.0.dev74}/omlish/sql/queries/multi.py

@@ -1,3 +1,4 @@
+import enum
 import typing as ta
 
 from ... import check
@@ -11,30 +12,26 @@ from .exprs import ExprBuilder
 ##
 
 
-class MultiOp(dc.Frozen, lang.Final, eq=False):
-    name: str
-
-
-class MultiOps(lang.Namespace):
-    AND = MultiOp('and')
-    OR = MultiOp('or')
+class MultiKind(enum.Enum):
+    AND = enum.auto()
+    OR = enum.auto()
 
 
 class Multi(Expr, lang.Final):
-    op: MultiOp
-    es: ta.Sequence[Expr] = dc.xfield(coerce=tuple)
+    k: MultiKind
+    es: ta.Sequence[Expr] = dc.xfield(coerce=tuple, validate=lambda es: len(es) > 1)
 
 
 class MultiBuilder(ExprBuilder):
-    def multi(self, op: MultiOp, *es: CanExpr) -> Expr:
+    def multi(self, k: MultiKind, *es: CanExpr) -> Expr:
         check.not_empty(es)
         if len(es) == 1:
             return self.expr(es[0])
         else:
-            return Multi(op, [self.expr(e) for e in es])
+            return Multi(k, [self.expr(e) for e in es])
 
     def and_(self, *es: CanExpr) -> Expr:
-        return self.multi(MultiOps.AND, *es)
+        return self.multi(MultiKind.AND, *es)
 
     def or_(self, *es: CanExpr) -> Expr:
-        return self.multi(MultiOps.OR, *es)
+        return self.multi(MultiKind.OR, *es)

omlish-0.0.0.dev74/omlish/sql/queries/ops.py

@@ -0,0 +1,8 @@
+import enum
+
+
+class OpKind(enum.Enum):
+    CMP = enum.auto()
+    ARITH = enum.auto()
+    BIT = enum.auto()
+    STR = enum.auto()

{omlish-0.0.0.dev73 → omlish-0.0.0.dev74}/omlish/sql/queries/relations.py

@@ -1,3 +1,8 @@
+"""
+TODO:
+ - join
+ - subquery
+"""
 import typing as ta
 
 from ... import dataclasses as dc

omlish-0.0.0.dev74/omlish/sql/queries/rendering.py

@@ -0,0 +1,180 @@
+"""
+TODO:
+ - minimal parens
+ - text.parts
+ - QuoteStyle
+ - ParamStyle
+
+==
+
+def needs_parens(self, e: Expr) -> bool:
+    if isinstance(e, (Literal, Ident, Name)):
+        return True
+    elif isinstance(e, Expr):
+        return False
+    else:
+        raise TypeError(e)
+"""
+import io
+import typing as ta
+
+from ... import dispatch
+from ... import lang
+from .base import Node
+from .binary import Binary
+from .binary import BinaryOp
+from .binary import BinaryOps
+from .exprs import Literal
+from .exprs import NameExpr
+from .idents import Ident
+from .multi import Multi
+from .multi import MultiKind
+from .names import Name
+from .relations import Table
+from .selects import Select
+from .selects import SelectItem
+from .unary import Unary
+from .unary import UnaryOp
+from .unary import UnaryOps
+
+
+class Renderer(lang.Abstract):
+    def __init__(self, out: ta.TextIO) -> None:
+        super().__init__()
+        self._out = out
+
+    @dispatch.method
+    def render(self, o: ta.Any) -> None:
+        raise TypeError(o)
+
+    @classmethod
+    def render_str(cls, o: ta.Any, *args: ta.Any, **kwargs: ta.Any) -> str:
+        out = io.StringIO()
+        cls(out, *args, **kwargs).render(o)
+        return out.getvalue()
+
+
+class StdRenderer(Renderer):
+    # binary
+
+    BINARY_OP_TO_STR: ta.ClassVar[ta.Mapping[BinaryOp, str]] = {
+        BinaryOps.EQ: '=',
+        BinaryOps.NE: '!=',
+        BinaryOps.LT: '<',
+        BinaryOps.LE: '<=',
+        BinaryOps.GT: '>',
+        BinaryOps.GE: '>=',
+
+        BinaryOps.ADD: '+',
+        BinaryOps.SUB: '-',
+        BinaryOps.MUL: '*',
+        BinaryOps.DIV: '/',
+        BinaryOps.MOD: '%',
+
+        BinaryOps.CONCAT: '||',
+    }
+
+    @Renderer.render.register
+    def render_binary(self, o: Binary) -> None:
+        self._out.write('(')
+        self.render(o.l)
+        self._out.write(f' {self.BINARY_OP_TO_STR[o.op]} ')
+        self.render(o.r)
+        self._out.write(')')
+
+    # exprs
+
+    @Renderer.render.register
+    def render_literal(self, o: Literal) -> None:
+        self._out.write(repr(o.v))
+
+    @Renderer.render.register
+    def render_name_expr(self, o: NameExpr) -> None:
+        self.render(o.n)
+
+    # idents
+
+    @Renderer.render.register
+    def render_ident(self, o: Ident) -> None:
+        self._out.write(f'"{o.s}"')
+
+    # multis
+
+    MULTI_KIND_TO_STR: ta.ClassVar[ta.Mapping[MultiKind, str]] = {
+        MultiKind.AND: 'and',
+        MultiKind.OR: 'or',
+
+    }
+
+    @Renderer.render.register
+    def render_multi(self, o: Multi) -> None:
+        d = f' {self.MULTI_KIND_TO_STR[o.k]} '
+        self._out.write('(')
+        for i, e in enumerate(o.es):
+            if i:
+                self._out.write(d)
+            self.render(e)
+        self._out.write(')')
+
+    # names
+
+    @Renderer.render.register
+    def render_name(self, o: Name) -> None:
+        for n, i in enumerate(o.ps):
+            if n:
+                self._out.write('.')
+            self.render(i)
+
+    # relations
+
+    @Renderer.render.register
+    def render_table(self, o: Table) -> None:
+        self.render(o.n)
+        if o.a is not None:
+            self._out.write(' as ')
+            self.render(o.a)
+
+    # selects
+
+    @Renderer.render.register
+    def render_select_item(self, o: SelectItem) -> None:
+        self.render(o.v)
+        if o.a is not None:
+            self._out.write(' as ')
+            self.render(o.a)
+
+    @Renderer.render.register
+    def render_select(self, o: Select) -> None:
+        self._out.write('select ')
+        for i, it in enumerate(o.items):
+            if i:
+                self._out.write(', ')
+            self.render(it)
+        if o.from_ is not None:
+            self._out.write(' from ')
+            self.render(o.from_)
+        if o.where:
+            self._out.write(' where ')
+            self.render(o.where)
+
+    # unary
+
+    UNARY_OP_TO_STR: ta.ClassVar[ta.Mapping[UnaryOp, tuple[str, str]]] = {
+        UnaryOps.NOT: ('not ', ''),
+        UnaryOps.IS_NULL: ('', ' is null'),
+        UnaryOps.IS_NOT_NULL: ('', ' is not null'),
+
+        UnaryOps.POS: ('+', ''),
+        UnaryOps.NEG: ('-', ''),
+    }
+
+    @Renderer.render.register
+    def render_unary(self, o: Unary) -> None:
+        pfx, sfx = self.UNARY_OP_TO_STR[o.op]
+        self._out.write(pfx)
+        self.render(o.v)
+        self._out.write(sfx)
+
+
+def render(n: Node) -> str:
+    return StdRenderer.render_str(n)

omlish-0.0.0.dev74/omlish/sql/queries/unary.py

@@ -0,0 +1,52 @@
+from ... import dataclasses as dc
+from ... import lang
+from .exprs import CanExpr
+from .exprs import Expr
+from .exprs import ExprBuilder
+from .ops import OpKind
+
+
+##
+
+
+class UnaryOp(dc.Frozen, lang.Final, eq=False):
+    name: str
+    kind: OpKind
+
+
+class UnaryOps(lang.Namespace):
+    NOT = UnaryOp('not', OpKind.CMP)
+    IS_NULL = UnaryOp('is_null', OpKind.CMP)
+    IS_NOT_NULL = UnaryOp('is_not_null', OpKind.CMP)
+
+    POS = UnaryOp('pos', OpKind.ARITH)
+    NEG = UnaryOp('neg', OpKind.ARITH)
+
+
+class Unary(Expr, lang.Final):
+    op: UnaryOp
+    v: Expr
+
+
+class UnaryBuilder(ExprBuilder):
+    def unary(self, op: UnaryOp, v: CanExpr) -> Unary:
+        return Unary(op, self.expr(v))
+
+    #
+
+    def not_(self, v: CanExpr) -> Unary:
+        return self.unary(UnaryOps.NOT, v)
+
+    def is_null(self, v: CanExpr) -> Unary:
+        return self.unary(UnaryOps.IS_NULL, v)
+
+    def is_not_null(self, v: CanExpr) -> Unary:
+        return self.unary(UnaryOps.IS_NOT_NULL, v)
+
+    #
+
+    def pos(self, v: CanExpr) -> Unary:
+        return self.unary(UnaryOps.POS, v)
+
+    def neg(self, v: CanExpr) -> Unary:
+        return self.unary(UnaryOps.NEG, v)

{omlish-0.0.0.dev73 → omlish-0.0.0.dev74}/omlish/sql/tabledefs/marshal.py

@@ -10,10 +10,7 @@ def _install_poly(cls: type) -> None:
     msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.PolymorphismUnmarshalerFactory(p)]
 
 
-@lang.cached_function
+@lang.static_init
 def _install_standard_marshalling() -> None:
     _install_poly(Dtype)
     _install_poly(Element)
-
-
-_install_standard_marshalling()

{omlish-0.0.0.dev73 → omlish-0.0.0.dev74/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev73
+Version: 0.0.0.dev74
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev73 → omlish-0.0.0.dev74}/omlish.egg-info/SOURCES.txt

@@ -401,13 +401,16 @@ omlish/sql/alchemy/sqlean.py
 omlish/sql/queries/__init__.py
 omlish/sql/queries/base.py
 omlish/sql/queries/binary.py
+omlish/sql/queries/building.py
 omlish/sql/queries/exprs.py
 omlish/sql/queries/idents.py
+omlish/sql/queries/marshal.py
 omlish/sql/queries/multi.py
 omlish/sql/queries/names.py
+omlish/sql/queries/ops.py
 omlish/sql/queries/relations.py
+omlish/sql/queries/rendering.py
 omlish/sql/queries/selects.py
-omlish/sql/queries/std.py
 omlish/sql/queries/stmts.py
 omlish/sql/queries/unary.py
 omlish/sql/tabledefs/__init__.py