Add config to Re2JRegexpType

presto-main/src/main/java/io/prestosql/metadata/MetadataManager.java

@@ -159,7 +159,7 @@ public final class MetadataManager
     private final ColumnPropertyManager columnPropertyManager;
     private final AnalyzePropertyManager analyzePropertyManager;
     private final TransactionManager transactionManager;
-    private final TypeRegistry typeRegistry = new TypeRegistry();
+    private final TypeRegistry typeRegistry;
 
     private final ConcurrentMap<String, BlockEncoding> blockEncodings = new ConcurrentHashMap<>();
     private final ConcurrentMap<QueryId, QueryCatalogs> catalogsByQueryId = new ConcurrentHashMap<>();
@@ -174,6 +174,7 @@ public MetadataManager(
             AnalyzePropertyManager analyzePropertyManager,
             TransactionManager transactionManager)
     {
+        typeRegistry = new TypeRegistry(featuresConfig);
         functions = new FunctionRegistry(this, featuresConfig);
         functionResolver = new FunctionResolver(this);
 

presto-main/src/main/java/io/prestosql/metadata/TypeRegistry.java

@@ -25,9 +25,11 @@
 import io.prestosql.spi.type.TypeParameter;
 import io.prestosql.spi.type.TypeSignature;
 import io.prestosql.spi.type.TypeSignatureParameter;
+import io.prestosql.sql.analyzer.FeaturesConfig;
 import io.prestosql.sql.parser.SqlParser;
 import io.prestosql.type.CharParametricType;
 import io.prestosql.type.DecimalParametricType;
+import io.prestosql.type.Re2JRegexpType;
 import io.prestosql.type.VarcharParametricType;
 
 import javax.annotation.concurrent.ThreadSafe;
@@ -72,7 +74,6 @@
 import static io.prestosql.type.JsonType.JSON;
 import static io.prestosql.type.LikePatternType.LIKE_PATTERN;
 import static io.prestosql.type.MapParametricType.MAP;
-import static io.prestosql.type.Re2JRegexpType.RE2J_REGEXP;
 import static io.prestosql.type.RowParametricType.ROW;
 import static io.prestosql.type.UnknownType.UNKNOWN;
 import static io.prestosql.type.UuidType.UUID;
@@ -89,7 +90,7 @@ final class TypeRegistry
 
     private final Cache<TypeSignature, Type> parametricTypeCache;
 
-    public TypeRegistry()
+    public TypeRegistry(FeaturesConfig featuresConfig)
     {
         // Manually register UNKNOWN type without a verifyTypeClass call since it is a special type that cannot be used by functions
         this.types.put(UNKNOWN.getTypeSignature(), UNKNOWN);
@@ -115,7 +116,7 @@ public TypeRegistry()
         addType(SET_DIGEST);
         addType(P4_HYPER_LOG_LOG);
         addType(JONI_REGEXP);
-        addType(RE2J_REGEXP);
+        addType(new Re2JRegexpType(featuresConfig.getRe2JDfaStatesLimit(), featuresConfig.getRe2JDfaRetries()));
         addType(LIKE_PATTERN);
         addType(JSON_PATH);
         addType(COLOR);

presto-main/src/main/java/io/prestosql/operator/scalar/Re2JCastToRegexpFunction.java

@@ -31,7 +31,7 @@
 import static io.prestosql.spi.StandardErrorCode.INVALID_FUNCTION_ARGUMENT;
 import static io.prestosql.spi.function.OperatorType.CAST;
 import static io.prestosql.spi.type.Chars.padSpaces;
-import static io.prestosql.type.Re2JRegexpType.RE2J_REGEXP;
+import static io.prestosql.type.Re2JRegexpType.RE2J_REGEXP_SIGNATURE;
 import static io.prestosql.util.Reflection.methodHandle;
 import static java.lang.invoke.MethodHandles.insertArguments;
 import static java.util.Collections.emptyList;
@@ -57,7 +57,7 @@ public static SqlOperator castCharToRe2JRegexp(int dfaStatesLimit, int dfaRetrie
 
     private Re2JCastToRegexpFunction(String sourceType, int dfaStatesLimit, int dfaRetries, boolean padSpaces)
     {
-        super(CAST, emptyList(), emptyList(), RE2J_REGEXP.getTypeSignature(), ImmutableList.of(parseTypeSignature(sourceType, ImmutableSet.of("x"))), false);
+        super(CAST, emptyList(), emptyList(), RE2J_REGEXP_SIGNATURE, ImmutableList.of(parseTypeSignature(sourceType, ImmutableSet.of("x"))), false);
         this.dfaStatesLimit = dfaStatesLimit;
         this.dfaRetries = dfaRetries;
         this.padSpaces = padSpaces;

presto-main/src/main/java/io/prestosql/sql/planner/LiteralEncoder.java

@@ -70,7 +70,6 @@
 import static io.prestosql.type.JoniRegexpType.JONI_REGEXP;
 import static io.prestosql.type.JsonPathType.JSON_PATH;
 import static io.prestosql.type.LikePatternType.LIKE_PATTERN;
-import static io.prestosql.type.Re2JRegexpType.RE2J_REGEXP;
 import static io.prestosql.type.UnknownType.UNKNOWN;
 import static java.lang.Float.intBitsToFloat;
 import static java.lang.Math.toIntExact;
@@ -226,7 +225,7 @@ public Expression toExpression(Object object, Type type)
             return new GenericLiteral(type.getBaseName(), ((JoniRegexp) object).pattern().toStringUtf8());
         }
 
-        if (type.equals(RE2J_REGEXP)) {
+        if (type instanceof Re2JRegexpType) {
             return new GenericLiteral(Re2JRegexpType.NAME, ((Re2JRegexp) object).pattern());
         }
 

presto-main/src/main/java/io/prestosql/type/Re2JRegexpType.java

@@ -26,12 +26,17 @@
 public class Re2JRegexpType
         extends AbstractType
 {
-    public static final Re2JRegexpType RE2J_REGEXP = new Re2JRegexpType();
     public static final String NAME = "Re2JRegExp";
+    public static final TypeSignature RE2J_REGEXP_SIGNATURE = new TypeSignature(NAME);
 
-    public Re2JRegexpType()
+    private final int dfaStatesLimit;
+    private final int dfaRetries;
+
+    public Re2JRegexpType(int dfaStatesLimit, int dfaRetries)
     {
-        super(new TypeSignature(NAME), Re2JRegexp.class);
+        super(RE2J_REGEXP_SIGNATURE, Re2JRegexp.class);
+        this.dfaStatesLimit = dfaStatesLimit;
+        this.dfaRetries = dfaRetries;
     }
 
     @Override

presto-main/src/main/java/io/prestosql/type/TypeCoercion.java

@@ -49,7 +49,7 @@
 import static io.prestosql.type.CodePointsType.CODE_POINTS;
 import static io.prestosql.type.JoniRegexpType.JONI_REGEXP;
 import static io.prestosql.type.JsonPathType.JSON_PATH;
-import static io.prestosql.type.Re2JRegexpType.RE2J_REGEXP;
+import static io.prestosql.type.Re2JRegexpType.RE2J_REGEXP_SIGNATURE;
 import static java.util.Objects.requireNonNull;
 
 public final class TypeCoercion
@@ -420,7 +420,7 @@ public Optional<Type> coerceTypeBase(Type sourceType, String resultTypeBase)
                     case JoniRegexpType.NAME:
                         return Optional.of(JONI_REGEXP);
                     case Re2JRegexpType.NAME:
-                        return Optional.of(RE2J_REGEXP);
+                        return Optional.of(lookupType.apply(RE2J_REGEXP_SIGNATURE));
                     case JsonPathType.NAME:
                         return Optional.of(JSON_PATH);
                     case CodePointsType.NAME:
@@ -436,7 +436,7 @@ public Optional<Type> coerceTypeBase(Type sourceType, String resultTypeBase)
                     case JoniRegexpType.NAME:
                         return Optional.of(JONI_REGEXP);
                     case Re2JRegexpType.NAME:
-                        return Optional.of(RE2J_REGEXP);
+                        return Optional.of(lookupType.apply(RE2J_REGEXP_SIGNATURE));
                     case JsonPathType.NAME:
                         return Optional.of(JSON_PATH);
                     case CodePointsType.NAME:

presto-main/src/test/java/io/prestosql/sql/planner/TestLiteralEncoder.java

@@ -37,7 +37,7 @@
 import static io.prestosql.type.JoniRegexpType.JONI_REGEXP;
 import static io.prestosql.type.JsonPathType.JSON_PATH;
 import static io.prestosql.type.LikePatternType.LIKE_PATTERN;
-import static io.prestosql.type.Re2JRegexpType.RE2J_REGEXP;
+import static io.prestosql.type.Re2JRegexpType.RE2J_REGEXP_SIGNATURE;
 import static io.prestosql.type.UnknownType.UNKNOWN;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.testng.Assert.assertEquals;
@@ -57,7 +57,7 @@ public void testEncode()
         assertEncode(utf8Slice("hello"), VARBINARY, literalVarbinary("hello".getBytes(UTF_8)));
         assertEncode(castVarcharToJoniRegexp(utf8Slice("[a-z]")), LIKE_PATTERN, "LikePattern '[a-z]'");
         assertEncode(castVarcharToJoniRegexp(utf8Slice("[a-z]")), JONI_REGEXP, "JoniRegExp '[a-z]'");
-        assertEncode(castVarcharToRe2JRegexp(utf8Slice("[a-z]")), RE2J_REGEXP, "Re2JRegExp '[a-z]'");
+        assertEncode(castVarcharToRe2JRegexp(utf8Slice("[a-z]")), metadata.getType(RE2J_REGEXP_SIGNATURE), "Re2JRegExp '[a-z]'");
         assertEncode(castVarcharToJsonPath(utf8Slice("$.foo")), JSON_PATH, "JsonPath '$.foo'");
         assertEncode(castVarcharToCodePoints(utf8Slice("hello")), CODE_POINTS, "CodePoints 'hello'");
     }

presto-main/src/test/java/io/prestosql/type/TestTypeCoercion.java

@@ -46,7 +46,7 @@
 import static io.prestosql.spi.type.VarcharType.createVarcharType;
 import static io.prestosql.type.JoniRegexpType.JONI_REGEXP;
 import static io.prestosql.type.JsonPathType.JSON_PATH;
-import static io.prestosql.type.Re2JRegexpType.RE2J_REGEXP;
+import static io.prestosql.type.Re2JRegexpType.RE2J_REGEXP_SIGNATURE;
 import static io.prestosql.type.UnknownType.UNKNOWN;
 import static java.lang.String.format;
 import static java.util.Objects.requireNonNull;
@@ -58,6 +58,7 @@
 public class TestTypeCoercion
 {
     private final Metadata metadata = createTestMetadataManager();
+    private final Type re2jType = metadata.getType(RE2J_REGEXP_SIGNATURE);
     private final TypeCoercion typeCoercion = new TypeCoercion(metadata::getType);
 
     @Test
@@ -122,7 +123,7 @@ public void testTypeCompatibility()
         assertThat(TIME, TIME_WITH_TIME_ZONE).hasCommonSuperType(TIME_WITH_TIME_ZONE).canCoerceFirstToSecondOnly();
         assertThat(TIMESTAMP, TIMESTAMP_WITH_TIME_ZONE).hasCommonSuperType(TIMESTAMP_WITH_TIME_ZONE).canCoerceFirstToSecondOnly();
         assertThat(VARCHAR, JONI_REGEXP).hasCommonSuperType(JONI_REGEXP).canCoerceFirstToSecondOnly();
-        assertThat(VARCHAR, RE2J_REGEXP).hasCommonSuperType(RE2J_REGEXP).canCoerceFirstToSecondOnly();
+        assertThat(VARCHAR, re2jType).hasCommonSuperType(re2jType).canCoerceFirstToSecondOnly();
         assertThat(VARCHAR, JSON_PATH).hasCommonSuperType(JSON_PATH).canCoerceFirstToSecondOnly();
 
         assertThat(REAL, DOUBLE).hasCommonSuperType(DOUBLE).canCoerceFirstToSecondOnly();
@@ -193,7 +194,7 @@ public void testTypeCompatibility()
 
         assertThat(createCharType(42), JONI_REGEXP).hasCommonSuperType(JONI_REGEXP).canCoerceFirstToSecondOnly();
         assertThat(createCharType(42), JSON_PATH).hasCommonSuperType(JSON_PATH).canCoerceFirstToSecondOnly();
-        assertThat(createCharType(42), RE2J_REGEXP).hasCommonSuperType(RE2J_REGEXP).canCoerceFirstToSecondOnly();
+        assertThat(createCharType(42), re2jType).hasCommonSuperType(re2jType).canCoerceFirstToSecondOnly();
 
         assertThat(anonymousRow(createVarcharType(2)), anonymousRow(createVarcharType(5)))
                 .hasCommonSuperType(anonymousRow(createVarcharType(5)))