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();
     }
   }
 

Reply via email to