Add PostgreSQL :: style casts

Author: dain

core/trino-grammar/src/main/antlr4/io/trino/grammar/sql/SqlBase.g4

@@ -592,6 +592,8 @@ primaryExpression
     | CASE operand=expression whenClause+ (ELSE elseExpression=expression)? END           #simpleCase
     | CASE whenClause+ (ELSE elseExpression=expression)? END                              #searchedCase
     | CAST '(' expression AS type ')'                                                     #cast
+    // This is a postgres extension to ANSI SQL, which allows for the use of "::" to cast
+    | primaryExpression DOUBLE_COLON type                                                 #cast
     | TRY_CAST '(' expression AS type ')'                                                 #cast
     | ARRAY '[' (expression (',' expression)*)? ']'                                       #arrayConstructor
     | value=primaryExpression '[' index=valueExpression ']'                               #subscript
@@ -1327,6 +1329,7 @@ LT: '<';
 LTE: '<=';
 GT: '>';
 GTE: '>=';
+DOUBLE_COLON: '::';
 
 PLUS: '+';
 MINUS: '-';

core/trino-parser/src/main/java/io/trino/sql/parser/AstBuilder.java

@@ -368,6 +368,7 @@
 import static io.trino.sql.tree.TableFunctionDescriptorArgument.nullDescriptorArgument;
 import static java.util.Locale.ENGLISH;
 import static java.util.Objects.requireNonNull;
+import static java.util.Objects.requireNonNullElse;
 import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toList;
 
@@ -2387,7 +2388,8 @@ public Node visitArrayConstructor(SqlBaseParser.ArrayConstructorContext context)
     public Node visitCast(SqlBaseParser.CastContext context)
     {
         boolean isTryCast = context.TRY_CAST() != null;
-        return new Cast(getLocation(context), (Expression) visit(context.expression()), (DataType) visit(context.type()), isTryCast);
+        Expression expression = (Expression) visit(requireNonNullElse(context.expression(), context.primaryExpression()));
+        return new Cast(getLocation(context), expression, (DataType) visit(context.type()), isTryCast);
     }
 
     @Override

core/trino-parser/src/test/java/io/trino/sql/parser/TestSqlParser.java

@@ -1345,6 +1345,51 @@ public void testCase()
                         Optional.of(new LongLiteral(location(1, 38), "3"))));
     }
 
+    @Test
+    public void testCast()
+    {
+        assertThat(expression("CAST(1 AS BIGINT)"))
+                .isEqualTo(new Cast(location(1, 1),
+                        new LongLiteral(location(1, 6), "1"),
+                        simpleType(location(1, 11), "BIGINT")));
+
+        assertThat(expression("1::BIGINT"))
+                .isEqualTo(new Cast(location(1, 1),
+                        new LongLiteral(location(1, 1), "1"),
+                        simpleType(location(1, 4), "BIGINT")));
+
+        assertThat(expression("-3::BIGINT"))
+                .isEqualTo(new Cast(location(1, 1),
+                        new LongLiteral(location(1, 1), "-3"),
+                        simpleType(location(1, 5), "BIGINT")));
+
+        assertThat(expression("3*'4'::BIGINT"))
+                .isEqualTo(new ArithmeticBinaryExpression(
+                        location(1, 2),
+                        ArithmeticBinaryExpression.Operator.MULTIPLY,
+                        new LongLiteral(location(1, 1), "3"),
+                        new Cast(
+                                location(1, 3),
+                                new StringLiteral(location(1, 3), "4"),
+                                simpleType(location(1, 8), "BIGINT"))));
+
+        assertThat(expression("CAST(ROW(11, 12) AS ROW(COL0 INTEGER, COL1 INTEGER))"))
+                .isEqualTo(new Cast(location(1, 1),
+                                new Row(location(1, 6), Lists.newArrayList(new LongLiteral(location(1, 10), "11"), new LongLiteral(location(1, 14), "12"))),
+                                rowType(
+                                        location(1, 21),
+                                        field(location(1, 25), "COL0", simpleType(location(1, 30), "INTEGER")),
+                                        field(location(1, 39), "COL1", simpleType(location(1, 44), "INTEGER")))));
+
+        assertThat(expression("ROW(11, 12)::ROW(COL0 INTEGER, COL1 INTEGER)"))
+                .isEqualTo(new Cast(location(1, 1),
+                                new Row(location(1, 1), Lists.newArrayList(new LongLiteral(location(1, 5), "11"), new LongLiteral(location(1, 9), "12"))),
+                                rowType(
+                                        location(1, 14),
+                                        field(location(1, 18), "COL0", simpleType(location(1, 23), "INTEGER")),
+                                        field(location(1, 32), "COL1", simpleType(location(1, 37), "INTEGER")))));
+    }
+
     @Test
     public void testSearchedCase()
     {