sqlleaf 0.0.1__py3-none-any.whl

sqlleaf/util/__init__.py

@@ -0,0 +1,34 @@
+from sqlleaf.util.expression import (
+    calculate_function_name as calculate_function_name,
+    column_def_to_column as column_def_to_column,
+    copy_expression as copy_expression,
+    find_property as find_property,
+    get_column_constraint_expression as get_column_constraint_expression,
+    get_function_args as get_function_args,
+    get_location_property as get_location_property,
+    get_selected_column_names as get_selected_column_names,
+    get_table as get_table,
+    get_udf_name as get_udf_name,
+    is_row_function as is_row_function,
+    qualify_and_annotate as qualify_and_annotate,
+    rename_if_stage as rename_if_stage,
+    str_to_column_def as str_to_column_def,
+    unwrap_expression as unwrap_expression,
+)
+from sqlleaf.util.graph import (
+    find_edges_downward as find_edges_downward,
+    find_paths as find_paths,
+    get_cycles as get_cycles,
+    get_root_nodes as get_root_nodes,
+)
+from sqlleaf.util.helpers import (
+    chunks as chunks,
+    flatten as flatten,
+    long_sha256_hash as long_sha256_hash,
+    short_sha256_hash as short_sha256_hash,
+    unique as unique,
+)
+from sqlleaf.util.iterators import (
+    default_column_index_iterator as default_column_index_iterator,
+    iter_inner_statements as iter_inner_statements,
+)

sqlleaf/util/expression.py

@@ -0,0 +1,282 @@
+import typing as t
+
+from sqlglot import exp
+from sqlglot.optimizer.annotate_types import annotate_types
+from sqlglot.optimizer.qualify import qualify
+
+from sqlleaf import exception, mappings, util
+from sqlleaf.typing import E, SourceExprType, TargetExprType
+
+
+def unwrap_expression(expr: E) -> exp.Expr:
+    """
+    Extract the expression from underneath an Alias or a Paren.
+    """
+    ex = expr
+    while isinstance(ex, (exp.Alias, exp.Paren)):
+        ex = ex.unalias()
+        if isinstance(ex, (exp.Subquery,)):
+            break
+        ex = ex.unnest()
+    return ex
+
+
+def copy_expression(expr: E) -> E:
+    """
+    Copy an expression.
+
+    Unlike sqlglot's copy() method, this preserves the expression's parents.
+    """
+    for i, ex in enumerate(expr.root().walk()):
+        if ex == expr:
+            copy_expr = expr.root().copy()
+            # Get the equivalent statement in the copy
+            for j, new_ex in enumerate(copy_expr.walk()):
+                if j == i:
+                    return t.cast(E, new_ex)
+    return expr
+
+
+def calculate_function_name(expr: exp.Expr, dialect: str) -> str:
+    """
+    Remove everything from the first '(' to the last ')' from a string.
+    We use this method because exp.Func.sql_name() includes the function's context in its name.
+    """
+    try:
+        # Get the name without its parameters
+        name = expr.__class__().sql(dialect=dialect)
+    except TypeError, AttributeError:
+        # Some classes can't be converted to SQL using this method (e.g. CONCAT() in Postgres)
+        name = expr.__class__().sql()
+        if not name:
+            name = expr.sql(dialect=dialect)
+
+    first_bracket = name.find("(")
+    if first_bracket == -1:
+        return name
+
+    last_bracket = name.rfind(")")
+    if last_bracket == -1:
+        return name
+
+    return name[:first_bracket] + name[last_bracket + 1 :]
+
+
+def find_property(statement: exp.Create, child_object: TargetExprType, dialect: str) -> str:
+    """
+    Get the table/view's property (e.g. TEMPORARY, EXTERNAL, RECURSIVE)
+    """
+    if dialect == "redshift" and isinstance(child_object, exp.Table) and child_object.name.startswith("#"):
+        return "temporary"
+
+    properties = (exp.TemporaryProperty, exp.ExternalProperty, exp.MaterializedProperty)
+    prop = ""
+    if props := statement.args.get("properties"):
+        prop = str(props.find(properties) or "").lower()
+    return prop
+
+
+def get_location_property(expr: exp.Create, dialect: str) -> str | None:
+    """
+    Get the LOCATION value from a CREATE statement.
+    """
+    location = None
+    if dialect in ["athena"]:
+        if props := expr.args["properties"]:
+            if location_expr := props.find(exp.LocationProperty):
+                location = location_expr.name
+    return location
+
+
+def column_def_to_column(column_def: exp.ColumnDef, parent_table: t.Optional[exp.Table] = None) -> exp.Column:
+    """
+    Convert an exp.ColumnDef to an exp.Column
+    """
+    if parent_table:
+        table = parent_table
+    elif isinstance(column_def.parent, exp.Schema):
+        table: exp.Table = column_def.parent.this
+    else:
+        table = column_def.parent
+
+    col = exp.column(
+        column_def.name,
+        table=table.name if table else None,
+        db=table.db if table else None,
+        catalog=table.catalog if table else None,
+    )
+    col.type = column_def.kind
+    return col
+
+
+def str_to_column_def(name: str) -> exp.ColumnDef:
+    """
+    Convert a string into a ColumnDef.
+    """
+    return exp.ColumnDef(this=exp.to_identifier(name), kind=exp.DType.UNKNOWN.into_expr())
+
+
+def get_table(expr: exp.Expr) -> exp.Table:
+    table = expr.find(exp.Table)
+    if table is None:
+        raise exception.InvalidQueryError(message=f"Could not find an exp.Table in expression: {expr.sql()}")
+    return table
+
+
+def get_udf_name(expr: exp.Anonymous) -> tuple[str, str]:
+    """
+    Get the schema and function name of a UDF (e.g. from SELECT my.func())
+    """
+    if isinstance(expr.parent, (exp.Dot,)):
+        schema = str(expr.parent.left.name)
+        function = str(expr.parent.right.name)
+    else:
+        # A function without a schema
+        schema = ""
+        function = expr.name
+
+    return schema, function
+
+
+def get_function_args(expr: exp.Func) -> t.List[exp.Expr]:
+    """
+    Get all the argument expressions inside a function.
+    Example: "a, b, c" in "SELECT my.func(a,b,c)"
+    """
+    function_args = list(expr.args.values())
+    function_args = util.flatten(function_args)
+    exclude = (exp.TableAlias,)  # SELECT FROM UNNEST() AS u
+    result = []
+    for arg in function_args:
+        if arg and isinstance(arg, exp.Expr) and not isinstance(arg, exclude):
+            if isinstance(arg, exp.Order):
+                # STRING_AGG(Order(Column)) -> Column
+                result.append(arg.this)
+            else:
+                result.append(arg)
+    return result
+
+
+def rename_if_stage(source: SourceExprType, target: TargetExprType) -> None:
+    """
+    Normalize (uppercase) the name if we are a Snowflake stage.
+    sqlglot only normalizes columns - see comments in `sqlglot.optimizer.normalize_identifiers()`
+    """
+    if str(source).startswith("@"):
+        if not str(source).startswith('@"'):
+            if isinstance(source, exp.Var):
+                source.set("this", str(source).upper())
+            else:
+                source.this.set("this", str(source).upper())
+
+    elif str(target).startswith("@"):
+        if not str(target).startswith('@"'):
+            if isinstance(target, exp.Var):
+                target.set("this", str(target).upper())
+            else:
+                target.this.set("this", str(target).upper())
+
+
+def get_selected_column_names(statement: exp.Expr) -> t.List[str]:
+    if isinstance(statement.expression, exp.Values):
+        return [s.name for s in statement.this.expressions]
+    return [s.alias_or_name for s in statement.selects]
+
+
+def is_row_function(expr: exp.Expr) -> bool:
+    """
+    Returns True if the given expression is the ROW() function.
+    """
+    return isinstance(expr, exp.Anonymous) and expr.this.upper() == "ROW"
+
+
+def qualify_and_annotate(
+    expr: exp.Expr, dialect: str, object_mapping: mappings.ObjectMapping, remove_added_aliases: bool = False
+) -> None:
+    stmt = qualify(
+        expr,
+        schema=object_mapping,
+        expand_stars=True,
+        expand_alias_refs=True,
+        qualify_columns=True,
+        infer_schema=False,
+        dialect=dialect,
+        isolate_tables=False,
+        validate_qualify_columns=False,
+        quote_identifiers=False,
+    )
+
+    # Rename the aliases automatically added by sqlglot
+    if remove_added_aliases:
+        if not isinstance(stmt.expression, exp.Values):
+            named_columns = stmt.args["this"].expressions
+            for i, ins in enumerate(named_columns):
+                # Overwrite the aliases because sqlglot may have added incorrect ones
+                if isinstance(ins, exp.ColumnDef):
+                    ins = ins.this
+                stmt.selects[i] = stmt.selects[i].as_(ins)
+
+    annotate_types(stmt, dialect=dialect, schema=object_mapping)
+
+
+def get_expression_for_column(column: exp.Column | int, expr: exp.Expr) -> tuple[exp.Expr, int]:
+    """
+    Get the expression that matches the given column name, along with its index (position) in the SELECT.
+    For example, given "SELECT 1 AS a, 2 AS b", column 'b' maps to expression 2.
+    """
+    if isinstance(column, int):
+        # The index of the query in "SELECT 1 UNION SELECT 2"
+        select = getattr(expr, "selects")[column]
+        idx = column
+    else:
+        if isinstance(expr, exp.Lateral):
+            selects = [(expr, 0)]
+        else:
+            # Common path
+            selects = [
+                (select, idx)
+                for idx, select in enumerate(getattr(expr, "selects"))
+                if select.alias_or_name == column.name
+            ]
+
+        if len(selects) > 1:
+            message = f"Column reference '{column}' is ambiguous ({len(selects)} possible options)"
+            raise exception.MappingError(message)
+
+        if selects:
+            select, idx = selects[0]
+        else:
+            select = expr
+            idx = -1
+    return select, idx
+
+
+def get_column_index(column: exp.Column | int, expr: exp.Expr) -> int:
+    """
+    Return the positional index of a column within a SELECT list.
+    Raises if the column cannot be found.
+    """
+    index = (
+        column
+        if isinstance(column, int)
+        else next(
+            (i for i, sel in enumerate(getattr(expr, "selects")) if sel.alias_or_name == column.name),
+            -1,  # a negative index should never be returned on success
+        )
+    )
+    if index == -1:
+        col_name = column if isinstance(column, int) else column.name
+        raise exception.MappingError(message=f"Could not find {col_name} in {expr}")
+    return index
+
+
+def get_column_constraint_expression(expr: exp.ColumnDef) -> exp.ColumnConstraintKind | None:
+    """
+    Get the DEFAULT or GENERATED expression for this column, if it exists.
+    There is only one, but this
+    """
+    types = (exp.DefaultColumnConstraint, exp.ComputedColumnConstraint)
+    constraints = [
+        c.kind for c in expr.constraints if isinstance(c, exp.ColumnConstraint) and isinstance(c.kind, types)
+    ]
+    return t.cast(exp.ColumnConstraintKind, constraints[0]) if constraints else None

sqlleaf/util/graph.py

@@ -0,0 +1,116 @@
+import logging
+import typing as t
+
+import networkx as nx
+
+from sqlleaf import util
+
+logger = logging.getLogger("sqlleaf")
+
+
+# TODO: add a function called 'find_unique_paths' to prevent traversal of duplicate edges
+
+
+def find_edges_downward(g: nx.MultiDiGraph, node: str, seen: t.Optional[t.Set[str]] = None, depth: int = 0):
+    """
+    Traverse the graph, returning any unseen edges.
+
+    Similar to find_edges_from_root(), except we return an unseen edge found at each hop,
+    rather than the entire path leading us there.
+    """
+    if seen is None:
+        seen = {node}
+
+    # Get direct descendants
+    desc = nx.descendants_at_distance(g, node, 1)
+
+    for n in desc:
+        if n not in seen:
+            # TODO: this could be a bug similar to the above comment in function
+            edges = g.get_edge_data(node, n)
+            for idx, data in edges.items():
+                hop = data["attrs"]
+                # Depth-first search?
+                yield depth, hop
+                yield from find_edges_downward(g, n, seen.union([n]), depth + 1)
+
+
+def find_paths(g: nx.MultiDiGraph, start=0, path: t.Optional[t.List[int]] = None, seen: t.Optional[t.Set[int]] = None):
+    """
+    Find all the complete paths in a graph by traversing the descendants of a node until we find
+    a node without any descendants.
+    """
+    if path is None:
+        path = [start]
+    if seen is None:
+        seen = {start}
+
+    # Get direct descendants
+    desc = nx.descendants_at_distance(g, start, 1)
+    if not desc:
+        yield path
+    else:
+        for n in desc:
+            if n in seen:
+                yield path
+            else:
+                yield from find_paths(g, n, path + [n], seen.union([n]))
+
+
+def get_root_nodes(graph: nx.MultiDiGraph) -> t.List[str]:
+    """
+    Get the root node of a graph. A root node has no parents.
+    """
+    selfloops = []
+
+    def remove_selfloop_edges(n1: str, n2: str, edge_key: int):
+        attrs = graph[n1][n2][edge_key]["attrs"]
+        if n1 == n2 and attrs:
+            if n1 not in selfloops:
+                selfloops.append(n1)
+            return False
+        return True
+
+    # Remove all the selfloop edges so that we can find the root node,
+    # and then add them back. (This is due to in/out_degree() inclduing them as edges)
+    view = nx.subgraph_view(graph, filter_edge=remove_selfloop_edges)
+    roots = [
+        n
+        for n in view.nodes
+        if
+        # A root node
+        (view.in_degree(n) == 0 and view.out_degree(n) > 0)
+        or
+        # A selfloop
+        (n in selfloops and view.degree(n) == 0)
+    ]
+    if selfloops:
+        logger.debug(f"Found selfloops: {selfloops}")
+    return roots
+
+
+def get_cycles(graph: nx.MultiDiGraph):
+    """
+    Find all cycles in a graph.
+    """
+    errors = 0
+
+    for cycle in nx.simple_cycles(graph):
+        columns = [col for col in cycle if col.startswith("column")]
+
+        if len(util.unique(columns)) == 1:
+            # A valid cycle. This is a selfloop that passes through another node, e.g. a function.
+            first_column = columns[0]
+            idx = cycle.index(first_column)
+            new_cycle = cycle[idx:] + cycle[:idx] + [first_column]
+            logger.debug(f"Found valid cycle in graph: {new_cycle}")
+            cycle = new_cycle
+        else:
+            if len(columns) == 0:
+                logger.error(f"A cycle must contain 1 column node: {cycle}")
+                errors = 1
+            elif len(util.unique(columns)) > 1:
+                logger.error(f"A cycle cannot contain more than 1 column (found {len(util.unique(columns))}): {cycle}")
+                errors = 1
+
+        yield cycle, errors

sqlleaf/util/helpers.py

@@ -0,0 +1,42 @@
+import hashlib
+import typing as t
+
+
+def unique(sequence: t.List):
+    """
+    Return a list of unique elements in a list while preserving insertion order.
+    """
+    seen = set()
+    return [x for x in sequence if not (x in seen or seen.add(x))]
+
+
+def flatten(lst: t.List):
+    """
+    Flatten a potentially nested list into a single list.
+    For example,
+        [a, 1, [b, c]]
+    returns
+        [a, 1, b, c]
+    """
+    result = []
+    for item in lst:
+        if isinstance(item, list):
+            result.extend(flatten(item))
+        else:
+            result.append(item)
+    return result
+
+
+def chunks(lst, n):
+    """
+    Yield successive n-sized chunks from lst.
+    """
+    return [lst[i : i + n] for i in range(0, len(lst), n)]
+
+
+def short_sha256_hash(text: str):
+    return hashlib.md5(text.encode()).hexdigest()[:16]
+
+
+def long_sha256_hash(text: str):
+    return hashlib.md5(text.encode()).hexdigest()

sqlleaf/util/iterators.py

@@ -0,0 +1,37 @@
+import typing as t
+
+import sqlglot
+from sqlglot import exp
+
+
+def default_column_index_iterator(dialect: str, elems: t.List[t.Any]) -> t.Generator[str]:
+    """
+    Generates default columns defined for a specific SQL dialect.
+    """
+    for i in range(len(elems)):
+        if dialect == "postgres":
+            yield f"column{i + 1}"
+        elif dialect == "mysql":
+            yield f"column_{i}"
+        else:
+            yield f"column{i + 1}"
+
+
+def iter_inner_statements(stmt: exp.Expr, dialect: str, wrap: bool = False) -> t.List[exp.Expr]:
+    """
+    Iterate over the inner statements of a given expression.
+    """
+    if isinstance(stmt, (exp.Literal, exp.Heredoc)):
+        body_text = stmt.this.strip()
+        try:
+            return sqlglot.parse(body_text, read=dialect)
+        except Exception:
+            return []
+    if isinstance(stmt, exp.Block):
+        return stmt.expressions
+    if isinstance(stmt, exp.Return):
+        return [exp.select(stmt.this)]
+
+    if wrap:
+        return [exp.select(stmt)]
+    return [stmt]

sqlleaf-0.0.1.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: sqlleaf
+Version: 0.0.1
+Summary: Trace your data
+Author-email: zac <zac@sqlleaf.io>
+Project-URL: Homepage, https://github.com/sqlleaf-io/sqlleaf
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: build>=1.6.1
+Requires-Dist: networkx==3.6.1
+Requires-Dist: sqlglot==30.17.0
+Dynamic: license-file
+
+# sqlleaf
+## Trace your data
+sqlleaf is a tool to help you to understand how your data flows across your data systems by producing detailed, column-level lineage across any SQL query and dialect.
+
+## Example
+
+```sql
+-- File: example.sql
+CREATE TABLE users (name VARCHAR(50), birthday DATE);
+CREATE TABLE logins (name VARCHAR(50));
+
+INSERT INTO users (name, birthday)
+SELECT LOWER(name) AS name, CURRENT_TIMESTAMP AS birthday
+FROM logins;
+```
+
+```python
+sql = open("example.sql").read()
+
+import sqlleaf
+lineage = sqlleaf.Lineage()
+lineage.generate(sql=sql, dialect="postgres")
+lineage.print_paths()
+```
+Output:
+```
+column[logins.name] -> function[LOWER] -> column[users.name]
+function[CURRENT_TIMESTAMP] -> column[users.birthday]
+```
+
+## Development
+This project is under heavy development; version 0.1 will be released soon.

sqlleaf-0.0.1.dist-info/RECORD

@@ -0,0 +1,111 @@
+sqlleaf/__init__.py,sha256=2WJBC8zD0ZbvtO-CQOaiJx1wggu7kMsXgSTl0dgVJtc,331
+sqlleaf/exception.py,sha256=TfMyvn-2oUWCfn8BI0370hIcZTIR8bdJu3hMX_mZZO4,1254
+sqlleaf/lineage.py,sha256=Z6WQ5FfegxRf3BxwAZVsKZXx9X71HpkTs-SkGJMIWZs,12099
+sqlleaf/mappings.py,sha256=QxdxWzvMRxvk2qpRvnWYf0E9EvF2VRoI_RM88KBccak,14821
+sqlleaf/path.py,sha256=C9JanxW1tx_o7L_PbUx145W-oKvWdHdQBokWvMNMxPg,6490
+sqlleaf/typing.py,sha256=U5-CQ8jiaZf8USNitpYp3skJAGXe_blpzt_mDECFMw0,2082
+sqlleaf/dialects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlleaf/dialects/plpgsql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlleaf/dialects/plpgsql/p_classes.py,sha256=HYvrgPNX6LqJltVrnanMzGeXdUP3WzA6yVRXF6YRaVU,6033
+sqlleaf/dialects/plpgsql/p_dialect.py,sha256=xYGbKCVE3Cz4biyyeCckAudYShfGQRy2Sio00sdS-5U,5705
+sqlleaf/dialects/plpgsql/p_generator.py,sha256=d0QQicRu29zomTgpk_g5euAhL2xaZTm-0zaDrS2KRMQ,22659
+sqlleaf/dialects/plpgsql/p_parser.py,sha256=VisP709VNnLn8edr8KKqBZfCeFPNuYt23o1fGVx-mZ8,47113
+sqlleaf/dialects/plpgsql/p_tokenizer.py,sha256=TDKMAlVvbO2DRg3RstZtXoYXnhTBQobVRC4sYsXSOpM,918
+sqlleaf/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlleaf/models/context.py,sha256=u2a8-ZKy-225HmpDm_iJ1LsmSPZc04Csh_I7J7EW-7g,5298
+sqlleaf/models/hook.py,sha256=X-pNZ7lU_pOVIChmIjo1vjPZqyDXa9oblI5T1I95gbs,219
+sqlleaf/models/node/__init__.py,sha256=5AtY0A6e4cSjReYTVrREqZvBjMvwz0xZJ4kNAA37jGo,1669
+sqlleaf/models/node/base.py,sha256=uh6IZZQBmTcS5DQOKYQQ3ism7IuHeQGhi_tg4vbrXHs,3979
+sqlleaf/models/node/column.py,sha256=gXR1mJvIotLzneNXPZoZUp6BwNco7lUdLP_SS2paGkc,11450
+sqlleaf/models/node/dynamodb.py,sha256=QzQ2JOiEjcdgevpZCIzpx-Z-xNzq22_XnJfWfiriMVU,951
+sqlleaf/models/node/function.py,sha256=wnurklIdp3UXAKoH9l9yxZPDdgfxbqgNObzFyochXLg,978
+sqlleaf/models/node/interval.py,sha256=xAQDGKZxMPjh4q93ICNyIGLESefbscgL5eG0th2bAVE,605
+sqlleaf/models/node/json.py,sha256=Uaqe19bGF5rXbpq5QbfI1KXGObAMk6mvm_uKi-aJsK4,1707
+sqlleaf/models/node/literal.py,sha256=cI_a5l8D7WhMdIaXlrlmFoxD9fOZz59ESriMJSY5A50,408
+sqlleaf/models/node/null.py,sha256=TIxp3495_qiGPD5yPkhw9s1T7w_p5j9hWhLBu8DmsyE,288
+sqlleaf/models/node/pivot.py,sha256=TVx8dpaGRGNnyb6yxci_re_PBG3cwf_FeZZV8NpOxNs,891
+sqlleaf/models/node/program.py,sha256=6OuVJ7Lc7J580HPNQcBbuanWc62_YkfQ3-7xDKpqd1o,920
+sqlleaf/models/node/sequence.py,sha256=Ur0yDteImYhhzphvKfP5RUswtlbEt4SZcJey-GBdWJg,565
+sqlleaf/models/node/star.py,sha256=mAJZXHOAgCVgKjQz8Al5A0y6zRq-x9Y-epTQmSya8Xw,220
+sqlleaf/models/node/stream.py,sha256=wYsIdh-Mz4cMZeWf4-ittUrj367ysejwBg1lbLAcZdg,410
+sqlleaf/models/node/user_defined_function.py,sha256=2-zVKY55MCkMgCRUrLCS7gewTzlzJwIzJ2cC8DVcmZ0,898
+sqlleaf/models/node/var.py,sha256=6kFy0bD10Db3X4XAW6mIdQoDyJDiN49gKCuttOTkpEs,133
+sqlleaf/models/node/variable.py,sha256=DQ4Jvz6iieoB-m_BHURTJuEycGYLDi-Xa7mfRhOytGg,169
+sqlleaf/models/node/window.py,sha256=Bn9D2Hq3VRZ1KWIGY6-Tr0C5EVkWWI1uIrPfAosB7o8,618
+sqlleaf/models/query/__init__.py,sha256=lIFcoT5SHB3XklSEqJ0Jt6Ydn9x2Sb26ov4UJXOHnlE,2049
+sqlleaf/models/query/base.py,sha256=YdiNCBu3Poq-9pS6wcbPasLUzjsx6JjRVbUikqQuRu0,8847
+sqlleaf/models/query/call.py,sha256=M1FkapforjstT5GI1tyGj86WIKFtkSw5AL2arfAbSjA,3247
+sqlleaf/models/query/copy.py,sha256=Jkop-b6SolAYxT9htcMxRj5sk3Oa40U5yvpOZkgomRo,5156
+sqlleaf/models/query/ctas.py,sha256=pRB32qOFiNdmjiMkOcFqqX1TbKEcM8FaRNDqvTSyxNU,2125
+sqlleaf/models/query/database.py,sha256=g6OSYc_AKvmt-wSUKcWCn9KoJsAmjgPlO5vcZTIYGsk,1229
+sqlleaf/models/query/delete.py,sha256=jHyR6wWrWbpTqR79eMh3Q0layO1oDpppzZzuETrgrTg,795
+sqlleaf/models/query/execute.py,sha256=Lzoo6aj_GnAW_IIkZJAyImaoK-5UluKpWSr5i8go0xU,1704
+sqlleaf/models/query/holder.py,sha256=PGVMkOBzGZvYbW_nH005RGXfm3fu-FgUWu_qhQ_xrXg,1838
+sqlleaf/models/query/insert.py,sha256=Ga5be9z3TWWjSFpsmHryu5LzsaAqKK0-N0o8KOAJRek,2455
+sqlleaf/models/query/merge.py,sha256=d-Zasi677TuQeHwYq4qtyMUnuRZks_ZuAFfPX8-GM0c,820
+sqlleaf/models/query/multitable_insert.py,sha256=1HBH2OQLQ8Y9hGSPm7qcxvLWsIIMQE8zWP8NqfRvXr8,1313
+sqlleaf/models/query/prepare.py,sha256=72MVxpIIjasD4V7WnFCGFFZc0_Pn64aTphRvYfFbkrc,2306
+sqlleaf/models/query/procedure.py,sha256=Rg2z2jzTE-vaafiX9eyulgH0aA1EqtQKV4mc7U-SQjg,2278
+sqlleaf/models/query/put.py,sha256=_vC2KuZ4DC5j-u3oHXRFOgxC3VvQ7VpHNq4ZBYES978,1141
+sqlleaf/models/query/replace.py,sha256=cS4u5ueEn9SYUi1p9mJ1L9S0MW-bwQwFnUcJ3xYjY6E,899
+sqlleaf/models/query/schema.py,sha256=MZ-lPZ626uYuRr8YeeJGODJIKFTnuN9MHL84g8SRIFY,1218
+sqlleaf/models/query/select.py,sha256=YFfHXOwG20ZoBghKKpdxI-wjecyFSTmkEqHqISCgjHk,867
+sqlleaf/models/query/sequence.py,sha256=YW9TM8GOZrCxhuAV6qtcyTsvFaHxiL8ZDzAJohXW_6Q,891
+sqlleaf/models/query/set.py,sha256=wgVfZkuuiOtsJSmVllg1M3xj_C2jIwmPBRCuNbWziTc,2937
+sqlleaf/models/query/stage.py,sha256=nR9WXQ-XJLEqlfO5KmWL2xaeXLuNTOS6UQpfQX55yn8,2240
+sqlleaf/models/query/table.py,sha256=mVHBeQL88TrhbXGCwURMun97FD_9TaszFc_6wIm7uU0,9225
+sqlleaf/models/query/trigger.py,sha256=MgknCT2VLCqsOCsYo8BKU5XGGjHuio3fJE2zTd0_qeQ,1416
+sqlleaf/models/query/type.py,sha256=tavtoqIcn5Q7kS7s_94D5t-l8B2b0p_HqKJp3p48Kds,1255
+sqlleaf/models/query/unload.py,sha256=tsdmlW_G09WpaN6SP89Uk5IhVV_vlm6z3ed0FRc8hBk,2624
+sqlleaf/models/query/update.py,sha256=-RmuhzDEnKB_ulZs4_D_ef-IEWf0mW7fU6Y5cC4og6E,1365
+sqlleaf/models/query/user_defined_function.py,sha256=nQ5gx9poj2IUabi5QePMQ0hd8JxzIFkiB8TDqGzj-o0,11506
+sqlleaf/models/query/values.py,sha256=O-j8-EXegtZAUOKAiuCFyFOUaM9tXIJAv9R1kNGg7Bc,684
+sqlleaf/models/query/view.py,sha256=dUdXwgX5AqhcknyNuxzfnJshm2d5s80M02LvpuX5RKM,1254
+sqlleaf/processors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlleaf/processors/collector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlleaf/processors/collector/collector.py,sha256=yu2KjOb6bET4NRo7zWgpcnbCs72e7_FYI22tZpkIWgU,31049
+sqlleaf/processors/collector/substitute.py,sha256=A59Oz3pm9ZfZ701-z9HcRILKJkioMKWlZZEJzIELp_g,14471
+sqlleaf/processors/generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlleaf/processors/generator/generator.py,sha256=gkKv3WIGIcfqL_KaIncofjuqnW3EeKvvb4deIuZ_6fg,18225
+sqlleaf/processors/generator/dialects/__init__.py,sha256=D_odD7gs7EvS00eTX7JInqqgKRKyxWi_hKAfs1C4Vl0,478
+sqlleaf/processors/generator/dialects/athena.py,sha256=UWaJwCWQ-KmKbH3dfPgCGpWP5TtvoMzKxJ_ieG3xxn4,1474
+sqlleaf/processors/generator/dialects/base.py,sha256=fQrhHYUtItxt0UH9yA43jf8ugOsGuIlNgdRGcIvtzoU,22587
+sqlleaf/processors/generator/dialects/mysql.py,sha256=Bqzr3GAUbX1C6gex4HshVB2e8NbJuj3YDtyRbA1KYVA,588
+sqlleaf/processors/generator/dialects/postgres.py,sha256=E7J8F1ANWCwLpvsuZXDrbF_olb5TZ_sQyE704EAxOEU,7342
+sqlleaf/processors/generator/dialects/redshift.py,sha256=J_XUBDpHiJqU0sbNlwGBfs8jGcBwhJk4-KdAe06b_Pg,7471
+sqlleaf/processors/generator/dialects/snowflake.py,sha256=fGnppTapcFUDGNTMXCgAJzQhSPrnqxFpS0HVZqsmHZk,3127
+sqlleaf/processors/transformer/__init__.py,sha256=EDt2LnAHXTx8wsTRUeZyY8rOxdndM0jC5nNyJFtqp_k,1302
+sqlleaf/processors/transformer/base.py,sha256=n6NW3YXE1nMhKo9XKw6n4IU5txllkQ1c5lsZcX-qVE0,37421
+sqlleaf/processors/transformer/call.py,sha256=jDr9z6-uQSP7piKpoVEAesns_wwcBGNpN4-UN5O37us,164
+sqlleaf/processors/transformer/copy.py,sha256=a8EYrdtynC6FDPKkb3LsteJdzHQagTM6hh7Q1CDfUN0,2230
+sqlleaf/processors/transformer/ctas.py,sha256=XgnDLTZQ2HAq19yVDrYPyE8vvtHAh003gQ3v44emz28,1603
+sqlleaf/processors/transformer/delete.py,sha256=UXqVXygyxsei1liHWSMUht4KTQWNPxCMy_WyejPXZ2Q,375
+sqlleaf/processors/transformer/execute.py,sha256=0-4fzmvDhqU98FGsWl62T9-pRGzVN-Y0MYA5Vio66NE,167
+sqlleaf/processors/transformer/insert.py,sha256=JBauC6nU0rM4S3YZrGavazadE8apgCtbQ6iFYl1W_no,4644
+sqlleaf/processors/transformer/merge.py,sha256=6kE_oiqIvAoy1C7FOx0s08FSJB9mYaDUttmbV7QyF0w,369
+sqlleaf/processors/transformer/multitable_insert.py,sha256=mNwvBid_73BjLuyvHv4hdgR6D7Bo3vvTjBOo21H8tFY,413
+sqlleaf/processors/transformer/replace.py,sha256=3Sd4rHPHZZULNh-Rv7PFKRy5VjMSfDnY2G1cI_5QqzQ,972
+sqlleaf/processors/transformer/transformer.py,sha256=YtDHRy_MzoBY2pBDlfwGkWB2Mig6D6-66rveF2QAttI,5068
+sqlleaf/processors/transformer/udf.py,sha256=wvXmCZxkcrAWkP0fhUfgYFz7wh3PjcQtwCSV0UU2Fdc,8820
+sqlleaf/processors/transformer/unload.py,sha256=bc-_XQo-o9LV8sxys2fWqCzQAWVRJFIY0ZP1YatizaI,960
+sqlleaf/processors/transformer/update.py,sha256=BZW-60IqVJvh_6XAoHiZs_W0cEB9R4Vp6tfXkaFodXw,7935
+sqlleaf/processors/transformer/values.py,sha256=rBOaHiD3wu5skDTdYQbiOcrZrxq-LZjNYA-j1N3ytuI,362
+sqlleaf/processors/transformer/expressions/__init__.py,sha256=WzhAQKYYJyJI00btAykFBLqLuqCSZABYsuG9a0SSjfs,508
+sqlleaf/processors/transformer/expressions/functional_notation.py,sha256=r4bweR3kfhzwUmu3BOcbk4gq6uz42-8wKuQQrLeSdBU,809
+sqlleaf/processors/transformer/expressions/row.py,sha256=6_ldPcjoeYm8OjPZPz2obO1t7ZPl0_Mibops6xhIVIg,16621
+sqlleaf/processors/transformer/expressions/values.py,sha256=x6rDdoyudPck4zZLzwjl1U0yDVC0_PoQjP5LDQNmhSQ,12297
+sqlleaf/settings/__init__.py,sha256=7hd3p03Wwi4CzKdwrpiP9bKYD4tANseWZzxp-e5bKk4,657
+sqlleaf/settings/athena.py,sha256=z9kW3Ai0-HZBb8Z4D8XaJJa4EzprArwScT2W09mqBVY,616
+sqlleaf/settings/base.py,sha256=ygwsWpUjbjW8HAKz9dG2p5NrQVQRVxYB0Ot3rMr7Qbw,985
+sqlleaf/settings/postgres.py,sha256=W5PG6K_yNLLW-jNZ5Q2dIpeC42J0PPaAr5SafGiHFuM,1749
+sqlleaf/system_tables/load.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlleaf/util/__init__.py,sha256=Vw296gA0C7-0NicFrCE2gYJIXkug9lYFRZrcE9bbG78,1263
+sqlleaf/util/expression.py,sha256=3iyE7OPXhnKsV1WxhrOMLVhiHbOZq8-a6KHeprgooNQ,9415
+sqlleaf/util/graph.py,sha256=CdfMYzEZ1eAa3kRhrD7UBB0t_Szeoaap4x0IFu70Daw,3669
+sqlleaf/util/helpers.py,sha256=44elo1HXDFlxcLNdAS0nD7xXAQgDkVFKvPZi4MJC06s,918
+sqlleaf/util/iterators.py,sha256=NSPtlUmFA7pJ0HsBZtR8tpmzkfJ2OObGr9TbJVoWB2g,1045
+sqlleaf-0.0.1.dist-info/licenses/LICENSE,sha256=z6iHh46VCvulJEPA9ZyH9v31vKaln0ZbwiUNicP6d1U,1071
+sqlleaf-0.0.1.dist-info/METADATA,sha256=DXvopvClo7fEnATMF5Zx83GydfCf0yFxUqE00CR1GTM,1197
+sqlleaf-0.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+sqlleaf-0.0.1.dist-info/top_level.txt,sha256=dokK2cq3jbXlILUgh6ymk5kGkJj7FqvTSBLGEzSRpjQ,8
+sqlleaf-0.0.1.dist-info/RECORD,,

sqlleaf-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+