omlish 0.0.0.dev252__py3-none-any.whl → 0.0.0.dev254__py3-none-any.whl

omlish/sql/parsing/_antlr/MinisqlVisitor.py

@@ -0,0 +1,291 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+# Generated from Minisql.g4 by ANTLR 4.13.2
+from omlish.antlr._runtime._all import *
+if "." in __name__:
+    from .MinisqlParser import MinisqlParser
+else:
+    from MinisqlParser import MinisqlParser
+
+# This class defines a complete generic visitor for a parse tree produced by MinisqlParser.
+
+class MinisqlVisitor(ParseTreeVisitor):
+
+    # Visit a parse tree produced by MinisqlParser#singleStmt.
+    def visitSingleStmt(self, ctx:MinisqlParser.SingleStmtContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#select.
+    def visitSelect(self, ctx:MinisqlParser.SelectContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#cteSelect.
+    def visitCteSelect(self, ctx:MinisqlParser.CteSelectContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#cte.
+    def visitCte(self, ctx:MinisqlParser.CteContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#unionSelect.
+    def visitUnionSelect(self, ctx:MinisqlParser.UnionSelectContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#unionItem.
+    def visitUnionItem(self, ctx:MinisqlParser.UnionItemContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#primarySelect.
+    def visitPrimarySelect(self, ctx:MinisqlParser.PrimarySelectContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#allSelectItem.
+    def visitAllSelectItem(self, ctx:MinisqlParser.AllSelectItemContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#exprSelectItem.
+    def visitExprSelectItem(self, ctx:MinisqlParser.ExprSelectItemContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#expr.
+    def visitExpr(self, ctx:MinisqlParser.ExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#unaryBooleanExpr.
+    def visitUnaryBooleanExpr(self, ctx:MinisqlParser.UnaryBooleanExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#predicatedBooleanExpr.
+    def visitPredicatedBooleanExpr(self, ctx:MinisqlParser.PredicatedBooleanExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#binaryBooleanExpr.
+    def visitBinaryBooleanExpr(self, ctx:MinisqlParser.BinaryBooleanExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#castBooleanExpr.
+    def visitCastBooleanExpr(self, ctx:MinisqlParser.CastBooleanExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#cmpPredicate.
+    def visitCmpPredicate(self, ctx:MinisqlParser.CmpPredicateContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#isNullPredicate.
+    def visitIsNullPredicate(self, ctx:MinisqlParser.IsNullPredicateContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#inListPredicate.
+    def visitInListPredicate(self, ctx:MinisqlParser.InListPredicateContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#inSelectPredicate.
+    def visitInSelectPredicate(self, ctx:MinisqlParser.InSelectPredicateContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#likePredicate.
+    def visitLikePredicate(self, ctx:MinisqlParser.LikePredicateContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#arithValueExpr.
+    def visitArithValueExpr(self, ctx:MinisqlParser.ArithValueExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#unaryValueExpr.
+    def visitUnaryValueExpr(self, ctx:MinisqlParser.UnaryValueExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#primaryValueExpr.
+    def visitPrimaryValueExpr(self, ctx:MinisqlParser.PrimaryValueExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#functionCallExpr.
+    def visitFunctionCallExpr(self, ctx:MinisqlParser.FunctionCallExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#starFunctionCallExpr.
+    def visitStarFunctionCallExpr(self, ctx:MinisqlParser.StarFunctionCallExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#caseExpr.
+    def visitCaseExpr(self, ctx:MinisqlParser.CaseExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#selectExpr.
+    def visitSelectExpr(self, ctx:MinisqlParser.SelectExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#parenExpr.
+    def visitParenExpr(self, ctx:MinisqlParser.ParenExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#simplePrimaryExpr.
+    def visitSimplePrimaryExpr(self, ctx:MinisqlParser.SimplePrimaryExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#simpleExpr.
+    def visitSimpleExpr(self, ctx:MinisqlParser.SimpleExprContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#caseItem.
+    def visitCaseItem(self, ctx:MinisqlParser.CaseItemContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#over.
+    def visitOver(self, ctx:MinisqlParser.OverContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#sortItem.
+    def visitSortItem(self, ctx:MinisqlParser.SortItemContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#aliasedRelation.
+    def visitAliasedRelation(self, ctx:MinisqlParser.AliasedRelationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#joinRelation.
+    def visitJoinRelation(self, ctx:MinisqlParser.JoinRelationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#selectRelation.
+    def visitSelectRelation(self, ctx:MinisqlParser.SelectRelationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#tableRelation.
+    def visitTableRelation(self, ctx:MinisqlParser.TableRelationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#parenRelation.
+    def visitParenRelation(self, ctx:MinisqlParser.ParenRelationContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#groupBy.
+    def visitGroupBy(self, ctx:MinisqlParser.GroupByContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#qualifiedName.
+    def visitQualifiedName(self, ctx:MinisqlParser.QualifiedNameContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#identList.
+    def visitIdentList(self, ctx:MinisqlParser.IdentListContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#ident.
+    def visitIdent(self, ctx:MinisqlParser.IdentContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#quotedIdent.
+    def visitQuotedIdent(self, ctx:MinisqlParser.QuotedIdentContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#integerNumber.
+    def visitIntegerNumber(self, ctx:MinisqlParser.IntegerNumberContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#decimalNumber.
+    def visitDecimalNumber(self, ctx:MinisqlParser.DecimalNumberContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#floatNumber.
+    def visitFloatNumber(self, ctx:MinisqlParser.FloatNumberContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#string.
+    def visitString(self, ctx:MinisqlParser.StringContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#null.
+    def visitNull(self, ctx:MinisqlParser.NullContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#true.
+    def visitTrue(self, ctx:MinisqlParser.TrueContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#false.
+    def visitFalse(self, ctx:MinisqlParser.FalseContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#setQuantifier.
+    def visitSetQuantifier(self, ctx:MinisqlParser.SetQuantifierContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#joinType.
+    def visitJoinType(self, ctx:MinisqlParser.JoinTypeContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#cmpOp.
+    def visitCmpOp(self, ctx:MinisqlParser.CmpOpContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#arithOp.
+    def visitArithOp(self, ctx:MinisqlParser.ArithOpContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#unaryOp.
+    def visitUnaryOp(self, ctx:MinisqlParser.UnaryOpContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by MinisqlParser#unquotedIdent.
+    def visitUnquotedIdent(self, ctx:MinisqlParser.UnquotedIdentContext):
+        return self.visitChildren(ctx)
+
+
+
+del MinisqlParser

omlish/sql/parsing/parsing.py

@@ -0,0 +1,119 @@
+# ruff: noqa: N802 N803
+import typing as ta
+
+from ... import check
+from ...antlr import runtime as antlr4
+from ...antlr.delimit import DelimitingLexer
+from ...antlr.errors import SilentRaisingErrorListener
+from .. import queries as no
+from ._antlr.MinisqlLexer import MinisqlLexer  # type: ignore
+from ._antlr.MinisqlParser import MinisqlParser  # type: ignore
+from ._antlr.MinisqlVisitor import MinisqlVisitor  # type: ignore
+
+
+##
+
+
+class _ParseVisitor(MinisqlVisitor):
+    def visit(self, ctx: antlr4.ParserRuleContext):
+        check.isinstance(ctx, antlr4.ParserRuleContext)
+        node = ctx.accept(self)
+        return node
+
+    def aggregateResult(self, aggregate, nextResult):
+        if aggregate is not None:
+            check.none(nextResult)
+            return aggregate
+        else:
+            check.none(aggregate)
+            return nextResult
+
+    #
+
+    def visitExprSelectItem(self, ctx: MinisqlParser.ExprSelectItemContext):
+        value = self.visit(ctx.expr())
+        label = self.visit(ctx.ident()) if ctx.ident() is not None else None
+        return no.SelectItem(value, label)
+
+    def visitIntegerNumber(self, ctx: MinisqlParser.IntegerNumberContext):
+        return no.Literal(int(ctx.INTEGER_VALUE().getText()))
+
+    def visitPrimarySelect(self, ctx: MinisqlParser.PrimarySelectContext):
+        items = [self.visit(i) for i in ctx.selectItem()]
+        relations = [self.visit(r) for r in ctx.relation()]
+        where = self.visit(ctx.where) if ctx.where is not None else None
+        return no.Select(
+            items=items,
+            from_=check.single(relations) if relations else None,
+            where=where,
+        )
+
+    def visitQuotedIdent(self, ctx: MinisqlParser.QuotedIdentContext):
+        name = unquote(ctx.QUOTED_IDENT().getText(), '"')
+        return no.Ident(name)
+
+    def visitUnquotedIdent(self, ctx: MinisqlParser.UnquotedIdentContext):
+        return no.Ident(ctx.getText())
+
+
+##
+
+
+def create_parser(buf: str) -> MinisqlParser:
+    lexer = MinisqlLexer(antlr4.InputStream(buf))
+    lexer.removeErrorListeners()
+    lexer.addErrorListener(SilentRaisingErrorListener())
+
+    stream = antlr4.CommonTokenStream(lexer)
+    stream.fill()
+
+    parser = MinisqlParser(stream)
+    parser.removeErrorListeners()
+    parser.addErrorListener(SilentRaisingErrorListener())
+
+    return parser
+
+
+##
+
+
+def parse_stmt(buf: str, **kwargs) -> no.Stmt:
+    parser = create_parser(buf, **kwargs)
+    node = _ParseVisitor().visit(parser.singleStmt())
+    return check.isinstance(node, no.Stmt)
+
+
+class _DelimitingLexer(DelimitingLexer, MinisqlLexer):
+    pass
+
+
+def split_stmts(buf: str) -> ta.Sequence[str]:
+    lexer = _DelimitingLexer(
+        antlr4.InputStream(buf),
+        delimiter_token=MinisqlParser.DELIMITER,
+        delimiters=[';'],
+    )
+    lexer.removeErrorListeners()
+    lexer.addErrorListener(SilentRaisingErrorListener())
+
+    lst, part = lexer.split()
+    if part.strip():
+        raise ValueError(part)
+
+    return [s for s, _ in lst]
+
+
+def parse_stmts(buf: str, **kwargs) -> ta.Sequence[no.Stmt]:
+    return [parse_stmt(sb, **kwargs) for sb in split_stmts(buf)]
+
+
+##
+
+
+def quote(val: str, q: str) -> str:
+    return q + val.replace(q, q * 2) + q
+
+
+def unquote(val: str, q: str) -> str:
+    check.arg(val.startswith(q) and val.endswith(q))
+    return val[1:-1].replace(q * 2, q)

omlish/subprocesses/wrap.py

@@ -1,5 +1,10 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
+"""
+This bypasses debuggers attaching to spawned subprocess children that look like python processes. See:
+
+  https://github.com/JetBrains/intellij-community/blob/e9d8f126c286acf9df3ff272f440b305bf2ff585/python/helpers/pydev/_pydev_bundle/pydev_monkey.py
+"""
 import shlex
 import typing as ta
 

omlish/text/decoding.py

@@ -0,0 +1,73 @@
+"""
+TODO:
+ - cext
+"""
+import array
+import codecs
+import typing as ta
+
+
+##
+
+
+def decode_to_list(
+        raw: bytes,
+        encoding: str = 'utf-8',
+        *,
+        errors: str = 'strict',
+) -> list[str]:
+    dec = codecs.getincrementaldecoder(encoding)(errors)
+    end = len(raw) - 1
+    return [dec.decode(bytes([b]), final=i == end) for i, b in enumerate(raw)]
+
+
+#
+
+
+class DecodedStringIndex(ta.NamedTuple):
+    byte_offsets: ta.Sequence[int]
+
+
+def decode_indexed(
+        raw: bytes,
+        encoding: str = 'utf-8',
+        *,
+        errors: str = 'strict',
+) -> tuple[str, DecodedStringIndex]:
+    dec_lst = decode_to_list(
+        raw,
+        encoding,
+        errors=errors,
+    )
+
+    dec_s = ''.join(dec_lst)
+
+    bo_arr_len = len(dec_s) + 1
+    if bo_arr_len < 2**8:
+        fmt = 'B'
+    elif bo_arr_len < 2**16:
+        fmt = 'H'
+    elif bo_arr_len < 2**32:
+        fmt = 'L'
+    else:
+        fmt = 'Q'
+
+    bo_arr = array.array(fmt, [0]) * bo_arr_len
+    so = 0
+    lbo = 0
+    for bo, s in enumerate(dec_lst):
+        if s:
+            bo_arr[so] = lbo
+            so += 1
+            lbo = bo + 1
+
+    if so != len(dec_s):
+        raise RuntimeError
+
+    bo_arr[len(dec_s)] = len(raw)
+
+    dsi = DecodedStringIndex(
+        bo_arr,
+    )
+
+    return (dec_s, dsi)