quillsql 2.2.4__py3-none-any.whl → 2.2.5__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")

quillsql/utils/pivot_template.py

@@ -483,3 +483,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.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quillsql
-Version: 2.2.4
+Version: 2.2.5
 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.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
 quillsql/__init__.py,sha256=FiuoxaNZveKXOPB0hkpfGNlpZKmSn3pRwcqm9HKYbCQ,180
-quillsql/core.py,sha256=HMmRtQQj3bWuLTIE8YuZaj6cAwh4bSui3pFe9pA9SgQ,23261
+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
@@ -10,11 +10,11 @@ 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=NzHO7Ux8GVAKY-DUtsOmE7TUls2q6FJG2kgJxVWq-wQ,18282
-quillsql/utils/run_query_processes.py,sha256=FRmNvjTDLUBr7MqDKQmivdC0anwybMXUyzQbKnaZx70,698
+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.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.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,,