omlish 0.0.0.dev70__py3-none-any.whl → 0.0.0.dev72__py3-none-any.whl

omlish/sql/queries/base.py

@@ -0,0 +1,21 @@
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+
+
+##
+
+
+Value: ta.TypeAlias = ta.Any
+
+
+##
+
+
+class Node(dc.Frozen, lang.Abstract, cache_hash=True):
+    pass
+
+
+class Builder(lang.Abstract):
+    pass

omlish/sql/queries/binary.py

@@ -0,0 +1,48 @@
+from ... import check
+from ... import lang
+from .base import Node
+from .exprs import CanExpr
+from .exprs import Expr
+from .exprs import ExprBuilder
+
+
+##
+
+
+class BinaryOp(Node, lang.Final):
+    name: str
+
+
+class BinaryOps(lang.Namespace):
+    ADD = BinaryOp('add')
+    SUB = BinaryOp('sub')
+
+    EQ = BinaryOp('eq')
+    NE = BinaryOp('ne')
+
+
+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 add(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.ADD, *es)
+
+    def sub(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.SUB, *es)
+
+    def eq(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.EQ, *es)
+
+    def ne(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.NE, *es)

omlish/sql/queries/exprs.py

@@ -0,0 +1,54 @@
+import typing as ta
+
+from ... import lang
+from .base import Node
+from .base import Value
+from .idents import Ident
+from .names import CanName
+from .names import Name
+from .names import NameBuilder
+
+
+##
+
+
+class Expr(Node, lang.Abstract):
+    pass
+
+
+class Literal(Expr, lang.Final):
+    v: Value
+
+
+class NameExpr(Expr, lang.Final):
+    n: Name
+
+
+CanLiteral: ta.TypeAlias = Literal | Value
+CanExpr: ta.TypeAlias = Expr | CanName | CanLiteral
+
+
+class ExprBuilder(NameBuilder):
+    def literal(self, o: CanLiteral) -> Literal:
+        if isinstance(o, Literal):
+            return o
+        elif isinstance(o, Node):
+            raise TypeError(o)
+        else:
+            return Literal(o)
+
+    @ta.final
+    def l(self, o: CanLiteral) -> Literal:  # noqa
+        return self.literal(o)
+
+    def expr(self, o: CanExpr) -> Expr:
+        if isinstance(o, Expr):
+            return o
+        elif isinstance(o, (Name, Ident)):
+            return NameExpr(self.name(o))
+        else:
+            return self.literal(o)
+
+    @ta.final
+    def e(self, o: CanExpr) -> Expr:
+        return self.expr(o)

omlish/sql/queries/idents.py

@@ -0,0 +1,29 @@
+import typing as ta
+
+from ... import lang
+from .base import Builder
+from .base import Node
+
+
+##
+
+
+class Ident(Node, lang.Final):
+    s: str
+
+
+CanIdent: ta.TypeAlias = Ident | str
+
+
+class IdentBuilder(Builder):
+    def ident(self, o: CanIdent) -> Ident:
+        if isinstance(o, Ident):
+            return o
+        elif isinstance(o, str):
+            return Ident(o)
+        else:
+            raise TypeError(o)
+
+    @ta.final
+    def i(self, o: CanIdent) -> Ident:
+        return self.ident(o)

omlish/sql/queries/multi.py

@@ -0,0 +1,41 @@
+import typing as ta
+
+from ... import check
+from ... import dataclasses as dc
+from ... import lang
+from .base import Node
+from .exprs import CanExpr
+from .exprs import Expr
+from .exprs import ExprBuilder
+
+
+##
+
+
+class MultiOp(Node, lang.Final):
+    name: str
+
+
+class MultiOps(lang.Namespace):
+    AND = MultiOp('and')
+    OR = MultiOp('or')
+
+
+class Multi(Expr, lang.Final):
+    op: MultiOp
+    es: ta.Sequence[Expr] = dc.xfield(coerce=tuple)
+
+
+class MultiBuilder(ExprBuilder):
+    def multi(self, op: MultiOp, *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])
+
+    def and_(self, *es: CanExpr) -> Expr:
+        return self.multi(MultiOps.AND, *es)
+
+    def or_(self, *es: CanExpr) -> Expr:
+        return self.multi(MultiOps.OR, *es)

omlish/sql/queries/names.py

@@ -0,0 +1,34 @@
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+from .base import Node
+from .idents import CanIdent
+from .idents import Ident
+from .idents import IdentBuilder
+
+
+##
+
+
+class Name(Node, lang.Final):
+    ps: ta.Sequence[Ident] = dc.xfield(coerce=tuple)
+
+
+CanName: ta.TypeAlias = Name | CanIdent | ta.Sequence[CanIdent]
+
+
+class NameBuilder(IdentBuilder):
+    def name(self, o: CanName) -> Name:
+        if isinstance(o, Name):
+            return o
+        elif isinstance(o, (Ident, str)):
+            return Name([self.ident(o)])
+        elif isinstance(o, ta.Sequence):
+            return Name([self.ident(p) for p in o])
+        else:
+            raise TypeError(o)
+
+    @ta.final
+    def n(self, o: CanName) -> Name:
+        return self.name(o)

omlish/sql/queries/relations.py

@@ -0,0 +1,39 @@
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+from .base import Node
+from .idents import Ident
+from .names import CanName
+from .names import Name
+from .names import NameBuilder
+
+
+##
+
+
+class Relation(Node, lang.Abstract):
+    pass
+
+
+class Table(Relation, lang.Final):
+    n: Name
+    a: Ident | None = dc.xfield(None, repr_fn=dc.opt_repr)
+
+
+CanTable: ta.TypeAlias = Table | CanName
+CanRelation: ta.TypeAlias = Relation | CanTable
+
+
+class RelationBuilder(NameBuilder):
+    def table(self, n: CanTable) -> Table:
+        if isinstance(n, Table):
+            return n
+        else:
+            return Table(self.name(n))
+
+    def relation(self, o: CanRelation) -> Relation:
+        if isinstance(o, Relation):
+            return o
+        else:
+            return self.table(o)

omlish/sql/queries/selects.py

@@ -0,0 +1,50 @@
+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
+from .idents import Ident
+from .relations import CanRelation
+from .relations import Relation
+from .relations import RelationBuilder
+from .stmts import Stmt
+
+
+##
+
+
+class SelectItem(Node, lang.Final):
+    v: Expr
+    a: Ident | None = dc.xfield(None, repr_fn=dc.opt_repr)
+
+
+class Select(Stmt, lang.Final):
+    its: ta.Sequence[SelectItem] = dc.xfield(coerce=tuple)
+    fr: Relation | None = dc.xfield(None, repr_fn=dc.opt_repr)
+    wh: Expr | None = dc.xfield(None, repr_fn=dc.opt_repr)
+
+
+CanSelectItem: ta.TypeAlias = SelectItem | CanExpr
+
+
+class SelectBuilder(ExprBuilder, RelationBuilder):
+    def select_item(self, o: CanSelectItem) -> SelectItem:
+        if isinstance(o, SelectItem):
+            return o
+        else:
+            return SelectItem(self.expr(o))
+
+    def select(
+            self,
+            its: ta.Sequence[CanSelectItem],
+            fr: CanRelation | None = None,
+            wh: CanExpr | None = None,
+    ) -> Select:
+        return Select(
+            [self.select_item(i) for i in its],
+            fr=self.relation(fr) if fr is not None else None,
+            wh=self.expr(wh) if wh is not None else None,
+        )

omlish/sql/queries/std.py

@@ -0,0 +1,29 @@
+from .base import Builder
+from .binary import BinaryBuilder
+from .exprs import ExprBuilder
+from .idents import IdentBuilder
+from .multi import MultiBuilder
+from .names import NameBuilder
+from .relations import RelationBuilder
+from .selects import SelectBuilder
+from .stmts import StmtBuilder
+from .unary import UnaryBuilder
+
+
+class StdBuilder(
+    SelectBuilder,
+    StmtBuilder,
+
+    MultiBuilder,
+    BinaryBuilder,
+    UnaryBuilder,
+    ExprBuilder,
+
+    RelationBuilder,
+
+    NameBuilder,
+    IdentBuilder,
+
+    Builder,
+):
+    pass

omlish/sql/queries/stmts.py

@@ -0,0 +1,28 @@
+import typing as ta
+
+from ... import lang
+from .base import Node
+from .exprs import CanExpr
+from .exprs import ExprBuilder
+
+
+##
+
+
+class Stmt(Node, lang.Abstract):
+    pass
+
+
+class ExprStmt(Stmt, lang.Final):
+    pass
+
+
+CanStmt: ta.TypeAlias = Stmt | CanExpr
+
+
+class StmtBuilder(ExprBuilder):
+    def stmt(self, o: CanStmt) -> Stmt:
+        if isinstance(o, Stmt):
+            return o
+        else:
+            return ExprStmt(self.expr(o))

omlish/sql/queries/unary.py

@@ -0,0 +1,29 @@
+from ... import lang
+from .base import Node
+from .exprs import CanExpr
+from .exprs import Expr
+from .exprs import ExprBuilder
+
+
+##
+
+
+class UnaryOp(Node, lang.Final):
+    name: str
+
+
+class UnaryOps(lang.Namespace):
+    NOT = UnaryOp('not')
+
+
+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)

omlish/sql/tabledefs/__init__.py

@@ -0,0 +1,11 @@
+from .tabledefs import (  # noqa
+    TableDef,
+)
+
+
+##
+
+
+from ...lang.imports import _register_conditional_import  # noqa
+
+_register_conditional_import('...marshal', '.marshal', __package__)

omlish/sql/tabledefs/alchemy.py

@@ -0,0 +1,26 @@
+"""
+TODO:
+ - move to sql/alchemy/tabledefs.py
+"""
+import typing as ta
+
+import sqlalchemy as sa
+import sqlalchemy.sql.schema
+
+from .tabledefs import TableDef
+
+
+def build_sa_table(
+        td: TableDef,
+        *,
+        metadata: sa.MetaData | None = None,
+        **kwargs: ta.Any,
+) -> sa.Table:
+    items: list[sa.sql.schema.SchemaItem] = []
+
+    return sa.Table(
+        td.name,
+        metadata if metadata is not None else sa.MetaData(),
+        *items,
+        **kwargs,
+    )

omlish/sql/tabledefs/dtypes.py

@@ -0,0 +1,22 @@
+from ... import dataclasses as dc
+from ... import lang
+
+
+@dc.dataclass(frozen=True)
+class Dtype(lang.Abstract, lang.Sealed):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class Integer(Dtype, lang.Singleton):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class String(Dtype, lang.Singleton):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class Datetime(Dtype, lang.Singleton):
+    pass

omlish/sql/tabledefs/elements.py

@@ -0,0 +1,88 @@
+import typing as ta
+
+from ... import check
+from ... import collections as col
+from ... import dataclasses as dc
+from ... import lang
+from .dtypes import Dtype
+
+
+##
+
+
+class Element(lang.Abstract, lang.Sealed):
+    pass
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Column(Element, lang.Final):
+    name: str
+    type: Dtype
+    nullable: bool = dc.field(default=False, kw_only=True)
+    default: lang.Maybe[ta.Any] = dc.field(default=lang.empty(), kw_only=True)
+
+
+@dc.dataclass(frozen=True)
+class PrimaryKey(Element, lang.Final):
+    columns: ta.Sequence[str]
+
+
+@dc.dataclass(frozen=True)
+class Index(Element, lang.Final):
+    columns: ta.Sequence[str] = dc.xfield(coerce=col.seq)
+    name: str | None = None
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class IdIntegerPrimaryKey(Element, lang.Final):
+    pass
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class CreatedAt(Element, lang.Final):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class UpdatedAt(Element, lang.Final):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class UpdatedAtTrigger(Element, lang.Final):
+    column: str
+
+
+@dc.dataclass(frozen=True)
+class CreatedAtUpdatedAt(Element, lang.Final):
+    pass
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Elements(ta.Sequence[Element], lang.Final):
+    lst: ta.Sequence[Element] = dc.xfield(coerce=col.seq_of(check.of_isinstance(Element)))
+
+    def __iter__(self) -> ta.Iterator[Element]:
+        return iter(self.lst)
+
+    def __getitem__(self, index: ta.Any) -> Element:  # type: ignore[override]
+        return self.lst[index]
+
+    def __len__(self) -> int:
+        return len(self.lst)
+
+    @lang.cached_property
+    def by_type(self) -> col.DynamicTypeMap[Element]:
+        return col.DynamicTypeMap(self.lst)

omlish/sql/tabledefs/lower.py

@@ -0,0 +1,49 @@
+from ... import dataclasses as dc
+from .dtypes import Datetime
+from .dtypes import Integer
+from .elements import Column
+from .elements import CreatedAt
+from .elements import CreatedAtUpdatedAt
+from .elements import Element
+from .elements import Elements
+from .elements import IdIntegerPrimaryKey
+from .elements import PrimaryKey
+from .elements import UpdatedAt
+from .elements import UpdatedAtTrigger
+from .tabledefs import TableDef
+
+
+def lower_table_elements(td: TableDef) -> TableDef:
+    todo: list[Element] = list(td.elements)[::-1]
+    out: list[Element] = []
+
+    while todo:
+        match (e := todo.pop()):
+            case Column() | PrimaryKey():
+                out.append(e)
+
+            case IdIntegerPrimaryKey():
+                out.extend([
+                    Column('id', Integer()),
+                    PrimaryKey(['id']),
+                ])
+
+            case CreatedAt():
+                out.append(Column('created_at', Datetime()))
+
+            case UpdatedAt():
+                out.extend([
+                    Column('updated_at', Datetime()),
+                    UpdatedAtTrigger('updated_at'),
+                ])
+
+            case CreatedAtUpdatedAt():
+                todo.extend([
+                    CreatedAt(),
+                    UpdatedAt(),
+                ][::-1])
+
+            case _:
+                raise TypeError(e)
+
+    return dc.replace(td, elements=Elements(out))

omlish/sql/tabledefs/marshal.py

@@ -0,0 +1,19 @@
+from ... import lang
+from ... import marshal as msh
+from .dtypes import Dtype
+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)]
+
+
+@lang.cached_function
+def _install_standard_marshalling() -> None:
+    _install_poly(Dtype)
+    _install_poly(Element)
+
+
+_install_standard_marshalling()

omlish/sql/tabledefs/tabledefs.py

@@ -0,0 +1,52 @@
+"""
+TODO:
+ - QualifiedName
+ - hybrid dataclass scheme
+ - sqlite without sqlalchemy
+
+==
+
+@td.tableclass([
+    IdIntegerPrimaryKey(),
+    CreatedAtUpdatedAt(),
+])
+@dc.dataclass(frozen=True)
+class User(lang.Final):
+    id: int
+
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+
+    name: str
+
+==
+
+@td.tableclass([
+    IdIntegerPrimaryKey(),
+    CreatedAtUpdatedAt(),
+])
+@dc.dataclass(frozen=True)
+class BaseTable(lang.Abstract):
+    id: int
+
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+
+@td.tableclass('user')
+@dc.dataclass(frozen=True)
+class User(BaseTable, lang.Final):
+    name: str
+
+"""
+from ... import dataclasses as dc
+from ... import lang
+from .elements import Elements
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class TableDef(lang.Final):
+    name: str
+    elements: Elements