django-sql-compiler 0.1.0__tar.gz → 0.2.0__tar.gz

django_sql_compiler-0.2.0/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project uses [Semantic Versioning](https://semver.org/).
+
+## [0.2.0] - 2026-10-25
+
+The first release since 0.1.1 (June 2021). It ships correctness fixes and first-time MySQL support.
+
+### Added
+
+- MySQL support for `django.db.backends.mysql` (via mysqlclient), contributed in [PR 2](https://github.com/JaredStufftGD/django-sql-compiler/pull/2). It is covered by the live-database test suite and CI. In 0.1.1 the MySQL compiler was a stub and was not registered.
+
+### Fixed
+
+- Non-ASCII parameters are decoded with the connection's encoding instead of byte by byte, so values like `café` are no longer garbled. 0.1.1 corrupted them.
+- SQL is compiled for the queryset's own database alias (`.using()` or a database router) instead of the default alias.
+- The unsupported-backend error names the ENGINE instead of saying "None backend is not supported".
+
+### Changed
+
+- Decoding is strict. Compiler output that can't be decoded with the connection's codec raises `UnicodeDecodeError` (or `LookupError` for an unknown client encoding) instead of returning garbled text. A Postgres connection on `SQL_ASCII`, or another unusual client encoding, with non-ASCII data now raises where 0.1.1 returned text. A compiler that returns non-bytes raises `TypeError`.
+- Semi-public API:
+  - `sql_compiler.utils.bytes_to_string` now requires an `encoding` argument.
+  - `BaseSQLCompiler` has a new `python_encoding(connection)` method that custom compiler subclasses must implement (the base raises `NotImplementedError`).
+  - `MySQLCompiler` is exported from `sql_compiler.compilers`.
+- Install requirements: Python >=3.10 and Django >=4.2. The package declares no database driver (psycopg2 or mysqlclient comes from your Django setup). Effects on existing environments:
+  - With an older Django installed but not pinned, upgrading django-sql-compiler can upgrade Django (accepted, because Django <4.2 is end-of-life).
+  - With Django <4.2 pinned, or on Python <3.10, pip stays on 0.1.1.
+  - An install from git master already reports 0.2.3, so pip won't treat 0.2.0 as an upgrade. Install `django-sql-compiler==0.2.0` explicitly.
+
+### Packaging
+
+- The first wheel release (0.1.1 was sdist-only).
+- Built with flit_core instead of setuptools.
+- The license is declared with PEP 639 `License-Expression: MIT`, and LICENSE ships in both artifacts.
+- Metadata-Version 2.5.
+- CHANGELOG.md ships in the sdist.
+
+### Known issues
+
+- psycopg 3 is not supported yet. With psycopg 3 installed, Django uses it and `executable_query` raises (planned for 1.0). 0.1.1 had this issue too.
+- `.none()` querysets raise `EmptyResultSet` (planned for 1.0). 0.1.1 had this issue too.
+
+[0.2.0]: https://github.com/JaredStufftGD/django-sql-compiler/releases/tag/v0.2.0

django_sql_compiler-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Grok Data
+
+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.

django_sql_compiler-0.2.0/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.5
+Name: django-sql-compiler
+Version: 0.2.0
+Summary: A light-weight module to generate usable SQL from a Django QuerySet.
+Author-email: Grok Data / Jared Stufft <jared@grokdata.tech>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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 :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+License-File: LICENSE
+Requires-Dist: Django>=4.2
+Project-URL: Changelog, https://github.com/JaredStufftGD/django-sql-compiler/blob/master/CHANGELOG.md
+Project-URL: Homepage, https://github.com/JaredStufftGD/django-sql-compiler
+Project-URL: Issues, https://github.com/JaredStufftGD/django-sql-compiler/issues
+Project-URL: Source, https://github.com/JaredStufftGD/django-sql-compiler
+Import-Name: sql_compiler
+
+# Django SQL Compiler
+
+[![CI](https://github.com/JaredStufftGD/django-sql-compiler/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/JaredStufftGD/django-sql-compiler/actions/workflows/ci.yml)
+
+A light-weight module to generate usable SQL from a Django QuerySet.
+
+## Backend Support
+`django-sql-compiler` supports connections made via these Django `ENGINE` values:
+
+- `django.db.backends.postgresql`
+- `django.db.backends.postgresql_psycopg2`: a legacy alias for the PostgreSQL backend that Django removed in Django 3.0. The package still accepts the ENGINE string and maps it to the same compiler.
+- `django_tenants.postgresql_backend` (django-tenants)
+- `django.db.backends.mysql` (via mysqlclient)
+
+PostgreSQL connections currently require psycopg2; psycopg 3 isn't supported yet. If psycopg 3 is installed, Django uses it and `executable_query` raises.
+
+## About Django SQL Compiler
+The Django ORM is very useful for abstracting away SQL queries from the focus of the developer. This is very useful
+for preventing SQL injection attacks and generating queries programmatically using applied logic in your Django app.
+
+However, very complex queries (such as those used in reporting, analytics, or data science projects) can be difficult
+or impossible to create with the Django ORM alone. The ORM provides the `.raw` query method and exposes the raw database
+`connection` objects which can be used to execute arbitrary SQL against the database. In doing so, we lose the benefit
+of the ORM with respect to dynamically adding components to the query (such as filters in a `WHERE` clause) in a way that
+prevents injection attacks.
+
+The base Django `QuerySet` object has a `Query` object available at the `.query` property. Casting this `Query` object as a `str`
+prints out what looks like a valid SQL query. However, this version of the query is not properly escaped or quoted, meaning
+it's not **actually** valid SQL unless there are no dynamic components (such as filters from user input) in the `QuerySet`.
+
+`django-sql-compiler` aims to provide a way to generate clean, usable SQL from a given `QuerySet`, which can be used in
+tandem with a raw SQL query to give SQL users more flexibility in querying their Django-connected database while still
+retaining the Django ORM for security and dynamic query generation purposes.
+
+## Usage
+Install the package:
+```
+pip install django-sql-compiler
+```
+
+No database driver is installed with the package and there are no extras: it uses the database connection your Django project already has, so the driver (for example psycopg2 or mysqlclient) comes from your existing Django setup.
+
+Add `sql_compiler` to your `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    ...,
+    'sql_compiler'
+]
+```
+
+Add the `SQLCompilerManager` to your models:
+
+```python
+from django.db import models
+from sql_compiler import SQLCompilerManager
+
+
+class MyModel(models.Model):
+
+    objects = SQLCompilerManager()
+    field_one = models.IntegerField()
+    field_two = models.CharField(max_length=200)
+    field_three = models.DateTimeField()
+
+```
+
+For a given `QuerySet` on the model, you can access the executable query be accessing the `.executable_query` property of the `QuerySet`.
+
+```python
+query_set = MyModel.objects.filter(field_one__lte=10)
+executable_query = query_set.executable_query
+print(executable_query)
+```
+
+This query can then be used in another query as a Common Table Expression or Subquery:
+
+```python
+# Basic usage
+wrapper_query = """select * from ({}) a""".format(executable_query)
+new_queryset = MyModel.objects.raw(wrapper_query)
+
+```
+
+While this is a very simple example, you can use this in more complicated queries:
+```python
+
+# inside a view
+filtered_query_set = MyModel.objects.filter(
+    field_one__lte=request.data.get('field_one_filter', 0),
+    field_two__in=request.data.get('field_two_filter', [])
+    )
+
+
+more_complex_query = """
+select
+    RANK() over (partition by a.field_one order by a.field_three desc) as rnk
+    ,a.field_one
+    ,a.field_two
+from
+    ({}) a
+""".format(filtered_query_set.executable_query)
+
+more_complex_results = MyModel.objects.raw(more_complex_query)
+```
+
+Now, users who are more familiar with SQL rather than the Django ORM can use the ORM for security and conveniently
+generating SQL queries and use SQL for the rest of their transformations.
+

{django-sql-compiler-0.1.0 → django_sql_compiler-0.2.0}/README.md

@@ -1,26 +1,35 @@
 # Django SQL Compiler
 
+[![CI](https://github.com/JaredStufftGD/django-sql-compiler/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/JaredStufftGD/django-sql-compiler/actions/workflows/ci.yml)
+
 A light-weight module to generate usable SQL from a Django QuerySet.
 
 ## Backend Support
-Currently, `django-sql-compiler` only supports connections made via the `django.db.backends.postgresql` backend.
+`django-sql-compiler` supports connections made via these Django `ENGINE` values:
+
+- `django.db.backends.postgresql`
+- `django.db.backends.postgresql_psycopg2`: a legacy alias for the PostgreSQL backend that Django removed in Django 3.0. The package still accepts the ENGINE string and maps it to the same compiler.
+- `django_tenants.postgresql_backend` (django-tenants)
+- `django.db.backends.mysql` (via mysqlclient)
+
+PostgreSQL connections currently require psycopg2; psycopg 3 isn't supported yet. If psycopg 3 is installed, Django uses it and `executable_query` raises.
 
 ## About Django SQL Compiler
 The Django ORM is very useful for abstracting away SQL queries from the focus of the developer. This is very useful
 for preventing SQL injection attacks and generating queries programmatically using applied logic in your Django app.
 
 However, very complex queries (such as those used in reporting, analytics, or data science projects) can be difficult
-or impossible to create with the Django ORM alone. The ORM provides the `.raw` query method and exposes the raw database 
+or impossible to create with the Django ORM alone. The ORM provides the `.raw` query method and exposes the raw database
 `connection` objects which can be used to execute arbitrary SQL against the database. In doing so, we lose the benefit
-of the ORM with respect to dynamically adding components to the query (such as filters in a `WHERE` clause) in a way that 
+of the ORM with respect to dynamically adding components to the query (such as filters in a `WHERE` clause) in a way that
 prevents injection attacks.
 
-The base Django `QuerySet` object has a `Query` object available at the `.query` property. Casting this `Query` object as a `str` 
-prints out what looks like a valid SQL query. However, this version of the query is not properly escaped or quoted, meaning 
+The base Django `QuerySet` object has a `Query` object available at the `.query` property. Casting this `Query` object as a `str`
+prints out what looks like a valid SQL query. However, this version of the query is not properly escaped or quoted, meaning
 it's not **actually** valid SQL unless there are no dynamic components (such as filters from user input) in the `QuerySet`.
 
-`django-sql-compiler` aims to provide a way to generate clean, usable SQL from a given `QuerySet`, which can be used in 
-tandem with a raw SQL query to give SQL users more flexibility in querying their Django-connected database while still 
+`django-sql-compiler` aims to provide a way to generate clean, usable SQL from a given `QuerySet`, which can be used in
+tandem with a raw SQL query to give SQL users more flexibility in querying their Django-connected database while still
 retaining the Django ORM for security and dynamic query generation purposes.
 
 ## Usage
@@ -29,6 +38,8 @@ Install the package:
 pip install django-sql-compiler
 ```
 
+No database driver is installed with the package and there are no extras: it uses the database connection your Django project already has, so the driver (for example psycopg2 or mysqlclient) comes from your existing Django setup.
+
 Add `sql_compiler` to your `INSTALLED_APPS`:
 
 ```python
@@ -79,7 +90,7 @@ filtered_query_set = MyModel.objects.filter(
     field_one__lte=request.data.get('field_one_filter', 0),
     field_two__in=request.data.get('field_two_filter', [])
     )
-    
+
 
 more_complex_query = """
 select
@@ -94,4 +105,4 @@ more_complex_results = MyModel.objects.raw(more_complex_query)
 ```
 
 Now, users who are more familiar with SQL rather than the Django ORM can use the ORM for security and conveniently
-generating SQL queries and use SQL for the rest of their transformations.
+generating SQL queries and use SQL for the rest of their transformations.

django_sql_compiler-0.2.0/pyproject.toml

@@ -0,0 +1,72 @@
+[project]
+name = "django-sql-compiler"
+version = "0.2.0"
+description = "A light-weight module to generate usable SQL from a Django QuerySet."
+readme = "README.md"
+authors = [
+    { name = "Grok Data / Jared Stufft", email = "jared@grokdata.tech" },
+]
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+dependencies = [
+    "Django>=4.2",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Web Environment",
+    "Framework :: Django",
+    "Framework :: Django :: 4.2",
+    "Framework :: Django :: 5.2",
+    "Framework :: Django :: 6.0",
+    "Framework :: Django :: 6.1",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://github.com/JaredStufftGD/django-sql-compiler"
+Source = "https://github.com/JaredStufftGD/django-sql-compiler"
+Changelog = "https://github.com/JaredStufftGD/django-sql-compiler/blob/master/CHANGELOG.md"
+Issues = "https://github.com/JaredStufftGD/django-sql-compiler/issues"
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+]
+pg2 = [
+    "psycopg2-binary>=2.9.9",
+]
+pg3 = [
+    "psycopg[binary]>=3.2",
+]
+mysql = [
+    "mysqlclient>=2.2.1",
+]
+
+[tool.uv]
+conflicts = [
+    [{ group = "pg2" }, { group = "pg3" }],
+]
+
+[build-system]
+requires = ["flit_core>=4,<5"]
+build-backend = "flit_core.buildapi"
+
+[tool.flit.module]
+name = "sql_compiler"
+
+[tool.flit.sdist]
+include = ["CHANGELOG.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+xfail_strict = true
+addopts = "-ra"

django_sql_compiler-0.2.0/sql_compiler/compilers/__init__.py

@@ -0,0 +1,24 @@
+from .postgresql import PostgresCompiler, PostgresTenantsCompiler, Psycopg2Compiler
+from .mysql import MySQLCompiler
+
+__all__ = [
+    'MySQLCompiler',
+    'PostgresCompiler',
+    'PostgresTenantsCompiler',
+    'Psycopg2Compiler',
+    'compiler_map',
+    'SUPPORTED_BACKENDS'
+]
+
+compilers = [
+    MySQLCompiler,
+    PostgresCompiler,
+    PostgresTenantsCompiler,
+    Psycopg2Compiler
+]
+
+compiler_map = {
+    compiler.backend_name: compiler for compiler in compilers
+}
+
+SUPPORTED_BACKENDS = compiler_map.keys()

{django-sql-compiler-0.1.0 → django_sql_compiler-0.2.0}/sql_compiler/compilers/base.py

@@ -6,3 +6,6 @@ class BaseSQLCompiler:
 
     def compile_sql(self, connection, query, params):
         raise NotImplementedError('Subclasses must implement compile_sql')
+
+    def python_encoding(self, connection):
+        raise NotImplementedError('Subclasses must implement python_encoding')

django_sql_compiler-0.2.0/sql_compiler/compilers/mysql.py

@@ -0,0 +1,40 @@
+import codecs
+
+from django.db.utils import ProgrammingError
+
+from .base import BaseSQLCompiler
+
+
+class MySQLCompiler(BaseSQLCompiler):
+
+    backend_name = 'django.db.backends.mysql'
+
+    def compile_sql(self, connection, query, params):
+        with connection.cursor() as cursor:
+            compiled_sql = self.mogrify(cursor, query, params)
+        return compiled_sql
+
+    def python_encoding(self, connection):
+        return codecs.lookup(connection.connection.encoding).name
+
+    def mogrify(self, cursor, query, args=None):
+        db = cursor.connection
+        if isinstance(query, str):
+            query = query.encode(db.encoding)
+
+        if args is not None:
+            if isinstance(args, dict):
+                nargs = {}
+                for key, item in args.items():
+                    if isinstance(key, str):
+                        key = key.encode(db.encoding)
+                    nargs[key] = db.literal(item)
+                args = nargs
+            else:
+                args = tuple(map(db.literal, args))
+            try:
+                query = query % args
+            except (TypeError, KeyError, ValueError) as m:
+                raise ProgrammingError(str(m)) from m
+
+        return query

django_sql_compiler-0.2.0/sql_compiler/compilers/postgresql.py

@@ -0,0 +1,43 @@
+import codecs
+
+from .base import BaseSQLCompiler
+
+
+class PostgresCompiler(BaseSQLCompiler):
+
+    """
+    Compiles an executable SQL query from a parameterized query and arg list using the postgresql/psycopg2 backend.
+    Also reports the raw connection's client encoding as a Python codec name, for psycopg2 and psycopg 3.
+    """
+
+    backend_name = 'django.db.backends.postgresql'
+
+    def encoding_map(self):
+        from psycopg2.extensions import encodings
+        return encodings
+
+    def python_encoding(self, connection):
+        raw = connection.connection
+        info = getattr(raw, 'info', None)
+        if info is not None and hasattr(info, 'encoding'):
+            # psycopg 3 already reports a Python codec name
+            return codecs.lookup(info.encoding).name
+        name = raw.encoding
+        try:
+            return self.encoding_map()[name]
+        except KeyError:
+            raise LookupError('unknown PostgreSQL client encoding: {}'.format(name)) from None
+
+    def compile_sql(self, connection, query, params):
+        with connection.cursor() as cursor:
+            compiled_sql = cursor.mogrify(query, params)
+
+        return compiled_sql
+
+
+class PostgresTenantsCompiler(PostgresCompiler):
+    backend_name = 'django_tenants.postgresql_backend'
+
+
+class Psycopg2Compiler(PostgresCompiler):
+    backend_name = 'django.db.backends.postgresql_psycopg2'

django_sql_compiler-0.2.0/sql_compiler/queryset.py

@@ -0,0 +1,40 @@
+from django.db import connections
+from django.db.models import QuerySet
+from django.utils.functional import cached_property
+from . import utils
+from . import compilers
+
+
+class SQLCompilerQuerySet(QuerySet):
+
+    @cached_property
+    def executable_query(self):
+
+        """
+        Takes the parameterized SQL query with the arg list and compiles the query so
+        that it can be used anywhere - as a subquery in a Raw SQL query, in a SQL GUI interface, etc.
+
+        The SQL is built for the queryset's own database alias, so the dialect and the
+        escaping come from the same database.
+
+        The result is decoded with the encoding the driver reports for this connection,
+        and undecodable output raises instead of being garbled.
+        """
+
+        alias = self.db
+        connection = utils.validate_connection(connections[alias])
+
+        if not connection:
+            raise NotImplementedError('{} backend is not supported.'.format(connections[alias].settings_dict['ENGINE']))
+
+        query, params = self.query.get_compiler(using=alias).as_sql()
+
+        backend_name = connection.settings_dict['ENGINE']
+        compiler = compilers.compiler_map[backend_name]()
+        compiled_query = compiler.compile_sql(connection, query, params)
+        if not isinstance(compiled_query, (bytes, bytearray)):
+            raise TypeError('compile_sql must return bytes, got {}'.format(type(compiled_query).__name__))
+        encoding = compiler.python_encoding(connection)
+        compiled_query = utils.bytes_to_string(compiled_query, encoding)
+
+        return compiled_query

{django-sql-compiler-0.1.0 → django_sql_compiler-0.2.0}/sql_compiler/utils.py

@@ -11,18 +11,16 @@ def validate_connection(connection):
     """
 
     backend_name = connection.settings_dict['ENGINE']
-
-    if backend_name in ('django.db.backends.postgresql_psycopg2', 'django_tenants.postgresql_backend'):
-        backend_name = 'django.db.backends.postgresql'
-
     if backend_name in SUPPORTED_BACKENDS:
         return connection
 
 
-def bytes_to_string(bytes_obj):
+def bytes_to_string(bytes_obj, encoding):
 
     """
-    Converts a bytes object to a string.
+    Decodes a bytes object to a string with the Python codec the connection's driver reports.
+
+    Decoding is strict: LookupError (unknown codec) and UnicodeDecodeError (invalid bytes) propagate.
     """
 
-    return "".join([chr(c) for c in bytes_obj])
+    return bytes_obj.decode(encoding)

django-sql-compiler-0.1.0/PKG-INFO

@@ -1,114 +0,0 @@
-Metadata-Version: 2.1
-Name: django-sql-compiler
-Version: 0.1.0
-Summary: A light-weight module to generate usable SQL from a Django QuerySet.
-Home-page: https://github.com/GrokData/django-sql-compiler
-Author: Grok Data / Jared Stufft
-Author-email: jared@grokdata.tech
-License: MIT
-Description: # Django SQL Compiler
-        
-        A light-weight module to generate usable SQL from a Django QuerySet.
-        
-        ## Backend Support
-        Currently, `django-sql-compiler` only supports connections made via the `django.db.backends.postgresql` backend.
-        
-        ## About Django SQL Compiler
-        The Django ORM is very useful for abstracting away SQL queries from the focus of the developer. This is very useful
-        for preventing SQL injection attacks and generating queries programmatically using applied logic in your Django app.
-        
-        However, very complex queries (such as those used in reporting, analytics, or data science projects) can be difficult
-        or impossible to create with the Django ORM alone. The ORM provides the `.raw` query method and exposes the raw database 
-        `connection` objects which can be used to execute arbitrary SQL against the database. In doing so, we lose the benefit
-        of the ORM with respect to dynamically adding components to the query (such as filters in a `WHERE` clause) in a way that 
-        prevents injection attacks.
-        
-        The base Django `QuerySet` object has a `Query` object available at the `.query` property. Casting this `Query` object as a `str` 
-        prints out what looks like a valid SQL query. However, this version of the query is not properly escaped or quoted, meaning 
-        it's not **actually** valid SQL unless there are no dynamic components (such as filters from user input) in the `QuerySet`.
-        
-        `django-sql-compiler` aims to provide a way to generate clean, usable SQL from a given `QuerySet`, which can be used in 
-        tandem with a raw SQL query to give SQL users more flexibility in querying their Django-connected database while still 
-        retaining the Django ORM for security and dynamic query generation purposes.
-        
-        ## Usage
-        Install the package:
-        ```
-        pip install django-sql-compiler
-        ```
-        
-        Add `sql_compiler` to your `INSTALLED_APPS`:
-        
-        ```python
-        INSTALLED_APPS = [
-            ...,
-            'sql_compiler'
-        ]
-        ```
-        
-        Add the `SQLCompilerManager` to your models:
-        
-        ```python
-        from django.db import models
-        from sql_compiler import SQLCompilerManager
-        
-        
-        class MyModel(models.Model):
-        
-            objects = SQLCompilerManager()
-            field_one = models.IntegerField()
-            field_two = models.CharField(max_length=200)
-            field_three = models.DateTimeField()
-        
-        ```
-        
-        For a given `QuerySet` on the model, you can access the executable query be accessing the `.executable_query` property of the `QuerySet`.
-        
-        ```python
-        query_set = MyModel.objects.filter(field_one__lte=10)
-        executable_query = query_set.executable_query
-        print(executable_query)
-        ```
-        
-        This query can then be used in another query as a Common Table Expression or Subquery:
-        
-        ```python
-        # Basic usage
-        wrapper_query = """select * from ({}) a""".format(executable_query)
-        new_queryset = MyModel.objects.raw(wrapper_query)
-        
-        ```
-        
-        While this is a very simple example, you can use this in more complicated queries:
-        ```python
-        
-        # inside a view
-        filtered_query_set = MyModel.objects.filter(
-            field_one__lte=request.data.get('field_one_filter', 0),
-            field_two__in=request.data.get('field_two_filter', [])
-            )
-            
-        
-        more_complex_query = """
-        select
-            RANK() over (partition by a.field_one order by a.field_three desc) as rnk
-            ,a.field_one
-            ,a.field_two
-        from
-            ({}) a
-        """.format(filtered_query_set.executable_query)
-        
-        more_complex_results = MyModel.objects.raw(more_complex_query)
-        ```
-        
-        Now, users who are more familiar with SQL rather than the Django ORM can use the ORM for security and conveniently
-        generating SQL queries and use SQL for the rest of their transformations.
-Platform: UNKNOWN
-Classifier: Development Status :: 3 - Alpha
-Classifier: Environment :: Web Environment
-Classifier: Framework :: Django
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Internet :: WWW/HTTP
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Description-Content-Type: text/markdown

django-sql-compiler-0.1.0/django_sql_compiler.egg-info/PKG-INFO

@@ -1,114 +0,0 @@
-Metadata-Version: 2.1
-Name: django-sql-compiler
-Version: 0.1.0
-Summary: A light-weight module to generate usable SQL from a Django QuerySet.
-Home-page: https://github.com/GrokData/django-sql-compiler
-Author: Grok Data / Jared Stufft
-Author-email: jared@grokdata.tech
-License: MIT
-Description: # Django SQL Compiler
-        
-        A light-weight module to generate usable SQL from a Django QuerySet.
-        
-        ## Backend Support
-        Currently, `django-sql-compiler` only supports connections made via the `django.db.backends.postgresql` backend.
-        
-        ## About Django SQL Compiler
-        The Django ORM is very useful for abstracting away SQL queries from the focus of the developer. This is very useful
-        for preventing SQL injection attacks and generating queries programmatically using applied logic in your Django app.
-        
-        However, very complex queries (such as those used in reporting, analytics, or data science projects) can be difficult
-        or impossible to create with the Django ORM alone. The ORM provides the `.raw` query method and exposes the raw database 
-        `connection` objects which can be used to execute arbitrary SQL against the database. In doing so, we lose the benefit
-        of the ORM with respect to dynamically adding components to the query (such as filters in a `WHERE` clause) in a way that 
-        prevents injection attacks.
-        
-        The base Django `QuerySet` object has a `Query` object available at the `.query` property. Casting this `Query` object as a `str` 
-        prints out what looks like a valid SQL query. However, this version of the query is not properly escaped or quoted, meaning 
-        it's not **actually** valid SQL unless there are no dynamic components (such as filters from user input) in the `QuerySet`.
-        
-        `django-sql-compiler` aims to provide a way to generate clean, usable SQL from a given `QuerySet`, which can be used in 
-        tandem with a raw SQL query to give SQL users more flexibility in querying their Django-connected database while still 
-        retaining the Django ORM for security and dynamic query generation purposes.
-        
-        ## Usage
-        Install the package:
-        ```
-        pip install django-sql-compiler
-        ```
-        
-        Add `sql_compiler` to your `INSTALLED_APPS`:
-        
-        ```python
-        INSTALLED_APPS = [
-            ...,
-            'sql_compiler'
-        ]
-        ```
-        
-        Add the `SQLCompilerManager` to your models:
-        
-        ```python
-        from django.db import models
-        from sql_compiler import SQLCompilerManager
-        
-        
-        class MyModel(models.Model):
-        
-            objects = SQLCompilerManager()
-            field_one = models.IntegerField()
-            field_two = models.CharField(max_length=200)
-            field_three = models.DateTimeField()
-        
-        ```
-        
-        For a given `QuerySet` on the model, you can access the executable query be accessing the `.executable_query` property of the `QuerySet`.
-        
-        ```python
-        query_set = MyModel.objects.filter(field_one__lte=10)
-        executable_query = query_set.executable_query
-        print(executable_query)
-        ```
-        
-        This query can then be used in another query as a Common Table Expression or Subquery:
-        
-        ```python
-        # Basic usage
-        wrapper_query = """select * from ({}) a""".format(executable_query)
-        new_queryset = MyModel.objects.raw(wrapper_query)
-        
-        ```
-        
-        While this is a very simple example, you can use this in more complicated queries:
-        ```python
-        
-        # inside a view
-        filtered_query_set = MyModel.objects.filter(
-            field_one__lte=request.data.get('field_one_filter', 0),
-            field_two__in=request.data.get('field_two_filter', [])
-            )
-            
-        
-        more_complex_query = """
-        select
-            RANK() over (partition by a.field_one order by a.field_three desc) as rnk
-            ,a.field_one
-            ,a.field_two
-        from
-            ({}) a
-        """.format(filtered_query_set.executable_query)
-        
-        more_complex_results = MyModel.objects.raw(more_complex_query)
-        ```
-        
-        Now, users who are more familiar with SQL rather than the Django ORM can use the ORM for security and conveniently
-        generating SQL queries and use SQL for the rest of their transformations.
-Platform: UNKNOWN
-Classifier: Development Status :: 3 - Alpha
-Classifier: Environment :: Web Environment
-Classifier: Framework :: Django
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Internet :: WWW/HTTP
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Description-Content-Type: text/markdown

django-sql-compiler-0.1.0/django_sql_compiler.egg-info/SOURCES.txt

@@ -1,16 +0,0 @@
-README.md
-setup.py
-django_sql_compiler.egg-info/PKG-INFO
-django_sql_compiler.egg-info/SOURCES.txt
-django_sql_compiler.egg-info/dependency_links.txt
-django_sql_compiler.egg-info/not-zip-safe
-django_sql_compiler.egg-info/requires.txt
-django_sql_compiler.egg-info/top_level.txt
-sql_compiler/__init__.py
-sql_compiler/manager.py
-sql_compiler/queryset.py
-sql_compiler/utils.py
-sql_compiler/compilers/__init__.py
-sql_compiler/compilers/base.py
-sql_compiler/compilers/mysql.py
-sql_compiler/compilers/postgresql.py

django-sql-compiler-0.1.0/django_sql_compiler.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

django-sql-compiler-0.1.0/django_sql_compiler.egg-info/not-zip-safe

@@ -1 +0,0 @@
-

django-sql-compiler-0.1.0/django_sql_compiler.egg-info/requires.txt

@@ -1 +0,0 @@
-django

django-sql-compiler-0.1.0/django_sql_compiler.egg-info/top_level.txt

@@ -1 +0,0 @@
-sql_compiler

django-sql-compiler-0.1.0/setup.cfg

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

django-sql-compiler-0.1.0/setup.py

@@ -1,29 +0,0 @@
-from setuptools import setup, find_packages
-
-
-setup(
-    name='django-sql-compiler',
-    version='0.1.0',
-    description="A light-weight module to generate usable SQL from a Django QuerySet.",
-    long_description=open('README.md').read(),
-    long_description_content_type='text/markdown',
-    author='Grok Data / Jared Stufft',
-    author_email='jared@grokdata.tech',
-    url='https://github.com/GrokData/django-sql-compiler',
-    license='MIT',
-    packages=find_packages(),
-    classifiers=[
-        "Development Status :: 3 - Alpha",
-        "Environment :: Web Environment",
-        "Framework :: Django",
-        "License :: OSI Approved :: MIT License",
-        "Programming Language :: Python :: 3",
-        "Topic :: Internet :: WWW/HTTP",
-        "Topic :: Software Development :: Libraries :: Python Modules",
-    ],
-    install_requires=[
-        'django',
-    ],
-    include_package_data=True,
-    zip_safe=False,
-)

django-sql-compiler-0.1.0/sql_compiler/compilers/__init__.py

@@ -1,13 +0,0 @@
-from .postgresql import PostgresCompiler
-
-__all__ = ['PostgresCompiler', 'compiler_map', 'SUPPORTED_BACKENDS']
-
-compilers = [
-    PostgresCompiler
-]
-
-compiler_map = {
-    compiler.backend_name: compiler for compiler in compilers
-}
-
-SUPPORTED_BACKENDS = compiler_map.keys()

django-sql-compiler-0.1.0/sql_compiler/compilers/mysql.py

@@ -1,9 +0,0 @@
-from .base import BaseSQLCompiler
-
-
-class MySQLCompiler(BaseSQLCompiler):
-
-    backend_name = 'django.db.backends.mysql'
-
-    def compile_sql(self, connection, query, params):
-        pass

django-sql-compiler-0.1.0/sql_compiler/compilers/postgresql.py

@@ -1,16 +0,0 @@
-from .base import BaseSQLCompiler
-
-
-class PostgresCompiler(BaseSQLCompiler):
-
-    """
-    Compiles an executable SQL query from a parameterized query and arg list using the postgresql/psycopg2 backend.
-    """
-
-    backend_name = 'django.db.backends.postgresql'
-
-    def compile_sql(self, connection, query, params):
-        with connection.cursor() as cursor:
-            compiled_sql = cursor.mogrify(query, params)
-
-        return compiled_sql

django-sql-compiler-0.1.0/sql_compiler/queryset.py

@@ -1,30 +0,0 @@
-from django.db import connections
-from django.db.models import QuerySet
-from django.utils.functional import cached_property
-from . import utils
-from . import compilers
-
-
-class SQLCompilerQuerySet(QuerySet):
-
-    @cached_property
-    def executable_query(self):
-
-        """
-        Takes the parameterized SQL query with the arg list and compiles the query so
-        that it can be used anywhere - as a subquery in a Raw SQL query, in a SQL GUI interface, etc.
-        """
-
-        connection = utils.validate_connection(connections[self.db])
-
-        if not connection:
-            raise NotImplementedError('{} backend is not supported.'.format(str(connection)))
-
-        query, params = self.query.sql_with_params()
-
-        backend_name = connection.settings_dict['ENGINE']
-        compiler = compilers.compiler_map[backend_name]()
-        compiled_query = compiler.compile_sql(connection, query, params)
-        compiled_query = utils.bytes_to_string(compiled_query)
-
-        return compiled_query