sqlcompose 0.0.0__py3-none-any.whl

sqlcompose/__init__.py

@@ -0,0 +1,6 @@
+from sqlcompose.core.functions import load, loads
+
+__all__ = [
+    'load',
+    'loads',
+]

sqlcompose/__main__.py

@@ -0,0 +1,30 @@
+from os import path
+from sys import exit
+from argparse import ArgumentParser
+
+from sqlcompose.core.functions import load, loads
+
+
+def main():
+    try:
+        parser = ArgumentParser(prog = "sqlcompose")
+        parser.add_argument("input", type=str, help = "SQL expression or location of an SQL file")
+        pargs = parser.parse_args()
+
+        if path.isfile(pargs.input):
+            sql = load(pargs.input)
+        else:
+            sql = loads(pargs.input)
+
+        print(sql)
+
+        return
+    except SystemExit:
+        raise # let argparse print error(s)
+    except Exception as ex:
+        print(f"Unexpected error: {ex}")
+        exit(1)
+
+
+if __name__ == "__main__":
+    main()

sqlcompose/core/compat.py

@@ -0,0 +1,32 @@
+from os import path
+
+WINDOWS_PATH_SEP = "\\"
+UNIX_PATH_SEP = "/"
+
+def fix_path(file_path: str) -> str:
+    """Replaces all path separators, be they Linux or Windows style
+    to the standard path separator of the system.
+
+    Args:
+        file_path (str): The file path to fix.
+    """
+    for str in [ WINDOWS_PATH_SEP, UNIX_PATH_SEP ]:
+        if str != path.sep:
+            file_path = file_path.replace(str, path.sep)
+
+    return file_path
+
+def get_relative_path(file_path: str, root: str) -> str:
+    """Get the path relative to root path.
+
+    Args:
+        file_path (str): The path.
+        root (str): The root path.
+
+    Returns:
+        str: The relative path.
+    """
+    if root == file_path:
+        return file_path
+    else:
+        return path.relpath(file_path, path.commonprefix([root, file_path]))

sqlcompose/core/functions.py

@@ -0,0 +1,117 @@
+from os import path
+from typing import Sequence, MutableSequence, MutableMapping, cast
+from os import path
+from re import compile, sub, escape, IGNORECASE
+from textwrap import indent
+
+from sqlcompose.core.include import Include
+from sqlcompose.core.compat import fix_path, get_relative_path
+
+REGEX_INCLUDE = compile(r"\$INCLUDE\(([^\)]+)\)", IGNORECASE)
+
+
+def loads(sql: str) -> str:
+    """Compose SQL
+
+    Args:
+        sql (str): The query text
+
+    Returns:
+        str: The composed query
+    """
+    return cast(str, compose(sql, "SQL", path.curdir, path.curdir))
+
+
+def load(filename: str) -> str:
+    """Compose SQL
+
+    Args:
+        filename (str): The path of the file containing the SQL
+
+    Returns:
+        str: The composed query
+    """
+
+
+    filename = fix_path(filename)
+
+    if not path.isfile(filename):
+        raise FileNotFoundError(filename)
+
+
+    with open(filename, "r", encoding="utf-8") as file:
+        return cast(str, compose(file.read(), filename, filename, path.dirname(filename)))
+
+
+def compose(
+    sql: str,
+    name: str,
+    file_path: str,
+    root: str,
+    level: int = 1,
+    included: MutableSequence[str] | None = None,
+    included1: MutableMapping[str, tuple[str, int]] | None = None
+) -> str | None:
+
+    file_path = fix_path(file_path)
+    included = included or []
+    included1 = included1 or {}
+    includes: list[Include] = []
+    parent = included[len(included)-2] if len(included) > 1 else None
+
+    if name in included and included1[name][1] == level:
+        #duplicate include at the same level - return none, to use the previously composed SQL
+        return None
+    elif name in included:
+        raise Exception(f"Circular dependency detected: File \"{get_relative_path(file_path, root)}\" has already been already included")
+    else:
+        included.append(name)
+        included1[name] = (file_path, level)
+
+    index = 1
+
+    for match in REGEX_INCLUDE.finditer(sql):
+        file_path_inner = fix_path(path.join(path.dirname(file_path), match.group(1)))
+        try:
+            with open(file_path_inner, "r", encoding="utf-8") as file:
+                composed = compose(file.read(), match.group(1), file_path_inner, root, level=level+1)
+        except FileNotFoundError:
+            if not parent is None:
+                raise FileNotFoundError(f"Include failed: File \"{get_relative_path(file_path_inner, root)}\" which was referred to in \"{get_relative_path(parent, root)}\", was not found...")
+            else:
+                raise FileNotFoundError(f"Include failed: File \"{get_relative_path(file_path_inner, root)}\" was not found...")
+
+        if composed is not None:
+            includes.append(
+                Include(
+                    composed,
+                    f"Q_{level}_{index}",
+                    match.group(0),
+                    match.group(1)
+                )
+            )
+            index = index + 1
+
+    for include in includes:
+        sql = sub(escape(include.match), include.name, sql)
+
+    return wrap_cte_sql(includes, sql, level, name)
+
+def wrap_cte_sql(includes: Sequence[Include], sql: str, level: int, source: str) -> str:
+    sql_output = ""
+    indent_str = "  "
+
+    if len(includes) > 0:
+        for include in includes:
+            sql_output = "WITH " if sql_output == "" else sql_output + ", "
+            sql_output = f"{sql_output}{include.name} AS (\n{include.sql}\n)"
+
+        sql_output = sql_output + ", Q_{0} AS (\n{1}\n)\nSELECT * FROM Q_{0}".format(level, indent("--{1}\n{0}".format(sql, source), indent_str)) #+ "\.format(level)
+    else:
+        sql_output = f"--{source}\n{sql}"
+
+    return sql_output if level == 1 else indent(sql_output, indent_str)
+
+
+
+

sqlcompose/core/include.py

@@ -0,0 +1,24 @@
+class Include():
+    __slots__ = [ "__sql", "__name", "__match", "__source" ]
+
+    def __init__(self, sql: str, name: str, match: str, source: str):
+        self.__sql = sql
+        self.__name = name
+        self.__match = match
+        self.__source = source
+
+    @property
+    def sql(self) -> str:
+        return self.__sql
+
+    @property
+    def name(self) -> str:
+        return self.__name
+
+    @property
+    def match(self) -> str:
+        return self.__match
+
+    @property
+    def source(self) -> str:
+        return self.__source

sqlcompose-0.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dagrofa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqlcompose-0.0.0.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.3
+Name: sqlcompose
+Version: 0.0.0
+Summary: 
+License: MIT
+Author: Anders Madsen
+Author-email: anders.madsen@alphavue.com
+Requires-Python: >=3.10,<=3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Project-URL: Repository, https://github.com/apmadsen/sqlcompose
+Description-Content-Type: text/markdown
+
+# sqlcompose: Composition of linked SQL files
+sqlcompose allows you to compose sql files from multiple files by introducing `INCLUDE` keywords. The SQL output is composed as CTE's or Common Table Expressions.
+
+## Examples
+__Execute the script directly:__
+```
+sqlcompose query.sql
+sqlcompose "select * from $INCLUDE(included-query1.sql)"
+```
+
+__Import it in another script:__
+```python
+from sqlcompose import load, loads
+# method 1 : loading from a file
+sql1 = load("query.sql")
+
+# method 2 : loading from an SQL string
+sql2 = loads("""
+    select *
+      from dataset.table main
+inner join $INCLUDE(other.sql) other
+        on other.field = main.field
+  """)
+```
+
+## Preparing SQL scripts
+Insert a `$INCLUDE(filename)` where the reference to the file should be in the resulting SQL, keeping in mind that references are loaded relative to the file loaded or the current working dir in case of an SQL string.
+
+```sql
+--main-query.sql
+select * from $INCLUDE(includes\included-query2.sql)
+```
+```sql
+--included-query1.sql
+select 1 as test
+```
+```sql
+--included-query2.sql
+select * from $INCLUDE(included-query1.sql)
+union all
+select * from $INCLUDE(nested\included-query3.sql)
+```
+```sql
+--nested\included-query3.sql
+select 1 as test
+```
+Which outputs:
+```sql
+WITH Q_1_1 AS (
+  WITH Q_2_1 AS (
+    --includes\included-query1.sql
+    select 1 as test
+  ), Q_2_2 AS (
+    --includes\nested\included-query3.sql
+    select 1 as test
+  ), Q_2 AS (
+    --includes\included-query2.sql
+    select * from Q_2_1
+    union all
+    select * from Q_2_2
+  )
+  SELECT * FROM Q_2
+), Q_1 AS (
+  --test\main-query.sql
+  select * from Q_1_1
+)
+SELECT * FROM Q_1
+```
+

sqlcompose-0.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+sqlcompose/__init__.py,sha256=yAFSzkLv3bCZ6e4OWvws6aYjwHfLQcxhGVzK12Fs_CQ,89
+sqlcompose/__main__.py,sha256=5TpsgP8V1SC14siCyUcHdEYWm9vDwxaUtqUgCC5f_4w,691
+sqlcompose/core/compat.py,sha256=pIF8Lk-5MhwAlHD4_RCMXYOxiDyTJIA5nlbR5_Dyw0g,819
+sqlcompose/core/functions.py,sha256=eHK_STVYOGDn3dtShTa0xaasYQi220tF12bQH9qEEUI,3693
+sqlcompose/core/include.py,sha256=ejNaz2p2Lq1pUnwMxtBqE4p_hBOtG8OynqRpECLEbNQ,541
+sqlcompose-0.0.0.dist-info/LICENSE,sha256=WtJk2ScYuo_lEP42z3DYU191mO2oU8z00nPsL9KAWCQ,1063
+sqlcompose-0.0.0.dist-info/METADATA,sha256=dPh6avQdIOJ6NO20-Z3h8iRUEFM8VtVEzxSPhjcOqrk,2269
+sqlcompose-0.0.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+sqlcompose-0.0.0.dist-info/entry_points.txt,sha256=N3eGXJzvw5yx5WgFFmX0L6Nw0-ojm90OfhtlC-C6t_4,51
+sqlcompose-0.0.0.dist-info/RECORD,,

sqlcompose-0.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.2
+Root-Is-Purelib: true
+Tag: py3-none-any

sqlcompose-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+sqlcompose=sqlcompose.main:main
+