TypeCheck now can preserve AnnotateTypeExpr to prevent invalid re-typing

pkg/sql/logictest/testdata/logic_test/annotate

@@ -0,0 +1,58 @@
+
+query T
+SELECT pg_typeof(NULL:::float);
+----
+unknown
+
+query T
+SELECT pg_typeof(NULL:::int:::float);
+----
+unknown
+
+query T
+SELECT pg_typeof(min(NULL:::FLOAT))
+----
+unknown
+
+query T
+SELECT pg_typeof(min(CASE WHEN true THEN NULL:::FLOAT END))
+----
+unknown
+
+query T
+SELECT pg_typeof(min((CASE WHEN true THEN NULL END):::FLOAT))
+----
+unknown
+
+query B
+SELECT min(NULL:::FLOAT) IS NOT NAN;
+----
+NULL
+
+query B
+SELECT min((CASE WHEN true THEN NULL END):::FLOAT) IS NOT NAN;
+----
+NULL
+
+query T
+SELECT CASE WHEN true THEN ('a', 2) ELSE NULL:::RECORD END
+----
+(a,2)
+
+
+query T
+SELECT CASE WHEN true THEN NULL:::RECORD ELSE ('a', 2) END
+----
+NULL
+
+
+query T
+SELECT (SELECT NULL):::FLOAT
+----
+NULL
+
+
+query T
+SELECT (SELECT NULL):::RECORD
+----
+NULL

pkg/sql/opt/optbuilder/scalar.go

@@ -281,6 +281,17 @@ func (b *Builder) buildScalar(
 		arg := b.buildScalar(texpr, inScope, nil, nil, colRefs)
 		out = b.factory.ConstructCast(arg, t.ResolvedType())
 
+	case *tree.AnnotateTypeExpr:
+		texpr := t.TypedInnerExpr()
+		if texpr.ResolvedType() == types.Unknown {
+			// If the inner expr is still unknown cast to its type to preserve the the annotation
+			arg := b.buildScalar(texpr, inScope, nil, nil, colRefs)
+			out = b.factory.ConstructCast(arg, t.ResolvedType())
+		} else {
+			// Treat AnnotateTypeExpr as if it wasn't present.
+			return b.buildScalar(texpr, inScope, outScope, outCol, colRefs)
+		}
+
 	case *tree.CoalesceExpr:
 		args := make(memo.ScalarListExpr, len(t.Exprs))
 		typ := t.ResolvedType()

pkg/sql/opt/optbuilder/testdata/aggregate

@@ -4859,3 +4859,73 @@ scalar-group-by
  └── aggregations
       └── const-agg [as=string_agg:8]
            └── string_agg:8
+
+build format=(show-types,show-scalars)
+SELECT min(NULL:::FLOAT);
+----
+scalar-group-by
+ ├── columns: min:2(float)
+ ├── project
+ │    ├── columns: column1:1(float)
+ │    ├── values
+ │    │    └── tuple [type=tuple]
+ │    └── projections
+ │         └── cast: FLOAT8 [as=column1:1, type=float]
+ │              └── null [type=unknown]
+ └── aggregations
+      └── min [as=min:2, type=float]
+           └── variable: column1:1 [type=float]
+
+
+build format=(show-types,show-scalars)
+SELECT min(1:::FLOAT);
+----
+scalar-group-by
+ ├── columns: min:2(float)
+ ├── project
+ │    ├── columns: column1:1(float!null)
+ │    ├── values
+ │    │    └── tuple [type=tuple]
+ │    └── projections
+ │         └── const: 1.0 [as=column1:1, type=float]
+ └── aggregations
+      └── min [as=min:2, type=float]
+           └── variable: column1:1 [type=float]
+
+build
+SELECT min(CASE WHEN true THEN NULL:::FLOAT END) IS NOT NAN;
+----
+project
+ ├── columns: "?column?":3
+ ├── scalar-group-by
+ │    ├── columns: min:2
+ │    ├── project
+ │    │    ├── columns: column1:1
+ │    │    ├── values
+ │    │    │    └── ()
+ │    │    └── projections
+ │    │         └── CASE WHEN true THEN NULL::FLOAT8 ELSE CAST(NULL AS FLOAT8) END [as=column1:1]
+ │    └── aggregations
+ │         └── min [as=min:2]
+ │              └── column1:1
+ └── projections
+      └── min:2 != NaN [as="?column?":3]
+
+build
+SELECT min((CASE WHEN true THEN NULL END):::FLOAT) IS NOT NAN;
+----
+project
+ ├── columns: "?column?":3
+ ├── scalar-group-by
+ │    ├── columns: min:2
+ │    ├── project
+ │    │    ├── columns: column1:1
+ │    │    ├── values
+ │    │    │    └── ()
+ │    │    └── projections
+ │    │         └── CASE WHEN true THEN NULL::FLOAT8 ELSE CAST(NULL AS FLOAT8) END [as=column1:1]
+ │    └── aggregations
+ │         └── min [as=min:2]
+ │              └── column1:1
+ └── projections
+      └── min:2 != NaN [as="?column?":3]