quillsql 2.2.5__py3-none-any.whl → 2.2.7__py3-none-any.whl

quillsql/__init__.py

@@ -2,4 +2,13 @@
 
 from .core import Quill
 from .error import PgQueryError
-from .utils import Filter, FilterType, FieldType, StringOperator, DateOperator, NumberOperator, NullOperator
+from .utils import (
+    Filter,
+    FilterType,
+    FieldType,
+    StringOperator,
+    DateOperator,
+    NumberOperator,
+    NullOperator,
+    ParallelPostQuill,
+)

quillsql/core.py

@@ -144,10 +144,14 @@ class Quill:
                         None
                     )
 
-                    distinct_values = parse_distinct_values(
-                        distinct_value_results["queryResults"][0],
-                        config.get("databaseType")
-                    )
+                    distinct_value_query_results = (
+                        distinct_value_results or {}
+                    ).get("queryResults") or []
+                    if distinct_value_query_results:
+                        distinct_values = parse_distinct_values(
+                            distinct_value_query_results[0],
+                            config.get("databaseType")
+                        )
 
                 try:
                     final_query = hydrate_pivot_template(template, distinct_values, config)
@@ -261,17 +265,16 @@ class Quill:
                 else:
                     tenant_flags = flags
 
-            pre_query_results = (
-                self.run_queries(
+            if metadata.get("preQueries"):
+                pre_query_results = self.run_queries(
                     metadata.get("preQueries"),
                     self.target_connection.database_type,
                     metadata.get("databaseType"),
                     metadata,
                     metadata.get("runQueryConfig"),
                 )
-                if metadata.get("preQueries")
-                else {}
-            )
+            else:
+                pre_query_results = {}
 
             if metadata.get("runQueryConfig") and metadata.get("runQueryConfig").get(
                 "overridePost"
@@ -402,7 +405,21 @@ class Quill:
         results = {}
         if not queries:
             return {"queryResults": []}
-        if databaseType and databaseType.lower() != pkDatabaseType.lower():
+        def _normalize_db_type(db_type):
+            if not db_type:
+                return None
+            lowered = db_type.lower()
+            if lowered in ("postgresql", "postgres"):
+                return "postgres"
+            return lowered
+
+        normalized_metadata_db = _normalize_db_type(databaseType)
+        normalized_backend_db = _normalize_db_type(pkDatabaseType)
+        if (
+            normalized_metadata_db
+            and normalized_backend_db
+            and normalized_metadata_db != normalized_backend_db
+        ):
             return {"dbMismatched": True, "backendDatabaseType": pkDatabaseType}
         if runQueryConfig and runQueryConfig.get("arrayToMap"):
             mapped_array = array_to_map(

quillsql/db/bigquery.py

@@ -27,7 +27,7 @@ def format_bigquery_config(connection_string):
             "credentials": service_account,
         }
     except (ValueError, TypeError) as e:
-        print("Invalid JSON string: ", e)
+        print("Invalid service account JSON.", e)
     return connection_string
 
 

quillsql/db/cached_connection.py

@@ -29,20 +29,43 @@ class CachedConnection:
             )
         return None
 
+    def _is_connection_closed(self):
+        return self.connection is None or getattr(self.connection, "closed", True)
+
+    def _open_connection(self):
+        self.connection = connect_to_db(
+            self.database_type, self.config, self.using_connection_string
+        )
+        return self.connection
+
+    def _close_connection(self):
+        if self.connection is None:
+            return
+        try:
+            self.connection.close()
+        except Exception:
+            pass
+        finally:
+            self.connection = None
+
     def exec_with_reconnect(self, sql):
         reconnect_count = 0
-        while True:
-            self.connection = connect_to_db(
-                self.database_type, self.config, self.using_connection_string
-            )
+        last_error = None
+        while reconnect_count < 10:
             try:
+                if self._is_connection_closed():
+                    self._open_connection()
                 return run_query_by_db(self.database_type, sql, self.connection)
             except psycopg2.Error as err:
-                reconnect_count = reconnect_count + 1
-                if reconnect_count < 10:
-                    continue
-                else:
-                    raise PgQueryError(err, sql, err.diag.statement_position)
+                last_error = err
+                reconnect_count += 1
+                self._close_connection()
+            except Exception:
+                self._close_connection()
+                raise
+        diag = getattr(last_error, "diag", None)
+        position = getattr(diag, "statement_position", None)
+        raise PgQueryError(last_error or "Failed to execute query", sql, position)
 
     def exec(self, sql):
         try:

quillsql/db/db_helper.py

@@ -15,47 +15,51 @@ from quillsql.db.bigquery import (
 )
 
 
+def _is_postgres(database_type):
+    return database_type and database_type.lower() in ("postgresql", "postgres")
+
+
 def get_db_credentials(database_type, connection_string):
-    if database_type.lower() == "postgresql":
+    if _is_postgres(database_type):
         return format_postgres(connection_string)
-    elif database_type.lower() == "bigquery":
+    elif database_type and database_type.lower() == "bigquery":
         return format_bigquery_config(connection_string)
     return {}
 
 
 def connect_to_db(database_type, config, using_connection_string):
-    if database_type.lower() == "postgresql":
+    if _is_postgres(database_type):
         return connect_to_postgres(config, using_connection_string)
-    elif database_type.lower() == "bigquery":
+    elif database_type and database_type.lower() == "bigquery":
         return connect_to_bigquery(config, using_connection_string)
     return None
 
 
 def run_query_by_db(database_type, query, connection):
-    if database_type.lower() == "postgresql":
+    if _is_postgres(database_type):
         return run_query_postgres(query, connection)
-    elif database_type.lower() == "bigquery":
+    elif database_type and database_type.lower() == "bigquery":
         return run_query_big_query(query, connection)
     return None
 
 
 def disconnect_from_db(database_type, connection):
-    if database_type.lower() == "postgresql":
+    if _is_postgres(database_type):
         return disconnect_from_postgres(connection)
     return None
 
 
 def get_schema_tables_by_db(database_type, connection, schema_name):
-    if database_type.lower() == "postgresql":
+    if _is_postgres(database_type):
         return get_tables_by_schema_postgres(connection, schema_name)
-    elif database_type.lower() == "bigquery":
+    elif database_type and database_type.lower() == "bigquery":
         return get_tables_by_schema_big_query(connection, schema_name)
     return None
 
 
 def get_schema_column_info_by_db(database_type, connection, schema_name, table_names):
-    if database_type.lower() == "postgresql":
+    if _is_postgres(database_type):
         return get_schema_column_info_postgres(connection, schema_name, table_names)
-    elif database_type.lower() == "bigquery":
+    elif database_type and database_type.lower() == "bigquery":
         return get_schema_column_info_big_query(connection, schema_name, table_names)
     return None

quillsql/utils/__init__.py

@@ -2,3 +2,4 @@
 
 from .run_query_processes import remove_fields, array_to_map
 from .filters import Filter, FilterType, FieldType, StringOperator, NumberOperator, NullOperator, DateOperator, convert_custom_filter
+from .post_quill_executor import ParallelPostQuill

quillsql/utils/pivot_template.py

@@ -198,7 +198,6 @@ def parse_distinct_values(query_result: Dict[str, Any], database_type: str) -> L
             distinct_values = [v.strip() for v in row["string_values"].split(",")]
     
     else:
-        print(f"Warning: Unknown database type: {database_type}")
         distinct_values = []
     
     # Filter out null/undefined/empty values

quillsql/utils/post_quill_executor.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import threading
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import Callable, Optional
+
+
+class ParallelPostQuill:
+    """
+    Provides a thread-pooled, drop-in replacement for Quill.post_quill.
+
+    Example
+    -------
+        parallel_post = ParallelPostQuill(
+            quill_factory=lambda: Quill(...),
+            max_workers=4,
+        )
+
+        # Synchronous (behaves like the original post_quill)
+        response = parallel_post("report", payload)
+
+        # Async-style execution
+        future = parallel_post("report", payload, wait=False)
+        response = future.result()
+    """
+
+    def __init__(
+        self,
+        quill_factory: Callable[[], "Quill"],
+        max_workers: int = 5,
+        executor: Optional[ThreadPoolExecutor] = None,
+    ):
+        if executor is None:
+            self._executor = ThreadPoolExecutor(
+                max_workers=max_workers,
+                thread_name_prefix="post-quill",
+            )
+            self._owns_executor = True
+        else:
+            self._executor = executor
+            self._owns_executor = False
+
+        if not callable(quill_factory):
+            raise ValueError("quill_factory must be callable and create Quill instances.")
+
+        self._quill_factory = quill_factory
+        self._thread_local = threading.local()
+
+    def __call__(self, path: str, payload: dict, wait: bool = True):
+        future: Future = self._executor.submit(self._invoke, path, payload)
+        if wait:
+            return future.result()
+        return future
+
+    def shutdown(self, wait: bool = True):
+        if self._owns_executor:
+            self._executor.shutdown(wait=wait)
+
+    def _get_quill(self):
+        quill = getattr(self._thread_local, "quill", None)
+        if quill is None:
+            quill = self._quill_factory()
+            self._thread_local.quill = quill
+        return quill
+
+    def _invoke(self, path: str, payload: dict):
+        quill = self._get_quill()
+        return quill.post_quill(path, payload)
+

{quillsql-2.2.5.dist-info → quillsql-2.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.2
 Name: quillsql
-Version: 2.2.5
+Version: 2.2.7
 Summary: Quill SDK for Python.
 Home-page: https://github.com/quill-sql/quill-python
 Author: Quill

quillsql-2.2.7.dist-info/RECORD

@@ -0,0 +1,21 @@
+quillsql/__init__.py,sha256=wjJfszle5vheUbgUfJMHQqtqhx2W3UaDN4ndcRIfmkQ,236
+quillsql/core.py,sha256=IQZlNdEAfiEuWF4PnA4hI6iK3Yk5OI8QKwKVklwW8GA,23943
+quillsql/error.py,sha256=n9VKHw4FAgg7ZEAz2YQ8L_8FdRG_1shwGngf2iWhUSM,175
+quillsql/assets/__init__.py,sha256=oXQ2ZS5XDXkXTYjADxNfGt55cIn_rqfgWL2EDqjTyoI,45
+quillsql/assets/pgtypes.py,sha256=-B_2wUaoAsdX7_HnJhUlx4ptZQ6x-cXwuST9ACgGFdE,33820
+quillsql/db/__init__.py,sha256=sPgYMF3eqKuc2k96i1Re8NHazLdGKCVN-rs15F1sovw,63
+quillsql/db/bigquery.py,sha256=XYQ-R1ktMpDrY8ycvrwRlp5Mvg8zcS5sS68Q6rdYHZ8,4819
+quillsql/db/cached_connection.py,sha256=ROGPt5jIZlI5KK9vaCVirMcw_dNVNGkbg-V06Odkl0Y,3270
+quillsql/db/db_helper.py,sha256=nK3E9zOW9YISXBdG4kkUBotHfY2sEq3XmUEjGJAAXmU,2257
+quillsql/db/postgres.py,sha256=ZTLtUVTJHkqAj7nZkcwbmkSOwR2ySN7vS5snoxqLRN0,4156
+quillsql/utils/__init__.py,sha256=v8OmCZymnB4ZpS8N1KyYEcaUFlN7CFz_NPMNkHO8ZNo,261
+quillsql/utils/filters.py,sha256=REXOLIQZDHL4EDKtConXY9_GaqUmc2uTcyUa2_4MvAg,6786
+quillsql/utils/pivot_template.py,sha256=1U1ALJHn-4K1_ps8-Z6VDpqJ9dsyOJZNYxt80NDwtlQ,18217
+quillsql/utils/post_quill_executor.py,sha256=DB1RHNfqHPYarMM10vSv--UjpCZqe4qYTjqp3wL3v-s,2062
+quillsql/utils/run_query_processes.py,sha256=QwnMr5UwXdtO_W88lv5nBaf6pJ_h5oWQnYd8K9oHQ5s,1030
+quillsql/utils/schema_conversion.py,sha256=TFfMibN9nOsxNRhHw5YIFl3jGTvipG81bxX4LFDulUY,314
+quillsql/utils/tenants.py,sha256=ZD2FuKz0gjBVSsThHDv1P8PU6EL8E009NWihE5hAH-Q,2022
+quillsql-2.2.7.dist-info/METADATA,sha256=EE-TzuvH71mqurYprv3i-rzqd4_REL4bB14WEHqPCaA,1786
+quillsql-2.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+quillsql-2.2.7.dist-info/top_level.txt,sha256=eU2vHnVqwpYQJ3ADl1Q-DIBzbYejZRUhcMdN_4zMCz8,9
+quillsql-2.2.7.dist-info/RECORD,,

quillsql-2.2.5.dist-info/RECORD

@@ -1,20 +0,0 @@
-quillsql/__init__.py,sha256=FiuoxaNZveKXOPB0hkpfGNlpZKmSn3pRwcqm9HKYbCQ,180
-quillsql/core.py,sha256=OOvhFEya_DGmyE5U9nVUQ58ZBnePTNh5mKPg7OTSI_Q,23259
-quillsql/error.py,sha256=n9VKHw4FAgg7ZEAz2YQ8L_8FdRG_1shwGngf2iWhUSM,175
-quillsql/assets/__init__.py,sha256=oXQ2ZS5XDXkXTYjADxNfGt55cIn_rqfgWL2EDqjTyoI,45
-quillsql/assets/pgtypes.py,sha256=-B_2wUaoAsdX7_HnJhUlx4ptZQ6x-cXwuST9ACgGFdE,33820
-quillsql/db/__init__.py,sha256=sPgYMF3eqKuc2k96i1Re8NHazLdGKCVN-rs15F1sovw,63
-quillsql/db/bigquery.py,sha256=xJv3WUjyDmnfwaAAeLTTezUEw_qxrxQy-CTCwj8Hmjs,4811
-quillsql/db/cached_connection.py,sha256=Pp0R2XGY-QuQYh8ThiDxSwNb6SEuEKfZcQRcvzjeC28,2556
-quillsql/db/db_helper.py,sha256=qiIP-BM7R-3PhvWBELYjNazi-92EcQB0q9eN7Ej7XUA,2111
-quillsql/db/postgres.py,sha256=ZTLtUVTJHkqAj7nZkcwbmkSOwR2ySN7vS5snoxqLRN0,4156
-quillsql/utils/__init__.py,sha256=C2k9Xe0sG5XrP0XJo9K_-iej1S9PLMRKOYMeLxj7NYE,210
-quillsql/utils/filters.py,sha256=REXOLIQZDHL4EDKtConXY9_GaqUmc2uTcyUa2_4MvAg,6786
-quillsql/utils/pivot_template.py,sha256=HXtb-DigrqFhdHKX2jWeYeFZNuWCfZSyNw31Fy2fIok,18283
-quillsql/utils/run_query_processes.py,sha256=QwnMr5UwXdtO_W88lv5nBaf6pJ_h5oWQnYd8K9oHQ5s,1030
-quillsql/utils/schema_conversion.py,sha256=TFfMibN9nOsxNRhHw5YIFl3jGTvipG81bxX4LFDulUY,314
-quillsql/utils/tenants.py,sha256=ZD2FuKz0gjBVSsThHDv1P8PU6EL8E009NWihE5hAH-Q,2022
-quillsql-2.2.5.dist-info/METADATA,sha256=AB1wJfgnGMitTW25kmjortFqmUVK4dlY74PFhFNXkL0,1786
-quillsql-2.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-quillsql-2.2.5.dist-info/top_level.txt,sha256=eU2vHnVqwpYQJ3ADl1Q-DIBzbYejZRUhcMdN_4zMCz8,9
-quillsql-2.2.5.dist-info/RECORD,,