Avoid unnecessary case transformation in QualifiedName

presto-main/src/main/java/com/facebook/presto/sql/planner/DeterminismEvaluator.java

@@ -45,7 +45,7 @@ private static class Visitor
         protected Void visitFunctionCall(FunctionCall node, AtomicBoolean deterministic)
         {
             // TODO: total hack to figure out if a function is deterministic. martint should fix this when he refactors the planning code
-            if (node.getName().equals(new QualifiedName("rand")) || node.getName().equals(new QualifiedName("random"))) {
+            if (node.getName().equals(QualifiedName.of("rand")) || node.getName().equals(QualifiedName.of("random"))) {
                 deterministic.set(false);
             }
             return super.visitFunctionCall(node, deterministic);

presto-main/src/main/java/com/facebook/presto/sql/planner/LiteralInterpreter.java

@@ -138,13 +138,13 @@ public static Expression toExpression(Object object, Type type)
             // if you remove this, you will need to update the TupleDomainOrcPredicate
             // When changing this, don't forget about similar code for FLOAT below
             if (value.isNaN()) {
-                return new FunctionCall(new QualifiedName("nan"), ImmutableList.<Expression>of());
+                return new FunctionCall(QualifiedName.of("nan"), ImmutableList.<Expression>of());
             }
             else if (value.equals(Double.NEGATIVE_INFINITY)) {
-                return ArithmeticUnaryExpression.negative(new FunctionCall(new QualifiedName("infinity"), ImmutableList.<Expression>of()));
+                return ArithmeticUnaryExpression.negative(new FunctionCall(QualifiedName.of("infinity"), ImmutableList.<Expression>of()));
             }
             else if (value.equals(Double.POSITIVE_INFINITY)) {
-                return new FunctionCall(new QualifiedName("infinity"), ImmutableList.<Expression>of());
+                return new FunctionCall(QualifiedName.of("infinity"), ImmutableList.<Expression>of());
             }
             else {
                 return new DoubleLiteral(object.toString());
@@ -155,13 +155,13 @@ else if (value.equals(Double.POSITIVE_INFINITY)) {
             Float value = intBitsToFloat(((Long) object).intValue());
             // WARNING for ORC predicate code as above (for double)
             if (value.isNaN()) {
-                return new Cast(new FunctionCall(new QualifiedName("nan"), ImmutableList.of()), StandardTypes.FLOAT);
+                return new Cast(new FunctionCall(QualifiedName.of("nan"), ImmutableList.of()), StandardTypes.FLOAT);
             }
             else if (value.equals(Float.NEGATIVE_INFINITY)) {
-                return ArithmeticUnaryExpression.negative(new Cast(new FunctionCall(new QualifiedName("infinity"), ImmutableList.of()), StandardTypes.FLOAT));
+                return ArithmeticUnaryExpression.negative(new Cast(new FunctionCall(QualifiedName.of("infinity"), ImmutableList.of()), StandardTypes.FLOAT));
             }
             else if (value.equals(Float.POSITIVE_INFINITY)) {
-                return new Cast(new FunctionCall(new QualifiedName("infinity"), ImmutableList.of()), StandardTypes.FLOAT);
+                return new Cast(new FunctionCall(QualifiedName.of("infinity"), ImmutableList.of()), StandardTypes.FLOAT);
             }
             else {
                 return new GenericLiteral("FLOAT", value.toString());
@@ -202,15 +202,15 @@ else if (value.equals(Float.POSITIVE_INFINITY)) {
             // HACK: we need to serialize VARBINARY in a format that can be embedded in an expression to be
             // able to encode it in the plan that gets sent to workers.
             // We do this by transforming the in-memory varbinary into a call to from_base64(<base64-encoded value>)
-            FunctionCall fromBase64 = new FunctionCall(new QualifiedName("from_base64"), ImmutableList.of(new StringLiteral(VarbinaryFunctions.toBase64((Slice) object).toStringUtf8())));
+            FunctionCall fromBase64 = new FunctionCall(QualifiedName.of("from_base64"), ImmutableList.of(new StringLiteral(VarbinaryFunctions.toBase64((Slice) object).toStringUtf8())));
             Signature signature = FunctionRegistry.getMagicLiteralFunctionSignature(type);
-            return new FunctionCall(new QualifiedName(signature.getName()), ImmutableList.of(fromBase64));
+            return new FunctionCall(QualifiedName.of(signature.getName()), ImmutableList.of(fromBase64));
         }
 
         Signature signature = FunctionRegistry.getMagicLiteralFunctionSignature(type);
         Expression rawLiteral = toExpression(object, FunctionRegistry.typeForMagicLiteral(type));
 
-        return new FunctionCall(new QualifiedName(signature.getName()), ImmutableList.of(rawLiteral));
+        return new FunctionCall(QualifiedName.of(signature.getName()), ImmutableList.of(rawLiteral));
     }
 
     private static class LiteralVisitor

presto-main/src/main/java/com/facebook/presto/sql/planner/optimizations/CanonicalizeExpressions.java

@@ -137,15 +137,15 @@ public Expression rewriteCurrentTime(CurrentTime node, Void context, ExpressionT
 
             switch (node.getType()) {
                 case DATE:
-                    return new FunctionCall(new QualifiedName("current_date"), ImmutableList.<Expression>of());
+                    return new FunctionCall(QualifiedName.of("current_date"), ImmutableList.<Expression>of());
                 case TIME:
-                    return new FunctionCall(new QualifiedName("current_time"), ImmutableList.<Expression>of());
+                    return new FunctionCall(QualifiedName.of("current_time"), ImmutableList.<Expression>of());
                 case LOCALTIME:
-                    return new FunctionCall(new QualifiedName("localtime"), ImmutableList.<Expression>of());
+                    return new FunctionCall(QualifiedName.of("localtime"), ImmutableList.<Expression>of());
                 case TIMESTAMP:
-                    return new FunctionCall(new QualifiedName("current_timestamp"), ImmutableList.<Expression>of());
+                    return new FunctionCall(QualifiedName.of("current_timestamp"), ImmutableList.<Expression>of());
                 case LOCALTIMESTAMP:
-                    return new FunctionCall(new QualifiedName("localtimestamp"), ImmutableList.<Expression>of());
+                    return new FunctionCall(QualifiedName.of("localtimestamp"), ImmutableList.<Expression>of());
                 default:
                     throw new UnsupportedOperationException("not yet implemented: " + node.getType());
             }
@@ -158,35 +158,35 @@ public Expression rewriteExtract(Extract node, Void context, ExpressionTreeRewri
 
             switch (node.getField()) {
                 case YEAR:
-                    return new FunctionCall(new QualifiedName("year"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("year"), ImmutableList.of(value));
                 case QUARTER:
-                    return new FunctionCall(new QualifiedName("quarter"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("quarter"), ImmutableList.of(value));
                 case MONTH:
-                    return new FunctionCall(new QualifiedName("month"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("month"), ImmutableList.of(value));
                 case WEEK:
-                    return new FunctionCall(new QualifiedName("week"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("week"), ImmutableList.of(value));
                 case DAY:
                 case DAY_OF_MONTH:
-                    return new FunctionCall(new QualifiedName("day"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("day"), ImmutableList.of(value));
                 case DAY_OF_WEEK:
                 case DOW:
-                    return new FunctionCall(new QualifiedName("day_of_week"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("day_of_week"), ImmutableList.of(value));
                 case DAY_OF_YEAR:
                 case DOY:
-                    return new FunctionCall(new QualifiedName("day_of_year"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("day_of_year"), ImmutableList.of(value));
                 case YEAR_OF_WEEK:
                 case YOW:
-                    return new FunctionCall(new QualifiedName("year_of_week"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("year_of_week"), ImmutableList.of(value));
                 case HOUR:
-                    return new FunctionCall(new QualifiedName("hour"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("hour"), ImmutableList.of(value));
                 case MINUTE:
-                    return new FunctionCall(new QualifiedName("minute"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("minute"), ImmutableList.of(value));
                 case SECOND:
-                    return new FunctionCall(new QualifiedName("second"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("second"), ImmutableList.of(value));
                 case TIMEZONE_MINUTE:
-                    return new FunctionCall(new QualifiedName("timezone_minute"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("timezone_minute"), ImmutableList.of(value));
                 case TIMEZONE_HOUR:
-                    return new FunctionCall(new QualifiedName("timezone_hour"), ImmutableList.of(value));
+                    return new FunctionCall(QualifiedName.of("timezone_hour"), ImmutableList.of(value));
             }
 
             throw new UnsupportedOperationException("not yet implemented: " + node.getField());

presto-main/src/test/java/com/facebook/presto/execution/TestSetSessionTask.java

@@ -69,7 +69,7 @@ public void testSetSession()
             throws Exception
     {
         testSetSession(new StringLiteral("baz"), "baz");
-        testSetSession(new FunctionCall(new QualifiedName("concat"), ImmutableList.of(
+        testSetSession(new FunctionCall(QualifiedName.of("concat"), ImmutableList.of(
                 new StringLiteral("ban"),
                 new StringLiteral("ana"))), "banana");
     }

presto-main/src/test/java/com/facebook/presto/sql/planner/TestDeterminismEvaluator.java

@@ -39,7 +39,7 @@ public void testSanity()
 
     private static FunctionCall function(String name, Expression... inputs)
     {
-        return new FunctionCall(new QualifiedName(name), Arrays.asList(inputs));
+        return new FunctionCall(QualifiedName.of(name), Arrays.asList(inputs));
     }
 
     private static QualifiedNameReference input(String symbol)

presto-main/src/test/java/com/facebook/presto/sql/planner/TestDomainTranslator.java

@@ -1342,7 +1342,7 @@ private static Expression unprocessableExpression2(Symbol symbol)
 
     private static Expression randPredicate(Symbol symbol)
     {
-        return comparison(GREATER_THAN, symbol.toSymbolReference(), new FunctionCall(new QualifiedName("rand"), ImmutableList.<Expression>of()));
+        return comparison(GREATER_THAN, symbol.toSymbolReference(), new FunctionCall(QualifiedName.of("rand"), ImmutableList.<Expression>of()));
     }
 
     private static NotExpression not(Expression expression)

presto-parser/src/main/java/com/facebook/presto/sql/QueryUtil.java

@@ -113,7 +113,7 @@ public static Expression caseWhen(Expression operand, Expression result)
 
     public static Expression functionCall(String name, Expression... arguments)
     {
-        return new FunctionCall(new QualifiedName(name), ImmutableList.copyOf(arguments));
+        return new FunctionCall(QualifiedName.of(name), ImmutableList.copyOf(arguments));
     }
 
     public static Values values(Row... row)

presto-parser/src/main/java/com/facebook/presto/sql/parser/AstBuilder.java

@@ -974,7 +974,7 @@ public Node visitConcatenation(SqlBaseParser.ConcatenationContext context)
     {
         return new FunctionCall(
                 getLocation(context.CONCAT()),
-                new QualifiedName("concat"), ImmutableList.of(
+                QualifiedName.of("concat"), ImmutableList.of(
                 (Expression) visit(context.left),
                 (Expression) visit(context.right)));
     }
@@ -1056,22 +1056,22 @@ public Node visitExtract(SqlBaseParser.ExtractContext context)
     @Override
     public Node visitSubstring(SqlBaseParser.SubstringContext context)
     {
-        return new FunctionCall(getLocation(context), new QualifiedName("substr"), visit(context.valueExpression(), Expression.class));
+        return new FunctionCall(getLocation(context), QualifiedName.of("substr"), visit(context.valueExpression(), Expression.class));
     }
 
     @Override
     public Node visitPosition(SqlBaseParser.PositionContext context)
     {
         List<Expression> arguments = Lists.reverse(visit(context.valueExpression(), Expression.class));
-        return new FunctionCall(getLocation(context), new QualifiedName("strpos"), arguments);
+        return new FunctionCall(getLocation(context), QualifiedName.of("strpos"), arguments);
     }
 
     @Override
     public Node visitNormalize(SqlBaseParser.NormalizeContext context)
     {
         Expression str = (Expression) visit(context.valueExpression());
         String normalForm = Optional.ofNullable(context.normalForm()).map(ParserRuleContext::getText).orElse("NFC");
-        return new FunctionCall(getLocation(context), new QualifiedName("normalize"), ImmutableList.of(str, new StringLiteral(getLocation(context), normalForm)));
+        return new FunctionCall(getLocation(context), QualifiedName.of("normalize"), ImmutableList.of(str, new StringLiteral(getLocation(context), normalForm)));
     }
 
     @Override
@@ -1095,7 +1095,7 @@ public Node visitDereference(SqlBaseParser.DereferenceContext context)
     @Override
     public Node visitColumnReference(SqlBaseParser.ColumnReferenceContext context)
     {
-        return new QualifiedNameReference(getLocation(context), new QualifiedName(context.getText()));
+        return new QualifiedNameReference(getLocation(context), QualifiedName.of(context.getText()));
     }
 
     @Override
@@ -1387,7 +1387,7 @@ private static QualifiedName getQualifiedName(SqlBaseParser.QualifiedNameContext
                 .map(ParseTree::getText)
                 .collect(toList());
 
-        return new QualifiedName(parts);
+        return QualifiedName.of(parts);
     }
 
     private static boolean isDistinct(SqlBaseParser.SetQuantifierContext setQuantifier)

presto-parser/src/main/java/com/facebook/presto/sql/tree/DereferenceExpression.java

@@ -69,7 +69,7 @@ public String getFieldName()
     public static QualifiedName getQualifiedName(DereferenceExpression expression)
     {
         List<String> parts = tryParseParts(expression.base, expression.fieldName);
-        return parts == null ? null : new QualifiedName(parts);
+        return parts == null ? null : QualifiedName.of(parts);
     }
 
     private static List<String> tryParseParts(Expression base, String fieldName)

presto-parser/src/main/java/com/facebook/presto/sql/tree/QualifiedName.java

@@ -35,20 +35,28 @@ public class QualifiedName
     public static QualifiedName of(String first, String... rest)
     {
         requireNonNull(first, "first is null");
-        return new QualifiedName(ImmutableList.copyOf(Lists.asList(first, rest)));
+        return of(ImmutableList.copyOf(Lists.asList(first, rest)));
     }
 
-    public QualifiedName(String name)
+    public static QualifiedName of(String name)
     {
-        this(ImmutableList.of(name));
+        requireNonNull(name, "name is null");
+        return of(ImmutableList.of(name));
     }
 
-    public QualifiedName(Iterable<String> parts)
+    public static QualifiedName of(Iterable<String> originalParts)
     {
-        requireNonNull(parts, "parts is null");
-        checkArgument(!isEmpty(parts), "parts is empty");
-        this.parts = ImmutableList.copyOf(transform(parts, part -> part.toLowerCase(ENGLISH)));
-        this.originalParts = ImmutableList.copyOf(parts);
+        requireNonNull(originalParts, "originalParts is null");
+        checkArgument(!isEmpty(originalParts), "originalParts is empty");
+        List<String> parts = ImmutableList.copyOf(transform(originalParts, part -> part.toLowerCase(ENGLISH)));
+
+        return new QualifiedName(ImmutableList.copyOf(originalParts), parts);
+    }
+
+    private QualifiedName(List<String> originalParts, List<String> parts)
+    {
+        this.originalParts = originalParts;
+        this.parts = parts;
     }
 
     public List<String> getParts()
@@ -77,7 +85,8 @@ public Optional<QualifiedName> getPrefix()
             return Optional.empty();
         }
 
-        return Optional.of(new QualifiedName(parts.subList(0, parts.size() - 1)));
+        List<String> subList = parts.subList(0, parts.size() - 1);
+        return Optional.of(new QualifiedName(subList, subList));
     }
 
     public boolean hasSuffix(QualifiedName suffix)

presto-parser/src/test/java/com/facebook/presto/sql/parser/TestSqlParser.java

@@ -121,6 +121,8 @@
 import static java.lang.String.format;
 import static java.util.Collections.nCopies;
 import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
 import static org.testng.Assert.fail;
 
 public class TestSqlParser
@@ -149,6 +151,18 @@ public void testPossibleExponentialBacktracking()
         SQL_PARSER.createExpression("(((((((((((((((((((((((((((true)))))))))))))))))))))))))))");
     }
 
+    @Test
+    public void testQualifiedName()
+    {
+        assertEquals(QualifiedName.of("a", "b", "c", "d").toString(), "a.b.c.d");
+        assertEquals(QualifiedName.of("A", "b", "C", "d").toString(), "a.b.c.d");
+        assertTrue(QualifiedName.of("a", "b", "c", "d").hasSuffix(QualifiedName.of("b", "c", "d")));
+        assertTrue(QualifiedName.of("a", "b", "c", "d").hasSuffix(QualifiedName.of("a", "b", "c", "d")));
+        assertFalse(QualifiedName.of("a", "b", "c", "d").hasSuffix(QualifiedName.of("a", "c", "d")));
+        assertFalse(QualifiedName.of("a", "b", "c", "d").hasSuffix(QualifiedName.of("z", "a", "b", "c", "d")));
+        assertEquals(QualifiedName.of("a", "b", "c", "d"), QualifiedName.of("a", "b", "c", "d"));
+    }
+
     @Test
     public void testGenericLiteral()
             throws Exception