sqlcompose 0.0.1__tar.gz → 0.0.3__tar.gz

sqlcompose-0.0.3/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: sqlcompose
+Version: 0.0.3
+Summary: Composition of linked SQL files
+Author-email: Anders Madsen <anders.madsen@alphavue.com>
+License: MIT
+Project-URL: repository, https://github.com/apmadsen/sqlcompose
+Keywords: sql,composition,windows,linux
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 6 - Mature
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3 :: Only
+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
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=8.3.0; extra == "test"
+Requires-Dist: pytest-cov>=6.1.0; extra == "test"
+Dynamic: license-file
+
+[![Test](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test.yml/badge.svg)](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test.yml)
+[![Coverage](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test-coverage.yml/badge.svg)](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test-coverage.yml)
+![Stable Version](https://img.shields.io/pypi/v/sqlcompose?label=stable&sort=semver&color=blue)
+![Pre-release Version](https://img.shields.io/github/v/release/apmadsen/sqlcompose?label=pre-release&include_prereleases&sort=semver&color=blue)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sqlcompose)
+
+
+# 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:__
+```console
+sqlcompose query.sql
+```
+```bash
+sqlcompose 'select * from $INCLUDE(included-query1.sql)' # on linux
+sqlcompose "select * from $INCLUDE(included-query1.sql)" # on windows
+```
+
+__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.1/PKG-INFO → sqlcompose-0.0.3/README.md

@@ -1,20 +1,9 @@
-Metadata-Version: 2.3
-Name: sqlcompose
-Version: 0.0.1
-Summary: Composition of linked SQL files
-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
+[![Test](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test.yml/badge.svg)](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test.yml)
+[![Coverage](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test-coverage.yml/badge.svg)](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test-coverage.yml)
+![Stable Version](https://img.shields.io/pypi/v/sqlcompose?label=stable&sort=semver&color=blue)
+![Pre-release Version](https://img.shields.io/github/v/release/apmadsen/sqlcompose?label=pre-release&include_prereleases&sort=semver&color=blue)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sqlcompose)
+
 
 # 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.
@@ -24,7 +13,7 @@ __Execute the script directly:__
 ```console
 sqlcompose query.sql
 ```
-```console
+```bash
 sqlcompose 'select * from $INCLUDE(included-query1.sql)' # on linux
 sqlcompose "select * from $INCLUDE(included-query1.sql)" # on windows
 ```
@@ -87,4 +76,3 @@ WITH Q_1_1 AS (
 )
 SELECT * FROM Q_1
 ```
-

sqlcompose-0.0.3/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "sqlcompose"
+dynamic = ["version"]
+description = "Composition of linked SQL files"
+keywords = ["sql", "composition", "windows", "linux"]
+readme = "README.md"
+authors = [
+    { name = "Anders Madsen", email = "anders.madsen@alphavue.com" }
+]
+license = { text = "MIT" }
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Development Status :: 6 - Mature",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
+    "Typing :: Typed"
+]
+dependencies = []
+requires-python = ">=3.10"
+
+[project.urls]
+repository = "https://github.com/apmadsen/sqlcompose"
+
+[project.scripts]
+"sqlcompose" = "sqlcompose.__main__:main"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.3.0",
+    "pytest-cov>=6.1.0",
+]
+
+[tool.setuptools.dynamic]
+version = { attr = 'sqlcompose.__init__.__version__' }
+
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"

sqlcompose-0.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sqlcompose-0.0.3/src/sqlcompose/__init__.py

@@ -0,0 +1,10 @@
+from sqlcompose.core.functions import load, loads
+from sqlcompose.core.circular_dependency_error import CircularDependencyError
+
+__all__ = [
+    'load',
+    'loads',
+    'CircularDependencyError',
+]
+__package_name__ = "sqlcompose"
+__version__ = "0.0.3"

sqlcompose-0.0.3/src/sqlcompose/__main__.py

@@ -0,0 +1,15 @@
+from sys import argv, exit, stderr, stdout
+from sqlcompose.core.app import app
+
+def main(): # pragma: no cover
+    result, code = app(argv[1:])
+
+    if code == 0:
+        stdout.write(result)
+    else:
+        stderr.write(result)
+
+    exit(code)
+
+if __name__ == "__main__":
+    main()

sqlcompose-0.0.1/src/sqlcompose/__main__.py → sqlcompose-0.0.3/src/sqlcompose/core/app.py

@@ -1,30 +1,22 @@
 from os import path
-from sys import exit
 from argparse import ArgumentParser
 
 from sqlcompose.core.functions import load, loads
 
 
-def main():
+def app(args: list[str]) -> tuple[str, int ]:
     try:
         parser = ArgumentParser(prog = "sqlcompose")
         parser.add_argument("input", type=str, help = "SQL expression or location of an SQL file")
-        pargs = parser.parse_args()
+        pargs = parser.parse_args(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()
+        return sql, 0
+    except SystemExit as ex:
+        return str(ex), 2
+    except Exception as ex: # pragma: no cover
+        return f"Unexpected error: {ex}", 1

sqlcompose-0.0.3/src/sqlcompose/core/circular_dependency_error.py

@@ -0,0 +1,2 @@
+class CircularDependencyError(Exception):
+    ...

{sqlcompose-0.0.1 → sqlcompose-0.0.3}/src/sqlcompose/core/functions.py

@@ -1,9 +1,10 @@
 from os import path
-from typing import Sequence, MutableSequence, MutableMapping, cast
+from typing import Sequence
 from os import path
 from re import compile, sub, escape, IGNORECASE
 from textwrap import indent
 
+from sqlcompose.core.circular_dependency_error import CircularDependencyError
 from sqlcompose.core.include import Include
 from sqlcompose.core.compat import fix_path, get_relative_path
 
@@ -19,7 +20,7 @@ def loads(sql: str) -> str:
     Returns:
         str: The composed query
     """
-    return cast(str, compose(sql, "SQL", path.curdir, path.curdir))
+    return compose(sql, "SQL", path.curdir, path.curdir)
 
 
 def load(filename: str) -> str:
@@ -40,7 +41,7 @@ def load(filename: str) -> str:
 
 
     with open(filename, "r", encoding="utf-8") as file:
-        return cast(str, compose(file.read(), filename, filename, path.dirname(filename)))
+        return compose(file.read(), filename, filename, path.dirname(filename))
 
 
 def compose(
@@ -49,52 +50,55 @@ def compose(
     file_path: str,
     root: str,
     level: int = 1,
-    included: MutableSequence[str] | None = None,
-    included1: MutableMapping[str, tuple[str, int]] | None = None
-) -> str | None:
+    stack: list[str] | None = None
+) -> str:
 
     file_path = fix_path(file_path)
-    included = included or []
-    included1 = included1 or {}
+    stack = stack or []
+    parent = stack[-1] if stack else None
+    name = get_relative_path(name, root)
+    index = 1
+    included: list[str] = []
     includes: list[Include] = []
-    parent = included[len(included)-2] if len(included) > 1 else None
+    stack.append(name)
 
-    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
+    if len(stack) > 1 and name in (stack[1:-1]):
+        raise CircularDependencyError
 
     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)
+        if file_path_inner not in included:
+            included.append(file_path_inner)
+            try:
+                with open(file_path_inner, "r", encoding="utf-8") as file:
+                    composed = compose(
+                        file.read(),
+                        match.group(1),
+                        file_path_inner,
+                        root,
+                        level + 1,
+                        stack.copy()
+                    )
+                includes.append(
+                    Include(
+                        composed,
+                        f"Q_{level}_{index}",
+                        match.group(0),
+                        match.group(1)
+                    )
                 )
-            )
-            index = index + 1
+                index = index + 1
+            except FileNotFoundError:
+                if parent is not 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...")
 
     for include in includes:
         sql = sub(escape(include.match), include.name, sql)
 
+    stack.pop()
+
     return wrap_cte_sql(includes, sql, level, name)
 
 def wrap_cte_sql(includes: Sequence[Include], sql: str, level: int, source: str) -> str:

{sqlcompose-0.0.1 → sqlcompose-0.0.3}/src/sqlcompose/core/include.py

@@ -20,5 +20,5 @@ class Include():
         return self.__match
 
     @property
-    def source(self) -> str:
+    def source(self) -> str: # pragma: no cover
         return self.__source

sqlcompose-0.0.3/src/sqlcompose.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: sqlcompose
+Version: 0.0.3
+Summary: Composition of linked SQL files
+Author-email: Anders Madsen <anders.madsen@alphavue.com>
+License: MIT
+Project-URL: repository, https://github.com/apmadsen/sqlcompose
+Keywords: sql,composition,windows,linux
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 6 - Mature
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3 :: Only
+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
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=8.3.0; extra == "test"
+Requires-Dist: pytest-cov>=6.1.0; extra == "test"
+Dynamic: license-file
+
+[![Test](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test.yml/badge.svg)](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test.yml)
+[![Coverage](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test-coverage.yml/badge.svg)](https://github.com/apmadsen/sqlcompose/actions/workflows/python-test-coverage.yml)
+![Stable Version](https://img.shields.io/pypi/v/sqlcompose?label=stable&sort=semver&color=blue)
+![Pre-release Version](https://img.shields.io/github/v/release/apmadsen/sqlcompose?label=pre-release&include_prereleases&sort=semver&color=blue)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sqlcompose)
+
+
+# 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:__
+```console
+sqlcompose query.sql
+```
+```bash
+sqlcompose 'select * from $INCLUDE(included-query1.sql)' # on linux
+sqlcompose "select * from $INCLUDE(included-query1.sql)" # on windows
+```
+
+__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.3/src/sqlcompose.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+src/sqlcompose/__init__.py
+src/sqlcompose/__main__.py
+src/sqlcompose/py.typed
+src/sqlcompose.egg-info/PKG-INFO
+src/sqlcompose.egg-info/SOURCES.txt
+src/sqlcompose.egg-info/dependency_links.txt
+src/sqlcompose.egg-info/entry_points.txt
+src/sqlcompose.egg-info/requires.txt
+src/sqlcompose.egg-info/top_level.txt
+src/sqlcompose/core/app.py
+src/sqlcompose/core/circular_dependency_error.py
+src/sqlcompose/core/compat.py
+src/sqlcompose/core/functions.py
+src/sqlcompose/core/include.py
+tests/test_app.py
+tests/test_compat.py
+tests/test_functions.py

sqlcompose-0.0.3/src/sqlcompose.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sqlcompose-0.0.3/src/sqlcompose.egg-info/entry_points.txt

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

sqlcompose-0.0.3/src/sqlcompose.egg-info/requires.txt

@@ -0,0 +1,4 @@
+
+[test]
+pytest>=8.3.0
+pytest-cov>=6.1.0

sqlcompose-0.0.3/src/sqlcompose.egg-info/top_level.txt

@@ -0,0 +1 @@
+sqlcompose

sqlcompose-0.0.3/tests/test_app.py

@@ -0,0 +1,29 @@
+# pyright: basic
+from unittest import TestCase, main
+
+from sqlcompose.core.app import app
+
+class Test(TestCase):
+    # def test_nonexisting(self):
+    #     _result, code = app(["nonexisting.sql"])
+    #     self.assertEqual(code, 1)
+
+    def test_missing_args(self):
+        _result, code = app([])
+        self.assertEqual(code, 2)
+
+    def test_existing_file_by_path(self):
+        result, code = app(["tests/main-query.sql"])
+        self.assertGreater(len(result), 0)
+        self.assertEqual(code, 0)
+
+    def test_sql(self):
+        result, code = app(["SELECT * FROM $INCLUDE(tests/main-query.sql)"])
+        # print(result)
+        self.assertGreater(len(result), 0)
+        self.assertEqual(code, 0)
+
+
+if __name__ == '__main__':
+    main()
+

sqlcompose-0.0.3/tests/test_compat.py

@@ -0,0 +1,52 @@
+# pyright: basic
+from unittest import TestCase, main
+from sys import platform
+
+from sqlcompose.core.compat import fix_path, get_relative_path
+
+class Test(TestCase):
+
+    def test_fix_path(self):
+        if platform == "win32":
+            tests = {
+                "sql\\file.sql" : "sql\\file.sql",
+                "sql\\file.sql" : "sql/file.sql",
+            }
+        else:
+            tests = {
+                "sql/file.sql" : "sql\\file.sql",
+                "sql/file.sql" : "sql/file.sql",
+            }
+
+        for expected_result, file_path in tests.items():
+            result = fix_path(file_path)
+            self.assertEqual(result, expected_result)
+
+
+    def test_get_relative_path(self):
+        if platform == "win32":
+            tests = {
+                "sql\\file.sql" : ("sql\\file.sql", "sql\\file.sql"),
+                "sql\\file.sql" : ("sql\\file.sql", "c:\\app\\"),
+                "sql\\file.sql" : ("c:\\app\\sql\\file.sql", "c:\\app\\"),
+            }
+
+            p = "sql\\file.sql"
+            self.assertEqual(p, get_relative_path(p, p))
+        else:
+            tests = {
+                "sql/file.sql" : ("sql/file.sql", "sql/file.sql"),
+                "sql/file.sql" : ("sql/file.sql", "/app/"),
+                "sql/file.sql" : ("/app/sql/file.sql", "/app/"),
+            }
+            p = "sql/file.sql"
+            self.assertEqual(p, get_relative_path(p, p))
+
+        for expected_result, (file_path, root) in tests.items():
+            result = get_relative_path(file_path, root)
+            self.assertEqual(result, expected_result)
+
+
+if __name__ == '__main__':
+    main()
+

sqlcompose-0.0.3/tests/test_functions.py

@@ -0,0 +1,40 @@
+# pyright: basic
+from unittest import TestCase, main
+
+from sqlcompose import loads, load, CircularDependencyError
+from sqlcompose.core.functions import compose
+
+class Test(TestCase):
+    def test_nonexisting(self):
+        self.assertRaises(FileNotFoundError, load, "nonexisting.sql")
+        self.assertRaises(FileNotFoundError, load, "tests/non_existing_include.sql")
+        self.assertRaises(FileNotFoundError, compose, "select * from $INCLUDE(some_file_that_does_not_exist.sql)", "SQL", ".", ".")
+
+        filename = "tests/existing_include.sql"
+        with open(filename, "r", encoding="utf-8") as file:
+            self.assertRaises(FileNotFoundError, compose, file.read(), filename, filename, ".")
+
+    def test_reuse_composition(self):
+        result = compose("select * from $INCLUDE(tests/includes/included-query3.sql)", "SQL", ".", ".")
+        # print(result)
+        self.assertTrue(len(result) > 0)
+
+
+    def test_existing_file_by_path(self):
+        result = load("tests/main-query.sql")
+        # print(result)
+        self.assertTrue(len(result) > 0)
+
+    def test_sql(self):
+        result = loads("SELECT * FROM $INCLUDE(tests/main-query.sql)")
+        # print(result)
+        self.assertTrue(len(result) > 0)
+
+    def test_circular_dependency(self):
+        self.assertRaises(CircularDependencyError, load, "tests/circular_left.sql")
+
+
+
+if __name__ == '__main__':
+    main()
+

sqlcompose-0.0.1/README.md

@@ -1,71 +0,0 @@
-# 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:__
-```console
-sqlcompose query.sql
-```
-```console
-sqlcompose 'select * from $INCLUDE(included-query1.sql)' # on linux
-sqlcompose "select * from $INCLUDE(included-query1.sql)" # on windows
-```
-
-__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.1/pyproject.toml

@@ -1,24 +0,0 @@
-[tool.poetry]
-name = "sqlcompose"
-version = "0.0.1"
-description = "Composition of linked SQL files"
-readme = "README.md"
-authors = ["Anders Madsen <anders.madsen@alphavue.com>"]
-license = "MIT"
-repository = "https://github.com/apmadsen/sqlcompose"
-classifiers = [
-    "Operating System :: OS Independent"
-]
-packages = [
-    { include = "sqlcompose", from = "src" }
-]
-
-[tool.poetry.scripts]
-"sqlcompose" = "sqlcompose.main:main"
-
-[tool.poetry.dependencies]
-python = ">=3.10,<=3.13"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"

sqlcompose-0.0.1/src/sqlcompose/__init__.py

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