quillsql 2.2.4__py3-none-any.whl → 2.2.6__py3-none-any.whl

quillsql/core.py

@@ -91,8 +91,6 @@ class Quill:
     ):
         if not tenants:
             raise ValueError("You may not pass an empty tenants array.")
-        if flags and not flags:
-            raise ValueError("You may not pass an empty flags array.")
 
         responseMetadata = {}
         if not metadata:
@@ -108,7 +106,6 @@ class Quill:
 
             # Handle pivot-template task
             if task == "pivot-template":
-                # Step 1: Get pivot template and queries from server
                 pivot_payload = {
                     **metadata,
                     "tenants": tenants,
@@ -129,16 +126,14 @@ class Quill:
                     return {
                         "status": "error",
                         "error": pivot_template_response.get("error"),
-                        "data": (pivot_template_response.get("metadata") or {}),
+                        "data": pivot_template_response.get("metadata") or {},
                     }
 
-                pivot_metadata = pivot_template_response.get("metadata") or {}
-                template = pivot_metadata.get("template")
-                config = pivot_metadata.get("config") or {}
-                distinct_values_query = pivot_metadata.get("distinctValuesQuery")
-                row_count_query = pivot_metadata.get("rowCountQuery")
+                template = pivot_template_response.get("metadata", {}).get("template")
+                config = pivot_template_response.get("metadata", {}).get("config")
+                distinct_values_query = pivot_template_response.get("metadata", {}).get("distinctValuesQuery")
+                row_count_query = pivot_template_response.get("metadata", {}).get("rowCountQuery")
 
-                # Step 2: Run the distinct values query to get unique values
                 distinct_values = []
                 if distinct_values_query:
                     distinct_value_results = self.run_queries(
@@ -149,13 +144,11 @@ class Quill:
                         None
                     )
 
-                    # Parse distinct values from database results
                     distinct_values = parse_distinct_values(
                         distinct_value_results["queryResults"][0],
                         config.get("databaseType")
                     )
 
-                # Step 3: Hydrate the template with the distinct values
                 try:
                     final_query = hydrate_pivot_template(template, distinct_values, config)
                 except Exception as err:
@@ -165,10 +158,8 @@ class Quill:
                         "data": {},
                     }
 
-                # Step 4: Run queries - pivot query and optional row count query
                 queries_to_run = [final_query]
                 if row_count_query:
-                    # Hydrate the rowCountQuery with the same distinct values
                     hydrated_row_count_query = hydrate_pivot_template(
                         row_count_query,
                         distinct_values,
@@ -181,11 +172,10 @@ class Quill:
                     self.target_connection.database_type,
                     metadata.get("databaseType"),
                     metadata,
-                    pivot_metadata.get("runQueryConfig"),
+                    pivot_template_response.get("metadata", {}).get("runQueryConfig")
                 )
 
-                responseMetadata = pivot_metadata or {}
-                # Set rows and fields from first query result (the pivot query)
+                responseMetadata = pivot_template_response.get("metadata") or {}
                 if final_results.get("queryResults") and len(final_results["queryResults"]) >= 1:
                     query_results = final_results["queryResults"][0]
                     if query_results.get("rows"):
@@ -193,7 +183,6 @@ class Quill:
                     if query_results.get("fields"):
                         responseMetadata["fields"] = query_results["fields"]
 
-                # Remove internal SDK fields before returning to frontend
                 if "template" in responseMetadata:
                     del responseMetadata["template"]
                 if "distinctValuesQuery" in responseMetadata:
@@ -229,7 +218,7 @@ class Quill:
                     return {
                         'status': 'error',
                         'error': response.get('error'),
-                        'data': (response.get('metadata') or {}),
+                        'data': response.get('metadata') or {},
                     }
                 
                 flag_query_results = self.run_queries(
@@ -238,22 +227,34 @@ class Quill:
                 )
                 
                 tenant_flags = []
-                response_metadata = response.get('metadata') or {}
-                query_order = response_metadata.get('queryOrder') or []
+                query_order = (response.get('metadata') or {}).get('queryOrder') or []
                 query_results = (flag_query_results or {}).get('queryResults') or []
-                for tenant_field, query_result in zip(query_order, query_results):
-                    rows = []
-                    if isinstance(query_result, dict):
-                        rows = query_result.get('rows') or []
-                    flags = {
-                        row.get('quill_flag')
-                        for row in rows
-                        if isinstance(row, dict) and row.get('quill_flag') is not None
-                    }
+                for index, tenant_field in enumerate(query_order):
+                    query_result = (
+                        query_results[index]
+                        if index < len(query_results)
+                        else {}
+                    )
+                    rows = (
+                        query_result.get('rows')
+                        if isinstance(query_result, dict)
+                        else []
+                    )
+                    ordered_flags = []
+                    seen = set()
+                    for row in rows or []:
+                        if not isinstance(row, dict):
+                            continue
+                        flag = row.get('quill_flag')
+                        if flag is None or flag in seen:
+                            continue
+                        seen.add(flag)
+                        ordered_flags.append(flag)
                     tenant_flags.append({
                         'tenantField': tenant_field,
-                        'flags': list(flags),
+                        'flags': ordered_flags,
                     })
+
             elif tenants[0] == SINGLE_TENANT and flags:
                 if flags and isinstance(flags[0], dict):
                     tenant_flags = [{'tenantField': SINGLE_TENANT, 'flags': flags}]
@@ -285,13 +286,14 @@ class Quill:
                 and metadata.get("runQueryConfig").get("getColumns")
                 else None
             )
-            payload: dict = {
+            payload = {
                 **metadata,
                 "tenants": tenants,
                 "flags": tenant_flags,
                 "viewQuery": view_query,
-                "preQueryResultsColumns": pre_query_columns,
             }
+            if pre_query_columns is not None:
+                payload["preQueryResultsColumns"] = pre_query_columns
             if admin_enabled is not None:
                 payload["adminEnabled"] = admin_enabled
             if filters is not None:
@@ -338,21 +340,25 @@ class Quill:
                     normalized_results.get("queryResults") or []
                 )
 
-            run_query_config = responseMetadata.get("runQueryConfig") or {}
-            array_to_map = run_query_config.get("arrayToMap")
-            if normalized_results.get("mapped_array") and array_to_map:
-                target_collection = responseMetadata.get(array_to_map.get("arrayName"))
+            if (
+                normalized_results.get("mapped_array")
+                and metadata.get("runQueryConfig", {}).get("arrayToMap")
+            ):
+                array_to_map = metadata["runQueryConfig"]["arrayToMap"]
+                target_collection = responseMetadata.get(array_to_map["arrayName"])
                 if isinstance(target_collection, list):
-                    for index, mapped_rows in enumerate(normalized_results["mapped_array"]):
+                    for index, array in enumerate(normalized_results["mapped_array"]):
                         if index >= len(target_collection):
                             continue
                         target_entry = target_collection[index]
-                        if isinstance(target_entry, dict):
-                            target_entry[array_to_map.get("field")] = mapped_rows
-                normalized_results.pop("mapped_array", None)
+                        if not isinstance(target_entry, dict):
+                            target_entry = {}
+                            target_collection[index] = target_entry
+                        target_entry[array_to_map["field"]] = array if array is not None else []
+                del normalized_results["mapped_array"]
 
             query_results_list = normalized_results.get("queryResults") or []
-            if len(query_results_list) == 1:
+            if len(query_results_list) == 1 and isinstance(query_results_list[0], dict):
                 query_result = query_results_list[0]
                 quill_results["metadata"]["rows"] = query_result.get("rows")
                 quill_results["metadata"]["fields"] = query_result.get("fields")
@@ -390,13 +396,24 @@ class Quill:
                 return query
             return f"{query.rstrip(';')} limit {limit}"
 
+    def normalize_database_type(self, db_type):
+        if not db_type:
+            return None
+        lowered = db_type.lower()
+        if lowered in ("postgresql", "postgres"):
+            return "postgres"
+        return lowered
+
     def run_queries(
         self, queries, pkDatabaseType, databaseType=None, metadata=None, runQueryConfig=None
     ):
         results = {}
         if not queries:
             return {"queryResults": []}
-        if databaseType and databaseType.lower() != pkDatabaseType.lower():
+        normalized_pk = self.normalize_database_type(pkDatabaseType)
+        normalized_requested = self.normalize_database_type(databaseType)
+        should_enforce_match = normalized_requested is not None
+        if should_enforce_match and normalized_requested != normalized_pk:
             return {"dbMismatched": True, "backendDatabaseType": pkDatabaseType}
         if runQueryConfig and runQueryConfig.get("arrayToMap"):
             mapped_array = array_to_map(

quillsql/db/bigquery.py

@@ -26,8 +26,7 @@ def format_bigquery_config(connection_string):
             "project": service_account.get("project_id"),
             "credentials": service_account,
         }
-    except (ValueError, TypeError) as e:
-        print("Invalid JSON string: ", e)
+    except (ValueError, TypeError):
     return connection_string
 
 

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/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
@@ -483,3 +482,4 @@ def validate_template(template: str, config: PivotConfig) -> Dict[str, Any]:
         "errors": errors
     }
 
+

quillsql/utils/run_query_processes.py

@@ -1,14 +1,21 @@
 def remove_fields(query_result, fields_to_remove):
+    if not isinstance(query_result, dict):
+        return query_result
     fields = [
         {"name": field["name"], "dataTypeID": field["dataTypeID"]}
-        for field in query_result["fields"]
-        if field["name"] not in fields_to_remove
+        for field in (query_result.get("fields") or [])
+        if field.get("name") not in fields_to_remove
     ]
-    rows = [row for row in query_result["rows"]]
-    for row in rows:
+    rows = []
+    for row in query_result.get("rows") or []:
+        if not isinstance(row, dict):
+            rows.append(row)
+            continue
+        filtered = dict(row)
         for field in fields_to_remove:
-            if field in row:
-                del row[field]
+            if field in filtered:
+                del filtered[field]
+        rows.append(filtered)
     return {"fields": fields, "rows": rows}
 
 
@@ -16,5 +23,8 @@ def array_to_map(queries, array_to_map, metadata, target_pool):
     mapped_array = []
     for i in range(len(queries)):
         query_result = target_pool.query(queries[i])
-        mapped_array.append(query_result.get("rows"))
+        if isinstance(query_result, dict):
+            mapped_array.append(query_result.get("rows"))
+        else:
+            mapped_array.append([])
     return mapped_array

{quillsql-2.2.4.dist-info → quillsql-2.2.6.dist-info}/METADATA

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

{quillsql-2.2.4.dist-info → quillsql-2.2.6.dist-info}/RECORD

@@ -1,20 +1,20 @@
 quillsql/__init__.py,sha256=FiuoxaNZveKXOPB0hkpfGNlpZKmSn3pRwcqm9HKYbCQ,180
-quillsql/core.py,sha256=HMmRtQQj3bWuLTIE8YuZaj6cAwh4bSui3pFe9pA9SgQ,23261
+quillsql/core.py,sha256=xQbg_gBDUkujJiWvj83jK2jgGgrS3VJvkRuM4friQbQ,23699
 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/bigquery.py,sha256=AGGlrpH1UBtN1yyluTFcrtgF53DdM9I3BIg05DK1FjU,4764
 quillsql/db/cached_connection.py,sha256=Pp0R2XGY-QuQYh8ThiDxSwNb6SEuEKfZcQRcvzjeC28,2556
-quillsql/db/db_helper.py,sha256=qiIP-BM7R-3PhvWBELYjNazi-92EcQB0q9eN7Ej7XUA,2111
+quillsql/db/db_helper.py,sha256=nK3E9zOW9YISXBdG4kkUBotHfY2sEq3XmUEjGJAAXmU,2257
 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=NzHO7Ux8GVAKY-DUtsOmE7TUls2q6FJG2kgJxVWq-wQ,18282
-quillsql/utils/run_query_processes.py,sha256=FRmNvjTDLUBr7MqDKQmivdC0anwybMXUyzQbKnaZx70,698
+quillsql/utils/pivot_template.py,sha256=1U1ALJHn-4K1_ps8-Z6VDpqJ9dsyOJZNYxt80NDwtlQ,18217
+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.4.dist-info/METADATA,sha256=wEywCChkWsaEmZezh0DCkKUXHkgGLv0RR3OzCgEEWk0,1786
-quillsql-2.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-quillsql-2.2.4.dist-info/top_level.txt,sha256=eU2vHnVqwpYQJ3ADl1Q-DIBzbYejZRUhcMdN_4zMCz8,9
-quillsql-2.2.4.dist-info/RECORD,,
+quillsql-2.2.6.dist-info/METADATA,sha256=wZVOGz--kUM4xMWhXHCAsGp_kOgx8J37IeV1siy5ABs,1786
+quillsql-2.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+quillsql-2.2.6.dist-info/top_level.txt,sha256=eU2vHnVqwpYQJ3ADl1Q-DIBzbYejZRUhcMdN_4zMCz8,9
+quillsql-2.2.6.dist-info/RECORD,,