This is an automated email from the ASF dual-hosted git repository. shuwenwei pushed a commit to branch fix/table-model-udf-classloader-lifecycle in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit c2b96252f871c0ecaac3a6c57923924cf96fa05c Author: shuwenwei <[email protected]> AuthorDate: Tue Nov 3 15:28:10 2026 +0800 Fix table model UDF classloader lifecycle --- .../fragment/FragmentInstanceContext.java | 20 ++++++++++++++ .../fragment/FragmentInstanceManager.java | 31 +++++++++++++++++----- .../operator/process/TransformOperator.java | 4 +-- .../queryengine/plan/execution/QueryExecution.java | 31 +++++++++++++++++++++- .../queryengine/plan/udf/UDFManagementService.java | 30 +++++++++++++-------- 5 files changed, 96 insertions(+), 20 deletions(-) diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/fragment/FragmentInstanceContext.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/fragment/FragmentInstanceContext.java index a060bd5b91b..84775f51132 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/fragment/FragmentInstanceContext.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/fragment/FragmentInstanceContext.java @@ -33,7 +33,9 @@ import org.apache.iotdb.commons.exception.IoTDBRuntimeException; import org.apache.iotdb.commons.path.AlignedFullPath; import org.apache.iotdb.commons.path.IFullPath; import org.apache.iotdb.commons.queryengine.common.SessionInfo; +import org.apache.iotdb.commons.queryengine.common.SqlDialect; import org.apache.iotdb.commons.queryengine.utils.TimestampPrecisionUtils; +import org.apache.iotdb.commons.udf.service.UDFClassLoaderManager; import org.apache.iotdb.commons.utils.TestOnly; import org.apache.iotdb.db.conf.IoTDBConfig; import org.apache.iotdb.db.conf.IoTDBDescriptor; @@ -116,6 +118,7 @@ public class FragmentInstanceContext extends QueryContext { private static final long LONG_WAIT_DURATION = 5_000_000_000L; private static final int MODS_MEMORY_ESTIMATE_READ_INTERVAL = 10_000; private final FragmentInstanceId id; + private boolean tableModelUDFQueryInitialized; private final FragmentInstanceStateMachine stateMachine; @@ -1348,6 +1351,7 @@ public class FragmentInstanceContext extends QueryContext { * be decreased. */ public synchronized void releaseResource() { + finalizeTableModelUDFQuery(); try { getQueryChunkReaders().close(); } catch (IOException e) { @@ -1493,6 +1497,22 @@ public class FragmentInstanceContext extends QueryContext { } } + public synchronized void initializeTableModelUDFQuery() { + if (!tableModelUDFQueryInitialized + && sessionInfo != null + && sessionInfo.getSqlDialect() == SqlDialect.TABLE) { + UDFClassLoaderManager.getInstance().initializeUDFQuery(id.getFullId()); + tableModelUDFQueryInitialized = true; + } + } + + public synchronized void finalizeTableModelUDFQuery() { + if (tableModelUDFQueryInitialized) { + UDFClassLoaderManager.getInstance().finalizeUDFQuery(id.getFullId()); + tableModelUDFQueryInitialized = false; + } + } + public void setMayHaveTmpFile(boolean mayHaveTmpFile) { this.mayHaveTmpFile = mayHaveTmpFile; } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/fragment/FragmentInstanceManager.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/fragment/FragmentInstanceManager.java index fa6a45e8374..b267bdba44d 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/fragment/FragmentInstanceManager.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/fragment/FragmentInstanceManager.java @@ -28,6 +28,8 @@ import org.apache.iotdb.commons.exception.IoTDBException; import org.apache.iotdb.commons.exception.IoTDBRuntimeException; import org.apache.iotdb.commons.exception.QueryTimeoutException; import org.apache.iotdb.commons.exception.SemanticException; +import org.apache.iotdb.commons.queryengine.common.SqlDialect; +import org.apache.iotdb.commons.queryengine.plan.udf.UDFManagementService; import org.apache.iotdb.db.conf.IoTDBDescriptor; import org.apache.iotdb.db.i18n.DataNodeQueryMessages; import org.apache.iotdb.db.queryengine.common.FragmentInstanceId; @@ -179,12 +181,28 @@ public class FragmentInstanceManager { context.setHighestPriority(instance.isHighestPriority()); try { - List<PipelineDriverFactory> driverFactories = - planner.plan( - instance.getFragment().getPlanNodeTree(), - instance.getFragment().getTypeProvider(), - context, - dataNodeQueryContexts[0]); + List<PipelineDriverFactory> driverFactories; + if (instance.getSessionInfo().getSqlDialect() == SqlDialect.TABLE) { + UDFManagementService.getInstance().acquireReadLock(); + try { + context.initializeTableModelUDFQuery(); + driverFactories = + planner.plan( + instance.getFragment().getPlanNodeTree(), + instance.getFragment().getTypeProvider(), + context, + dataNodeQueryContexts[0]); + } finally { + UDFManagementService.getInstance().releaseReadLock(); + } + } else { + driverFactories = + planner.plan( + instance.getFragment().getPlanNodeTree(), + instance.getFragment().getTypeProvider(), + context, + dataNodeQueryContexts[0]); + } List<IDriver> drivers = new ArrayList<>(); driverFactories.forEach(factory -> drivers.add(factory.createDriver())); @@ -235,6 +253,7 @@ public class FragmentInstanceManager { // still being created. Capture the failure result from the local context before // returning from computeIfAbsent instead of looking it up from the map later. failedInstanceInfo.set(context.getInstanceInfo()); + context.finalizeTableModelUDFQuery(); clearFIRelatedResources(instanceId); return null; } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/TransformOperator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/TransformOperator.java index 9a4526c5bfe..4d5724c4363 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/TransformOperator.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/operator/process/TransformOperator.java @@ -136,7 +136,7 @@ public class TransformOperator implements ProcessOperator { Map<String, List<InputLocation>> inputLocations, Expression[] outputExpressions, Map<NodeRef<Expression>, TSDataType> expressionTypes) { - UDFManagementService.getInstance().acquireLock(); + UDFManagementService.getInstance().acquireReadLock(); try { // This statement must be surrounded by the registration lock. UDFClassLoaderManager.getInstance().initializeUDFQuery(udtfQueryId); @@ -155,7 +155,7 @@ public class TransformOperator implements ProcessOperator { .buildResultColumnPointReaders() .getOutputReaders(); } finally { - UDFManagementService.getInstance().releaseLock(); + UDFManagementService.getInstance().releaseReadLock(); } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/QueryExecution.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/QueryExecution.java index 2324bea7877..528f7593f4b 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/QueryExecution.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/QueryExecution.java @@ -25,7 +25,9 @@ import org.apache.iotdb.commons.conf.IoTDBConstant; import org.apache.iotdb.commons.exception.IoTDBException; import org.apache.iotdb.commons.exception.IoTDBRuntimeException; import org.apache.iotdb.commons.queryengine.common.SqlDialect; +import org.apache.iotdb.commons.queryengine.plan.udf.UDFManagementService; import org.apache.iotdb.commons.service.metric.PerformanceOverviewMetrics; +import org.apache.iotdb.commons.udf.service.UDFClassLoaderManager; import org.apache.iotdb.db.conf.IoTDBConfig; import org.apache.iotdb.db.conf.IoTDBDescriptor; import org.apache.iotdb.db.exception.query.KilledByOthersException; @@ -49,6 +51,7 @@ import org.apache.iotdb.db.queryengine.plan.planner.plan.FragmentInstance; import org.apache.iotdb.db.queryengine.plan.planner.plan.LogicalQueryPlan; import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNodeUtil; import org.apache.iotdb.db.queryengine.plan.relational.metadata.spill.DeviceEntrySpillManager; +import org.apache.iotdb.db.queryengine.plan.relational.planner.TableModelPlanner; import org.apache.iotdb.db.queryengine.plan.scheduler.IScheduler; import org.apache.iotdb.db.utils.SetThreadName; import org.apache.iotdb.mpp.rpc.thrift.TFragmentInstanceId; @@ -109,6 +112,7 @@ public class QueryExecution implements IQueryExecution { private final AtomicBoolean resultHandleCleanUp; private final AtomicBoolean stopped; + private final Object tableUdfClassLoaderLock = new Object(); // cost time in ns of finished rpc private long totalExecutionTime = 0; @@ -164,6 +168,7 @@ public class QueryExecution implements IQueryExecution { // preventing a premature close raced with late-scheduled FragmentInstances. context.releaseExternalTsFileQueryResources(); this.stop(cause); + finalizeTableUDFClassLoader(); } }); this.stopped = new AtomicBoolean(false); @@ -332,7 +337,24 @@ public class QueryExecution implements IQueryExecution { // Analyze the statement in QueryContext. Generate the analysis this query need private IAnalysis analyze(MPPQueryContext context) { - return planner.analyze(context); + if (!(planner instanceof TableModelPlanner)) { + return planner.analyze(context); + } + String queryId = context.getQueryId().getId(); + UDFManagementService.getInstance().acquireReadLock(); + try { + synchronized (tableUdfClassLoaderLock) { + UDFClassLoaderManager.getInstance().initializeUDFQuery(queryId); + try { + return planner.analyze(context); + } catch (RuntimeException | Error e) { + finalizeTableUDFClassLoader(); + throw e; + } + } + } finally { + UDFManagementService.getInstance().releaseReadLock(); + } } private void schedule() { @@ -436,6 +458,7 @@ public class QueryExecution implements IQueryExecution { /** Release the resources that current QueryExecution hold with a specified exception */ private void releaseResource(Throwable t) { + finalizeTableUDFClassLoader(); context.recordDeviceEntryDiskIOMetricsOnRelease(); // close ResultHandle to unblock client's getResult request // Actually, we should not close the ResultHandle when the QueryExecution is Finished. @@ -466,6 +489,12 @@ public class QueryExecution implements IQueryExecution { } } + private void finalizeTableUDFClassLoader() { + synchronized (tableUdfClassLoaderLock) { + UDFClassLoaderManager.getInstance().finalizeUDFQuery(context.getQueryId().getId()); + } + } + /** * Clear up Coordinator.queryExecutionMap by calling Coordinator.cleanupQueryExecution if there is * no RPC in progress for this query (that is, the current RPC has finished and {@code diff --git a/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/queryengine/plan/udf/UDFManagementService.java b/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/queryengine/plan/udf/UDFManagementService.java index fd5dc23d77d..bd931fb9324 100644 --- a/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/queryengine/plan/udf/UDFManagementService.java +++ b/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/queryengine/plan/udf/UDFManagementService.java @@ -42,17 +42,17 @@ import org.slf4j.LoggerFactory; import java.io.IOException; import java.lang.reflect.InvocationTargetException; import java.nio.ByteBuffer; -import java.util.concurrent.locks.ReentrantLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; public class UDFManagementService { private static final Logger LOGGER = LoggerFactory.getLogger(UDFManagementService.class); - private final ReentrantLock lock; + private final ReentrantReadWriteLock lock; private final UDFTable udfTable; private UDFManagementService() { - lock = new ReentrantLock(); + lock = new ReentrantReadWriteLock(); udfTable = new UDFTable(); // register tree model built-in functions for (BuiltinTimeSeriesGeneratingFunction builtinTimeSeriesGeneratingFunction : @@ -69,23 +69,31 @@ public class UDFManagementService { } } - public void acquireLock() { - lock.lock(); + public void acquireReadLock() { + lock.readLock().lock(); } - public void releaseLock() { - lock.unlock(); + public void releaseReadLock() { + lock.readLock().unlock(); + } + + public void acquireWriteLock() { + lock.writeLock().lock(); + } + + public void releaseWriteLock() { + lock.writeLock().unlock(); } public void register(UDFInformation udfInformation, ByteBuffer jarFile) throws Exception { Model model = checkAndGetModel(udfInformation); try { - acquireLock(); + acquireWriteLock(); checkIfRegistered(model, udfInformation); saveJarFile(udfInformation.getJarName(), jarFile); doRegister(model, udfInformation); } finally { - releaseLock(); + releaseWriteLock(); } } @@ -206,7 +214,7 @@ public class UDFManagementService { public void deregister(Model model, String functionName, boolean needToDeleteJar) throws Exception { try { - acquireLock(); + acquireWriteLock(); UDFInformation information = udfTable.getUDFInformation(model, functionName); if (information == null) { return; @@ -219,7 +227,7 @@ public class UDFManagementService { .removeFileUnderTemporaryRoot(functionName.toUpperCase() + ".txt"); } } finally { - releaseLock(); + releaseWriteLock(); } }
