Add performance warning for MAP_FILTER

Author: abhinavmuk04

presto-main-base/src/main/java/com/facebook/presto/sql/analyzer/ExpressionAnalyzer.java

@@ -30,6 +30,7 @@
 import com.facebook.presto.common.type.MapType;
 import com.facebook.presto.common.type.RowType;
 import com.facebook.presto.common.type.Type;
+import com.facebook.presto.common.type.TypeSignature;
 import com.facebook.presto.common.type.TypeSignatureParameter;
 import com.facebook.presto.common.type.TypeUtils;
 import com.facebook.presto.common.type.TypeWithName;
@@ -154,6 +155,7 @@
 import static com.facebook.presto.common.type.VarcharType.VARCHAR;
 import static com.facebook.presto.metadata.BuiltInTypeAndFunctionNamespaceManager.JAVA_BUILTIN_NAMESPACE;
 import static com.facebook.presto.spi.StandardErrorCode.OPERATOR_NOT_FOUND;
+import static com.facebook.presto.spi.StandardWarningCode.PERFORMANCE_WARNING;
 import static com.facebook.presto.spi.StandardWarningCode.SEMANTIC_WARNING;
 import static com.facebook.presto.sql.NodeUtils.getSortItemsFromOrderBy;
 import static com.facebook.presto.sql.analyzer.Analyzer.verifyNoAggregateWindowOrGroupingFunctions;
@@ -1119,6 +1121,34 @@ else if (frame.getType() == GROUPS) {
                 }
             }
 
+            List<TypeSignature> arguments = functionMetadata.getArgumentTypes();
+            String functionName = functionMetadata.getName().toString();
+
+            if (!argumentTypes.isEmpty() && "map".equals(arguments.get(0).getBase())) {
+                if (arguments.size() > 1) {
+                    arguments.stream()
+                            .skip(1)
+                            .filter(arg -> {
+                                String base = arg.getBase();
+                                return "function".equals(base) || "lambda".equals(base);
+                            })
+                            .findFirst()
+                            .ifPresent(arg -> {
+                                String warningMessage = createWarningMessage(node,
+                                        String.format("Function '%s' uses a lambda on large maps which is expensive. Consider using map_subset", functionName));
+                                warningCollector.add(new PrestoWarning(PERFORMANCE_WARNING, warningMessage));
+                            }
+                            );
+                } else if (arguments.size() == 1) {
+                    String base = arguments.get(0).getBase();
+                    if ("function".equals(base) || "lambda".equals(base)) {
+                        String warningMessage = createWarningMessage(node,
+                                String.format("Function '%s' uses a lambda on large maps which is expensive. Consider using map_subset", functionName));
+                        warningCollector.add(new PrestoWarning(PERFORMANCE_WARNING, warningMessage));
+                    }
+                }
+            }
+
             if (node.isIgnoreNulls() && node.getWindow().isPresent()) {
                 if (!functionResolution.isWindowValueFunction(function)) {
                     String warningMessage = createWarningMessage(node, "IGNORE NULLS is not used for aggregate and ranking window functions. This will cause queries to fail in future versions.");

presto-main-base/src/test/java/com/facebook/presto/sql/analyzer/TestAnalyzer.java

@@ -152,6 +152,35 @@ void testNoORWarning()
         assertNoWarning(analyzeWithWarnings("SELECT * FROM t1 JOIN t2 ON t1.a = t2.a \n" + "AND (t1.b = t2.b OR t1.b > t2.b)"));
     }
 
+    @Test
+    public void testMapFilterWarnings()
+    {
+        assertHasWarning(
+                analyzeWithWarnings("SELECT map_filter(x, (k, v) -> v > 1) FROM (VALUES (map(ARRAY[1,2], ARRAY[2,3]))) AS t(x)"),
+                PERFORMANCE_WARNING,
+                "Function 'presto.default.map_filter' uses a lambda on large maps which is expensive. Consider using map_subset");
+
+        assertHasWarning(
+                analyzeWithWarnings("SELECT map_filter(x, (k, v) -> k = 2) FROM (VALUES (map(ARRAY[1,2,3], ARRAY[10,20,30]))) AS t(x)"),
+                PERFORMANCE_WARNING,
+                "Function 'presto.default.map_filter' uses a lambda on large maps which is expensive. Consider using map_subset");
+
+        assertHasWarning(
+                analyzeWithWarnings("SELECT map_filter(x, (k, v) -> k IN (1, 3)) FROM (VALUES (map(ARRAY[1,2,3], ARRAY[10,20,30]))) AS t(x)"),
+                PERFORMANCE_WARNING,
+                "Function 'presto.default.map_filter' uses a lambda on large maps which is expensive. Consider using map_subset");
+
+        assertHasWarning(
+                analyzeWithWarnings("SELECT map_filter(x, (k, v) -> v IN (20, 30)) FROM (VALUES (map(ARRAY[1,2,3], ARRAY[10,20,30]))) AS t(x)"),
+                PERFORMANCE_WARNING,
+                "Function 'presto.default.map_filter' uses a lambda on large maps which is expensive. Consider using map_subset");
+
+        assertHasWarning(
+                analyzeWithWarnings("SELECT map_filter(x, (k, v) -> k + v > 25) FROM (VALUES (map(ARRAY[1,2,3], ARRAY[10,20,30]))) AS t(x)"),
+                PERFORMANCE_WARNING,
+                "Function 'presto.default.map_filter' uses a lambda on large maps which is expensive. Consider using map_subset");
+    }
+
     @Test
     public void testIgnoreNullWarning()
     {

presto-tests/src/test/java/com/facebook/presto/execution/TestWarnings.java

@@ -180,7 +180,7 @@ public void testMapWithDoubleKeysProducesWarnings()
         assertWarnings(queryRunner, TEST_SESSION, query, ImmutableSet.of(SEMANTIC_WARNING.toWarningCode()));
 
         query = "select transform_keys(map(ARRAY [25.5E0, 26.5E0, 27.5E0], ARRAY [25.5E0, 26.5E0, 27.5E0]), (k, v) -> k + v)";
-        assertWarnings(queryRunner, TEST_SESSION, query, ImmutableSet.of(SEMANTIC_WARNING.toWarningCode()));
+        assertWarnings(queryRunner, TEST_SESSION, query, ImmutableSet.of(SEMANTIC_WARNING.toWarningCode(), PERFORMANCE_WARNING.toWarningCode()));
 
         query = "SELECT histogram(RETAILPRICE) FROM tpch.tiny.part";
         assertWarnings(queryRunner, TEST_SESSION, query, ImmutableSet.of(SEMANTIC_WARNING.toWarningCode()));