Add support for language function engines

Author: electrum

core/trino-main/src/main/java/io/trino/execution/CreateFunctionTask.java

@@ -33,19 +33,27 @@
 import io.trino.sql.tree.Expression;
 import io.trino.sql.tree.FunctionSpecification;
 import io.trino.sql.tree.Node;
+import io.trino.sql.tree.NodeRef;
+import io.trino.sql.tree.Parameter;
+import io.trino.sql.tree.PropertiesCharacteristic;
+import io.trino.sql.tree.Property;
 import io.trino.sql.tree.QualifiedName;
 
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.function.BiFunction;
 
+import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.util.concurrent.Futures.immediateVoidFuture;
+import static io.trino.execution.ParameterExtractor.bindParameters;
 import static io.trino.spi.StandardErrorCode.ALREADY_EXISTS;
 import static io.trino.spi.StandardErrorCode.GENERIC_INTERNAL_ERROR;
 import static io.trino.spi.StandardErrorCode.NOT_SUPPORTED;
 import static io.trino.spi.StandardErrorCode.SYNTAX_ERROR;
 import static io.trino.sql.SqlFormatter.formatSql;
 import static io.trino.sql.analyzer.SemanticExceptions.semanticException;
+import static io.trino.sql.routine.SqlRoutineAnalyzer.getProperties;
 import static io.trino.sql.routine.SqlRoutineAnalyzer.isRunAsInvoker;
 import static java.util.Objects.requireNonNull;
 
@@ -94,6 +102,8 @@ public ListenableFuture<Void> execute(CreateFunction statement, QueryStateMachin
 
         languageFunctionManager.verifyForCreate(session, function, functionManager, accessControl);
 
+        function = materializeFunctionProperties(session, function, bindParameters(statement, parameters));
+
         String signatureToken = languageFunctionManager.getSignatureToken(function.getParameters());
 
         String sql = functionToSql(function);
@@ -121,6 +131,32 @@ public ListenableFuture<Void> execute(CreateFunction statement, QueryStateMachin
         return immediateVoidFuture();
     }
 
+    private FunctionSpecification materializeFunctionProperties(Session session, FunctionSpecification function, Map<NodeRef<Parameter>, Expression> parameters)
+    {
+        List<Property> originalProperties = getProperties(function);
+        if (originalProperties.isEmpty()) {
+            return function;
+        }
+
+        List<Property> sqlProperties = languageFunctionManager.materializeFunctionProperties(session, function, parameters, accessControl);
+
+        return new FunctionSpecification(
+                function.getLocation().orElseThrow(),
+                function.getName(),
+                function.getParameters(),
+                function.getReturnsClause(),
+                function.getRoutineCharacteristics().stream()
+                        .map(characteristic -> {
+                            if (characteristic instanceof PropertiesCharacteristic) {
+                                return new PropertiesCharacteristic(characteristic.getLocation().orElseThrow(), sqlProperties);
+                            }
+                            return characteristic;
+                        })
+                        .collect(toImmutableList()),
+                function.getStatement(),
+                function.getDefinition());
+    }
+
     private String functionToSql(FunctionSpecification function)
     {
         String sql = formatSql(function);

core/trino-main/src/main/java/io/trino/metadata/LanguageFunctionDefinition.java

@@ -0,0 +1,39 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.trino.metadata;
+
+import com.google.common.collect.ImmutableMap;
+import io.trino.spi.type.Type;
+
+import java.util.List;
+import java.util.Map;
+
+import static java.util.Objects.requireNonNull;
+
+public record LanguageFunctionDefinition(
+        String language,
+        Type returnType,
+        List<Type> argumentTypes,
+        String definition,
+        Map<String, Object> properties)
+{
+    public LanguageFunctionDefinition
+    {
+        requireNonNull(language, "language is null");
+        requireNonNull(returnType, "returnType is null");
+        requireNonNull(argumentTypes, "argumentTypes is null");
+        requireNonNull(definition, "definition is null");
+        properties = ImmutableMap.copyOf(requireNonNull(properties, "properties is null"));
+    }
+}

core/trino-main/src/main/java/io/trino/metadata/LanguageFunctionEngineManager.java

@@ -0,0 +1,39 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.trino.metadata;
+
+import io.trino.spi.function.LanguageFunctionEngine;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static java.util.Locale.ENGLISH;
+
+public class LanguageFunctionEngineManager
+{
+    private final Map<String, LanguageFunctionEngine> languageFunctionEngines = new ConcurrentHashMap<>();
+
+    public Optional<LanguageFunctionEngine> getLanguageFunctionEngine(String language)
+    {
+        return Optional.ofNullable(languageFunctionEngines.get(language.toUpperCase(ENGLISH)));
+    }
+
+    public void addLanguageFunctionEngine(LanguageFunctionEngine engine)
+    {
+        if (languageFunctionEngines.putIfAbsent(engine.getLanguage().toUpperCase(ENGLISH), engine) != null) {
+            throw new IllegalArgumentException("Language function engine for language %s is already registered".formatted(engine.getLanguage()));
+        }
+    }
+}