From fd0846f313925c050e7d2cf78fd9ca1d4b7ece08 Mon Sep 17 00:00:00 2001 From: Weihao Li <18110526956@163.com> Date: Wed, 24 Jun 2026 02:19:53 +0800 Subject: [PATCH 01/11] draft Signed-off-by: Weihao Li <18110526956@163.com> --- .../org/apache/iotdb/udf/api/IoTDBLocal.java | 73 +++++++ .../apache/iotdb/udf/api/UDFResultSet.java | 45 +++++ .../udf/api/relational/AggregateFunction.java | 9 + .../udf/api/relational/ScalarFunction.java | 19 ++ .../relational/ColumnTransformerBuilder.java | 45 ++++- .../plan/planner/TableOperatorGenerator.java | 31 ++- .../UserDefineScalarFunctionTransformer.java | 23 ++- .../thrift/impl/ClientRPCServiceImpl.java | 4 +- .../db/queryengine/plan/Coordinator.java | 46 ++++- .../DataNodeTableOperatorGenerator.java | 37 +++- .../udf/InternalQueryExecutor.java | 126 ++++++++++++ .../queryengine/udf/InternalQueryResult.java | 43 ++++ .../db/queryengine/udf/IoTDBLocalImpl.java | 188 ++++++++++++++++++ .../udf/ScalarUdfExpressionDetector.java | 58 ++++++ .../db/queryengine/udf/UDFResultSetImpl.java | 123 ++++++++++++ 15 files changed, 857 insertions(+), 13 deletions(-) create mode 100644 iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/IoTDBLocal.java create mode 100644 iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/UDFResultSet.java create mode 100644 iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java create mode 100644 iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryResult.java create mode 100644 iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java create mode 100644 iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/ScalarUdfExpressionDetector.java create mode 100644 iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/UDFResultSetImpl.java diff --git a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/IoTDBLocal.java b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/IoTDBLocal.java new file mode 100644 index 0000000000000..0c96f919fc1b3 --- /dev/null +++ b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/IoTDBLocal.java @@ -0,0 +1,73 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.udf.api; + +import org.apache.iotdb.udf.api.exception.UDFException; + +/** + * Entry point for UDF-embedded SQL queries and logging, injected by the framework during UDF + * lifecycle. Reuses the outer query caller's user identity and permissions without extra client + * dependencies. + */ +public interface IoTDBLocal { + + /** + * Execute a single read-only table-model SQL statement and return a streaming result set. + * + * @param sql table-model read SQL (e.g. SELECT, SHOW CONFIGNODES) + * @return query result set; call {@link UDFResultSet#close()} when done or rely on framework + * cleanup + * @throws UDFException on parse failure, permission denied, or execution error + */ + UDFResultSet query(String sql) throws UDFException; + + /** Log at INFO level. */ + void info(String msg); + + /** Log at INFO level with formatting. */ + void info(String format, Object... args); + + /** Log at INFO level with exception stack. */ + void info(String msg, Throwable t); + + /** Log at WARN level. */ + void warn(String msg); + + /** Log at WARN level with formatting. */ + void warn(String format, Object... args); + + /** Log at WARN level with exception stack. */ + void warn(String msg, Throwable t); + + /** Log at ERROR level. */ + void error(String msg); + + /** Log at ERROR level with formatting. */ + void error(String format, Object... args); + + /** Log at ERROR level with exception stack. */ + void error(String msg, Throwable t); + + /** + * Release internal session and other resources. Called by the framework after beforeDestroy + * method. + */ + void close(); +} diff --git a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/UDFResultSet.java b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/UDFResultSet.java new file mode 100644 index 0000000000000..ed6d13442bf2b --- /dev/null +++ b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/UDFResultSet.java @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.udf.api; + +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.access.Record; + +/** Streaming result set returned by {@link IoTDBLocal#query(String)}. */ +public interface UDFResultSet extends AutoCloseable { + + /** + * @return {@code true} if another row is available + * @throws UDFException if underlying read fails + */ + boolean hasNext() throws UDFException; + + /** + * @return the next row + * @throws UDFException if underlying read fails + * @throws java.util.NoSuchElementException if no more rows (consistent with {@link + * java.util.Iterator}) + */ + Record next() throws UDFException; + + /** Release query resources. Repeated calls must be idempotent. */ + @Override + void close() throws UDFException; +} diff --git a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/AggregateFunction.java b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/AggregateFunction.java index 6c9d385ac2467..67fdb0aa2b1f0 100644 --- a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/AggregateFunction.java +++ b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/AggregateFunction.java @@ -19,6 +19,7 @@ package org.apache.iotdb.udf.api.relational; +import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.State; import org.apache.iotdb.udf.api.customizer.analysis.AggregateFunctionAnalysis; import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; @@ -58,6 +59,10 @@ default void beforeStart(FunctionArguments arguments) throws UDFException { // do nothing } + default void beforeStart(FunctionArguments arguments, IoTDBLocal local) throws UDFException { + beforeStart(arguments); + } + /** Create and initialize state. You may bind some resource in this method. */ State createState(); @@ -101,4 +106,8 @@ default void remove(State state, Record input) { default void beforeDestroy() { // do nothing } + + default void beforeDestroy(IoTDBLocal local) { + beforeDestroy(); + } } diff --git a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/ScalarFunction.java b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/ScalarFunction.java index 68d7793093d2a..e1daab6e4b0c1 100644 --- a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/ScalarFunction.java +++ b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/ScalarFunction.java @@ -19,6 +19,7 @@ package org.apache.iotdb.udf.api.relational; +import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.customizer.analysis.ScalarFunctionAnalysis; import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; @@ -54,6 +55,14 @@ default void beforeStart(FunctionArguments arguments) throws UDFException { // do nothing } + /** + * Same as {@link #beforeStart(FunctionArguments)} with access to {@link IoTDBLocal} for embedded + * queries. + */ + default void beforeStart(FunctionArguments arguments, IoTDBLocal local) throws UDFException { + beforeStart(arguments); + } + /** * This method will be called to process the transformation. In a single UDF query, this method * may be called multiple times. @@ -63,8 +72,18 @@ default void beforeStart(FunctionArguments arguments) throws UDFException { */ Object evaluate(Record input) throws UDFException; + /** Same as {@link #evaluate(Record)} with access to {@link IoTDBLocal} for embedded queries. */ + default Object evaluate(Record input, IoTDBLocal local) throws UDFException { + return evaluate(input); + } + /** This method is mainly used to release the resources used in the ScalarFunction. */ default void beforeDestroy() { // do nothing } + + /** Same as {@link #beforeDestroy()} with access to {@link IoTDBLocal}. */ + default void beforeDestroy(IoTDBLocal local) { + beforeDestroy(); + } } diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java index a25188361af2d..782222a13947f 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java @@ -198,6 +198,7 @@ import org.apache.iotdb.commons.queryengine.plan.udf.TableUDFUtils; import org.apache.iotdb.commons.udf.builtin.relational.TableBuiltinScalarFunction; import org.apache.iotdb.commons.udf.utils.UDFDataTypeTransformer; +import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.customizer.analysis.ScalarFunctionAnalysis; import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; import org.apache.iotdb.udf.api.relational.ScalarFunction; @@ -1489,11 +1490,16 @@ private ColumnTransformer getFunctionColumnTransformer( .collect(Collectors.toList()), Collections.emptyMap()); ScalarFunctionAnalysis analysis = scalarFunction.analyze(parameters); - scalarFunction.beforeStart(parameters); + Optional ioTDBLocal = context.getIoTDBLocal(); + if (ioTDBLocal.isPresent()) { + scalarFunction.beforeStart(parameters, ioTDBLocal.get()); + } else { + scalarFunction.beforeStart(parameters); + } Type returnType = UDFDataTypeTransformer.transformUDFDataTypeToReadType(analysis.getOutputDataType()); return new UserDefineScalarFunctionTransformer( - returnType, scalarFunction, childrenColumnTransformer); + returnType, scalarFunction, childrenColumnTransformer, ioTDBLocal.orElse(null)); } } throw new IllegalArgumentException( @@ -1954,6 +1960,8 @@ public static class Context { @SuppressWarnings("unused") private final Optional memoryReservationManager; + private final Optional ioTDBLocal; + public Context( SessionInfo sessionInfo, List leafList, @@ -1966,6 +1974,34 @@ public Context( ITableTypeProvider typeProvider, ITypeMetadata metadata, @Nullable MemoryReservationManager memoryReservationManager) { + this( + sessionInfo, + leafList, + inputLocations, + cache, + hasSeen, + commonTransformerList, + inputDataTypes, + originSize, + typeProvider, + metadata, + memoryReservationManager, + Optional.empty()); + } + + public Context( + SessionInfo sessionInfo, + List leafList, + Map> inputLocations, + Map cache, + Map hasSeen, + List commonTransformerList, + List inputDataTypes, + int originSize, + ITableTypeProvider typeProvider, + ITypeMetadata metadata, + @Nullable MemoryReservationManager memoryReservationManager, + Optional ioTDBLocal) { this.sessionInfo = sessionInfo; this.leafList = leafList; this.inputLocations = inputLocations; @@ -1977,6 +2013,11 @@ public Context( this.typeProvider = typeProvider; this.metadata = metadata; this.memoryReservationManager = Optional.ofNullable(memoryReservationManager); + this.ioTDBLocal = ioTDBLocal; + } + + public Optional getIoTDBLocal() { + return ioTDBLocal; } public Type getType(SymbolReference symbolReference) { diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java index bfac196461e3d..8b7f6cb714b00 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java @@ -169,6 +169,7 @@ import org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.Literal; import org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.SymbolReference; import org.apache.iotdb.commons.queryengine.plan.relational.type.InternalTypeManager; +import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.relational.TableFunction; import org.apache.iotdb.udf.api.relational.table.TableFunctionProcessorProvider; @@ -313,6 +314,30 @@ protected Operator constructFilterAndProjectOperator( Map> inputLocations, PlanNodeId planNodeId, C context) { + return constructFilterAndProjectOperator( + predicate, + inputOperator, + projectExpressions, + inputDataTypes, + inputLocations, + planNodeId, + context, + getIoTDBLocal(context, planNodeId)); + } + + protected Optional getIoTDBLocal(C context, PlanNodeId planNodeId) { + return Optional.empty(); + } + + protected Operator constructFilterAndProjectOperator( + Optional predicate, + Operator inputOperator, + Expression[] projectExpressions, + List inputDataTypes, + Map> inputLocations, + PlanNodeId planNodeId, + C context, + Optional ioTDBLocal) { final List filterOutputDataTypes = new ArrayList<>(inputDataTypes); @@ -341,7 +366,8 @@ protected Operator constructFilterAndProjectOperator( 0, context.getTableTypeProvider(), metadata, - context.getMemoryReservationManager()); + context.getMemoryReservationManager(), + ioTDBLocal); return visitor.process(p, filterColumnTransformerContext); }) @@ -369,7 +395,8 @@ protected Operator constructFilterAndProjectOperator( inputLocations.size(), context.getTableTypeProvider(), metadata, - context.getMemoryReservationManager()); + context.getMemoryReservationManager(), + ioTDBLocal); for (Expression expression : projectExpressions) { projectOutputTransformerList.add( diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java index 4e22315b62868..dd7c175774d43 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java @@ -22,6 +22,7 @@ import org.apache.iotdb.calc.execution.operator.source.relational.aggregation.RecordIterator; import org.apache.iotdb.calc.transformation.dag.column.ColumnTransformer; import org.apache.iotdb.calc.transformation.dag.column.multi.MultiColumnTransformer; +import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.relational.ScalarFunction; import org.apache.iotdb.udf.api.relational.access.Record; @@ -36,13 +37,16 @@ public class UserDefineScalarFunctionTransformer extends MultiColumnTransformer private final ScalarFunction scalarFunction; private final List inputTypes; + private final IoTDBLocal ioTDBLocal; public UserDefineScalarFunctionTransformer( Type returnType, ScalarFunction scalarFunction, - List childrenTransformers) { + List childrenTransformers, + IoTDBLocal ioTDBLocal) { super(returnType, childrenTransformers); this.scalarFunction = scalarFunction; + this.ioTDBLocal = ioTDBLocal; this.inputTypes = childrenTransformers.stream().map(ColumnTransformer::getType).collect(Collectors.toList()); } @@ -53,7 +57,10 @@ protected void doTransform( RecordIterator iterator = new RecordIterator(childrenColumns, inputTypes, positionCount); while (iterator.hasNext()) { try { - Object result = scalarFunction.evaluate(iterator.next()); + Object result = + ioTDBLocal != null + ? scalarFunction.evaluate(iterator.next(), ioTDBLocal) + : scalarFunction.evaluate(iterator.next()); if (result == null) { builder.appendNull(); } else { @@ -80,7 +87,10 @@ protected void doTransform( builder.appendNull(); continue; } - Object result = scalarFunction.evaluate(input); + Object result = + ioTDBLocal != null + ? scalarFunction.evaluate(input, ioTDBLocal) + : scalarFunction.evaluate(input); if (result == null) { builder.appendNull(); } else { @@ -98,7 +108,12 @@ protected void doTransform( @Override public void close() { super.close(); - scalarFunction.beforeDestroy(); + if (ioTDBLocal != null) { + scalarFunction.beforeDestroy(ioTDBLocal); + ioTDBLocal.close(); + } else { + scalarFunction.beforeDestroy(); + } } @Override diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java index 54ac31ce7f774..1aa14e053ea6e 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java @@ -562,7 +562,7 @@ private TSExecuteStatementResp executeStatementInternal( } } - private void clearUp( + private static void clearUp( IClientSession clientSession, Long statementId, Long queryId, @@ -572,7 +572,7 @@ private void clearUp( clientSession.removeQueryId(statementId, queryId); } - private void clearUp( + private static void clearUp( IClientSession clientSession, Long statementId, Long queryId, diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java index 73a09597cd594..45b8643d02ced 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java @@ -20,7 +20,6 @@ package org.apache.iotdb.db.queryengine.plan; import org.apache.iotdb.common.rpc.thrift.TEndPoint; -import org.apache.iotdb.commons.client.ClientPoolFactory; import org.apache.iotdb.commons.client.IClientManager; import org.apache.iotdb.commons.client.async.AsyncDataNodeInternalServiceClient; import org.apache.iotdb.commons.client.sync.SyncDataNodeInternalServiceClient; @@ -30,6 +29,7 @@ import org.apache.iotdb.commons.conf.CommonConfig; import org.apache.iotdb.commons.conf.CommonDescriptor; import org.apache.iotdb.commons.conf.IoTDBConstant; +import org.apache.iotdb.commons.exception.IoTDBException; import org.apache.iotdb.commons.exception.SemanticException; import org.apache.iotdb.commons.memory.IMemoryBlock; import org.apache.iotdb.commons.memory.MemoryBlockType; @@ -155,6 +155,7 @@ import org.apache.iotdb.db.queryengine.plan.statement.IConfigStatement; import org.apache.iotdb.db.queryengine.plan.statement.Statement; import org.apache.iotdb.db.queryengine.plan.statement.pipe.PipeEnrichedStatement; +import org.apache.iotdb.db.queryengine.udf.InternalQueryExecutor; import org.apache.iotdb.db.utils.SetThreadName; import org.apache.thrift.TBase; @@ -307,6 +308,18 @@ private ExecutionResult execution( boolean userQuery, boolean debug, BiFunction iQueryExecutionFactory) { + return execution(queryId, session, sql, userQuery, debug, false, iQueryExecutionFactory); + } + + private ExecutionResult execution( + long queryId, + SessionInfo session, + String sql, + boolean userQuery, + boolean debug, + boolean readOnlyInternalQuery, + BiFunction iQueryExecutionFactory) + throws IoTDBException { long startTime = System.currentTimeMillis(); QueryId globalQueryId = queryIdGenerator.createNextQueryId(); MPPQueryContext queryContext = null; @@ -325,6 +338,9 @@ private ExecutionResult execution( queryContext.setUserQuery(userQuery); queryContext.setDebug(debug); IQueryExecution execution = iQueryExecutionFactory.apply(queryContext, startTime); + if (readOnlyInternalQuery) { + InternalQueryExecutor.validateReadOnlyQuery(execution); + } if (execution.isQuery()) { queryExecutionMap.put(queryId, execution); } else { @@ -488,12 +504,40 @@ public ExecutionResult executeForTableModel( long timeOut, boolean userQuery, boolean debug) { + return executeForTableModel( + statement, + sqlParser, + clientSession, + queryId, + session, + sql, + metadata, + timeOut, + userQuery, + debug, + false); + } + + public ExecutionResult executeForTableModel( + org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.Statement statement, + SqlParser sqlParser, + IClientSession clientSession, + long queryId, + SessionInfo session, + String sql, + Metadata metadata, + long timeOut, + boolean userQuery, + boolean debug, + boolean readOnlyInternalQuery) + throws IoTDBException { return execution( queryId, session, sql, userQuery, debug, + readOnlyInternalQuery, ((queryContext, startTime) -> createQueryExecutionForTableModel( statement, diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java index 185c0d12c0632..9a2e35a8c1e50 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java @@ -68,7 +68,6 @@ import org.apache.iotdb.db.queryengine.execution.exchange.sink.ShuffleSinkHandle; import org.apache.iotdb.db.queryengine.execution.exchange.source.ISourceHandle; import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceManager; -import org.apache.iotdb.db.queryengine.execution.operator.EmptyDataOperator; import org.apache.iotdb.db.queryengine.execution.operator.ExplainAnalyzeOperator; import org.apache.iotdb.db.queryengine.execution.operator.OperatorContext; import org.apache.iotdb.db.queryengine.execution.operator.process.TableIntoOperator; @@ -132,13 +131,15 @@ import org.apache.iotdb.db.queryengine.plan.relational.planner.node.schema.TableDeviceQueryCountNode; import org.apache.iotdb.db.queryengine.plan.relational.planner.node.schema.TableDeviceQueryScanNode; import org.apache.iotdb.db.queryengine.plan.statement.component.Ordering; +import org.apache.iotdb.db.queryengine.udf.IoTDBLocalImpl; +import org.apache.iotdb.db.queryengine.udf.ScalarUdfExpressionDetector; import org.apache.iotdb.db.schemaengine.schemaregion.read.resp.info.IDeviceSchemaInfo; import org.apache.iotdb.db.schemaengine.table.DataNodeTableCache; import org.apache.iotdb.db.schemaengine.table.DataNodeTreeViewSchemaUtils; +import org.apache.iotdb.udf.api.IoTDBLocal; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; -import org.apache.tsfile.common.conf.TSFileDescriptor; import org.apache.tsfile.enums.TSDataType; import org.apache.tsfile.file.metadata.IDeviceID; import org.apache.tsfile.file.metadata.idcolumn.FourOrHigherLevelDBExtractor; @@ -2101,4 +2102,36 @@ private OptimizeType canUseLastCacheOptimize( protected SessionInfo getSessionInfo(LocalExecutionPlanContext context) { return context.getDriverContext().getFragmentInstanceContext().getSessionInfo(); } + + @Override + protected Optional getIoTDBLocal( + LocalExecutionPlanContext context, PlanNodeId planNodeId) { + return Optional.of( + IoTDBLocalImpl.create( + getSessionInfo(context), context.getFragmentInstanceId(), planNodeId)); + } + + @Override + protected Operator constructFilterAndProjectOperator( + Optional predicate, + Operator inputOperator, + Expression[] projectExpressions, + List inputDataTypes, + Map> inputLocations, + PlanNodeId planNodeId, + LocalExecutionPlanContext context) { + Optional ioTDBLocal = + ScalarUdfExpressionDetector.contains(predicate, projectExpressions) + ? getIoTDBLocal(context, planNodeId) + : Optional.empty(); + return constructFilterAndProjectOperator( + predicate, + inputOperator, + projectExpressions, + inputDataTypes, + inputLocations, + planNodeId, + context, + ioTDBLocal); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java new file mode 100644 index 0000000000000..5a31c5910f7ed --- /dev/null +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java @@ -0,0 +1,126 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.queryengine.udf; + +import org.apache.iotdb.commons.exception.IoTDBException; +import org.apache.iotdb.commons.exception.QueryTimeoutException; +import org.apache.iotdb.commons.exception.SemanticException; +import org.apache.iotdb.commons.queryengine.common.SessionInfo; +import org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.Statement; +import org.apache.iotdb.db.protocol.session.IClientSession; +import org.apache.iotdb.db.protocol.session.SessionManager; +import org.apache.iotdb.db.queryengine.plan.Coordinator; +import org.apache.iotdb.db.queryengine.plan.analyze.QueryType; +import org.apache.iotdb.db.queryengine.plan.execution.ExecutionResult; +import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution; +import org.apache.iotdb.db.queryengine.plan.planner.LocalExecutionPlanner; +import org.apache.iotdb.db.queryengine.plan.relational.metadata.Metadata; +import org.apache.iotdb.db.queryengine.plan.relational.sql.parser.SqlParser; +import org.apache.iotdb.rpc.TSStatusCode; + +/** Stateless utility for UDF embedded table-model queries. */ +public final class InternalQueryExecutor { + + private static final Coordinator COORDINATOR = Coordinator.getInstance(); + private static final SessionManager SESSION_MANAGER = SessionManager.getInstance(); + private static final Metadata METADATA = LocalExecutionPlanner.getInstance().metadata; + private static final SqlParser RELATION_SQL_PARSER = new SqlParser(); + + private InternalQueryExecutor() {} + + public static long computeRemainingTimeoutMs( + long outerQueryStartTimeMs, long outerQueryTimeoutMs) { + return outerQueryTimeoutMs - (System.currentTimeMillis() - outerQueryStartTimeMs); + } + + public static InternalQueryResult executeInternalQuery( + IClientSession internalSession, + SessionInfo sessionInfo, + String sql, + long outerQueryStartTimeMs, + long outerQueryTimeoutMs) + throws IoTDBException { + + long timeoutMs = computeRemainingTimeoutMs(outerQueryStartTimeMs, outerQueryTimeoutMs); + if (timeoutMs <= 0) { + throw new QueryTimeoutException( + "Outer query timeout exceeded before UDF internal query starts"); + } + + Statement parsedStatement = parseTableStatement(internalSession, sessionInfo, sql); + + long statementId = SESSION_MANAGER.requestStatementId(internalSession); + long queryId = SESSION_MANAGER.requestQueryId(internalSession, statementId); + + ExecutionResult result = + COORDINATOR.executeForTableModel( + parsedStatement, + RELATION_SQL_PARSER, + internalSession, + queryId, + sessionInfo, + sql, + METADATA, + timeoutMs, + false, + false, + true); + + if (result.status.code != TSStatusCode.SUCCESS_STATUS.getStatusCode() + && result.status.code != TSStatusCode.REDIRECTION_RECOMMEND.getStatusCode()) { + COORDINATOR.cleanupQueryExecution(queryId, () -> sql, null); + internalSession.removeQueryId(statementId, queryId); + throw new IoTDBException(result.status.message, result.status.code); + } + + IQueryExecution queryExecution = COORDINATOR.getQueryExecution(queryId); + if (queryExecution == null) { + COORDINATOR.cleanupQueryExecution(queryId, () -> sql, null); + internalSession.removeQueryId(statementId, queryId); + throw new IoTDBException( + "Internal query execution not found", TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode()); + } + + return new InternalQueryResult( + queryExecution, + () -> { + COORDINATOR.cleanupQueryExecution(queryId, () -> sql, null); + internalSession.removeQueryId(statementId, queryId); + }); + } + + static void validateReadOnlyQuery(IQueryExecution execution) throws IoTDBException { + if (execution.getQueryType() != QueryType.READ) { + execution.stopAndCleanup(null); + throw new SemanticException("Only query is allowed when used IoTDBLocal in UDF"); + } + } + + private static Statement parseTableStatement( + IClientSession internalSession, SessionInfo sessionInfo, String sql) throws IoTDBException { + try { + Statement statement = + RELATION_SQL_PARSER.createStatement(sql, sessionInfo.getZoneId(), internalSession); + return statement; + } catch (Exception e) { + throw new IoTDBException(e.getMessage(), TSStatusCode.SQL_PARSE_ERROR.getStatusCode()); + } + } +} diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryResult.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryResult.java new file mode 100644 index 0000000000000..9f35fa9561899 --- /dev/null +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryResult.java @@ -0,0 +1,43 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.queryengine.udf; + +import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution; + +/** Internal query result holding {@link IQueryExecution} and a cleanup action. */ +public final class InternalQueryResult implements AutoCloseable { + + private final IQueryExecution queryExecution; + private final Runnable releaseAction; + + public InternalQueryResult(IQueryExecution queryExecution, Runnable releaseAction) { + this.queryExecution = queryExecution; + this.releaseAction = releaseAction; + } + + public IQueryExecution getQueryExecution() { + return queryExecution; + } + + @Override + public void close() { + releaseAction.run(); + } +} diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java new file mode 100644 index 0000000000000..32540b20e0664 --- /dev/null +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java @@ -0,0 +1,188 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.queryengine.udf; + +import org.apache.iotdb.commons.conf.IoTDBConstant.ClientVersion; +import org.apache.iotdb.commons.exception.IoTDBException; +import org.apache.iotdb.commons.queryengine.common.SessionInfo; +import org.apache.iotdb.commons.queryengine.plan.planner.plan.node.PlanNodeId; +import org.apache.iotdb.db.protocol.session.InternalClientSession; +import org.apache.iotdb.db.protocol.session.SessionManager; +import org.apache.iotdb.db.queryengine.common.FragmentInstanceId; +import org.apache.iotdb.db.queryengine.plan.Coordinator; +import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution; +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.exception.UDFException; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.List; + +/** Server-side implementation of {@link IoTDBLocal}. */ +public class IoTDBLocalImpl implements IoTDBLocal { + + private static final Logger LOGGER = LoggerFactory.getLogger(IoTDBLocalImpl.class); + private static final SessionManager SESSION_MANAGER = SessionManager.getInstance(); + private static final Coordinator COORDINATOR = Coordinator.getInstance(); + + private final SessionInfo sessionInfo; + private final InternalClientSession internalSession; + private final long outerQueryStartTimeMs; + private final long outerQueryTimeoutMs; + private final List openResultSets = new ArrayList<>(); + private boolean closed; + + public IoTDBLocalImpl( + SessionInfo sessionInfo, + String internalClientId, + long outerQueryStartTimeMs, + long outerQueryTimeoutMs) { + this.sessionInfo = sessionInfo; + this.outerQueryStartTimeMs = outerQueryStartTimeMs; + this.outerQueryTimeoutMs = outerQueryTimeoutMs; + this.internalSession = new InternalClientSession(internalClientId); + internalSession.setSqlDialect(sessionInfo.getSqlDialect()); + sessionInfo.getDatabaseName().ifPresent(internalSession::setDatabaseName); + SESSION_MANAGER.supplySession( + internalSession, + sessionInfo.getUserId(), + sessionInfo.getUserName(), + sessionInfo.getZoneId(), + ClientVersion.V_1_0); + } + + public static String formatInternalClientId( + FragmentInstanceId fragmentInstanceId, PlanNodeId planNodeId) { + return "udf-local-" + fragmentInstanceId + "-" + planNodeId; + } + + public static IoTDBLocalImpl create( + SessionInfo sessionInfo, FragmentInstanceId fragmentInstanceId, PlanNodeId planNodeId) { + long outerStart = System.currentTimeMillis(); + long outerTimeout = + org.apache.iotdb.db.conf.IoTDBDescriptor.getInstance() + .getConfig() + .getQueryTimeoutThreshold(); + String globalQueryId = fragmentInstanceId.getQueryId().getId(); + for (IQueryExecution execution : COORDINATOR.getAllQueryExecutions()) { + if (globalQueryId.equals(execution.getQueryId())) { + outerStart = execution.getStartExecutionTime(); + outerTimeout = execution.getTimeout(); + break; + } + } + return new IoTDBLocalImpl( + sessionInfo, + formatInternalClientId(fragmentInstanceId, planNodeId), + outerStart, + outerTimeout); + } + + @Override + public UDFResultSet query(String sql) throws UDFException { + if (closed) { + throw new UDFException("IoTDBLocal is already closed"); + } + try { + InternalQueryResult result = + InternalQueryExecutor.executeInternalQuery( + internalSession, sessionInfo, sql, outerQueryStartTimeMs, outerQueryTimeoutMs); + int index = openResultSets.size(); + UDFResultSetImpl rs = new UDFResultSetImpl(result, this, index); + openResultSets.add(rs); + return rs; + } catch (IoTDBException e) { + throw new UDFException(e.getMessage(), e); + } + } + + void markResultSetClosed(int index) { + if (index >= 0 && index < openResultSets.size()) { + openResultSets.set(index, null); + } + } + + public void closeAllResultSets() { + for (UDFResultSetImpl rs : openResultSets) { + if (rs != null) { + rs.close(); + } + } + openResultSets.clear(); + } + + @Override + public void close() { + if (closed) { + return; + } + closed = true; + closeAllResultSets(); + SESSION_MANAGER.closeSession(internalSession, COORDINATOR::cleanupQueryExecution); + } + + @Override + public void info(String msg) { + LOGGER.info(msg); + } + + @Override + public void info(String format, Object... args) { + LOGGER.info(format, args); + } + + @Override + public void info(String msg, Throwable t) { + LOGGER.info(msg, t); + } + + @Override + public void warn(String msg) { + LOGGER.warn(msg); + } + + @Override + public void warn(String format, Object... args) { + LOGGER.warn(format, args); + } + + @Override + public void warn(String msg, Throwable t) { + LOGGER.warn(msg, t); + } + + @Override + public void error(String msg) { + LOGGER.error(msg); + } + + @Override + public void error(String format, Object... args) { + LOGGER.error(format, args); + } + + @Override + public void error(String msg, Throwable t) { + LOGGER.error(msg, t); + } +} diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/ScalarUdfExpressionDetector.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/ScalarUdfExpressionDetector.java new file mode 100644 index 0000000000000..cf87bee846a77 --- /dev/null +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/ScalarUdfExpressionDetector.java @@ -0,0 +1,58 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.queryengine.udf; + +import org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.Expression; +import org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.FunctionCall; +import org.apache.iotdb.commons.queryengine.plan.udf.TableUDFUtils; +import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.DefaultTraversalVisitor; + +import java.util.Optional; + +/** Detects whether filter or project expressions contain a user-defined scalar function. */ +public final class ScalarUdfExpressionDetector extends DefaultTraversalVisitor { + + private boolean found; + + private ScalarUdfExpressionDetector() {} + + public static boolean contains(Optional predicate, Expression[] projectExpressions) { + ScalarUdfExpressionDetector detector = new ScalarUdfExpressionDetector(); + if (predicate.isPresent()) { + detector.process(predicate.get(), null); + } + for (Expression expression : projectExpressions) { + if (detector.found) { + return true; + } + detector.process(expression, null); + } + return detector.found; + } + + @Override + public Void visitFunctionCall(FunctionCall node, Void context) { + if (TableUDFUtils.isScalarFunction(node.getName().getSuffix())) { + found = true; + return null; + } + return super.visitFunctionCall(node, context); + } +} diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/UDFResultSetImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/UDFResultSetImpl.java new file mode 100644 index 0000000000000..647e0115a6497 --- /dev/null +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/UDFResultSetImpl.java @@ -0,0 +1,123 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.queryengine.udf; + +import org.apache.iotdb.calc.execution.operator.source.relational.aggregation.RecordIterator; +import org.apache.iotdb.commons.exception.IoTDBException; +import org.apache.iotdb.commons.schema.column.ColumnHeader; +import org.apache.iotdb.commons.udf.utils.UDFDataTypeTransformer; +import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.access.Record; + +import org.apache.tsfile.read.common.block.TsBlock; +import org.apache.tsfile.read.common.type.Type; + +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.Optional; +import java.util.stream.Collectors; + +/** Server-side implementation of {@link UDFResultSet}. */ +public class UDFResultSetImpl implements UDFResultSet { + + private final InternalQueryResult queryResult; + private final IoTDBLocalImpl owner; + private final int index; + + private Iterator rowIterator; + private final List columnTypes; + private boolean closed; + + public UDFResultSetImpl(InternalQueryResult queryResult, IoTDBLocalImpl owner, int index) { + this.queryResult = queryResult; + this.owner = owner; + this.index = index; + this.columnTypes = buildColumnTypes(queryResult.getQueryExecution()); + } + + @Override + public boolean hasNext() throws UDFException { + ensureOpen(); + + while (rowIterator == null || !rowIterator.hasNext()) { + if (!queryResult.getQueryExecution().hasNextResult()) { + return false; + } + Optional batch; + try { + batch = queryResult.getQueryExecution().getBatchResult(); + } catch (IoTDBException e) { + throw new UDFException(e.getMessage()); + } + if (!batch.isPresent()) { + return false; + } + TsBlock currentBlock = batch.get(); + rowIterator = + new RecordIterator( + Arrays.asList(currentBlock.getValueColumns()), + columnTypes, + currentBlock.getPositionCount()); + } + return true; + } + + @Override + public Record next() throws UDFException { + ensureOpen(); + + if (rowIterator == null || !rowIterator.hasNext()) { + throw new NoSuchElementException(); + } + return rowIterator.next(); + } + + @Override + public void close() throws UDFException { + if (closed) { + return; + } + closed = true; + try { + queryResult.close(); + } catch (RuntimeException e) { + throw new UDFException("Failed to close internal query result", e); + } + owner.markResultSetClosed(index); + } + + private void ensureOpen() throws UDFException { + if (closed) { + throw new UDFException("UDFResultSet is already closed"); + } + } + + private static List buildColumnTypes(IQueryExecution queryExecution) { + return queryExecution.getDatasetHeader().getColumnHeaders().stream() + .map(ColumnHeader::getColumnType) + .map(UDFDataTypeTransformer::transformToUDFDataType) + .map(UDFDataTypeTransformer::transformUDFDataTypeToReadType) + .collect(Collectors.toList()); + } +} From 794cc603cc3d06efa5fc7e66fa9f4b939d3b6451 Mon Sep 17 00:00:00 2001 From: Weihao Li <18110526956@163.com> Date: Wed, 24 Jun 2026 11:48:15 +0800 Subject: [PATCH 02/11] modify some Signed-off-by: Weihao Li <18110526956@163.com> --- .../org/apache/iotdb/udf/api/IoTDBLocal.java | 5 +- .../relational/ColumnTransformerBuilder.java | 45 ++++-- .../plan/planner/TableOperatorGenerator.java | 53 +++---- .../UserDefineScalarFunctionTransformer.java | 34 ++++- .../db/protocol/session/SessionManager.java | 17 +++ .../thrift/impl/ClientRPCServiceImpl.java | 2 +- .../db/queryengine/plan/Coordinator.java | 33 +---- .../DataNodeTableOperatorGenerator.java | 40 ++---- .../udf/InternalQueryExecutor.java | 129 +++++++++--------- .../queryengine/udf/InternalQueryResult.java | 32 ++++- .../db/queryengine/udf/IoTDBLocalImpl.java | 111 +++++---------- .../udf/ScalarUdfExpressionDetector.java | 58 -------- .../db/queryengine/udf/UDFResultSetImpl.java | 28 ++-- 13 files changed, 264 insertions(+), 323 deletions(-) delete mode 100644 iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/ScalarUdfExpressionDetector.java diff --git a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/IoTDBLocal.java b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/IoTDBLocal.java index 0c96f919fc1b3..b84cb45965a6b 100644 --- a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/IoTDBLocal.java +++ b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/IoTDBLocal.java @@ -65,9 +65,6 @@ public interface IoTDBLocal { /** Log at ERROR level with exception stack. */ void error(String msg, Throwable t); - /** - * Release internal session and other resources. Called by the framework after beforeDestroy - * method. - */ + /** Close internal session. Called by the framework after beforeDestroy method. */ void close(); } diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java index 782222a13947f..ba0464b07777d 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java @@ -20,6 +20,7 @@ package org.apache.iotdb.calc.execution.relational; import org.apache.iotdb.calc.i18n.CalcMessages; +import org.apache.iotdb.calc.plan.planner.TableOperatorGenerator.IoTDBLocalFactory; import org.apache.iotdb.calc.plan.planner.memory.MemoryReservationManager; import org.apache.iotdb.calc.plan.relational.metadata.ITypeMetadata; import org.apache.iotdb.calc.transformation.dag.column.ColumnTransformer; @@ -198,7 +199,6 @@ import org.apache.iotdb.commons.queryengine.plan.udf.TableUDFUtils; import org.apache.iotdb.commons.udf.builtin.relational.TableBuiltinScalarFunction; import org.apache.iotdb.commons.udf.utils.UDFDataTypeTransformer; -import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.customizer.analysis.ScalarFunctionAnalysis; import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; import org.apache.iotdb.udf.api.relational.ScalarFunction; @@ -1490,16 +1490,10 @@ private ColumnTransformer getFunctionColumnTransformer( .collect(Collectors.toList()), Collections.emptyMap()); ScalarFunctionAnalysis analysis = scalarFunction.analyze(parameters); - Optional ioTDBLocal = context.getIoTDBLocal(); - if (ioTDBLocal.isPresent()) { - scalarFunction.beforeStart(parameters, ioTDBLocal.get()); - } else { - scalarFunction.beforeStart(parameters); - } Type returnType = UDFDataTypeTransformer.transformUDFDataTypeToReadType(analysis.getOutputDataType()); return new UserDefineScalarFunctionTransformer( - returnType, scalarFunction, childrenColumnTransformer, ioTDBLocal.orElse(null)); + returnType, scalarFunction, childrenColumnTransformer, parameters, context); } } throw new IllegalArgumentException( @@ -1960,7 +1954,11 @@ public static class Context { @SuppressWarnings("unused") private final Optional memoryReservationManager; - private final Optional ioTDBLocal; + private final String fragmentInstanceId; + + private final String outerQueryId; + + @Nullable private final IoTDBLocalFactory ioTDBLocalFactory; public Context( SessionInfo sessionInfo, @@ -1986,7 +1984,9 @@ public Context( typeProvider, metadata, memoryReservationManager, - Optional.empty()); + null, + null, + null); } public Context( @@ -2001,7 +2001,9 @@ public Context( ITableTypeProvider typeProvider, ITypeMetadata metadata, @Nullable MemoryReservationManager memoryReservationManager, - Optional ioTDBLocal) { + String fragmentInstanceId, + String outerQueryId, + @Nullable IoTDBLocalFactory ioTDBLocalFactory) { this.sessionInfo = sessionInfo; this.leafList = leafList; this.inputLocations = inputLocations; @@ -2013,11 +2015,26 @@ public Context( this.typeProvider = typeProvider; this.metadata = metadata; this.memoryReservationManager = Optional.ofNullable(memoryReservationManager); - this.ioTDBLocal = ioTDBLocal; + this.fragmentInstanceId = fragmentInstanceId; + this.outerQueryId = outerQueryId; + this.ioTDBLocalFactory = ioTDBLocalFactory; + } + + public SessionInfo getSessionInfo() { + return sessionInfo; + } + + public String getFragmentInstanceId() { + return fragmentInstanceId; + } + + public String getOuterQueryId() { + return outerQueryId; } - public Optional getIoTDBLocal() { - return ioTDBLocal; + @Nullable + public IoTDBLocalFactory getIoTDBLocalFactory() { + return ioTDBLocalFactory; } public Type getType(SymbolReference symbolReference) { diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java index 8b7f6cb714b00..6454bd38d472e 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java @@ -314,30 +314,10 @@ protected Operator constructFilterAndProjectOperator( Map> inputLocations, PlanNodeId planNodeId, C context) { - return constructFilterAndProjectOperator( - predicate, - inputOperator, - projectExpressions, - inputDataTypes, - inputLocations, - planNodeId, - context, - getIoTDBLocal(context, planNodeId)); - } - protected Optional getIoTDBLocal(C context, PlanNodeId planNodeId) { - return Optional.empty(); - } - - protected Operator constructFilterAndProjectOperator( - Optional predicate, - Operator inputOperator, - Expression[] projectExpressions, - List inputDataTypes, - Map> inputLocations, - PlanNodeId planNodeId, - C context, - Optional ioTDBLocal) { + String fragmentInstanceId = getFragmentInstanceId(context); + String outerQueryId = getQueryId(context); + IoTDBLocalFactory ioTDBLocalFactory = getIoTDBLocalFactory(context); final List filterOutputDataTypes = new ArrayList<>(inputDataTypes); @@ -367,7 +347,9 @@ protected Operator constructFilterAndProjectOperator( context.getTableTypeProvider(), metadata, context.getMemoryReservationManager(), - ioTDBLocal); + fragmentInstanceId, + outerQueryId, + ioTDBLocalFactory); return visitor.process(p, filterColumnTransformerContext); }) @@ -396,7 +378,9 @@ protected Operator constructFilterAndProjectOperator( context.getTableTypeProvider(), metadata, context.getMemoryReservationManager(), - ioTDBLocal); + fragmentInstanceId, + outerQueryId, + ioTDBLocalFactory); for (Expression expression : projectExpressions) { projectOutputTransformerList.add( @@ -420,6 +404,18 @@ protected Operator constructFilterAndProjectOperator( predicate.isPresent()); } + protected String getFragmentInstanceId(C context) { + return null; + } + + protected String getQueryId(C context) { + return null; + } + + protected IoTDBLocalFactory getIoTDBLocalFactory(C context) { + return null; + } + @Override public Operator visitProject(ProjectNode node, C context) { ITableTypeProvider typeProvider = context.getTableTypeProvider(); @@ -2494,4 +2490,11 @@ public Operator visitTopKRanking(TopKRankingNode node, C context) { } protected abstract SessionInfo getSessionInfo(C context); + + /** Factory for creating {@link IoTDBLocal} inside UDF column transformers. */ + @FunctionalInterface + public interface IoTDBLocalFactory { + + IoTDBLocal create(SessionInfo sessionInfo, String fragmentInstanceId, String queryId); + } } diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java index dd7c175774d43..ab2f99031d278 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java @@ -20,9 +20,13 @@ package org.apache.iotdb.calc.transformation.dag.column.udf; import org.apache.iotdb.calc.execution.operator.source.relational.aggregation.RecordIterator; +import org.apache.iotdb.calc.execution.relational.ColumnTransformerBuilder; +import org.apache.iotdb.calc.plan.planner.TableOperatorGenerator.IoTDBLocalFactory; import org.apache.iotdb.calc.transformation.dag.column.ColumnTransformer; import org.apache.iotdb.calc.transformation.dag.column.multi.MultiColumnTransformer; import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFException; import org.apache.iotdb.udf.api.relational.ScalarFunction; import org.apache.iotdb.udf.api.relational.access.Record; @@ -43,12 +47,36 @@ public UserDefineScalarFunctionTransformer( Type returnType, ScalarFunction scalarFunction, List childrenTransformers, - IoTDBLocal ioTDBLocal) { + FunctionArguments parameters, + ColumnTransformerBuilder.Context context) { super(returnType, childrenTransformers); this.scalarFunction = scalarFunction; - this.ioTDBLocal = ioTDBLocal; + this.ioTDBLocal = createIoTDBLocal(context); this.inputTypes = childrenTransformers.stream().map(ColumnTransformer::getType).collect(Collectors.toList()); + try { + if (ioTDBLocal != null) { + scalarFunction.beforeStart(parameters, ioTDBLocal); + } else { + scalarFunction.beforeStart(parameters); + } + } catch (UDFException e) { + throw new RuntimeException( + "Error occurs when starting user-defined scalar function " + + scalarFunction.getClass().getName(), + e); + } + } + + private static IoTDBLocal createIoTDBLocal(ColumnTransformerBuilder.Context context) { + IoTDBLocalFactory factory = context.getIoTDBLocalFactory(); + if (factory == null + || context.getFragmentInstanceId() == null + || context.getOuterQueryId() == null) { + return null; + } + return factory.create( + context.getSessionInfo(), context.getFragmentInstanceId(), context.getOuterQueryId()); } @Override @@ -109,8 +137,8 @@ protected void doTransform( public void close() { super.close(); if (ioTDBLocal != null) { - scalarFunction.beforeDestroy(ioTDBLocal); ioTDBLocal.close(); + scalarFunction.beforeDestroy(ioTDBLocal); } else { scalarFunction.beforeDestroy(); } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/session/SessionManager.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/session/SessionManager.java index b3fa3c049f363..04ddf7f4b9f62 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/session/SessionManager.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/session/SessionManager.java @@ -369,6 +369,23 @@ public IClientSession getCurrSession() { return currSession.get(); } + /** + * Swap the ThreadLocal session and return the previous one. Used by UDF internal queries to + * temporarily install an internal session without removing the previous session from the session + * map. + */ + public IClientSession exchangeCurrSession(IClientSession session) { + IClientSession previous = currSession.get(); + if (session != null) { + currSession.set(session); + sessions.putIfAbsent(session, placeHolder); + } else { + currSession.remove(); + currSessionIdleTime.remove(); + } + return previous; + } + /** get current session and update session idle time. */ public IClientSession getCurrSessionAndUpdateIdleTime() { IClientSession clientSession = getCurrSession(); diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java index 1aa14e053ea6e..d940d2260968f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java @@ -562,7 +562,7 @@ private TSExecuteStatementResp executeStatementInternal( } } - private static void clearUp( + public static void clearUp( IClientSession clientSession, Long statementId, Long queryId, diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java index 45b8643d02ced..402424d1f6914 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan; import org.apache.iotdb.common.rpc.thrift.TEndPoint; +import org.apache.iotdb.commons.client.ClientPoolFactory; import org.apache.iotdb.commons.client.IClientManager; import org.apache.iotdb.commons.client.async.AsyncDataNodeInternalServiceClient; import org.apache.iotdb.commons.client.sync.SyncDataNodeInternalServiceClient; @@ -29,7 +30,6 @@ import org.apache.iotdb.commons.conf.CommonConfig; import org.apache.iotdb.commons.conf.CommonDescriptor; import org.apache.iotdb.commons.conf.IoTDBConstant; -import org.apache.iotdb.commons.exception.IoTDBException; import org.apache.iotdb.commons.exception.SemanticException; import org.apache.iotdb.commons.memory.IMemoryBlock; import org.apache.iotdb.commons.memory.MemoryBlockType; @@ -318,8 +318,7 @@ private ExecutionResult execution( boolean userQuery, boolean debug, boolean readOnlyInternalQuery, - BiFunction iQueryExecutionFactory) - throws IoTDBException { + BiFunction iQueryExecutionFactory) { long startTime = System.currentTimeMillis(); QueryId globalQueryId = queryIdGenerator.createNextQueryId(); MPPQueryContext queryContext = null; @@ -504,40 +503,12 @@ public ExecutionResult executeForTableModel( long timeOut, boolean userQuery, boolean debug) { - return executeForTableModel( - statement, - sqlParser, - clientSession, - queryId, - session, - sql, - metadata, - timeOut, - userQuery, - debug, - false); - } - - public ExecutionResult executeForTableModel( - org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.Statement statement, - SqlParser sqlParser, - IClientSession clientSession, - long queryId, - SessionInfo session, - String sql, - Metadata metadata, - long timeOut, - boolean userQuery, - boolean debug, - boolean readOnlyInternalQuery) - throws IoTDBException { return execution( queryId, session, sql, userQuery, debug, - readOnlyInternalQuery, ((queryContext, startTime) -> createQueryExecutionForTableModel( statement, diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java index 9a2e35a8c1e50..97383309a485c 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java @@ -28,6 +28,7 @@ import org.apache.iotdb.calc.execution.operator.source.relational.aggregation.TableAggregator; import org.apache.iotdb.calc.execution.relational.ColumnTransformerBuilder; import org.apache.iotdb.calc.plan.planner.TableOperatorGenerator; +import org.apache.iotdb.calc.plan.planner.TableOperatorGenerator.IoTDBLocalFactory; import org.apache.iotdb.calc.transformation.dag.column.leaf.LeafColumnTransformer; import org.apache.iotdb.calc.transformation.dag.column.unary.scalar.DateBinFunctionColumnTransformer; import org.apache.iotdb.common.rpc.thrift.TEndPoint; @@ -68,6 +69,7 @@ import org.apache.iotdb.db.queryengine.execution.exchange.sink.ShuffleSinkHandle; import org.apache.iotdb.db.queryengine.execution.exchange.source.ISourceHandle; import org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceManager; +import org.apache.iotdb.db.queryengine.execution.operator.EmptyDataOperator; import org.apache.iotdb.db.queryengine.execution.operator.ExplainAnalyzeOperator; import org.apache.iotdb.db.queryengine.execution.operator.OperatorContext; import org.apache.iotdb.db.queryengine.execution.operator.process.TableIntoOperator; @@ -132,14 +134,13 @@ import org.apache.iotdb.db.queryengine.plan.relational.planner.node.schema.TableDeviceQueryScanNode; import org.apache.iotdb.db.queryengine.plan.statement.component.Ordering; import org.apache.iotdb.db.queryengine.udf.IoTDBLocalImpl; -import org.apache.iotdb.db.queryengine.udf.ScalarUdfExpressionDetector; import org.apache.iotdb.db.schemaengine.schemaregion.read.resp.info.IDeviceSchemaInfo; import org.apache.iotdb.db.schemaengine.table.DataNodeTableCache; import org.apache.iotdb.db.schemaengine.table.DataNodeTreeViewSchemaUtils; -import org.apache.iotdb.udf.api.IoTDBLocal; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; +import org.apache.tsfile.common.conf.TSFileDescriptor; import org.apache.tsfile.enums.TSDataType; import org.apache.tsfile.file.metadata.IDeviceID; import org.apache.tsfile.file.metadata.idcolumn.FourOrHigherLevelDBExtractor; @@ -2104,34 +2105,17 @@ protected SessionInfo getSessionInfo(LocalExecutionPlanContext context) { } @Override - protected Optional getIoTDBLocal( - LocalExecutionPlanContext context, PlanNodeId planNodeId) { - return Optional.of( - IoTDBLocalImpl.create( - getSessionInfo(context), context.getFragmentInstanceId(), planNodeId)); + protected String getFragmentInstanceId(LocalExecutionPlanContext context) { + return context.getFragmentInstanceId().getFullId(); } @Override - protected Operator constructFilterAndProjectOperator( - Optional predicate, - Operator inputOperator, - Expression[] projectExpressions, - List inputDataTypes, - Map> inputLocations, - PlanNodeId planNodeId, - LocalExecutionPlanContext context) { - Optional ioTDBLocal = - ScalarUdfExpressionDetector.contains(predicate, projectExpressions) - ? getIoTDBLocal(context, planNodeId) - : Optional.empty(); - return constructFilterAndProjectOperator( - predicate, - inputOperator, - projectExpressions, - inputDataTypes, - inputLocations, - planNodeId, - context, - ioTDBLocal); + protected String getQueryId(LocalExecutionPlanContext context) { + return context.getFragmentInstanceId().getQueryId().getId(); + } + + @Override + protected IoTDBLocalFactory getIoTDBLocalFactory(LocalExecutionPlanContext context) { + return IoTDBLocalImpl.FACTORY; } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java index 5a31c5910f7ed..328542d05c143 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java @@ -20,12 +20,14 @@ package org.apache.iotdb.db.queryengine.udf; import org.apache.iotdb.commons.exception.IoTDBException; -import org.apache.iotdb.commons.exception.QueryTimeoutException; import org.apache.iotdb.commons.exception.SemanticException; import org.apache.iotdb.commons.queryengine.common.SessionInfo; import org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.Statement; import org.apache.iotdb.db.protocol.session.IClientSession; +import org.apache.iotdb.db.protocol.session.InternalClientSession; import org.apache.iotdb.db.protocol.session.SessionManager; +import org.apache.iotdb.db.protocol.thrift.impl.ClientRPCServiceImpl; +import org.apache.iotdb.db.queryengine.common.QueryId; import org.apache.iotdb.db.queryengine.plan.Coordinator; import org.apache.iotdb.db.queryengine.plan.analyze.QueryType; import org.apache.iotdb.db.queryengine.plan.execution.ExecutionResult; @@ -45,82 +47,79 @@ public final class InternalQueryExecutor { private InternalQueryExecutor() {} - public static long computeRemainingTimeoutMs( - long outerQueryStartTimeMs, long outerQueryTimeoutMs) { - return outerQueryTimeoutMs - (System.currentTimeMillis() - outerQueryStartTimeMs); - } - public static InternalQueryResult executeInternalQuery( - IClientSession internalSession, SessionInfo sessionInfo, + String fragmentInstanceId, + QueryId outerQueryId, String sql, - long outerQueryStartTimeMs, - long outerQueryTimeoutMs) + long timeoutMs) throws IoTDBException { - long timeoutMs = computeRemainingTimeoutMs(outerQueryStartTimeMs, outerQueryTimeoutMs); - if (timeoutMs <= 0) { - throw new QueryTimeoutException( - "Outer query timeout exceeded before UDF internal query starts"); - } + IClientSession previousSession = SESSION_MANAGER.getCurrSession(); - Statement parsedStatement = parseTableStatement(internalSession, sessionInfo, sql); - - long statementId = SESSION_MANAGER.requestStatementId(internalSession); - long queryId = SESSION_MANAGER.requestQueryId(internalSession, statementId); - - ExecutionResult result = - COORDINATOR.executeForTableModel( - parsedStatement, - RELATION_SQL_PARSER, - internalSession, - queryId, - sessionInfo, - sql, - METADATA, - timeoutMs, - false, - false, - true); - - if (result.status.code != TSStatusCode.SUCCESS_STATUS.getStatusCode() - && result.status.code != TSStatusCode.REDIRECTION_RECOMMEND.getStatusCode()) { - COORDINATOR.cleanupQueryExecution(queryId, () -> sql, null); - internalSession.removeQueryId(statementId, queryId); - throw new IoTDBException(result.status.message, result.status.code); - } + InternalClientSession internalSession = + new InternalClientSession(formatInternalClientId(fragmentInstanceId, outerQueryId)); + internalSession.setSqlDialect(sessionInfo.getSqlDialect()); + sessionInfo.getDatabaseName().ifPresent(internalSession::setDatabaseName); - IQueryExecution queryExecution = COORDINATOR.getQueryExecution(queryId); - if (queryExecution == null) { - COORDINATOR.cleanupQueryExecution(queryId, () -> sql, null); - internalSession.removeQueryId(statementId, queryId); - throw new IoTDBException( - "Internal query execution not found", TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode()); - } + SESSION_MANAGER.supplySession( + internalSession, + sessionInfo.getUserId(), + sessionInfo.getUserName(), + sessionInfo.getZoneId(), + sessionInfo.getVersion()); - return new InternalQueryResult( - queryExecution, - () -> { - COORDINATOR.cleanupQueryExecution(queryId, () -> sql, null); - internalSession.removeQueryId(statementId, queryId); - }); - } + long statementId = -1; + long queryId = -1; + try { + SESSION_MANAGER.exchangeCurrSession(internalSession); - static void validateReadOnlyQuery(IQueryExecution execution) throws IoTDBException { - if (execution.getQueryType() != QueryType.READ) { - execution.stopAndCleanup(null); - throw new SemanticException("Only query is allowed when used IoTDBLocal in UDF"); - } - } + statementId = SESSION_MANAGER.requestStatementId(internalSession); + queryId = SESSION_MANAGER.requestQueryId(internalSession, statementId); - private static Statement parseTableStatement( - IClientSession internalSession, SessionInfo sessionInfo, String sql) throws IoTDBException { - try { - Statement statement = + Statement parsedStatement = RELATION_SQL_PARSER.createStatement(sql, sessionInfo.getZoneId(), internalSession); - return statement; + + ExecutionResult result = + COORDINATOR.executeForTableModel( + parsedStatement, + RELATION_SQL_PARSER, + internalSession, + queryId, + sessionInfo, + sql, + METADATA, + timeoutMs, + false, + false); + + if (result.status.code != TSStatusCode.SUCCESS_STATUS.getStatusCode()) { + throw new IoTDBException(result.status.message, result.status.code); + } + + IQueryExecution queryExecution = COORDINATOR.getQueryExecution(queryId); + if (queryExecution == null) { + throw new IoTDBException( + "Internal query execution not found", + TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode()); + } + + return new InternalQueryResult(queryExecution, internalSession, statementId, queryId, sql); } catch (Exception e) { - throw new IoTDBException(e.getMessage(), TSStatusCode.SQL_PARSE_ERROR.getStatusCode()); + ClientRPCServiceImpl.clearUp(internalSession, statementId, queryId, () -> sql, e); + throw new IoTDBException(e.getMessage(), TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode()); + } finally { + SESSION_MANAGER.exchangeCurrSession(previousSession); + } + } + + static String formatInternalClientId(String fragmentInstanceId, QueryId outerQueryId) { + return String.format("udf-local-%s-%s", fragmentInstanceId, outerQueryId); + } + + public static void validateReadOnlyQuery(IQueryExecution execution) { + if (execution.getQueryType() != QueryType.READ) { + throw new SemanticException("Only query is supported for IoTDBLocal query interface"); } } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryResult.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryResult.java index 9f35fa9561899..419ea00eb0028 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryResult.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryResult.java @@ -19,25 +19,47 @@ package org.apache.iotdb.db.queryengine.udf; +import org.apache.iotdb.db.protocol.session.IClientSession; +import org.apache.iotdb.db.protocol.thrift.impl.ClientRPCServiceImpl; +import org.apache.iotdb.db.queryengine.common.header.DatasetHeader; import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution; -/** Internal query result holding {@link IQueryExecution} and a cleanup action. */ +/** Internal query result holding {@link IQueryExecution} and cleanup metadata. */ public final class InternalQueryResult implements AutoCloseable { private final IQueryExecution queryExecution; - private final Runnable releaseAction; + private final IClientSession internalSession; + private final long statementId; + private final long queryId; + private final String sql; - public InternalQueryResult(IQueryExecution queryExecution, Runnable releaseAction) { + public InternalQueryResult( + IQueryExecution queryExecution, + IClientSession internalSession, + long statementId, + long queryId, + String sql) { this.queryExecution = queryExecution; - this.releaseAction = releaseAction; + this.internalSession = internalSession; + this.statementId = statementId; + this.queryId = queryId; + this.sql = sql; } public IQueryExecution getQueryExecution() { return queryExecution; } + public long getQueryId() { + return queryId; + } + + public DatasetHeader getDatasetHeader() { + return queryExecution.getDatasetHeader(); + } + @Override public void close() { - releaseAction.run(); + ClientRPCServiceImpl.clearUp(internalSession, statementId, queryId, () -> sql, null); } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java index 32540b20e0664..47ee7d07f27e7 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java @@ -19,13 +19,12 @@ package org.apache.iotdb.db.queryengine.udf; -import org.apache.iotdb.commons.conf.IoTDBConstant.ClientVersion; +import org.apache.iotdb.calc.plan.planner.TableOperatorGenerator.IoTDBLocalFactory; import org.apache.iotdb.commons.exception.IoTDBException; +import org.apache.iotdb.commons.exception.QueryTimeoutException; import org.apache.iotdb.commons.queryengine.common.SessionInfo; -import org.apache.iotdb.commons.queryengine.plan.planner.plan.node.PlanNodeId; -import org.apache.iotdb.db.protocol.session.InternalClientSession; -import org.apache.iotdb.db.protocol.session.SessionManager; -import org.apache.iotdb.db.queryengine.common.FragmentInstanceId; +import org.apache.iotdb.db.conf.IoTDBDescriptor; +import org.apache.iotdb.db.queryengine.common.QueryId; import org.apache.iotdb.db.queryengine.plan.Coordinator; import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution; import org.apache.iotdb.udf.api.IoTDBLocal; @@ -41,74 +40,35 @@ /** Server-side implementation of {@link IoTDBLocal}. */ public class IoTDBLocalImpl implements IoTDBLocal { + public static final IoTDBLocalFactory FACTORY = IoTDBLocalImpl::new; + private static final Logger LOGGER = LoggerFactory.getLogger(IoTDBLocalImpl.class); - private static final SessionManager SESSION_MANAGER = SessionManager.getInstance(); private static final Coordinator COORDINATOR = Coordinator.getInstance(); private final SessionInfo sessionInfo; - private final InternalClientSession internalSession; - private final long outerQueryStartTimeMs; - private final long outerQueryTimeoutMs; + private final String fragmentInstanceId; + private final QueryId outerQueryId; private final List openResultSets = new ArrayList<>(); - private boolean closed; - public IoTDBLocalImpl( - SessionInfo sessionInfo, - String internalClientId, - long outerQueryStartTimeMs, - long outerQueryTimeoutMs) { + public IoTDBLocalImpl(SessionInfo sessionInfo, String fragmentInstanceId, String outerQueryId) { this.sessionInfo = sessionInfo; - this.outerQueryStartTimeMs = outerQueryStartTimeMs; - this.outerQueryTimeoutMs = outerQueryTimeoutMs; - this.internalSession = new InternalClientSession(internalClientId); - internalSession.setSqlDialect(sessionInfo.getSqlDialect()); - sessionInfo.getDatabaseName().ifPresent(internalSession::setDatabaseName); - SESSION_MANAGER.supplySession( - internalSession, - sessionInfo.getUserId(), - sessionInfo.getUserName(), - sessionInfo.getZoneId(), - ClientVersion.V_1_0); - } - - public static String formatInternalClientId( - FragmentInstanceId fragmentInstanceId, PlanNodeId planNodeId) { - return "udf-local-" + fragmentInstanceId + "-" + planNodeId; - } - - public static IoTDBLocalImpl create( - SessionInfo sessionInfo, FragmentInstanceId fragmentInstanceId, PlanNodeId planNodeId) { - long outerStart = System.currentTimeMillis(); - long outerTimeout = - org.apache.iotdb.db.conf.IoTDBDescriptor.getInstance() - .getConfig() - .getQueryTimeoutThreshold(); - String globalQueryId = fragmentInstanceId.getQueryId().getId(); - for (IQueryExecution execution : COORDINATOR.getAllQueryExecutions()) { - if (globalQueryId.equals(execution.getQueryId())) { - outerStart = execution.getStartExecutionTime(); - outerTimeout = execution.getTimeout(); - break; - } - } - return new IoTDBLocalImpl( - sessionInfo, - formatInternalClientId(fragmentInstanceId, planNodeId), - outerStart, - outerTimeout); + this.fragmentInstanceId = fragmentInstanceId; + this.outerQueryId = QueryId.valueOf(outerQueryId); } @Override public UDFResultSet query(String sql) throws UDFException { - if (closed) { - throw new UDFException("IoTDBLocal is already closed"); - } try { + long timeoutMs = computeRemainingTimeoutMs(); + if (timeoutMs <= 0) { + throw new QueryTimeoutException( + "Outer query timeout exceeded before IoTDBLocal query starts"); + } InternalQueryResult result = InternalQueryExecutor.executeInternalQuery( - internalSession, sessionInfo, sql, outerQueryStartTimeMs, outerQueryTimeoutMs); + sessionInfo, fragmentInstanceId, outerQueryId, sql, timeoutMs); int index = openResultSets.size(); - UDFResultSetImpl rs = new UDFResultSetImpl(result, this, index); + UDFResultSetImpl rs = new UDFResultSetImpl(openResultSets, index, result); openResultSets.add(rs); return rs; } catch (IoTDBException e) { @@ -116,29 +76,32 @@ public UDFResultSet query(String sql) throws UDFException { } } - void markResultSetClosed(int index) { - if (index >= 0 && index < openResultSets.size()) { - openResultSets.set(index, null); - } - } - - public void closeAllResultSets() { - for (UDFResultSetImpl rs : openResultSets) { + @Override + public void close() { + for (int i = 0; i < openResultSets.size(); i++) { + UDFResultSetImpl rs = openResultSets.get(i); if (rs != null) { - rs.close(); + try { + rs.close(); + } catch (UDFException e) { + LOGGER.warn("Failed to close UDF result set at index {}", i, e); + } } } openResultSets.clear(); } - @Override - public void close() { - if (closed) { - return; + private long computeRemainingTimeoutMs() { + long outerStart = System.currentTimeMillis(); + long outerTimeout = IoTDBDescriptor.getInstance().getConfig().getQueryTimeoutThreshold(); + for (IQueryExecution execution : COORDINATOR.getAllQueryExecutions()) { + if (outerQueryId.getId().equals(execution.getQueryId())) { + outerStart = execution.getStartExecutionTime(); + outerTimeout = execution.getTimeout(); + break; + } } - closed = true; - closeAllResultSets(); - SESSION_MANAGER.closeSession(internalSession, COORDINATOR::cleanupQueryExecution); + return outerTimeout - (System.currentTimeMillis() - outerStart); } @Override diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/ScalarUdfExpressionDetector.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/ScalarUdfExpressionDetector.java deleted file mode 100644 index cf87bee846a77..0000000000000 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/ScalarUdfExpressionDetector.java +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you 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 org.apache.iotdb.db.queryengine.udf; - -import org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.Expression; -import org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.FunctionCall; -import org.apache.iotdb.commons.queryengine.plan.udf.TableUDFUtils; -import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.DefaultTraversalVisitor; - -import java.util.Optional; - -/** Detects whether filter or project expressions contain a user-defined scalar function. */ -public final class ScalarUdfExpressionDetector extends DefaultTraversalVisitor { - - private boolean found; - - private ScalarUdfExpressionDetector() {} - - public static boolean contains(Optional predicate, Expression[] projectExpressions) { - ScalarUdfExpressionDetector detector = new ScalarUdfExpressionDetector(); - if (predicate.isPresent()) { - detector.process(predicate.get(), null); - } - for (Expression expression : projectExpressions) { - if (detector.found) { - return true; - } - detector.process(expression, null); - } - return detector.found; - } - - @Override - public Void visitFunctionCall(FunctionCall node, Void context) { - if (TableUDFUtils.isScalarFunction(node.getName().getSuffix())) { - found = true; - return null; - } - return super.visitFunctionCall(node, context); - } -} diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/UDFResultSetImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/UDFResultSetImpl.java index 647e0115a6497..bc3f163eee864 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/UDFResultSetImpl.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/UDFResultSetImpl.java @@ -23,7 +23,6 @@ import org.apache.iotdb.commons.exception.IoTDBException; import org.apache.iotdb.commons.schema.column.ColumnHeader; import org.apache.iotdb.commons.udf.utils.UDFDataTypeTransformer; -import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution; import org.apache.iotdb.udf.api.UDFResultSet; import org.apache.iotdb.udf.api.exception.UDFException; import org.apache.iotdb.udf.api.relational.access.Record; @@ -41,19 +40,20 @@ /** Server-side implementation of {@link UDFResultSet}. */ public class UDFResultSetImpl implements UDFResultSet { - private final InternalQueryResult queryResult; - private final IoTDBLocalImpl owner; + private final List openResultSets; private final int index; + private final InternalQueryResult queryResult; + private final List columnTypes; private Iterator rowIterator; - private final List columnTypes; private boolean closed; - public UDFResultSetImpl(InternalQueryResult queryResult, IoTDBLocalImpl owner, int index) { - this.queryResult = queryResult; - this.owner = owner; + public UDFResultSetImpl( + List openResultSets, int index, InternalQueryResult queryResult) { + this.openResultSets = openResultSets; this.index = index; - this.columnTypes = buildColumnTypes(queryResult.getQueryExecution()); + this.queryResult = queryResult; + this.columnTypes = buildColumnTypes(queryResult.getDatasetHeader().getColumnHeaders()); } @Override @@ -68,7 +68,7 @@ public boolean hasNext() throws UDFException { try { batch = queryResult.getQueryExecution().getBatchResult(); } catch (IoTDBException e) { - throw new UDFException(e.getMessage()); + throw new UDFException(e.getMessage(), e); } if (!batch.isPresent()) { return false; @@ -85,9 +85,7 @@ public boolean hasNext() throws UDFException { @Override public Record next() throws UDFException { - ensureOpen(); - - if (rowIterator == null || !rowIterator.hasNext()) { + if (!hasNext()) { throw new NoSuchElementException(); } return rowIterator.next(); @@ -99,12 +97,12 @@ public void close() throws UDFException { return; } closed = true; + openResultSets.set(index, null); try { queryResult.close(); } catch (RuntimeException e) { throw new UDFException("Failed to close internal query result", e); } - owner.markResultSetClosed(index); } private void ensureOpen() throws UDFException { @@ -113,8 +111,8 @@ private void ensureOpen() throws UDFException { } } - private static List buildColumnTypes(IQueryExecution queryExecution) { - return queryExecution.getDatasetHeader().getColumnHeaders().stream() + private static List buildColumnTypes(List columnHeaders) { + return columnHeaders.stream() .map(ColumnHeader::getColumnType) .map(UDFDataTypeTransformer::transformToUDFDataType) .map(UDFDataTypeTransformer::transformUDFDataTypeToReadType) From 917b11aeb8f6cdb9ae14fa8c9095506ec0e33501 Mon Sep 17 00:00:00 2001 From: Weihao Li <18110526956@163.com> Date: Thu, 25 Jun 2026 17:32:19 +0800 Subject: [PATCH 03/11] CI Signed-off-by: Weihao Li <18110526956@163.com> --- .../iotdblocal/DeviceNameFunction.java | 77 + .../iotdblocal/DeviceSummaryFunction.java | 97 + .../DeviceSummaryNoCloseFunction.java | 93 + .../iotdblocal/IoTDBLocalLogFunction.java | 67 + .../iotdblocal/SecretTableQueryFunction.java | 57 + .../relational/it/db/it/udf/IoTDBLocalIT.java | 310 +++ .../udf/api/relational/AggregateFunction.java | 24 + .../processor/TableFunctionDataProcessor.java | 34 + .../processor/TableFunctionLeafProcessor.java | 17 + .../function/TableFunctionLeafOperator.java | 16 +- .../function/TableFunctionOperator.java | 28 +- .../aggregation/AccumulatorFactory.java | 98 +- ...erDefinedAggregateFunctionAccumulator.java | 23 +- ...roupedUserDefinedAggregateAccumulator.java | 23 +- .../plan/planner/TableOperatorGenerator.java | 52 +- .../DataNodeTableOperatorGenerator.java | 3 +- log | 1924 +++++++++++++++++ 17 files changed, 2901 insertions(+), 42 deletions(-) create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceNameFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceSummaryFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceSummaryNoCloseFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/SecretTableQueryFunction.java create mode 100644 integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java create mode 100644 log diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceNameFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceNameFunction.java new file mode 100644 index 0000000000000..d08d0d0affec1 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceNameFunction.java @@ -0,0 +1,77 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.customizer.analysis.ScalarFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.ScalarFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.type.Type; + +import org.apache.tsfile.common.conf.TSFileConfig; +import org.apache.tsfile.utils.Binary; + +import java.util.HashMap; +import java.util.Map; + +/** Lookup device_name by device_id via a single IoTDBLocal query in {@link #beforeStart}. */ +public class DeviceNameFunction implements ScalarFunction { + + private Map idToName = Map.of(); + + @Override + public ScalarFunctionAnalysis analyze(FunctionArguments arguments) + throws UDFArgumentNotValidException { + return new ScalarFunctionAnalysis.Builder().outputDataType(Type.STRING).build(); + } + + @Override + public void beforeStart(FunctionArguments arguments, IoTDBLocal local) throws UDFException { + local.info("DeviceNameFunction: loading device_info"); + Map map = new HashMap<>(); + try (UDFResultSet rs = local.query("SELECT device_id, device_name FROM device_info")) { + while (rs.hasNext()) { + Record row = rs.next(); + map.put(row.getString(0), row.getString(1)); + } + } + idToName = map; + local.info("DeviceNameFunction: loaded {} mappings", idToName.size()); + } + + @Override + public Object evaluate(Record input) { + return lookupName(input); + } + + @Override + public Object evaluate(Record input, IoTDBLocal local) { + return lookupName(input); + } + + private Object lookupName(Record input) { + String deviceId = input.getString(0); + return new Binary(idToName.getOrDefault(deviceId, "未知设备"), TSFileConfig.STRING_CHARSET); + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceSummaryFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceSummaryFunction.java new file mode 100644 index 0000000000000..3aacbf6269b9d --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceSummaryFunction.java @@ -0,0 +1,97 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.customizer.analysis.ScalarFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.ScalarFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.type.Type; + +import org.apache.tsfile.common.conf.TSFileConfig; +import org.apache.tsfile.utils.Binary; + +import java.util.HashMap; +import java.util.Map; + +/** + * Lookup device_name and max_temp via two concurrent IoTDBLocal queries in {@link #beforeStart}. + */ +public class DeviceSummaryFunction implements ScalarFunction { + + private Map idToName = Map.of(); + private Map idToMaxTemp = Map.of(); + + @Override + public ScalarFunctionAnalysis analyze(FunctionArguments arguments) + throws UDFArgumentNotValidException { + return new ScalarFunctionAnalysis.Builder().outputDataType(Type.STRING).build(); + } + + @Override + public void beforeStart(FunctionArguments arguments, IoTDBLocal local) throws UDFException { + idToName = new HashMap<>(); + idToMaxTemp = new HashMap<>(); + UDFResultSet nameResult = local.query("SELECT device_id, device_name FROM device_info"); + UDFResultSet limitResult = local.query("SELECT device_id, max_temp FROM device_limits"); + try { + boolean hasName = nameResult.hasNext(); + boolean hasLimit = limitResult.hasNext(); + while (hasName || hasLimit) { + if (hasName) { + Record row = nameResult.next(); + idToName.put(row.getString(0), row.getString(1)); + hasName = nameResult.hasNext(); + } + if (hasLimit) { + Record row = limitResult.next(); + idToMaxTemp.put(row.getString(0), row.getDouble(1)); + hasLimit = limitResult.hasNext(); + } + } + } finally { + nameResult.close(); + limitResult.close(); + } + } + + @Override + public Object evaluate(Record input) { + return buildSummary(input); + } + + @Override + public Object evaluate(Record input, IoTDBLocal local) { + return buildSummary(input); + } + + private Object buildSummary(Record input) { + String deviceId = input.getString(0); + String name = idToName.getOrDefault(deviceId, "未知设备"); + Double maxTemp = idToMaxTemp.get(deviceId); + return new Binary( + String.format("%s(上限:%s)", name, maxTemp == null ? "未知" : maxTemp), + TSFileConfig.STRING_CHARSET); + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceSummaryNoCloseFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceSummaryNoCloseFunction.java new file mode 100644 index 0000000000000..c0ef353e4c1f1 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceSummaryNoCloseFunction.java @@ -0,0 +1,93 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.customizer.analysis.ScalarFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.ScalarFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.type.Type; + +import org.apache.tsfile.common.conf.TSFileConfig; +import org.apache.tsfile.utils.Binary; + +import java.util.HashMap; +import java.util.Map; + +/** + * Same as {@link DeviceSummaryFunction} but intentionally does not close result sets, for verifying + * framework auto-cleanup. + */ +public class DeviceSummaryNoCloseFunction implements ScalarFunction { + + private Map idToName = Map.of(); + private Map idToMaxTemp = Map.of(); + + @Override + public ScalarFunctionAnalysis analyze(FunctionArguments arguments) + throws UDFArgumentNotValidException { + return new ScalarFunctionAnalysis.Builder().outputDataType(Type.STRING).build(); + } + + @Override + public void beforeStart(FunctionArguments arguments, IoTDBLocal local) throws UDFException { + idToName = new HashMap<>(); + idToMaxTemp = new HashMap<>(); + UDFResultSet nameResult = local.query("SELECT device_id, device_name FROM device_info"); + UDFResultSet limitResult = local.query("SELECT device_id, max_temp FROM device_limits"); + boolean hasName = nameResult.hasNext(); + boolean hasLimit = limitResult.hasNext(); + while (hasName || hasLimit) { + if (hasName) { + Record row = nameResult.next(); + idToName.put(row.getString(0), row.getString(1)); + hasName = nameResult.hasNext(); + } + if (hasLimit) { + Record row = limitResult.next(); + idToMaxTemp.put(row.getString(0), row.getDouble(1)); + hasLimit = limitResult.hasNext(); + } + } + } + + @Override + public Object evaluate(Record input) { + return buildSummary(input); + } + + @Override + public Object evaluate(Record input, IoTDBLocal local) { + return buildSummary(input); + } + + private Object buildSummary(Record input) { + String deviceId = input.getString(0); + String name = idToName.getOrDefault(deviceId, "未知设备"); + Double maxTemp = idToMaxTemp.get(deviceId); + return new Binary( + String.format("%s(上限:%s)", name, maxTemp == null ? "未知" : maxTemp), + TSFileConfig.STRING_CHARSET); + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogFunction.java new file mode 100644 index 0000000000000..b22c5a1841fd0 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogFunction.java @@ -0,0 +1,67 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.customizer.analysis.ScalarFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.relational.ScalarFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.type.Type; + +/** Exercises all IoTDBLocal log APIs with distinctive markers for integration tests. */ +public class IoTDBLocalLogFunction implements ScalarFunction { + + public static final String INFO_PLAIN = "IOTDB_LOCAL_IT_INFO_PLAIN"; + public static final String INFO_FORMAT = "IOTDB_LOCAL_IT_INFO_FORMAT loaded 3 rows"; + public static final String INFO_CAUSE = "IOTDB_LOCAL_IT_INFO_CAUSE"; + public static final String WARN_PLAIN = "IOTDB_LOCAL_IT_WARN_PLAIN"; + public static final String WARN_FORMAT = "IOTDB_LOCAL_IT_WARN_FORMAT warn ab"; + public static final String WARN_CAUSE = "IOTDB_LOCAL_IT_WARN_CAUSE"; + public static final String ERROR_PLAIN = "IOTDB_LOCAL_IT_ERROR_PLAIN"; + public static final String ERROR_FORMAT = "IOTDB_LOCAL_IT_ERROR_FORMAT error code=500"; + public static final String ERROR_CAUSE = "IOTDB_LOCAL_IT_ERROR_CAUSE"; + + @Override + public ScalarFunctionAnalysis analyze(FunctionArguments arguments) + throws UDFArgumentNotValidException { + return new ScalarFunctionAnalysis.Builder().outputDataType(Type.STRING).build(); + } + + @Override + public void beforeStart(FunctionArguments arguments, IoTDBLocal local) { + RuntimeException cause = new RuntimeException("iotdb-local-it-log-cause"); + local.info(INFO_PLAIN); + local.info("IOTDB_LOCAL_IT_INFO_FORMAT loaded {} rows", 3); + local.info(INFO_CAUSE, cause); + local.warn(WARN_PLAIN); + local.warn("IOTDB_LOCAL_IT_WARN_FORMAT warn {} {}", "a", "b"); + local.warn(WARN_CAUSE, cause); + local.error(ERROR_PLAIN); + local.error("IOTDB_LOCAL_IT_ERROR_FORMAT error code={}", 500); + local.error(ERROR_CAUSE, cause); + } + + @Override + public Object evaluate(Record input) { + return "ok"; + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/SecretTableQueryFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/SecretTableQueryFunction.java new file mode 100644 index 0000000000000..de3b8a13aae8b --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/SecretTableQueryFunction.java @@ -0,0 +1,57 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.customizer.analysis.ScalarFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.ScalarFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.type.Type; + +import org.apache.tsfile.common.conf.TSFileConfig; +import org.apache.tsfile.utils.Binary; + +/** Probes IoTDBLocal query against secret_table for permission integration tests. */ +public class SecretTableQueryFunction implements ScalarFunction { + + @Override + public ScalarFunctionAnalysis analyze(FunctionArguments arguments) + throws UDFArgumentNotValidException { + return new ScalarFunctionAnalysis.Builder().outputDataType(Type.STRING).build(); + } + + @Override + public void beforeStart(FunctionArguments arguments, IoTDBLocal local) throws UDFException { + try (UDFResultSet rs = local.query("SELECT secret FROM secret_table")) { + while (rs.hasNext()) { + rs.next(); + } + } + } + + @Override + public Object evaluate(Record input) { + return new Binary(input.getString(0), TSFileConfig.STRING_CHARSET); + } +} diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java new file mode 100644 index 0000000000000..d6fb2339ae29e --- /dev/null +++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java @@ -0,0 +1,310 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.relational.it.db.it.udf; + +import org.apache.iotdb.db.query.udf.example.relational.iotdblocal.IoTDBLocalLogFunction; +import org.apache.iotdb.it.env.EnvFactory; +import org.apache.iotdb.it.framework.IoTDBTestRunner; +import org.apache.iotdb.itbase.category.TableClusterIT; +import org.apache.iotdb.itbase.category.TableLocalStandaloneIT; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; + +import java.io.IOException; +import java.sql.Connection; +import java.sql.Statement; + +import static org.apache.iotdb.db.it.utils.TestUtils.tableAssertTestFail; +import static org.apache.iotdb.db.it.utils.TestUtils.tableResultSetEqualTest; +import static org.junit.Assert.fail; + +/** + * Integration tests for {@link org.apache.iotdb.udf.api.IoTDBLocal} in table-model UDF, covering + * compatibility, embedded query, logging, permission inheritance and auto resource cleanup. + */ +@RunWith(IoTDBTestRunner.class) +@Category({TableLocalStandaloneIT.class, TableClusterIT.class}) +public class IoTDBLocalIT { + + private static final String DATABASE_NAME = "iotdb_local_it"; + private static final String LIMITED_USER = "iotdb_local_user"; + private static final String LIMITED_PASSWORD = "iotdbLocalPw123456"; + + private static final String PKG = "org.apache.iotdb.db.query.udf.example.relational"; + private static final String IOTDB_LOCAL_PKG = + "org.apache.iotdb.db.query.udf.example.relational.iotdblocal"; + + private static final String[] SETUP_SQLS = + new String[] { + "CREATE DATABASE " + DATABASE_NAME, + "USE " + DATABASE_NAME, + "CREATE TABLE readings (device_id STRING TAG, temperature DOUBLE FIELD)", + "CREATE TABLE device_info (device_id STRING TAG, device_name STRING FIELD)", + "CREATE TABLE device_limits (device_id STRING TAG, max_temp DOUBLE FIELD)", + "CREATE TABLE secret_table (device_id STRING TAG, secret STRING FIELD)", + "CREATE TABLE vehicle (device_id STRING TAG, s1 INT32 FIELD, s2 INT64 FIELD)", + "INSERT INTO device_info(time, device_id, device_name) VALUES (1, 'd1', '一号车间温度传感器'), (1, 'd2', '二号车间温度传感器')", + "INSERT INTO device_limits(time, device_id, max_temp) VALUES (1, 'd1', 30.0), (1, 'd2', 35.0)", + "INSERT INTO readings(time, device_id, temperature) VALUES (1000, 'd1', 25.5), (1001, 'd2', 32.0), (1002, 'd3', 20.0)", + "INSERT INTO secret_table(time, device_id, secret) VALUES (1, 'd1', 'top-secret')", + "INSERT INTO vehicle(time, device_id, s1, s2) VALUES (1, 'd0', 1, 1)", + "INSERT INTO vehicle(time, device_id, s1, s2) VALUES (2, 'd0', null, 2)", + "INSERT INTO vehicle(time, device_id, s1, s2) VALUES (3, 'd0', 3, 3)", + "INSERT INTO vehicle(time, device_id, s1) VALUES (5, 'd0', 4)", + "FLUSH", + "CLEAR ATTRIBUTE CACHE", + }; + + public static void main(String[] args) { + for (String sql : SETUP_SQLS) { + System.out.println(sql + ";"); + } + } + + @BeforeClass + public static void setUp() throws Exception { + EnvFactory.getEnv().getConfig().getCommonConfig().setEnforceStrongPassword(false); + EnvFactory.getEnv().initClusterEnvironment(); + executeAsRoot(SETUP_SQLS); + } + + @AfterClass + public static void tearDown() throws Exception { + EnvFactory.getEnv().cleanClusterEnvironment(); + } + + @After + public void dropFunctions() { + SQLFunctionUtils.dropAllUDF(); + } + + private static void executeAsRoot(String... sqls) { + try (Connection connection = EnvFactory.getEnv().getTableConnection(); + Statement statement = connection.createStatement()) { + for (String sql : sqls) { + statement.execute(sql); + } + } catch (Exception e) { + fail("executeAsRoot failed: " + e.getMessage()); + } + } + + // ── compatibility: legacy UDF without IoTDBLocal parameter ───────────────── + + @Test + public void testLegacyScalarUdf() { + SQLFunctionUtils.createUDF("contain_null", PKG + ".ContainNull"); + SQLFunctionUtils.createUDF("all_sum", PKG + ".AllSum"); + tableResultSetEqualTest( + "SELECT time, contain_null(s1, s2) AS contain_null, contain_null(s1) AS s1_null FROM vehicle", + new String[] {"time", "contain_null", "s1_null"}, + new String[] { + "1970-01-01T00:00:00.001Z,false,false,", + "1970-01-01T00:00:00.002Z,true,true,", + "1970-01-01T00:00:00.003Z,true,false,", + "1970-01-01T00:00:00.005Z,true,true," + }, + DATABASE_NAME); + tableResultSetEqualTest( + "SELECT time, all_sum(s1, s2) AS s12 FROM vehicle", + new String[] {"time", "s12"}, + new String[] { + "1970-01-01T00:00:00.001Z,2,", + "1970-01-01T00:00:00.002Z,2,", + "1970-01-01T00:00:00.003Z,3,", + "5,4," + }, + DATABASE_NAME); + } + + @Test + public void testLegacyAggregateUdf() { + SQLFunctionUtils.createUDF("my_avg", PKG + ".MyAvg"); + tableResultSetEqualTest( + "SELECT device_id, my_avg(s1) AS avg_s1 FROM vehicle GROUP BY device_id", + new String[] {"device_id", "avg_s1"}, + new String[] {"d0,2.0,"}, + DATABASE_NAME); + } + + @Test + public void testLegacyTableFunctionUdf() { + SQLFunctionUtils.createUDF("my_split", PKG + ".MySplit"); + SQLFunctionUtils.createUDF("my_repeat", PKG + ".MyRepeatWithoutIndex"); + tableResultSetEqualTest( + "SELECT * FROM TABLE(my_split('a,b,c'))", + new String[] {"output"}, + new String[] {"a,", "b,", "c,"}, + DATABASE_NAME); + tableResultSetEqualTest( + "SELECT * FROM my_repeat(vehicle, 2) ORDER BY time", + new String[] {"time", "device_id", "s1"}, + new String[] { + "1970-01-01T00:00:00.001Z,d0,1,", + "1970-01-01T00:00:00.001Z,d0,1,", + "1970-01-01T00:00:00.002Z,d0,null,", + "1970-01-01T00:00:00.002Z,d0,null,", + "1970-01-01T00:00:00.003Z,d0,3,", + "1970-01-01T00:00:00.003Z,d0,3,", + "1970-01-01T00:00:00.005Z,d0,4,", + "1970-01-01T00:00:00.005Z,d0,4,", + }, + DATABASE_NAME); + } + + // ── IoTDBLocal embedded query ─────────────────────────────────────────────── + + @Test + public void testDeviceNameWithSingleQuery() { + SQLFunctionUtils.createUDF("device_name", IOTDB_LOCAL_PKG + ".DeviceNameFunction"); + tableResultSetEqualTest( + "SELECT time, device_id, device_name(device_id) AS name, temperature FROM readings ORDER BY time", + new String[] {"time", "device_id", "name", "temperature"}, + new String[] { + "1000,d1,一号车间温度传感器,25.5,", "1001,d2,二号车间温度传感器,32.0,", "1002,d3,未知设备,20.0,", + }, + DATABASE_NAME); + } + + @Test + public void testDeviceSummaryWithMultipleQueries() { + SQLFunctionUtils.createUDF("device_summary", IOTDB_LOCAL_PKG + ".DeviceSummaryFunction"); + tableResultSetEqualTest( + "SELECT time, device_id, temperature, device_summary(device_id) AS summary FROM readings ORDER BY time", + new String[] {"time", "device_id", "temperature", "summary"}, + new String[] { + "1000,d1,25.5,一号车间温度传感器(上限:30.0),", + "1001,d2,32.0,二号车间温度传感器(上限:35.0),", + "1002,d3,20.0,未知设备(上限:未知),", + }, + DATABASE_NAME); + } + + @Test + public void testDeviceSummaryWithoutManualClose() { + SQLFunctionUtils.createUDF( + "device_summary_no_close", IOTDB_LOCAL_PKG + ".DeviceSummaryNoCloseFunction"); + tableResultSetEqualTest( + "SELECT device_summary_no_close(device_id) AS summary FROM readings WHERE device_id = 'd1'", + new String[] {"summary"}, + new String[] {"一号车间温度传感器(上限:30.0),"}, + DATABASE_NAME); + tableResultSetEqualTest( + "SELECT device_summary_no_close(device_id) AS summary FROM readings WHERE device_id = 'd2'", + new String[] {"summary"}, + new String[] {"二号车间温度传感器(上限:35.0),"}, + DATABASE_NAME); + } + + // ── IoTDBLocal logging ────────────────────────────────────────────────────── + + @Test + public void testIoTDBLocalLogApis() throws IOException { + SQLFunctionUtils.createUDF("iotdb_local_log", IOTDB_LOCAL_PKG + ".IoTDBLocalLogFunction"); + EnvFactory.getEnv().getDataNodeWrapper(0).clearLogContent(); + tableResultSetEqualTest( + "SELECT iotdb_local_log(device_id) AS log_ok FROM readings WHERE device_id = 'd1'", + new String[] {"log_ok"}, + new String[] {"ok,"}, + DATABASE_NAME); + assertLogContains(IoTDBLocalLogFunction.INFO_PLAIN); + assertLogContains(IoTDBLocalLogFunction.INFO_FORMAT); + assertLogContains(IoTDBLocalLogFunction.INFO_CAUSE); + assertLogContains(IoTDBLocalLogFunction.WARN_PLAIN); + assertLogContains(IoTDBLocalLogFunction.WARN_FORMAT); + assertLogContains(IoTDBLocalLogFunction.WARN_CAUSE); + assertLogContains(IoTDBLocalLogFunction.ERROR_PLAIN); + assertLogContains(IoTDBLocalLogFunction.ERROR_FORMAT); + assertLogContains(IoTDBLocalLogFunction.ERROR_CAUSE); + assertLogContains("iotdb-local-it-log-cause"); + } + + private static void assertLogContains(String content) throws IOException { + Assert.assertTrue( + "Expected log to contain: " + content, + EnvFactory.getEnv().getDataNodeWrapper(0).logContains(content)); + } + + // ── permission inheritance ────────────────────────────────────────────────── + + @Test + public void testIoTDBLocalInheritsSelectPermission() { + setupLimitedUserWithTableGrants("readings", "device_info", "device_limits"); + SQLFunctionUtils.createUDF("device_name", IOTDB_LOCAL_PKG + ".DeviceNameFunction"); + tableResultSetEqualTest( + "SELECT device_name(device_id) AS name FROM readings WHERE device_id = 'd1'", + new String[] {"name"}, + new String[] {"一号车间温度传感器,"}, + DATABASE_NAME, + LIMITED_USER, + LIMITED_PASSWORD); + dropLimitedUser(); + } + + @Test + public void testIoTDBLocalDeniedWithoutTablePermission() { + setupLimitedUserWithTableGrants("readings"); + SQLFunctionUtils.createUDF("secret_query", IOTDB_LOCAL_PKG + ".SecretTableQueryFunction"); + tableAssertTestFail( + "SELECT secret_query(device_id) FROM readings WHERE device_id = 'd1'", + "Access Denied", + LIMITED_USER, + LIMITED_PASSWORD, + DATABASE_NAME); + dropLimitedUser(); + } + + private static void setupLimitedUserWithTableGrants(String... tables) { + try (Connection connection = EnvFactory.getEnv().getTableConnection(); + Statement statement = connection.createStatement()) { + try { + statement.execute("DROP USER " + LIMITED_USER); + } catch (Exception ignored) { + // user may not exist + } + statement.execute("CREATE USER " + LIMITED_USER + " '" + LIMITED_PASSWORD + "'"); + for (String table : tables) { + statement.execute( + "GRANT SELECT ON " + DATABASE_NAME + "." + table + " TO USER " + LIMITED_USER); + } + } catch (Exception e) { + fail("setupLimitedUserWithTableGrants failed: " + e.getMessage()); + } + } + + private static void dropLimitedUser() { + try (Connection connection = EnvFactory.getEnv().getTableConnection(); + Statement statement = connection.createStatement()) { + try { + statement.execute("DROP USER " + LIMITED_USER); + } catch (Exception ignored) { + // user may not exist + } + } catch (Exception e) { + fail("dropLimitedUser failed: " + e.getMessage()); + } + } +} diff --git a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/AggregateFunction.java b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/AggregateFunction.java index 67fdb0aa2b1f0..6c29de6e7ad9c 100644 --- a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/AggregateFunction.java +++ b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/AggregateFunction.java @@ -63,6 +63,22 @@ default void beforeStart(FunctionArguments arguments, IoTDBLocal local) throws U beforeStart(arguments); } + /** + * Same as {@link #addInput(State, Record)} with access to {@link IoTDBLocal} for embedded + * queries. + */ + default void addInput(State state, Record input, IoTDBLocal local) { + addInput(state, input); + } + + /** + * Same as {@link #combineState(State, State)} with access to {@link IoTDBLocal} for embedded + * queries. + */ + default void combineState(State state, State rhs, IoTDBLocal local) { + combineState(state, rhs); + } + /** Create and initialize state. You may bind some resource in this method. */ State createState(); @@ -90,6 +106,14 @@ default void beforeStart(FunctionArguments arguments, IoTDBLocal local) throws U */ void outputFinal(State state, ResultValue resultValue); + /** + * Same as {@link #outputFinal(State, ResultValue)} with access to {@link IoTDBLocal} for embedded + * queries. + */ + default void outputFinal(State state, ResultValue resultValue, IoTDBLocal local) { + outputFinal(state, resultValue); + } + /** * Remove input data from state. This method is used to remove the data points that have been * added to the state. Once it is implemented, {@linkplain diff --git a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/table/processor/TableFunctionDataProcessor.java b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/table/processor/TableFunctionDataProcessor.java index 0fe40fc894b82..e4960fce409c0 100644 --- a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/table/processor/TableFunctionDataProcessor.java +++ b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/table/processor/TableFunctionDataProcessor.java @@ -19,6 +19,7 @@ package org.apache.iotdb.udf.api.relational.table.processor; +import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.relational.access.Record; import org.apache.iotdb.udf.api.relational.table.TableFunctionAnalysis; @@ -33,6 +34,11 @@ default void beforeStart() { // do nothing } + /** Same as {@link #beforeStart()} with access to {@link IoTDBLocal} for embedded queries. */ + default void beforeStart(IoTDBLocal local) { + beforeStart(); + } + /** * This method processes a portion of data. It is called multiple times until the partition is * fully processed. @@ -51,6 +57,18 @@ void process( List properColumnBuilders, ColumnBuilder passThroughIndexBuilder); + /** + * Same as {@link #process(Record, List, ColumnBuilder)} with access to {@link IoTDBLocal} for + * embedded queries. + */ + default void process( + Record input, + List properColumnBuilders, + ColumnBuilder passThroughIndexBuilder, + IoTDBLocal local) { + process(input, properColumnBuilders, passThroughIndexBuilder); + } + /** * This method is called after all data is processed. It is used to finalize the output table and * close resource. All remaining data should be written to the columnBuilders. @@ -66,8 +84,24 @@ default void finish( // do nothing } + /** + * Same as {@link #finish(List, ColumnBuilder)} with access to {@link IoTDBLocal} for embedded + * queries. + */ + default void finish( + List properColumnBuilders, + ColumnBuilder passThroughIndexBuilder, + IoTDBLocal local) { + finish(properColumnBuilders, passThroughIndexBuilder); + } + /** This method is mainly used to release the resources used in the UDF. */ default void beforeDestroy() { // do nothing } + + /** Same as {@link #beforeDestroy()} with access to {@link IoTDBLocal}. */ + default void beforeDestroy(IoTDBLocal local) { + beforeDestroy(); + } } diff --git a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/table/processor/TableFunctionLeafProcessor.java b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/table/processor/TableFunctionLeafProcessor.java index ab8763f3c4ae7..6da0c8d5149c9 100644 --- a/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/table/processor/TableFunctionLeafProcessor.java +++ b/iotdb-api/udf-api/src/main/java/org/apache/iotdb/udf/api/relational/table/processor/TableFunctionLeafProcessor.java @@ -19,6 +19,8 @@ package org.apache.iotdb.udf.api.relational.table.processor; +import org.apache.iotdb.udf.api.IoTDBLocal; + import org.apache.tsfile.block.column.ColumnBuilder; import java.util.List; @@ -29,6 +31,11 @@ default void beforeStart() { // do nothing } + /** Same as {@link #beforeStart()} with access to {@link IoTDBLocal} for embedded queries. */ + default void beforeStart(IoTDBLocal local) { + beforeStart(); + } + /** * This method processes a portion of data. It is called multiple times until the processor is * fully processed. @@ -37,6 +44,11 @@ default void beforeStart() { */ void process(List columnBuilders); + /** Same as {@link #process(List)} with access to {@link IoTDBLocal} for embedded queries. */ + default void process(List columnBuilders, IoTDBLocal local) { + process(columnBuilders); + } + /** This method is called to determine if the processor has finished processing all data. */ boolean isFinish(); @@ -44,4 +56,9 @@ default void beforeStart() { default void beforeDestroy() { // do nothing } + + /** Same as {@link #beforeDestroy()} with access to {@link IoTDBLocal}. */ + default void beforeDestroy(IoTDBLocal local) { + beforeDestroy(); + } } diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/process/function/TableFunctionLeafOperator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/process/function/TableFunctionLeafOperator.java index ced20f7bbf0b6..589e175e146e7 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/process/function/TableFunctionLeafOperator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/process/function/TableFunctionLeafOperator.java @@ -25,6 +25,7 @@ import org.apache.iotdb.calc.plan.planner.CommonOperatorUtils; import org.apache.iotdb.commons.exception.IoTDBRuntimeException; import org.apache.iotdb.rpc.TSStatusCode; +import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.relational.table.TableFunctionProcessorProvider; import org.apache.iotdb.udf.api.relational.table.processor.TableFunctionLeafProcessor; @@ -40,6 +41,8 @@ import java.util.Arrays; import java.util.List; +import static com.google.common.base.Preconditions.checkArgument; + // only one input source is supported now public class TableFunctionLeafOperator implements ProcessOperator { private static final Logger LOGGER = LoggerFactory.getLogger(TableFunctionLeafOperator.class); @@ -48,22 +51,26 @@ public class TableFunctionLeafOperator implements ProcessOperator { private final TsBlockBuilder blockBuilder; private final TableFunctionLeafProcessor processor; + private final IoTDBLocal ioTDBLocal; private volatile boolean init = false; public TableFunctionLeafOperator( CommonOperatorContext operatorContext, TableFunctionProcessorProvider processorProvider, - List outputDataTypes) { + List outputDataTypes, + IoTDBLocal ioTDBLocal) { + checkArgument(ioTDBLocal != null, "IoTDBLocal must not be null for table function"); this.operatorContext = operatorContext; this.processor = processorProvider.getSplitProcessor(); this.blockBuilder = new TsBlockBuilder(outputDataTypes); + this.ioTDBLocal = ioTDBLocal; } @Override public ListenableFuture isBlocked() { if (!init) { init = true; - processor.beforeStart(); + processor.beforeStart(ioTDBLocal); } return NOT_BLOCKED; } @@ -77,7 +84,7 @@ public CommonOperatorContext getOperatorContext() { public TsBlock next() throws Exception { List columnBuilders = getOutputColumnBuilders(); try { - processor.process(columnBuilders); + processor.process(columnBuilders, ioTDBLocal); } catch (Exception e) { LOGGER.warn(CalcMessages.EXCEPTION_HAPPENED_WHEN_EXECUTING_UDTF, e); throw new IoTDBRuntimeException( @@ -106,7 +113,8 @@ public boolean hasNext() throws Exception { @Override public void close() throws Exception { try { - processor.beforeDestroy(); + processor.beforeDestroy(ioTDBLocal); + ioTDBLocal.close(); } catch (Exception e) { LOGGER.warn(CalcMessages.EXCEPTION_HAPPENED_WHEN_EXECUTING_UDTF, e); throw new IoTDBRuntimeException( diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/process/function/TableFunctionOperator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/process/function/TableFunctionOperator.java index e4f11d7cd49fa..d4bc8a0da4c79 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/process/function/TableFunctionOperator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/process/function/TableFunctionOperator.java @@ -28,6 +28,7 @@ import org.apache.iotdb.calc.execution.operator.process.function.partition.Slice; import org.apache.iotdb.calc.plan.planner.CommonOperatorUtils; import org.apache.iotdb.commons.queryengine.execution.MemoryEstimationHelper; +import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.relational.access.Record; import org.apache.iotdb.udf.api.relational.table.TableFunctionProcessorProvider; import org.apache.iotdb.udf.api.relational.table.processor.TableFunctionDataProcessor; @@ -53,6 +54,8 @@ import java.util.Optional; import java.util.Queue; +import static com.google.common.base.Preconditions.checkArgument; + // only one input source is supported now public class TableFunctionOperator implements ProcessOperator { @@ -72,6 +75,7 @@ public class TableFunctionOperator implements ProcessOperator { private final PartitionCache partitionCache; private final boolean requireRecordSnapshot; private final boolean isDeclaredAsPassThrough; + private final IoTDBLocal ioTDBLocal; private TableFunctionDataProcessor processor; private PartitionState partitionState; @@ -91,7 +95,9 @@ public TableFunctionOperator( List passThroughChannels, boolean isDeclaredAsPassThrough, List partitionChannels, - boolean requireRecordSnapshot) { + boolean requireRecordSnapshot, + IoTDBLocal ioTDBLocal) { + checkArgument(ioTDBLocal != null, "IoTDBLocal must not be null for table function"); this.operatorContext = operatorContext; this.inputOperator = inputOperator; this.properChannelCount = properChannelCount; @@ -106,6 +112,7 @@ public TableFunctionOperator( this.partitionCache = new PartitionCache(); this.resultTsBlocks = new LinkedList<>(); this.requireRecordSnapshot = requireRecordSnapshot; + this.ioTDBLocal = ioTDBLocal; } @Override @@ -159,7 +166,7 @@ public TsBlock next() throws Exception { ColumnBuilder passThroughIndexBuilder = getPassThroughIndexBuilder(); if (stateType == PartitionState.StateType.FINISHED) { if (processor != null) { - processor.finish(properColumnBuilders, passThroughIndexBuilder); + processor.finish(properColumnBuilders, passThroughIndexBuilder, ioTDBLocal); } finished = true; resultTsBlocks.addAll(buildTsBlock(properColumnBuilders, passThroughIndexBuilder)); @@ -170,21 +177,22 @@ public TsBlock next() throws Exception { if (stateType == PartitionState.StateType.NEW_PARTITION) { if (processor != null) { // previous partition state has not finished consuming yet - processor.finish(properColumnBuilders, passThroughIndexBuilder); + processor.finish(properColumnBuilders, passThroughIndexBuilder, ioTDBLocal); resultTsBlocks.addAll(buildTsBlock(properColumnBuilders, passThroughIndexBuilder)); partitionCache.clear(); - processor.beforeDestroy(); + destroyProcessor(processor); processor = null; return resultTsBlocks.poll(); } else { processor = processorProvider.getDataProcessor(); - processor.beforeStart(); + processor.beforeStart(ioTDBLocal); } } partitionCache.addSlice(slice); Iterator recordIterator = slice.getRequiredRecordIterator(requireRecordSnapshot); while (recordIterator.hasNext()) { - processor.process(recordIterator.next(), properColumnBuilders, passThroughIndexBuilder); + processor.process( + recordIterator.next(), properColumnBuilders, passThroughIndexBuilder, ioTDBLocal); } consumeCurrentPartitionState(); resultTsBlocks.addAll(buildTsBlock(properColumnBuilders, passThroughIndexBuilder)); @@ -251,6 +259,10 @@ private void consumeCurrentSourceTsBlock() { isBlocked = null; } + private void destroyProcessor(TableFunctionDataProcessor dataProcessor) { + dataProcessor.beforeDestroy(ioTDBLocal); + } + @Override public boolean hasNext() throws Exception { return !finished || !resultTsBlocks.isEmpty(); @@ -261,8 +273,10 @@ public void close() throws Exception { partitionCache.close(); inputOperator.close(); if (processor != null) { - processor.beforeDestroy(); + destroyProcessor(processor); + processor = null; } + ioTDBLocal.close(); } @Override diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/AccumulatorFactory.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/AccumulatorFactory.java index a37f1bef0c64d..d2b40c742d549 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/AccumulatorFactory.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/AccumulatorFactory.java @@ -65,7 +65,9 @@ import org.apache.iotdb.commons.queryengine.plan.relational.type.InternalTypeManager; import org.apache.iotdb.commons.queryengine.plan.udf.TableUDFUtils; import org.apache.iotdb.commons.udf.utils.UDFDataTypeTransformer; +import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFException; import org.apache.iotdb.udf.api.relational.AggregateFunction; import com.google.common.collect.ImmutableList; @@ -78,6 +80,8 @@ import org.apache.tsfile.read.common.type.TypeFactory; import org.apache.tsfile.write.UnSupportedDataTypeException; +import javax.annotation.Nullable; + import java.util.Arrays; import java.util.List; import java.util.Map; @@ -86,6 +90,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; +import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkState; import static java.util.Objects.requireNonNull; import static org.apache.iotdb.calc.plan.relational.planner.ir.GlobalTimePredicateExtractVisitor.isMeasurementColumn; @@ -110,13 +115,41 @@ public static TableAccumulator createAccumulator( Set measurementColumnNames, boolean distinct, MemoryReservationManager memoryReservationManager) { + return createAccumulator( + functionName, + aggregationType, + inputDataTypes, + inputExpressions, + inputAttributes, + ascending, + isAggTableScan, + timeColumnName, + measurementColumnNames, + distinct, + memoryReservationManager, + null); + } + + public static TableAccumulator createAccumulator( + String functionName, + TAggregationType aggregationType, + List inputDataTypes, + List inputExpressions, + Map inputAttributes, + boolean ascending, + boolean isAggTableScan, + String timeColumnName, + Set measurementColumnNames, + boolean distinct, + MemoryReservationManager memoryReservationManager, + @Nullable IoTDBLocal ioTDBLocal) { TableAccumulator result; // Input expression size of 1 indicates aggregation split has occurred and this is a final // aggregation if (aggregationType == TAggregationType.UDAF) { // If UDAF accumulator receives raw input, it needs to check input's attribute - result = createUDAFAccumulator(functionName, inputDataTypes, inputAttributes); + result = createUDAFAccumulator(functionName, inputDataTypes, inputAttributes, ioTDBLocal); } else if ((LAST_BY.getFunctionName().equals(functionName) || FIRST_BY.getFunctionName().equals(functionName)) && inputExpressions.size() > 1) { @@ -193,11 +226,34 @@ public static GroupedAccumulator createGroupedAccumulator( boolean ascending, boolean distinct, MemoryReservationManager memoryReservationManager) { + return createGroupedAccumulator( + functionName, + aggregationType, + inputDataTypes, + inputExpressions, + inputAttributes, + ascending, + distinct, + memoryReservationManager, + null); + } + + public static GroupedAccumulator createGroupedAccumulator( + String functionName, + TAggregationType aggregationType, + List inputDataTypes, + List inputExpressions, + Map inputAttributes, + boolean ascending, + boolean distinct, + MemoryReservationManager memoryReservationManager, + @Nullable IoTDBLocal ioTDBLocal) { GroupedAccumulator result; if (aggregationType == TAggregationType.UDAF) { // If UDAF accumulator receives raw input, it needs to check input's attribute - result = createGroupedUDAFAccumulator(functionName, inputDataTypes, inputAttributes); + result = + createGroupedUDAFAccumulator(functionName, inputDataTypes, inputAttributes, ioTDBLocal); } else { result = createBuiltinGroupedAccumulator( @@ -222,28 +278,54 @@ public static GroupedAccumulator createGroupedAccumulator( } private static TableAccumulator createUDAFAccumulator( - String functionName, List inputDataTypes, Map inputAttributes) { + String functionName, + List inputDataTypes, + Map inputAttributes, + IoTDBLocal ioTDBLocal) { + checkArgument(ioTDBLocal != null, "IoTDBLocal must not be null for UDAF"); AggregateFunction aggregateFunction = TableUDFUtils.getAggregateFunction(functionName); FunctionArguments functionArguments = new FunctionArguments( UDFDataTypeTransformer.transformToUDFDataTypeList(inputDataTypes), inputAttributes); - aggregateFunction.beforeStart(functionArguments); + try { + aggregateFunction.beforeStart(functionArguments, ioTDBLocal); + } catch (UDFException e) { + throw new RuntimeException( + "Error occurs when starting user-defined aggregate function " + + aggregateFunction.getClass().getName(), + e); + } return new UserDefinedAggregateFunctionAccumulator( aggregateFunction.analyze(functionArguments), aggregateFunction, - inputDataTypes.stream().map(TypeFactory::getType).collect(Collectors.toList())); + functionArguments, + inputDataTypes.stream().map(TypeFactory::getType).collect(Collectors.toList()), + ioTDBLocal); } private static GroupedAccumulator createGroupedUDAFAccumulator( - String functionName, List inputDataTypes, Map inputAttributes) { + String functionName, + List inputDataTypes, + Map inputAttributes, + IoTDBLocal ioTDBLocal) { + checkArgument(ioTDBLocal != null, "IoTDBLocal must not be null for UDAF"); AggregateFunction aggregateFunction = TableUDFUtils.getAggregateFunction(functionName); FunctionArguments functionArguments = new FunctionArguments( UDFDataTypeTransformer.transformToUDFDataTypeList(inputDataTypes), inputAttributes); - aggregateFunction.beforeStart(functionArguments); + try { + aggregateFunction.beforeStart(functionArguments, ioTDBLocal); + } catch (UDFException e) { + throw new RuntimeException( + "Error occurs when starting user-defined aggregate function " + + aggregateFunction.getClass().getName(), + e); + } return new GroupedUserDefinedAggregateAccumulator( aggregateFunction, - inputDataTypes.stream().map(TypeFactory::getType).collect(Collectors.toList())); + functionArguments, + inputDataTypes.stream().map(TypeFactory::getType).collect(Collectors.toList()), + ioTDBLocal); } private static GroupedAccumulator createBuiltinGroupedAccumulator( diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java index cd6d0dc1101e9..0e1d38f54e449 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java @@ -20,8 +20,10 @@ package org.apache.iotdb.calc.execution.operator.source.relational.aggregation; import org.apache.iotdb.calc.i18n.CalcMessages; +import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.State; import org.apache.iotdb.udf.api.customizer.analysis.AggregateFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; import org.apache.iotdb.udf.api.relational.AggregateFunction; import org.apache.iotdb.udf.api.utils.ResultValue; @@ -46,17 +48,24 @@ public class UserDefinedAggregateFunctionAccumulator implements TableAccumulator RamUsageEstimator.shallowSizeOfInstance(UserDefinedAggregateFunctionAccumulator.class); private final AggregateFunctionAnalysis analysis; private final AggregateFunction aggregateFunction; + private final FunctionArguments functionArguments; private final List inputDataTypes; private final State state; + private final IoTDBLocal ioTDBLocal; public UserDefinedAggregateFunctionAccumulator( AggregateFunctionAnalysis analysis, AggregateFunction aggregateFunction, - List inputDataTypes) { + FunctionArguments functionArguments, + List inputDataTypes, + IoTDBLocal ioTDBLocal) { + checkArgument(ioTDBLocal != null, "IoTDBLocal must not be null for UDAF"); this.analysis = analysis; this.aggregateFunction = aggregateFunction; + this.functionArguments = functionArguments; this.inputDataTypes = inputDataTypes; this.state = aggregateFunction.createState(); + this.ioTDBLocal = ioTDBLocal; } @Override @@ -66,7 +75,8 @@ public long getEstimatedSize() { @Override public TableAccumulator copy() { - return new UserDefinedAggregateFunctionAccumulator(analysis, aggregateFunction, inputDataTypes); + return new UserDefinedAggregateFunctionAccumulator( + analysis, aggregateFunction, functionArguments, inputDataTypes, ioTDBLocal); } @Override @@ -77,7 +87,7 @@ public void addInput(Column[] arguments, AggregationMask mask) { Arrays.asList(arguments), inputDataTypes, arguments[0].getPositionCount()) : new MaskedRecordIterator(Arrays.asList(arguments), inputDataTypes, mask); while (iterator.hasNext()) { - aggregateFunction.addInput(state, iterator.next()); + aggregateFunction.addInput(state, iterator.next(), ioTDBLocal); } } @@ -93,7 +103,7 @@ public void addIntermediate(Column argument) { otherState.reset(); Binary otherStateBinary = argument.getBinary(i); otherState.deserialize(otherStateBinary.getValues()); - aggregateFunction.combineState(state, otherState); + aggregateFunction.combineState(state, otherState, ioTDBLocal); } } @@ -109,7 +119,7 @@ public void evaluateIntermediate(ColumnBuilder columnBuilder) { @Override public void evaluateFinal(ColumnBuilder columnBuilder) { ResultValue resultValue = new ResultValue(columnBuilder); - aggregateFunction.outputFinal(state, resultValue); + aggregateFunction.outputFinal(state, resultValue, ioTDBLocal); } @Override @@ -150,7 +160,8 @@ public boolean removable() { @Override public void close() { - aggregateFunction.beforeDestroy(); + aggregateFunction.beforeDestroy(ioTDBLocal); + ioTDBLocal.close(); state.destroyState(); } } diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/grouped/GroupedUserDefinedAggregateAccumulator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/grouped/GroupedUserDefinedAggregateAccumulator.java index 2ef228b06624b..5cffef0110501 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/grouped/GroupedUserDefinedAggregateAccumulator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/grouped/GroupedUserDefinedAggregateAccumulator.java @@ -24,7 +24,9 @@ import org.apache.iotdb.calc.execution.operator.source.relational.aggregation.RecordIterator; import org.apache.iotdb.calc.execution.operator.source.relational.aggregation.grouped.array.ObjectBigArray; import org.apache.iotdb.calc.i18n.CalcMessages; +import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.State; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; import org.apache.iotdb.udf.api.relational.AggregateFunction; import org.apache.iotdb.udf.api.utils.ResultValue; @@ -47,14 +49,22 @@ public class GroupedUserDefinedAggregateAccumulator implements GroupedAccumulato private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(GroupedUserDefinedAggregateAccumulator.class); private final AggregateFunction aggregateFunction; + private final FunctionArguments functionArguments; private final ObjectBigArray stateArray; private final List inputDataTypes; + private final IoTDBLocal ioTDBLocal; public GroupedUserDefinedAggregateAccumulator( - AggregateFunction aggregateFunction, List inputDataTypes) { + AggregateFunction aggregateFunction, + FunctionArguments functionArguments, + List inputDataTypes, + IoTDBLocal ioTDBLocal) { + checkArgument(ioTDBLocal != null, "IoTDBLocal must not be null for UDAF"); this.aggregateFunction = aggregateFunction; + this.functionArguments = functionArguments; this.stateArray = new ObjectBigArray<>(); this.inputDataTypes = inputDataTypes; + this.ioTDBLocal = ioTDBLocal; } @Override @@ -90,7 +100,7 @@ public void addInput(int[] groupIds, Column[] arguments, AggregationMask mask) { int groupId = groupIds[index]; index++; State state = getOrCreateState(groupId); - aggregateFunction.addInput(state, iterator.next()); + aggregateFunction.addInput(state, iterator.next(), ioTDBLocal); } } else { int[] selectedPositions = mask.getSelectedPositions(); @@ -98,7 +108,7 @@ public void addInput(int[] groupIds, Column[] arguments, AggregationMask mask) { int groupId = groupIds[selectedPositions[index]]; index++; State state = getOrCreateState(groupId); - aggregateFunction.addInput(state, iterator.next()); + aggregateFunction.addInput(state, iterator.next(), ioTDBLocal); } } } @@ -116,7 +126,7 @@ public void addIntermediate(int[] groupIds, Column argument) { State otherState = aggregateFunction.createState(); Binary otherStateBinary = argument.getBinary(i); otherState.deserialize(otherStateBinary.getValues()); - aggregateFunction.combineState(getOrCreateState(groupIds[i]), otherState); + aggregateFunction.combineState(getOrCreateState(groupIds[i]), otherState, ioTDBLocal); } } } @@ -137,7 +147,7 @@ public void evaluateIntermediate(int groupId, ColumnBuilder columnBuilder) { @Override public void evaluateFinal(int groupId, ColumnBuilder columnBuilder) { ResultValue resultValue = new ResultValue(columnBuilder); - aggregateFunction.outputFinal(getOrCreateState(groupId), resultValue); + aggregateFunction.outputFinal(getOrCreateState(groupId), resultValue, ioTDBLocal); } @Override @@ -152,7 +162,8 @@ public void reset() { @Override public void close() { - aggregateFunction.beforeDestroy(); + aggregateFunction.beforeDestroy(ioTDBLocal); + ioTDBLocal.close(); stateArray.forEach( state -> { if (state != null) { diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java index 6454bd38d472e..d423db6dba63a 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java @@ -109,6 +109,7 @@ import org.apache.iotdb.calc.transformation.dag.column.ColumnTransformer; import org.apache.iotdb.calc.transformation.dag.column.leaf.LeafColumnTransformer; import org.apache.iotdb.calc.utils.datastructure.SortKey; +import org.apache.iotdb.common.rpc.thrift.TAggregationType; import org.apache.iotdb.commons.exception.SemanticException; import org.apache.iotdb.commons.queryengine.common.SessionInfo; import org.apache.iotdb.commons.queryengine.plan.analyze.ITableTypeProvider; @@ -1352,7 +1353,8 @@ protected AggregationOperator planGlobalAggregation( false, null, Collections.emptySet(), - operatorContext.getMemoryReservationContext()))); + operatorContext.getMemoryReservationContext(), + context))); return createAggregationOperator(operatorContext, child, aggregatorBuilder.build()); } @@ -1367,7 +1369,8 @@ protected TableAggregator buildAggregator( boolean isAggTableScan, String timeColumnName, Set measurementColumnNames, - MemoryReservationManager memoryReservationManager) { + MemoryReservationManager memoryReservationManager, + C context) { List argumentChannels = new ArrayList<>(); for (Expression argument : aggregation.getArguments()) { Symbol argumentSymbol = Symbol.from(argument); @@ -1379,6 +1382,10 @@ protected TableAggregator buildAggregator( aggregation.getResolvedFunction().getSignature().getArgumentTypes().stream() .map(InternalTypeManager::getTSDataType) .collect(Collectors.toList()); + IoTDBLocal ioTDBLocal = + getAggregationTypeByFuncName(functionName) == TAggregationType.UDAF + ? createIoTDBLocal(context) + : null; TableAccumulator accumulator = createAccumulator( functionName, @@ -1391,7 +1398,8 @@ protected TableAggregator buildAggregator( timeColumnName, measurementColumnNames, aggregation.isDistinct(), - memoryReservationManager); + memoryReservationManager, + ioTDBLocal); OptionalInt maskChannel = OptionalInt.empty(); if (aggregation.hasMask()) { @@ -1434,7 +1442,8 @@ protected Operator planGroupByAggregation( false, null, Collections.emptySet(), - context.getMemoryReservationManager()))); + context.getMemoryReservationManager(), + context))); CommonOperatorContext operatorContext = addOperatorContext( @@ -1462,7 +1471,8 @@ protected Operator planGroupByAggregation( v, node.getStep(), typeProvider, - context.getMemoryReservationManager()))); + context.getMemoryReservationManager(), + context))); Set preGroupedKeys = ImmutableSet.copyOf(node.getPreGroupedSymbols()); List groupingKeys = node.getGroupingKeys(); @@ -1519,7 +1529,8 @@ protected Operator planGroupByAggregation( v, node.getStep(), typeProvider, - context.getMemoryReservationManager()))); + context.getMemoryReservationManager(), + context))); CommonOperatorContext operatorContext = addOperatorContext( context, node.getPlanNodeId(), HashAggregationOperator.class.getSimpleName()); @@ -1644,7 +1655,8 @@ protected GroupedAggregator buildGroupByAggregator( AggregationNode.Aggregation aggregation, AggregationNode.Step step, ITableTypeProvider typeProvider, - MemoryReservationManager memoryReservationManager) { + MemoryReservationManager memoryReservationManager, + C context) { List argumentChannels = new ArrayList<>(); for (Expression argument : aggregation.getArguments()) { Symbol argumentSymbol = Symbol.from(argument); @@ -1656,6 +1668,10 @@ protected GroupedAggregator buildGroupByAggregator( aggregation.getResolvedFunction().getSignature().getArgumentTypes().stream() .map(InternalTypeManager::getTSDataType) .collect(Collectors.toList()); + IoTDBLocal ioTDBLocal = + getAggregationTypeByFuncName(functionName) == TAggregationType.UDAF + ? createIoTDBLocal(context) + : null; GroupedAccumulator accumulator = createGroupedAccumulator( functionName, @@ -1665,7 +1681,8 @@ protected GroupedAggregator buildGroupByAggregator( Collections.emptyMap(), true, aggregation.isDistinct(), - memoryReservationManager); + memoryReservationManager, + ioTDBLocal); OptionalInt maskChannel = OptionalInt.empty(); if (aggregation.hasMask()) { @@ -1694,7 +1711,9 @@ public Operator visitTableFunctionProcessor(TableFunctionProcessorNode node, C c CommonOperatorContext operatorContext = addOperatorContext( context, node.getPlanNodeId(), TableFunctionLeafOperator.class.getSimpleName()); - return new TableFunctionLeafOperator(operatorContext, processorProvider, outputDataTypes); + IoTDBLocal ioTDBLocal = createIoTDBLocal(context); + return new TableFunctionLeafOperator( + operatorContext, processorProvider, outputDataTypes, ioTDBLocal); } else { Operator operator = node.getChild().accept(this, context); CommonOperatorContext operatorContext = @@ -1739,6 +1758,7 @@ public Operator visitTableFunctionProcessor(TableFunctionProcessorNode node, C c } else { partitionChannels = Collections.emptyList(); } + IoTDBLocal ioTDBLocal = createIoTDBLocal(context); return new TableFunctionOperator( operatorContext, processorProvider, @@ -1752,7 +1772,8 @@ public Operator visitTableFunctionProcessor(TableFunctionProcessorNode node, C c .map(TableFunctionNode.PassThroughSpecification::isDeclaredAsPassThrough) .orElse(false), partitionChannels, - node.isRequireRecordSnapshot()); + node.isRequireRecordSnapshot(), + ioTDBLocal); } } @@ -2491,6 +2512,17 @@ public Operator visitTopKRanking(TopKRankingNode node, C context) { protected abstract SessionInfo getSessionInfo(C context); + protected IoTDBLocal createIoTDBLocal(C context) { + IoTDBLocalFactory factory = getIoTDBLocalFactory(context); + String fragmentInstanceId = getFragmentInstanceId(context); + String queryId = getQueryId(context); + checkArgument(factory != null, "IoTDBLocalFactory must not be null for UDF execution"); + checkArgument( + fragmentInstanceId != null, "fragmentInstanceId must not be null for UDF execution"); + checkArgument(queryId != null, "queryId must not be null for UDF execution"); + return factory.create(getSessionInfo(context), fragmentInstanceId, queryId); + } + /** Factory for creating {@link IoTDBLocal} inside UDF column transformers. */ @FunctionalInterface public interface IoTDBLocalFactory { diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java index 97383309a485c..f7d1e9dc9fd63 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java @@ -1466,7 +1466,8 @@ public Operator visitNonAlignedAggregationTreeDeviceViewScan( true, timeColumnName, measurementColumnsIndexMap.keySet(), - context.getMemoryReservationManager())); + context.getMemoryReservationManager(), + context)); } ITableTimeRangeIterator timeRangeIterator = null; diff --git a/log b/log new file mode 100644 index 0000000000000..37034a9feecec --- /dev/null +++ b/log @@ -0,0 +1,1924 @@ +2026-06-25 15:50:13 +Full thread dump OpenJDK 64-Bit Server VM (17.0.8.1+1-LTS mixed mode, sharing): + +Threads class SMR info: +_java_thread_list=0x0000600003afb840, length=136, elements={ +0x000000013480e200, 0x000000013300de00, 0x000000013408d000, 0x000000013300e400, +0x000000013408a200, 0x0000000135008200, 0x000000013300ea00, 0x0000000122015e00, +0x0000000122017a00, 0x000000011301ac00, 0x000000012700a200, 0x000000013480ce00, +0x0000000122019000, 0x0000000122018000, 0x0000000122078600, 0x0000000134a59e00, +0x000000012241fa00, 0x000000011361ce00, 0x0000000134bec200, 0x000000011363be00, +0x00000001358f0a00, 0x0000000134777a00, 0x00000001336d6800, 0x0000000134d8b600, +0x0000000134d7aa00, 0x0000000134d70800, 0x00000001358e9000, 0x0000000134def800, +0x00000001226e1e00, 0x000000013595de00, 0x0000000134d0ce00, 0x00000001226ef800, +0x00000001347c9000, 0x0000000122696200, 0x000000012262e200, 0x0000000133743e00, +0x00000001137eaa00, 0x0000000135952c00, 0x00000001347d2000, 0x000000013594f400, +0x0000000122632a00, 0x00000001347d4400, 0x00000001347c0200, 0x0000000135959c00, +0x0000000134d3e800, 0x0000000122629c00, 0x0000000122612200, 0x000000012264e000, +0x00000001226c6600, 0x00000001226dc000, 0x000000012268da00, 0x00000001347a7c00, +0x00000001347fdc00, 0x000000013595a200, 0x000000013379ce00, 0x000000013375c400, +0x000000013379b600, 0x000000032201ee00, 0x0000000322061c00, 0x0000000137a0c400, +0x00000003059fc200, 0x00000001379c1600, 0x0000000127869200, 0x0000000322027e00, +0x00000003059c8e00, 0x00000003220b1800, 0x0000000322106e00, 0x000000032215ac00, +0x0000000322161c00, 0x0000000137aa2c00, 0x0000000322151800, 0x0000000322197c00, +0x0000000305a7ee00, 0x0000000137b07e00, 0x000000011208e400, 0x00000003061f5800, +0x000000030620ca00, 0x0000000135dc8e00, 0x000000030623da00, 0x0000000135e31c00, +0x0000000137c02400, 0x00000003222a4600, 0x0000000322288800, 0x0000000135e91a00, +0x00000003222b3800, 0x000000011333fe00, 0x000000013599ec00, 0x000000012270de00, +0x0000000113338e00, 0x00000001359c4400, 0x00000001359d1800, 0x000000030587a400, +0x0000000137909200, 0x00000001350baa00, 0x00000001350b4800, 0x0000000127896c00, +0x0000000127053800, 0x000000012258b400, 0x0000000322671600, 0x00000003224b4c00, +0x0000000113071800, 0x0000000137ee1a00, 0x000000013207d200, 0x000000012243c200, +0x0000000137865800, 0x0000000134cd6800, 0x00000001130ae800, 0x0000000305940000, +0x0000000305867c00, 0x0000000122840400, 0x00000001120d5a00, 0x00000001320b0a00, +0x0000000127053e00, 0x000000012704f000, 0x000000012785d800, 0x00000001320b1000, +0x000000012283d000, 0x00000001350ef000, 0x0000000122856000, 0x00000001320b1600, +0x000000012280a600, 0x0000000127872e00, 0x0000000127859200, 0x000000012787a800, +0x000000012280ac00, 0x0000000113087a00, 0x0000000137865200, 0x0000000137d02c00, +0x0000000134efe400, 0x00000001358d5600, 0x0000000305944200, 0x000000013477e600, +0x0000000113060800, 0x0000000122664600, 0x0000000122194e00, 0x0000000122598c00 +} + +"Reference Handler" #2 daemon prio=10 os_prio=31 cpu=1.67ms elapsed=140.98s tid=0x000000013480e200 nid=0x4a03 waiting on condition [0x000000016ebaa000] + java.lang.Thread.State: RUNNABLE + at java.lang.ref.Reference.waitForReferencePendingList(java.base@17.0.8.1/Native Method) + at java.lang.ref.Reference.processPendingReferences(java.base@17.0.8.1/Reference.java:253) + at java.lang.ref.Reference$ReferenceHandler.run(java.base@17.0.8.1/Reference.java:215) + +"Finalizer" #3 daemon prio=8 os_prio=31 cpu=0.12ms elapsed=140.98s tid=0x000000013300de00 nid=0x4d03 in Object.wait() [0x000000016edb6000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e0178ad8> (a java.lang.ref.ReferenceQueue$Lock) + at java.lang.ref.ReferenceQueue.remove(java.base@17.0.8.1/ReferenceQueue.java:155) + - locked <0x00000006e0178ad8> (a java.lang.ref.ReferenceQueue$Lock) + at java.lang.ref.ReferenceQueue.remove(java.base@17.0.8.1/ReferenceQueue.java:176) + at java.lang.ref.Finalizer$FinalizerThread.run(java.base@17.0.8.1/Finalizer.java:172) + +"Signal Dispatcher" #4 daemon prio=9 os_prio=31 cpu=0.41ms elapsed=140.98s tid=0x000000013408d000 nid=0x7b03 waiting on condition [0x0000000000000000] + java.lang.Thread.State: RUNNABLE + +"Service Thread" #5 daemon prio=9 os_prio=31 cpu=7.12ms elapsed=140.98s tid=0x000000013300e400 nid=0x7903 runnable [0x0000000000000000] + java.lang.Thread.State: RUNNABLE + +"Monitor Deflation Thread" #6 daemon prio=9 os_prio=31 cpu=4.70ms elapsed=140.98s tid=0x000000013408a200 nid=0x5d03 runnable [0x0000000000000000] + java.lang.Thread.State: RUNNABLE + +"C2 CompilerThread0" #7 daemon prio=9 os_prio=31 cpu=2556.76ms elapsed=140.98s tid=0x0000000135008200 nid=0x7803 waiting on condition [0x0000000000000000] + java.lang.Thread.State: RUNNABLE + No compile task + +"C1 CompilerThread0" #10 daemon prio=9 os_prio=31 cpu=719.18ms elapsed=140.98s tid=0x000000013300ea00 nid=0x7703 waiting on condition [0x0000000000000000] + java.lang.Thread.State: RUNNABLE + No compile task + +"Sweeper thread" #11 daemon prio=9 os_prio=31 cpu=1.77ms elapsed=140.98s tid=0x0000000122015e00 nid=0x7603 runnable [0x0000000000000000] + java.lang.Thread.State: RUNNABLE + +"Common-Cleaner" #12 daemon prio=8 os_prio=31 cpu=1.95ms elapsed=140.96s tid=0x0000000122017a00 nid=0x6103 in Object.wait() [0x000000016fd22000] + java.lang.Thread.State: TIMED_WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e0179a88> (a java.lang.ref.ReferenceQueue$Lock) + at java.lang.ref.ReferenceQueue.remove(java.base@17.0.8.1/ReferenceQueue.java:155) + - locked <0x00000006e0179a88> (a java.lang.ref.ReferenceQueue$Lock) + at jdk.internal.ref.CleanerImpl.run(java.base@17.0.8.1/CleanerImpl.java:140) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + at jdk.internal.misc.InnocuousThread.run(java.base@17.0.8.1/InnocuousThread.java:162) + +"JDWP Transport Listener: dt_socket" #13 daemon prio=10 os_prio=31 cpu=313.31ms elapsed=140.94s tid=0x000000011301ac00 nid=0x7403 runnable [0x0000000000000000] + java.lang.Thread.State: RUNNABLE + +"JDWP Event Helper Thread" #14 daemon prio=10 os_prio=31 cpu=185.66ms elapsed=140.94s tid=0x000000012700a200 nid=0x6403 runnable [0x0000000000000000] + java.lang.Thread.State: RUNNABLE + +"JDWP Command Reader" #15 daemon prio=10 os_prio=31 cpu=198.36ms elapsed=140.94s tid=0x000000013480ce00 nid=0x7203 runnable [0x0000000000000000] + java.lang.Thread.State: RUNNABLE + +"IntelliJ Suspend Helper" #16 daemon prio=5 os_prio=31 cpu=24.56ms elapsed=140.88s tid=0x0000000122019000 nid=0x6603 waiting on condition [0x000000030061e000] + java.lang.Thread.State: TIMED_WAITING (sleeping) + at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) + at com.intellij.rt.debugger.agent.SuspendHelper.suspendHelperLoopBody(SuspendHelper.java:29) + at com.intellij.rt.debugger.agent.SuspendHelper.access$000(SuspendHelper.java:5) + at com.intellij.rt.debugger.agent.SuspendHelper$1.run(SuspendHelper.java:15) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"CoarseTimer" #17 daemon prio=5 os_prio=31 cpu=4458.74ms elapsed=140.88s tid=0x0000000122018000 nid=0x6703 runnable [0x000000030082a000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:376) + at com.intellij.rt.debugger.agent.OverheadDetector$CoarseTimer$1.run(OverheadDetector.java:87) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"Notification Thread" #18 daemon prio=9 os_prio=31 cpu=10.36ms elapsed=140.82s tid=0x0000000122078600 nid=0x7003 runnable [0x0000000000000000] + java.lang.Thread.State: RUNNABLE + +"commons-pool-evictor" #21 daemon prio=5 os_prio=31 cpu=3.77ms elapsed=140.36s tid=0x0000000134a59e00 nid=0xa503 waiting on condition [0x00000003020ba000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e0881160> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-2-IoTDB-ACTIVE_LOAD_DIR_SCANNER-1" #22 prio=5 os_prio=31 cpu=28.20ms elapsed=139.89s tid=0x000000012241fa00 nid=0xa303 waiting on condition [0x00000003024d2000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e0d9da30> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-3-IoTDB-ACTIVE_LOAD_METRICS_COLLECTOR-1" #23 prio=5 os_prio=31 cpu=7.47ms elapsed=139.89s tid=0x000000011361ce00 nid=0x8c03 waiting on condition [0x00000003026de000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e0d9cb88> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"AsyncDataNodeIoTConsensusServiceClientPool-selector-24" #24 daemon prio=5 os_prio=31 cpu=0.44ms elapsed=139.85s tid=0x0000000134bec200 nid=0x8e03 runnable [0x00000003028ea000] + java.lang.Thread.State: RUNNABLE + at sun.nio.ch.KQueue.poll(java.base@17.0.8.1/Native Method) + at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@17.0.8.1/KQueueSelectorImpl.java:122) + at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@17.0.8.1/SelectorImpl.java:129) + - locked <0x00000006e0d9eab0> (a sun.nio.ch.Util$2) + - locked <0x00000006e0d9ea58> (a sun.nio.ch.KQueueSelectorImpl) + at sun.nio.ch.SelectorImpl.select(java.base@17.0.8.1/SelectorImpl.java:146) + at org.apache.thrift.async.TAsyncClientManager$SelectThread.run(TAsyncClientManager.java:97) + +"AsyncDataNodeIoTConsensusServiceClientPool-selector-25" #25 daemon prio=5 os_prio=31 cpu=0.26ms elapsed=139.85s tid=0x000000011363be00 nid=0xa103 runnable [0x0000000302af6000] + java.lang.Thread.State: RUNNABLE + at sun.nio.ch.KQueue.poll(java.base@17.0.8.1/Native Method) + at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@17.0.8.1/KQueueSelectorImpl.java:122) + at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@17.0.8.1/SelectorImpl.java:129) + - locked <0x00000006e0d9cf58> (a sun.nio.ch.Util$2) + - locked <0x00000006e0d9cf00> (a sun.nio.ch.KQueueSelectorImpl) + at sun.nio.ch.SelectorImpl.select(java.base@17.0.8.1/SelectorImpl.java:146) + at org.apache.thrift.async.TAsyncClientManager$SelectThread.run(TAsyncClientManager.java:97) + +"pool-14-IoTDB-WAL-Delete-1" #28 prio=5 os_prio=31 cpu=7.97ms elapsed=139.49s tid=0x00000001358f0a00 nid=0x9f07 waiting on condition [0x0000000302d02000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e0f9f170> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-15-IoTDB-Compaction-Schedule-1" #29 prio=5 os_prio=31 cpu=4.76ms elapsed=139.49s tid=0x0000000134777a00 nid=0x9e03 waiting on condition [0x0000000302f0e000] + java.lang.Thread.State: TIMED_WAITING (sleeping) + at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:55) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:35) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-15-IoTDB-Compaction-Schedule-2" #30 prio=5 os_prio=31 cpu=12.98ms elapsed=139.49s tid=0x00000001336d6800 nid=0x9c03 waiting on condition [0x000000030311a000] + java.lang.Thread.State: TIMED_WAITING (sleeping) + at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:55) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:35) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-15-IoTDB-Compaction-Schedule-3" #31 prio=5 os_prio=31 cpu=0.26ms elapsed=139.49s tid=0x0000000134d8b600 nid=0x9203 waiting on condition [0x0000000303326000] + java.lang.Thread.State: TIMED_WAITING (sleeping) + at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:55) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:35) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-15-IoTDB-Compaction-Schedule-4" #32 prio=5 os_prio=31 cpu=0.23ms elapsed=139.49s tid=0x0000000134d7aa00 nid=0x9a03 waiting on condition [0x0000000303532000] + java.lang.Thread.State: TIMED_WAITING (sleeping) + at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:55) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:35) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-15-IoTDB-Compaction-Schedule-5" #33 prio=5 os_prio=31 cpu=0.04ms elapsed=139.49s tid=0x0000000134d70800 nid=0x9403 waiting on condition [0x000000030373e000] + java.lang.Thread.State: TIMED_WAITING (sleeping) + at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.TTLScheduleTask.call(TTLScheduleTask.java:57) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.TTLScheduleTask.call(TTLScheduleTask.java:36) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-19-IoTDB-TableSizeIndexRecord-1" #36 prio=5 os_prio=31 cpu=32.96ms elapsed=139.47s tid=0x00000001358e9000 nid=0xaa03 waiting on condition [0x0000000303d62000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e0fabdd0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.LinkedBlockingQueue.poll(java.base@17.0.8.1/LinkedBlockingQueue.java:460) + at org.apache.iotdb.db.storageengine.dataregion.utils.tableDiskUsageIndex.TableDiskUsageIndex.run(TableDiskUsageIndex.java:73) + at org.apache.iotdb.db.storageengine.dataregion.utils.tableDiskUsageIndex.TableDiskUsageIndex$$Lambda$573/0x000000700140dc98.run(Unknown Source) + at org.apache.iotdb.commons.concurrent.WrappedRunnable$1.runMayThrow(WrappedRunnable.java:45) + at org.apache.iotdb.commons.concurrent.WrappedRunnable.run(WrappedRunnable.java:30) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:304) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-21-IoTDB-WAL-Serialize(node-test-2)-1" #39 prio=5 os_prio=31 cpu=0.13ms elapsed=139.24s tid=0x0000000134def800 nid=0xac03 waiting on condition [0x0000000304386000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b5898> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at org.apache.iotdb.db.storageengine.dataregion.wal.utils.MemoryControlledWALEntryQueue.take(MemoryControlledWALEntryQueue.java:73) + at org.apache.iotdb.db.storageengine.dataregion.wal.buffer.WALBuffer$SerializeTask.serialize(WALBuffer.java:256) + at org.apache.iotdb.db.storageengine.dataregion.wal.buffer.WALBuffer$SerializeTask.run(WALBuffer.java:243) + at org.apache.iotdb.commons.concurrent.WrappedRunnable$1.runMayThrow(WrappedRunnable.java:45) + at org.apache.iotdb.commons.concurrent.WrappedRunnable.run(WrappedRunnable.java:30) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-23-IoTDB-WAL-Serialize(node-test-1)-1" #40 prio=5 os_prio=31 cpu=0.16ms elapsed=139.23s tid=0x00000001226e1e00 nid=0xfa03 waiting on condition [0x000000030504a000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05aeb90> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at org.apache.iotdb.db.storageengine.dataregion.wal.utils.MemoryControlledWALEntryQueue.take(MemoryControlledWALEntryQueue.java:73) + at org.apache.iotdb.db.storageengine.dataregion.wal.buffer.WALBuffer$SerializeTask.serialize(WALBuffer.java:256) + at org.apache.iotdb.db.storageengine.dataregion.wal.buffer.WALBuffer$SerializeTask.run(WALBuffer.java:243) + at org.apache.iotdb.commons.concurrent.WrappedRunnable$1.runMayThrow(WrappedRunnable.java:45) + at org.apache.iotdb.commons.concurrent.WrappedRunnable.run(WrappedRunnable.java:30) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-25-IoTDB-Timed-Flush-Seq-Memtable-1" #42 prio=5 os_prio=31 cpu=0.80ms elapsed=139.22s tid=0x000000013595de00 nid=0xfd0b waiting on condition [0x0000000303f6e000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05bc580> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-26-IoTDB-Timed-Flush-Unseq-Memtable-1" #43 prio=5 os_prio=31 cpu=0.69ms elapsed=139.22s tid=0x0000000134d0ce00 nid=0xfe07 waiting on condition [0x000000030417a000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05bc7b0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"MPPDataExchangeRPC-Service" #45 prio=5 os_prio=31 cpu=0.31ms elapsed=139.20s tid=0x00000001226ef800 nid=0xf807 runnable [0x0000000305256000] + java.lang.Thread.State: RUNNABLE + at sun.nio.ch.Net.accept(java.base@17.0.8.1/Native Method) + at sun.nio.ch.NioSocketImpl.accept(java.base@17.0.8.1/NioSocketImpl.java:760) + at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:675) + at java.net.ServerSocket.platformImplAccept(java.base@17.0.8.1/ServerSocket.java:641) + at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:617) + at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:574) + at java.net.ServerSocket.accept(java.base@17.0.8.1/ServerSocket.java:532) + at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:131) + at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:35) + at org.apache.thrift.server.TThreadPoolServer.execute(TThreadPoolServer.java:153) + at org.apache.thrift.server.TThreadPoolServer.serve(TThreadPoolServer.java:139) + at org.apache.iotdb.commons.service.AbstractThriftServiceThread.run(AbstractThriftServiceThread.java:350) + +"Query-Worker-Thread-0" #46 prio=5 os_prio=31 cpu=51.89ms elapsed=139.08s tid=0x00000001347c9000 nid=0xad03 in Object.wait() [0x0000000305462000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) + at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) + - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) + +"Query-Worker-Thread-1" #47 prio=5 os_prio=31 cpu=0.83ms elapsed=139.08s tid=0x0000000122696200 nid=0xf603 in Object.wait() [0x000000030566e000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) + at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) + - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) + +"Query-Worker-Thread-2" #48 prio=5 os_prio=31 cpu=1.43ms elapsed=139.08s tid=0x000000012262e200 nid=0xf403 in Object.wait() [0x0000000306a06000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) + at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) + - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) + +"Query-Worker-Thread-3" #49 prio=5 os_prio=31 cpu=0.34ms elapsed=139.08s tid=0x0000000133743e00 nid=0xb003 in Object.wait() [0x0000000306c12000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) + at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) + - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) + +"Query-Worker-Thread-4" #50 prio=5 os_prio=31 cpu=2.19ms elapsed=139.08s tid=0x00000001137eaa00 nid=0xf203 in Object.wait() [0x0000000306e1e000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) + at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) + - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) + +"Query-Worker-Thread-5" #51 prio=5 os_prio=31 cpu=1.66ms elapsed=139.08s tid=0x0000000135952c00 nid=0xb103 in Object.wait() [0x000000030702a000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) + at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) + - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) + +"Query-Worker-Thread-6" #52 prio=5 os_prio=31 cpu=0.31ms elapsed=139.08s tid=0x00000001347d2000 nid=0xb203 in Object.wait() [0x0000000307236000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) + at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) + - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) + +"Query-Worker-Thread-7" #53 prio=5 os_prio=31 cpu=0.24ms elapsed=139.08s tid=0x000000013594f400 nid=0xef03 in Object.wait() [0x0000000307442000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) + at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) + - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) + +"Query-Worker-Thread-8" #54 prio=5 os_prio=31 cpu=2.27ms elapsed=139.08s tid=0x0000000122632a00 nid=0xb503 in Object.wait() [0x000000030764e000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) + at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) + - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) + +"Query-Worker-Thread-9" #55 prio=5 os_prio=31 cpu=17.25ms elapsed=139.08s tid=0x00000001347d4400 nid=0xed03 in Object.wait() [0x000000030785a000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) + at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) + - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) + +"Query-Worker-Thread-10" #56 prio=5 os_prio=31 cpu=6.12ms elapsed=139.08s tid=0x00000001347c0200 nid=0xec03 in Object.wait() [0x0000000307a66000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) + at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) + - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) + at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) + +"Query-Sentinel-Thread" #57 prio=5 os_prio=31 cpu=3.15ms elapsed=139.08s tid=0x0000000135959c00 nid=0xb803 in Object.wait() [0x0000000307c72000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e05c3540> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.L1PriorityQueue) + at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) + at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingQueue.poll(IndexedBlockingQueue.java:73) + - locked <0x00000006e05c3540> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.L1PriorityQueue) + at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) + +"pool-31-IoTDB-Compaction-Worker-1" #58 prio=5 os_prio=31 cpu=0.10ms elapsed=139.07s tid=0x0000000134d3e800 nid=0xba03 waiting on condition [0x0000000307e7e000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-31-IoTDB-Compaction-Worker-2" #59 prio=5 os_prio=31 cpu=0.09ms elapsed=139.07s tid=0x0000000122629c00 nid=0xea03 waiting on condition [0x0000000320206000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-31-IoTDB-Compaction-Worker-3" #60 prio=5 os_prio=31 cpu=0.05ms elapsed=139.07s tid=0x0000000122612200 nid=0xbb03 waiting on condition [0x0000000320412000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-31-IoTDB-Compaction-Worker-4" #61 prio=5 os_prio=31 cpu=0.04ms elapsed=139.07s tid=0x000000012264e000 nid=0xbc03 waiting on condition [0x000000032061e000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-31-IoTDB-Compaction-Worker-5" #62 prio=5 os_prio=31 cpu=0.04ms elapsed=139.07s tid=0x00000001226c6600 nid=0xe603 waiting on condition [0x000000032082a000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-31-IoTDB-Compaction-Worker-6" #63 prio=5 os_prio=31 cpu=0.10ms elapsed=139.07s tid=0x00000001226dc000 nid=0xbd03 waiting on condition [0x0000000320a36000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-31-IoTDB-Compaction-Worker-7" #64 prio=5 os_prio=31 cpu=0.06ms elapsed=139.07s tid=0x000000012268da00 nid=0xbe03 waiting on condition [0x0000000320c42000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-31-IoTDB-Compaction-Worker-8" #65 prio=5 os_prio=31 cpu=0.03ms elapsed=139.07s tid=0x00000001347a7c00 nid=0xe303 waiting on condition [0x0000000320e4e000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-31-IoTDB-Compaction-Worker-9" #66 prio=5 os_prio=31 cpu=0.07ms elapsed=139.07s tid=0x00000001347fdc00 nid=0xc003 waiting on condition [0x000000032105a000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-31-IoTDB-Compaction-Worker-10" #67 prio=5 os_prio=31 cpu=0.09ms elapsed=139.07s tid=0x000000013595a200 nid=0xc103 waiting on condition [0x0000000321266000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) + at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"AsyncDataNodeInternalServiceClientPool-selector-68" #68 daemon prio=5 os_prio=31 cpu=0.06ms elapsed=139.05s tid=0x000000013379ce00 nid=0xc203 runnable [0x0000000321472000] + java.lang.Thread.State: RUNNABLE + at sun.nio.ch.KQueue.poll(java.base@17.0.8.1/Native Method) + at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@17.0.8.1/KQueueSelectorImpl.java:122) + at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@17.0.8.1/SelectorImpl.java:129) + - locked <0x00000006e05bd480> (a sun.nio.ch.Util$2) + - locked <0x00000006e05bd370> (a sun.nio.ch.KQueueSelectorImpl) + at sun.nio.ch.SelectorImpl.select(java.base@17.0.8.1/SelectorImpl.java:146) + at org.apache.thrift.async.TAsyncClientManager$SelectThread.run(TAsyncClientManager.java:97) + +"AsyncDataNodeInternalServiceClientPool-selector-69" #69 daemon prio=5 os_prio=31 cpu=0.04ms elapsed=139.05s tid=0x000000013375c400 nid=0xc303 runnable [0x000000032167e000] + java.lang.Thread.State: RUNNABLE + at sun.nio.ch.KQueue.poll(java.base@17.0.8.1/Native Method) + at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@17.0.8.1/KQueueSelectorImpl.java:122) + at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@17.0.8.1/SelectorImpl.java:129) + - locked <0x00000006e05df0d0> (a sun.nio.ch.Util$2) + - locked <0x00000006e05df078> (a sun.nio.ch.KQueueSelectorImpl) + at sun.nio.ch.SelectorImpl.select(java.base@17.0.8.1/SelectorImpl.java:146) + at org.apache.thrift.async.TAsyncClientManager$SelectThread.run(TAsyncClientManager.java:97) + +"pool-33-IoTDB-Expired-Queries-Info-Clear-1" #70 prio=5 os_prio=31 cpu=7.23ms elapsed=139.04s tid=0x000000013379b600 nid=0xc403 waiting on condition [0x000000032188a000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b6268> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-38-IoTDB-ResourceControl-DataRegionDiskStatistics-1" #71 prio=5 os_prio=31 cpu=2.03ms elapsed=138.93s tid=0x000000032201ee00 nid=0xc603 waiting on condition [0x0000000321a96000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05df250> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"DataNodeInternalRPC-Service" #72 prio=5 os_prio=31 cpu=0.76ms elapsed=138.84s tid=0x0000000322061c00 nid=0xdd03 runnable [0x0000000321ca2000] + java.lang.Thread.State: RUNNABLE + at sun.nio.ch.Net.accept(java.base@17.0.8.1/Native Method) + at sun.nio.ch.NioSocketImpl.accept(java.base@17.0.8.1/NioSocketImpl.java:760) + at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:675) + at java.net.ServerSocket.platformImplAccept(java.base@17.0.8.1/ServerSocket.java:641) + at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:617) + at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:574) + at java.net.ServerSocket.accept(java.base@17.0.8.1/ServerSocket.java:532) + at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:131) + at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:35) + at org.apache.thrift.server.TThreadPoolServer.execute(TThreadPoolServer.java:153) + at org.apache.thrift.server.TThreadPoolServer.serve(TThreadPoolServer.java:139) + at org.apache.iotdb.commons.service.AbstractThriftServiceThread.run(AbstractThriftServiceThread.java:350) + +"pool-41-IoTDB-SubscriptionReceiverAgent-Timeout-Checker-1" #73 prio=5 os_prio=31 cpu=2.91ms elapsed=138.72s tid=0x0000000137a0c400 nid=0xdb03 waiting on condition [0x0000000321eae000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b6498> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-42-IoTDB-Subscription-Consensus-Prefetch-Executor-Pool-0-1" #74 prio=5 os_prio=31 cpu=0.10ms elapsed=138.72s tid=0x00000003059fc200 nid=0xc803 waiting on condition [0x0000000322a06000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b66e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at org.apache.iotdb.db.subscription.task.execution.ConsensusSubscriptionPrefetchExecutor.workerLoop(ConsensusSubscriptionPrefetchExecutor.java:148) + at org.apache.iotdb.db.subscription.task.execution.ConsensusSubscriptionPrefetchExecutor$$Lambda$763/0x00000070014ec6e8.run(Unknown Source) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-42-IoTDB-Subscription-Consensus-Prefetch-Executor-Pool-0-2" #75 prio=5 os_prio=31 cpu=0.15ms elapsed=138.72s tid=0x00000001379c1600 nid=0xd803 waiting on condition [0x0000000322c12000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b66e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at org.apache.iotdb.db.subscription.task.execution.ConsensusSubscriptionPrefetchExecutor.workerLoop(ConsensusSubscriptionPrefetchExecutor.java:148) + at org.apache.iotdb.db.subscription.task.execution.ConsensusSubscriptionPrefetchExecutor$$Lambda$763/0x00000070014ec6e8.run(Unknown Source) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-5-IoTDB-Pipe-Runtime-Periodical-Job-Executor-1" #76 prio=5 os_prio=31 cpu=7.64ms elapsed=138.70s tid=0x0000000127869200 nid=0xd603 waiting on condition [0x0000000322e1e000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e0d9f980> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-6-IoTDB-Pipe-Runtime-Periodical-Phantom-Reference-Cleaner-1" #77 prio=5 os_prio=31 cpu=9.76ms elapsed=138.70s tid=0x0000000322027e00 nid=0xc903 waiting on condition [0x000000032302a000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e0da0998> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-44-IoTDB-General-Region-Attribute-Security-Service-1" #78 prio=5 os_prio=31 cpu=1.28ms elapsed=138.69s tid=0x00000003059c8e00 nid=0xd403 waiting on condition [0x0000000323236000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05d8180> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1757) + at org.apache.iotdb.commons.service.AbstractPeriodicalServiceWithAdvance.execute(AbstractPeriodicalServiceWithAdvance.java:66) + at org.apache.iotdb.commons.service.AbstractPeriodicalServiceWithAdvance$$Lambda$1520/0x0000007001759f28.run(Unknown Source) + at org.apache.iotdb.commons.concurrent.WrappedRunnable$1.runMayThrow(WrappedRunnable.java:45) + at org.apache.iotdb.commons.concurrent.WrappedRunnable.run(WrappedRunnable.java:30) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"1-groupManagement" #80 prio=5 os_prio=31 cpu=30.94ms elapsed=138.49s tid=0x00000003220b1800 nid=0xcc03 waiting on condition [0x000000032364e000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05d1640> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-45-IoTDB-Fragment-Instance-Management-1" #81 prio=5 os_prio=31 cpu=13.12ms elapsed=138.48s tid=0x0000000322106e00 nid=0xd103 waiting on condition [0x000000032385a000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05e1c20> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"1@group-000200000000-cacheEviction-AwaitToRun" #82 daemon prio=5 os_prio=31 cpu=0.28ms elapsed=138.38s tid=0x000000032215ac00 nid=0xcf03 waiting on condition [0x0000000323a66000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05e57c8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at org.apache.ratis.util.AwaitForSignal.await(AwaitForSignal.java:48) + at org.apache.ratis.util.AwaitToRun$RunnableImpl.run(AwaitToRun.java:47) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"1@group-000200000000-SegmentedRaftLogWorker" #83 prio=5 os_prio=31 cpu=11.16ms elapsed=138.34s tid=0x0000000322161c00 nid=0x10003 waiting on condition [0x0000000324c76000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05e1e50> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at org.apache.ratis.util.DataBlockingQueue.poll(DataBlockingQueue.java:148) + at org.apache.ratis.server.raftlog.segmented.SegmentedRaftLogWorker.run(SegmentedRaftLogWorker.java:309) + at org.apache.ratis.server.raftlog.segmented.SegmentedRaftLogWorker$$Lambda$1054/0x00000070016061f0.run(Unknown Source) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"1@group-000200000000-StateMachineUpdater" #85 daemon prio=5 os_prio=31 cpu=47.88ms elapsed=138.33s tid=0x0000000137aa2c00 nid=0x15203 waiting on condition [0x000000032508e000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05d8428> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1757) + at org.apache.ratis.util.AwaitForSignal.await(AwaitForSignal.java:65) + at org.apache.ratis.server.impl.StateMachineUpdater.waitForCommit(StateMachineUpdater.java:223) + at org.apache.ratis.server.impl.StateMachineUpdater.run(StateMachineUpdater.java:188) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"grpc-nio-boss-ELG-1-1" #86 daemon prio=5 os_prio=31 cpu=26.69ms elapsed=138.33s tid=0x0000000322151800 nid=0x15003 runnable [0x000000032529a000] + java.lang.Thread.State: RUNNABLE + at sun.nio.ch.KQueue.poll(java.base@17.0.8.1/Native Method) + at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@17.0.8.1/KQueueSelectorImpl.java:122) + at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@17.0.8.1/SelectorImpl.java:129) + - locked <0x00000006e05af0a8> (a org.apache.ratis.thirdparty.io.netty.channel.nio.SelectedSelectionKeySet) + - locked <0x00000006e05af050> (a sun.nio.ch.KQueueSelectorImpl) + at sun.nio.ch.SelectorImpl.select(java.base@17.0.8.1/SelectorImpl.java:146) + at org.apache.ratis.thirdparty.io.netty.channel.nio.SelectedSelectionKeySetSelector.select(SelectedSelectionKeySetSelector.java:68) + at org.apache.ratis.thirdparty.io.netty.channel.nio.NioEventLoop.select(NioEventLoop.java:887) + at org.apache.ratis.thirdparty.io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:526) + at org.apache.ratis.thirdparty.io.netty.util.concurrent.SingleThreadEventExecutor$4.run(SingleThreadEventExecutor.java:998) + at org.apache.ratis.thirdparty.io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74) + at org.apache.ratis.thirdparty.io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"JvmPauseMonitor0" #87 daemon prio=5 os_prio=31 cpu=65.42ms elapsed=138.30s tid=0x0000000322197c00 nid=0x10303 waiting on condition [0x00000003254a6000] + java.lang.Thread.State: TIMED_WAITING (sleeping) + at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) + at java.lang.Thread.sleep(java.base@17.0.8.1/Thread.java:337) + at java.util.concurrent.TimeUnit.sleep(java.base@17.0.8.1/TimeUnit.java:446) + at org.apache.ratis.util.TimeDuration.sleep(TimeDuration.java:353) + at org.apache.ratis.util.TimeDuration.sleep(TimeDuration.java:338) + at org.apache.ratis.util.JvmPauseMonitor.detectPause(JvmPauseMonitor.java:160) + at org.apache.ratis.util.JvmPauseMonitor.run(JvmPauseMonitor.java:149) + at org.apache.ratis.util.JvmPauseMonitor$$Lambda$1086/0x00000070016233a0.run(Unknown Source) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-9-IoTDB-RatisBgDiskGuardian-1" #88 prio=5 os_prio=31 cpu=3.46ms elapsed=138.29s tid=0x0000000305a7ee00 nid=0x10503 waiting on condition [0x00000003256b2000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e0e20a00> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"IoTConsensusRPC-Service" #89 prio=5 os_prio=31 cpu=0.09ms elapsed=138.28s tid=0x0000000137b07e00 nid=0x14e03 runnable [0x00000003258be000] + java.lang.Thread.State: RUNNABLE + at sun.nio.ch.Net.accept(java.base@17.0.8.1/Native Method) + at sun.nio.ch.NioSocketImpl.accept(java.base@17.0.8.1/NioSocketImpl.java:760) + at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:675) + at java.net.ServerSocket.platformImplAccept(java.base@17.0.8.1/ServerSocket.java:641) + at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:617) + at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:574) + at java.net.ServerSocket.accept(java.base@17.0.8.1/ServerSocket.java:532) + at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:131) + at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:35) + at org.apache.thrift.server.TThreadPoolServer.execute(TThreadPoolServer.java:153) + at org.apache.thrift.server.TThreadPoolServer.serve(TThreadPoolServer.java:139) + at org.apache.iotdb.commons.service.AbstractThriftServiceThread.run(AbstractThriftServiceThread.java:350) + +"1@group-000200000000-LeaderStateImpl" #91 daemon prio=5 os_prio=31 cpu=12.36ms elapsed=138.24s tid=0x000000011208e400 nid=0x15307 waiting on condition [0x0000000324e82000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05c3960> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ArrayBlockingQueue.poll(java.base@17.0.8.1/ArrayBlockingQueue.java:435) + at org.apache.ratis.server.impl.LeaderStateImpl$EventQueue.poll(LeaderStateImpl.java:168) + at org.apache.ratis.server.impl.LeaderStateImpl$EventProcessor.run(LeaderStateImpl.java:763) + +"pool-40-IoTDB-DataNodeInternalRPC-Processor-1" #92 prio=5 os_prio=31 cpu=70.49ms elapsed=138.18s tid=0x00000003061f5800 nid=0x10707 runnable [0x0000000325ac9000] + java.lang.Thread.State: RUNNABLE + at sun.nio.ch.SocketDispatcher.read0(java.base@17.0.8.1/Native Method) + at sun.nio.ch.SocketDispatcher.read(java.base@17.0.8.1/SocketDispatcher.java:47) + at sun.nio.ch.NioSocketImpl.tryRead(java.base@17.0.8.1/NioSocketImpl.java:266) + at sun.nio.ch.NioSocketImpl.implRead(java.base@17.0.8.1/NioSocketImpl.java:317) + at sun.nio.ch.NioSocketImpl.read(java.base@17.0.8.1/NioSocketImpl.java:355) + at sun.nio.ch.NioSocketImpl$1.read(java.base@17.0.8.1/NioSocketImpl.java:808) + at java.net.Socket$SocketInputStream.read(java.base@17.0.8.1/Socket.java:966) + at java.io.BufferedInputStream.fill(java.base@17.0.8.1/BufferedInputStream.java:244) + at java.io.BufferedInputStream.read1(java.base@17.0.8.1/BufferedInputStream.java:284) + at java.io.BufferedInputStream.read(java.base@17.0.8.1/BufferedInputStream.java:343) + - locked <0x00000006e05e7b28> (a java.io.BufferedInputStream) + at org.apache.thrift.transport.TIOStreamTransport.read(TIOStreamTransport.java:176) + at org.apache.thrift.transport.TTransport.readAll(TTransport.java:109) + at org.apache.iotdb.rpc.TElasticFramedTransport.readFrame(TElasticFramedTransport.java:176) + at org.apache.iotdb.rpc.TElasticFramedTransport.read(TElasticFramedTransport.java:130) + at org.apache.thrift.transport.TTransport.readAll(TTransport.java:109) + at org.apache.thrift.protocol.TBinaryProtocol.readAll(TBinaryProtocol.java:463) + at org.apache.thrift.protocol.TBinaryProtocol.readI32(TBinaryProtocol.java:361) + at org.apache.thrift.protocol.TBinaryProtocol.readMessageBegin(TBinaryProtocol.java:244) + at org.apache.thrift.TBaseProcessor.process(TBaseProcessor.java:27) + at org.apache.thrift.server.TThreadPoolServer$WorkerProcess.run(TThreadPoolServer.java:248) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-8-IoTDB-IoTConsensusBackgroundTaskExecutor-1" #93 prio=5 os_prio=31 cpu=0.08ms elapsed=138.17s tid=0x000000030620ca00 nid=0x14c03 waiting on condition [0x0000000325cd6000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e0e20e28> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"boundedElastic-evictor-1" #94 daemon prio=5 os_prio=31 cpu=0.64ms elapsed=138.11s tid=0x0000000135dc8e00 nid=0x14b03 waiting on condition [0x0000000325ee2000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e117ed70> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"reactor-http-nio-1" #95 daemon prio=5 os_prio=31 cpu=1.77ms elapsed=138.04s tid=0x000000030623da00 nid=0x14a03 runnable [0x00000003260ee000] + java.lang.Thread.State: RUNNABLE + at sun.nio.ch.KQueue.poll(java.base@17.0.8.1/Native Method) + at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@17.0.8.1/KQueueSelectorImpl.java:122) + at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@17.0.8.1/SelectorImpl.java:129) + - locked <0x00000006e11bf670> (a io.netty.channel.nio.SelectedSelectionKeySet) + - locked <0x00000006e11bf618> (a sun.nio.ch.KQueueSelectorImpl) + at sun.nio.ch.SelectorImpl.select(java.base@17.0.8.1/SelectorImpl.java:146) + at io.netty.channel.nio.SelectedSelectionKeySetSelector.select(SelectedSelectionKeySetSelector.java:68) + at io.netty.channel.nio.NioEventLoop.select(NioEventLoop.java:887) + at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:526) + at io.netty.util.concurrent.SingleThreadEventExecutor$4.run(SingleThreadEventExecutor.java:998) + at io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74) + at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-50-IoTDB-JVM-GC-Statistics-Monitor-1" #96 prio=5 os_prio=31 cpu=11.20ms elapsed=137.96s tid=0x0000000135e31c00 nid=0x14903 waiting on condition [0x00000003262fa000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e118ef78> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"ClientRPC-Service" #97 prio=5 os_prio=31 cpu=0.81ms elapsed=137.91s tid=0x0000000137c02400 nid=0x10b03 runnable [0x0000000326506000] + java.lang.Thread.State: RUNNABLE + at sun.nio.ch.Net.accept(java.base@17.0.8.1/Native Method) + at sun.nio.ch.NioSocketImpl.accept(java.base@17.0.8.1/NioSocketImpl.java:760) + at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:675) + at java.net.ServerSocket.platformImplAccept(java.base@17.0.8.1/ServerSocket.java:641) + at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:617) + at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:574) + at java.net.ServerSocket.accept(java.base@17.0.8.1/ServerSocket.java:532) + at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:131) + at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:35) + at org.apache.thrift.server.TThreadPoolServer.execute(TThreadPoolServer.java:153) + at org.apache.thrift.server.TThreadPoolServer.serve(TThreadPoolServer.java:139) + at org.apache.iotdb.commons.service.AbstractThriftServiceThread.run(AbstractThriftServiceThread.java:350) + +"pool-52-IoTDB-BinaryAllocator-SampleEvictor-1" #98 prio=5 os_prio=31 cpu=11.33ms elapsed=137.90s tid=0x00000003222a4600 nid=0x14603 waiting on condition [0x0000000326712000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e11af388> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-53-IoTDB-BinaryAllocator-Auto-Releaser-1" #99 prio=5 os_prio=31 cpu=0.05ms elapsed=137.90s tid=0x0000000322288800 nid=0x10d03 in Object.wait() [0x000000032691e000] + java.lang.Thread.State: WAITING (on object monitor) + at java.lang.Object.wait(java.base@17.0.8.1/Native Method) + - waiting on <0x00000006e11cf798> (a java.lang.ref.ReferenceQueue$Lock) + at java.lang.ref.ReferenceQueue.remove(java.base@17.0.8.1/ReferenceQueue.java:155) + - locked <0x00000006e11cf798> (a java.lang.ref.ReferenceQueue$Lock) + at java.lang.ref.ReferenceQueue.remove(java.base@17.0.8.1/ReferenceQueue.java:176) + at org.apache.iotdb.commons.binaryallocator.BinaryAllocator$AutoReleaser.run(BinaryAllocator.java:301) + at org.apache.iotdb.commons.concurrent.WrappedRunnable$1.runMayThrow(WrappedRunnable.java:45) + at org.apache.iotdb.commons.concurrent.WrappedRunnable.run(WrappedRunnable.java:30) + at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"DestroyJavaVM" #100 prio=5 os_prio=31 cpu=1649.84ms elapsed=137.80s tid=0x0000000135e91a00 nid=0x2203 waiting on condition [0x0000000000000000] + java.lang.Thread.State: RUNNABLE + +"pool-51-IoTDB-ClientRPC-Processor-1$20260625_074908_00006_1" #101 prio=5 os_prio=31 cpu=364.76ms elapsed=93.39s tid=0x00000003222b3800 nid=0x5a07 waiting on condition [0x0000000301ead000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e4917990> (a java.util.concurrent.FutureTask) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:211) + at java.util.concurrent.FutureTask.awaitDone(java.base@17.0.8.1/FutureTask.java:447) + at java.util.concurrent.FutureTask.get(java.base@17.0.8.1/FutureTask.java:190) + at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.topologicalParallelDispatchRead(FragmentInstanceDispatcherImpl.java:163) + at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.dispatch(FragmentInstanceDispatcherImpl.java:136) + at org.apache.iotdb.db.queryengine.plan.scheduler.ClusterScheduler.start(ClusterScheduler.java:117) + at org.apache.iotdb.db.queryengine.plan.relational.planner.TableModelPlanner.doSchedule(TableModelPlanner.java:212) + at org.apache.iotdb.db.queryengine.plan.execution.QueryExecution.schedule(QueryExecution.java:283) + at org.apache.iotdb.db.queryengine.plan.execution.QueryExecution.start(QueryExecution.java:205) + at org.apache.iotdb.db.queryengine.plan.Coordinator.execution(Coordinator.java:349) + at org.apache.iotdb.db.queryengine.plan.Coordinator.execution(Coordinator.java:311) + at org.apache.iotdb.db.queryengine.plan.Coordinator.executeForTableModel(Coordinator.java:506) + at org.apache.iotdb.db.protocol.thrift.impl.ClientRPCServiceImpl.executeStatementInternal(ClientRPCServiceImpl.java:459) + at org.apache.iotdb.db.protocol.thrift.impl.ClientRPCServiceImpl.executeStatementV2(ClientRPCServiceImpl.java:1157) + at org.apache.iotdb.service.rpc.thrift.IClientRPCService$Processor$executeStatementV2.getResult(IClientRPCService.java:4283) + at org.apache.iotdb.service.rpc.thrift.IClientRPCService$Processor$executeStatementV2.getResult(IClientRPCService.java:4263) + at org.apache.thrift.ProcessFunction.process(ProcessFunction.java:38) + at org.apache.iotdb.db.protocol.thrift.ProcessorWithMetrics.process(ProcessorWithMetrics.java:64) + at org.apache.thrift.server.TThreadPoolServer$WorkerProcess.run(TThreadPoolServer.java:248) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-1" #103 prio=5 os_prio=31 cpu=0.61ms elapsed=93.06s tid=0x000000011333fe00 nid=0x10f03 waiting on condition [0x0000000326d36000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-2" #104 prio=5 os_prio=31 cpu=0.19ms elapsed=92.98s tid=0x000000013599ec00 nid=0x11103 waiting on condition [0x0000000326f42000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-3" #105 prio=5 os_prio=31 cpu=1.26ms elapsed=92.95s tid=0x000000012270de00 nid=0x14403 waiting on condition [0x000000032714e000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-4" #106 prio=5 os_prio=31 cpu=0.20ms elapsed=92.93s tid=0x0000000113338e00 nid=0x11303 waiting on condition [0x000000032735a000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-46-IoTDB-Fragment-Instance-Notification-1" #107 prio=5 os_prio=31 cpu=5.10ms elapsed=89.98s tid=0x00000001359c4400 nid=0x11503 waiting on condition [0x0000000327566000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05f5740> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-46-IoTDB-Fragment-Instance-Notification-2" #108 prio=5 os_prio=31 cpu=4.81ms elapsed=89.96s tid=0x00000001359d1800 nid=0x11703 waiting on condition [0x0000000327772000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05f5740> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-46-IoTDB-Fragment-Instance-Notification-3" #109 prio=5 os_prio=31 cpu=7.14ms elapsed=89.96s tid=0x000000030587a400 nid=0x14103 waiting on condition [0x000000032797e000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05f5740> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-46-IoTDB-Fragment-Instance-Notification-4" #110 prio=5 os_prio=31 cpu=3.19ms elapsed=89.96s tid=0x0000000137909200 nid=0x11803 waiting on condition [0x0000000327b8a000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05f5740> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-5" #111 prio=5 os_prio=31 cpu=0.38ms elapsed=89.51s tid=0x00000001350baa00 nid=0x11903 waiting on condition [0x0000000327d96000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-1" #112 prio=5 os_prio=31 cpu=4.40ms elapsed=89.51s tid=0x00000001350b4800 nid=0x13d03 waiting on condition [0x0000000327fa2000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1170) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-6" #113 prio=5 os_prio=31 cpu=0.23ms elapsed=89.50s tid=0x0000000127896c00 nid=0x13c03 waiting on condition [0x00000003281ae000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-2" #114 prio=5 os_prio=31 cpu=0.48ms elapsed=89.50s tid=0x0000000127053800 nid=0x11c03 waiting on condition [0x00000003283ba000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1170) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-3" #115 prio=5 os_prio=31 cpu=1.23ms elapsed=89.49s tid=0x000000012258b400 nid=0x13b03 waiting on condition [0x00000003285c6000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-7" #116 prio=5 os_prio=31 cpu=0.23ms elapsed=89.46s tid=0x0000000322671600 nid=0x13a03 waiting on condition [0x00000003287d2000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-8" #117 prio=5 os_prio=31 cpu=0.12ms elapsed=89.46s tid=0x00000003224b4c00 nid=0x12003 waiting on condition [0x00000003289de000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-1" #118 prio=5 os_prio=31 cpu=5.35ms elapsed=88.76s tid=0x0000000113071800 nid=0x12203 waiting on condition [0x0000000328bea000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-2" #119 prio=5 os_prio=31 cpu=49.50ms elapsed=88.75s tid=0x0000000137ee1a00 nid=0x12403 waiting on condition [0x0000000328df6000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-3" #120 prio=5 os_prio=31 cpu=34.92ms elapsed=88.75s tid=0x000000013207d200 nid=0x12503 waiting on condition [0x0000000329002000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-9" #121 prio=5 os_prio=31 cpu=0.17ms elapsed=88.16s tid=0x000000012243c200 nid=0x12603 waiting on condition [0x000000032920e000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-10" #122 prio=5 os_prio=31 cpu=0.15ms elapsed=88.16s tid=0x0000000137865800 nid=0x12703 waiting on condition [0x000000032941a000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-11" #123 prio=5 os_prio=31 cpu=0.13ms elapsed=88.16s tid=0x0000000134cd6800 nid=0x13503 waiting on condition [0x0000000329626000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-12" #124 prio=5 os_prio=31 cpu=0.15ms elapsed=88.16s tid=0x00000001130ae800 nid=0x12803 waiting on condition [0x0000000329832000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-13" #125 prio=5 os_prio=31 cpu=0.11ms elapsed=88.16s tid=0x0000000305940000 nid=0x13203 waiting on condition [0x0000000329a3e000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-14" #126 prio=5 os_prio=31 cpu=0.07ms elapsed=88.16s tid=0x0000000305867c00 nid=0x13003 waiting on condition [0x0000000329c4a000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-15" #127 prio=5 os_prio=31 cpu=0.17ms elapsed=86.81s tid=0x0000000122840400 nid=0x12e03 waiting on condition [0x0000000329e56000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-16" #128 prio=5 os_prio=31 cpu=0.26ms elapsed=86.81s tid=0x00000001120d5a00 nid=0x12c03 waiting on condition [0x000000032a062000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-17" #129 prio=5 os_prio=31 cpu=0.31ms elapsed=86.17s tid=0x00000001320b0a00 nid=0x12a03 waiting on condition [0x000000032a26e000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-4" #130 prio=5 os_prio=31 cpu=0.73ms elapsed=86.17s tid=0x0000000127053e00 nid=0x15503 waiting on condition [0x000000032a47a000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-18" #131 prio=5 os_prio=31 cpu=0.23ms elapsed=86.17s tid=0x000000012704f000 nid=0x1ff03 waiting on condition [0x000000032a686000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-5" #132 prio=5 os_prio=31 cpu=1.81ms elapsed=86.17s tid=0x000000012785d800 nid=0x15803 waiting on condition [0x000000032a892000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-29-IoTDB-Driver-Task-Scheduler-Notification-1" #133 prio=5 os_prio=31 cpu=0.70ms elapsed=86.17s tid=0x00000001320b1000 nid=0x15903 waiting on condition [0x000000032aa9e000] + java.lang.Thread.State: TIMED_WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e06fb1a8> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:401) + at java.util.concurrent.SynchronousQueue.poll(java.base@17.0.8.1/SynchronousQueue.java:903) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1061) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-6" #134 prio=5 os_prio=31 cpu=0.39ms elapsed=86.17s tid=0x000000012283d000 nid=0x1fc03 waiting on condition [0x000000032acaa000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-19" #135 prio=5 os_prio=31 cpu=0.33ms elapsed=86.16s tid=0x00000001350ef000 nid=0x1fa03 waiting on condition [0x000000032aeb6000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-34-IoTDB-MPP-Coordinator-Executor-20" #136 prio=5 os_prio=31 cpu=0.24ms elapsed=84.91s tid=0x0000000122856000 nid=0x1f803 waiting on condition [0x000000032b0c2000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-4" #137 prio=5 os_prio=31 cpu=1.36ms elapsed=84.91s tid=0x00000001320b1600 nid=0x1f703 waiting on condition [0x000000032b2ce000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-7" #138 prio=5 os_prio=31 cpu=0.35ms elapsed=84.90s tid=0x000000012280a600 nid=0x1f503 waiting on condition [0x000000032b4da000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-5" #139 prio=5 os_prio=31 cpu=1.79ms elapsed=84.90s tid=0x0000000127872e00 nid=0x1f403 waiting on condition [0x000000032b6e6000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-6" #140 prio=5 os_prio=31 cpu=1.27ms elapsed=84.90s tid=0x0000000127859200 nid=0x15c03 waiting on condition [0x000000032b8f2000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-8" #141 prio=5 os_prio=31 cpu=0.29ms elapsed=84.90s tid=0x000000012787a800 nid=0x15d03 waiting on condition [0x000000032bafe000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-9" #142 prio=5 os_prio=31 cpu=0.28ms elapsed=84.90s tid=0x000000012280ac00 nid=0x15e03 waiting on condition [0x000000032bd0a000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-10" #143 prio=5 os_prio=31 cpu=0.09ms elapsed=84.84s tid=0x0000000113087a00 nid=0x1ef03 waiting on condition [0x000000032bf16000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) + at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-7" #144 prio=5 os_prio=31 cpu=0.87ms elapsed=64.45s tid=0x0000000137865200 nid=0xd207 waiting on condition [0x000000030394a000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-8$20260625_074909_00009_1" #145 prio=5 os_prio=31 cpu=7.79ms elapsed=64.45s tid=0x0000000137d02c00 nid=0x9907 waiting on condition [0x0000000303b54000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e44e3888> (a java.util.concurrent.FutureTask) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:211) + at java.util.concurrent.FutureTask.awaitDone(java.base@17.0.8.1/FutureTask.java:447) + at java.util.concurrent.FutureTask.get(java.base@17.0.8.1/FutureTask.java:190) + at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.topologicalParallelDispatchRead(FragmentInstanceDispatcherImpl.java:163) + at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.dispatch(FragmentInstanceDispatcherImpl.java:136) + at org.apache.iotdb.db.queryengine.plan.scheduler.ClusterScheduler.start(ClusterScheduler.java:117) + at org.apache.iotdb.db.queryengine.plan.relational.planner.TableModelPlanner.doSchedule(TableModelPlanner.java:212) + at org.apache.iotdb.db.queryengine.plan.execution.QueryExecution.schedule(QueryExecution.java:283) + at org.apache.iotdb.db.queryengine.plan.execution.QueryExecution.start(QueryExecution.java:205) + at org.apache.iotdb.db.queryengine.plan.Coordinator.execution(Coordinator.java:349) + at org.apache.iotdb.db.queryengine.plan.Coordinator.execution(Coordinator.java:311) + at org.apache.iotdb.db.queryengine.plan.Coordinator.executeForTableModel(Coordinator.java:506) + at org.apache.iotdb.db.queryengine.udf.InternalQueryExecutor.executeInternalQuery(InternalQueryExecutor.java:84) + at org.apache.iotdb.db.queryengine.udf.IoTDBLocalImpl.query(IoTDBLocalImpl.java:68) + at org.apache.iotdb.db.queryengine.udf.DeviceNameFunction.beforeStart(DeviceNameFunction.java:52) + at org.apache.iotdb.calc.transformation.dag.column.udf.UserDefineScalarFunctionTransformer.(UserDefineScalarFunctionTransformer.java:59) + at org.apache.iotdb.calc.execution.relational.ColumnTransformerBuilder.getFunctionColumnTransformer(ColumnTransformerBuilder.java:1495) + at org.apache.iotdb.calc.execution.relational.ColumnTransformerBuilder.visitFunctionCall(ColumnTransformerBuilder.java:708) + at org.apache.iotdb.calc.execution.relational.ColumnTransformerBuilder.visitFunctionCall(ColumnTransformerBuilder.java:254) + at org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.FunctionCall.accept(FunctionCall.java:173) + at org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.CommonQueryAstVisitor.process(CommonQueryAstVisitor.java:34) + at org.apache.iotdb.calc.plan.planner.TableOperatorGenerator.constructFilterAndProjectOperator(TableOperatorGenerator.java:388) + at org.apache.iotdb.calc.plan.planner.TableOperatorGenerator.visitProject(TableOperatorGenerator.java:440) + at org.apache.iotdb.calc.plan.planner.TableOperatorGenerator.visitProject(TableOperatorGenerator.java:248) + at org.apache.iotdb.commons.queryengine.plan.relational.planner.node.ProjectNode.accept(ProjectNode.java:52) + at org.apache.iotdb.db.queryengine.plan.planner.DataNodeTableOperatorGenerator.visitIdentitySink(DataNodeTableOperatorGenerator.java:283) + at org.apache.iotdb.db.queryengine.plan.planner.DataNodeTableOperatorGenerator.visitIdentitySink(DataNodeTableOperatorGenerator.java:209) + at org.apache.iotdb.db.queryengine.plan.planner.plan.node.sink.IdentitySinkNode.accept(IdentitySinkNode.java:76) + at org.apache.iotdb.db.queryengine.plan.planner.LocalExecutionPlanner.generateOperator(LocalExecutionPlanner.java:186) + at org.apache.iotdb.db.queryengine.plan.planner.LocalExecutionPlanner.plan(LocalExecutionPlanner.java:113) + at org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceManager.lambda$execDataQueryFragmentInstance$3(FragmentInstanceManager.java:178) + at org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceManager$$Lambda$1891/0x00000070018dccd8.apply(Unknown Source) + at java.util.concurrent.ConcurrentHashMap.computeIfAbsent(java.base@17.0.8.1/ConcurrentHashMap.java:1708) + - locked <0x00000006e4973aa8> (a java.util.concurrent.ConcurrentHashMap$ReservationNode) + at org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceManager.execDataQueryFragmentInstance(FragmentInstanceManager.java:144) + at org.apache.iotdb.db.consensus.statemachine.dataregion.DataRegionStateMachine.read(DataRegionStateMachine.java:271) + at org.apache.iotdb.consensus.iot.IoTConsensusServerImpl.read(IoTConsensusServerImpl.java:345) + at org.apache.iotdb.consensus.iot.IoTConsensus.read(IoTConsensus.java:277) + at org.apache.iotdb.db.queryengine.execution.executor.RegionReadExecutor.execute(RegionReadExecutor.java:86) + at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.dispatchLocally(FragmentInstanceDispatcherImpl.java:652) + at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.dispatchOneInstance(FragmentInstanceDispatcherImpl.java:456) + at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.lambda$asyncDispatchOneInstance$0(FragmentInstanceDispatcherImpl.java:200) + at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl$$Lambda$1889/0x00000070018dbe60.call(Unknown Source) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-9" #146 prio=5 os_prio=31 cpu=7.59ms elapsed=64.45s tid=0x0000000134efe400 nid=0x9707 waiting on condition [0x0000000323442000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-10" #147 prio=5 os_prio=31 cpu=0.39ms elapsed=64.44s tid=0x00000001358d5600 nid=0x15f03 waiting on condition [0x000000032c122000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-11" #148 prio=5 os_prio=31 cpu=0.42ms elapsed=64.44s tid=0x0000000305944200 nid=0x1ed03 waiting on condition [0x000000032c32e000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-12" #149 prio=5 os_prio=31 cpu=0.31ms elapsed=64.44s tid=0x000000013477e600 nid=0x1ec03 waiting on condition [0x000000032c53a000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-13" #150 prio=5 os_prio=31 cpu=0.44ms elapsed=64.44s tid=0x0000000113060800 nid=0x1eb03 waiting on condition [0x000000032c746000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-14$20260625_074909_00009_1.2.0" #151 prio=5 os_prio=31 cpu=3.38ms elapsed=64.44s tid=0x0000000122664600 nid=0x1ea03 waiting for monitor entry [0x000000032c951000] + java.lang.Thread.State: BLOCKED (on object monitor) + at java.util.concurrent.ConcurrentHashMap.computeIfAbsent(java.base@17.0.8.1/ConcurrentHashMap.java:1726) + - waiting to lock <0x00000006e4973aa8> (a java.util.concurrent.ConcurrentHashMap$ReservationNode) + at org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceManager.execDataQueryFragmentInstance(FragmentInstanceManager.java:144) + at org.apache.iotdb.db.consensus.statemachine.dataregion.DataRegionStateMachine.read(DataRegionStateMachine.java:271) + at org.apache.iotdb.consensus.iot.IoTConsensusServerImpl.read(IoTConsensusServerImpl.java:345) + at org.apache.iotdb.consensus.iot.IoTConsensus.read(IoTConsensus.java:277) + at org.apache.iotdb.db.queryengine.execution.executor.RegionReadExecutor.execute(RegionReadExecutor.java:86) + at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.dispatchLocally(FragmentInstanceDispatcherImpl.java:652) + at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.dispatchOneInstance(FragmentInstanceDispatcherImpl.java:456) + at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.lambda$asyncDispatchOneInstance$0(FragmentInstanceDispatcherImpl.java:200) + at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl$$Lambda$1889/0x00000070018dbe60.call(Unknown Source) + at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) + at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"pool-36-IoTDB-Fragment-Instance-Dispatch-15" #152 prio=5 os_prio=31 cpu=0.38ms elapsed=64.44s tid=0x0000000122194e00 nid=0x1e903 waiting on condition [0x000000032cb5e000] + java.lang.Thread.State: WAITING (parking) + at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) + - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) + at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) + at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) + at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) + at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) + at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) + at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) + at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) + at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) + at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) + at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) + +"Attach Listener" #153 daemon prio=9 os_prio=31 cpu=0.55ms elapsed=0.10s tid=0x0000000122598c00 nid=0x890b waiting on condition [0x0000000000000000] + java.lang.Thread.State: RUNNABLE + +"VM Thread" os_prio=31 cpu=39.17ms elapsed=140.99s tid=0x0000000133b05780 nid=0x4803 runnable + +"GC Thread#0" os_prio=31 cpu=29.13ms elapsed=141.00s tid=0x0000000133905f30 nid=0x3903 runnable + +"GC Thread#1" os_prio=31 cpu=30.65ms elapsed=140.74s tid=0x0000000112e06f90 nid=0x6c03 runnable + +"GC Thread#2" os_prio=31 cpu=29.98ms elapsed=140.74s tid=0x0000000112e07490 nid=0x6903 runnable + +"GC Thread#3" os_prio=31 cpu=33.57ms elapsed=140.74s tid=0x0000000132e11aa0 nid=0x8003 runnable + +"GC Thread#4" os_prio=31 cpu=30.11ms elapsed=140.74s tid=0x000000013390e9d0 nid=0xa903 runnable + +"GC Thread#5" os_prio=31 cpu=32.41ms elapsed=140.74s tid=0x0000000132e12330 nid=0x8203 runnable + +"GC Thread#6" os_prio=31 cpu=32.46ms elapsed=140.74s tid=0x0000000132e12ba0 nid=0xa703 runnable + +"GC Thread#7" os_prio=31 cpu=28.41ms elapsed=140.61s tid=0x0000000133b1b7f0 nid=0x8503 runnable + +"GC Thread#8" os_prio=31 cpu=29.81ms elapsed=140.61s tid=0x0000000133b1baa0 nid=0x8703 runnable + +"G1 Main Marker" os_prio=31 cpu=0.35ms elapsed=141.00s tid=0x0000000132e05d40 nid=0x3403 runnable + +"G1 Conc#0" os_prio=31 cpu=14.46ms elapsed=141.00s tid=0x0000000133a052a0 nid=0x3603 runnable + +"G1 Conc#1" os_prio=31 cpu=18.60ms elapsed=140.01s tid=0x0000000133928620 nid=0x8b03 runnable + +"G1 Refine#0" os_prio=31 cpu=0.02ms elapsed=141.00s tid=0x0000000133a073d0 nid=0x5303 runnable + +"G1 Service" os_prio=31 cpu=6.41ms elapsed=141.00s tid=0x0000000133a07c70 nid=0x5203 runnable + +"VM Periodic Task Thread" os_prio=31 cpu=23.10ms elapsed=140.82s tid=0x0000000112f119a0 nid=0x6e03 waiting on condition + +JNI global refs: 184, weak refs: 10235 + From 5f18fc57d36fa575dd5ce4f3314a3bfe96a3e009 Mon Sep 17 00:00:00 2001 From: Weihao Li <18110526956@163.com> Date: Fri, 26 Jun 2026 00:12:24 +0800 Subject: [PATCH 04/11] fix timeout Signed-off-by: Weihao Li <18110526956@163.com> --- .../relational/ColumnTransformerBuilder.java | 19 ++++++++---- .../plan/planner/TableOperatorGenerator.java | 29 ++++++++++++++----- .../UserDefineScalarFunctionTransformer.java | 8 +++-- .../fragment/FragmentInstanceContext.java | 11 +++++++ .../fragment/FragmentInstanceManager.java | 1 + .../DataNodeTableOperatorGenerator.java | 5 ++++ .../planner/LocalExecutionPlanContext.java | 4 +++ .../SimpleFragmentParallelPlanner.java | 1 + .../plan/planner/plan/FragmentInstance.java | 15 ++++++++++ .../TableModelQueryFragmentPlanner.java | 1 + .../db/queryengine/udf/IoTDBLocalImpl.java | 29 ++++++++++--------- 11 files changed, 95 insertions(+), 28 deletions(-) diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java index ba0464b07777d..20d35fe0ab392 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java @@ -1956,7 +1956,9 @@ public static class Context { private final String fragmentInstanceId; - private final String outerQueryId; + private final String outerGlobalQueryId; + + private final long outerLocalQueryId; @Nullable private final IoTDBLocalFactory ioTDBLocalFactory; @@ -1986,6 +1988,7 @@ public Context( memoryReservationManager, null, null, + -1L, null); } @@ -2002,7 +2005,8 @@ public Context( ITypeMetadata metadata, @Nullable MemoryReservationManager memoryReservationManager, String fragmentInstanceId, - String outerQueryId, + String outerGlobalQueryId, + long outerLocalQueryId, @Nullable IoTDBLocalFactory ioTDBLocalFactory) { this.sessionInfo = sessionInfo; this.leafList = leafList; @@ -2016,7 +2020,8 @@ public Context( this.metadata = metadata; this.memoryReservationManager = Optional.ofNullable(memoryReservationManager); this.fragmentInstanceId = fragmentInstanceId; - this.outerQueryId = outerQueryId; + this.outerGlobalQueryId = outerGlobalQueryId; + this.outerLocalQueryId = outerLocalQueryId; this.ioTDBLocalFactory = ioTDBLocalFactory; } @@ -2028,8 +2033,12 @@ public String getFragmentInstanceId() { return fragmentInstanceId; } - public String getOuterQueryId() { - return outerQueryId; + public String getOuterGlobalQueryId() { + return outerGlobalQueryId; + } + + public long getOuterLocalQueryId() { + return outerLocalQueryId; } @Nullable diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java index d423db6dba63a..f12dadbb87ae7 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java @@ -317,7 +317,8 @@ protected Operator constructFilterAndProjectOperator( C context) { String fragmentInstanceId = getFragmentInstanceId(context); - String outerQueryId = getQueryId(context); + String outerGlobalQueryId = getQueryId(context); + long outerLocalQueryId = getLocalQueryId(context); IoTDBLocalFactory ioTDBLocalFactory = getIoTDBLocalFactory(context); final List filterOutputDataTypes = new ArrayList<>(inputDataTypes); @@ -349,7 +350,8 @@ protected Operator constructFilterAndProjectOperator( metadata, context.getMemoryReservationManager(), fragmentInstanceId, - outerQueryId, + outerGlobalQueryId, + outerLocalQueryId, ioTDBLocalFactory); return visitor.process(p, filterColumnTransformerContext); @@ -380,7 +382,8 @@ protected Operator constructFilterAndProjectOperator( metadata, context.getMemoryReservationManager(), fragmentInstanceId, - outerQueryId, + outerGlobalQueryId, + outerLocalQueryId, ioTDBLocalFactory); for (Expression expression : projectExpressions) { @@ -413,6 +416,10 @@ protected String getQueryId(C context) { return null; } + protected long getLocalQueryId(C context) { + return -1L; + } + protected IoTDBLocalFactory getIoTDBLocalFactory(C context) { return null; } @@ -2515,18 +2522,26 @@ public Operator visitTopKRanking(TopKRankingNode node, C context) { protected IoTDBLocal createIoTDBLocal(C context) { IoTDBLocalFactory factory = getIoTDBLocalFactory(context); String fragmentInstanceId = getFragmentInstanceId(context); - String queryId = getQueryId(context); + String outerGlobalQueryId = getQueryId(context); + long outerLocalQueryId = getLocalQueryId(context); checkArgument(factory != null, "IoTDBLocalFactory must not be null for UDF execution"); checkArgument( fragmentInstanceId != null, "fragmentInstanceId must not be null for UDF execution"); - checkArgument(queryId != null, "queryId must not be null for UDF execution"); - return factory.create(getSessionInfo(context), fragmentInstanceId, queryId); + checkArgument(outerGlobalQueryId != null, "queryId must not be null for UDF execution"); + checkArgument( + outerLocalQueryId >= 0, "outerLocalQueryId must not be negative for UDF execution"); + return factory.create( + getSessionInfo(context), fragmentInstanceId, outerLocalQueryId, outerGlobalQueryId); } /** Factory for creating {@link IoTDBLocal} inside UDF column transformers. */ @FunctionalInterface public interface IoTDBLocalFactory { - IoTDBLocal create(SessionInfo sessionInfo, String fragmentInstanceId, String queryId); + IoTDBLocal create( + SessionInfo sessionInfo, + String fragmentInstanceId, + long outerLocalQueryId, + String outerGlobalQueryId); } } diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java index ab2f99031d278..07d92d967f8c8 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java @@ -72,11 +72,15 @@ private static IoTDBLocal createIoTDBLocal(ColumnTransformerBuilder.Context cont IoTDBLocalFactory factory = context.getIoTDBLocalFactory(); if (factory == null || context.getFragmentInstanceId() == null - || context.getOuterQueryId() == null) { + || context.getOuterGlobalQueryId() == null + || context.getOuterLocalQueryId() < 0) { return null; } return factory.create( - context.getSessionInfo(), context.getFragmentInstanceId(), context.getOuterQueryId()); + context.getSessionInfo(), + context.getFragmentInstanceId(), + context.getOuterLocalQueryId(), + context.getOuterGlobalQueryId()); } @Override 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 6bda6e9c14d6e..a41660ef55640 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 @@ -152,6 +152,9 @@ public class FragmentInstanceContext extends QueryContext { // session info private SessionInfo sessionInfo; + // Coordinator-local query id of the outer query, used by IoTDBLocal UDF + private long localQueryId = -1L; + private final Map dataNodeQueryContextMap; private DataNodeQueryContext dataNodeQueryContext; @@ -206,6 +209,7 @@ public static FragmentInstanceContext createFragmentInstanceContext( IDataRegionForQuery dataRegion, TimePredicate globalTimePredicate, Map dataNodeQueryContextMap, + long localQueryId, boolean debug, boolean isVerbose) { FragmentInstanceContext instanceContext = @@ -216,6 +220,7 @@ public static FragmentInstanceContext createFragmentInstanceContext( dataRegion, globalTimePredicate, dataNodeQueryContextMap, + localQueryId, debug, isVerbose); instanceContext.initialize(); @@ -271,6 +276,7 @@ private FragmentInstanceContext( IDataRegionForQuery dataRegion, TimePredicate globalTimePredicate, Map dataNodeQueryContextMap, + long localQueryId, boolean debug, boolean verbose) { super(debug, verbose); @@ -278,6 +284,7 @@ private FragmentInstanceContext( this.stateMachine = stateMachine; this.executionEndTime.set(END_TIME_INITIAL_VALUE); this.sessionInfo = sessionInfo; + this.localQueryId = localQueryId; this.dataRegion = dataRegion; this.globalTimeFilter = globalTimePredicate == null @@ -567,6 +574,10 @@ public SessionInfo getSessionInfo() { return sessionInfo; } + public long getLocalQueryId() { + return localQueryId; + } + public Optional getFailureCause() { return Optional.ofNullable( stateMachine.getFailureCauses().stream() 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 e5f3cbc7e0d58..75e447de5861b 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 @@ -167,6 +167,7 @@ public FragmentInstanceInfo execDataQueryFragmentInstance( dataRegion, instance.getGlobalTimePredicate(), dataNodeQueryContextMap, + instance.getLocalQueryId(), instance.isDebug(), instance.isVerbose()); }); diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java index f7d1e9dc9fd63..aa748cde854c3 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java @@ -2115,6 +2115,11 @@ protected String getQueryId(LocalExecutionPlanContext context) { return context.getFragmentInstanceId().getQueryId().getId(); } + @Override + protected long getLocalQueryId(LocalExecutionPlanContext context) { + return context.getLocalQueryId(); + } + @Override protected IoTDBLocalFactory getIoTDBLocalFactory(LocalExecutionPlanContext context) { return IoTDBLocalImpl.FACTORY; diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LocalExecutionPlanContext.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LocalExecutionPlanContext.java index 6590870839472..c9172bb44ca9c 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LocalExecutionPlanContext.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LocalExecutionPlanContext.java @@ -198,6 +198,10 @@ public FragmentInstanceId getFragmentInstanceId() { return driverContext.getFragmentInstanceContext().getId(); } + public long getLocalQueryId() { + return driverContext.getFragmentInstanceContext().getLocalQueryId(); + } + public List getPipelineDriverFactories() { return pipelineDriverFactories; } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/SimpleFragmentParallelPlanner.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/SimpleFragmentParallelPlanner.java index 4e34d36147168..dec7c1917b6e5 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/SimpleFragmentParallelPlanner.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/SimpleFragmentParallelPlanner.java @@ -148,6 +148,7 @@ private void produceFragmentInstance(PlanFragment fragment) { queryContext.isDebug(), fragment.isRoot(), queryContext.isVerbose()); + fragmentInstance.setLocalQueryId(queryContext.getLocalQueryId()); selectExecutorAndHost( fragment, diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/FragmentInstance.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/FragmentInstance.java index 463aeb5413196..4cc98ee7d0676 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/FragmentInstance.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/FragmentInstance.java @@ -83,6 +83,9 @@ public class FragmentInstance implements IConsensusRequest { private final boolean debug; private final boolean verbose; + // Coordinator-local query id, used to look up IQueryExecution on DataNode + private long localQueryId = -1L; + // We can add some more params for a specific FragmentInstance // So that we can make different FragmentInstance owns different data range. @@ -269,6 +272,9 @@ public static FragmentInstance deserializeFrom(ByteBuffer buffer) { hasHostDataNode ? ThriftCommonsSerDeUtils.deserializeTDataNodeLocation(buffer) : null; fragmentInstance.isExplainAnalyze = ReadWriteIOUtils.readBool(buffer); fragmentInstance.setHighestPriority(ReadWriteIOUtils.readBool(buffer)); + if (buffer.hasRemaining()) { + fragmentInstance.setLocalQueryId(ReadWriteIOUtils.readLong(buffer)); + } return fragmentInstance; } @@ -296,6 +302,7 @@ public ByteBuffer serializeToByteBuffer() { } ReadWriteIOUtils.write(isExplainAnalyze, outputStream); ReadWriteIOUtils.write(isHighestPriority, outputStream); + ReadWriteIOUtils.write(localQueryId, outputStream); return ByteBuffer.wrap(publicBAOS.getBuf(), 0, publicBAOS.size()); } catch (IOException e) { LOGGER.error( @@ -342,6 +349,14 @@ public SessionInfo getSessionInfo() { return sessionInfo; } + public long getLocalQueryId() { + return localQueryId; + } + + public void setLocalQueryId(long localQueryId) { + this.localQueryId = localQueryId; + } + public boolean isExplainAnalyze() { return isExplainAnalyze; } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelQueryFragmentPlanner.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelQueryFragmentPlanner.java index f2942536cb552..e9695ec73f6ea 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelQueryFragmentPlanner.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelQueryFragmentPlanner.java @@ -186,6 +186,7 @@ private void produceFragmentInstance( queryContext.isDebug(), fragment.isRoot(), queryContext.isVerbose()); + fragmentInstance.setLocalQueryId(queryContext.getLocalQueryId()); selectExecutorAndHost( fragment, diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java index 47ee7d07f27e7..940288a83ac6d 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java @@ -23,7 +23,6 @@ import org.apache.iotdb.commons.exception.IoTDBException; import org.apache.iotdb.commons.exception.QueryTimeoutException; import org.apache.iotdb.commons.queryengine.common.SessionInfo; -import org.apache.iotdb.db.conf.IoTDBDescriptor; import org.apache.iotdb.db.queryengine.common.QueryId; import org.apache.iotdb.db.queryengine.plan.Coordinator; import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution; @@ -47,13 +46,19 @@ public class IoTDBLocalImpl implements IoTDBLocal { private final SessionInfo sessionInfo; private final String fragmentInstanceId; - private final QueryId outerQueryId; + private final long outerLocalQueryId; + private final QueryId outerGlobalQueryId; private final List openResultSets = new ArrayList<>(); - public IoTDBLocalImpl(SessionInfo sessionInfo, String fragmentInstanceId, String outerQueryId) { + public IoTDBLocalImpl( + SessionInfo sessionInfo, + String fragmentInstanceId, + long outerLocalQueryId, + String outerGlobalQueryId) { this.sessionInfo = sessionInfo; this.fragmentInstanceId = fragmentInstanceId; - this.outerQueryId = QueryId.valueOf(outerQueryId); + this.outerLocalQueryId = outerLocalQueryId; + this.outerGlobalQueryId = QueryId.valueOf(outerGlobalQueryId); } @Override @@ -66,7 +71,7 @@ public UDFResultSet query(String sql) throws UDFException { } InternalQueryResult result = InternalQueryExecutor.executeInternalQuery( - sessionInfo, fragmentInstanceId, outerQueryId, sql, timeoutMs); + sessionInfo, fragmentInstanceId, outerGlobalQueryId, sql, timeoutMs); int index = openResultSets.size(); UDFResultSetImpl rs = new UDFResultSetImpl(openResultSets, index, result); openResultSets.add(rs); @@ -92,16 +97,12 @@ public void close() { } private long computeRemainingTimeoutMs() { - long outerStart = System.currentTimeMillis(); - long outerTimeout = IoTDBDescriptor.getInstance().getConfig().getQueryTimeoutThreshold(); - for (IQueryExecution execution : COORDINATOR.getAllQueryExecutions()) { - if (outerQueryId.getId().equals(execution.getQueryId())) { - outerStart = execution.getStartExecutionTime(); - outerTimeout = execution.getTimeout(); - break; - } + IQueryExecution execution = COORDINATOR.getQueryExecution(outerLocalQueryId); + if (execution == null) { + return 0; } - return outerTimeout - (System.currentTimeMillis() - outerStart); + return execution.getTimeout() + - (System.currentTimeMillis() - execution.getStartExecutionTime()); } @Override From 0d161fe98abcb87d9d526fc772eb9d326bec32af Mon Sep 17 00:00:00 2001 From: Weihao Li <18110526956@163.com> Date: Fri, 26 Jun 2026 00:30:21 +0800 Subject: [PATCH 05/11] fix beforeStart of UDSF+UDAF Signed-off-by: Weihao Li <18110526956@163.com> --- .../relational/it/db/it/udf/IoTDBLocalIT.java | 6 -- .../aggregation/AccumulatorFactory.java | 17 ----- ...erDefinedAggregateFunctionAccumulator.java | 33 ++++++++- ...roupedUserDefinedAggregateAccumulator.java | 20 ++++++ .../UserDefineScalarFunctionTransformer.java | 69 ++++++++++--------- 5 files changed, 87 insertions(+), 58 deletions(-) diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java index d6fb2339ae29e..c50d360ba66a6 100644 --- a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java +++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java @@ -78,12 +78,6 @@ public class IoTDBLocalIT { "CLEAR ATTRIBUTE CACHE", }; - public static void main(String[] args) { - for (String sql : SETUP_SQLS) { - System.out.println(sql + ";"); - } - } - @BeforeClass public static void setUp() throws Exception { EnvFactory.getEnv().getConfig().getCommonConfig().setEnforceStrongPassword(false); diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/AccumulatorFactory.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/AccumulatorFactory.java index d2b40c742d549..f9d35cf67f529 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/AccumulatorFactory.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/AccumulatorFactory.java @@ -67,7 +67,6 @@ import org.apache.iotdb.commons.udf.utils.UDFDataTypeTransformer; import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; -import org.apache.iotdb.udf.api.exception.UDFException; import org.apache.iotdb.udf.api.relational.AggregateFunction; import com.google.common.collect.ImmutableList; @@ -287,14 +286,6 @@ private static TableAccumulator createUDAFAccumulator( FunctionArguments functionArguments = new FunctionArguments( UDFDataTypeTransformer.transformToUDFDataTypeList(inputDataTypes), inputAttributes); - try { - aggregateFunction.beforeStart(functionArguments, ioTDBLocal); - } catch (UDFException e) { - throw new RuntimeException( - "Error occurs when starting user-defined aggregate function " - + aggregateFunction.getClass().getName(), - e); - } return new UserDefinedAggregateFunctionAccumulator( aggregateFunction.analyze(functionArguments), aggregateFunction, @@ -313,14 +304,6 @@ private static GroupedAccumulator createGroupedUDAFAccumulator( FunctionArguments functionArguments = new FunctionArguments( UDFDataTypeTransformer.transformToUDFDataTypeList(inputDataTypes), inputAttributes); - try { - aggregateFunction.beforeStart(functionArguments, ioTDBLocal); - } catch (UDFException e) { - throw new RuntimeException( - "Error occurs when starting user-defined aggregate function " - + aggregateFunction.getClass().getName(), - e); - } return new GroupedUserDefinedAggregateAccumulator( aggregateFunction, functionArguments, diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java index 0e1d38f54e449..7bedcbbb03055 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java @@ -24,6 +24,7 @@ import org.apache.iotdb.udf.api.State; import org.apache.iotdb.udf.api.customizer.analysis.AggregateFunctionAnalysis; import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFException; import org.apache.iotdb.udf.api.relational.AggregateFunction; import org.apache.iotdb.udf.api.utils.ResultValue; @@ -52,6 +53,7 @@ public class UserDefinedAggregateFunctionAccumulator implements TableAccumulator private final List inputDataTypes; private final State state; private final IoTDBLocal ioTDBLocal; + private boolean init; public UserDefinedAggregateFunctionAccumulator( AggregateFunctionAnalysis analysis, @@ -59,6 +61,16 @@ public UserDefinedAggregateFunctionAccumulator( FunctionArguments functionArguments, List inputDataTypes, IoTDBLocal ioTDBLocal) { + this(analysis, aggregateFunction, functionArguments, inputDataTypes, ioTDBLocal, false); + } + + private UserDefinedAggregateFunctionAccumulator( + AggregateFunctionAnalysis analysis, + AggregateFunction aggregateFunction, + FunctionArguments functionArguments, + List inputDataTypes, + IoTDBLocal ioTDBLocal, + boolean init) { checkArgument(ioTDBLocal != null, "IoTDBLocal must not be null for UDAF"); this.analysis = analysis; this.aggregateFunction = aggregateFunction; @@ -66,6 +78,22 @@ public UserDefinedAggregateFunctionAccumulator( this.inputDataTypes = inputDataTypes; this.state = aggregateFunction.createState(); this.ioTDBLocal = ioTDBLocal; + this.init = init; + } + + private void initIfNeeded() { + if (init) { + return; + } + init = true; + try { + aggregateFunction.beforeStart(functionArguments, ioTDBLocal); + } catch (UDFException e) { + throw new RuntimeException( + "Error occurs when starting user-defined aggregate function " + + aggregateFunction.getClass().getName(), + e); + } } @Override @@ -76,11 +104,12 @@ public long getEstimatedSize() { @Override public TableAccumulator copy() { return new UserDefinedAggregateFunctionAccumulator( - analysis, aggregateFunction, functionArguments, inputDataTypes, ioTDBLocal); + analysis, aggregateFunction, functionArguments, inputDataTypes, ioTDBLocal, true); } @Override public void addInput(Column[] arguments, AggregationMask mask) { + initIfNeeded(); RecordIterator iterator = mask.isSelectAll() ? new RecordIterator( @@ -93,6 +122,7 @@ public void addInput(Column[] arguments, AggregationMask mask) { @Override public void addIntermediate(Column argument) { + initIfNeeded(); checkArgument( argument instanceof BinaryColumn || (argument instanceof RunLengthEncodedColumn @@ -118,6 +148,7 @@ public void evaluateIntermediate(ColumnBuilder columnBuilder) { @Override public void evaluateFinal(ColumnBuilder columnBuilder) { + initIfNeeded(); ResultValue resultValue = new ResultValue(columnBuilder); aggregateFunction.outputFinal(state, resultValue, ioTDBLocal); } diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/grouped/GroupedUserDefinedAggregateAccumulator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/grouped/GroupedUserDefinedAggregateAccumulator.java index 5cffef0110501..a530ce4f7de57 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/grouped/GroupedUserDefinedAggregateAccumulator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/grouped/GroupedUserDefinedAggregateAccumulator.java @@ -27,6 +27,7 @@ import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.State; import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFException; import org.apache.iotdb.udf.api.relational.AggregateFunction; import org.apache.iotdb.udf.api.utils.ResultValue; @@ -53,6 +54,7 @@ public class GroupedUserDefinedAggregateAccumulator implements GroupedAccumulato private final ObjectBigArray stateArray; private final List inputDataTypes; private final IoTDBLocal ioTDBLocal; + private boolean init = false; public GroupedUserDefinedAggregateAccumulator( AggregateFunction aggregateFunction, @@ -67,6 +69,21 @@ public GroupedUserDefinedAggregateAccumulator( this.ioTDBLocal = ioTDBLocal; } + private void initIfNeeded() { + if (init) { + return; + } + init = true; + try { + aggregateFunction.beforeStart(functionArguments, ioTDBLocal); + } catch (UDFException e) { + throw new RuntimeException( + "Error occurs when starting user-defined aggregate function " + + aggregateFunction.getClass().getName(), + e); + } + } + @Override public long getEstimatedSize() { return INSTANCE_SIZE; @@ -88,6 +105,7 @@ private State getOrCreateState(int groupId) { @Override public void addInput(int[] groupIds, Column[] arguments, AggregationMask mask) { + initIfNeeded(); RecordIterator iterator = mask.isSelectAll() ? new RecordIterator( @@ -115,6 +133,7 @@ public void addInput(int[] groupIds, Column[] arguments, AggregationMask mask) { @Override public void addIntermediate(int[] groupIds, Column argument) { + initIfNeeded(); checkArgument( argument instanceof BinaryColumn || (argument instanceof RunLengthEncodedColumn @@ -146,6 +165,7 @@ public void evaluateIntermediate(int groupId, ColumnBuilder columnBuilder) { @Override public void evaluateFinal(int groupId, ColumnBuilder columnBuilder) { + initIfNeeded(); ResultValue resultValue = new ResultValue(columnBuilder); aggregateFunction.outputFinal(getOrCreateState(groupId), resultValue, ioTDBLocal); } diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java index 07d92d967f8c8..6955dd56663f2 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java @@ -37,11 +37,15 @@ import java.util.List; import java.util.stream.Collectors; +import static com.google.common.base.Preconditions.checkArgument; + public class UserDefineScalarFunctionTransformer extends MultiColumnTransformer { private final ScalarFunction scalarFunction; + private final FunctionArguments parameters; private final List inputTypes; private final IoTDBLocal ioTDBLocal; + private boolean init = false; public UserDefineScalarFunctionTransformer( Type returnType, @@ -51,15 +55,35 @@ public UserDefineScalarFunctionTransformer( ColumnTransformerBuilder.Context context) { super(returnType, childrenTransformers); this.scalarFunction = scalarFunction; + this.parameters = parameters; this.ioTDBLocal = createIoTDBLocal(context); this.inputTypes = childrenTransformers.stream().map(ColumnTransformer::getType).collect(Collectors.toList()); + } + + private static IoTDBLocal createIoTDBLocal(ColumnTransformerBuilder.Context context) { + IoTDBLocalFactory factory = context.getIoTDBLocalFactory(); + String fragmentInstanceId = context.getFragmentInstanceId(); + String outerGlobalQueryId = context.getOuterGlobalQueryId(); + long outerLocalQueryId = context.getOuterLocalQueryId(); + checkArgument(factory != null, "IoTDBLocalFactory must not be null for UDF execution"); + checkArgument( + fragmentInstanceId != null, "fragmentInstanceId must not be null for UDF execution"); + checkArgument( + outerGlobalQueryId != null, "outerGlobalQueryId must not be null for UDF execution"); + checkArgument( + outerLocalQueryId >= 0, "outerLocalQueryId must not be negative for UDF execution"); + return factory.create( + context.getSessionInfo(), fragmentInstanceId, outerLocalQueryId, outerGlobalQueryId); + } + + private void initIfNeeded() { + if (init) { + return; + } + init = true; try { - if (ioTDBLocal != null) { - scalarFunction.beforeStart(parameters, ioTDBLocal); - } else { - scalarFunction.beforeStart(parameters); - } + scalarFunction.beforeStart(parameters, ioTDBLocal); } catch (UDFException e) { throw new RuntimeException( "Error occurs when starting user-defined scalar function " @@ -68,31 +92,14 @@ public UserDefineScalarFunctionTransformer( } } - private static IoTDBLocal createIoTDBLocal(ColumnTransformerBuilder.Context context) { - IoTDBLocalFactory factory = context.getIoTDBLocalFactory(); - if (factory == null - || context.getFragmentInstanceId() == null - || context.getOuterGlobalQueryId() == null - || context.getOuterLocalQueryId() < 0) { - return null; - } - return factory.create( - context.getSessionInfo(), - context.getFragmentInstanceId(), - context.getOuterLocalQueryId(), - context.getOuterGlobalQueryId()); - } - @Override protected void doTransform( List childrenColumns, ColumnBuilder builder, int positionCount) { + initIfNeeded(); RecordIterator iterator = new RecordIterator(childrenColumns, inputTypes, positionCount); while (iterator.hasNext()) { try { - Object result = - ioTDBLocal != null - ? scalarFunction.evaluate(iterator.next(), ioTDBLocal) - : scalarFunction.evaluate(iterator.next()); + Object result = scalarFunction.evaluate(iterator.next(), ioTDBLocal); if (result == null) { builder.appendNull(); } else { @@ -110,6 +117,7 @@ protected void doTransform( @Override protected void doTransform( List childrenColumns, ColumnBuilder builder, int positionCount, boolean[] selection) { + initIfNeeded(); RecordIterator iterator = new RecordIterator(childrenColumns, inputTypes, positionCount); int i = 0; while (iterator.hasNext()) { @@ -119,10 +127,7 @@ protected void doTransform( builder.appendNull(); continue; } - Object result = - ioTDBLocal != null - ? scalarFunction.evaluate(input, ioTDBLocal) - : scalarFunction.evaluate(input); + Object result = scalarFunction.evaluate(input, ioTDBLocal); if (result == null) { builder.appendNull(); } else { @@ -140,12 +145,8 @@ protected void doTransform( @Override public void close() { super.close(); - if (ioTDBLocal != null) { - ioTDBLocal.close(); - scalarFunction.beforeDestroy(ioTDBLocal); - } else { - scalarFunction.beforeDestroy(); - } + scalarFunction.beforeDestroy(ioTDBLocal); + ioTDBLocal.close(); } @Override From a5e0539e3c7d61c06c9d262e2b1446d4d597cd00 Mon Sep 17 00:00:00 2001 From: Weihao Li <18110526956@163.com> Date: Fri, 26 Jun 2026 02:55:38 +0800 Subject: [PATCH 06/11] fix IT and add more Signed-off-by: Weihao Li <18110526956@163.com> --- .../IoTDBLocalLogAggregateFunction.java | 133 +++++++++++++++ .../iotdblocal/IoTDBLocalLogFunction.java | 46 ++--- .../iotdblocal/IoTDBLocalLogHelper.java | 93 ++++++++++ .../IoTDBLocalLogTableFunction.java | 134 +++++++++++++++ .../relational/it/db/it/udf/IoTDBLocalIT.java | 62 ++----- .../it/db/it/udf/IoTDBLocalLogIT.java | 159 ++++++++++++++++++ .../it/db/it/udf/SQLFunctionUtils.java | 1 - .../relational/ColumnTransformerBuilder.java | 10 +- .../plan/planner/TableOperatorGenerator.java | 46 +++-- .../UserDefineScalarFunctionTransformer.java | 26 +-- .../fragment/FragmentInstanceContext.java | 16 +- .../fragment/FragmentInstanceManager.java | 2 +- .../DataNodeTableOperatorGenerator.java | 4 +- .../planner/LocalExecutionPlanContext.java | 4 +- .../SimpleFragmentParallelPlanner.java | 3 +- .../plan/planner/plan/FragmentInstance.java | 18 +- .../TableModelQueryFragmentPlanner.java | 3 +- .../db/queryengine/udf/IoTDBLocalImpl.java | 17 +- 18 files changed, 631 insertions(+), 146 deletions(-) create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogAggregateFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogHelper.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogTableFunction.java create mode 100644 integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalLogIT.java diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogAggregateFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogAggregateFunction.java new file mode 100644 index 0000000000000..7b7630bf5b046 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogAggregateFunction.java @@ -0,0 +1,133 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.State; +import org.apache.iotdb.udf.api.customizer.analysis.AggregateFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.relational.AggregateFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.type.Type; +import org.apache.iotdb.udf.api.utils.ResultValue; + +import java.nio.ByteBuffer; + +/** Exercises IoTDBLocal log APIs at each aggregate-function lifecycle hook. */ +public class IoTDBLocalLogAggregateFunction implements AggregateFunction { + + private static class CountState implements State { + long count; + boolean addInputLogged; + boolean combineStateLogged; + boolean outputFinalLogged; + boolean destroyLogged; + + @Override + public void reset() { + count = 0; + } + + @Override + public byte[] serialize() { + ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES); + buffer.putLong(count); + return buffer.array(); + } + + @Override + public void deserialize(byte[] bytes) { + count = ByteBuffer.wrap(bytes).getLong(); + } + } + + @Override + public AggregateFunctionAnalysis analyze(FunctionArguments arguments) + throws UDFArgumentNotValidException { + if (arguments.getArgumentsSize() != 1) { + throw new UDFArgumentNotValidException("IoTDBLocalLogAggregateFunction accepts one column"); + } + return new AggregateFunctionAnalysis.Builder().outputDataType(Type.INT64).build(); + } + + @Override + public void beforeStart(FunctionArguments arguments, IoTDBLocal local) { + IoTDBLocalLogHelper.logAllApis(local, IoTDBLocalLogHelper.UDAF_BEFORE_START); + } + + @Override + public State createState() { + return new CountState(); + } + + @Override + public void addInput(State state, Record input) { + CountState countState = (CountState) state; + countState.count++; + } + + @Override + public void addInput(State state, Record input, IoTDBLocal local) { + CountState countState = (CountState) state; + if (!countState.addInputLogged) { + countState.addInputLogged = true; + IoTDBLocalLogHelper.logAllApis(local, IoTDBLocalLogHelper.UDAF_ADD_INPUT); + } + addInput(state, input); + } + + @Override + public void combineState(State state, State rhs) { + CountState left = (CountState) state; + CountState right = (CountState) rhs; + left.count += right.count; + } + + @Override + public void combineState(State state, State rhs, IoTDBLocal local) { + CountState countState = (CountState) state; + if (!countState.combineStateLogged) { + countState.combineStateLogged = true; + IoTDBLocalLogHelper.logAllApis(local, IoTDBLocalLogHelper.UDAF_COMBINE_STATE); + } + combineState(state, rhs); + } + + @Override + public void outputFinal(State state, ResultValue resultValue) { + resultValue.setLong(((CountState) state).count); + } + + @Override + public void outputFinal(State state, ResultValue resultValue, IoTDBLocal local) { + CountState countState = (CountState) state; + if (!countState.outputFinalLogged) { + countState.outputFinalLogged = true; + IoTDBLocalLogHelper.logAllApis(local, IoTDBLocalLogHelper.UDAF_OUTPUT_FINAL); + } + outputFinal(state, resultValue); + } + + @Override + public void beforeDestroy(IoTDBLocal local) { + IoTDBLocalLogHelper.logAllApis(local, IoTDBLocalLogHelper.UDAF_BEFORE_DESTROY); + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogFunction.java index b22c5a1841fd0..720828dcf1b39 100644 --- a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogFunction.java +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogFunction.java @@ -27,18 +27,14 @@ import org.apache.iotdb.udf.api.relational.access.Record; import org.apache.iotdb.udf.api.type.Type; -/** Exercises all IoTDBLocal log APIs with distinctive markers for integration tests. */ +import org.apache.tsfile.common.conf.TSFileConfig; +import org.apache.tsfile.utils.Binary; + +/** Exercises IoTDBLocal log APIs at each scalar-function lifecycle hook. */ public class IoTDBLocalLogFunction implements ScalarFunction { - public static final String INFO_PLAIN = "IOTDB_LOCAL_IT_INFO_PLAIN"; - public static final String INFO_FORMAT = "IOTDB_LOCAL_IT_INFO_FORMAT loaded 3 rows"; - public static final String INFO_CAUSE = "IOTDB_LOCAL_IT_INFO_CAUSE"; - public static final String WARN_PLAIN = "IOTDB_LOCAL_IT_WARN_PLAIN"; - public static final String WARN_FORMAT = "IOTDB_LOCAL_IT_WARN_FORMAT warn ab"; - public static final String WARN_CAUSE = "IOTDB_LOCAL_IT_WARN_CAUSE"; - public static final String ERROR_PLAIN = "IOTDB_LOCAL_IT_ERROR_PLAIN"; - public static final String ERROR_FORMAT = "IOTDB_LOCAL_IT_ERROR_FORMAT error code=500"; - public static final String ERROR_CAUSE = "IOTDB_LOCAL_IT_ERROR_CAUSE"; + private boolean evaluateLogged; + private boolean destroyLogged; @Override public ScalarFunctionAnalysis analyze(FunctionArguments arguments) @@ -48,20 +44,28 @@ public ScalarFunctionAnalysis analyze(FunctionArguments arguments) @Override public void beforeStart(FunctionArguments arguments, IoTDBLocal local) { - RuntimeException cause = new RuntimeException("iotdb-local-it-log-cause"); - local.info(INFO_PLAIN); - local.info("IOTDB_LOCAL_IT_INFO_FORMAT loaded {} rows", 3); - local.info(INFO_CAUSE, cause); - local.warn(WARN_PLAIN); - local.warn("IOTDB_LOCAL_IT_WARN_FORMAT warn {} {}", "a", "b"); - local.warn(WARN_CAUSE, cause); - local.error(ERROR_PLAIN); - local.error("IOTDB_LOCAL_IT_ERROR_FORMAT error code={}", 500); - local.error(ERROR_CAUSE, cause); + IoTDBLocalLogHelper.logAllApis(local, IoTDBLocalLogHelper.SCALAR_BEFORE_START); } @Override public Object evaluate(Record input) { - return "ok"; + return new Binary("ok", TSFileConfig.STRING_CHARSET); + } + + @Override + public Object evaluate(Record input, IoTDBLocal local) { + if (!evaluateLogged) { + evaluateLogged = true; + IoTDBLocalLogHelper.logAllApis(local, IoTDBLocalLogHelper.SCALAR_EVALUATE); + } + return evaluate(input); + } + + @Override + public void beforeDestroy(IoTDBLocal local) { + if (!destroyLogged) { + destroyLogged = true; + IoTDBLocalLogHelper.logAllApis(local, IoTDBLocalLogHelper.SCALAR_BEFORE_DESTROY); + } } } diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogHelper.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogHelper.java new file mode 100644 index 0000000000000..970b25c3e84a4 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogHelper.java @@ -0,0 +1,93 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; + +/** Shared IoTDBLocal log markers for integration tests. */ +public final class IoTDBLocalLogHelper { + + public static final String CAUSE_MESSAGE = "iotdb-local-it-log-cause"; + + public static final String SCALAR_BEFORE_START = "IOTDB_LOCAL_SCALAR_BEFORE_START"; + public static final String SCALAR_EVALUATE = "IOTDB_LOCAL_SCALAR_EVALUATE"; + public static final String SCALAR_BEFORE_DESTROY = "IOTDB_LOCAL_SCALAR_BEFORE_DESTROY"; + + public static final String UDAF_BEFORE_START = "IOTDB_LOCAL_UDAF_BEFORE_START"; + public static final String UDAF_ADD_INPUT = "IOTDB_LOCAL_UDAF_ADD_INPUT"; + public static final String UDAF_COMBINE_STATE = "IOTDB_LOCAL_UDAF_COMBINE_STATE"; + public static final String UDAF_OUTPUT_FINAL = "IOTDB_LOCAL_UDAF_OUTPUT_FINAL"; + public static final String UDAF_BEFORE_DESTROY = "IOTDB_LOCAL_UDAF_BEFORE_DESTROY"; + + public static final String TVF_BEFORE_START = "IOTDB_LOCAL_TVF_BEFORE_START"; + public static final String TVF_PROCESS = "IOTDB_LOCAL_TVF_PROCESS"; + public static final String TVF_BEFORE_DESTROY = "IOTDB_LOCAL_TVF_BEFORE_DESTROY"; + + private IoTDBLocalLogHelper() {} + + public static void logAllApis(IoTDBLocal local, String phase) { + RuntimeException cause = new RuntimeException(CAUSE_MESSAGE); + local.info(phase + "_INFO_PLAIN"); + local.info(phase + "_INFO_FORMAT loaded {} rows", 3); + local.info(phase + "_INFO_CAUSE", cause); + local.warn(phase + "_WARN_PLAIN"); + local.warn(phase + "_WARN_FORMAT warn {} {}", "a", "b"); + local.warn(phase + "_WARN_CAUSE", cause); + local.error(phase + "_ERROR_PLAIN"); + local.error(phase + "_ERROR_FORMAT error code={}", 500); + local.error(phase + "_ERROR_CAUSE", cause); + } + + public static String infoPlain(String phase) { + return phase + "_INFO_PLAIN"; + } + + public static String infoFormat(String phase) { + return phase + "_INFO_FORMAT loaded 3 rows"; + } + + public static String infoCause(String phase) { + return phase + "_INFO_CAUSE"; + } + + public static String warnPlain(String phase) { + return phase + "_WARN_PLAIN"; + } + + public static String warnFormat(String phase) { + return phase + "_WARN_FORMAT warn a b"; + } + + public static String warnCause(String phase) { + return phase + "_WARN_CAUSE"; + } + + public static String errorPlain(String phase) { + return phase + "_ERROR_PLAIN"; + } + + public static String errorFormat(String phase) { + return phase + "_ERROR_FORMAT error code=500"; + } + + public static String errorCause(String phase) { + return phase + "_ERROR_CAUSE"; + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogTableFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogTableFunction.java new file mode 100644 index 0000000000000..39dfa05775185 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/IoTDBLocalLogTableFunction.java @@ -0,0 +1,134 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.TableFunction; +import org.apache.iotdb.udf.api.relational.table.MapTableFunctionHandle; +import org.apache.iotdb.udf.api.relational.table.TableFunctionAnalysis; +import org.apache.iotdb.udf.api.relational.table.TableFunctionHandle; +import org.apache.iotdb.udf.api.relational.table.TableFunctionProcessorProvider; +import org.apache.iotdb.udf.api.relational.table.argument.Argument; +import org.apache.iotdb.udf.api.relational.table.argument.DescribedSchema; +import org.apache.iotdb.udf.api.relational.table.argument.ScalarArgument; +import org.apache.iotdb.udf.api.relational.table.processor.TableFunctionLeafProcessor; +import org.apache.iotdb.udf.api.relational.table.specification.ParameterSpecification; +import org.apache.iotdb.udf.api.relational.table.specification.ScalarParameterSpecification; +import org.apache.iotdb.udf.api.type.Type; + +import org.apache.tsfile.block.column.ColumnBuilder; +import org.apache.tsfile.utils.Binary; + +import java.nio.charset.Charset; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +/** Exercises IoTDBLocal log APIs at each table-function lifecycle hook. */ +public class IoTDBLocalLogTableFunction implements TableFunction { + + private static final String INPUT_PARAMETER_NAME = "input"; + + @Override + public List getArgumentsSpecifications() { + return Collections.singletonList( + ScalarParameterSpecification.builder() + .name(INPUT_PARAMETER_NAME) + .type(Type.STRING) + .build()); + } + + @Override + public TableFunctionAnalysis analyze(Map arguments) throws UDFException { + DescribedSchema schema = DescribedSchema.builder().addField("output", Type.STRING).build(); + MapTableFunctionHandle handle = + new MapTableFunctionHandle.Builder() + .addProperty( + INPUT_PARAMETER_NAME, + ((ScalarArgument) arguments.get(INPUT_PARAMETER_NAME)).getValue()) + .build(); + return TableFunctionAnalysis.builder().properColumnSchema(schema).handle(handle).build(); + } + + @Override + public TableFunctionHandle createTableFunctionHandle() { + return new MapTableFunctionHandle(); + } + + @Override + public TableFunctionProcessorProvider getProcessorProvider( + TableFunctionHandle tableFunctionHandle) { + return new TableFunctionProcessorProvider() { + @Override + public TableFunctionLeafProcessor getSplitProcessor() { + return new LogSplitProcessor( + (String) + ((MapTableFunctionHandle) tableFunctionHandle).getProperty(INPUT_PARAMETER_NAME)); + } + }; + } + + private static class LogSplitProcessor implements TableFunctionLeafProcessor { + private final String input; + private boolean finish; + private boolean processLogged; + private boolean destroyLogged; + + LogSplitProcessor(String input) { + this.input = input; + } + + @Override + public void beforeStart(IoTDBLocal local) { + IoTDBLocalLogHelper.logAllApis(local, IoTDBLocalLogHelper.TVF_BEFORE_START); + } + + @Override + public void process(List columnBuilders) { + for (String value : input.split(",")) { + columnBuilders.get(0).writeBinary(new Binary(value, Charset.defaultCharset())); + } + finish = true; + } + + @Override + public void process(List columnBuilders, IoTDBLocal local) { + if (!processLogged) { + processLogged = true; + IoTDBLocalLogHelper.logAllApis(local, IoTDBLocalLogHelper.TVF_PROCESS); + } + process(columnBuilders); + } + + @Override + public boolean isFinish() { + return finish; + } + + @Override + public void beforeDestroy(IoTDBLocal local) { + if (!destroyLogged) { + destroyLogged = true; + IoTDBLocalLogHelper.logAllApis(local, IoTDBLocalLogHelper.TVF_BEFORE_DESTROY); + } + } + } +} diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java index c50d360ba66a6..0cebd2afe7a21 100644 --- a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java +++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java @@ -19,7 +19,6 @@ package org.apache.iotdb.relational.it.db.it.udf; -import org.apache.iotdb.db.query.udf.example.relational.iotdblocal.IoTDBLocalLogFunction; import org.apache.iotdb.it.env.EnvFactory; import org.apache.iotdb.it.framework.IoTDBTestRunner; import org.apache.iotdb.itbase.category.TableClusterIT; @@ -27,13 +26,11 @@ import org.junit.After; import org.junit.AfterClass; -import org.junit.Assert; import org.junit.BeforeClass; import org.junit.Test; import org.junit.experimental.categories.Category; import org.junit.runner.RunWith; -import java.io.IOException; import java.sql.Connection; import java.sql.Statement; @@ -43,7 +40,7 @@ /** * Integration tests for {@link org.apache.iotdb.udf.api.IoTDBLocal} in table-model UDF, covering - * compatibility, embedded query, logging, permission inheritance and auto resource cleanup. + * compatibility, embedded query, permission inheritance and auto resource cleanup. */ @RunWith(IoTDBTestRunner.class) @Category({TableLocalStandaloneIT.class, TableClusterIT.class}) @@ -118,8 +115,8 @@ public void testLegacyScalarUdf() { new String[] { "1970-01-01T00:00:00.001Z,false,false,", "1970-01-01T00:00:00.002Z,true,true,", - "1970-01-01T00:00:00.003Z,true,false,", - "1970-01-01T00:00:00.005Z,true,true," + "1970-01-01T00:00:00.003Z,false,false,", + "1970-01-01T00:00:00.005Z,true,false," }, DATABASE_NAME); tableResultSetEqualTest( @@ -128,8 +125,8 @@ public void testLegacyScalarUdf() { new String[] { "1970-01-01T00:00:00.001Z,2,", "1970-01-01T00:00:00.002Z,2,", - "1970-01-01T00:00:00.003Z,3,", - "5,4," + "1970-01-01T00:00:00.003Z,6,", + "1970-01-01T00:00:00.005Z,4," }, DATABASE_NAME); } @@ -140,7 +137,7 @@ public void testLegacyAggregateUdf() { tableResultSetEqualTest( "SELECT device_id, my_avg(s1) AS avg_s1 FROM vehicle GROUP BY device_id", new String[] {"device_id", "avg_s1"}, - new String[] {"d0,2.0,"}, + new String[] {"d0,2.6666666666666665,"}, DATABASE_NAME); } @@ -149,12 +146,12 @@ public void testLegacyTableFunctionUdf() { SQLFunctionUtils.createUDF("my_split", PKG + ".MySplit"); SQLFunctionUtils.createUDF("my_repeat", PKG + ".MyRepeatWithoutIndex"); tableResultSetEqualTest( - "SELECT * FROM TABLE(my_split('a,b,c'))", + "select * from my_split('a,b,c')", new String[] {"output"}, new String[] {"a,", "b,", "c,"}, DATABASE_NAME); tableResultSetEqualTest( - "SELECT * FROM my_repeat(vehicle, 2) ORDER BY time", + "select * from my_repeat((select time, device_id, s1 from vehicle), 2) order by time", new String[] {"time", "device_id", "s1"}, new String[] { "1970-01-01T00:00:00.001Z,d0,1,", @@ -178,7 +175,9 @@ public void testDeviceNameWithSingleQuery() { "SELECT time, device_id, device_name(device_id) AS name, temperature FROM readings ORDER BY time", new String[] {"time", "device_id", "name", "temperature"}, new String[] { - "1000,d1,一号车间温度传感器,25.5,", "1001,d2,二号车间温度传感器,32.0,", "1002,d3,未知设备,20.0,", + "1970-01-01T00:00:01.000Z,d1,一号车间温度传感器,25.5,", + "1970-01-01T00:00:01.001Z,d2,二号车间温度传感器,32.0,", + "1970-01-01T00:00:01.002Z,d3,未知设备,20.0,", }, DATABASE_NAME); } @@ -190,9 +189,9 @@ public void testDeviceSummaryWithMultipleQueries() { "SELECT time, device_id, temperature, device_summary(device_id) AS summary FROM readings ORDER BY time", new String[] {"time", "device_id", "temperature", "summary"}, new String[] { - "1000,d1,25.5,一号车间温度传感器(上限:30.0),", - "1001,d2,32.0,二号车间温度传感器(上限:35.0),", - "1002,d3,20.0,未知设备(上限:未知),", + "1970-01-01T00:00:01.000Z,d1,25.5,一号车间温度传感器(上限:30.0),", + "1970-01-01T00:00:01.001Z,d2,32.0,二号车间温度传感器(上限:35.0),", + "1970-01-01T00:00:01.002Z,d3,20.0,未知设备(上限:未知),", }, DATABASE_NAME); } @@ -213,35 +212,6 @@ public void testDeviceSummaryWithoutManualClose() { DATABASE_NAME); } - // ── IoTDBLocal logging ────────────────────────────────────────────────────── - - @Test - public void testIoTDBLocalLogApis() throws IOException { - SQLFunctionUtils.createUDF("iotdb_local_log", IOTDB_LOCAL_PKG + ".IoTDBLocalLogFunction"); - EnvFactory.getEnv().getDataNodeWrapper(0).clearLogContent(); - tableResultSetEqualTest( - "SELECT iotdb_local_log(device_id) AS log_ok FROM readings WHERE device_id = 'd1'", - new String[] {"log_ok"}, - new String[] {"ok,"}, - DATABASE_NAME); - assertLogContains(IoTDBLocalLogFunction.INFO_PLAIN); - assertLogContains(IoTDBLocalLogFunction.INFO_FORMAT); - assertLogContains(IoTDBLocalLogFunction.INFO_CAUSE); - assertLogContains(IoTDBLocalLogFunction.WARN_PLAIN); - assertLogContains(IoTDBLocalLogFunction.WARN_FORMAT); - assertLogContains(IoTDBLocalLogFunction.WARN_CAUSE); - assertLogContains(IoTDBLocalLogFunction.ERROR_PLAIN); - assertLogContains(IoTDBLocalLogFunction.ERROR_FORMAT); - assertLogContains(IoTDBLocalLogFunction.ERROR_CAUSE); - assertLogContains("iotdb-local-it-log-cause"); - } - - private static void assertLogContains(String content) throws IOException { - Assert.assertTrue( - "Expected log to contain: " + content, - EnvFactory.getEnv().getDataNodeWrapper(0).logContains(content)); - } - // ── permission inheritance ────────────────────────────────────────────────── @Test @@ -252,9 +222,9 @@ public void testIoTDBLocalInheritsSelectPermission() { "SELECT device_name(device_id) AS name FROM readings WHERE device_id = 'd1'", new String[] {"name"}, new String[] {"一号车间温度传感器,"}, - DATABASE_NAME, LIMITED_USER, - LIMITED_PASSWORD); + LIMITED_PASSWORD, + DATABASE_NAME); dropLimitedUser(); } diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalLogIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalLogIT.java new file mode 100644 index 0000000000000..c045357296aeb --- /dev/null +++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalLogIT.java @@ -0,0 +1,159 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.relational.it.db.it.udf; + +import org.apache.iotdb.db.query.udf.example.relational.iotdblocal.IoTDBLocalLogHelper; +import org.apache.iotdb.it.env.EnvFactory; +import org.apache.iotdb.it.env.cluster.node.DataNodeWrapper; +import org.apache.iotdb.it.framework.IoTDBTestRunner; +import org.apache.iotdb.itbase.category.TableLocalStandaloneIT; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; + +import java.io.IOException; +import java.sql.Connection; +import java.sql.Statement; + +import static org.apache.iotdb.db.it.utils.TestUtils.tableResultSetEqualTest; +import static org.junit.Assert.fail; + +/** + * Verifies {@link org.apache.iotdb.udf.api.IoTDBLocal} logging APIs on DataNode log output. Runs + * only in 1C1D ({@link TableLocalStandaloneIT}) because log inspection uses {@code + * DataNodeWrapper(0)}. + */ +@RunWith(IoTDBTestRunner.class) +@Category({TableLocalStandaloneIT.class}) +public class IoTDBLocalLogIT { + + private static final String DATABASE_NAME = "iotdb_local_log_it"; + private static final String IOTDB_LOCAL_PKG = + "org.apache.iotdb.db.query.udf.example.relational.iotdblocal"; + + private static DataNodeWrapper dataNodeWrapper; + + private static final String[] SETUP_SQLS = + new String[] { + "CREATE DATABASE " + DATABASE_NAME, + "USE " + DATABASE_NAME, + "CREATE TABLE readings (device_id STRING TAG, temperature DOUBLE FIELD)", + "CREATE TABLE vehicle (device_id STRING TAG, s1 INT32 FIELD)", + "INSERT INTO readings(time, device_id, temperature) VALUES (1000, 'd1', 25.5)", + "INSERT INTO vehicle(time, device_id, s1) VALUES (1, 'd0', 1), (2, 'd0', 2), (3, 'd0', 3)", + "FLUSH", + }; + + @BeforeClass + public static void setUp() throws Exception { + EnvFactory.getEnv().initClusterEnvironment(); + dataNodeWrapper = EnvFactory.getEnv().getDataNodeWrapper(0); + executeAsRoot(SETUP_SQLS); + } + + @AfterClass + public static void tearDown() throws Exception { + EnvFactory.getEnv().cleanClusterEnvironment(); + } + + @After + public void dropFunctions() { + SQLFunctionUtils.dropAllUDF(); + } + + @Test + public void testScalarFunctionLogApis() throws IOException { + SQLFunctionUtils.createUDF( + "iotdb_local_log_scalar", IOTDB_LOCAL_PKG + ".IoTDBLocalLogFunction"); + dataNodeWrapper.clearLogContent(); + tableResultSetEqualTest( + "SELECT iotdb_local_log_scalar(device_id) AS log_ok FROM readings WHERE device_id = 'd1'", + new String[] {"log_ok"}, + new String[] {"ok,"}, + DATABASE_NAME); + assertPhaseLogs(IoTDBLocalLogHelper.SCALAR_BEFORE_START); + assertPhaseLogs(IoTDBLocalLogHelper.SCALAR_EVALUATE); + assertPhaseLogs(IoTDBLocalLogHelper.SCALAR_BEFORE_DESTROY); + } + + @Test + public void testAggregateFunctionLogApis() throws IOException { + SQLFunctionUtils.createUDF( + "iotdb_local_log_udaf", IOTDB_LOCAL_PKG + ".IoTDBLocalLogAggregateFunction"); + dataNodeWrapper.clearLogContent(); + tableResultSetEqualTest( + "SELECT iotdb_local_log_udaf(s1) AS row_count FROM vehicle", + new String[] {"row_count"}, + new String[] {"3,"}, + DATABASE_NAME); + assertPhaseLogs(IoTDBLocalLogHelper.UDAF_BEFORE_START); + assertPhaseLogs(IoTDBLocalLogHelper.UDAF_ADD_INPUT); + assertPhaseLogs(IoTDBLocalLogHelper.UDAF_OUTPUT_FINAL); + assertPhaseLogs(IoTDBLocalLogHelper.UDAF_BEFORE_DESTROY); + } + + @Test + public void testTableFunctionLogApis() throws IOException { + SQLFunctionUtils.createUDF( + "iotdb_local_log_split", IOTDB_LOCAL_PKG + ".IoTDBLocalLogTableFunction"); + dataNodeWrapper.clearLogContent(); + tableResultSetEqualTest( + "SELECT * FROM iotdb_local_log_split('a,b')", + new String[] {"output"}, + new String[] {"a,", "b,"}, + DATABASE_NAME); + assertPhaseLogs(IoTDBLocalLogHelper.TVF_BEFORE_START); + assertPhaseLogs(IoTDBLocalLogHelper.TVF_PROCESS); + assertPhaseLogs(IoTDBLocalLogHelper.TVF_BEFORE_DESTROY); + } + + private static void assertPhaseLogs(String phase) throws IOException { + assertLogContains(IoTDBLocalLogHelper.infoPlain(phase)); + assertLogContains(IoTDBLocalLogHelper.infoFormat(phase)); + assertLogContains(IoTDBLocalLogHelper.infoCause(phase)); + assertLogContains(IoTDBLocalLogHelper.warnPlain(phase)); + assertLogContains(IoTDBLocalLogHelper.warnFormat(phase)); + assertLogContains(IoTDBLocalLogHelper.warnCause(phase)); + assertLogContains(IoTDBLocalLogHelper.errorPlain(phase)); + assertLogContains(IoTDBLocalLogHelper.errorFormat(phase)); + assertLogContains(IoTDBLocalLogHelper.errorCause(phase)); + assertLogContains(IoTDBLocalLogHelper.CAUSE_MESSAGE); + } + + private static void assertLogContains(String content) throws IOException { + Assert.assertTrue("Expected log to contain: " + content, dataNodeWrapper.logContains(content)); + } + + private static void executeAsRoot(String... sqls) { + try (Connection connection = EnvFactory.getEnv().getTableConnection(); + Statement statement = connection.createStatement()) { + for (String sql : sqls) { + statement.execute(sql); + } + } catch (Exception e) { + fail("executeAsRoot failed: " + e.getMessage()); + } + } +} diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/SQLFunctionUtils.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/SQLFunctionUtils.java index 34f57b2940b6f..6174f06bb5b3d 100644 --- a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/SQLFunctionUtils.java +++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/SQLFunctionUtils.java @@ -41,7 +41,6 @@ public class SQLFunctionUtils { public static void createUDF(String udfName, String classPath) { try (Connection connection = EnvFactory.getEnv().getTableConnection(); Statement statement = connection.createStatement()) { - // create statement.execute(String.format("create function %s as '%s'", udfName, classPath)); // check try (ResultSet resultSet = statement.executeQuery("show functions")) { diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java index 20d35fe0ab392..7d3c1ab9bc547 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/relational/ColumnTransformerBuilder.java @@ -1958,7 +1958,7 @@ public static class Context { private final String outerGlobalQueryId; - private final long outerLocalQueryId; + private final long outerQueryDeadlineMs; @Nullable private final IoTDBLocalFactory ioTDBLocalFactory; @@ -2006,7 +2006,7 @@ public Context( @Nullable MemoryReservationManager memoryReservationManager, String fragmentInstanceId, String outerGlobalQueryId, - long outerLocalQueryId, + long outerQueryDeadlineMs, @Nullable IoTDBLocalFactory ioTDBLocalFactory) { this.sessionInfo = sessionInfo; this.leafList = leafList; @@ -2021,7 +2021,7 @@ public Context( this.memoryReservationManager = Optional.ofNullable(memoryReservationManager); this.fragmentInstanceId = fragmentInstanceId; this.outerGlobalQueryId = outerGlobalQueryId; - this.outerLocalQueryId = outerLocalQueryId; + this.outerQueryDeadlineMs = outerQueryDeadlineMs; this.ioTDBLocalFactory = ioTDBLocalFactory; } @@ -2037,8 +2037,8 @@ public String getOuterGlobalQueryId() { return outerGlobalQueryId; } - public long getOuterLocalQueryId() { - return outerLocalQueryId; + public long getOuterQueryDeadlineMs() { + return outerQueryDeadlineMs; } @Nullable diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java index f12dadbb87ae7..86786404bc4c3 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/plan/planner/TableOperatorGenerator.java @@ -318,7 +318,7 @@ protected Operator constructFilterAndProjectOperator( String fragmentInstanceId = getFragmentInstanceId(context); String outerGlobalQueryId = getQueryId(context); - long outerLocalQueryId = getLocalQueryId(context); + long outerQueryDeadlineMs = getOuterQueryDeadlineMs(context); IoTDBLocalFactory ioTDBLocalFactory = getIoTDBLocalFactory(context); final List filterOutputDataTypes = new ArrayList<>(inputDataTypes); @@ -351,7 +351,7 @@ protected Operator constructFilterAndProjectOperator( context.getMemoryReservationManager(), fragmentInstanceId, outerGlobalQueryId, - outerLocalQueryId, + outerQueryDeadlineMs, ioTDBLocalFactory); return visitor.process(p, filterColumnTransformerContext); @@ -383,7 +383,7 @@ protected Operator constructFilterAndProjectOperator( context.getMemoryReservationManager(), fragmentInstanceId, outerGlobalQueryId, - outerLocalQueryId, + outerQueryDeadlineMs, ioTDBLocalFactory); for (Expression expression : projectExpressions) { @@ -416,7 +416,7 @@ protected String getQueryId(C context) { return null; } - protected long getLocalQueryId(C context) { + protected long getOuterQueryDeadlineMs(C context) { return -1L; } @@ -2520,18 +2520,12 @@ public Operator visitTopKRanking(TopKRankingNode node, C context) { protected abstract SessionInfo getSessionInfo(C context); protected IoTDBLocal createIoTDBLocal(C context) { - IoTDBLocalFactory factory = getIoTDBLocalFactory(context); - String fragmentInstanceId = getFragmentInstanceId(context); - String outerGlobalQueryId = getQueryId(context); - long outerLocalQueryId = getLocalQueryId(context); - checkArgument(factory != null, "IoTDBLocalFactory must not be null for UDF execution"); - checkArgument( - fragmentInstanceId != null, "fragmentInstanceId must not be null for UDF execution"); - checkArgument(outerGlobalQueryId != null, "queryId must not be null for UDF execution"); - checkArgument( - outerLocalQueryId >= 0, "outerLocalQueryId must not be negative for UDF execution"); - return factory.create( - getSessionInfo(context), fragmentInstanceId, outerLocalQueryId, outerGlobalQueryId); + return IoTDBLocalFactory.createIoTDBLocal( + getIoTDBLocalFactory(context), + getSessionInfo(context), + getFragmentInstanceId(context), + getQueryId(context), + getOuterQueryDeadlineMs(context)); } /** Factory for creating {@link IoTDBLocal} inside UDF column transformers. */ @@ -2541,7 +2535,23 @@ public interface IoTDBLocalFactory { IoTDBLocal create( SessionInfo sessionInfo, String fragmentInstanceId, - long outerLocalQueryId, - String outerGlobalQueryId); + String outerGlobalQueryId, + long outerQueryDeadlineMs); + + static IoTDBLocal createIoTDBLocal( + IoTDBLocalFactory factory, + SessionInfo sessionInfo, + String fragmentInstanceId, + String outerGlobalQueryId, + long outerQueryDeadlineMs) { + checkArgument(factory != null, "IoTDBLocalFactory must not be null for UDF execution"); + checkArgument( + fragmentInstanceId != null, "fragmentInstanceId must not be null for UDF execution"); + checkArgument(outerGlobalQueryId != null, "queryId must not be null for UDF execution"); + checkArgument( + outerQueryDeadlineMs > 0, "outerQueryDeadlineMs must be positive for UDF execution"); + return factory.create( + sessionInfo, fragmentInstanceId, outerGlobalQueryId, outerQueryDeadlineMs); + } } } diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java index 6955dd56663f2..0a50cc1949256 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java @@ -37,8 +37,6 @@ import java.util.List; import java.util.stream.Collectors; -import static com.google.common.base.Preconditions.checkArgument; - public class UserDefineScalarFunctionTransformer extends MultiColumnTransformer { private final ScalarFunction scalarFunction; @@ -56,27 +54,17 @@ public UserDefineScalarFunctionTransformer( super(returnType, childrenTransformers); this.scalarFunction = scalarFunction; this.parameters = parameters; - this.ioTDBLocal = createIoTDBLocal(context); + this.ioTDBLocal = + IoTDBLocalFactory.createIoTDBLocal( + context.getIoTDBLocalFactory(), + context.getSessionInfo(), + context.getFragmentInstanceId(), + context.getOuterGlobalQueryId(), + context.getOuterQueryDeadlineMs()); this.inputTypes = childrenTransformers.stream().map(ColumnTransformer::getType).collect(Collectors.toList()); } - private static IoTDBLocal createIoTDBLocal(ColumnTransformerBuilder.Context context) { - IoTDBLocalFactory factory = context.getIoTDBLocalFactory(); - String fragmentInstanceId = context.getFragmentInstanceId(); - String outerGlobalQueryId = context.getOuterGlobalQueryId(); - long outerLocalQueryId = context.getOuterLocalQueryId(); - checkArgument(factory != null, "IoTDBLocalFactory must not be null for UDF execution"); - checkArgument( - fragmentInstanceId != null, "fragmentInstanceId must not be null for UDF execution"); - checkArgument( - outerGlobalQueryId != null, "outerGlobalQueryId must not be null for UDF execution"); - checkArgument( - outerLocalQueryId >= 0, "outerLocalQueryId must not be negative for UDF execution"); - return factory.create( - context.getSessionInfo(), fragmentInstanceId, outerLocalQueryId, outerGlobalQueryId); - } - private void initIfNeeded() { if (init) { return; 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 a41660ef55640..595e9da7065fb 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 @@ -152,8 +152,8 @@ public class FragmentInstanceContext extends QueryContext { // session info private SessionInfo sessionInfo; - // Coordinator-local query id of the outer query, used by IoTDBLocal UDF - private long localQueryId = -1L; + // Outer query deadline (startTime + timeout) for IoTDBLocal UDF + private long outerQueryDeadlineMs = -1L; private final Map dataNodeQueryContextMap; private DataNodeQueryContext dataNodeQueryContext; @@ -209,7 +209,7 @@ public static FragmentInstanceContext createFragmentInstanceContext( IDataRegionForQuery dataRegion, TimePredicate globalTimePredicate, Map dataNodeQueryContextMap, - long localQueryId, + long outerQueryDeadlineMs, boolean debug, boolean isVerbose) { FragmentInstanceContext instanceContext = @@ -220,7 +220,7 @@ public static FragmentInstanceContext createFragmentInstanceContext( dataRegion, globalTimePredicate, dataNodeQueryContextMap, - localQueryId, + outerQueryDeadlineMs, debug, isVerbose); instanceContext.initialize(); @@ -276,7 +276,7 @@ private FragmentInstanceContext( IDataRegionForQuery dataRegion, TimePredicate globalTimePredicate, Map dataNodeQueryContextMap, - long localQueryId, + long outerQueryDeadlineMs, boolean debug, boolean verbose) { super(debug, verbose); @@ -284,7 +284,7 @@ private FragmentInstanceContext( this.stateMachine = stateMachine; this.executionEndTime.set(END_TIME_INITIAL_VALUE); this.sessionInfo = sessionInfo; - this.localQueryId = localQueryId; + this.outerQueryDeadlineMs = outerQueryDeadlineMs; this.dataRegion = dataRegion; this.globalTimeFilter = globalTimePredicate == null @@ -574,8 +574,8 @@ public SessionInfo getSessionInfo() { return sessionInfo; } - public long getLocalQueryId() { - return localQueryId; + public long getOuterQueryDeadlineMs() { + return outerQueryDeadlineMs; } public Optional getFailureCause() { 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 75e447de5861b..18042372b8057 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 @@ -167,7 +167,7 @@ public FragmentInstanceInfo execDataQueryFragmentInstance( dataRegion, instance.getGlobalTimePredicate(), dataNodeQueryContextMap, - instance.getLocalQueryId(), + instance.getOuterQueryDeadlineMs(), instance.isDebug(), instance.isVerbose()); }); diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java index aa748cde854c3..7d628e78d7933 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/DataNodeTableOperatorGenerator.java @@ -2116,8 +2116,8 @@ protected String getQueryId(LocalExecutionPlanContext context) { } @Override - protected long getLocalQueryId(LocalExecutionPlanContext context) { - return context.getLocalQueryId(); + protected long getOuterQueryDeadlineMs(LocalExecutionPlanContext context) { + return context.getOuterQueryDeadlineMs(); } @Override diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LocalExecutionPlanContext.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LocalExecutionPlanContext.java index c9172bb44ca9c..4d78236f38d1b 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LocalExecutionPlanContext.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/LocalExecutionPlanContext.java @@ -198,8 +198,8 @@ public FragmentInstanceId getFragmentInstanceId() { return driverContext.getFragmentInstanceContext().getId(); } - public long getLocalQueryId() { - return driverContext.getFragmentInstanceContext().getLocalQueryId(); + public long getOuterQueryDeadlineMs() { + return driverContext.getFragmentInstanceContext().getOuterQueryDeadlineMs(); } public List getPipelineDriverFactories() { diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/SimpleFragmentParallelPlanner.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/SimpleFragmentParallelPlanner.java index dec7c1917b6e5..a39aaff6fb4c7 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/SimpleFragmentParallelPlanner.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/SimpleFragmentParallelPlanner.java @@ -148,7 +148,8 @@ private void produceFragmentInstance(PlanFragment fragment) { queryContext.isDebug(), fragment.isRoot(), queryContext.isVerbose()); - fragmentInstance.setLocalQueryId(queryContext.getLocalQueryId()); + fragmentInstance.setOuterQueryDeadlineMs( + queryContext.getStartTime() + queryContext.getTimeOut()); selectExecutorAndHost( fragment, diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/FragmentInstance.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/FragmentInstance.java index 4cc98ee7d0676..ff03aa006d7fa 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/FragmentInstance.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/FragmentInstance.java @@ -83,8 +83,8 @@ public class FragmentInstance implements IConsensusRequest { private final boolean debug; private final boolean verbose; - // Coordinator-local query id, used to look up IQueryExecution on DataNode - private long localQueryId = -1L; + // Outer query deadline (startTime + timeout) for IoTDBLocal on remote DataNodes. + private long outerQueryDeadlineMs = -1L; // We can add some more params for a specific FragmentInstance // So that we can make different FragmentInstance owns different data range. @@ -272,9 +272,7 @@ public static FragmentInstance deserializeFrom(ByteBuffer buffer) { hasHostDataNode ? ThriftCommonsSerDeUtils.deserializeTDataNodeLocation(buffer) : null; fragmentInstance.isExplainAnalyze = ReadWriteIOUtils.readBool(buffer); fragmentInstance.setHighestPriority(ReadWriteIOUtils.readBool(buffer)); - if (buffer.hasRemaining()) { - fragmentInstance.setLocalQueryId(ReadWriteIOUtils.readLong(buffer)); - } + fragmentInstance.setOuterQueryDeadlineMs(ReadWriteIOUtils.readLong(buffer)); return fragmentInstance; } @@ -302,7 +300,7 @@ public ByteBuffer serializeToByteBuffer() { } ReadWriteIOUtils.write(isExplainAnalyze, outputStream); ReadWriteIOUtils.write(isHighestPriority, outputStream); - ReadWriteIOUtils.write(localQueryId, outputStream); + ReadWriteIOUtils.write(outerQueryDeadlineMs, outputStream); return ByteBuffer.wrap(publicBAOS.getBuf(), 0, publicBAOS.size()); } catch (IOException e) { LOGGER.error( @@ -349,12 +347,12 @@ public SessionInfo getSessionInfo() { return sessionInfo; } - public long getLocalQueryId() { - return localQueryId; + public long getOuterQueryDeadlineMs() { + return outerQueryDeadlineMs; } - public void setLocalQueryId(long localQueryId) { - this.localQueryId = localQueryId; + public void setOuterQueryDeadlineMs(long outerQueryDeadlineMs) { + this.outerQueryDeadlineMs = outerQueryDeadlineMs; } public boolean isExplainAnalyze() { diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelQueryFragmentPlanner.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelQueryFragmentPlanner.java index e9695ec73f6ea..586bb6d61dcf4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelQueryFragmentPlanner.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelQueryFragmentPlanner.java @@ -186,7 +186,8 @@ private void produceFragmentInstance( queryContext.isDebug(), fragment.isRoot(), queryContext.isVerbose()); - fragmentInstance.setLocalQueryId(queryContext.getLocalQueryId()); + fragmentInstance.setOuterQueryDeadlineMs( + queryContext.getStartTime() + queryContext.getTimeOut()); selectExecutorAndHost( fragment, diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java index 940288a83ac6d..630360f485808 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/IoTDBLocalImpl.java @@ -24,8 +24,6 @@ import org.apache.iotdb.commons.exception.QueryTimeoutException; import org.apache.iotdb.commons.queryengine.common.SessionInfo; import org.apache.iotdb.db.queryengine.common.QueryId; -import org.apache.iotdb.db.queryengine.plan.Coordinator; -import org.apache.iotdb.db.queryengine.plan.execution.IQueryExecution; import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.UDFResultSet; import org.apache.iotdb.udf.api.exception.UDFException; @@ -42,23 +40,22 @@ public class IoTDBLocalImpl implements IoTDBLocal { public static final IoTDBLocalFactory FACTORY = IoTDBLocalImpl::new; private static final Logger LOGGER = LoggerFactory.getLogger(IoTDBLocalImpl.class); - private static final Coordinator COORDINATOR = Coordinator.getInstance(); private final SessionInfo sessionInfo; private final String fragmentInstanceId; - private final long outerLocalQueryId; private final QueryId outerGlobalQueryId; + private final long outerQueryDeadlineMs; private final List openResultSets = new ArrayList<>(); public IoTDBLocalImpl( SessionInfo sessionInfo, String fragmentInstanceId, - long outerLocalQueryId, - String outerGlobalQueryId) { + String outerGlobalQueryId, + long outerQueryDeadlineMs) { this.sessionInfo = sessionInfo; this.fragmentInstanceId = fragmentInstanceId; - this.outerLocalQueryId = outerLocalQueryId; this.outerGlobalQueryId = QueryId.valueOf(outerGlobalQueryId); + this.outerQueryDeadlineMs = outerQueryDeadlineMs; } @Override @@ -97,12 +94,10 @@ public void close() { } private long computeRemainingTimeoutMs() { - IQueryExecution execution = COORDINATOR.getQueryExecution(outerLocalQueryId); - if (execution == null) { + if (outerQueryDeadlineMs <= 0) { return 0; } - return execution.getTimeout() - - (System.currentTimeMillis() - execution.getStartExecutionTime()); + return outerQueryDeadlineMs - System.currentTimeMillis(); } @Override From a16d87e19f30759d02ccf3bae4174bacb88594d3 Mon Sep 17 00:00:00 2001 From: Weihao Li <18110526956@163.com> Date: Fri, 26 Jun 2026 09:16:32 +0800 Subject: [PATCH 07/11] add concurrent case Signed-off-by: Weihao Li <18110526956@163.com> --- .../example/relational/iotdblocal/DeviceSummaryFunction.java | 3 ++- .../org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceSummaryFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceSummaryFunction.java index 3aacbf6269b9d..a400f70dcaf1d 100644 --- a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceSummaryFunction.java +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceSummaryFunction.java @@ -36,7 +36,8 @@ import java.util.Map; /** - * Lookup device_name and max_temp via two concurrent IoTDBLocal queries in {@link #beforeStart}. + * Lookup device_name and max_temp via two IoTDBLocal queries in {@link #beforeStart}, reading both + * {@link UDFResultSet} instances in an interleaved manner. */ public class DeviceSummaryFunction implements ScalarFunction { diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java index 0cebd2afe7a21..d2477a670a404 100644 --- a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java +++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java @@ -183,7 +183,7 @@ public void testDeviceNameWithSingleQuery() { } @Test - public void testDeviceSummaryWithMultipleQueries() { + public void testInterleavedIoTDBLocalQueries() { SQLFunctionUtils.createUDF("device_summary", IOTDB_LOCAL_PKG + ".DeviceSummaryFunction"); tableResultSetEqualTest( "SELECT time, device_id, temperature, device_summary(device_id) AS summary FROM readings ORDER BY time", From 72dab4f924bd595bca154a74b8c42e7f902d8a44 Mon Sep 17 00:00:00 2001 From: Weihao Li <18110526956@163.com> Date: Fri, 26 Jun 2026 09:37:23 +0800 Subject: [PATCH 08/11] fix Signed-off-by: Weihao Li <18110526956@163.com> --- log | 1924 ----------------------------------------------------------- 1 file changed, 1924 deletions(-) delete mode 100644 log diff --git a/log b/log deleted file mode 100644 index 37034a9feecec..0000000000000 --- a/log +++ /dev/null @@ -1,1924 +0,0 @@ -2026-06-25 15:50:13 -Full thread dump OpenJDK 64-Bit Server VM (17.0.8.1+1-LTS mixed mode, sharing): - -Threads class SMR info: -_java_thread_list=0x0000600003afb840, length=136, elements={ -0x000000013480e200, 0x000000013300de00, 0x000000013408d000, 0x000000013300e400, -0x000000013408a200, 0x0000000135008200, 0x000000013300ea00, 0x0000000122015e00, -0x0000000122017a00, 0x000000011301ac00, 0x000000012700a200, 0x000000013480ce00, -0x0000000122019000, 0x0000000122018000, 0x0000000122078600, 0x0000000134a59e00, -0x000000012241fa00, 0x000000011361ce00, 0x0000000134bec200, 0x000000011363be00, -0x00000001358f0a00, 0x0000000134777a00, 0x00000001336d6800, 0x0000000134d8b600, -0x0000000134d7aa00, 0x0000000134d70800, 0x00000001358e9000, 0x0000000134def800, -0x00000001226e1e00, 0x000000013595de00, 0x0000000134d0ce00, 0x00000001226ef800, -0x00000001347c9000, 0x0000000122696200, 0x000000012262e200, 0x0000000133743e00, -0x00000001137eaa00, 0x0000000135952c00, 0x00000001347d2000, 0x000000013594f400, -0x0000000122632a00, 0x00000001347d4400, 0x00000001347c0200, 0x0000000135959c00, -0x0000000134d3e800, 0x0000000122629c00, 0x0000000122612200, 0x000000012264e000, -0x00000001226c6600, 0x00000001226dc000, 0x000000012268da00, 0x00000001347a7c00, -0x00000001347fdc00, 0x000000013595a200, 0x000000013379ce00, 0x000000013375c400, -0x000000013379b600, 0x000000032201ee00, 0x0000000322061c00, 0x0000000137a0c400, -0x00000003059fc200, 0x00000001379c1600, 0x0000000127869200, 0x0000000322027e00, -0x00000003059c8e00, 0x00000003220b1800, 0x0000000322106e00, 0x000000032215ac00, -0x0000000322161c00, 0x0000000137aa2c00, 0x0000000322151800, 0x0000000322197c00, -0x0000000305a7ee00, 0x0000000137b07e00, 0x000000011208e400, 0x00000003061f5800, -0x000000030620ca00, 0x0000000135dc8e00, 0x000000030623da00, 0x0000000135e31c00, -0x0000000137c02400, 0x00000003222a4600, 0x0000000322288800, 0x0000000135e91a00, -0x00000003222b3800, 0x000000011333fe00, 0x000000013599ec00, 0x000000012270de00, -0x0000000113338e00, 0x00000001359c4400, 0x00000001359d1800, 0x000000030587a400, -0x0000000137909200, 0x00000001350baa00, 0x00000001350b4800, 0x0000000127896c00, -0x0000000127053800, 0x000000012258b400, 0x0000000322671600, 0x00000003224b4c00, -0x0000000113071800, 0x0000000137ee1a00, 0x000000013207d200, 0x000000012243c200, -0x0000000137865800, 0x0000000134cd6800, 0x00000001130ae800, 0x0000000305940000, -0x0000000305867c00, 0x0000000122840400, 0x00000001120d5a00, 0x00000001320b0a00, -0x0000000127053e00, 0x000000012704f000, 0x000000012785d800, 0x00000001320b1000, -0x000000012283d000, 0x00000001350ef000, 0x0000000122856000, 0x00000001320b1600, -0x000000012280a600, 0x0000000127872e00, 0x0000000127859200, 0x000000012787a800, -0x000000012280ac00, 0x0000000113087a00, 0x0000000137865200, 0x0000000137d02c00, -0x0000000134efe400, 0x00000001358d5600, 0x0000000305944200, 0x000000013477e600, -0x0000000113060800, 0x0000000122664600, 0x0000000122194e00, 0x0000000122598c00 -} - -"Reference Handler" #2 daemon prio=10 os_prio=31 cpu=1.67ms elapsed=140.98s tid=0x000000013480e200 nid=0x4a03 waiting on condition [0x000000016ebaa000] - java.lang.Thread.State: RUNNABLE - at java.lang.ref.Reference.waitForReferencePendingList(java.base@17.0.8.1/Native Method) - at java.lang.ref.Reference.processPendingReferences(java.base@17.0.8.1/Reference.java:253) - at java.lang.ref.Reference$ReferenceHandler.run(java.base@17.0.8.1/Reference.java:215) - -"Finalizer" #3 daemon prio=8 os_prio=31 cpu=0.12ms elapsed=140.98s tid=0x000000013300de00 nid=0x4d03 in Object.wait() [0x000000016edb6000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e0178ad8> (a java.lang.ref.ReferenceQueue$Lock) - at java.lang.ref.ReferenceQueue.remove(java.base@17.0.8.1/ReferenceQueue.java:155) - - locked <0x00000006e0178ad8> (a java.lang.ref.ReferenceQueue$Lock) - at java.lang.ref.ReferenceQueue.remove(java.base@17.0.8.1/ReferenceQueue.java:176) - at java.lang.ref.Finalizer$FinalizerThread.run(java.base@17.0.8.1/Finalizer.java:172) - -"Signal Dispatcher" #4 daemon prio=9 os_prio=31 cpu=0.41ms elapsed=140.98s tid=0x000000013408d000 nid=0x7b03 waiting on condition [0x0000000000000000] - java.lang.Thread.State: RUNNABLE - -"Service Thread" #5 daemon prio=9 os_prio=31 cpu=7.12ms elapsed=140.98s tid=0x000000013300e400 nid=0x7903 runnable [0x0000000000000000] - java.lang.Thread.State: RUNNABLE - -"Monitor Deflation Thread" #6 daemon prio=9 os_prio=31 cpu=4.70ms elapsed=140.98s tid=0x000000013408a200 nid=0x5d03 runnable [0x0000000000000000] - java.lang.Thread.State: RUNNABLE - -"C2 CompilerThread0" #7 daemon prio=9 os_prio=31 cpu=2556.76ms elapsed=140.98s tid=0x0000000135008200 nid=0x7803 waiting on condition [0x0000000000000000] - java.lang.Thread.State: RUNNABLE - No compile task - -"C1 CompilerThread0" #10 daemon prio=9 os_prio=31 cpu=719.18ms elapsed=140.98s tid=0x000000013300ea00 nid=0x7703 waiting on condition [0x0000000000000000] - java.lang.Thread.State: RUNNABLE - No compile task - -"Sweeper thread" #11 daemon prio=9 os_prio=31 cpu=1.77ms elapsed=140.98s tid=0x0000000122015e00 nid=0x7603 runnable [0x0000000000000000] - java.lang.Thread.State: RUNNABLE - -"Common-Cleaner" #12 daemon prio=8 os_prio=31 cpu=1.95ms elapsed=140.96s tid=0x0000000122017a00 nid=0x6103 in Object.wait() [0x000000016fd22000] - java.lang.Thread.State: TIMED_WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e0179a88> (a java.lang.ref.ReferenceQueue$Lock) - at java.lang.ref.ReferenceQueue.remove(java.base@17.0.8.1/ReferenceQueue.java:155) - - locked <0x00000006e0179a88> (a java.lang.ref.ReferenceQueue$Lock) - at jdk.internal.ref.CleanerImpl.run(java.base@17.0.8.1/CleanerImpl.java:140) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - at jdk.internal.misc.InnocuousThread.run(java.base@17.0.8.1/InnocuousThread.java:162) - -"JDWP Transport Listener: dt_socket" #13 daemon prio=10 os_prio=31 cpu=313.31ms elapsed=140.94s tid=0x000000011301ac00 nid=0x7403 runnable [0x0000000000000000] - java.lang.Thread.State: RUNNABLE - -"JDWP Event Helper Thread" #14 daemon prio=10 os_prio=31 cpu=185.66ms elapsed=140.94s tid=0x000000012700a200 nid=0x6403 runnable [0x0000000000000000] - java.lang.Thread.State: RUNNABLE - -"JDWP Command Reader" #15 daemon prio=10 os_prio=31 cpu=198.36ms elapsed=140.94s tid=0x000000013480ce00 nid=0x7203 runnable [0x0000000000000000] - java.lang.Thread.State: RUNNABLE - -"IntelliJ Suspend Helper" #16 daemon prio=5 os_prio=31 cpu=24.56ms elapsed=140.88s tid=0x0000000122019000 nid=0x6603 waiting on condition [0x000000030061e000] - java.lang.Thread.State: TIMED_WAITING (sleeping) - at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) - at com.intellij.rt.debugger.agent.SuspendHelper.suspendHelperLoopBody(SuspendHelper.java:29) - at com.intellij.rt.debugger.agent.SuspendHelper.access$000(SuspendHelper.java:5) - at com.intellij.rt.debugger.agent.SuspendHelper$1.run(SuspendHelper.java:15) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"CoarseTimer" #17 daemon prio=5 os_prio=31 cpu=4458.74ms elapsed=140.88s tid=0x0000000122018000 nid=0x6703 runnable [0x000000030082a000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:376) - at com.intellij.rt.debugger.agent.OverheadDetector$CoarseTimer$1.run(OverheadDetector.java:87) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"Notification Thread" #18 daemon prio=9 os_prio=31 cpu=10.36ms elapsed=140.82s tid=0x0000000122078600 nid=0x7003 runnable [0x0000000000000000] - java.lang.Thread.State: RUNNABLE - -"commons-pool-evictor" #21 daemon prio=5 os_prio=31 cpu=3.77ms elapsed=140.36s tid=0x0000000134a59e00 nid=0xa503 waiting on condition [0x00000003020ba000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e0881160> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-2-IoTDB-ACTIVE_LOAD_DIR_SCANNER-1" #22 prio=5 os_prio=31 cpu=28.20ms elapsed=139.89s tid=0x000000012241fa00 nid=0xa303 waiting on condition [0x00000003024d2000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e0d9da30> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-3-IoTDB-ACTIVE_LOAD_METRICS_COLLECTOR-1" #23 prio=5 os_prio=31 cpu=7.47ms elapsed=139.89s tid=0x000000011361ce00 nid=0x8c03 waiting on condition [0x00000003026de000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e0d9cb88> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"AsyncDataNodeIoTConsensusServiceClientPool-selector-24" #24 daemon prio=5 os_prio=31 cpu=0.44ms elapsed=139.85s tid=0x0000000134bec200 nid=0x8e03 runnable [0x00000003028ea000] - java.lang.Thread.State: RUNNABLE - at sun.nio.ch.KQueue.poll(java.base@17.0.8.1/Native Method) - at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@17.0.8.1/KQueueSelectorImpl.java:122) - at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@17.0.8.1/SelectorImpl.java:129) - - locked <0x00000006e0d9eab0> (a sun.nio.ch.Util$2) - - locked <0x00000006e0d9ea58> (a sun.nio.ch.KQueueSelectorImpl) - at sun.nio.ch.SelectorImpl.select(java.base@17.0.8.1/SelectorImpl.java:146) - at org.apache.thrift.async.TAsyncClientManager$SelectThread.run(TAsyncClientManager.java:97) - -"AsyncDataNodeIoTConsensusServiceClientPool-selector-25" #25 daemon prio=5 os_prio=31 cpu=0.26ms elapsed=139.85s tid=0x000000011363be00 nid=0xa103 runnable [0x0000000302af6000] - java.lang.Thread.State: RUNNABLE - at sun.nio.ch.KQueue.poll(java.base@17.0.8.1/Native Method) - at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@17.0.8.1/KQueueSelectorImpl.java:122) - at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@17.0.8.1/SelectorImpl.java:129) - - locked <0x00000006e0d9cf58> (a sun.nio.ch.Util$2) - - locked <0x00000006e0d9cf00> (a sun.nio.ch.KQueueSelectorImpl) - at sun.nio.ch.SelectorImpl.select(java.base@17.0.8.1/SelectorImpl.java:146) - at org.apache.thrift.async.TAsyncClientManager$SelectThread.run(TAsyncClientManager.java:97) - -"pool-14-IoTDB-WAL-Delete-1" #28 prio=5 os_prio=31 cpu=7.97ms elapsed=139.49s tid=0x00000001358f0a00 nid=0x9f07 waiting on condition [0x0000000302d02000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e0f9f170> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-15-IoTDB-Compaction-Schedule-1" #29 prio=5 os_prio=31 cpu=4.76ms elapsed=139.49s tid=0x0000000134777a00 nid=0x9e03 waiting on condition [0x0000000302f0e000] - java.lang.Thread.State: TIMED_WAITING (sleeping) - at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:55) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:35) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-15-IoTDB-Compaction-Schedule-2" #30 prio=5 os_prio=31 cpu=12.98ms elapsed=139.49s tid=0x00000001336d6800 nid=0x9c03 waiting on condition [0x000000030311a000] - java.lang.Thread.State: TIMED_WAITING (sleeping) - at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:55) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:35) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-15-IoTDB-Compaction-Schedule-3" #31 prio=5 os_prio=31 cpu=0.26ms elapsed=139.49s tid=0x0000000134d8b600 nid=0x9203 waiting on condition [0x0000000303326000] - java.lang.Thread.State: TIMED_WAITING (sleeping) - at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:55) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:35) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-15-IoTDB-Compaction-Schedule-4" #32 prio=5 os_prio=31 cpu=0.23ms elapsed=139.49s tid=0x0000000134d7aa00 nid=0x9a03 waiting on condition [0x0000000303532000] - java.lang.Thread.State: TIMED_WAITING (sleeping) - at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:55) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionScheduleTaskWorker.call(CompactionScheduleTaskWorker.java:35) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-15-IoTDB-Compaction-Schedule-5" #33 prio=5 os_prio=31 cpu=0.04ms elapsed=139.49s tid=0x0000000134d70800 nid=0x9403 waiting on condition [0x000000030373e000] - java.lang.Thread.State: TIMED_WAITING (sleeping) - at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.TTLScheduleTask.call(TTLScheduleTask.java:57) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.TTLScheduleTask.call(TTLScheduleTask.java:36) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-19-IoTDB-TableSizeIndexRecord-1" #36 prio=5 os_prio=31 cpu=32.96ms elapsed=139.47s tid=0x00000001358e9000 nid=0xaa03 waiting on condition [0x0000000303d62000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e0fabdd0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.LinkedBlockingQueue.poll(java.base@17.0.8.1/LinkedBlockingQueue.java:460) - at org.apache.iotdb.db.storageengine.dataregion.utils.tableDiskUsageIndex.TableDiskUsageIndex.run(TableDiskUsageIndex.java:73) - at org.apache.iotdb.db.storageengine.dataregion.utils.tableDiskUsageIndex.TableDiskUsageIndex$$Lambda$573/0x000000700140dc98.run(Unknown Source) - at org.apache.iotdb.commons.concurrent.WrappedRunnable$1.runMayThrow(WrappedRunnable.java:45) - at org.apache.iotdb.commons.concurrent.WrappedRunnable.run(WrappedRunnable.java:30) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:304) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-21-IoTDB-WAL-Serialize(node-test-2)-1" #39 prio=5 os_prio=31 cpu=0.13ms elapsed=139.24s tid=0x0000000134def800 nid=0xac03 waiting on condition [0x0000000304386000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b5898> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at org.apache.iotdb.db.storageengine.dataregion.wal.utils.MemoryControlledWALEntryQueue.take(MemoryControlledWALEntryQueue.java:73) - at org.apache.iotdb.db.storageengine.dataregion.wal.buffer.WALBuffer$SerializeTask.serialize(WALBuffer.java:256) - at org.apache.iotdb.db.storageengine.dataregion.wal.buffer.WALBuffer$SerializeTask.run(WALBuffer.java:243) - at org.apache.iotdb.commons.concurrent.WrappedRunnable$1.runMayThrow(WrappedRunnable.java:45) - at org.apache.iotdb.commons.concurrent.WrappedRunnable.run(WrappedRunnable.java:30) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-23-IoTDB-WAL-Serialize(node-test-1)-1" #40 prio=5 os_prio=31 cpu=0.16ms elapsed=139.23s tid=0x00000001226e1e00 nid=0xfa03 waiting on condition [0x000000030504a000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05aeb90> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at org.apache.iotdb.db.storageengine.dataregion.wal.utils.MemoryControlledWALEntryQueue.take(MemoryControlledWALEntryQueue.java:73) - at org.apache.iotdb.db.storageengine.dataregion.wal.buffer.WALBuffer$SerializeTask.serialize(WALBuffer.java:256) - at org.apache.iotdb.db.storageengine.dataregion.wal.buffer.WALBuffer$SerializeTask.run(WALBuffer.java:243) - at org.apache.iotdb.commons.concurrent.WrappedRunnable$1.runMayThrow(WrappedRunnable.java:45) - at org.apache.iotdb.commons.concurrent.WrappedRunnable.run(WrappedRunnable.java:30) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-25-IoTDB-Timed-Flush-Seq-Memtable-1" #42 prio=5 os_prio=31 cpu=0.80ms elapsed=139.22s tid=0x000000013595de00 nid=0xfd0b waiting on condition [0x0000000303f6e000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05bc580> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-26-IoTDB-Timed-Flush-Unseq-Memtable-1" #43 prio=5 os_prio=31 cpu=0.69ms elapsed=139.22s tid=0x0000000134d0ce00 nid=0xfe07 waiting on condition [0x000000030417a000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05bc7b0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"MPPDataExchangeRPC-Service" #45 prio=5 os_prio=31 cpu=0.31ms elapsed=139.20s tid=0x00000001226ef800 nid=0xf807 runnable [0x0000000305256000] - java.lang.Thread.State: RUNNABLE - at sun.nio.ch.Net.accept(java.base@17.0.8.1/Native Method) - at sun.nio.ch.NioSocketImpl.accept(java.base@17.0.8.1/NioSocketImpl.java:760) - at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:675) - at java.net.ServerSocket.platformImplAccept(java.base@17.0.8.1/ServerSocket.java:641) - at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:617) - at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:574) - at java.net.ServerSocket.accept(java.base@17.0.8.1/ServerSocket.java:532) - at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:131) - at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:35) - at org.apache.thrift.server.TThreadPoolServer.execute(TThreadPoolServer.java:153) - at org.apache.thrift.server.TThreadPoolServer.serve(TThreadPoolServer.java:139) - at org.apache.iotdb.commons.service.AbstractThriftServiceThread.run(AbstractThriftServiceThread.java:350) - -"Query-Worker-Thread-0" #46 prio=5 os_prio=31 cpu=51.89ms elapsed=139.08s tid=0x00000001347c9000 nid=0xad03 in Object.wait() [0x0000000305462000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) - at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) - - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) - -"Query-Worker-Thread-1" #47 prio=5 os_prio=31 cpu=0.83ms elapsed=139.08s tid=0x0000000122696200 nid=0xf603 in Object.wait() [0x000000030566e000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) - at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) - - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) - -"Query-Worker-Thread-2" #48 prio=5 os_prio=31 cpu=1.43ms elapsed=139.08s tid=0x000000012262e200 nid=0xf403 in Object.wait() [0x0000000306a06000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) - at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) - - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) - -"Query-Worker-Thread-3" #49 prio=5 os_prio=31 cpu=0.34ms elapsed=139.08s tid=0x0000000133743e00 nid=0xb003 in Object.wait() [0x0000000306c12000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) - at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) - - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) - -"Query-Worker-Thread-4" #50 prio=5 os_prio=31 cpu=2.19ms elapsed=139.08s tid=0x00000001137eaa00 nid=0xf203 in Object.wait() [0x0000000306e1e000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) - at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) - - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) - -"Query-Worker-Thread-5" #51 prio=5 os_prio=31 cpu=1.66ms elapsed=139.08s tid=0x0000000135952c00 nid=0xb103 in Object.wait() [0x000000030702a000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) - at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) - - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) - -"Query-Worker-Thread-6" #52 prio=5 os_prio=31 cpu=0.31ms elapsed=139.08s tid=0x00000001347d2000 nid=0xb203 in Object.wait() [0x0000000307236000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) - at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) - - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) - -"Query-Worker-Thread-7" #53 prio=5 os_prio=31 cpu=0.24ms elapsed=139.08s tid=0x000000013594f400 nid=0xef03 in Object.wait() [0x0000000307442000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) - at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) - - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) - -"Query-Worker-Thread-8" #54 prio=5 os_prio=31 cpu=2.27ms elapsed=139.08s tid=0x0000000122632a00 nid=0xb503 in Object.wait() [0x000000030764e000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) - at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) - - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) - -"Query-Worker-Thread-9" #55 prio=5 os_prio=31 cpu=17.25ms elapsed=139.08s tid=0x00000001347d4400 nid=0xed03 in Object.wait() [0x000000030785a000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) - at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) - - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) - -"Query-Worker-Thread-10" #56 prio=5 os_prio=31 cpu=6.12ms elapsed=139.08s tid=0x00000001347c0200 nid=0xec03 in Object.wait() [0x0000000307a66000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) - at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingReserveQueue.poll(IndexedBlockingReserveQueue.java:47) - - locked <0x00000006e05bcfa8> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.multilevelqueue.MultilevelPriorityQueue) - at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) - -"Query-Sentinel-Thread" #57 prio=5 os_prio=31 cpu=3.15ms elapsed=139.08s tid=0x0000000135959c00 nid=0xb803 in Object.wait() [0x0000000307c72000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e05c3540> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.L1PriorityQueue) - at java.lang.Object.wait(java.base@17.0.8.1/Object.java:338) - at org.apache.iotdb.calc.execution.schedule.queue.IndexedBlockingQueue.poll(IndexedBlockingQueue.java:73) - - locked <0x00000006e05c3540> (a org.apache.iotdb.db.queryengine.execution.schedule.queue.L1PriorityQueue) - at org.apache.iotdb.db.queryengine.execution.schedule.AbstractDriverThread.run(AbstractDriverThread.java:67) - -"pool-31-IoTDB-Compaction-Worker-1" #58 prio=5 os_prio=31 cpu=0.10ms elapsed=139.07s tid=0x0000000134d3e800 nid=0xba03 waiting on condition [0x0000000307e7e000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-31-IoTDB-Compaction-Worker-2" #59 prio=5 os_prio=31 cpu=0.09ms elapsed=139.07s tid=0x0000000122629c00 nid=0xea03 waiting on condition [0x0000000320206000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-31-IoTDB-Compaction-Worker-3" #60 prio=5 os_prio=31 cpu=0.05ms elapsed=139.07s tid=0x0000000122612200 nid=0xbb03 waiting on condition [0x0000000320412000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-31-IoTDB-Compaction-Worker-4" #61 prio=5 os_prio=31 cpu=0.04ms elapsed=139.07s tid=0x000000012264e000 nid=0xbc03 waiting on condition [0x000000032061e000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-31-IoTDB-Compaction-Worker-5" #62 prio=5 os_prio=31 cpu=0.04ms elapsed=139.07s tid=0x00000001226c6600 nid=0xe603 waiting on condition [0x000000032082a000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-31-IoTDB-Compaction-Worker-6" #63 prio=5 os_prio=31 cpu=0.10ms elapsed=139.07s tid=0x00000001226dc000 nid=0xbd03 waiting on condition [0x0000000320a36000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-31-IoTDB-Compaction-Worker-7" #64 prio=5 os_prio=31 cpu=0.06ms elapsed=139.07s tid=0x000000012268da00 nid=0xbe03 waiting on condition [0x0000000320c42000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-31-IoTDB-Compaction-Worker-8" #65 prio=5 os_prio=31 cpu=0.03ms elapsed=139.07s tid=0x00000001347a7c00 nid=0xe303 waiting on condition [0x0000000320e4e000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-31-IoTDB-Compaction-Worker-9" #66 prio=5 os_prio=31 cpu=0.07ms elapsed=139.07s tid=0x00000001347fdc00 nid=0xc003 waiting on condition [0x000000032105a000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-31-IoTDB-Compaction-Worker-10" #67 prio=5 os_prio=31 cpu=0.09ms elapsed=139.07s tid=0x000000013595a200 nid=0xc103 waiting on condition [0x0000000321266000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05de8d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:43) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionTaskQueue.take(CompactionTaskQueue.java:30) - at org.apache.iotdb.db.storageengine.dataregion.compaction.schedule.CompactionWorker.run(CompactionWorker.java:65) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"AsyncDataNodeInternalServiceClientPool-selector-68" #68 daemon prio=5 os_prio=31 cpu=0.06ms elapsed=139.05s tid=0x000000013379ce00 nid=0xc203 runnable [0x0000000321472000] - java.lang.Thread.State: RUNNABLE - at sun.nio.ch.KQueue.poll(java.base@17.0.8.1/Native Method) - at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@17.0.8.1/KQueueSelectorImpl.java:122) - at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@17.0.8.1/SelectorImpl.java:129) - - locked <0x00000006e05bd480> (a sun.nio.ch.Util$2) - - locked <0x00000006e05bd370> (a sun.nio.ch.KQueueSelectorImpl) - at sun.nio.ch.SelectorImpl.select(java.base@17.0.8.1/SelectorImpl.java:146) - at org.apache.thrift.async.TAsyncClientManager$SelectThread.run(TAsyncClientManager.java:97) - -"AsyncDataNodeInternalServiceClientPool-selector-69" #69 daemon prio=5 os_prio=31 cpu=0.04ms elapsed=139.05s tid=0x000000013375c400 nid=0xc303 runnable [0x000000032167e000] - java.lang.Thread.State: RUNNABLE - at sun.nio.ch.KQueue.poll(java.base@17.0.8.1/Native Method) - at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@17.0.8.1/KQueueSelectorImpl.java:122) - at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@17.0.8.1/SelectorImpl.java:129) - - locked <0x00000006e05df0d0> (a sun.nio.ch.Util$2) - - locked <0x00000006e05df078> (a sun.nio.ch.KQueueSelectorImpl) - at sun.nio.ch.SelectorImpl.select(java.base@17.0.8.1/SelectorImpl.java:146) - at org.apache.thrift.async.TAsyncClientManager$SelectThread.run(TAsyncClientManager.java:97) - -"pool-33-IoTDB-Expired-Queries-Info-Clear-1" #70 prio=5 os_prio=31 cpu=7.23ms elapsed=139.04s tid=0x000000013379b600 nid=0xc403 waiting on condition [0x000000032188a000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b6268> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-38-IoTDB-ResourceControl-DataRegionDiskStatistics-1" #71 prio=5 os_prio=31 cpu=2.03ms elapsed=138.93s tid=0x000000032201ee00 nid=0xc603 waiting on condition [0x0000000321a96000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05df250> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"DataNodeInternalRPC-Service" #72 prio=5 os_prio=31 cpu=0.76ms elapsed=138.84s tid=0x0000000322061c00 nid=0xdd03 runnable [0x0000000321ca2000] - java.lang.Thread.State: RUNNABLE - at sun.nio.ch.Net.accept(java.base@17.0.8.1/Native Method) - at sun.nio.ch.NioSocketImpl.accept(java.base@17.0.8.1/NioSocketImpl.java:760) - at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:675) - at java.net.ServerSocket.platformImplAccept(java.base@17.0.8.1/ServerSocket.java:641) - at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:617) - at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:574) - at java.net.ServerSocket.accept(java.base@17.0.8.1/ServerSocket.java:532) - at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:131) - at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:35) - at org.apache.thrift.server.TThreadPoolServer.execute(TThreadPoolServer.java:153) - at org.apache.thrift.server.TThreadPoolServer.serve(TThreadPoolServer.java:139) - at org.apache.iotdb.commons.service.AbstractThriftServiceThread.run(AbstractThriftServiceThread.java:350) - -"pool-41-IoTDB-SubscriptionReceiverAgent-Timeout-Checker-1" #73 prio=5 os_prio=31 cpu=2.91ms elapsed=138.72s tid=0x0000000137a0c400 nid=0xdb03 waiting on condition [0x0000000321eae000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b6498> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-42-IoTDB-Subscription-Consensus-Prefetch-Executor-Pool-0-1" #74 prio=5 os_prio=31 cpu=0.10ms elapsed=138.72s tid=0x00000003059fc200 nid=0xc803 waiting on condition [0x0000000322a06000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b66e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at org.apache.iotdb.db.subscription.task.execution.ConsensusSubscriptionPrefetchExecutor.workerLoop(ConsensusSubscriptionPrefetchExecutor.java:148) - at org.apache.iotdb.db.subscription.task.execution.ConsensusSubscriptionPrefetchExecutor$$Lambda$763/0x00000070014ec6e8.run(Unknown Source) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-42-IoTDB-Subscription-Consensus-Prefetch-Executor-Pool-0-2" #75 prio=5 os_prio=31 cpu=0.15ms elapsed=138.72s tid=0x00000001379c1600 nid=0xd803 waiting on condition [0x0000000322c12000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b66e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at org.apache.iotdb.db.subscription.task.execution.ConsensusSubscriptionPrefetchExecutor.workerLoop(ConsensusSubscriptionPrefetchExecutor.java:148) - at org.apache.iotdb.db.subscription.task.execution.ConsensusSubscriptionPrefetchExecutor$$Lambda$763/0x00000070014ec6e8.run(Unknown Source) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-5-IoTDB-Pipe-Runtime-Periodical-Job-Executor-1" #76 prio=5 os_prio=31 cpu=7.64ms elapsed=138.70s tid=0x0000000127869200 nid=0xd603 waiting on condition [0x0000000322e1e000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e0d9f980> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-6-IoTDB-Pipe-Runtime-Periodical-Phantom-Reference-Cleaner-1" #77 prio=5 os_prio=31 cpu=9.76ms elapsed=138.70s tid=0x0000000322027e00 nid=0xc903 waiting on condition [0x000000032302a000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e0da0998> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-44-IoTDB-General-Region-Attribute-Security-Service-1" #78 prio=5 os_prio=31 cpu=1.28ms elapsed=138.69s tid=0x00000003059c8e00 nid=0xd403 waiting on condition [0x0000000323236000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05d8180> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1757) - at org.apache.iotdb.commons.service.AbstractPeriodicalServiceWithAdvance.execute(AbstractPeriodicalServiceWithAdvance.java:66) - at org.apache.iotdb.commons.service.AbstractPeriodicalServiceWithAdvance$$Lambda$1520/0x0000007001759f28.run(Unknown Source) - at org.apache.iotdb.commons.concurrent.WrappedRunnable$1.runMayThrow(WrappedRunnable.java:45) - at org.apache.iotdb.commons.concurrent.WrappedRunnable.run(WrappedRunnable.java:30) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"1-groupManagement" #80 prio=5 os_prio=31 cpu=30.94ms elapsed=138.49s tid=0x00000003220b1800 nid=0xcc03 waiting on condition [0x000000032364e000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05d1640> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-45-IoTDB-Fragment-Instance-Management-1" #81 prio=5 os_prio=31 cpu=13.12ms elapsed=138.48s tid=0x0000000322106e00 nid=0xd103 waiting on condition [0x000000032385a000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05e1c20> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"1@group-000200000000-cacheEviction-AwaitToRun" #82 daemon prio=5 os_prio=31 cpu=0.28ms elapsed=138.38s tid=0x000000032215ac00 nid=0xcf03 waiting on condition [0x0000000323a66000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05e57c8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at org.apache.ratis.util.AwaitForSignal.await(AwaitForSignal.java:48) - at org.apache.ratis.util.AwaitToRun$RunnableImpl.run(AwaitToRun.java:47) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"1@group-000200000000-SegmentedRaftLogWorker" #83 prio=5 os_prio=31 cpu=11.16ms elapsed=138.34s tid=0x0000000322161c00 nid=0x10003 waiting on condition [0x0000000324c76000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05e1e50> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at org.apache.ratis.util.DataBlockingQueue.poll(DataBlockingQueue.java:148) - at org.apache.ratis.server.raftlog.segmented.SegmentedRaftLogWorker.run(SegmentedRaftLogWorker.java:309) - at org.apache.ratis.server.raftlog.segmented.SegmentedRaftLogWorker$$Lambda$1054/0x00000070016061f0.run(Unknown Source) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"1@group-000200000000-StateMachineUpdater" #85 daemon prio=5 os_prio=31 cpu=47.88ms elapsed=138.33s tid=0x0000000137aa2c00 nid=0x15203 waiting on condition [0x000000032508e000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05d8428> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1757) - at org.apache.ratis.util.AwaitForSignal.await(AwaitForSignal.java:65) - at org.apache.ratis.server.impl.StateMachineUpdater.waitForCommit(StateMachineUpdater.java:223) - at org.apache.ratis.server.impl.StateMachineUpdater.run(StateMachineUpdater.java:188) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"grpc-nio-boss-ELG-1-1" #86 daemon prio=5 os_prio=31 cpu=26.69ms elapsed=138.33s tid=0x0000000322151800 nid=0x15003 runnable [0x000000032529a000] - java.lang.Thread.State: RUNNABLE - at sun.nio.ch.KQueue.poll(java.base@17.0.8.1/Native Method) - at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@17.0.8.1/KQueueSelectorImpl.java:122) - at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@17.0.8.1/SelectorImpl.java:129) - - locked <0x00000006e05af0a8> (a org.apache.ratis.thirdparty.io.netty.channel.nio.SelectedSelectionKeySet) - - locked <0x00000006e05af050> (a sun.nio.ch.KQueueSelectorImpl) - at sun.nio.ch.SelectorImpl.select(java.base@17.0.8.1/SelectorImpl.java:146) - at org.apache.ratis.thirdparty.io.netty.channel.nio.SelectedSelectionKeySetSelector.select(SelectedSelectionKeySetSelector.java:68) - at org.apache.ratis.thirdparty.io.netty.channel.nio.NioEventLoop.select(NioEventLoop.java:887) - at org.apache.ratis.thirdparty.io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:526) - at org.apache.ratis.thirdparty.io.netty.util.concurrent.SingleThreadEventExecutor$4.run(SingleThreadEventExecutor.java:998) - at org.apache.ratis.thirdparty.io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74) - at org.apache.ratis.thirdparty.io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"JvmPauseMonitor0" #87 daemon prio=5 os_prio=31 cpu=65.42ms elapsed=138.30s tid=0x0000000322197c00 nid=0x10303 waiting on condition [0x00000003254a6000] - java.lang.Thread.State: TIMED_WAITING (sleeping) - at java.lang.Thread.sleep(java.base@17.0.8.1/Native Method) - at java.lang.Thread.sleep(java.base@17.0.8.1/Thread.java:337) - at java.util.concurrent.TimeUnit.sleep(java.base@17.0.8.1/TimeUnit.java:446) - at org.apache.ratis.util.TimeDuration.sleep(TimeDuration.java:353) - at org.apache.ratis.util.TimeDuration.sleep(TimeDuration.java:338) - at org.apache.ratis.util.JvmPauseMonitor.detectPause(JvmPauseMonitor.java:160) - at org.apache.ratis.util.JvmPauseMonitor.run(JvmPauseMonitor.java:149) - at org.apache.ratis.util.JvmPauseMonitor$$Lambda$1086/0x00000070016233a0.run(Unknown Source) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-9-IoTDB-RatisBgDiskGuardian-1" #88 prio=5 os_prio=31 cpu=3.46ms elapsed=138.29s tid=0x0000000305a7ee00 nid=0x10503 waiting on condition [0x00000003256b2000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e0e20a00> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"IoTConsensusRPC-Service" #89 prio=5 os_prio=31 cpu=0.09ms elapsed=138.28s tid=0x0000000137b07e00 nid=0x14e03 runnable [0x00000003258be000] - java.lang.Thread.State: RUNNABLE - at sun.nio.ch.Net.accept(java.base@17.0.8.1/Native Method) - at sun.nio.ch.NioSocketImpl.accept(java.base@17.0.8.1/NioSocketImpl.java:760) - at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:675) - at java.net.ServerSocket.platformImplAccept(java.base@17.0.8.1/ServerSocket.java:641) - at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:617) - at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:574) - at java.net.ServerSocket.accept(java.base@17.0.8.1/ServerSocket.java:532) - at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:131) - at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:35) - at org.apache.thrift.server.TThreadPoolServer.execute(TThreadPoolServer.java:153) - at org.apache.thrift.server.TThreadPoolServer.serve(TThreadPoolServer.java:139) - at org.apache.iotdb.commons.service.AbstractThriftServiceThread.run(AbstractThriftServiceThread.java:350) - -"1@group-000200000000-LeaderStateImpl" #91 daemon prio=5 os_prio=31 cpu=12.36ms elapsed=138.24s tid=0x000000011208e400 nid=0x15307 waiting on condition [0x0000000324e82000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05c3960> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ArrayBlockingQueue.poll(java.base@17.0.8.1/ArrayBlockingQueue.java:435) - at org.apache.ratis.server.impl.LeaderStateImpl$EventQueue.poll(LeaderStateImpl.java:168) - at org.apache.ratis.server.impl.LeaderStateImpl$EventProcessor.run(LeaderStateImpl.java:763) - -"pool-40-IoTDB-DataNodeInternalRPC-Processor-1" #92 prio=5 os_prio=31 cpu=70.49ms elapsed=138.18s tid=0x00000003061f5800 nid=0x10707 runnable [0x0000000325ac9000] - java.lang.Thread.State: RUNNABLE - at sun.nio.ch.SocketDispatcher.read0(java.base@17.0.8.1/Native Method) - at sun.nio.ch.SocketDispatcher.read(java.base@17.0.8.1/SocketDispatcher.java:47) - at sun.nio.ch.NioSocketImpl.tryRead(java.base@17.0.8.1/NioSocketImpl.java:266) - at sun.nio.ch.NioSocketImpl.implRead(java.base@17.0.8.1/NioSocketImpl.java:317) - at sun.nio.ch.NioSocketImpl.read(java.base@17.0.8.1/NioSocketImpl.java:355) - at sun.nio.ch.NioSocketImpl$1.read(java.base@17.0.8.1/NioSocketImpl.java:808) - at java.net.Socket$SocketInputStream.read(java.base@17.0.8.1/Socket.java:966) - at java.io.BufferedInputStream.fill(java.base@17.0.8.1/BufferedInputStream.java:244) - at java.io.BufferedInputStream.read1(java.base@17.0.8.1/BufferedInputStream.java:284) - at java.io.BufferedInputStream.read(java.base@17.0.8.1/BufferedInputStream.java:343) - - locked <0x00000006e05e7b28> (a java.io.BufferedInputStream) - at org.apache.thrift.transport.TIOStreamTransport.read(TIOStreamTransport.java:176) - at org.apache.thrift.transport.TTransport.readAll(TTransport.java:109) - at org.apache.iotdb.rpc.TElasticFramedTransport.readFrame(TElasticFramedTransport.java:176) - at org.apache.iotdb.rpc.TElasticFramedTransport.read(TElasticFramedTransport.java:130) - at org.apache.thrift.transport.TTransport.readAll(TTransport.java:109) - at org.apache.thrift.protocol.TBinaryProtocol.readAll(TBinaryProtocol.java:463) - at org.apache.thrift.protocol.TBinaryProtocol.readI32(TBinaryProtocol.java:361) - at org.apache.thrift.protocol.TBinaryProtocol.readMessageBegin(TBinaryProtocol.java:244) - at org.apache.thrift.TBaseProcessor.process(TBaseProcessor.java:27) - at org.apache.thrift.server.TThreadPoolServer$WorkerProcess.run(TThreadPoolServer.java:248) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-8-IoTDB-IoTConsensusBackgroundTaskExecutor-1" #93 prio=5 os_prio=31 cpu=0.08ms elapsed=138.17s tid=0x000000030620ca00 nid=0x14c03 waiting on condition [0x0000000325cd6000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e0e20e28> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"boundedElastic-evictor-1" #94 daemon prio=5 os_prio=31 cpu=0.64ms elapsed=138.11s tid=0x0000000135dc8e00 nid=0x14b03 waiting on condition [0x0000000325ee2000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e117ed70> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"reactor-http-nio-1" #95 daemon prio=5 os_prio=31 cpu=1.77ms elapsed=138.04s tid=0x000000030623da00 nid=0x14a03 runnable [0x00000003260ee000] - java.lang.Thread.State: RUNNABLE - at sun.nio.ch.KQueue.poll(java.base@17.0.8.1/Native Method) - at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@17.0.8.1/KQueueSelectorImpl.java:122) - at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@17.0.8.1/SelectorImpl.java:129) - - locked <0x00000006e11bf670> (a io.netty.channel.nio.SelectedSelectionKeySet) - - locked <0x00000006e11bf618> (a sun.nio.ch.KQueueSelectorImpl) - at sun.nio.ch.SelectorImpl.select(java.base@17.0.8.1/SelectorImpl.java:146) - at io.netty.channel.nio.SelectedSelectionKeySetSelector.select(SelectedSelectionKeySetSelector.java:68) - at io.netty.channel.nio.NioEventLoop.select(NioEventLoop.java:887) - at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:526) - at io.netty.util.concurrent.SingleThreadEventExecutor$4.run(SingleThreadEventExecutor.java:998) - at io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74) - at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-50-IoTDB-JVM-GC-Statistics-Monitor-1" #96 prio=5 os_prio=31 cpu=11.20ms elapsed=137.96s tid=0x0000000135e31c00 nid=0x14903 waiting on condition [0x00000003262fa000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e118ef78> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"ClientRPC-Service" #97 prio=5 os_prio=31 cpu=0.81ms elapsed=137.91s tid=0x0000000137c02400 nid=0x10b03 runnable [0x0000000326506000] - java.lang.Thread.State: RUNNABLE - at sun.nio.ch.Net.accept(java.base@17.0.8.1/Native Method) - at sun.nio.ch.NioSocketImpl.accept(java.base@17.0.8.1/NioSocketImpl.java:760) - at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:675) - at java.net.ServerSocket.platformImplAccept(java.base@17.0.8.1/ServerSocket.java:641) - at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:617) - at java.net.ServerSocket.implAccept(java.base@17.0.8.1/ServerSocket.java:574) - at java.net.ServerSocket.accept(java.base@17.0.8.1/ServerSocket.java:532) - at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:131) - at org.apache.thrift.transport.TServerSocket.accept(TServerSocket.java:35) - at org.apache.thrift.server.TThreadPoolServer.execute(TThreadPoolServer.java:153) - at org.apache.thrift.server.TThreadPoolServer.serve(TThreadPoolServer.java:139) - at org.apache.iotdb.commons.service.AbstractThriftServiceThread.run(AbstractThriftServiceThread.java:350) - -"pool-52-IoTDB-BinaryAllocator-SampleEvictor-1" #98 prio=5 os_prio=31 cpu=11.33ms elapsed=137.90s tid=0x00000003222a4600 nid=0x14603 waiting on condition [0x0000000326712000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e11af388> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1672) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1182) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-53-IoTDB-BinaryAllocator-Auto-Releaser-1" #99 prio=5 os_prio=31 cpu=0.05ms elapsed=137.90s tid=0x0000000322288800 nid=0x10d03 in Object.wait() [0x000000032691e000] - java.lang.Thread.State: WAITING (on object monitor) - at java.lang.Object.wait(java.base@17.0.8.1/Native Method) - - waiting on <0x00000006e11cf798> (a java.lang.ref.ReferenceQueue$Lock) - at java.lang.ref.ReferenceQueue.remove(java.base@17.0.8.1/ReferenceQueue.java:155) - - locked <0x00000006e11cf798> (a java.lang.ref.ReferenceQueue$Lock) - at java.lang.ref.ReferenceQueue.remove(java.base@17.0.8.1/ReferenceQueue.java:176) - at org.apache.iotdb.commons.binaryallocator.BinaryAllocator$AutoReleaser.run(BinaryAllocator.java:301) - at org.apache.iotdb.commons.concurrent.WrappedRunnable$1.runMayThrow(WrappedRunnable.java:45) - at org.apache.iotdb.commons.concurrent.WrappedRunnable.run(WrappedRunnable.java:30) - at java.util.concurrent.Executors$RunnableAdapter.call(java.base@17.0.8.1/Executors.java:539) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"DestroyJavaVM" #100 prio=5 os_prio=31 cpu=1649.84ms elapsed=137.80s tid=0x0000000135e91a00 nid=0x2203 waiting on condition [0x0000000000000000] - java.lang.Thread.State: RUNNABLE - -"pool-51-IoTDB-ClientRPC-Processor-1$20260625_074908_00006_1" #101 prio=5 os_prio=31 cpu=364.76ms elapsed=93.39s tid=0x00000003222b3800 nid=0x5a07 waiting on condition [0x0000000301ead000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e4917990> (a java.util.concurrent.FutureTask) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:211) - at java.util.concurrent.FutureTask.awaitDone(java.base@17.0.8.1/FutureTask.java:447) - at java.util.concurrent.FutureTask.get(java.base@17.0.8.1/FutureTask.java:190) - at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.topologicalParallelDispatchRead(FragmentInstanceDispatcherImpl.java:163) - at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.dispatch(FragmentInstanceDispatcherImpl.java:136) - at org.apache.iotdb.db.queryengine.plan.scheduler.ClusterScheduler.start(ClusterScheduler.java:117) - at org.apache.iotdb.db.queryengine.plan.relational.planner.TableModelPlanner.doSchedule(TableModelPlanner.java:212) - at org.apache.iotdb.db.queryengine.plan.execution.QueryExecution.schedule(QueryExecution.java:283) - at org.apache.iotdb.db.queryengine.plan.execution.QueryExecution.start(QueryExecution.java:205) - at org.apache.iotdb.db.queryengine.plan.Coordinator.execution(Coordinator.java:349) - at org.apache.iotdb.db.queryengine.plan.Coordinator.execution(Coordinator.java:311) - at org.apache.iotdb.db.queryengine.plan.Coordinator.executeForTableModel(Coordinator.java:506) - at org.apache.iotdb.db.protocol.thrift.impl.ClientRPCServiceImpl.executeStatementInternal(ClientRPCServiceImpl.java:459) - at org.apache.iotdb.db.protocol.thrift.impl.ClientRPCServiceImpl.executeStatementV2(ClientRPCServiceImpl.java:1157) - at org.apache.iotdb.service.rpc.thrift.IClientRPCService$Processor$executeStatementV2.getResult(IClientRPCService.java:4283) - at org.apache.iotdb.service.rpc.thrift.IClientRPCService$Processor$executeStatementV2.getResult(IClientRPCService.java:4263) - at org.apache.thrift.ProcessFunction.process(ProcessFunction.java:38) - at org.apache.iotdb.db.protocol.thrift.ProcessorWithMetrics.process(ProcessorWithMetrics.java:64) - at org.apache.thrift.server.TThreadPoolServer$WorkerProcess.run(TThreadPoolServer.java:248) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-1" #103 prio=5 os_prio=31 cpu=0.61ms elapsed=93.06s tid=0x000000011333fe00 nid=0x10f03 waiting on condition [0x0000000326d36000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-2" #104 prio=5 os_prio=31 cpu=0.19ms elapsed=92.98s tid=0x000000013599ec00 nid=0x11103 waiting on condition [0x0000000326f42000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-3" #105 prio=5 os_prio=31 cpu=1.26ms elapsed=92.95s tid=0x000000012270de00 nid=0x14403 waiting on condition [0x000000032714e000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-4" #106 prio=5 os_prio=31 cpu=0.20ms elapsed=92.93s tid=0x0000000113338e00 nid=0x11303 waiting on condition [0x000000032735a000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-46-IoTDB-Fragment-Instance-Notification-1" #107 prio=5 os_prio=31 cpu=5.10ms elapsed=89.98s tid=0x00000001359c4400 nid=0x11503 waiting on condition [0x0000000327566000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05f5740> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-46-IoTDB-Fragment-Instance-Notification-2" #108 prio=5 os_prio=31 cpu=4.81ms elapsed=89.96s tid=0x00000001359d1800 nid=0x11703 waiting on condition [0x0000000327772000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05f5740> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-46-IoTDB-Fragment-Instance-Notification-3" #109 prio=5 os_prio=31 cpu=7.14ms elapsed=89.96s tid=0x000000030587a400 nid=0x14103 waiting on condition [0x000000032797e000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05f5740> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-46-IoTDB-Fragment-Instance-Notification-4" #110 prio=5 os_prio=31 cpu=3.19ms elapsed=89.96s tid=0x0000000137909200 nid=0x11803 waiting on condition [0x0000000327b8a000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05f5740> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-5" #111 prio=5 os_prio=31 cpu=0.38ms elapsed=89.51s tid=0x00000001350baa00 nid=0x11903 waiting on condition [0x0000000327d96000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-1" #112 prio=5 os_prio=31 cpu=4.40ms elapsed=89.51s tid=0x00000001350b4800 nid=0x13d03 waiting on condition [0x0000000327fa2000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1170) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-6" #113 prio=5 os_prio=31 cpu=0.23ms elapsed=89.50s tid=0x0000000127896c00 nid=0x13c03 waiting on condition [0x00000003281ae000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-2" #114 prio=5 os_prio=31 cpu=0.48ms elapsed=89.50s tid=0x0000000127053800 nid=0x11c03 waiting on condition [0x00000003283ba000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1170) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-3" #115 prio=5 os_prio=31 cpu=1.23ms elapsed=89.49s tid=0x000000012258b400 nid=0x13b03 waiting on condition [0x00000003285c6000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-7" #116 prio=5 os_prio=31 cpu=0.23ms elapsed=89.46s tid=0x0000000322671600 nid=0x13a03 waiting on condition [0x00000003287d2000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-8" #117 prio=5 os_prio=31 cpu=0.12ms elapsed=89.46s tid=0x00000003224b4c00 nid=0x12003 waiting on condition [0x00000003289de000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-1" #118 prio=5 os_prio=31 cpu=5.35ms elapsed=88.76s tid=0x0000000113071800 nid=0x12203 waiting on condition [0x0000000328bea000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-2" #119 prio=5 os_prio=31 cpu=49.50ms elapsed=88.75s tid=0x0000000137ee1a00 nid=0x12403 waiting on condition [0x0000000328df6000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-3" #120 prio=5 os_prio=31 cpu=34.92ms elapsed=88.75s tid=0x000000013207d200 nid=0x12503 waiting on condition [0x0000000329002000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-9" #121 prio=5 os_prio=31 cpu=0.17ms elapsed=88.16s tid=0x000000012243c200 nid=0x12603 waiting on condition [0x000000032920e000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-10" #122 prio=5 os_prio=31 cpu=0.15ms elapsed=88.16s tid=0x0000000137865800 nid=0x12703 waiting on condition [0x000000032941a000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-11" #123 prio=5 os_prio=31 cpu=0.13ms elapsed=88.16s tid=0x0000000134cd6800 nid=0x13503 waiting on condition [0x0000000329626000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-12" #124 prio=5 os_prio=31 cpu=0.15ms elapsed=88.16s tid=0x00000001130ae800 nid=0x12803 waiting on condition [0x0000000329832000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-13" #125 prio=5 os_prio=31 cpu=0.11ms elapsed=88.16s tid=0x0000000305940000 nid=0x13203 waiting on condition [0x0000000329a3e000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-14" #126 prio=5 os_prio=31 cpu=0.07ms elapsed=88.16s tid=0x0000000305867c00 nid=0x13003 waiting on condition [0x0000000329c4a000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-15" #127 prio=5 os_prio=31 cpu=0.17ms elapsed=86.81s tid=0x0000000122840400 nid=0x12e03 waiting on condition [0x0000000329e56000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-16" #128 prio=5 os_prio=31 cpu=0.26ms elapsed=86.81s tid=0x00000001120d5a00 nid=0x12c03 waiting on condition [0x000000032a062000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-17" #129 prio=5 os_prio=31 cpu=0.31ms elapsed=86.17s tid=0x00000001320b0a00 nid=0x12a03 waiting on condition [0x000000032a26e000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-4" #130 prio=5 os_prio=31 cpu=0.73ms elapsed=86.17s tid=0x0000000127053e00 nid=0x15503 waiting on condition [0x000000032a47a000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-18" #131 prio=5 os_prio=31 cpu=0.23ms elapsed=86.17s tid=0x000000012704f000 nid=0x1ff03 waiting on condition [0x000000032a686000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-5" #132 prio=5 os_prio=31 cpu=1.81ms elapsed=86.17s tid=0x000000012785d800 nid=0x15803 waiting on condition [0x000000032a892000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-29-IoTDB-Driver-Task-Scheduler-Notification-1" #133 prio=5 os_prio=31 cpu=0.70ms elapsed=86.17s tid=0x00000001320b1000 nid=0x15903 waiting on condition [0x000000032aa9e000] - java.lang.Thread.State: TIMED_WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e06fb1a8> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.parkNanos(java.base@17.0.8.1/LockSupport.java:252) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:401) - at java.util.concurrent.SynchronousQueue.poll(java.base@17.0.8.1/SynchronousQueue.java:903) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1061) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-6" #134 prio=5 os_prio=31 cpu=0.39ms elapsed=86.17s tid=0x000000012283d000 nid=0x1fc03 waiting on condition [0x000000032acaa000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-19" #135 prio=5 os_prio=31 cpu=0.33ms elapsed=86.16s tid=0x00000001350ef000 nid=0x1fa03 waiting on condition [0x000000032aeb6000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-34-IoTDB-MPP-Coordinator-Executor-20" #136 prio=5 os_prio=31 cpu=0.24ms elapsed=84.91s tid=0x0000000122856000 nid=0x1f803 waiting on condition [0x000000032b0c2000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b74e8> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.LinkedBlockingQueue.take(java.base@17.0.8.1/LinkedBlockingQueue.java:435) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-4" #137 prio=5 os_prio=31 cpu=1.36ms elapsed=84.91s tid=0x00000001320b1600 nid=0x1f703 waiting on condition [0x000000032b2ce000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-7" #138 prio=5 os_prio=31 cpu=0.35ms elapsed=84.90s tid=0x000000012280a600 nid=0x1f503 waiting on condition [0x000000032b4da000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-5" #139 prio=5 os_prio=31 cpu=1.79ms elapsed=84.90s tid=0x0000000127872e00 nid=0x1f403 waiting on condition [0x000000032b6e6000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-6" #140 prio=5 os_prio=31 cpu=1.27ms elapsed=84.90s tid=0x0000000127859200 nid=0x15c03 waiting on condition [0x000000032b8f2000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-8" #141 prio=5 os_prio=31 cpu=0.29ms elapsed=84.90s tid=0x000000012787a800 nid=0x15d03 waiting on condition [0x000000032bafe000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-9" #142 prio=5 os_prio=31 cpu=0.28ms elapsed=84.90s tid=0x000000012280ac00 nid=0x15e03 waiting on condition [0x000000032bd0a000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-35-IoTDB-MPP-Coordinator-Scheduled-Executor-10" #143 prio=5 os_prio=31 cpu=0.09ms elapsed=84.84s tid=0x0000000113087a00 nid=0x1ef03 waiting on condition [0x000000032bf16000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7848> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionNode.block(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:506) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(java.base@17.0.8.1/AbstractQueuedSynchronizer.java:1623) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:1177) - at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(java.base@17.0.8.1/ScheduledThreadPoolExecutor.java:899) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-7" #144 prio=5 os_prio=31 cpu=0.87ms elapsed=64.45s tid=0x0000000137865200 nid=0xd207 waiting on condition [0x000000030394a000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-8$20260625_074909_00009_1" #145 prio=5 os_prio=31 cpu=7.79ms elapsed=64.45s tid=0x0000000137d02c00 nid=0x9907 waiting on condition [0x0000000303b54000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e44e3888> (a java.util.concurrent.FutureTask) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:211) - at java.util.concurrent.FutureTask.awaitDone(java.base@17.0.8.1/FutureTask.java:447) - at java.util.concurrent.FutureTask.get(java.base@17.0.8.1/FutureTask.java:190) - at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.topologicalParallelDispatchRead(FragmentInstanceDispatcherImpl.java:163) - at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.dispatch(FragmentInstanceDispatcherImpl.java:136) - at org.apache.iotdb.db.queryengine.plan.scheduler.ClusterScheduler.start(ClusterScheduler.java:117) - at org.apache.iotdb.db.queryengine.plan.relational.planner.TableModelPlanner.doSchedule(TableModelPlanner.java:212) - at org.apache.iotdb.db.queryengine.plan.execution.QueryExecution.schedule(QueryExecution.java:283) - at org.apache.iotdb.db.queryengine.plan.execution.QueryExecution.start(QueryExecution.java:205) - at org.apache.iotdb.db.queryengine.plan.Coordinator.execution(Coordinator.java:349) - at org.apache.iotdb.db.queryengine.plan.Coordinator.execution(Coordinator.java:311) - at org.apache.iotdb.db.queryengine.plan.Coordinator.executeForTableModel(Coordinator.java:506) - at org.apache.iotdb.db.queryengine.udf.InternalQueryExecutor.executeInternalQuery(InternalQueryExecutor.java:84) - at org.apache.iotdb.db.queryengine.udf.IoTDBLocalImpl.query(IoTDBLocalImpl.java:68) - at org.apache.iotdb.db.queryengine.udf.DeviceNameFunction.beforeStart(DeviceNameFunction.java:52) - at org.apache.iotdb.calc.transformation.dag.column.udf.UserDefineScalarFunctionTransformer.(UserDefineScalarFunctionTransformer.java:59) - at org.apache.iotdb.calc.execution.relational.ColumnTransformerBuilder.getFunctionColumnTransformer(ColumnTransformerBuilder.java:1495) - at org.apache.iotdb.calc.execution.relational.ColumnTransformerBuilder.visitFunctionCall(ColumnTransformerBuilder.java:708) - at org.apache.iotdb.calc.execution.relational.ColumnTransformerBuilder.visitFunctionCall(ColumnTransformerBuilder.java:254) - at org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.FunctionCall.accept(FunctionCall.java:173) - at org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.CommonQueryAstVisitor.process(CommonQueryAstVisitor.java:34) - at org.apache.iotdb.calc.plan.planner.TableOperatorGenerator.constructFilterAndProjectOperator(TableOperatorGenerator.java:388) - at org.apache.iotdb.calc.plan.planner.TableOperatorGenerator.visitProject(TableOperatorGenerator.java:440) - at org.apache.iotdb.calc.plan.planner.TableOperatorGenerator.visitProject(TableOperatorGenerator.java:248) - at org.apache.iotdb.commons.queryengine.plan.relational.planner.node.ProjectNode.accept(ProjectNode.java:52) - at org.apache.iotdb.db.queryengine.plan.planner.DataNodeTableOperatorGenerator.visitIdentitySink(DataNodeTableOperatorGenerator.java:283) - at org.apache.iotdb.db.queryengine.plan.planner.DataNodeTableOperatorGenerator.visitIdentitySink(DataNodeTableOperatorGenerator.java:209) - at org.apache.iotdb.db.queryengine.plan.planner.plan.node.sink.IdentitySinkNode.accept(IdentitySinkNode.java:76) - at org.apache.iotdb.db.queryengine.plan.planner.LocalExecutionPlanner.generateOperator(LocalExecutionPlanner.java:186) - at org.apache.iotdb.db.queryengine.plan.planner.LocalExecutionPlanner.plan(LocalExecutionPlanner.java:113) - at org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceManager.lambda$execDataQueryFragmentInstance$3(FragmentInstanceManager.java:178) - at org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceManager$$Lambda$1891/0x00000070018dccd8.apply(Unknown Source) - at java.util.concurrent.ConcurrentHashMap.computeIfAbsent(java.base@17.0.8.1/ConcurrentHashMap.java:1708) - - locked <0x00000006e4973aa8> (a java.util.concurrent.ConcurrentHashMap$ReservationNode) - at org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceManager.execDataQueryFragmentInstance(FragmentInstanceManager.java:144) - at org.apache.iotdb.db.consensus.statemachine.dataregion.DataRegionStateMachine.read(DataRegionStateMachine.java:271) - at org.apache.iotdb.consensus.iot.IoTConsensusServerImpl.read(IoTConsensusServerImpl.java:345) - at org.apache.iotdb.consensus.iot.IoTConsensus.read(IoTConsensus.java:277) - at org.apache.iotdb.db.queryengine.execution.executor.RegionReadExecutor.execute(RegionReadExecutor.java:86) - at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.dispatchLocally(FragmentInstanceDispatcherImpl.java:652) - at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.dispatchOneInstance(FragmentInstanceDispatcherImpl.java:456) - at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.lambda$asyncDispatchOneInstance$0(FragmentInstanceDispatcherImpl.java:200) - at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl$$Lambda$1889/0x00000070018dbe60.call(Unknown Source) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-9" #146 prio=5 os_prio=31 cpu=7.59ms elapsed=64.45s tid=0x0000000134efe400 nid=0x9707 waiting on condition [0x0000000323442000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-10" #147 prio=5 os_prio=31 cpu=0.39ms elapsed=64.44s tid=0x00000001358d5600 nid=0x15f03 waiting on condition [0x000000032c122000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-11" #148 prio=5 os_prio=31 cpu=0.42ms elapsed=64.44s tid=0x0000000305944200 nid=0x1ed03 waiting on condition [0x000000032c32e000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-12" #149 prio=5 os_prio=31 cpu=0.31ms elapsed=64.44s tid=0x000000013477e600 nid=0x1ec03 waiting on condition [0x000000032c53a000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-13" #150 prio=5 os_prio=31 cpu=0.44ms elapsed=64.44s tid=0x0000000113060800 nid=0x1eb03 waiting on condition [0x000000032c746000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-14$20260625_074909_00009_1.2.0" #151 prio=5 os_prio=31 cpu=3.38ms elapsed=64.44s tid=0x0000000122664600 nid=0x1ea03 waiting for monitor entry [0x000000032c951000] - java.lang.Thread.State: BLOCKED (on object monitor) - at java.util.concurrent.ConcurrentHashMap.computeIfAbsent(java.base@17.0.8.1/ConcurrentHashMap.java:1726) - - waiting to lock <0x00000006e4973aa8> (a java.util.concurrent.ConcurrentHashMap$ReservationNode) - at org.apache.iotdb.db.queryengine.execution.fragment.FragmentInstanceManager.execDataQueryFragmentInstance(FragmentInstanceManager.java:144) - at org.apache.iotdb.db.consensus.statemachine.dataregion.DataRegionStateMachine.read(DataRegionStateMachine.java:271) - at org.apache.iotdb.consensus.iot.IoTConsensusServerImpl.read(IoTConsensusServerImpl.java:345) - at org.apache.iotdb.consensus.iot.IoTConsensus.read(IoTConsensus.java:277) - at org.apache.iotdb.db.queryengine.execution.executor.RegionReadExecutor.execute(RegionReadExecutor.java:86) - at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.dispatchLocally(FragmentInstanceDispatcherImpl.java:652) - at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.dispatchOneInstance(FragmentInstanceDispatcherImpl.java:456) - at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl.lambda$asyncDispatchOneInstance$0(FragmentInstanceDispatcherImpl.java:200) - at org.apache.iotdb.db.queryengine.plan.scheduler.FragmentInstanceDispatcherImpl$$Lambda$1889/0x00000070018dbe60.call(Unknown Source) - at java.util.concurrent.FutureTask.run$$$capture(java.base@17.0.8.1/FutureTask.java:264) - at java.util.concurrent.FutureTask.run(java.base@17.0.8.1/FutureTask.java) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1136) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"pool-36-IoTDB-Fragment-Instance-Dispatch-15" #152 prio=5 os_prio=31 cpu=0.38ms elapsed=64.44s tid=0x0000000122194e00 nid=0x1e903 waiting on condition [0x000000032cb5e000] - java.lang.Thread.State: WAITING (parking) - at jdk.internal.misc.Unsafe.park(java.base@17.0.8.1/Native Method) - - parking to wait for <0x00000006e05b7a08> (a java.util.concurrent.SynchronousQueue$TransferStack) - at java.util.concurrent.locks.LockSupport.park(java.base@17.0.8.1/LockSupport.java:341) - at java.util.concurrent.SynchronousQueue$TransferStack$SNode.block(java.base@17.0.8.1/SynchronousQueue.java:288) - at java.util.concurrent.ForkJoinPool.unmanagedBlock(java.base@17.0.8.1/ForkJoinPool.java:3465) - at java.util.concurrent.ForkJoinPool.managedBlock(java.base@17.0.8.1/ForkJoinPool.java:3436) - at java.util.concurrent.SynchronousQueue$TransferStack.transfer(java.base@17.0.8.1/SynchronousQueue.java:397) - at java.util.concurrent.SynchronousQueue.take(java.base@17.0.8.1/SynchronousQueue.java:886) - at java.util.concurrent.ThreadPoolExecutor.getTask(java.base@17.0.8.1/ThreadPoolExecutor.java:1062) - at java.util.concurrent.ThreadPoolExecutor.runWorker(java.base@17.0.8.1/ThreadPoolExecutor.java:1122) - at java.util.concurrent.ThreadPoolExecutor$Worker.run(java.base@17.0.8.1/ThreadPoolExecutor.java:635) - at java.lang.Thread.run(java.base@17.0.8.1/Thread.java:833) - -"Attach Listener" #153 daemon prio=9 os_prio=31 cpu=0.55ms elapsed=0.10s tid=0x0000000122598c00 nid=0x890b waiting on condition [0x0000000000000000] - java.lang.Thread.State: RUNNABLE - -"VM Thread" os_prio=31 cpu=39.17ms elapsed=140.99s tid=0x0000000133b05780 nid=0x4803 runnable - -"GC Thread#0" os_prio=31 cpu=29.13ms elapsed=141.00s tid=0x0000000133905f30 nid=0x3903 runnable - -"GC Thread#1" os_prio=31 cpu=30.65ms elapsed=140.74s tid=0x0000000112e06f90 nid=0x6c03 runnable - -"GC Thread#2" os_prio=31 cpu=29.98ms elapsed=140.74s tid=0x0000000112e07490 nid=0x6903 runnable - -"GC Thread#3" os_prio=31 cpu=33.57ms elapsed=140.74s tid=0x0000000132e11aa0 nid=0x8003 runnable - -"GC Thread#4" os_prio=31 cpu=30.11ms elapsed=140.74s tid=0x000000013390e9d0 nid=0xa903 runnable - -"GC Thread#5" os_prio=31 cpu=32.41ms elapsed=140.74s tid=0x0000000132e12330 nid=0x8203 runnable - -"GC Thread#6" os_prio=31 cpu=32.46ms elapsed=140.74s tid=0x0000000132e12ba0 nid=0xa703 runnable - -"GC Thread#7" os_prio=31 cpu=28.41ms elapsed=140.61s tid=0x0000000133b1b7f0 nid=0x8503 runnable - -"GC Thread#8" os_prio=31 cpu=29.81ms elapsed=140.61s tid=0x0000000133b1baa0 nid=0x8703 runnable - -"G1 Main Marker" os_prio=31 cpu=0.35ms elapsed=141.00s tid=0x0000000132e05d40 nid=0x3403 runnable - -"G1 Conc#0" os_prio=31 cpu=14.46ms elapsed=141.00s tid=0x0000000133a052a0 nid=0x3603 runnable - -"G1 Conc#1" os_prio=31 cpu=18.60ms elapsed=140.01s tid=0x0000000133928620 nid=0x8b03 runnable - -"G1 Refine#0" os_prio=31 cpu=0.02ms elapsed=141.00s tid=0x0000000133a073d0 nid=0x5303 runnable - -"G1 Service" os_prio=31 cpu=6.41ms elapsed=141.00s tid=0x0000000133a07c70 nid=0x5203 runnable - -"VM Periodic Task Thread" os_prio=31 cpu=23.10ms elapsed=140.82s tid=0x0000000112f119a0 nid=0x6e03 waiting on condition - -JNI global refs: 184, weak refs: 10235 - From 5c2b0adee66b8dfa52322aa2aa09c1481266a221 Mon Sep 17 00:00:00 2001 From: Weihao Li <18110526956@163.com> Date: Fri, 26 Jun 2026 16:03:39 +0800 Subject: [PATCH 09/11] fix some Signed-off-by: Weihao Li <18110526956@163.com> --- .../iotdblocal/CreateTableProbeFunction.java | 29 ++++ .../DeviceIdListInProcessTableFunction.java | 131 ++++++++++++++++ .../iotdblocal/DeviceIdListTableFunction.java | 142 +++++++++++++++++ ...iceNameEnrichBeforeStartTableFunction.java | 144 +++++++++++++++++ ...eviceNameEnrichInProcessTableFunction.java | 139 ++++++++++++++++ .../iotdblocal/DropTableProbeFunction.java | 29 ++++ .../iotdblocal/InsertProbeFunction.java | 29 ++++ ...yUdafAtBeforeDestroyAggregateFunction.java | 101 ++++++++++++ ...eryUdafAtBeforeStartAggregateFunction.java | 112 +++++++++++++ ...lQueryUdafInAddInputAggregateFunction.java | 123 +++++++++++++++ ...ryUdafInCombineStateAggregateFunction.java | 123 +++++++++++++++ ...eryUdafInOutputFinalAggregateFunction.java | 104 ++++++++++++ .../MutatingQueryProbeFunction.java | 54 +++++++ .../relational/it/db/it/udf/IoTDBLocalIT.java | 148 ++++++++++++++++++ ...erDefinedAggregateFunctionAccumulator.java | 3 +- .../db/protocol/session/SessionManager.java | 26 +-- .../db/queryengine/plan/Coordinator.java | 27 ++++ .../udf/InternalQueryExecutor.java | 7 +- .../db/queryengine/udf/UDFResultSetImpl.java | 41 ++++- 19 files changed, 1495 insertions(+), 17 deletions(-) create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/CreateTableProbeFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceIdListInProcessTableFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceIdListTableFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceNameEnrichBeforeStartTableFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceNameEnrichInProcessTableFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DropTableProbeFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/InsertProbeFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafAtBeforeDestroyAggregateFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafAtBeforeStartAggregateFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafInAddInputAggregateFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafInCombineStateAggregateFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafInOutputFinalAggregateFunction.java create mode 100644 integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/MutatingQueryProbeFunction.java diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/CreateTableProbeFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/CreateTableProbeFunction.java new file mode 100644 index 0000000000000..90bbd4bac34e9 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/CreateTableProbeFunction.java @@ -0,0 +1,29 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +/** Probes CREATE TABLE rejection for IoTDBLocal integration tests. */ +public class CreateTableProbeFunction extends MutatingQueryProbeFunction { + + @Override + protected String mutatingSql() { + return "CREATE TABLE should_not_exist_local_probe (x INT32 FIELD)"; + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceIdListInProcessTableFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceIdListInProcessTableFunction.java new file mode 100644 index 0000000000000..ae2a9cc4138ab --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceIdListInProcessTableFunction.java @@ -0,0 +1,131 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.TableFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.relational.table.MapTableFunctionHandle; +import org.apache.iotdb.udf.api.relational.table.TableFunctionAnalysis; +import org.apache.iotdb.udf.api.relational.table.TableFunctionHandle; +import org.apache.iotdb.udf.api.relational.table.TableFunctionProcessorProvider; +import org.apache.iotdb.udf.api.relational.table.argument.Argument; +import org.apache.iotdb.udf.api.relational.table.argument.DescribedSchema; +import org.apache.iotdb.udf.api.relational.table.argument.ScalarArgument; +import org.apache.iotdb.udf.api.relational.table.processor.TableFunctionLeafProcessor; +import org.apache.iotdb.udf.api.relational.table.specification.ParameterSpecification; +import org.apache.iotdb.udf.api.relational.table.specification.ScalarParameterSpecification; +import org.apache.iotdb.udf.api.type.Type; + +import org.apache.tsfile.block.column.ColumnBuilder; +import org.apache.tsfile.common.conf.TSFileConfig; +import org.apache.tsfile.utils.Binary; + +import java.util.Collections; +import java.util.List; +import java.util.Map; + +/** + * Leaf table function: loads device_id via {@link IoTDBLocal#query(String)} in {@link + * TableFunctionLeafProcessor#process(List, IoTDBLocal)}. + */ +public class DeviceIdListInProcessTableFunction implements TableFunction { + + private static final String PREFIX_PARAMETER_NAME = "prefix"; + + @Override + public List getArgumentsSpecifications() { + return Collections.singletonList( + ScalarParameterSpecification.builder() + .name(PREFIX_PARAMETER_NAME) + .type(Type.STRING) + .defaultValue("") + .build()); + } + + @Override + public TableFunctionAnalysis analyze(Map arguments) throws UDFException { + DescribedSchema schema = DescribedSchema.builder().addField("device_id", Type.STRING).build(); + MapTableFunctionHandle handle = + new MapTableFunctionHandle.Builder() + .addProperty( + PREFIX_PARAMETER_NAME, + ((ScalarArgument) arguments.get(PREFIX_PARAMETER_NAME)).getValue()) + .build(); + return TableFunctionAnalysis.builder().properColumnSchema(schema).handle(handle).build(); + } + + @Override + public TableFunctionHandle createTableFunctionHandle() { + return new MapTableFunctionHandle(); + } + + @Override + public TableFunctionProcessorProvider getProcessorProvider( + TableFunctionHandle tableFunctionHandle) { + return new TableFunctionProcessorProvider() { + @Override + public TableFunctionLeafProcessor getSplitProcessor() { + return new InProcessProcessor( + (String) + ((MapTableFunctionHandle) tableFunctionHandle).getProperty(PREFIX_PARAMETER_NAME)); + } + }; + } + + private static class InProcessProcessor implements TableFunctionLeafProcessor { + private final String prefix; + private boolean finish; + + InProcessProcessor(String prefix) { + this.prefix = prefix == null ? "" : prefix; + } + + @Override + public void process(List columnBuilders) { + throw new UnsupportedOperationException("framework invokes process(List, IoTDBLocal)"); + } + + @Override + public void process(List columnBuilders, IoTDBLocal local) { + if (finish) { + return; + } + try (UDFResultSet rs = local.query("SELECT device_id FROM device_info ORDER BY device_id")) { + while (rs.hasNext()) { + Record row = rs.next(); + columnBuilders + .get(0) + .writeBinary(new Binary(prefix + row.getString(0), TSFileConfig.STRING_CHARSET)); + } + } catch (UDFException e) { + throw new IllegalStateException(e); + } + finish = true; + } + + @Override + public boolean isFinish() { + return finish; + } + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceIdListTableFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceIdListTableFunction.java new file mode 100644 index 0000000000000..1a036d4722a14 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceIdListTableFunction.java @@ -0,0 +1,142 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.TableFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.relational.table.MapTableFunctionHandle; +import org.apache.iotdb.udf.api.relational.table.TableFunctionAnalysis; +import org.apache.iotdb.udf.api.relational.table.TableFunctionHandle; +import org.apache.iotdb.udf.api.relational.table.TableFunctionProcessorProvider; +import org.apache.iotdb.udf.api.relational.table.argument.Argument; +import org.apache.iotdb.udf.api.relational.table.argument.DescribedSchema; +import org.apache.iotdb.udf.api.relational.table.argument.ScalarArgument; +import org.apache.iotdb.udf.api.relational.table.processor.TableFunctionLeafProcessor; +import org.apache.iotdb.udf.api.relational.table.specification.ParameterSpecification; +import org.apache.iotdb.udf.api.relational.table.specification.ScalarParameterSpecification; +import org.apache.iotdb.udf.api.type.Type; + +import org.apache.tsfile.block.column.ColumnBuilder; +import org.apache.tsfile.common.conf.TSFileConfig; +import org.apache.tsfile.utils.Binary; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +/** + * Leaf table function: loads device_id via {@link IoTDBLocal#query(String)} in {@link + * TableFunctionLeafProcessor#beforeStart(IoTDBLocal)}. + */ +public class DeviceIdListTableFunction implements TableFunction { + + private static final String PREFIX_PARAMETER_NAME = "prefix"; + + @Override + public List getArgumentsSpecifications() { + return Collections.singletonList( + ScalarParameterSpecification.builder() + .name(PREFIX_PARAMETER_NAME) + .type(Type.STRING) + .defaultValue("") + .build()); + } + + @Override + public TableFunctionAnalysis analyze(Map arguments) throws UDFException { + DescribedSchema schema = DescribedSchema.builder().addField("device_id", Type.STRING).build(); + MapTableFunctionHandle handle = + new MapTableFunctionHandle.Builder() + .addProperty( + PREFIX_PARAMETER_NAME, + ((ScalarArgument) arguments.get(PREFIX_PARAMETER_NAME)).getValue()) + .build(); + return TableFunctionAnalysis.builder().properColumnSchema(schema).handle(handle).build(); + } + + @Override + public TableFunctionHandle createTableFunctionHandle() { + return new MapTableFunctionHandle(); + } + + @Override + public TableFunctionProcessorProvider getProcessorProvider( + TableFunctionHandle tableFunctionHandle) { + return new TableFunctionProcessorProvider() { + @Override + public TableFunctionLeafProcessor getSplitProcessor() { + return new BeforeStartProcessor( + (String) + ((MapTableFunctionHandle) tableFunctionHandle).getProperty(PREFIX_PARAMETER_NAME)); + } + }; + } + + private static class BeforeStartProcessor implements TableFunctionLeafProcessor { + private final String prefix; + private final List deviceIds = new ArrayList<>(); + private boolean finish; + + BeforeStartProcessor(String prefix) { + this.prefix = prefix == null ? "" : prefix; + } + + @Override + public void beforeStart(IoTDBLocal local) throws UDFException { + try (UDFResultSet rs = local.query("SELECT device_id FROM device_info ORDER BY device_id")) { + while (rs.hasNext()) { + Record row = rs.next(); + deviceIds.add(row.getString(0)); + } + } + } + + @Override + public void process(List columnBuilders) { + writeDeviceIds(columnBuilders); + } + + @Override + public void process(List columnBuilders, IoTDBLocal local) { + writeDeviceIds(columnBuilders); + } + + private void writeDeviceIds(List columnBuilders) { + if (finish) { + return; + } + for (String deviceId : deviceIds) { + columnBuilders + .get(0) + .writeBinary(new Binary(prefix + deviceId, TSFileConfig.STRING_CHARSET)); + } + finish = true; + } + + @Override + public boolean isFinish() { + return finish; + } + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceNameEnrichBeforeStartTableFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceNameEnrichBeforeStartTableFunction.java new file mode 100644 index 0000000000000..af49b63d2f618 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceNameEnrichBeforeStartTableFunction.java @@ -0,0 +1,144 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.EmptyTableFunctionHandle; +import org.apache.iotdb.udf.api.relational.TableFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.relational.table.TableFunctionAnalysis; +import org.apache.iotdb.udf.api.relational.table.TableFunctionHandle; +import org.apache.iotdb.udf.api.relational.table.TableFunctionProcessorProvider; +import org.apache.iotdb.udf.api.relational.table.argument.Argument; +import org.apache.iotdb.udf.api.relational.table.argument.DescribedSchema; +import org.apache.iotdb.udf.api.relational.table.argument.TableArgument; +import org.apache.iotdb.udf.api.relational.table.processor.TableFunctionDataProcessor; +import org.apache.iotdb.udf.api.relational.table.specification.ParameterSpecification; +import org.apache.iotdb.udf.api.relational.table.specification.TableParameterSpecification; +import org.apache.iotdb.udf.api.type.Type; + +import org.apache.tsfile.block.column.ColumnBuilder; +import org.apache.tsfile.common.conf.TSFileConfig; +import org.apache.tsfile.utils.Binary; + +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +/** + * Data table function: loads device_name mapping via {@link IoTDBLocal#query(String)} in {@link + * TableFunctionDataProcessor#beforeStart(IoTDBLocal)}. + */ +public class DeviceNameEnrichBeforeStartTableFunction implements TableFunction { + + private static final String TABLE_PARAM = "DATA"; + + @Override + public List getArgumentsSpecifications() { + return Collections.singletonList( + TableParameterSpecification.builder().name(TABLE_PARAM).rowSemantics().build()); + } + + @Override + public TableFunctionAnalysis analyze(Map arguments) throws UDFException { + TableArgument tableArgument = (TableArgument) arguments.get(TABLE_PARAM); + int deviceIdIndex = findDeviceIdIndex(tableArgument); + if (deviceIdIndex < 0) { + throw new UDFArgumentNotValidException("device_id column is required in table argument"); + } + return TableFunctionAnalysis.builder() + .properColumnSchema(DescribedSchema.builder().addField("device_name", Type.STRING).build()) + .requiredColumns(TABLE_PARAM, Collections.singletonList(deviceIdIndex)) + .handle(new EmptyTableFunctionHandle()) + .build(); + } + + @Override + public TableFunctionHandle createTableFunctionHandle() { + return new EmptyTableFunctionHandle(); + } + + @Override + public TableFunctionProcessorProvider getProcessorProvider( + TableFunctionHandle tableFunctionHandle) { + return new TableFunctionProcessorProvider() { + @Override + public TableFunctionDataProcessor getDataProcessor() { + return new BeforeStartProcessor(); + } + }; + } + + private static int findDeviceIdIndex(TableArgument tableArgument) { + for (int i = 0; i < tableArgument.getFieldNames().size(); i++) { + Optional fieldName = tableArgument.getFieldNames().get(i); + if (fieldName.isPresent() && "device_id".equalsIgnoreCase(fieldName.get())) { + return i; + } + } + return -1; + } + + private static class BeforeStartProcessor implements TableFunctionDataProcessor { + private Map idToName = Map.of(); + + @Override + public void beforeStart(IoTDBLocal local) throws UDFException { + Map map = new HashMap<>(); + try (UDFResultSet rs = local.query("SELECT device_id, device_name FROM device_info")) { + while (rs.hasNext()) { + Record row = rs.next(); + map.put(row.getString(0), row.getString(1)); + } + } + idToName = map; + } + + @Override + public void process( + Record input, + List properColumnBuilders, + ColumnBuilder passThroughIndexBuilder) { + writeDeviceName(input, properColumnBuilders); + } + + @Override + public void process( + Record input, + List properColumnBuilders, + ColumnBuilder passThroughIndexBuilder, + IoTDBLocal local) { + writeDeviceName(input, properColumnBuilders); + } + + private void writeDeviceName(Record input, List properColumnBuilders) { + String deviceId = input.getString(0); + properColumnBuilders + .get(0) + .writeBinary( + new Binary(idToName.getOrDefault(deviceId, "未知设备"), TSFileConfig.STRING_CHARSET)); + } + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceNameEnrichInProcessTableFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceNameEnrichInProcessTableFunction.java new file mode 100644 index 0000000000000..7839fa6b99a7d --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DeviceNameEnrichInProcessTableFunction.java @@ -0,0 +1,139 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.EmptyTableFunctionHandle; +import org.apache.iotdb.udf.api.relational.TableFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.relational.table.TableFunctionAnalysis; +import org.apache.iotdb.udf.api.relational.table.TableFunctionHandle; +import org.apache.iotdb.udf.api.relational.table.TableFunctionProcessorProvider; +import org.apache.iotdb.udf.api.relational.table.argument.Argument; +import org.apache.iotdb.udf.api.relational.table.argument.DescribedSchema; +import org.apache.iotdb.udf.api.relational.table.argument.TableArgument; +import org.apache.iotdb.udf.api.relational.table.processor.TableFunctionDataProcessor; +import org.apache.iotdb.udf.api.relational.table.specification.ParameterSpecification; +import org.apache.iotdb.udf.api.relational.table.specification.TableParameterSpecification; +import org.apache.iotdb.udf.api.type.Type; + +import org.apache.tsfile.block.column.ColumnBuilder; +import org.apache.tsfile.common.conf.TSFileConfig; +import org.apache.tsfile.utils.Binary; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +/** + * Data table function: looks up device_name via per-row {@link IoTDBLocal#query(String)} in {@link + * TableFunctionDataProcessor#process(Record, List, ColumnBuilder, IoTDBLocal)}. + */ +public class DeviceNameEnrichInProcessTableFunction implements TableFunction { + + private static final String TABLE_PARAM = "DATA"; + + @Override + public List getArgumentsSpecifications() { + return Collections.singletonList( + TableParameterSpecification.builder().name(TABLE_PARAM).rowSemantics().build()); + } + + @Override + public TableFunctionAnalysis analyze(Map arguments) throws UDFException { + TableArgument tableArgument = (TableArgument) arguments.get(TABLE_PARAM); + int deviceIdIndex = findDeviceIdIndex(tableArgument); + if (deviceIdIndex < 0) { + throw new UDFArgumentNotValidException("device_id column is required in table argument"); + } + return TableFunctionAnalysis.builder() + .properColumnSchema(DescribedSchema.builder().addField("device_name", Type.STRING).build()) + .requiredColumns(TABLE_PARAM, Collections.singletonList(deviceIdIndex)) + .handle(new EmptyTableFunctionHandle()) + .build(); + } + + @Override + public TableFunctionHandle createTableFunctionHandle() { + return new EmptyTableFunctionHandle(); + } + + @Override + public TableFunctionProcessorProvider getProcessorProvider( + TableFunctionHandle tableFunctionHandle) { + return new TableFunctionProcessorProvider() { + @Override + public TableFunctionDataProcessor getDataProcessor() { + return new InProcessProcessor(); + } + }; + } + + private static int findDeviceIdIndex(TableArgument tableArgument) { + for (int i = 0; i < tableArgument.getFieldNames().size(); i++) { + Optional fieldName = tableArgument.getFieldNames().get(i); + if (fieldName.isPresent() && "device_id".equalsIgnoreCase(fieldName.get())) { + return i; + } + } + return -1; + } + + private static class InProcessProcessor implements TableFunctionDataProcessor { + + @Override + public void process( + Record input, + List properColumnBuilders, + ColumnBuilder passThroughIndexBuilder) { + throw new UnsupportedOperationException( + "framework invokes process(Record, List, ColumnBuilder, IoTDBLocal)"); + } + + @Override + public void process( + Record input, + List properColumnBuilders, + ColumnBuilder passThroughIndexBuilder, + IoTDBLocal local) { + String deviceId = input.getString(0); + properColumnBuilders + .get(0) + .writeBinary(new Binary(queryDeviceName(local, deviceId), TSFileConfig.STRING_CHARSET)); + } + + private static String queryDeviceName(IoTDBLocal local, String deviceId) { + String sql = + String.format("SELECT device_name FROM device_info WHERE device_id = '%s'", deviceId); + try (UDFResultSet rs = local.query(sql)) { + if (rs.hasNext()) { + return rs.next().getString(0); + } + } catch (UDFException e) { + throw new IllegalStateException(e); + } + return "未知设备"; + } + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DropTableProbeFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DropTableProbeFunction.java new file mode 100644 index 0000000000000..a5825eab4fa8a --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/DropTableProbeFunction.java @@ -0,0 +1,29 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +/** Probes DROP TABLE rejection for IoTDBLocal integration tests. */ +public class DropTableProbeFunction extends MutatingQueryProbeFunction { + + @Override + protected String mutatingSql() { + return "DROP TABLE device_info"; + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/InsertProbeFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/InsertProbeFunction.java new file mode 100644 index 0000000000000..a4d5fc525c4f3 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/InsertProbeFunction.java @@ -0,0 +1,29 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +/** Probes INSERT rejection for IoTDBLocal integration tests. */ +public class InsertProbeFunction extends MutatingQueryProbeFunction { + + @Override + protected String mutatingSql() { + return "INSERT INTO probe_table(time, device_id, value) VALUES (2, 'probe', 99.0)"; + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafAtBeforeDestroyAggregateFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafAtBeforeDestroyAggregateFunction.java new file mode 100644 index 0000000000000..16e924c7bbd5d --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafAtBeforeDestroyAggregateFunction.java @@ -0,0 +1,101 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.State; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.customizer.analysis.AggregateFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.AggregateFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.type.Type; +import org.apache.iotdb.udf.api.utils.ResultValue; + +import java.nio.ByteBuffer; + +/** UDAF that calls {@link IoTDBLocal#query(String)} only in {@link #beforeDestroy(IoTDBLocal)}. */ +public class LocalQueryUdafAtBeforeDestroyAggregateFunction implements AggregateFunction { + + private static class CountState implements State { + long count; + + @Override + public void reset() { + count = 0; + } + + @Override + public byte[] serialize() { + ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES); + buffer.putLong(count); + return buffer.array(); + } + + @Override + public void deserialize(byte[] bytes) { + count = ByteBuffer.wrap(bytes).getLong(); + } + } + + @Override + public AggregateFunctionAnalysis analyze(FunctionArguments arguments) + throws UDFArgumentNotValidException { + if (arguments.getArgumentsSize() != 1) { + throw new UDFArgumentNotValidException("expects one column"); + } + return new AggregateFunctionAnalysis.Builder().outputDataType(Type.INT64).build(); + } + + @Override + public State createState() { + return new CountState(); + } + + @Override + public void addInput(State state, Record input) { + if (!input.isNull(0)) { + ((CountState) state).count++; + } + } + + @Override + public void combineState(State state, State rhs) { + ((CountState) state).count += ((CountState) rhs).count; + } + + @Override + public void outputFinal(State state, ResultValue resultValue) { + resultValue.setLong(((CountState) state).count); + } + + @Override + public void beforeDestroy(IoTDBLocal local) { + try (UDFResultSet rs = local.query("SELECT COUNT(*) FROM device_limits")) { + while (rs.hasNext()) { + rs.next(); + } + } catch (UDFException e) { + throw new IllegalStateException(e); + } + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafAtBeforeStartAggregateFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafAtBeforeStartAggregateFunction.java new file mode 100644 index 0000000000000..ef0196727f69d --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafAtBeforeStartAggregateFunction.java @@ -0,0 +1,112 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.State; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.customizer.analysis.AggregateFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.AggregateFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.type.Type; +import org.apache.iotdb.udf.api.utils.ResultValue; + +import java.nio.ByteBuffer; + +/** UDAF that calls {@link IoTDBLocal#query(String)} only in {@link #beforeStart}. */ +public class LocalQueryUdafAtBeforeStartAggregateFunction implements AggregateFunction { + + private long extraCount; + + private static class CountState implements State { + long count; + long extraCount; + + @Override + public void reset() { + count = 0; + extraCount = 0; + } + + @Override + public byte[] serialize() { + ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES * 2); + buffer.putLong(count); + buffer.putLong(extraCount); + return buffer.array(); + } + + @Override + public void deserialize(byte[] bytes) { + ByteBuffer buffer = ByteBuffer.wrap(bytes); + count = buffer.getLong(); + extraCount = buffer.getLong(); + } + } + + @Override + public AggregateFunctionAnalysis analyze(FunctionArguments arguments) + throws UDFArgumentNotValidException { + if (arguments.getArgumentsSize() != 1) { + throw new UDFArgumentNotValidException("expects one column"); + } + return new AggregateFunctionAnalysis.Builder().outputDataType(Type.INT64).build(); + } + + @Override + public void beforeStart(FunctionArguments arguments, IoTDBLocal local) throws UDFException { + try (UDFResultSet rs = local.query("SELECT COUNT(*) FROM device_info")) { + if (rs.hasNext()) { + extraCount = rs.next().getLong(0); + } + } + } + + @Override + public State createState() { + CountState state = new CountState(); + state.extraCount = extraCount; + return state; + } + + @Override + public void addInput(State state, Record input) { + if (!input.isNull(0)) { + ((CountState) state).count++; + } + } + + @Override + public void combineState(State state, State rhs) { + CountState left = (CountState) state; + CountState right = (CountState) rhs; + left.count += right.count; + left.extraCount = Math.max(left.extraCount, right.extraCount); + } + + @Override + public void outputFinal(State state, ResultValue resultValue) { + CountState countState = (CountState) state; + resultValue.setLong(countState.count + countState.extraCount); + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafInAddInputAggregateFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafInAddInputAggregateFunction.java new file mode 100644 index 0000000000000..1f1005925cd18 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafInAddInputAggregateFunction.java @@ -0,0 +1,123 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.State; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.customizer.analysis.AggregateFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.AggregateFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.type.Type; +import org.apache.iotdb.udf.api.utils.ResultValue; + +import java.nio.ByteBuffer; + +/** + * UDAF that calls {@link IoTDBLocal#query(String)} only in {@link #addInput(State, Record, + * IoTDBLocal)}. + */ +public class LocalQueryUdafInAddInputAggregateFunction implements AggregateFunction { + + private static class CountState implements State { + long count; + long extraCount; + boolean queried; + + @Override + public void reset() { + count = 0; + extraCount = 0; + queried = false; + } + + @Override + public byte[] serialize() { + ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES * 2 + 1); + buffer.putLong(count); + buffer.putLong(extraCount); + buffer.put((byte) (queried ? 1 : 0)); + return buffer.array(); + } + + @Override + public void deserialize(byte[] bytes) { + ByteBuffer buffer = ByteBuffer.wrap(bytes); + count = buffer.getLong(); + extraCount = buffer.getLong(); + queried = buffer.get() != 0; + } + } + + @Override + public AggregateFunctionAnalysis analyze(FunctionArguments arguments) + throws UDFArgumentNotValidException { + if (arguments.getArgumentsSize() != 1) { + throw new UDFArgumentNotValidException("expects one column"); + } + return new AggregateFunctionAnalysis.Builder().outputDataType(Type.INT64).build(); + } + + @Override + public State createState() { + return new CountState(); + } + + @Override + public void addInput(State state, Record input) { + if (!input.isNull(0)) { + ((CountState) state).count++; + } + } + + @Override + public void addInput(State state, Record input, IoTDBLocal local) { + CountState countState = (CountState) state; + if (!countState.queried) { + try (UDFResultSet rs = local.query("SELECT COUNT(*) FROM device_limits")) { + if (rs.hasNext()) { + countState.extraCount = rs.next().getLong(0); + } + } catch (UDFException e) { + throw new IllegalStateException(e); + } + countState.queried = true; + } + addInput(state, input); + } + + @Override + public void combineState(State state, State rhs) { + CountState left = (CountState) state; + CountState right = (CountState) rhs; + left.count += right.count; + left.extraCount = Math.max(left.extraCount, right.extraCount); + left.queried = left.queried || right.queried; + } + + @Override + public void outputFinal(State state, ResultValue resultValue) { + CountState countState = (CountState) state; + resultValue.setLong(countState.count + countState.extraCount); + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafInCombineStateAggregateFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafInCombineStateAggregateFunction.java new file mode 100644 index 0000000000000..7e66de05bc211 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafInCombineStateAggregateFunction.java @@ -0,0 +1,123 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.State; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.customizer.analysis.AggregateFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.AggregateFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.type.Type; +import org.apache.iotdb.udf.api.utils.ResultValue; + +import java.nio.ByteBuffer; + +/** + * UDAF that calls {@link IoTDBLocal#query(String)} only in {@link #combineState(State, State, + * IoTDBLocal)}. + */ +public class LocalQueryUdafInCombineStateAggregateFunction implements AggregateFunction { + + private static class CountState implements State { + long count; + long extraCount; + boolean combineQueried; + + @Override + public void reset() { + count = 0; + extraCount = 0; + combineQueried = false; + } + + @Override + public byte[] serialize() { + ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES * 2 + 1); + buffer.putLong(count); + buffer.putLong(extraCount); + buffer.put((byte) (combineQueried ? 1 : 0)); + return buffer.array(); + } + + @Override + public void deserialize(byte[] bytes) { + ByteBuffer buffer = ByteBuffer.wrap(bytes); + count = buffer.getLong(); + extraCount = buffer.getLong(); + combineQueried = buffer.get() != 0; + } + } + + @Override + public AggregateFunctionAnalysis analyze(FunctionArguments arguments) + throws UDFArgumentNotValidException { + if (arguments.getArgumentsSize() != 1) { + throw new UDFArgumentNotValidException("expects one column"); + } + return new AggregateFunctionAnalysis.Builder().outputDataType(Type.INT64).build(); + } + + @Override + public State createState() { + return new CountState(); + } + + @Override + public void addInput(State state, Record input) { + if (!input.isNull(0)) { + ((CountState) state).count++; + } + } + + @Override + public void combineState(State state, State rhs) { + CountState left = (CountState) state; + CountState right = (CountState) rhs; + left.count += right.count; + left.extraCount = Math.max(left.extraCount, right.extraCount); + left.combineQueried = left.combineQueried || right.combineQueried; + } + + @Override + public void combineState(State state, State rhs, IoTDBLocal local) { + CountState left = (CountState) state; + if (!left.combineQueried) { + try (UDFResultSet rs = local.query("SELECT COUNT(*) FROM device_limits")) { + if (rs.hasNext()) { + left.extraCount = rs.next().getLong(0); + } + } catch (UDFException e) { + throw new IllegalStateException(e); + } + left.combineQueried = true; + } + combineState(state, rhs); + } + + @Override + public void outputFinal(State state, ResultValue resultValue) { + CountState countState = (CountState) state; + resultValue.setLong(countState.count + countState.extraCount); + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafInOutputFinalAggregateFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafInOutputFinalAggregateFunction.java new file mode 100644 index 0000000000000..bf2dbaae52628 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafInOutputFinalAggregateFunction.java @@ -0,0 +1,104 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.State; +import org.apache.iotdb.udf.api.UDFResultSet; +import org.apache.iotdb.udf.api.customizer.analysis.AggregateFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.AggregateFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.type.Type; +import org.apache.iotdb.udf.api.utils.ResultValue; + +import java.nio.ByteBuffer; + +/** UDAF that calls {@link IoTDBLocal#query(String)} only in {@link #outputFinal} with local. */ +public class LocalQueryUdafInOutputFinalAggregateFunction implements AggregateFunction { + + private static class CountState implements State { + long count; + + @Override + public void reset() { + count = 0; + } + + @Override + public byte[] serialize() { + ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES); + buffer.putLong(count); + return buffer.array(); + } + + @Override + public void deserialize(byte[] bytes) { + count = ByteBuffer.wrap(bytes).getLong(); + } + } + + @Override + public AggregateFunctionAnalysis analyze(FunctionArguments arguments) + throws UDFArgumentNotValidException { + if (arguments.getArgumentsSize() != 1) { + throw new UDFArgumentNotValidException("expects one column"); + } + return new AggregateFunctionAnalysis.Builder().outputDataType(Type.INT64).build(); + } + + @Override + public State createState() { + return new CountState(); + } + + @Override + public void addInput(State state, Record input) { + if (!input.isNull(0)) { + ((CountState) state).count++; + } + } + + @Override + public void combineState(State state, State rhs) { + ((CountState) state).count += ((CountState) rhs).count; + } + + @Override + public void outputFinal(State state, ResultValue resultValue) { + resultValue.setLong(((CountState) state).count); + } + + @Override + public void outputFinal(State state, ResultValue resultValue, IoTDBLocal local) { + CountState countState = (CountState) state; + long extraCount = 0; + try (UDFResultSet rs = local.query("SELECT COUNT(*) FROM device_info")) { + if (rs.hasNext()) { + extraCount = rs.next().getLong(0); + } + } catch (UDFException e) { + throw new IllegalStateException(e); + } + resultValue.setLong(countState.count + extraCount); + } +} diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/MutatingQueryProbeFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/MutatingQueryProbeFunction.java new file mode 100644 index 0000000000000..09c1784800e73 --- /dev/null +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/MutatingQueryProbeFunction.java @@ -0,0 +1,54 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.iotdb.db.query.udf.example.relational.iotdblocal; + +import org.apache.iotdb.udf.api.IoTDBLocal; +import org.apache.iotdb.udf.api.customizer.analysis.ScalarFunctionAnalysis; +import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; +import org.apache.iotdb.udf.api.exception.UDFArgumentNotValidException; +import org.apache.iotdb.udf.api.exception.UDFException; +import org.apache.iotdb.udf.api.relational.ScalarFunction; +import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.iotdb.udf.api.type.Type; + +import org.apache.tsfile.common.conf.TSFileConfig; +import org.apache.tsfile.utils.Binary; + +/** Base scalar UDF that probes a mutating SQL statement via {@link IoTDBLocal#query(String)}. */ +abstract class MutatingQueryProbeFunction implements ScalarFunction { + + protected abstract String mutatingSql(); + + @Override + public ScalarFunctionAnalysis analyze(FunctionArguments arguments) + throws UDFArgumentNotValidException { + return new ScalarFunctionAnalysis.Builder().outputDataType(Type.STRING).build(); + } + + @Override + public void beforeStart(FunctionArguments arguments, IoTDBLocal local) throws UDFException { + local.query(mutatingSql()); + } + + @Override + public Object evaluate(Record input) { + return new Binary("unexpected", TSFileConfig.STRING_CHARSET); + } +} diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java index d2477a670a404..9a953ddc44795 100644 --- a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java +++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java @@ -37,6 +37,7 @@ import static org.apache.iotdb.db.it.utils.TestUtils.tableAssertTestFail; import static org.apache.iotdb.db.it.utils.TestUtils.tableResultSetEqualTest; import static org.junit.Assert.fail; +import static org.junit.Assume.assumeTrue; /** * Integration tests for {@link org.apache.iotdb.udf.api.IoTDBLocal} in table-model UDF, covering @@ -63,10 +64,12 @@ public class IoTDBLocalIT { "CREATE TABLE device_limits (device_id STRING TAG, max_temp DOUBLE FIELD)", "CREATE TABLE secret_table (device_id STRING TAG, secret STRING FIELD)", "CREATE TABLE vehicle (device_id STRING TAG, s1 INT32 FIELD, s2 INT64 FIELD)", + "CREATE TABLE probe_table (device_id STRING TAG, value DOUBLE FIELD)", "INSERT INTO device_info(time, device_id, device_name) VALUES (1, 'd1', '一号车间温度传感器'), (1, 'd2', '二号车间温度传感器')", "INSERT INTO device_limits(time, device_id, max_temp) VALUES (1, 'd1', 30.0), (1, 'd2', 35.0)", "INSERT INTO readings(time, device_id, temperature) VALUES (1000, 'd1', 25.5), (1001, 'd2', 32.0), (1002, 'd3', 20.0)", "INSERT INTO secret_table(time, device_id, secret) VALUES (1, 'd1', 'top-secret')", + "INSERT INTO probe_table(time, device_id, value) VALUES (1, 'seed', 1.0)", "INSERT INTO vehicle(time, device_id, s1, s2) VALUES (1, 'd0', 1, 1)", "INSERT INTO vehicle(time, device_id, s1, s2) VALUES (2, 'd0', null, 2)", "INSERT INTO vehicle(time, device_id, s1, s2) VALUES (3, 'd0', 3, 3)", @@ -212,6 +215,151 @@ public void testDeviceSummaryWithoutManualClose() { DATABASE_NAME); } + @Test + public void testRejectMutatingStatementsViaIoTDBLocal() { + SQLFunctionUtils.createUDF("insert_probe", IOTDB_LOCAL_PKG + ".InsertProbeFunction"); + tableAssertTestFail( + "SELECT insert_probe(device_id) FROM readings WHERE device_id = 'd1'", + "305: Only query is supported for IoTDBLocal query interface", + DATABASE_NAME); + tableResultSetEqualTest( + "SELECT COUNT(*) AS cnt FROM probe_table", + new String[] {"cnt"}, + new String[] {"1,"}, + DATABASE_NAME); + + SQLFunctionUtils.createUDF("create_table_probe", IOTDB_LOCAL_PKG + ".CreateTableProbeFunction"); + tableAssertTestFail( + "SELECT create_table_probe(device_id) FROM readings WHERE device_id = 'd1'", + "305: Only query is supported for IoTDBLocal query interface", + DATABASE_NAME); + tableAssertTestFail( + "SELECT * FROM should_not_exist_local_probe", "does not exist", DATABASE_NAME); + + SQLFunctionUtils.createUDF("drop_table_probe", IOTDB_LOCAL_PKG + ".DropTableProbeFunction"); + tableAssertTestFail( + "SELECT drop_table_probe(device_id) FROM readings WHERE device_id = 'd1'", + "305: Only query is supported for IoTDBLocal query interface", + DATABASE_NAME); + tableResultSetEqualTest( + "SELECT device_id FROM device_info ORDER BY device_id", + new String[] {"device_id"}, + new String[] {"d1,", "d2,"}, + DATABASE_NAME); + } + + @Test + public void testLocalQueryUdafAtBeforeStart() { + SQLFunctionUtils.createUDF( + "local_query_udaf_before_start", + IOTDB_LOCAL_PKG + ".LocalQueryUdafAtBeforeStartAggregateFunction"); + tableResultSetEqualTest( + "SELECT local_query_udaf_before_start(temperature) AS total FROM readings", + new String[] {"total"}, + new String[] {"5,"}, + DATABASE_NAME); + } + + @Test + public void testLocalQueryUdafInAddInput() { + SQLFunctionUtils.createUDF( + "local_query_udaf_add_input", + IOTDB_LOCAL_PKG + ".LocalQueryUdafInAddInputAggregateFunction"); + tableResultSetEqualTest( + "SELECT local_query_udaf_add_input(temperature) AS total FROM readings", + new String[] {"total"}, + new String[] {"5,"}, + DATABASE_NAME); + } + + @Test + public void testLocalQueryUdafInCombineState() { + assumeTrue( + "combineState IoTDBLocal.query coverage requires cluster execution", + EnvFactory.getEnv().getDataNodeWrapperList().size() > 1); + SQLFunctionUtils.createUDF( + "local_query_udaf_combine_state", + IOTDB_LOCAL_PKG + ".LocalQueryUdafInCombineStateAggregateFunction"); + tableResultSetEqualTest( + "SELECT local_query_udaf_combine_state(temperature) AS total FROM readings", + new String[] {"total"}, + new String[] {"5,"}, + DATABASE_NAME); + } + + @Test + public void testLocalQueryUdafInOutputFinal() { + SQLFunctionUtils.createUDF( + "local_query_udaf_output_final", + IOTDB_LOCAL_PKG + ".LocalQueryUdafInOutputFinalAggregateFunction"); + tableResultSetEqualTest( + "SELECT local_query_udaf_output_final(temperature) AS total FROM readings", + new String[] {"total"}, + new String[] {"5,"}, + DATABASE_NAME); + } + + @Test + public void testLocalQueryUdafAtBeforeDestroy() { + SQLFunctionUtils.createUDF( + "local_query_udaf_before_destroy", + IOTDB_LOCAL_PKG + ".LocalQueryUdafAtBeforeDestroyAggregateFunction"); + tableResultSetEqualTest( + "SELECT local_query_udaf_before_destroy(temperature) AS total FROM readings", + new String[] {"total"}, + new String[] {"3,"}, + DATABASE_NAME); + } + + @Test + public void testLocalQueryLeafTableFunctionAtBeforeStart() { + SQLFunctionUtils.createUDF("device_id_list", IOTDB_LOCAL_PKG + ".DeviceIdListTableFunction"); + tableResultSetEqualTest( + "SELECT * FROM device_id_list('id:')", + new String[] {"device_id"}, + new String[] {"id:d1,", "id:d2,"}, + DATABASE_NAME); + } + + @Test + public void testLocalQueryLeafTableFunctionInProcess() { + SQLFunctionUtils.createUDF( + "device_id_list_in_process", IOTDB_LOCAL_PKG + ".DeviceIdListInProcessTableFunction"); + tableResultSetEqualTest( + "SELECT * FROM device_id_list_in_process('id:')", + new String[] {"device_id"}, + new String[] {"id:d1,", "id:d2,"}, + DATABASE_NAME); + } + + @Test + public void testLocalQueryDataTableFunctionAtBeforeStart() { + SQLFunctionUtils.createUDF( + "enrich_device_name_at_before_start", + IOTDB_LOCAL_PKG + ".DeviceNameEnrichBeforeStartTableFunction"); + tableResultSetEqualTest( + "SELECT device_name FROM enrich_device_name_at_before_start((SELECT device_id FROM readings ORDER BY time))", + new String[] {"device_name"}, + new String[] { + "一号车间温度传感器,", "二号车间温度传感器,", "未知设备,", + }, + DATABASE_NAME); + } + + @Test + public void testLocalQueryDataTableFunctionInProcess() { + SQLFunctionUtils.createUDF( + "enrich_device_name_in_process", + IOTDB_LOCAL_PKG + ".DeviceNameEnrichInProcessTableFunction"); + tableResultSetEqualTest( + "SELECT device_name FROM enrich_device_name_in_process((SELECT device_id FROM readings ORDER BY time))", + new String[] {"device_name"}, + new String[] { + "一号车间温度传感器,", "二号车间温度传感器,", "未知设备,", + }, + DATABASE_NAME); + } + // ── permission inheritance ────────────────────────────────────────────────── @Test diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java index 7bedcbbb03055..37623c34247aa 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java @@ -104,7 +104,7 @@ public long getEstimatedSize() { @Override public TableAccumulator copy() { return new UserDefinedAggregateFunctionAccumulator( - analysis, aggregateFunction, functionArguments, inputDataTypes, ioTDBLocal, true); + analysis, aggregateFunction, functionArguments, inputDataTypes, ioTDBLocal, init); } @Override @@ -139,6 +139,7 @@ public void addIntermediate(Column argument) { @Override public void evaluateIntermediate(ColumnBuilder columnBuilder) { + initIfNeeded(); checkArgument( columnBuilder instanceof BinaryColumnBuilder, "intermediate input and output of UDAF should be BinaryColumn"); diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/session/SessionManager.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/session/SessionManager.java index 04ddf7f4b9f62..21dbffb606ebd 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/session/SessionManager.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/session/SessionManager.java @@ -370,20 +370,28 @@ public IClientSession getCurrSession() { } /** - * Swap the ThreadLocal session and return the previous one. Used by UDF internal queries to - * temporarily install an internal session without removing the previous session from the session - * map. + * Temporarily install a session into the current thread. Used by UDF internal queries that need + * ThreadLocal session visibility without {@link #registerSession(IClientSession)}. */ - public IClientSession exchangeCurrSession(IClientSession session) { - IClientSession previous = currSession.get(); - if (session != null) { - currSession.set(session); - sessions.putIfAbsent(session, placeHolder); + public void setCurrSession(IClientSession session) { + currSession.set(session); + sessions.putIfAbsent(session, placeHolder); + } + + /** + * Restore the previous ThreadLocal session and remove the temporarily installed session from + * {@code sessions}. + */ + public void restoreSession(IClientSession previous, IClientSession installedSession) { + if (installedSession != null) { + sessions.remove(installedSession); + } + if (previous != null) { + currSession.set(previous); } else { currSession.remove(); currSessionIdleTime.remove(); } - return previous; } /** get current session and update session idle time. */ diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java index 402424d1f6914..1e89784aa0add 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java @@ -503,12 +503,39 @@ public ExecutionResult executeForTableModel( long timeOut, boolean userQuery, boolean debug) { + return executeForTableModel( + statement, + sqlParser, + clientSession, + queryId, + session, + sql, + metadata, + timeOut, + userQuery, + debug, + false); + } + + public ExecutionResult executeForTableModel( + org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.Statement statement, + SqlParser sqlParser, + IClientSession clientSession, + long queryId, + SessionInfo session, + String sql, + Metadata metadata, + long timeOut, + boolean userQuery, + boolean debug, + boolean readOnlyInternalQuery) { return execution( queryId, session, sql, userQuery, debug, + readOnlyInternalQuery, ((queryContext, startTime) -> createQueryExecutionForTableModel( statement, diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java index 328542d05c143..3391cf242b916 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java @@ -72,7 +72,7 @@ public static InternalQueryResult executeInternalQuery( long statementId = -1; long queryId = -1; try { - SESSION_MANAGER.exchangeCurrSession(internalSession); + SESSION_MANAGER.setCurrSession(internalSession); statementId = SESSION_MANAGER.requestStatementId(internalSession); queryId = SESSION_MANAGER.requestQueryId(internalSession, statementId); @@ -91,7 +91,8 @@ public static InternalQueryResult executeInternalQuery( METADATA, timeoutMs, false, - false); + false, + true); if (result.status.code != TSStatusCode.SUCCESS_STATUS.getStatusCode()) { throw new IoTDBException(result.status.message, result.status.code); @@ -109,7 +110,7 @@ public static InternalQueryResult executeInternalQuery( ClientRPCServiceImpl.clearUp(internalSession, statementId, queryId, () -> sql, e); throw new IoTDBException(e.getMessage(), TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode()); } finally { - SESSION_MANAGER.exchangeCurrSession(previousSession); + SESSION_MANAGER.restoreSession(previousSession, internalSession); } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/UDFResultSetImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/UDFResultSetImpl.java index bc3f163eee864..74cc1a3859f77 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/UDFResultSetImpl.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/UDFResultSetImpl.java @@ -23,10 +23,12 @@ import org.apache.iotdb.commons.exception.IoTDBException; import org.apache.iotdb.commons.schema.column.ColumnHeader; import org.apache.iotdb.commons.udf.utils.UDFDataTypeTransformer; +import org.apache.iotdb.db.queryengine.common.header.DatasetHeader; import org.apache.iotdb.udf.api.UDFResultSet; import org.apache.iotdb.udf.api.exception.UDFException; import org.apache.iotdb.udf.api.relational.access.Record; +import org.apache.tsfile.block.column.Column; import org.apache.tsfile.read.common.block.TsBlock; import org.apache.tsfile.read.common.type.Type; @@ -45,6 +47,9 @@ public class UDFResultSetImpl implements UDFResultSet { private final InternalQueryResult queryResult; private final List columnTypes; + /** null when output columns align with TsBlock value columns without index mapping */ + private final int[] columnIndexes; + private Iterator rowIterator; private boolean closed; @@ -53,7 +58,9 @@ public UDFResultSetImpl( this.openResultSets = openResultSets; this.index = index; this.queryResult = queryResult; - this.columnTypes = buildColumnTypes(queryResult.getDatasetHeader().getColumnHeaders()); + DatasetHeader datasetHeader = queryResult.getDatasetHeader(); + this.columnTypes = buildColumnTypes(datasetHeader.getColumnHeaders()); + this.columnIndexes = buildColumnIndexes(datasetHeader.getColumnIndex2TsBlockColumnIndexList()); } @Override @@ -74,11 +81,12 @@ public boolean hasNext() throws UDFException { return false; } TsBlock currentBlock = batch.get(); + if (currentBlock.getPositionCount() == 0) { + continue; + } rowIterator = new RecordIterator( - Arrays.asList(currentBlock.getValueColumns()), - columnTypes, - currentBlock.getPositionCount()); + extractColumns(currentBlock), columnTypes, currentBlock.getPositionCount()); } return true; } @@ -118,4 +126,29 @@ private static List buildColumnTypes(List columnHeaders) { .map(UDFDataTypeTransformer::transformUDFDataTypeToReadType) .collect(Collectors.toList()); } + + private static int[] buildColumnIndexes(List columnIndex2TsBlockColumnIndexList) { + if (columnIndex2TsBlockColumnIndexList == null + || columnIndex2TsBlockColumnIndexList.isEmpty()) { + return null; + } + int size = columnIndex2TsBlockColumnIndexList.size(); + int[] indexes = new int[size]; + for (int i = 0; i < size; i++) { + indexes[i] = columnIndex2TsBlockColumnIndexList.get(i); + } + return indexes; + } + + private List extractColumns(TsBlock tsBlock) { + Column[] valueColumns = tsBlock.getValueColumns(); + if (valueColumns.length == 0) { + return Arrays.asList(valueColumns); + } + + if (columnIndexes != null) { + return Arrays.asList(tsBlock.getColumns(columnIndexes)); + } + return Arrays.asList(valueColumns); + } } From cd02c6dc1748bb39e7575c7e5be74d9e4b4ca0f4 Mon Sep 17 00:00:00 2001 From: Weihao Li <18110526956@163.com> Date: Fri, 26 Jun 2026 18:02:52 +0800 Subject: [PATCH 10/11] fix some Signed-off-by: Weihao Li <18110526956@163.com> --- ...eryUdafAtBeforeStartAggregateFunction.java | 1 - .../relational/it/db/it/udf/IoTDBLocalIT.java | 39 ++++++++++++++++--- ...erDefinedAggregateFunctionAccumulator.java | 20 ++++++---- ...roupedUserDefinedAggregateAccumulator.java | 11 +++--- .../UserDefineScalarFunctionTransformer.java | 10 +++-- .../udf/InternalQueryExecutor.java | 7 ++++ 6 files changed, 66 insertions(+), 22 deletions(-) diff --git a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafAtBeforeStartAggregateFunction.java b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafAtBeforeStartAggregateFunction.java index ef0196727f69d..71dd52485145c 100644 --- a/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafAtBeforeStartAggregateFunction.java +++ b/integration-test/src/main/java/org/apache/iotdb/db/query/udf/example/relational/iotdblocal/LocalQueryUdafAtBeforeStartAggregateFunction.java @@ -45,7 +45,6 @@ private static class CountState implements State { @Override public void reset() { count = 0; - extraCount = 0; } @Override diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java index 9a953ddc44795..4e918e8bbef99 100644 --- a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java +++ b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/udf/IoTDBLocalIT.java @@ -220,7 +220,7 @@ public void testRejectMutatingStatementsViaIoTDBLocal() { SQLFunctionUtils.createUDF("insert_probe", IOTDB_LOCAL_PKG + ".InsertProbeFunction"); tableAssertTestFail( "SELECT insert_probe(device_id) FROM readings WHERE device_id = 'd1'", - "305: Only query is supported for IoTDBLocal query interface", + "701: Only query is supported for IoTDBLocal query interface", DATABASE_NAME); tableResultSetEqualTest( "SELECT COUNT(*) AS cnt FROM probe_table", @@ -231,7 +231,7 @@ public void testRejectMutatingStatementsViaIoTDBLocal() { SQLFunctionUtils.createUDF("create_table_probe", IOTDB_LOCAL_PKG + ".CreateTableProbeFunction"); tableAssertTestFail( "SELECT create_table_probe(device_id) FROM readings WHERE device_id = 'd1'", - "305: Only query is supported for IoTDBLocal query interface", + "701: Only query is supported for IoTDBLocal query interface", DATABASE_NAME); tableAssertTestFail( "SELECT * FROM should_not_exist_local_probe", "does not exist", DATABASE_NAME); @@ -239,7 +239,7 @@ public void testRejectMutatingStatementsViaIoTDBLocal() { SQLFunctionUtils.createUDF("drop_table_probe", IOTDB_LOCAL_PKG + ".DropTableProbeFunction"); tableAssertTestFail( "SELECT drop_table_probe(device_id) FROM readings WHERE device_id = 'd1'", - "305: Only query is supported for IoTDBLocal query interface", + "701: Only query is supported for IoTDBLocal query interface", DATABASE_NAME); tableResultSetEqualTest( "SELECT device_id FROM device_info ORDER BY device_id", @@ -260,6 +260,35 @@ public void testLocalQueryUdafAtBeforeStart() { DATABASE_NAME); } + @Test + public void testLocalQueryGroupedUdafAtBeforeStart() { + SQLFunctionUtils.createUDF( + "local_query_grouped_udaf_before_start", + IOTDB_LOCAL_PKG + ".LocalQueryUdafAtBeforeStartAggregateFunction"); + // GROUP BY device_id, temperature disables agg pushdown and exercises + // GroupedUserDefinedAggregateAccumulator (hash aggregation path). + tableResultSetEqualTest( + "SELECT device_id, local_query_grouped_udaf_before_start(temperature) AS total " + + "FROM readings GROUP BY device_id, temperature ORDER BY device_id", + new String[] {"device_id", "total"}, + new String[] {"d1,3,", "d2,3,", "d3,3,"}, + DATABASE_NAME); + } + + @Test + public void testLocalQueryGroupedUdafAtBeforeStartViaAggPushdown() { + SQLFunctionUtils.createUDF( + "local_query_grouped_udaf_agg_pushdown", + IOTDB_LOCAL_PKG + ".LocalQueryUdafAtBeforeStartAggregateFunction"); + // GROUP BY tag only: aggregation is pushed into AggTableScan, one device per group. + tableResultSetEqualTest( + "SELECT device_id, local_query_grouped_udaf_agg_pushdown(temperature) AS total " + + "FROM readings GROUP BY device_id ORDER BY device_id", + new String[] {"device_id", "total"}, + new String[] {"d1,3,", "d2,3,", "d3,3,"}, + DATABASE_NAME); + } + @Test public void testLocalQueryUdafInAddInput() { SQLFunctionUtils.createUDF( @@ -338,7 +367,7 @@ public void testLocalQueryDataTableFunctionAtBeforeStart() { "enrich_device_name_at_before_start", IOTDB_LOCAL_PKG + ".DeviceNameEnrichBeforeStartTableFunction"); tableResultSetEqualTest( - "SELECT device_name FROM enrich_device_name_at_before_start((SELECT device_id FROM readings ORDER BY time))", + "SELECT device_name FROM enrich_device_name_at_before_start((SELECT device_id FROM readings ORDER BY time)) order by device_name", new String[] {"device_name"}, new String[] { "一号车间温度传感器,", "二号车间温度传感器,", "未知设备,", @@ -352,7 +381,7 @@ public void testLocalQueryDataTableFunctionInProcess() { "enrich_device_name_in_process", IOTDB_LOCAL_PKG + ".DeviceNameEnrichInProcessTableFunction"); tableResultSetEqualTest( - "SELECT device_name FROM enrich_device_name_in_process((SELECT device_id FROM readings ORDER BY time))", + "SELECT device_name FROM enrich_device_name_in_process((SELECT device_id FROM readings ORDER BY time)) order by device_name", new String[] {"device_name"}, new String[] { "一号车间温度传感器,", "二号车间温度传感器,", "未知设备,", diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java index 37623c34247aa..13c0b92305f12 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/UserDefinedAggregateFunctionAccumulator.java @@ -20,6 +20,7 @@ package org.apache.iotdb.calc.execution.operator.source.relational.aggregation; import org.apache.iotdb.calc.i18n.CalcMessages; +import org.apache.iotdb.commons.exception.IoTDBRuntimeException; import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.State; import org.apache.iotdb.udf.api.customizer.analysis.AggregateFunctionAnalysis; @@ -42,6 +43,7 @@ import java.util.List; import static com.google.common.base.Preconditions.checkArgument; +import static org.apache.iotdb.rpc.TSStatusCode.EXECUTE_UDF_ERROR; public class UserDefinedAggregateFunctionAccumulator implements TableAccumulator { @@ -51,7 +53,7 @@ public class UserDefinedAggregateFunctionAccumulator implements TableAccumulator private final AggregateFunction aggregateFunction; private final FunctionArguments functionArguments; private final List inputDataTypes; - private final State state; + private State state; private final IoTDBLocal ioTDBLocal; private boolean init; @@ -76,23 +78,22 @@ private UserDefinedAggregateFunctionAccumulator( this.aggregateFunction = aggregateFunction; this.functionArguments = functionArguments; this.inputDataTypes = inputDataTypes; - this.state = aggregateFunction.createState(); this.ioTDBLocal = ioTDBLocal; this.init = init; + this.state = init ? aggregateFunction.createState() : null; } private void initIfNeeded() { if (init) { return; } - init = true; try { aggregateFunction.beforeStart(functionArguments, ioTDBLocal); + init = true; + // create State after beforeStart + state = aggregateFunction.createState(); } catch (UDFException e) { - throw new RuntimeException( - "Error occurs when starting user-defined aggregate function " - + aggregateFunction.getClass().getName(), - e); + throw new IoTDBRuntimeException(e, EXECUTE_UDF_ERROR.getStatusCode()); } } @@ -168,6 +169,9 @@ public void addStatistics(Statistics[] statistics) { @Override public void reset() { + if (!init) { + return; + } state.reset(); } @@ -192,6 +196,8 @@ public boolean removable() { @Override public void close() { + // ensure beforeStart was called + initIfNeeded(); aggregateFunction.beforeDestroy(ioTDBLocal); ioTDBLocal.close(); state.destroyState(); diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/grouped/GroupedUserDefinedAggregateAccumulator.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/grouped/GroupedUserDefinedAggregateAccumulator.java index a530ce4f7de57..44df7fab1d7e7 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/grouped/GroupedUserDefinedAggregateAccumulator.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/execution/operator/source/relational/aggregation/grouped/GroupedUserDefinedAggregateAccumulator.java @@ -24,6 +24,7 @@ import org.apache.iotdb.calc.execution.operator.source.relational.aggregation.RecordIterator; import org.apache.iotdb.calc.execution.operator.source.relational.aggregation.grouped.array.ObjectBigArray; import org.apache.iotdb.calc.i18n.CalcMessages; +import org.apache.iotdb.commons.exception.IoTDBRuntimeException; import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.State; import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; @@ -44,6 +45,7 @@ import java.util.List; import static com.google.common.base.Preconditions.checkArgument; +import static org.apache.iotdb.rpc.TSStatusCode.EXECUTE_UDF_ERROR; public class GroupedUserDefinedAggregateAccumulator implements GroupedAccumulator { @@ -73,14 +75,11 @@ private void initIfNeeded() { if (init) { return; } - init = true; try { aggregateFunction.beforeStart(functionArguments, ioTDBLocal); + init = true; } catch (UDFException e) { - throw new RuntimeException( - "Error occurs when starting user-defined aggregate function " - + aggregateFunction.getClass().getName(), - e); + throw new IoTDBRuntimeException(e, EXECUTE_UDF_ERROR.getStatusCode()); } } @@ -152,6 +151,7 @@ public void addIntermediate(int[] groupIds, Column argument) { @Override public void evaluateIntermediate(int groupId, ColumnBuilder columnBuilder) { + initIfNeeded(); checkArgument( columnBuilder instanceof BinaryColumnBuilder, "intermediate input and output of UDAF should be BinaryColumn"); @@ -182,6 +182,7 @@ public void reset() { @Override public void close() { + initIfNeeded(); aggregateFunction.beforeDestroy(ioTDBLocal); ioTDBLocal.close(); stateArray.forEach( diff --git a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java index 0a50cc1949256..3288dcbad0768 100644 --- a/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java +++ b/iotdb-core/calc-commons/src/main/java/org/apache/iotdb/calc/transformation/dag/column/udf/UserDefineScalarFunctionTransformer.java @@ -24,6 +24,7 @@ import org.apache.iotdb.calc.plan.planner.TableOperatorGenerator.IoTDBLocalFactory; import org.apache.iotdb.calc.transformation.dag.column.ColumnTransformer; import org.apache.iotdb.calc.transformation.dag.column.multi.MultiColumnTransformer; +import org.apache.iotdb.commons.exception.IoTDBRuntimeException; import org.apache.iotdb.udf.api.IoTDBLocal; import org.apache.iotdb.udf.api.customizer.parameter.FunctionArguments; import org.apache.iotdb.udf.api.exception.UDFException; @@ -37,6 +38,8 @@ import java.util.List; import java.util.stream.Collectors; +import static org.apache.iotdb.rpc.TSStatusCode.EXECUTE_UDF_ERROR; + public class UserDefineScalarFunctionTransformer extends MultiColumnTransformer { private final ScalarFunction scalarFunction; @@ -73,10 +76,7 @@ private void initIfNeeded() { try { scalarFunction.beforeStart(parameters, ioTDBLocal); } catch (UDFException e) { - throw new RuntimeException( - "Error occurs when starting user-defined scalar function " - + scalarFunction.getClass().getName(), - e); + throw new IoTDBRuntimeException(e, EXECUTE_UDF_ERROR.getStatusCode()); } } @@ -132,6 +132,8 @@ protected void doTransform( @Override public void close() { + // ensure beforeStart was called + initIfNeeded(); super.close(); scalarFunction.beforeDestroy(ioTDBLocal); ioTDBLocal.close(); diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java index 3391cf242b916..5abcf05d22b3f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/udf/InternalQueryExecutor.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.udf; import org.apache.iotdb.commons.exception.IoTDBException; +import org.apache.iotdb.commons.exception.IoTDBRuntimeException; import org.apache.iotdb.commons.exception.SemanticException; import org.apache.iotdb.commons.queryengine.common.SessionInfo; import org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.Statement; @@ -106,6 +107,12 @@ public static InternalQueryResult executeInternalQuery( } return new InternalQueryResult(queryExecution, internalSession, statementId, queryId, sql); + } catch (IoTDBException e) { + ClientRPCServiceImpl.clearUp(internalSession, statementId, queryId, () -> sql, e); + throw e; + } catch (IoTDBRuntimeException e) { + ClientRPCServiceImpl.clearUp(internalSession, statementId, queryId, () -> sql, e); + throw e; } catch (Exception e) { ClientRPCServiceImpl.clearUp(internalSession, statementId, queryId, () -> sql, e); throw new IoTDBException(e.getMessage(), TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode()); From d8ac6a46f2aa4d2d667a7d2b43e217d94a169ed7 Mon Sep 17 00:00:00 2001 From: Weihao Li <18110526956@163.com> Date: Fri, 26 Jun 2026 18:16:09 +0800 Subject: [PATCH 11/11] fix some Signed-off-by: Weihao Li <18110526956@163.com> --- .../fragment/FragmentInstanceManager.java | 3 ++- .../execution/schedule/task/DriverTask.java | 21 +++++++++++-------- .../SimpleFragmentParallelPlanner.java | 2 -- .../plan/planner/plan/FragmentInstance.java | 13 ------------ .../TableModelQueryFragmentPlanner.java | 2 -- 5 files changed, 14 insertions(+), 27 deletions(-) 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 18042372b8057..a9473982237e6 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 @@ -38,6 +38,7 @@ import org.apache.iotdb.db.queryengine.execution.exchange.sink.ISink; import org.apache.iotdb.db.queryengine.execution.schedule.DriverScheduler; import org.apache.iotdb.db.queryengine.execution.schedule.IDriverScheduler; +import org.apache.iotdb.db.queryengine.execution.schedule.task.DriverTask; import org.apache.iotdb.db.queryengine.metric.QueryRelatedResourceMetricSet; import org.apache.iotdb.db.queryengine.plan.Coordinator; import org.apache.iotdb.db.queryengine.plan.planner.LocalExecutionPlanner; @@ -167,7 +168,7 @@ public FragmentInstanceInfo execDataQueryFragmentInstance( dataRegion, instance.getGlobalTimePredicate(), dataNodeQueryContextMap, - instance.getOuterQueryDeadlineMs(), + DriverTask.computeDeadlineTimeInMs(instance.getTimeOut()), instance.isDebug(), instance.isVerbose()); }); diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/schedule/task/DriverTask.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/schedule/task/DriverTask.java index c85d00e17e16e..285c67dd7babc 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/schedule/task/DriverTask.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/execution/schedule/task/DriverTask.java @@ -79,15 +79,7 @@ public DriverTask( this.driver = driver; this.setStatus(status); - long currentTime = System.currentTimeMillis(); - long ddlTmp = currentTime + timeoutMs; - // avoid infinite timeout check loop, schema fetch query for write operation may pass a very - // large timeout here which may causing currentTime + timeoutMs be negative - if (ddlTmp < currentTime) { - this.ddl = Long.MAX_VALUE; - } else { - this.ddl = ddlTmp; - } + this.ddl = computeDeadlineTimeInMs(timeoutMs); this.lock = new ReentrantLock(); this.driverTaskHandle = driverTaskHandle; @@ -96,6 +88,17 @@ public DriverTask( this.isHighestPriority = isHighestPriority; } + public static long computeDeadlineTimeInMs(long timeoutMs) { + long currentTime = System.currentTimeMillis(); + long deadlineMs = currentTime + timeoutMs; + // avoid infinite timeout check loop, schema fetch query for write operation may pass a very + // large timeout here which may causing currentTime + timeoutMs be negative + if (deadlineMs < currentTime) { + return Long.MAX_VALUE; + } + return deadlineMs; + } + @Override public DriverTaskId getDriverTaskId() { return driver.getDriverTaskId(); diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/SimpleFragmentParallelPlanner.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/SimpleFragmentParallelPlanner.java index a39aaff6fb4c7..4e34d36147168 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/SimpleFragmentParallelPlanner.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/distribution/SimpleFragmentParallelPlanner.java @@ -148,8 +148,6 @@ private void produceFragmentInstance(PlanFragment fragment) { queryContext.isDebug(), fragment.isRoot(), queryContext.isVerbose()); - fragmentInstance.setOuterQueryDeadlineMs( - queryContext.getStartTime() + queryContext.getTimeOut()); selectExecutorAndHost( fragment, diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/FragmentInstance.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/FragmentInstance.java index ff03aa006d7fa..463aeb5413196 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/FragmentInstance.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/planner/plan/FragmentInstance.java @@ -83,9 +83,6 @@ public class FragmentInstance implements IConsensusRequest { private final boolean debug; private final boolean verbose; - // Outer query deadline (startTime + timeout) for IoTDBLocal on remote DataNodes. - private long outerQueryDeadlineMs = -1L; - // We can add some more params for a specific FragmentInstance // So that we can make different FragmentInstance owns different data range. @@ -272,7 +269,6 @@ public static FragmentInstance deserializeFrom(ByteBuffer buffer) { hasHostDataNode ? ThriftCommonsSerDeUtils.deserializeTDataNodeLocation(buffer) : null; fragmentInstance.isExplainAnalyze = ReadWriteIOUtils.readBool(buffer); fragmentInstance.setHighestPriority(ReadWriteIOUtils.readBool(buffer)); - fragmentInstance.setOuterQueryDeadlineMs(ReadWriteIOUtils.readLong(buffer)); return fragmentInstance; } @@ -300,7 +296,6 @@ public ByteBuffer serializeToByteBuffer() { } ReadWriteIOUtils.write(isExplainAnalyze, outputStream); ReadWriteIOUtils.write(isHighestPriority, outputStream); - ReadWriteIOUtils.write(outerQueryDeadlineMs, outputStream); return ByteBuffer.wrap(publicBAOS.getBuf(), 0, publicBAOS.size()); } catch (IOException e) { LOGGER.error( @@ -347,14 +342,6 @@ public SessionInfo getSessionInfo() { return sessionInfo; } - public long getOuterQueryDeadlineMs() { - return outerQueryDeadlineMs; - } - - public void setOuterQueryDeadlineMs(long outerQueryDeadlineMs) { - this.outerQueryDeadlineMs = outerQueryDeadlineMs; - } - public boolean isExplainAnalyze() { return isExplainAnalyze; } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelQueryFragmentPlanner.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelQueryFragmentPlanner.java index 586bb6d61dcf4..f2942536cb552 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelQueryFragmentPlanner.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/distribute/TableModelQueryFragmentPlanner.java @@ -186,8 +186,6 @@ private void produceFragmentInstance( queryContext.isDebug(), fragment.isRoot(), queryContext.isVerbose()); - fragmentInstance.setOuterQueryDeadlineMs( - queryContext.getStartTime() + queryContext.getTimeOut()); selectExecutorAndHost( fragment,