jaaql-middleware-python 4.34.0__tar.gz → 4.34.2__tar.gz

{jaaql_middleware_python-4.34.0 → jaaql_middleware_python-4.34.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaaql-middleware-python
-Version: 4.34.0
+Version: 4.34.2
 Summary: The jaaql package, allowing for rapid development and deployment of RESTful HTTP applications
 Home-page: https://github.com/JAAQL/JAAQL-middleware-python
 Author: Software Quality Measurement and Improvement bv

{jaaql_middleware_python-4.34.0 → jaaql_middleware_python-4.34.2}/jaaql/constants.py

@@ -208,5 +208,5 @@ ROLE__postgres = "postgres"
 
 PROTOCOL__postgres = "postgresql://"
 
-VERSION = "4.34.0"
+VERSION = "4.34.2"
 

{jaaql_middleware_python-4.34.0 → jaaql_middleware_python-4.34.2}/jaaql/interpreter/interpret_jaaql.py

@@ -336,35 +336,95 @@ class InterpretJAAQL:
                                                                          requires_dba_check=check_required and canned_query_service is not None)
                         last_query = """
 WITH RECURSIVE column_hierarchy AS (
-    -- Base case: Select columns from 'managed_service'
-    SELECT
-        C.column_name, C.data_type, C.udt_name, C.domain_name,
-        VC.table_catalog, VC.table_schema, VC.table_name,
-        true as is_nullable,
-        1 as level
-    FROM information_schema.columns C
-    LEFT JOIN information_schema.view_column_usage VC on VC.view_name = C.table_name AND VC.column_name = C.column_name
-    WHERE C.table_name = 'temp_view__""" + temp_view_name + """'
-
-    UNION ALL
-
-    SELECT
-        C.column_name, C.data_type, C.udt_name, C.domain_name,
-        VC.table_catalog, VC.table_schema, VC.table_name,
-        CASE WHEN C.is_nullable = 'NO' then false else true end as is_nullable,
-        CH.level + 1 as level
-    FROM information_schema.columns C
-    JOIN column_hierarchy CH ON C.column_name = CH.column_name
-    LEFT JOIN information_schema.view_column_usage VC on VC.view_name = C.table_name AND VC.column_name = C.column_name
-    WHERE C.table_name = CH.table_name AND C.table_schema = CH.table_schema AND C.table_catalog = CH.table_catalog
-)SELECT
-    MAX(CH.column_name) as column_name,
-    MAX(CH.data_type) as data_type,
-    MAX(CH.udt_name) as udt_name,
-    MAX(CH.domain_name) as domain_name,
-    NOT(bool_or(NOT(CH.is_nullable))) as is_nullable
-FROM column_hierarchy CH
-GROUP BY CH.column_name, CH.data_type, CH.udt_name, CH.domain_name;"""
+	SELECT
+		c.column_name,
+		c.data_type,
+		c.udt_name,
+		c.domain_name,
+		c.table_catalog,
+		c.table_schema,
+		c.table_name,
+		true AS is_nullable,
+		1 AS level
+	FROM information_schema.columns c
+	WHERE c.table_name =  'temp_view__""" + temp_view_name + """'
+		AND c.table_schema = (
+			SELECT n.nspname
+			FROM pg_namespace n
+			WHERE n.oid = pg_my_temp_schema()
+		)
+
+	UNION ALL
+
+	SELECT
+		ch.column_name,
+		ref.data_type,
+		ref.udt_name,
+		ref.domain_name,
+		ref.table_catalog,
+		ref.table_schema,
+		ref.table_name,
+		(ref.is_nullable = 'YES') AS is_nullable,
+		ch.level + 1 AS level
+	FROM column_hierarchy ch
+	JOIN information_schema.views v
+		ON v.table_catalog = ch.table_catalog
+		AND v.table_schema = ch.table_schema
+		AND v.table_name = ch.table_name
+	JOIN LATERAL (
+		SELECT
+			c2.data_type,
+			c2.udt_name,
+			c2.domain_name,
+			c2.table_catalog,
+			c2.table_schema,
+			c2.table_name,
+			c2.is_nullable
+		FROM information_schema.view_column_usage u
+		JOIN information_schema.columns c2
+			ON c2.table_catalog = u.table_catalog
+			AND c2.table_schema = u.table_schema
+			AND c2.table_name = u.table_name
+			AND c2.column_name = u.column_name
+		WHERE u.view_catalog = ch.table_catalog
+			AND u.view_schema = ch.table_schema
+			AND u.view_name = ch.table_name
+			AND u.column_name = ch.column_name
+		ORDER BY
+			CASE WHEN ch.domain_name IS NOT DISTINCT FROM c2.domain_name THEN 3 ELSE 0 END DESC,
+			CASE WHEN ch.udt_name = c2.udt_name THEN 2 ELSE 0 END DESC,
+			CASE WHEN ch.data_type = c2.data_type THEN 1 ELSE 0 END DESC,
+			c2.table_schema,
+			c2.table_name
+		LIMIT 1
+	) ref ON true
+),
+deep AS (
+	SELECT DISTINCT ON (column_name)
+		column_name,
+		data_type,
+		udt_name,
+		domain_name
+	FROM column_hierarchy
+	ORDER BY column_name, level DESC
+),
+nul AS (
+	SELECT
+		column_name,
+		NOT(bool_or(NOT is_nullable)) AS is_nullable
+	FROM column_hierarchy
+	GROUP BY column_name
+)
+SELECT
+	d.column_name,
+	d.data_type,
+	d.udt_name,
+	d.domain_name,
+	n.is_nullable
+FROM deep d
+JOIN nul n USING (column_name)
+ORDER BY d.column_name;
+"""
                         found_params = {}
                     elif do_prepare_only and not psql:
                         arg_open = "(" if len(found_params) != 0 else ""

{jaaql_middleware_python-4.34.0 → jaaql_middleware_python-4.34.2}/jaaql/mvc/model.py

@@ -203,28 +203,46 @@ class JAAQLModel(BaseJAAQLModel):
     def parse_gdesc_output(self, output):
         """
         Parse the output of gdesc to extract column names and types.
+
+        If duplicate column names exist, raise an exception listing them.
         """
         lines = output.strip().split('\n')
         columns = {}
         parsing = False
+
+        seen = {}
         for line in lines:
             if line.strip().replace(" ", "") == "Column|Type":
                 # Found the header line
                 parsing = True
                 continue
+
             if parsing:
                 if line.strip() == '':
                     # End of table
                     break
+
                 # Parse the line
                 parts = [part.strip() for part in line.strip().split('|')]
                 if len(parts) >= 2:
                     column_name = parts[0]
                     column_type = parts[1]
+
+                    seen[column_name] = seen.get(column_name, 0) + 1
+
+                    # Still build the dict, but we'll error afterwards if duplicates exist
                     columns[column_name] = {
                         "type": column_type,
                         "nullable": True  # We can't figure this out with gdesc
                     }
+
+        dupes = [name for name, count in seen.items() if count > 1]
+        if dupes:
+            dupes.sort()
+            # Include counts so it's unambiguous
+            dupe_str = ", ".join([f"{name} (x{seen[name]})" for name in dupes])
+            raise Exception("Duplicate output column names are not supported: " + dupe_str)
+
         return columns
 
     def fetch_domains(self, inputs: dict, account_id: str):
@@ -269,32 +287,58 @@ ORDER BY
             cost = None
             type_resolution_method = None
             columns = None
+
             try:
-                results = execute_supplied_statement(db_connection, query["query"].strip(),
-                                                     do_prepare_only=my_uuid)  # Fetch cursor descriptors here too and then merge
+                results = execute_supplied_statement(
+                    db_connection,
+                    query["query"].strip(),
+                    do_prepare_only=my_uuid
+                )
                 cost = float(results["rows"][0][0].split("..")[1].split(" ")[0])
             except Exception as ex:
                 exc = str(ex).replace("PREPARE _jaaql_query_check_" + my_uuid + " as ", "").replace(
                     " ... _jaaql_query_check_" + my_uuid + " as ", "")
 
             if exc is None and not cost_only:
+                # Try temp_view domain type resolution first
                 try:
-                    domain_types = execute_supplied_statement(db_connection, query["query"].strip(), do_prepare_only=my_uuid, attempt_fetch_domain_types=True)
+                    domain_types = execute_supplied_statement(
+                        db_connection,
+                        query["query"].strip(),
+                        do_prepare_only=my_uuid,
+                        attempt_fetch_domain_types=True
+                    )
                     type_resolution_method = "temp_view"
+
                     temp_columns = [row[0] for row in domain_types['rows']]
-                    nullable = [row[4] for row in domain_types['rows']]
-                    temp_types = [row[3] if row[3] is not None else row[2] for row in domain_types['rows']]
-                    columns = {
-                        col: {
-                            "type": temp_types[idx],
-                            "nullable": nullable[idx]
+
+                    # Detect duplicates BEFORE building the dict (dict would overwrite)
+                    counts = {}
+                    for c in temp_columns:
+                        counts[c] = counts.get(c, 0) + 1
+
+                    dupes = [name for name, count in counts.items() if count > 1]
+                    if dupes:
+                        dupes.sort()
+                        dupe_str = ", ".join([f"{name} (x{counts[name]})" for name in dupes])
+                        exc = "Duplicate output column names are not supported: " + dupe_str
+                        columns = None
+                    else:
+                        nullable = [row[4] for row in domain_types['rows']]
+                        temp_types = [row[3] if row[3] is not None else row[2] for row in domain_types['rows']]
+                        columns = {
+                            col: {
+                                "type": temp_types[idx],
+                                "nullable": nullable[idx]
+                            }
+                            for col, idx in zip(temp_columns, range(len(temp_columns)))
                         }
-                        for col, idx in zip(temp_columns, range(len(temp_columns)))
-                    }
-                except Exception as ex:
+
+                except Exception:
                     pass  # This is fine
 
-                if columns is None:
+                # If temp_view didn't work, fallback to gdesc/psql
+                if columns is None and exc is None:
                     try:
                         type_resolution_method = "gdesc"
                         psql = [
@@ -303,11 +347,22 @@ ORDER BY
                             "-d", inputs[KEY__database],
                             "-q", "-X", "--pset", "pager=off", "-f", "-"
                         ]
-                        results = execute_supplied_statement(db_connection, query["query"].strip(), do_prepare_only=my_uuid, psql=psql,
-                                                             pre_psql="SET SESSION AUTHORIZATION \"" + account_id + "\";")
+                        results = execute_supplied_statement(
+                            db_connection,
+                            query["query"].strip(),
+                            do_prepare_only=my_uuid,
+                            psql=psql,
+                            pre_psql="SET SESSION AUTHORIZATION \"" + account_id + "\";"
+                        )
+
+                        # parse_gdesc_output now throws if duplicates exist
                         columns = self.parse_gdesc_output(results['rows'][0])
-                    except:
+
+                    except Exception as ex:
+                        # This catches duplicate column errors and also any parse failures
+                        exc = str(ex)
                         type_resolution_method = "failed"
+                        columns = None
 
             res.append({
                 "location": query["file"] + ":" + str(query["line_number"]),
@@ -319,7 +374,13 @@ ORDER BY
             })
 
         if inputs.get("sort_cost", True):
-            return sorted(res, key=lambda x: (x["exception"] if x["exception"] is not None else '', float('-inf') if x["cost"] is None else -x["cost"]))
+            return sorted(
+                res,
+                key=lambda x: (
+                    x["exception"] if x["exception"] is not None else '',
+                    float('-inf') if x["cost"] is None else -x["cost"]
+                )
+            )
         else:
             return res
 

{jaaql_middleware_python-4.34.0 → jaaql_middleware_python-4.34.2}/jaaql_middleware_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaaql-middleware-python
-Version: 4.34.0
+Version: 4.34.2
 Summary: The jaaql package, allowing for rapid development and deployment of RESTful HTTP applications
 Home-page: https://github.com/JAAQL/JAAQL-middleware-python
 Author: Software Quality Measurement and Improvement bv