Make empty comines work in Postgres.

compiler/expr_translate.py

@@ -623,11 +623,17 @@ def ConvertToSql(self, expression):
         record_type=record_type)
 
     if 'combine' in expression:
-      return '(%s)' % (
+      combined_value = '(%s)' % (
           self.subquery_translator.TranslateRule(
               expression['combine'],
               self.vocabulary,
               is_combine=True))
+      if self.dialect.Name() == 'PostgreSQL':
+        # We need this for nirvana.
+        return 'CAST(%s AS %s)' % (combined_value,
+                                   expression['type']['combine_psql_type'])
+      return combined_value
+
 
     if 'implication' in expression:
       implication = expression['implication']

integration_tests/sqlite_shortest_path_test.l

@@ -15,22 +15,22 @@
 
 # This example was causing record unfolding go wild.
 
-@Engine("sqlite");
+@Engine("sqlite", type_checking: true);
 
 Edge("a", "b");
 Edge("b", "c");
 Edge("c", "d");
 Edge("d", "e");
 Edge("d", "a");
 
-ShortestPath(open_path) = ArgMin(k -> v).nodes :-
+`*`(open_path) = ArgMin(k -> v).nodes :-
     k == {nodes: open_path},
     v == Size(open_path);
 
-OpenPath(start, end) ShortestPath= [start] :-
+OpenPath(start, end) *= [start] :-
     (Edge(start, end) | Edge(end, start));
 
-OpenPath(start, end) ShortestPath= ArrayConcat(path_one, path_two) :-
+OpenPath(start, end) *= ArrayConcat(path_one, path_two) :-
   OpenPath(start, intermediate_node) = path_one,
   OpenPath(intermediate_node, end) = path_two,
   start != end;

parser_py/parse.py

@@ -1494,6 +1494,8 @@ def AggregationOperator(cls, raw_operator):
       return 'Agg+'
     if raw_operator == '++':
       return 'Agg++'
+    if raw_operator == '*':
+      return '`*`'
     return raw_operator
 
   @classmethod

type_inference/research/infer.py

@@ -408,7 +408,7 @@ def ActMindingRecordLiterals(self, node):
         field_name = fv['field']
         reference_algebra.UnifyRecordField(
           record_type, field_name, field_type)
-      # print('>>>', node)
+        # print('>>>', node)
 
       node['type']['the_type'].CloseRecord()
 
@@ -669,6 +669,8 @@ def ActPopulatingTypeMap(self, node):
       t_rendering = reference_algebra.RenderType(t)
       self.type_map[t_rendering] = t
       node['type']['rendered_type'] = t_rendering
+      if 'combine' in node and reference_algebra.IsFullyDefined(t):
+        node['type']['combine_psql_type'] = self.PsqlType(t)
       if isinstance(t, dict) and reference_algebra.IsFullyDefined(t):
         node['type']['type_name'] = RecordTypeName(t_rendering)
       if isinstance(t, list) and reference_algebra.IsFullyDefined(t):

type_inference/research/integration_tests/typing_combine2_test.txt

@@ -230,6 +230,7 @@
          }
         },
         "type": {
+         "combine_psql_type": "logicarecord350574256[]",
          "element_type_name": "logicarecord350574256",
          "rendered_type": "[{a: {z: Num}}]",
          "the_type": [

type_inference/research/integration_tests/typing_combines_test.txt

@@ -143,6 +143,7 @@
          }
         },
         "type": {
+         "combine_psql_type": "numeric",
          "rendered_type": "Num",
          "the_type": "Num",
          "type_id": 4
@@ -283,6 +284,7 @@
          }
         },
         "type": {
+         "combine_psql_type": "text[]",
          "element_type_name": "text",
          "rendered_type": "[Str]",
          "the_type": [

type_inference/research/integration_tests/typing_kitchensync_test.txt

@@ -940,6 +940,7 @@
          }
         },
         "type": {
+         "combine_psql_type": "logicarecord980116590[]",
          "element_type_name": "logicarecord980116590",
          "rendered_type": "[{item: Str, quantity: Str}]",
          "the_type": [