Use the function name when fields() has no named output columns

DiegoDAF pointed out that the earlier change only moved the crash:
for a TABLE(...) function declared without argument names, fields()
now returned ColumnMetadata entries with name=None, and
generate_alias() then failed iterating that None.

When arg_modes has no usable output column (unnamed TABLE columns, or
only a variadic parameter), fall back to the function name as the
column name, like the branch above already does for functions without
output parameters. The variadic case now completes 'labels' instead of
offering nothing, and the TABLE case no longer reaches generate_alias()
with None.

Author: cristianchiriac

pgcli/packages/parseutils/meta.py

@@ -158,10 +158,13 @@ def fields(self):
             return [ColumnMetadata(self.func_name, self.return_type, [])]
 
         # arg_modes being truthy doesn't guarantee arg_names/arg_types are
-        # populated too (e.g. an unnamed variadic parameter), so fall back
-        # to None placeholders the same way args() falls back for modes.
-        names = self.arg_names or [None] * len(self.arg_modes)
-        types = self.arg_types or [None] * len(self.arg_modes)
-        return [
-            ColumnMetadata(name, typ, []) for name, typ, mode in zip(names, types, self.arg_modes) if mode in ("o", "b", "t")
-        ]  # OUT, INOUT, TABLE
+        # populated too (e.g. an unnamed variadic parameter or a TABLE(...)
+        # return without argument names).
+        fields = [
+            ColumnMetadata(name, typ, [])
+            for name, typ, mode in zip(self.arg_names or [], self.arg_types or [], self.arg_modes)
+            if mode in ("o", "b", "t")  # OUT, INOUT, TABLE
+        ]
+        # Without any usable output column, fall back to the function name,
+        # as for functions declared without output parameters.
+        return fields or [ColumnMetadata(self.func_name, self.return_type, [])]

tests/parseutils/test_function_metadata.py

@@ -1,4 +1,5 @@
-from pgcli.packages.parseutils.meta import FunctionMetadata
+from pgcli.packages.parseutils.meta import ColumnMetadata, FunctionMetadata
+from pgcli.pgcompleter import generate_alias
 
 
 def test_function_metadata_eq():
@@ -16,14 +17,20 @@ def test_function_metadata_eq():
 def test_function_metadata_fields_with_variadic_and_no_arg_names():
     # Regression test: arg_modes being truthy doesn't guarantee arg_names is
     # populated (e.g. an unnamed variadic parameter). fields() used to crash
-    # with "'NoneType' object is not iterable" instead of returning [].
+    # with "'NoneType' object is not iterable".
     f = FunctionMetadata("s", "labels", None, ["text[]"], ["v"], "hstore", False, False, False, False, None)
-    assert f.fields() == []
+    assert f.fields() == [ColumnMetadata("labels", "hstore", [])]
 
 
 def test_function_metadata_fields_table_mode_with_no_arg_names():
+    # Without argument names there is no output column name to offer, so the
+    # function name is used and generate_alias() gets a real string.
     f = FunctionMetadata("s", "f", None, ["int4", "text"], ["t", "t"], "record", False, False, True, False, None)
     fields = f.fields()
-    assert len(fields) == 2
-    assert [field.datatype for field in fields] == ["int4", "text"]
-    assert [field.name for field in fields] == [None, None]
+    assert fields == [ColumnMetadata("f", "record", [])]
+    assert all(generate_alias(field.name) for field in fields)
+
+
+def test_function_metadata_fields_table_mode_with_arg_names():
+    f = FunctionMetadata("s", "f", ["a", "b"], ["int4", "text"], ["t", "t"], "record", False, False, True, False, None)
+    assert f.fields() == [ColumnMetadata("a", "int4", []), ColumnMetadata("b", "text", [])]