diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/session/PrepareTask.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/session/PrepareTask.java index bf61e702c72d0..62c59d5bf785e 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/session/PrepareTask.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/execution/config/session/PrepareTask.java @@ -26,7 +26,6 @@ import org.apache.iotdb.db.queryengine.plan.execution.config.ConfigTaskResult; import org.apache.iotdb.db.queryengine.plan.execution.config.IConfigTask; import org.apache.iotdb.db.queryengine.plan.execution.config.executor.IConfigTaskExecutor; -import org.apache.iotdb.db.queryengine.plan.relational.sql.AstMemoryEstimator; import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Statement; import org.apache.iotdb.rpc.TSStatusCode; @@ -69,7 +68,7 @@ public ListenableFuture execute(IConfigTaskExecutor configTask } // Estimate memory size of the AST - long memorySizeInBytes = AstMemoryEstimator.estimateMemorySize(sql); + long memorySizeInBytes = sql == null ? 0L : sql.ramBytesUsed(); // Allocate memory from CoordinatorMemoryManager // This memory is shared across all sessions using a single MemoryBlock diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/AstMemoryEstimator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/AstMemoryEstimator.java deleted file mode 100644 index d45f6546e0f6a..0000000000000 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/AstMemoryEstimator.java +++ /dev/null @@ -1,67 +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.plan.relational.sql; - -import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.DefaultTraversalVisitor; -import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Node; -import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Statement; - -import org.apache.tsfile.utils.RamUsageEstimator; - -/** - * Utility class for estimating memory usage of AST nodes. Uses RamUsageEstimator to calculate - * approximate memory size. - */ -public final class AstMemoryEstimator { - private AstMemoryEstimator() {} - - /** - * Estimate the memory size of a Statement AST node in bytes. - * - * @param statement the statement AST to estimate - * @return estimated memory size in bytes - */ - public static long estimateMemorySize(Statement statement) { - if (statement == null) { - return 0L; - } - MemoryEstimatingVisitor visitor = new MemoryEstimatingVisitor(); - visitor.process(statement, null); - return visitor.getTotalMemorySize(); - } - - private static class MemoryEstimatingVisitor extends DefaultTraversalVisitor { - private long totalMemorySize = 0L; - - public long getTotalMemorySize() { - return totalMemorySize; - } - - @Override - protected Void visitNode(Node node, Void context) { - // Estimate shallow size of the node object - long nodeSize = RamUsageEstimator.shallowSizeOfInstance(node.getClass()); - totalMemorySize += nodeSize; - - // Traverse children (DefaultTraversalVisitor handles this) - return super.visitNode(node, context); - } - } -} diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AbstractTraverseDevice.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AbstractTraverseDevice.java index c61945b1b9136..fdd478e111b59 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AbstractTraverseDevice.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AbstractTraverseDevice.java @@ -187,6 +187,10 @@ public void setAttributeColumns(final List attributeColumns) { this.attributeColumns = attributeColumns; } + public List getAttributeColumns() { + return attributeColumns; + } + public List getColumnHeaderList() { return columnHeaderList; } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AddColumn.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AddColumn.java index 41d9f28c4fd8b..6f271c042ffc9 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AddColumn.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AddColumn.java @@ -19,6 +19,8 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.Collections; import java.util.List; import java.util.Objects; @@ -27,6 +29,8 @@ import static java.util.Objects.requireNonNull; public class AddColumn extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(AddColumn.class); private final QualifiedName tableName; private final ColumnDefinition column; @@ -112,4 +116,13 @@ public String toString() { .add("view", view) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += tableName == null ? 0L : tableName.ramBytesUsed(); + size += column == null ? 0L : column.ramBytesUsed(); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AliasedRelation.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AliasedRelation.java index 95d94a7e17f8c..075381f0243e4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AliasedRelation.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AliasedRelation.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ import static java.util.Objects.requireNonNull; public class AliasedRelation extends Relation { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(AliasedRelation.class); + private final Relation relation; private final Identifier alias; private final List columnNames; @@ -109,4 +113,16 @@ public boolean shallowEquals(Node other) { return alias.equals(otherRelation.alias) && Objects.equals(columnNames, otherRelation.columnNames); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(relation); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(alias); + if (columnNames != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(columnNames); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AllColumns.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AllColumns.java index 99c83caf648fa..fd32acce6c7db 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AllColumns.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AllColumns.java @@ -21,6 +21,7 @@ import com.google.common.base.Joiner; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -32,6 +33,9 @@ public class AllColumns extends SelectItem { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(AllColumns.class); + private final List aliases; @Nullable private final Expression target; @@ -127,4 +131,13 @@ public boolean shallowEquals(Node other) { return aliases.equals(((AllColumns) other).aliases); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(aliases); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(target); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AllRows.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AllRows.java index e5ae50c33c80c..f8cc6454c5b2a 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AllRows.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AllRows.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; @@ -28,6 +29,7 @@ import static java.util.Objects.requireNonNull; public final class AllRows extends Expression { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(AllRows.class); public AllRows() { super(null); @@ -64,4 +66,11 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AlterDB.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AlterDB.java index 4a5e6a8d12297..e177a8fed1ecc 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AlterDB.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AlterDB.java @@ -21,12 +21,16 @@ import org.apache.iotdb.db.queryengine.plan.statement.metadata.DatabaseSchemaStatement; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.List; import static com.google.common.base.MoreObjects.toStringHelper; import static java.util.Objects.requireNonNull; public class AlterDB extends DatabaseStatement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(AlterDB.class); + public AlterDB( final NodeLocation location, final boolean exists, @@ -53,4 +57,13 @@ public String toString() { .add("properties", properties) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(dbName); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(properties); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AlterPipe.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AlterPipe.java index a40fab917a517..1b10de12b4230 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AlterPipe.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AlterPipe.java @@ -19,6 +19,9 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + +import java.util.ArrayList; import java.util.Map; import java.util.Objects; @@ -26,6 +29,8 @@ import static java.util.Objects.requireNonNull; public class AlterPipe extends PipeStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(AlterPipe.class); private final String pipeName; private final boolean ifExistsCondition; @@ -140,4 +145,30 @@ public String toString() { .add("isReplaceAllConnectorAttributes", isReplaceAllConnectorAttributes) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(pipeName); + size += + AstMemoryEstimationHelper.getShallowSizeOfList( + new ArrayList<>(extractorAttributes.entrySet())); + size += + AstMemoryEstimationHelper.getEstimatedSizeOfStringList( + new ArrayList<>(extractorAttributes.values())); + size += + AstMemoryEstimationHelper.getShallowSizeOfList( + new ArrayList<>(processorAttributes.entrySet())); + size += + AstMemoryEstimationHelper.getEstimatedSizeOfStringList( + new ArrayList<>(processorAttributes.values())); + size += + AstMemoryEstimationHelper.getShallowSizeOfList( + new ArrayList<>(connectorAttributes.entrySet())); + size += + AstMemoryEstimationHelper.getEstimatedSizeOfStringList( + new ArrayList<>(connectorAttributes.values())); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AnchorPattern.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AnchorPattern.java index e8ced62839578..9063ed7e0ee68 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AnchorPattern.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AnchorPattern.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -33,6 +34,9 @@ public enum Type { PARTITION_END } + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(AnchorPattern.class); + private final Type type; public AnchorPattern(NodeLocation location, Type type) { @@ -80,4 +84,11 @@ public String toString() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ArithmeticBinaryExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ArithmeticBinaryExpression.java index da15baae013be..69fb130b705a6 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ArithmeticBinaryExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ArithmeticBinaryExpression.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import javax.annotation.Nonnull; @@ -34,6 +35,9 @@ public class ArithmeticBinaryExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ArithmeticBinaryExpression.class); + public enum Operator { ADD("+"), SUBTRACT("-"), @@ -139,4 +143,12 @@ public boolean shallowEquals(Node other) { return operator == ((ArithmeticBinaryExpression) other).operator; } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(left) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(right); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ArithmeticUnaryExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ArithmeticUnaryExpression.java index 5385914e2cd68..4b3e0f9a77fa9 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ArithmeticUnaryExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ArithmeticUnaryExpression.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import javax.annotation.Nonnull; @@ -34,6 +35,9 @@ public class ArithmeticUnaryExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ArithmeticUnaryExpression.class); + public enum Sign { PLUS, MINUS @@ -141,4 +145,11 @@ public boolean shallowEquals(Node other) { return sign == ((ArithmeticUnaryExpression) other).sign; } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(value); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AsofJoinOn.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AsofJoinOn.java index c19606c754893..b4cb43e684766 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AsofJoinOn.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AsofJoinOn.java @@ -23,6 +23,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.TimeDuration; import java.util.List; @@ -33,6 +34,8 @@ import static org.apache.iotdb.db.queryengine.plan.relational.sql.ast.ComparisonExpression.Operator.LESS_THAN_OR_EQUAL; public class AsofJoinOn extends JoinOn { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(AsofJoinOn.class); // record main expression of ASOF join // .e.g 'ASOF (tolerance 1) JOIN ON t1.device = t2.device and t1.time > t2.time' => @@ -160,4 +163,16 @@ public String toString() { public List getNodes() { return ImmutableList.of(expression, asofExpression); } + + @Override + public long ramBytesUsed() { + long size = super.ramBytesUsed(); + // Subtract JoinOn's INSTANCE_SIZE and add AsofJoinOn's INSTANCE_SIZE + size -= RamUsageEstimator.shallowSizeOfInstance(JoinOn.class); + size += INSTANCE_SIZE; + if (asofExpression != null) { + size += asofExpression.ramBytesUsed(); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AstMemoryEstimationHelper.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AstMemoryEstimationHelper.java new file mode 100644 index 0000000000000..397c141f8e65a --- /dev/null +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AstMemoryEstimationHelper.java @@ -0,0 +1,109 @@ +/* + * 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.plan.relational.sql.ast; + +import org.apache.tsfile.utils.Accountable; +import org.apache.tsfile.utils.RamUsageEstimator; + +import javax.annotation.Nullable; + +import java.util.List; +import java.util.Optional; + +/** + * Helper class for estimating memory usage of AST nodes. This class provides utility methods that + * can be used by Node subclasses to calculate their memory footprint. + */ +public final class AstMemoryEstimationHelper { + + public static final long OPTIONAL_INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(Optional.class); + + public static final long NODE_LOCATION_INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(NodeLocation.class); + + private AstMemoryEstimationHelper() { + // hide the constructor + } + + public static long getEstimatedSizeOfAccountableObject(@Nullable final Accountable accountable) { + return accountable == null ? 0 : accountable.ramBytesUsed(); + } + + public static long getEstimatedSizeOfString(@Nullable final String str) { + return str == null ? 0L : RamUsageEstimator.sizeOf(str); + } + + public static long getEstimatedSizeOfByteArray(@Nullable final byte[] bytes) { + return bytes == null ? 0L : RamUsageEstimator.sizeOf(bytes); + } + + public static long getShallowSizeOfList(@Nullable final List list) { + return list == null ? 0L : RamUsageEstimator.shallowSizeOf(list); + } + + public static long getEstimatedSizeOfNodeLocation(@Nullable final NodeLocation location) { + if (location != null) { + return OPTIONAL_INSTANCE_SIZE + NODE_LOCATION_INSTANCE_SIZE; + } + return 0L; + } + + public static long getEstimatedSizeOfNodeList(@Nullable final List children) { + if (children == null || children.isEmpty()) { + return 0L; + } + long size = RamUsageEstimator.shallowSizeOf(children); + for (Node child : children) { + if (child != null) { + size += child.ramBytesUsed(); + } + } + return size; + } + + public static long getEstimatedSizeOfStringList(@Nullable final List strings) { + if (strings == null || strings.isEmpty()) { + return 0L; + } + long size = RamUsageEstimator.shallowSizeOf(strings); + for (String str : strings) { + if (str != null) { + size += RamUsageEstimator.sizeOf(str); + } + } + return size; + } + + public static long getEstimatedSizeOfIntegerList(@Nullable final List integers) { + if (integers == null || integers.isEmpty()) { + return 0L; + } + long size = RamUsageEstimator.shallowSizeOf(integers); + // Integer objects are typically cached by JVM for small values, but we estimate + // the overhead for Integer objects (16 bytes each) + for (Integer integer : integers) { + if (integer != null) { + size += RamUsageEstimator.shallowSizeOfInstance(Integer.class); + } + } + return size; + } +} diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/BetweenPredicate.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/BetweenPredicate.java index 5a0f00af45689..a421e65630d6f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/BetweenPredicate.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/BetweenPredicate.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; @@ -33,6 +34,9 @@ public final class BetweenPredicate extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(BetweenPredicate.class); + private final Expression value; private final Expression min; private final Expression max; @@ -125,4 +129,13 @@ public BetweenPredicate(ByteBuffer byteBuffer) { this.min = Expression.deserialize(byteBuffer); this.max = Expression.deserialize(byteBuffer); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(value) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(min) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(max); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/BinaryLiteral.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/BinaryLiteral.java index e11cd7a1182c5..766df8347ad9f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/BinaryLiteral.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/BinaryLiteral.java @@ -24,6 +24,7 @@ import com.google.common.base.CharMatcher; import com.google.common.io.BaseEncoding; import org.apache.tsfile.utils.Binary; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -35,6 +36,9 @@ import static java.util.Objects.requireNonNull; public class BinaryLiteral extends Literal { + + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(BinaryLiteral.class); // the grammar could possibly include whitespace in the value it passes to us private static final CharMatcher WHITESPACE_MATCHER = CharMatcher.whitespace(); private static final CharMatcher HEX_DIGIT_MATCHER = @@ -142,4 +146,11 @@ public BinaryLiteral(ByteBuffer byteBuffer) { public Object getTsValue() { return new Binary(value); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfByteArray(value); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/BooleanLiteral.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/BooleanLiteral.java index 75ad655743ca1..42f62559a7286 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/BooleanLiteral.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/BooleanLiteral.java @@ -19,6 +19,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -32,6 +33,9 @@ public class BooleanLiteral extends Literal { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(BooleanLiteral.class); + public static final BooleanLiteral TRUE_LITERAL = new BooleanLiteral("true"); public static final BooleanLiteral FALSE_LITERAL = new BooleanLiteral("false"); @@ -109,4 +113,10 @@ public BooleanLiteral(ByteBuffer byteBuffer) { public Object getTsValue() { return value; } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Cast.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Cast.java index cc8183f8be6d7..1b240db6d865b 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Cast.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Cast.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import javax.annotation.Nonnull; @@ -33,6 +34,9 @@ import static java.util.Objects.requireNonNull; public final class Cast extends Expression { + + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Cast.class); + private final Expression expression; private final DataType type; private final boolean safe; @@ -156,4 +160,12 @@ public Cast(ByteBuffer byteBuffer) { this.safe = ReadWriteIOUtils.readBool(byteBuffer); this.typeOnly = ReadWriteIOUtils.readBool(byteBuffer); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(expression) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(type); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ClearCache.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ClearCache.java index 6f9183da1fec4..ce06f18ea57b7 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ClearCache.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ClearCache.java @@ -22,14 +22,18 @@ import org.apache.iotdb.commons.schema.cache.CacheClearOptions; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; import java.util.Set; import static com.google.common.base.MoreObjects.toStringHelper; +import static java.util.stream.Collectors.toList; public class ClearCache extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ClearCache.class); private final boolean onCluster; private final Set options; @@ -80,4 +84,16 @@ public boolean equals(final Object obj) { public String toString() { return toStringHelper(this).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (options != null) { + size += + AstMemoryEstimationHelper.getShallowSizeOfList( + options.stream().map(Enum::ordinal).collect(toList())); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CoalesceExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CoalesceExpression.java index d16ab376698df..05fccd1c01cda 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CoalesceExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CoalesceExpression.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import javax.annotation.Nonnull; @@ -36,6 +37,9 @@ public final class CoalesceExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CoalesceExpression.class); + private final List operands; public CoalesceExpression(Expression first, Expression second, Expression... additional) { @@ -117,4 +121,11 @@ public CoalesceExpression(ByteBuffer byteBuffer) { operands.add(deserialize(byteBuffer)); } } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(operands); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ColumnDefinition.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ColumnDefinition.java index 3d78b9e51cd99..396ed121cc1bc 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ColumnDefinition.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ColumnDefinition.java @@ -22,6 +22,7 @@ import org.apache.iotdb.commons.schema.table.column.TsTableColumnCategory; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -35,6 +36,9 @@ public class ColumnDefinition extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ColumnDefinition.class); + private final Identifier name; private final DataType type; private final TsTableColumnCategory columnCategory; @@ -130,4 +134,21 @@ public String toString() { .add("comment", comment) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(name); + if (type != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(type); + } + if (charsetName != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(charsetName); + } + if (comment != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(comment); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Columns.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Columns.java index 6860940aa2862..60ca264450097 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Columns.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Columns.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; @@ -31,6 +32,8 @@ import static java.util.Objects.requireNonNull; public final class Columns extends Expression { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Columns.class); + private final String pattern; public Columns(@Nonnull NodeLocation location, String pattern) { @@ -93,4 +96,14 @@ public TableExpressionType getExpressionType() { public void serialize(DataOutputStream stream) throws IOException { throw new UnsupportedOperationException("Columns should be expanded in Analyze stage"); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (pattern != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(pattern); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ComparisonExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ComparisonExpression.java index a70badc932a93..c968ac7c2854a 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ComparisonExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ComparisonExpression.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import javax.annotation.Nonnull; @@ -34,6 +35,9 @@ public class ComparisonExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ComparisonExpression.class); + public enum Operator { EQUAL("="), NOT_EQUAL("<>"), @@ -192,4 +196,12 @@ public ComparisonExpression(ByteBuffer byteBuffer) { left = deserialize(byteBuffer); right = deserialize(byteBuffer); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(left) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(right); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CountDevice.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CountDevice.java index 7127ec55d6bc7..90055bb27635e 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CountDevice.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CountDevice.java @@ -22,14 +22,18 @@ import org.apache.iotdb.commons.schema.column.ColumnHeader; import org.apache.iotdb.db.queryengine.common.header.DatasetHeader; import org.apache.iotdb.db.queryengine.plan.relational.analyzer.Analysis; +import org.apache.iotdb.db.schemaengine.schemaregion.read.resp.info.impl.ShowDevicesResult; import org.apache.tsfile.enums.TSDataType; import org.apache.tsfile.read.common.block.TsBlock; import org.apache.tsfile.read.common.block.TsBlockBuilder; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.Collections; public class CountDevice extends AbstractQueryDeviceWithCache { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CountDevice.class); public static final String COUNT_DEVICE_HEADER_STRING = "count(devices)"; @@ -65,4 +69,29 @@ public R accept(final AstVisitor visitor, final C context) { public String toString() { return "CountDevice" + toStringContent(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(table); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(where); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(database); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(tableName); + size += AstMemoryEstimationHelper.getShallowSizeOfList(tagDeterminedFilterList); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(tagFuzzyPredicate); + size += AstMemoryEstimationHelper.getShallowSizeOfList(columnHeaderList); + if (getAttributeColumns() != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfStringList(getAttributeColumns()); + } + if (results != null) { + size += AstMemoryEstimationHelper.getShallowSizeOfList(results); + for (ShowDevicesResult result : results) { + if (result != null) { + size += result.ramBytesUsed(); + } + } + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CountStatement.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CountStatement.java index 146b2467aa471..16627ec07112f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CountStatement.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CountStatement.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,8 @@ import static java.util.Objects.requireNonNull; public class CountStatement extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CountStatement.class); private final String tableName; private final Optional where; @@ -83,4 +86,16 @@ public String toString() { .omitNullValues() .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(tableName); + if (where.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += where.get() == null ? 0L : where.get().ramBytesUsed(); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateDB.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateDB.java index 9f493b16d4812..8d61da299b6e5 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateDB.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateDB.java @@ -21,6 +21,8 @@ import org.apache.iotdb.db.queryengine.plan.statement.metadata.DatabaseSchemaStatement; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.List; import static com.google.common.base.MoreObjects.toStringHelper; @@ -28,6 +30,8 @@ public class CreateDB extends DatabaseStatement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(CreateDB.class); + public CreateDB( final NodeLocation location, final boolean exists, @@ -54,4 +58,15 @@ public String toString() { .add("properties", properties) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (dbName != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(dbName); + } + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(properties); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateFunction.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateFunction.java index 3ff15880c1dc5..1b1189a94bde8 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateFunction.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateFunction.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -31,6 +32,8 @@ import static java.util.Objects.requireNonNull; public class CreateFunction extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CreateFunction.class); private final String udfName; private final String className; @@ -101,4 +104,14 @@ public String toString() { .add("uriString", uriString) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(udfName); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(className); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(uriString); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateIndex.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateIndex.java index 04d071e898888..4c6c8414f06e5 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateIndex.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateIndex.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,8 @@ import static java.util.Objects.requireNonNull; public class CreateIndex extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CreateIndex.class); private final QualifiedName tableName; @@ -107,4 +110,17 @@ public String toString() { .add("columnList", columnList) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += tableName == null ? 0L : tableName.ramBytesUsed(); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(indexName); + size += AstMemoryEstimationHelper.getShallowSizeOfList(columnList); + for (Identifier column : columnList) { + size += column == null ? 0L : column.ramBytesUsed(); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateModel.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateModel.java index f2132aab4404f..c19ea6d739c47 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateModel.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateModel.java @@ -19,10 +19,14 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.List; import java.util.Objects; public class CreateModel extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CreateModel.class); private final String modelId; private final String uri; @@ -69,4 +73,13 @@ public int hashCode() { public String toString() { return "CreateModel{" + "modelId='" + modelId + '\'' + ", uri='" + uri + '\'' + '}'; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(modelId); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(uri); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateOrUpdateDevice.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateOrUpdateDevice.java index 766112e5cef12..e96249272ccf4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateOrUpdateDevice.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateOrUpdateDevice.java @@ -19,6 +19,8 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import javax.annotation.Nonnull; import java.util.Arrays; @@ -31,6 +33,8 @@ import static org.apache.iotdb.db.storageengine.dataregion.memtable.DeviceIDFactory.truncateTailingNull; public class CreateOrUpdateDevice extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CreateOrUpdateDevice.class); private final String database; @@ -137,4 +141,27 @@ public String toString() { + attributeValueList + '}'; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(database); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(table); + size += AstMemoryEstimationHelper.getShallowSizeOfList(deviceIdList); + for (Object[] deviceId : deviceIdList) { + if (deviceId != null) { + size += + AstMemoryEstimationHelper.getEstimatedSizeOfByteArray(deviceId.toString().getBytes()); + } + } + size += AstMemoryEstimationHelper.getEstimatedSizeOfStringList(attributeNameList); + size += AstMemoryEstimationHelper.getShallowSizeOfList(attributeValueList); + for (Object[] values : attributeValueList) { + if (values != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfByteArray(values.toString().getBytes()); + } + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreatePipe.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreatePipe.java index 3f53c5e4504da..69897d96cf526 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreatePipe.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreatePipe.java @@ -19,6 +19,9 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + +import java.util.ArrayList; import java.util.Map; import java.util.Objects; @@ -26,6 +29,8 @@ import static java.util.Objects.requireNonNull; public class CreatePipe extends PipeStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CreatePipe.class); private final String pipeName; private final boolean ifNotExistsCondition; @@ -110,4 +115,30 @@ public String toString() { .add("connectorAttributes", connectorAttributes) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(pipeName); + size += + AstMemoryEstimationHelper.getShallowSizeOfList( + new ArrayList<>(extractorAttributes.entrySet())); + size += + AstMemoryEstimationHelper.getEstimatedSizeOfStringList( + new ArrayList<>(extractorAttributes.values())); + size += + AstMemoryEstimationHelper.getShallowSizeOfList( + new ArrayList<>(processorAttributes.entrySet())); + size += + AstMemoryEstimationHelper.getEstimatedSizeOfStringList( + new ArrayList<>(processorAttributes.values())); + size += + AstMemoryEstimationHelper.getShallowSizeOfList( + new ArrayList<>(connectorAttributes.entrySet())); + size += + AstMemoryEstimationHelper.getEstimatedSizeOfStringList( + new ArrayList<>(connectorAttributes.values())); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreatePipePlugin.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreatePipePlugin.java index 676e360b3ab15..23a32915d326f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreatePipePlugin.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreatePipePlugin.java @@ -19,12 +19,16 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.Objects; import static com.google.common.base.MoreObjects.toStringHelper; import static java.util.Objects.requireNonNull; public class CreatePipePlugin extends PipeStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CreatePipePlugin.class); private final String pluginName; private final boolean ifNotExistsCondition; @@ -92,4 +96,14 @@ public String toString() { .add("uriString", uriString) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(pluginName); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(className); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(uriString); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateTable.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateTable.java index f18b740ef029d..b6a16f9790d06 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateTable.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateTable.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -31,6 +32,9 @@ import static java.util.Objects.requireNonNull; public class CreateTable extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CreateTable.class); + private final QualifiedName name; private final List elements; @@ -123,4 +127,20 @@ public String toString() { .add("properties", properties) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += name == null ? 0L : name.ramBytesUsed(); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(elements); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(properties); + if (charsetName != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(charsetName); + } + if (comment != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(comment); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateTopic.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateTopic.java index 5780170029138..41cfbf115b2ab 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateTopic.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateTopic.java @@ -19,6 +19,9 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + +import java.util.ArrayList; import java.util.Map; import java.util.Objects; @@ -26,6 +29,8 @@ import static java.util.Objects.requireNonNull; public class CreateTopic extends SubscriptionStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CreateTopic.class); private final String topicName; private final boolean ifNotExistsCondition; @@ -84,4 +89,17 @@ public String toString() { .add("topicAttributes", topicAttributes) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(topicName); + size += + AstMemoryEstimationHelper.getShallowSizeOfList(new ArrayList<>(topicAttributes.entrySet())); + size += + AstMemoryEstimationHelper.getEstimatedSizeOfStringList( + new ArrayList<>(topicAttributes.values())); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateTraining.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateTraining.java index a62e4305d4087..fd1dcbd8d8f97 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateTraining.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateTraining.java @@ -19,11 +19,16 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + +import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.Objects; public class CreateTraining extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CreateTraining.class); private final String modelId; private final String targetSql; @@ -104,4 +109,21 @@ public String toString() { + '\'' + '}'; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(modelId); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(targetSql); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(existingModelId); + if (parameters != null) { + size += + AstMemoryEstimationHelper.getShallowSizeOfList(new ArrayList<>(parameters.entrySet())); + size += + AstMemoryEstimationHelper.getEstimatedSizeOfStringList( + new ArrayList<>(parameters.values())); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateView.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateView.java index d0ed0681a6101..146dea1ce11c9 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateView.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CreateView.java @@ -20,6 +20,9 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import org.apache.iotdb.commons.path.PartialPath; +import org.apache.iotdb.db.queryengine.execution.MemoryEstimationHelper; + +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -29,6 +32,9 @@ import static com.google.common.base.MoreObjects.toStringHelper; public class CreateView extends CreateTable { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CreateView.class); + private final PartialPath prefixPath; private final boolean replace; private final boolean restrict; @@ -92,4 +98,16 @@ public String toString() { .add("restrict", restrict) .toString(); } + + @Override + public long ramBytesUsed() { + long size = super.ramBytesUsed(); + // super.ramBytesUsed() includes CreateTable's INSTANCE_SIZE, but we need CreateView's + size -= RamUsageEstimator.shallowSizeOfInstance(CreateTable.class); + size += INSTANCE_SIZE; + if (prefixPath != null) { + size += MemoryEstimationHelper.getEstimatedSizeOfPartialPath(prefixPath); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CurrentDatabase.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CurrentDatabase.java index 7a8dddf44aa4f..e22baecca7f7c 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CurrentDatabase.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CurrentDatabase.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; @@ -29,6 +30,9 @@ public class CurrentDatabase extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CurrentDatabase.class); + public CurrentDatabase() { super(null); } @@ -72,4 +76,11 @@ public boolean shallowEquals(final Node other) { public TableExpressionType getExpressionType() { return TableExpressionType.CURRENT_DATABASE; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CurrentTime.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CurrentTime.java index b166cf2d06702..2bf19ec17aa10 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CurrentTime.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CurrentTime.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -30,6 +31,9 @@ import static java.util.Objects.requireNonNull; public class CurrentTime extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CurrentTime.class); + private final Function function; @Nullable private final Integer precision; @@ -110,4 +114,14 @@ public boolean shallowEquals(Node other) { CurrentTime otherNode = (CurrentTime) other; return (function == otherNode.function) && Objects.equals(precision, otherNode.precision); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (precision != null) { + size += RamUsageEstimator.shallowSizeOfInstance(Integer.class); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CurrentUser.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CurrentUser.java index 760d86a01143b..4849649d19e33 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CurrentUser.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/CurrentUser.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; @@ -29,6 +30,9 @@ public class CurrentUser extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(CurrentUser.class); + public CurrentUser() { super(null); } @@ -72,4 +76,11 @@ public boolean shallowEquals(final Node other) { public TableExpressionType getExpressionType() { return TableExpressionType.CURRENT_USER; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Deallocate.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Deallocate.java index fd579bb64b5b6..2a977ae25df67 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Deallocate.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Deallocate.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -30,6 +31,9 @@ /** DEALLOCATE PREPARE statement AST node. Example: DEALLOCATE PREPARE stmt1 */ public final class Deallocate extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(Deallocate.class); + private final Identifier statementName; public Deallocate(Identifier statementName) { @@ -76,4 +80,12 @@ public int hashCode() { public String toString() { return toStringHelper(this).add("statementName", statementName).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(statementName); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DecimalLiteral.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DecimalLiteral.java index f7f99e0a1a0a0..714c882914057 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DecimalLiteral.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DecimalLiteral.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import org.apache.tsfile.utils.Binary; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -32,6 +33,9 @@ public class DecimalLiteral extends Literal { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DecimalLiteral.class); + private final String value; public DecimalLiteral(String value) { @@ -100,4 +104,11 @@ public DecimalLiteral(ByteBuffer byteBuffer) { public Object getTsValue() { return new Binary(value.getBytes(StandardCharsets.UTF_8)); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfString(value); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Delete.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Delete.java index 788b5ddffcd07..391a4137d1295 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Delete.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Delete.java @@ -23,6 +23,7 @@ import org.apache.iotdb.db.storageengine.dataregion.modification.TableDeletionEntry; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -36,6 +37,8 @@ public class Delete extends Statement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Delete.class); + private Table table; @Nullable private Expression where; @@ -129,4 +132,15 @@ public Collection getReplicaSets() { public void setReplicaSets(final Collection replicaSets) { this.replicaSets = replicaSets; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(table); + if (where != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(where); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DeleteDevice.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DeleteDevice.java index 9b1487b0a48a6..21c03f37c1c0d 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DeleteDevice.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DeleteDevice.java @@ -47,6 +47,7 @@ import com.google.common.collect.ImmutableMap; import org.apache.tsfile.read.common.type.TypeFactory; import org.apache.tsfile.utils.Binary; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -65,6 +66,8 @@ import static com.google.common.base.MoreObjects.toStringHelper; public class DeleteDevice extends AbstractTraverseDevice { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DeleteDevice.class); // Used for data deletion private List modEntries; @@ -249,4 +252,27 @@ public R accept(final AstVisitor visitor, final C context) { public String toString() { return toStringHelper(this) + " - " + super.toStringContent(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(table); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(where); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(database); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(tableName); + size += AstMemoryEstimationHelper.getShallowSizeOfList(tagDeterminedFilterList); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(tagFuzzyPredicate); + size += AstMemoryEstimationHelper.getShallowSizeOfList(columnHeaderList); + if (getAttributeColumns() != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfStringList(getAttributeColumns()); + } + if (modEntries != null) { + size += AstMemoryEstimationHelper.getShallowSizeOfList(modEntries); + for (TableDeletionEntry entry : modEntries) { + size += entry == null ? 0L : entry.ramBytesUsed(); + } + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DereferenceExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DereferenceExpression.java index e22e57eb18941..149cac131fdda 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DereferenceExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DereferenceExpression.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -31,6 +32,9 @@ public class DereferenceExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DereferenceExpression.class); + private final Expression base; @Nullable private final Identifier field; @@ -148,4 +152,17 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (base != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(base); + } + if (field != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(field); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DescribeTable.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DescribeTable.java index 0dfbe4429d257..d06415f6c36cb 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DescribeTable.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DescribeTable.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; @@ -30,6 +31,8 @@ import static java.util.Objects.requireNonNull; public class DescribeTable extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DescribeTable.class); private final QualifiedName table; private final boolean isDetails; @@ -98,4 +101,15 @@ public String toString() { .add("isShowCreateView", isShowCreateView) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += table == null ? 0L : table.ramBytesUsed(); + if (isShowCreateView != null) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DoubleLiteral.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DoubleLiteral.java index cf2fa70832655..44c732e66f0e6 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DoubleLiteral.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DoubleLiteral.java @@ -19,6 +19,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -29,6 +30,9 @@ public class DoubleLiteral extends Literal { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DoubleLiteral.class); + private final double value; public DoubleLiteral(String value) { @@ -108,4 +112,10 @@ public DoubleLiteral(ByteBuffer byteBuffer) { public Object getTsValue() { return value; } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropColumn.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropColumn.java index 095e7511f36bf..cc95814ee0e30 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropColumn.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropColumn.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,8 @@ import static java.util.Objects.requireNonNull; public class DropColumn extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DropColumn.class); private final QualifiedName table; private final Identifier field; @@ -112,4 +115,13 @@ public String toString() { .add("view", view) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += table == null ? 0L : table.ramBytesUsed(); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(field); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropDB.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropDB.java index d64f7a458afe8..8f1ea9b191654 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropDB.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropDB.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,8 @@ public class DropDB extends Statement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(DropDB.class); + private final Identifier dbName; private final boolean exists; @@ -77,4 +80,12 @@ public int hashCode() { public String toString() { return toStringHelper(this).add("catalogName", dbName).add("exists", exists).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(dbName); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropFunction.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropFunction.java index 1439ea19798b6..f883fd829c974 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropFunction.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropFunction.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,8 @@ import static java.util.Objects.requireNonNull; public class DropFunction extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DropFunction.class); private final String udfName; @@ -71,4 +74,12 @@ public int hashCode() { public String toString() { return toStringHelper(this).add("udfName", udfName).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(udfName); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropIndex.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropIndex.java index 0b03e8551ca13..e19308d4259e7 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropIndex.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropIndex.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,8 @@ import static java.util.Objects.requireNonNull; public class DropIndex extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DropIndex.class); private final QualifiedName tableName; @@ -85,4 +88,13 @@ public int hashCode() { public String toString() { return toStringHelper(this).add("tableName", tableName).add("indexName", indexName).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += tableName == null ? 0L : tableName.ramBytesUsed(); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(indexName); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropModel.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropModel.java index 780b7c38f9a44..18611ca2422ab 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropModel.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropModel.java @@ -19,10 +19,14 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.List; import java.util.Objects; public class DropModel extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DropModel.class); private final String modelId; @@ -61,4 +65,12 @@ public int hashCode() { public String toString() { return "DropModel{" + "modelId='" + modelId + '\'' + '}'; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(modelId); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropPipe.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropPipe.java index 1b3837ba21470..c71780a1b1835 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropPipe.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropPipe.java @@ -19,12 +19,15 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.Objects; import static com.google.common.base.MoreObjects.toStringHelper; import static java.util.Objects.requireNonNull; public class DropPipe extends PipeStatement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(DropPipe.class); private final String pipeName; private final boolean ifExistsCondition; @@ -72,4 +75,12 @@ public String toString() { .add("ifExistsCondition", ifExistsCondition) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(pipeName); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropPipePlugin.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropPipePlugin.java index aaa7de52d2141..ddccb42bb6f88 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropPipePlugin.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropPipePlugin.java @@ -19,12 +19,16 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.Objects; import static com.google.common.base.MoreObjects.toStringHelper; import static java.util.Objects.requireNonNull; public class DropPipePlugin extends PipeStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DropPipePlugin.class); private final String pluginName; private final boolean ifExistsCondition; @@ -72,4 +76,12 @@ public String toString() { .add("ifExistsCondition", ifExistsCondition) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(pluginName); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropSubscription.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropSubscription.java index 24aba397013b6..e1b20681c9bd4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropSubscription.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropSubscription.java @@ -19,12 +19,16 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.Objects; import static com.google.common.base.MoreObjects.toStringHelper; import static java.util.Objects.requireNonNull; public class DropSubscription extends SubscriptionStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DropSubscription.class); private final String subscriptionId; private final boolean ifExistsCondition; @@ -72,4 +76,12 @@ public String toString() { .add("ifExistsCondition", ifExistsCondition) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(subscriptionId); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropTable.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropTable.java index 901a2565e8453..4b7e8f31f7db1 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropTable.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropTable.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,9 @@ public class DropTable extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DropTable.class); + private final QualifiedName tableName; private final boolean exists; private final boolean isView; @@ -87,4 +91,12 @@ public boolean equals(final Object obj) { public String toString() { return toStringHelper(this).add("tableName", tableName).add("exists", exists).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += tableName == null ? 0L : tableName.ramBytesUsed(); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropTopic.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropTopic.java index 0ec50fde79aad..ee0386526242a 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropTopic.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/DropTopic.java @@ -19,12 +19,16 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.Objects; import static com.google.common.base.MoreObjects.toStringHelper; import static java.util.Objects.requireNonNull; public class DropTopic extends SubscriptionStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(DropTopic.class); private final String topicName; private final boolean ifExistsCondition; @@ -72,4 +76,12 @@ public String toString() { .add("ifExistsCondition", ifExistsCondition) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(topicName); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/EmptyPattern.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/EmptyPattern.java index 85a316d711838..20485df6cf595 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/EmptyPattern.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/EmptyPattern.java @@ -20,12 +20,16 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import static com.google.common.base.MoreObjects.toStringHelper; public class EmptyPattern extends RowPattern { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(EmptyPattern.class); + public EmptyPattern(NodeLocation location) { super(location); } @@ -65,4 +69,11 @@ public String toString() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Except.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Except.java index eacdab488caaf..1d300134651a2 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Except.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Except.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,8 @@ import static java.util.Objects.requireNonNull; public final class Except extends SetOperation { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Except.class); + private final Relation left; private final Relation right; @@ -104,4 +107,13 @@ public boolean shallowEquals(Node other) { return this.isDistinct() == ((Except) other).isDistinct(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(left); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(right); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExcludedPattern.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExcludedPattern.java index 9c69b3089f3cd..2f23a847c4525 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExcludedPattern.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExcludedPattern.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ import static java.util.Objects.requireNonNull; public class ExcludedPattern extends RowPattern { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ExcludedPattern.class); + private final RowPattern pattern; public ExcludedPattern(NodeLocation location, RowPattern pattern) { @@ -75,4 +79,12 @@ public String toString() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += pattern == null ? 0L : pattern.ramBytesUsed(); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Execute.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Execute.java index d7e219faf1b98..7ae15183dab95 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Execute.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Execute.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -30,6 +31,8 @@ /** EXECUTE statement AST node. Example: EXECUTE stmt1 USING 100, 'test' */ public final class Execute extends Statement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Execute.class); + private final Identifier statementName; private final List parameters; @@ -93,4 +96,13 @@ public String toString() { .add("parameters", parameters) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(statementName); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(parameters); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExecuteImmediate.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExecuteImmediate.java index 955ac54e4fb8b..342d018f63144 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExecuteImmediate.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExecuteImmediate.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -33,6 +34,9 @@ */ public final class ExecuteImmediate extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ExecuteImmediate.class); + private final StringLiteral sql; private final List parameters; @@ -96,4 +100,13 @@ public int hashCode() { public String toString() { return toStringHelper(this).add("sql", sql).add("parameters", parameters).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(sql); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(parameters); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExistsPredicate.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExistsPredicate.java index e75c5cf2f3018..c87b704761c21 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExistsPredicate.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExistsPredicate.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; @@ -29,6 +30,9 @@ import static java.util.Objects.requireNonNull; public class ExistsPredicate extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ExistsPredicate.class); + private final Expression subquery; public ExistsPredicate(Expression subquery) { @@ -77,4 +81,12 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(subquery); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Explain.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Explain.java index 9b486309d6b24..f3a50175269e8 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Explain.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Explain.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,8 @@ public class Explain extends Statement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Explain.class); + private final Statement statement; public Explain(Statement statement) { @@ -76,4 +79,12 @@ public boolean equals(Object obj) { public String toString() { return toStringHelper(this).add("statement", statement).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(statement); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExplainAnalyze.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExplainAnalyze.java index bf48c0b5efc82..cd3df879fc55e 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExplainAnalyze.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExplainAnalyze.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,9 @@ public class ExplainAnalyze extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ExplainAnalyze.class); + private final Statement statement; private final boolean verbose; @@ -83,4 +87,12 @@ public boolean equals(Object obj) { public String toString() { return toStringHelper(this).add("statement", statement).add("verbose", verbose).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(statement); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExtendRegion.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExtendRegion.java index 056be45d151d9..afa102c7554ff 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExtendRegion.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ExtendRegion.java @@ -20,11 +20,14 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; public class ExtendRegion extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ExtendRegion.class); private final List regionIds; private final int dataNodeId; @@ -74,4 +77,12 @@ public List getRegionIds() { public int getDataNodeId() { return dataNodeId; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getShallowSizeOfList(regionIds); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Extract.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Extract.java index e9e04073ad26c..3c85af1f4b695 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Extract.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Extract.java @@ -21,6 +21,7 @@ import com.google.common.collect.ImmutableList; import com.google.errorprone.annotations.Immutable; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -33,6 +34,9 @@ @Immutable public class Extract extends Expression { + + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Extract.class); + private final Expression expression; private final Field field; @@ -136,4 +140,11 @@ public boolean shallowEquals(Node other) { Extract otherExtract = (Extract) other; return field.equals(otherExtract.field); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(expression); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FetchDevice.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FetchDevice.java index 4700bbcf8c7c4..8cffa0ff76771 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FetchDevice.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FetchDevice.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import org.apache.tsfile.file.metadata.IDeviceID; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,8 @@ import static org.apache.iotdb.db.storageengine.dataregion.memtable.DeviceIDFactory.truncateTailingNull; public class FetchDevice extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(FetchDevice.class); private final String database; @@ -107,4 +110,26 @@ public String toString() { + deviceIdList + '}'; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(database); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(tableName); + size += AstMemoryEstimationHelper.getShallowSizeOfList(deviceIdList); + for (Object[] deviceId : deviceIdList) { + if (deviceId != null) { + size += + AstMemoryEstimationHelper.getEstimatedSizeOfByteArray(deviceId.toString().getBytes()); + } + } + if (partitionKeyList != null) { + size += AstMemoryEstimationHelper.getShallowSizeOfList(partitionKeyList); + for (IDeviceID deviceID : partitionKeyList) { + size += deviceID == null ? 0L : deviceID.ramBytesUsed(); + } + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FieldReference.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FieldReference.java index 0fcffe6bd1d24..26ce73eeb8ed4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FieldReference.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FieldReference.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; @@ -27,6 +28,9 @@ public class FieldReference extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(FieldReference.class); + private final int fieldIndex; public FieldReference(int fieldIndex) { @@ -77,4 +81,11 @@ public boolean shallowEquals(Node other) { return fieldIndex == ((FieldReference) other).fieldIndex; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Fill.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Fill.java index 36e92dabf3cf2..01920012f4f95 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Fill.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Fill.java @@ -23,6 +23,7 @@ import com.google.common.base.MoreObjects; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.TimeDuration; import java.util.List; @@ -33,6 +34,8 @@ import static java.util.Objects.requireNonNull; public class Fill extends Node { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Fill.class); + private final FillPolicy fillMethod; // used for constant fill @@ -165,4 +168,24 @@ public boolean shallowEquals(Node other) { && Objects.equals(timeColumnIndex, fill.timeColumnIndex) && Objects.equals(fillGroupingElements, fill.fillGroupingElements); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (fillValue != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(fillValue); + } + if (timeColumnIndex != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(timeColumnIndex); + } + if (fillGroupingElements != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(fillGroupingElements); + } + // TimeDuration is a simple object, estimate its size + if (timeBound != null) { + size += RamUsageEstimator.shallowSizeOfInstance(TimeDuration.class); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Flush.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Flush.java index a005a121c6a70..99d1d6180b391 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Flush.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Flush.java @@ -22,7 +22,10 @@ import org.apache.iotdb.db.queryengine.common.MPPQueryContext; import org.apache.iotdb.db.queryengine.plan.statement.Statement; +import org.apache.tsfile.utils.RamUsageEstimator; + public class Flush extends WrappedStatement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Flush.class); public Flush(final Statement innerTreeStatement, final MPPQueryContext context) { super(innerTreeStatement, context); diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FrameBound.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FrameBound.java index 04aa993e99d86..a0e4543e5c23f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FrameBound.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FrameBound.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -33,6 +34,9 @@ import static java.util.Objects.requireNonNull; public class FrameBound extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(FrameBound.class); + public enum Type { UNBOUNDED_PRECEDING, PRECEDING, @@ -136,4 +140,15 @@ public FrameBound(ByteBuffer byteBuffer) { this.value = Optional.empty(); } } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (value.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(value.get()); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FunctionCall.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FunctionCall.java index 0ef3e51adebad..456f524024c80 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FunctionCall.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/FunctionCall.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -33,6 +34,10 @@ import static java.util.Objects.requireNonNull; public class FunctionCall extends Expression { + + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(FunctionCall.class); + private final QualifiedName name; private final Optional window; private final boolean distinct; @@ -332,4 +337,27 @@ public FunctionCall(ByteBuffer byteBuffer) { this.processingMode = Optional.empty(); } } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += name == null ? 0L : name.ramBytesUsed(); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(arguments); + if (window.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + Window windowValue = window.get(); + if (windowValue instanceof Node) { + size += ((Node) windowValue).ramBytesUsed(); + } + } + if (processingMode.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += processingMode.get().ramBytesUsed(); + } + if (nullTreatment.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GenericDataType.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GenericDataType.java index 00560ad7cc38c..ebc5b7880cd3a 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GenericDataType.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GenericDataType.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; @@ -34,6 +35,9 @@ public final class GenericDataType extends DataType { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(GenericDataType.class); + private final Identifier name; private final List arguments; @@ -108,4 +112,12 @@ public GenericDataType(ByteBuffer byteBuffer) { // arguments are always empty now this.arguments = Collections.emptyList(); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(name) + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(arguments); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GenericLiteral.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GenericLiteral.java index 25e41093c8b51..2c1a0ed9dc3b3 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GenericLiteral.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GenericLiteral.java @@ -22,6 +22,7 @@ import org.apache.iotdb.db.queryengine.plan.relational.sql.parser.ParsingException; import org.apache.tsfile.utils.Binary; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -34,6 +35,9 @@ public class GenericLiteral extends Literal { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(GenericLiteral.class); + private final String type; private final String value; @@ -129,4 +133,12 @@ public GenericLiteral(ByteBuffer byteBuffer) { public Object getTsValue() { return new Binary(value.getBytes(StandardCharsets.UTF_8)); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfString(type) + + AstMemoryEstimationHelper.getEstimatedSizeOfString(value); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GroupBy.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GroupBy.java index 289e550d28de2..00d201648ca8f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GroupBy.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GroupBy.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,8 @@ public class GroupBy extends Node { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(GroupBy.class); + private final boolean isDistinct; private final List groupingElements; @@ -97,4 +100,12 @@ public boolean shallowEquals(Node other) { return isDistinct == ((GroupBy) other).isDistinct; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(groupingElements); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GroupingSets.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GroupingSets.java index ec4789ec3f089..23438a666ca5a 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GroupingSets.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/GroupingSets.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -31,6 +32,8 @@ import static java.util.Objects.requireNonNull; public class GroupingSets extends GroupingElement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(GroupingSets.class); public enum Type { EXPLICIT, @@ -111,4 +114,15 @@ public boolean shallowEquals(Node other) { GroupingSets that = (GroupingSets) other; return Objects.equals(sets, that.sets) && Objects.equals(type, that.type); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getShallowSizeOfList(sets); + for (List set : sets) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(set); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Identifier.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Identifier.java index b4cd90dc0a816..8d2e8ec80ac09 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Identifier.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Identifier.java @@ -22,6 +22,7 @@ import com.google.common.base.CharMatcher; import com.google.common.base.Strings; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -37,6 +38,9 @@ public class Identifier extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(Identifier.class); + private static final CharMatcher FIRST_CHAR_DISALLOWED_MATCHER = CharMatcher.inRange('0', '9').precomputed(); @@ -175,4 +179,11 @@ public Identifier(ByteBuffer byteBuffer) { this.value = ReadWriteIOUtils.readString(byteBuffer); this.delimited = ReadWriteIOUtils.readBool(byteBuffer); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfString(value); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/IfExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/IfExpression.java index a287244a07044..6b1be6558bf72 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/IfExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/IfExpression.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -31,6 +32,9 @@ /** IF(v1,v2[,v3]): CASE WHEN v1 THEN v2 [ELSE v3] END */ public class IfExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(IfExpression.class); + private final Expression condition; private final Expression trueValue; @Nullable private final Expression falseValue; @@ -102,4 +106,16 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(condition); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(trueValue); + if (falseValue != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(falseValue); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/InListExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/InListExpression.java index 29f62025b1aef..fb8f8752a14ba 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/InListExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/InListExpression.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -33,6 +34,10 @@ import static java.util.Objects.requireNonNull; public class InListExpression extends Expression { + + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(InListExpression.class); + private final List values; public InListExpression(List values) { @@ -107,4 +112,11 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(values); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/InPredicate.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/InPredicate.java index b04c222347e82..464e9af4d6f18 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/InPredicate.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/InPredicate.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.io.DataOutputStream; import java.io.IOException; @@ -31,6 +32,9 @@ public class InPredicate extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(InPredicate.class); + private final Expression value; private final Expression valueList; @@ -103,4 +107,12 @@ public InPredicate(ByteBuffer byteBuffer) { this.value = Expression.deserialize(byteBuffer); this.valueList = Expression.deserialize(byteBuffer); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(value) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(valueList); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Insert.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Insert.java index 3e18ceb3be5e0..4e028d0ec60d3 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Insert.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Insert.java @@ -24,6 +24,7 @@ import com.google.common.collect.ImmutableList; import org.apache.tsfile.read.common.type.LongType; import org.apache.tsfile.read.common.type.Type; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -39,6 +40,8 @@ public final class Insert extends Statement { public static final Type ROWS_TYPE = LongType.INT64; public static final TsTableColumnCategory ROWS_CATEGORY = TsTableColumnCategory.FIELD; + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Insert.class); + private final Table table; private final Query query; @@ -111,4 +114,16 @@ public String toString() { .add("query", query) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(table); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(query); + if (columns != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(columns); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Intersect.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Intersect.java index c1739e0a0f521..a64bcbdaec5df 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Intersect.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Intersect.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ import static java.util.Objects.requireNonNull; public final class Intersect extends SetOperation { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(Intersect.class); + private final List relations; public Intersect(List relations, boolean distinct) { @@ -88,4 +92,12 @@ public boolean shallowEquals(Node other) { return this.isDistinct() == ((Intersect) other).isDistinct(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(relations); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/IsNotNullPredicate.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/IsNotNullPredicate.java index 3aecaf4576ad8..4db717ce69217 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/IsNotNullPredicate.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/IsNotNullPredicate.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.io.DataOutputStream; import java.io.IOException; @@ -31,6 +32,9 @@ public class IsNotNullPredicate extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(IsNotNullPredicate.class); + private final Expression value; public IsNotNullPredicate(Expression value) { @@ -94,4 +98,11 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(value); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/IsNullPredicate.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/IsNullPredicate.java index 3afe47d8ea90b..0d297ebac8ec8 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/IsNullPredicate.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/IsNullPredicate.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.io.DataOutputStream; import java.io.IOException; @@ -31,6 +32,9 @@ public class IsNullPredicate extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(IsNullPredicate.class); + private final Expression value; public IsNullPredicate(Expression value) { @@ -94,4 +98,11 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(value); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Join.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Join.java index bc936951ec34b..7d2043c78969f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Join.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Join.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -33,6 +34,8 @@ public class Join extends Relation { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Join.class); + public enum Type { CROSS, INNER, @@ -162,4 +165,14 @@ public boolean shallowEquals(Node other) { return type.equals(((Join) other).type); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(left); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(right); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(criteria); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/JoinCriteria.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/JoinCriteria.java index 3195b983e7132..da0cdbf312d42 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/JoinCriteria.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/JoinCriteria.java @@ -19,9 +19,11 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.Accountable; + import java.util.List; -public abstract class JoinCriteria { +public abstract class JoinCriteria implements Accountable { // Force subclasses to have a proper equals and hashcode implementation @Override diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/JoinOn.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/JoinOn.java index 5c86dfaa1aeab..a87ef182dd728 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/JoinOn.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/JoinOn.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -29,6 +30,7 @@ import static com.google.common.base.MoreObjects.toStringHelper; public class JoinOn extends JoinCriteria { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(JoinOn.class); // this can be null when it is AsofJoinOn @Nullable protected final Expression expression; @@ -68,4 +70,13 @@ public String toString() { public List getNodes() { return ImmutableList.of(expression); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + if (expression != null) { + size += expression.ramBytesUsed(); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/JoinUsing.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/JoinUsing.java index a2c5540044520..a9a22e4eb2631 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/JoinUsing.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/JoinUsing.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,9 @@ import static java.util.Objects.requireNonNull; public class JoinUsing extends JoinCriteria { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(JoinUsing.class); + private final List columns; public JoinUsing(List columns) { @@ -67,4 +71,11 @@ public String toString() { public List getNodes() { return ImmutableList.of(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(columns); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/KillQuery.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/KillQuery.java index cbeebafebddbe..90e7745de19a3 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/KillQuery.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/KillQuery.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -27,6 +28,9 @@ import java.util.Objects; public class KillQuery extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(KillQuery.class); + private final String queryId; public KillQuery(String queryId, @Nullable NodeLocation location) { @@ -78,4 +82,14 @@ public boolean shallowEquals(Node other) { public String toString() { return "KILL QUERY " + queryId; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (queryId != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(queryId); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LikePredicate.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LikePredicate.java index 0fcad0fa8b514..6f0490bfc44d4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LikePredicate.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LikePredicate.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import javax.annotation.Nullable; @@ -35,6 +36,9 @@ public class LikePredicate extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(LikePredicate.class); + private final Expression value; private final Expression pattern; @Nullable private final Expression escape; @@ -147,4 +151,13 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(value) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(pattern) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(escape); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Limit.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Limit.java index b313ef14c9ad6..b234d1b407491 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Limit.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Limit.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,8 @@ import static java.util.Objects.requireNonNull; public class Limit extends Node { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Limit.class); + private final Expression rowCount; public Limit(Expression rowCount) { @@ -93,4 +96,12 @@ public String toString() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(rowCount); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LoadConfiguration.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LoadConfiguration.java index b67ed2b3acf98..4a0d53ef27a36 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LoadConfiguration.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LoadConfiguration.java @@ -22,7 +22,12 @@ import org.apache.iotdb.db.queryengine.common.MPPQueryContext; import org.apache.iotdb.db.queryengine.plan.statement.Statement; +import org.apache.tsfile.utils.RamUsageEstimator; + public class LoadConfiguration extends WrappedStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(LoadConfiguration.class); + public LoadConfiguration(Statement innerTreeStatement, MPPQueryContext context) { super(innerTreeStatement, context); } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LoadModel.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LoadModel.java index 519510043dc5f..8489c2a8310a4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LoadModel.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LoadModel.java @@ -19,11 +19,16 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.List; import java.util.Objects; public class LoadModel extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(LoadModel.class); + private final String modelId; private final List deviceIdList; @@ -70,4 +75,17 @@ public int hashCode() { public String toString() { return "LoadModel{" + "modelId='" + modelId + '\'' + ", deviceIdList=" + deviceIdList + '}'; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (modelId != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(modelId); + } + if (deviceIdList != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfStringList(deviceIdList); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LoadTsFile.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LoadTsFile.java index 166f06b85e328..6f02ab0039597 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LoadTsFile.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LoadTsFile.java @@ -24,6 +24,8 @@ import org.apache.iotdb.db.storageengine.dataregion.tsfile.TsFileResource; import org.apache.iotdb.db.storageengine.load.config.LoadTsFileConfigurator; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.io.File; import java.io.FileNotFoundException; import java.util.ArrayList; @@ -37,6 +39,9 @@ public class LoadTsFile extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(LoadTsFile.class); + private String filePath; private int databaseLevel; // For loading to tree-model only @@ -324,4 +329,59 @@ public String toString() { .add("loadAttributes", loadAttributes) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (filePath != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(filePath); + } + if (database != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(database); + } + if (loadAttributes != null && !loadAttributes.isEmpty()) { + for (Map.Entry entry : loadAttributes.entrySet()) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(entry.getKey()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(entry.getValue()); + } + // Map overhead + size += + AstMemoryEstimationHelper.getShallowSizeOfList( + new ArrayList<>(loadAttributes.entrySet())); + } + if (tsFiles != null) { + size += AstMemoryEstimationHelper.getShallowSizeOfList(tsFiles); + for (File file : tsFiles) { + if (file != null) { + size += RamUsageEstimator.shallowSizeOfInstance(File.class); + } + } + } + if (resources != null) { + size += AstMemoryEstimationHelper.getShallowSizeOfList(resources); + for (TsFileResource resource : resources) { + if (resource != null) { + size += resource.calculateRamSize(); + } + } + } + if (writePointCountList != null) { + size += AstMemoryEstimationHelper.getShallowSizeOfList(writePointCountList); + for (Long count : writePointCountList) { + if (count != null) { + size += RamUsageEstimator.shallowSizeOfInstance(Long.class); + } + } + } + if (isTableModel != null) { + size += AstMemoryEstimationHelper.getShallowSizeOfList(isTableModel); + for (Boolean bool : isTableModel) { + if (bool != null) { + size += RamUsageEstimator.shallowSizeOfInstance(Boolean.class); + } + } + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LogicalExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LogicalExpression.java index 34c008bd60c06..de7dc1ad06294 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LogicalExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LogicalExpression.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -34,6 +35,9 @@ public class LogicalExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(LogicalExpression.class); + public enum Operator { AND, OR; @@ -145,4 +149,11 @@ public LogicalExpression(ByteBuffer byteBuffer) { this.terms.add(deserialize(byteBuffer)); } } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(terms); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LongLiteral.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LongLiteral.java index f9b8a14c0354c..df6bf22e3ca74 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LongLiteral.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/LongLiteral.java @@ -21,6 +21,7 @@ import org.apache.iotdb.db.queryengine.plan.relational.sql.parser.ParsingException; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -31,6 +32,9 @@ public class LongLiteral extends Literal { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(LongLiteral.class); + private final String value; private final long parsedValue; @@ -134,4 +138,11 @@ public LongLiteral(ByteBuffer byteBuffer) { public Object getTsValue() { return parsedValue; } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfString(value); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/MeasureDefinition.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/MeasureDefinition.java index db6475307b304..c61b5bd3ba5fc 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/MeasureDefinition.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/MeasureDefinition.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ import static java.util.Objects.requireNonNull; public class MeasureDefinition extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(MeasureDefinition.class); + private final Expression expression; private final Identifier name; @@ -86,4 +90,13 @@ public boolean shallowEquals(Node other) { return Objects.equals(name, ((MeasureDefinition) other).name); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(expression); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(name); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/MigrateRegion.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/MigrateRegion.java index 4ec5497f471ef..e1cb03de65452 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/MigrateRegion.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/MigrateRegion.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -27,6 +28,8 @@ import java.util.Objects; public class MigrateRegion extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(MigrateRegion.class); private final int regionId; private final int fromId; @@ -87,4 +90,11 @@ public int getFromId() { public int getToId() { return toId; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NaturalJoin.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NaturalJoin.java index a628ea5112404..9dd25c6cc2c05 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NaturalJoin.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NaturalJoin.java @@ -20,12 +20,16 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import static com.google.common.base.MoreObjects.toStringHelper; public class NaturalJoin extends JoinCriteria { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(NaturalJoin.class); + @Override public boolean equals(Object obj) { if (this == obj) { @@ -48,4 +52,9 @@ public String toString() { public List getNodes() { return ImmutableList.of(); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Node.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Node.java index fd5ce98e8ef50..1f5a4e645ccfb 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Node.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Node.java @@ -19,12 +19,14 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.Accountable; + import javax.annotation.Nullable; import java.util.List; import java.util.Optional; -public abstract class Node { +public abstract class Node implements Accountable { @Nullable private final NodeLocation location; @@ -41,6 +43,11 @@ public Optional getLocation() { return Optional.ofNullable(location); } + @Nullable + protected NodeLocation getLocationInternal() { + return location; + } + public abstract List getChildren(); // Force subclasses to have a proper equals and hashcode implementation diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NotExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NotExpression.java index e9f0cfc03f216..617d2b5665878 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NotExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NotExpression.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.io.DataOutputStream; import java.io.IOException; @@ -31,6 +32,9 @@ public class NotExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(NotExpression.class); + private final Expression value; public NotExpression(Expression value) { @@ -94,4 +98,11 @@ public NotExpression(ByteBuffer byteBuffer) { super(null); this.value = Expression.deserialize(byteBuffer); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(value); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NullIfExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NullIfExpression.java index 464a87b32b06f..96ac85152eb1e 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NullIfExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NullIfExpression.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ /** NULLIF(V1,V2): CASE WHEN V1=V2 THEN NULL ELSE V1 END */ public class NullIfExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(NullIfExpression.class); + private final Expression first; private final Expression second; @@ -83,4 +87,13 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(first); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(second); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NullLiteral.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NullLiteral.java index 2fd8dab059768..3dd4cab22b0d1 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NullLiteral.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NullLiteral.java @@ -19,6 +19,8 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.io.DataOutputStream; import java.io.IOException; import java.nio.ByteBuffer; @@ -27,6 +29,9 @@ public class NullLiteral extends Literal { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(NullLiteral.class); + public NullLiteral() { super(null); } @@ -78,4 +83,10 @@ public NullLiteral(ByteBuffer byteBuffer) { public Object getTsValue() { return null; } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NumericParameter.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NumericParameter.java index 1c9eec5e9c1a6..8bbda2741cda4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NumericParameter.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/NumericParameter.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; @@ -29,6 +30,8 @@ import static java.util.Objects.requireNonNull; public class NumericParameter extends DataTypeParameter { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(NumericParameter.class); private final String value; public NumericParameter(String value) { @@ -85,4 +88,12 @@ public boolean shallowEquals(Node other) { return Objects.equals(value, ((NumericParameter) other).value); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(value); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Offset.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Offset.java index ae63bce3a43bc..378eb21119497 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Offset.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Offset.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -30,6 +31,8 @@ public class Offset extends Node { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Offset.class); + private final Expression rowCount; public Offset(Expression rowCount) { @@ -91,4 +94,12 @@ public String toString() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(rowCount); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/OneOrMoreQuantifier.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/OneOrMoreQuantifier.java index ea82719f2bd20..b91c9016cc835 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/OneOrMoreQuantifier.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/OneOrMoreQuantifier.java @@ -19,7 +19,12 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + public class OneOrMoreQuantifier extends PatternQuantifier { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(OneOrMoreQuantifier.class); + public OneOrMoreQuantifier(NodeLocation location, boolean greedy) { super(location, greedy); } @@ -28,4 +33,11 @@ public OneOrMoreQuantifier(NodeLocation location, boolean greedy) { public R accept(AstVisitor visitor, C context) { return visitor.visitOneOrMoreQuantifier(this, context); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/OrderBy.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/OrderBy.java index 56bb95bac2a52..c589acae3b965 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/OrderBy.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/OrderBy.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -35,6 +36,8 @@ public class OrderBy extends Node { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(OrderBy.class); + private final List sortItems; public OrderBy(List sortItems) { @@ -115,4 +118,12 @@ public OrderBy(ByteBuffer byteBuffer) { sortItems.add(new SortItem(byteBuffer)); } } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(sortItems); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Parameter.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Parameter.java index 9f9d934ed4439..32ff931c51a9d 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Parameter.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Parameter.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -27,6 +28,9 @@ import static java.util.Objects.requireNonNull; public class Parameter extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(Parameter.class); + private final int id; public Parameter(int id) { @@ -79,4 +83,12 @@ public boolean shallowEquals(Node other) { return id == ((Parameter) other).id; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + // int (4 bytes, but typically aligned to 8 bytes) + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternAlternation.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternAlternation.java index 78e84fc6a2c6e..15f6f22d10073 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternAlternation.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternAlternation.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,9 @@ import static java.util.Objects.requireNonNull; public class PatternAlternation extends RowPattern { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(PatternAlternation.class); + private final List patterns; public PatternAlternation(NodeLocation location, List patterns) { @@ -77,4 +81,12 @@ public String toString() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(patterns); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternConcatenation.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternConcatenation.java index 2d0836d4c4758..6a43b61cd5653 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternConcatenation.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternConcatenation.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,9 @@ import static java.util.Objects.requireNonNull; public class PatternConcatenation extends RowPattern { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(PatternConcatenation.class); + private final List patterns; public PatternConcatenation(NodeLocation location, List patterns) { @@ -77,4 +81,12 @@ public String toString() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(patterns); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternPermutation.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternPermutation.java index 577b1005ff0cc..f44727a444e3b 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternPermutation.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternPermutation.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,9 @@ import static java.util.Objects.requireNonNull; public class PatternPermutation extends RowPattern { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(PatternPermutation.class); + private final List patterns; public PatternPermutation(NodeLocation location, List patterns) { @@ -77,4 +81,12 @@ public String toString() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(patterns); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternRecognitionRelation.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternRecognitionRelation.java index 479421245c5e9..7def011cb7e77 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternRecognitionRelation.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternRecognitionRelation.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -30,6 +31,9 @@ import static java.util.Objects.requireNonNull; public class PatternRecognitionRelation extends Relation { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(PatternRecognitionRelation.class); + private final Relation input; private final List partitionBy; private final Optional orderBy; @@ -202,4 +206,25 @@ public enum RowsPerMatch { // Pattern exclusions are not allowed with this option. ALL_WITH_UNMATCHED } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(input); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(partitionBy); + if (orderBy.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(orderBy.get()); + } + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(measures); + if (afterMatchSkipTo.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(afterMatchSkipTo.get()); + } + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(pattern); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(subsets); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(variableDefinitions); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternVariable.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternVariable.java index ce9dcc4fe6c68..3189f78433a39 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternVariable.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PatternVariable.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ import static java.util.Objects.requireNonNull; public class PatternVariable extends RowPattern { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(PatternVariable.class); + private final Identifier name; public PatternVariable(NodeLocation location, Identifier name) { @@ -75,4 +79,12 @@ public String toString() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(name); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PipeEnriched.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PipeEnriched.java index 0b494c674b7f9..ff4d1b4c09e68 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PipeEnriched.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/PipeEnriched.java @@ -19,6 +19,8 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import javax.validation.constraints.NotNull; import java.util.List; @@ -26,6 +28,9 @@ public class PipeEnriched extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(PipeEnriched.class); + private final Statement innerStatement; public PipeEnriched(final @NotNull Statement innerstatement) { @@ -68,4 +73,12 @@ public String toString() { public Statement getInnerStatement() { return innerStatement; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += innerStatement == null ? 0L : innerStatement.ramBytesUsed(); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Prepare.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Prepare.java index f413b8a19266e..5b6cdbc431358 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Prepare.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Prepare.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -30,6 +31,8 @@ /** PREPARE statement AST node. Example: PREPARE stmt1 FROM SELECT * FROM table WHERE id = ? */ public final class Prepare extends Statement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Prepare.class); + private final Identifier statementName; private final Statement sql; @@ -84,4 +87,13 @@ public int hashCode() { public String toString() { return toStringHelper(this).add("statementName", statementName).add("sql", sql).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(statementName); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(sql); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ProcessingMode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ProcessingMode.java index 780a5b9a13312..b7b5e8f8870cf 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ProcessingMode.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ProcessingMode.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ import static java.util.Objects.requireNonNull; public final class ProcessingMode extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ProcessingMode.class); + private final Mode mode; public ProcessingMode(NodeLocation location, Mode mode) { @@ -74,4 +78,11 @@ public enum Mode { RUNNING, FINAL } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Property.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Property.java index 64b9c757faa71..974899b88385c 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Property.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Property.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -32,6 +33,8 @@ import static java.util.Objects.requireNonNull; public class Property extends Node { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Property.class); + private final Identifier name; @Nullable private final Expression value; // null iff the value is set to DEFAULT @@ -117,4 +120,15 @@ public String toString() { .add("value", isSetToDefault() ? "DEFAULT" : getNonDefaultValue()) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(name); + if (value != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(value); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QualifiedName.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QualifiedName.java index 332aa7b07f7ff..23c5e4005a5a7 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QualifiedName.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QualifiedName.java @@ -21,6 +21,8 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; +import org.apache.tsfile.utils.Accountable; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import javax.annotation.Nullable; @@ -38,7 +40,12 @@ import static java.util.Locale.ENGLISH; import static java.util.Objects.requireNonNull; -public class QualifiedName { +public class QualifiedName implements Accountable { + + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(QualifiedName.class); + private static final long OPTIONAL_INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(Optional.class); private final List originalParts; private final List parts; @@ -226,4 +233,36 @@ public static QualifiedName deserialize(ByteBuffer byteBuffer) { return new QualifiedName(originalParts, parts, name, prefix, suffix); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + if (originalParts != null) { + size += RamUsageEstimator.shallowSizeOf(originalParts); + for (Identifier identifier : originalParts) { + if (identifier != null) { + size += identifier.ramBytesUsed(); + } + } + } + if (parts != null) { + size += RamUsageEstimator.shallowSizeOf(parts); + for (String part : parts) { + if (part != null) { + size += RamUsageEstimator.sizeOf(part); + } + } + } + if (name != null) { + size += RamUsageEstimator.sizeOf(name); + } + if (prefix != null) { + size += OPTIONAL_INSTANCE_SIZE; + size += prefix.ramBytesUsed(); + } + if (suffix != null) { + size += RamUsageEstimator.sizeOf(suffix); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QuantifiedComparisonExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QuantifiedComparisonExpression.java index 98205917b04bb..18e7f8b7606a5 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QuantifiedComparisonExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QuantifiedComparisonExpression.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ public class QuantifiedComparisonExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(QuantifiedComparisonExpression.class); + public enum Quantifier { ALL, ANY, @@ -120,4 +124,13 @@ public boolean shallowEquals(Node other) { QuantifiedComparisonExpression otherNode = (QuantifiedComparisonExpression) other; return operator == otherNode.operator && quantifier == otherNode.quantifier; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(value); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(subquery); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QuantifiedPattern.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QuantifiedPattern.java index f4b6ae3944d15..c74e2ffa9a5de 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QuantifiedPattern.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QuantifiedPattern.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ import static java.util.Objects.requireNonNull; public class QuantifiedPattern extends RowPattern { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(QuantifiedPattern.class); + private final RowPattern pattern; private final PatternQuantifier patternQuantifier; @@ -86,4 +90,13 @@ public String toString() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += pattern == null ? 0L : pattern.ramBytesUsed(); + size += patternQuantifier == null ? 0L : patternQuantifier.ramBytesUsed(); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Query.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Query.java index b8598cd4f7f91..67be11cdfb09a 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Query.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Query.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -31,6 +32,8 @@ public class Query extends Statement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Query.class); + private final Optional with; private final QueryBody queryBody; private final Optional fill; @@ -155,4 +158,32 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(queryBody); + if (with.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += with.get().ramBytesUsed(); + } + if (fill.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += fill.get().ramBytesUsed(); + } + if (orderBy.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += orderBy.get().ramBytesUsed(); + } + if (offset.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += offset.get().ramBytesUsed(); + } + if (limit.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += limit.get().ramBytesUsed(); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QuerySpecification.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QuerySpecification.java index 7c59844c5d6c2..f6441dcb6fb58 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QuerySpecification.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/QuerySpecification.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -30,6 +31,9 @@ public class QuerySpecification extends QueryBody { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(QuerySpecification.class); + private final Select select; private final Optional from; private final Optional where; @@ -185,4 +189,45 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(select); + if (from.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += from.get().ramBytesUsed(); + } + if (where.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += where.get().ramBytesUsed(); + } + if (groupBy.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += groupBy.get().ramBytesUsed(); + } + if (having.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += having.get().ramBytesUsed(); + } + if (fill.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += fill.get().ramBytesUsed(); + } + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(windows); + if (orderBy.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += orderBy.get().ramBytesUsed(); + } + if (offset.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += offset.get().ramBytesUsed(); + } + if (limit.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += limit.get().ramBytesUsed(); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RangeQuantifier.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RangeQuantifier.java index bf41ea2d89600..63b7fda851a0e 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RangeQuantifier.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RangeQuantifier.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,9 @@ import static java.util.Objects.requireNonNull; public class RangeQuantifier extends PatternQuantifier { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(RangeQuantifier.class); + private final Optional atLeast; private final Optional atMost; @@ -90,4 +94,19 @@ public String toString() { .add("greedy", isGreedy()) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (atLeast.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += atLeast.get() == null ? 0L : atLeast.get().ramBytesUsed(); + } + if (atMost.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += atMost.get() == null ? 0L : atMost.get().ramBytesUsed(); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ReconstructRegion.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ReconstructRegion.java index df4aad226064d..9d9fe40332486 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ReconstructRegion.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ReconstructRegion.java @@ -20,11 +20,14 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; public class ReconstructRegion extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ReconstructRegion.class); final int dataNodeId; final List regionIds; @@ -73,4 +76,12 @@ public int getDataNodeId() { public List getRegionIds() { return regionIds; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getShallowSizeOfList(regionIds); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RelationalAuthorStatement.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RelationalAuthorStatement.java index d4a0d93985473..03a66d2c4e367 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RelationalAuthorStatement.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RelationalAuthorStatement.java @@ -32,6 +32,7 @@ import org.apache.iotdb.rpc.StatementExecutionException; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.HashSet; import java.util.List; @@ -40,6 +41,8 @@ import java.util.stream.Collectors; public class RelationalAuthorStatement extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(RelationalAuthorStatement.class); private final AuthorRType authorType; @@ -457,4 +460,26 @@ public TSStatus checkStatementIsValid(String currentUser) { public long getAssociatedUserId() { return associatedUserId; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(tableName); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(database); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(userName); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(roleName); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(password); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(oldPassword); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(newUsername); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(loginAddr); + if (privilegeType != null) { + size += + AstMemoryEstimationHelper.getShallowSizeOfList( + privilegeType.stream() + .map(Enum::ordinal) + .collect(java.util.stream.Collectors.toList())); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveAINode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveAINode.java index 1765c2badae1f..ad1cff33b440b 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveAINode.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveAINode.java @@ -20,11 +20,14 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; public class RemoveAINode extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(RemoveAINode.class); private final int nodeId; @@ -61,4 +64,11 @@ public int hashCode() { public String toString() { return "RemoveAINode{" + "nodeId=" + nodeId + '}'; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveConfigNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveConfigNode.java index 0760e6d581a77..d1f31ef53f4cd 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveConfigNode.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveConfigNode.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -27,6 +28,8 @@ import static com.google.common.base.MoreObjects.toStringHelper; public class RemoveConfigNode extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(RemoveConfigNode.class); final Integer nodeId; public RemoveConfigNode(Integer nodeId) { @@ -69,4 +72,11 @@ public boolean equals(Object obj) { public String toString() { return toStringHelper(this).add("nodeId", nodeId).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveDataNode.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveDataNode.java index 7e0140137a5b4..908ac997534d7 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveDataNode.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveDataNode.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -27,6 +28,8 @@ import static com.google.common.base.MoreObjects.toStringHelper; public class RemoveDataNode extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(RemoveDataNode.class); final List nodeIds; public RemoveDataNode(List dataNodeIDs) { @@ -69,4 +72,12 @@ public boolean equals(Object obj) { public String toString() { return toStringHelper(this).add("nodeIds", nodeIds).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getShallowSizeOfList(nodeIds); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveRegion.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveRegion.java index 9dc1dad708364..dbcd9bb0a478d 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveRegion.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RemoveRegion.java @@ -20,11 +20,14 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; public class RemoveRegion extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(RemoveRegion.class); private final List regionIds; private final int dataNodeId; @@ -74,4 +77,12 @@ public List getRegionIds() { public int getDataNodeId() { return dataNodeId; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getShallowSizeOfList(regionIds); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RenameColumn.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RenameColumn.java index d0fbf1ed3200a..5e1277316a439 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RenameColumn.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RenameColumn.java @@ -22,6 +22,7 @@ import org.apache.iotdb.db.exception.sql.SemanticException; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -30,6 +31,9 @@ import static java.util.Objects.requireNonNull; public final class RenameColumn extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(RenameColumn.class); + private final QualifiedName table; private final Identifier source; private final Identifier target; @@ -125,4 +129,14 @@ public String toString() { .add("view", view) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += table == null ? 0L : table.ramBytesUsed(); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(source); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(target); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RenameTable.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RenameTable.java index 4a181f99bba09..77c3296fee00b 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RenameTable.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/RenameTable.java @@ -22,6 +22,7 @@ import org.apache.iotdb.db.exception.sql.SemanticException; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -30,6 +31,9 @@ import static java.util.Objects.requireNonNull; public class RenameTable extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(RenameTable.class); + private final QualifiedName source; private final Identifier target; @@ -107,4 +111,13 @@ public String toString() { .add("view", view) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += source == null ? 0L : source.ramBytesUsed(); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(target); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Row.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Row.java index d65dbb856b0a9..8510abb5b1b3f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Row.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Row.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -31,6 +32,9 @@ import static java.util.Objects.requireNonNull; public class Row extends Expression { + + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Row.class); + private final List items; public Row(List items) { @@ -107,4 +111,11 @@ public boolean equals(Object obj) { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(items); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SearchedCaseExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SearchedCaseExpression.java index 1010d44ed25a9..de8faf5f13464 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SearchedCaseExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SearchedCaseExpression.java @@ -21,6 +21,7 @@ import com.google.common.collect.ImmutableList; import org.apache.tsfile.external.commons.lang3.Validate; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import javax.annotation.Nullable; @@ -36,6 +37,9 @@ import static java.util.Objects.requireNonNull; public class SearchedCaseExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SearchedCaseExpression.class); + private final List whenClauses; @Nullable private final Expression defaultValue; @@ -146,4 +150,15 @@ protected void serialize(DataOutputStream stream) throws IOException { } Expression.serialize(getDefaultValue().orElse(new NullLiteral()), stream); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(whenClauses); + if (defaultValue != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(defaultValue); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Select.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Select.java index 236dc40d10f59..db644daa872b4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Select.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Select.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,8 @@ public class Select extends Node { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Select.class); + private final boolean distinct; private final List selectItems; @@ -97,4 +100,11 @@ public boolean shallowEquals(Node other) { return distinct == ((Select) other).distinct; } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(selectItems); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetColumnComment.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetColumnComment.java index c179f23c6d247..cbd81779e7aa3 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetColumnComment.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetColumnComment.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -30,6 +31,8 @@ import static java.util.Objects.requireNonNull; public class SetColumnComment extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SetColumnComment.class); private final QualifiedName table; private final Identifier field; @@ -113,4 +116,14 @@ public String toString() { .add("comment", comment) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += table == null ? 0L : table.ramBytesUsed(); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(field); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(comment); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetConfiguration.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetConfiguration.java index 040452a511571..996da532781db 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetConfiguration.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetConfiguration.java @@ -22,7 +22,12 @@ import org.apache.iotdb.db.queryengine.common.MPPQueryContext; import org.apache.iotdb.db.queryengine.plan.statement.Statement; +import org.apache.tsfile.utils.RamUsageEstimator; + public class SetConfiguration extends WrappedStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SetConfiguration.class); + public SetConfiguration(Statement innerTreeStatement, MPPQueryContext context) { super(innerTreeStatement, context); } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetProperties.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetProperties.java index 943e362c05dfb..08289e31eaf53 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetProperties.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetProperties.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; @@ -30,6 +31,8 @@ import static java.util.Objects.requireNonNull; public class SetProperties extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SetProperties.class); public enum Type { TABLE, @@ -110,4 +113,13 @@ public String toString() { .add("ifExists", ifExists) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += name == null ? 0L : name.ramBytesUsed(); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(properties); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetSqlDialect.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetSqlDialect.java index 5f4092d5c31b8..fb0d7b763e323 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetSqlDialect.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetSqlDialect.java @@ -22,6 +22,7 @@ import org.apache.iotdb.db.protocol.session.IClientSession; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -29,6 +30,8 @@ import java.util.Objects; public class SetSqlDialect extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SetSqlDialect.class); private final IClientSession.SqlDialect sqlDialect; public SetSqlDialect(IClientSession.SqlDialect sqlDialect, @Nullable NodeLocation location) { @@ -76,4 +79,11 @@ public boolean shallowEquals(Node other) { public String toString() { return "SET SQL_DIALECT=" + sqlDialect; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetSystemStatus.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetSystemStatus.java index c767b67c96f95..d80b74bbd6946 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetSystemStatus.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetSystemStatus.java @@ -22,7 +22,12 @@ import org.apache.iotdb.db.queryengine.common.MPPQueryContext; import org.apache.iotdb.db.queryengine.plan.statement.Statement; +import org.apache.tsfile.utils.RamUsageEstimator; + public class SetSystemStatus extends WrappedStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SetSystemStatus.class); + public SetSystemStatus(Statement innerTreeStatement, MPPQueryContext context) { super(innerTreeStatement, context); } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetTableComment.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetTableComment.java index 4dfd78a033664..ba805d8423c26 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetTableComment.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SetTableComment.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -30,6 +31,8 @@ import static com.google.common.base.MoreObjects.toStringHelper; public class SetTableComment extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SetTableComment.class); private final QualifiedName tableName; private final boolean ifExists; @Nullable private final String comment; @@ -104,4 +107,13 @@ public String toString() { .add("view", view) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += tableName == null ? 0L : tableName.ramBytesUsed(); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(comment); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowAIDevices.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowAIDevices.java index 40fec58b2f070..b65d716459f4b 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowAIDevices.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowAIDevices.java @@ -19,12 +19,17 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.List; import static com.google.common.base.MoreObjects.toStringHelper; public class ShowAIDevices extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowAIDevices.class); + public ShowAIDevices() { super(null); } @@ -56,4 +61,11 @@ public boolean equals(Object obj) { public String toString() { return toStringHelper(this).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowAINodes.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowAINodes.java index baaaa5eea5e21..04fa5089ee653 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowAINodes.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowAINodes.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; @@ -28,6 +29,9 @@ public class ShowAINodes extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowAINodes.class); + public ShowAINodes() { super(null); } @@ -63,4 +67,11 @@ public boolean equals(Object obj) { public String toString() { return toStringHelper(this).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowAvailableUrls.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowAvailableUrls.java index 2117cdfdac28f..e33e0bf8df23b 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowAvailableUrls.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowAvailableUrls.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; @@ -27,6 +28,9 @@ public class ShowAvailableUrls extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowAvailableUrls.class); + public ShowAvailableUrls() { super(null); } @@ -58,4 +62,11 @@ public boolean equals(Object obj) { public String toString() { return toStringHelper(this).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCluster.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCluster.java index d7ea18642b6b6..a12a9eef06aca 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCluster.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCluster.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -30,6 +31,9 @@ public class ShowCluster extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowCluster.class); + private final boolean details; public ShowCluster() { @@ -87,4 +91,11 @@ public boolean equals(Object obj) { public String toString() { return toStringHelper(this).add("details", details).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowClusterId.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowClusterId.java index 1a5f7e0182a6c..a754a0542eab4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowClusterId.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowClusterId.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -27,6 +28,9 @@ public class ShowClusterId extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowClusterId.class); + public ShowClusterId(@Nullable NodeLocation location) { super(location); } @@ -63,4 +67,11 @@ public boolean shallowEquals(Node other) { public String toString() { return "SHOW CLUSTERID"; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowConfigNodes.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowConfigNodes.java index 8139789f77b65..7c5bfb12829b4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowConfigNodes.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowConfigNodes.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; @@ -28,6 +29,9 @@ public class ShowConfigNodes extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowConfigNodes.class); + public ShowConfigNodes() { super(null); } @@ -63,4 +67,11 @@ public boolean equals(Object obj) { public String toString() { return toStringHelper(this).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowConfiguration.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowConfiguration.java index b8bd5578246ca..2b9a3d7796a49 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowConfiguration.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowConfiguration.java @@ -23,7 +23,6 @@ import org.apache.iotdb.db.queryengine.plan.statement.Statement; public class ShowConfiguration extends WrappedStatement { - public ShowConfiguration(Statement innerTreeStatement, MPPQueryContext context) { super(innerTreeStatement, context); } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentDatabase.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentDatabase.java index caeb4d0eee8a8..26c09f32c8fee 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentDatabase.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentDatabase.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -27,6 +28,9 @@ public class ShowCurrentDatabase extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowCurrentDatabase.class); + public ShowCurrentDatabase(@Nullable NodeLocation location) { super(location); } @@ -63,4 +67,11 @@ public boolean shallowEquals(Node other) { public String toString() { return "SHOW CURRENT_DATABASE"; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentSqlDialect.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentSqlDialect.java index b4054b0ca691f..a9d6af80c4ae9 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentSqlDialect.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentSqlDialect.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -27,6 +28,9 @@ public class ShowCurrentSqlDialect extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowCurrentSqlDialect.class); + public ShowCurrentSqlDialect(@Nullable NodeLocation location) { super(location); } @@ -63,4 +67,11 @@ public boolean shallowEquals(Node other) { public String toString() { return "SHOW CURRENT_SQL_DIALECT"; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentTimestamp.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentTimestamp.java index d37a37d10f3dd..18a7f48dd2735 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentTimestamp.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentTimestamp.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -27,6 +28,9 @@ public class ShowCurrentTimestamp extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowCurrentTimestamp.class); + public ShowCurrentTimestamp(@Nullable NodeLocation location) { super(location); } @@ -63,4 +67,11 @@ public boolean shallowEquals(Node other) { public String toString() { return "SHOW CURRENT_TIMESTAMP"; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentUser.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentUser.java index d6e9400ed43e1..ede46f87a3fd7 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentUser.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowCurrentUser.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -27,6 +28,9 @@ public class ShowCurrentUser extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowCurrentUser.class); + public ShowCurrentUser(@Nullable NodeLocation location) { super(location); } @@ -63,4 +67,11 @@ public boolean shallowEquals(Node other) { public String toString() { return "SHOW CURRENT_USER"; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowDB.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowDB.java index b8dd93e356271..a19c3b9eca025 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowDB.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowDB.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; @@ -27,6 +28,8 @@ public class ShowDB extends Statement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(ShowDB.class); + private final boolean isDetails; public ShowDB(final NodeLocation location, final boolean isDetails) { @@ -65,4 +68,11 @@ public boolean equals(final Object obj) { public String toString() { return "SHOW DATABASES"; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowDataNodes.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowDataNodes.java index c95f5b9cbab8e..b06e326fb9294 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowDataNodes.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowDataNodes.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; @@ -28,6 +29,9 @@ public class ShowDataNodes extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowDataNodes.class); + public ShowDataNodes() { super(null); } @@ -63,4 +67,11 @@ public boolean equals(Object obj) { public String toString() { return toStringHelper(this).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowDevice.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowDevice.java index f7f773ffeae59..f9f4978f15324 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowDevice.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowDevice.java @@ -25,16 +25,21 @@ import org.apache.iotdb.db.queryengine.common.header.DatasetHeader; import org.apache.iotdb.db.queryengine.execution.operator.schema.source.TableDeviceQuerySource; import org.apache.iotdb.db.queryengine.plan.relational.analyzer.Analysis; +import org.apache.iotdb.db.schemaengine.schemaregion.read.resp.info.impl.ShowDevicesResult; import org.apache.iotdb.db.schemaengine.table.DataNodeTableCache; import org.apache.tsfile.enums.TSDataType; import org.apache.tsfile.read.common.block.TsBlock; import org.apache.tsfile.read.common.block.TsBlockBuilder; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.Objects; import java.util.stream.Collectors; public class ShowDevice extends AbstractQueryDeviceWithCache { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowDevice.class); + private static final String ALIGNED_HEADER = "__aligned"; private static final String DATABASE_HEADER = "__database"; private Offset offset; @@ -139,4 +144,28 @@ public R accept(final AstVisitor visitor, final C context) { public String toString() { return "ShowDevice" + toStringContent(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (offset != null) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += offset.ramBytesUsed(); + } + if (limit != null) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += limit.ramBytesUsed(); + } + // AbstractQueryDeviceWithCache fields + if (results != null) { + size += AstMemoryEstimationHelper.getShallowSizeOfList(results); + for (ShowDevicesResult result : results) { + if (result != null) { + size += result.ramBytesUsed(); + } + } + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowFunctions.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowFunctions.java index 9dc82bee89ac8..8dc8311e22d1d 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowFunctions.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowFunctions.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; @@ -27,6 +28,9 @@ public class ShowFunctions extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowFunctions.class); + public ShowFunctions() { super(null); } @@ -62,4 +66,11 @@ public boolean equals(Object obj) { public String toString() { return "SHOW FUNCTIONS"; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowIndex.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowIndex.java index 46b902e841f20..ea2733ce58359 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowIndex.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowIndex.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ import static java.util.Objects.requireNonNull; public class ShowIndex extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowIndex.class); + private final QualifiedName tableName; public ShowIndex(QualifiedName tableName) { @@ -75,4 +79,12 @@ public int hashCode() { public String toString() { return toStringHelper(this).add("tableName", tableName).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += tableName == null ? 0L : tableName.ramBytesUsed(); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowLoadedModels.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowLoadedModels.java index 99dd60afd877c..b263e5a832414 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowLoadedModels.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowLoadedModels.java @@ -19,11 +19,16 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.List; import java.util.Objects; public class ShowLoadedModels extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowLoadedModels.class); + private final List deviceIdList; public ShowLoadedModels(List deviceIdList) { @@ -63,4 +68,14 @@ public int hashCode() { public String toString() { return "ShowLoadedModels{" + "deviceIdList=" + deviceIdList + '}'; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (deviceIdList != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfStringList(deviceIdList); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowModels.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowModels.java index 6032a29a2466d..7db5a43baec1e 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowModels.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowModels.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; @@ -27,6 +28,9 @@ public class ShowModels extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowModels.class); + private String modelId = null; public ShowModels() { @@ -71,4 +75,14 @@ public boolean equals(Object obj) { public String toString() { return toStringHelper(this).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (modelId != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(modelId); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowPipePlugins.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowPipePlugins.java index 115a554a227cc..009b89d97dcfe 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowPipePlugins.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowPipePlugins.java @@ -19,10 +19,15 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import static com.google.common.base.MoreObjects.toStringHelper; public class ShowPipePlugins extends PipeStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowPipePlugins.class); + @Override public R accept(AstVisitor visitor, C context) { return visitor.visitShowPipePlugins(this, context); @@ -42,4 +47,11 @@ public boolean equals(Object obj) { public String toString() { return toStringHelper(this).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowPipes.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowPipes.java index c0dfe9379de1f..bb94986f9424a 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowPipes.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowPipes.java @@ -19,6 +19,8 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import javax.annotation.Nullable; import java.util.Objects; @@ -27,6 +29,9 @@ public class ShowPipes extends PipeStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowPipes.class); + private final String pipeName; private final boolean hasWhereClause; @@ -73,4 +78,14 @@ public String toString() { .add("hasWhereClause", hasWhereClause) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (pipeName != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(pipeName); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowRegions.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowRegions.java index facfcb9554a4e..01149165aaaa6 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowRegions.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowRegions.java @@ -22,6 +22,7 @@ import org.apache.iotdb.common.rpc.thrift.TConsensusGroupType; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -30,6 +31,9 @@ public class ShowRegions extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowRegions.class); + private final TConsensusGroupType regionType; private final String database; private final List nodeIds; @@ -91,4 +95,17 @@ public String toString() { .add("nodeIds", nodeIds) .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (database != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(database); + } + if (nodeIds != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfIntegerList(nodeIds); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowStatement.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowStatement.java index d193bf1590dd9..b604ce02ac1f0 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowStatement.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowStatement.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,9 @@ import static java.util.Objects.requireNonNull; public class ShowStatement extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowStatement.class); + private final String tableName; private final Optional where; @@ -113,4 +117,30 @@ public String toString() { .omitNullValues() .toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (tableName != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(tableName); + } + if (where.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(where.get()); + } + if (orderBy.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(orderBy.get()); + } + if (offset.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(offset.get()); + } + if (limit.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(limit.get()); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowSubscriptions.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowSubscriptions.java index fc89088dc8447..add9378c5bd70 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowSubscriptions.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowSubscriptions.java @@ -19,12 +19,17 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.Objects; import static com.google.common.base.MoreObjects.toStringHelper; public class ShowSubscriptions extends SubscriptionStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowSubscriptions.class); + private final String topicName; public ShowSubscriptions(final String topicName) { @@ -61,4 +66,14 @@ public boolean equals(final Object obj) { public String toString() { return toStringHelper(this).add("topicName", topicName).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (topicName != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(topicName); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowTables.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowTables.java index edb711ca9a220..74756ca2ca31c 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowTables.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowTables.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -32,6 +33,9 @@ public class ShowTables extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowTables.class); + @Nullable private final Identifier dbName; private final boolean isDetails; @@ -87,4 +91,14 @@ public boolean equals(final Object obj) { public String toString() { return toStringHelper(this).add("dbName", dbName).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (dbName != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(dbName); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowTopics.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowTopics.java index 5b78117cefa03..842fc89932420 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowTopics.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowTopics.java @@ -19,12 +19,17 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.Objects; import static com.google.common.base.MoreObjects.toStringHelper; public class ShowTopics extends SubscriptionStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowTopics.class); + private final String topicName; public ShowTopics(final String topicName) { @@ -61,4 +66,14 @@ public boolean equals(final Object obj) { public String toString() { return toStringHelper(this).add("topicName", topicName).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (topicName != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(topicName); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowVariables.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowVariables.java index 0bd8c46202cd5..dc0b0e8869e78 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowVariables.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowVariables.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -27,6 +28,9 @@ public class ShowVariables extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowVariables.class); + public ShowVariables(@Nullable NodeLocation location) { super(location); } @@ -63,4 +67,11 @@ public boolean shallowEquals(Node other) { public String toString() { return "SHOW VARIABLES"; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowVersion.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowVersion.java index 048dcb60e1d35..75ecf86e449a8 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowVersion.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ShowVersion.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -27,6 +28,9 @@ public class ShowVersion extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ShowVersion.class); + public ShowVersion(@Nullable NodeLocation location) { super(location); } @@ -63,4 +67,11 @@ public boolean shallowEquals(Node other) { public String toString() { return "SHOW VERSION"; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SimpleCaseExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SimpleCaseExpression.java index 66273e145aa91..17ad1f6c52e3a 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SimpleCaseExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SimpleCaseExpression.java @@ -21,6 +21,7 @@ import com.google.common.collect.ImmutableList; import org.apache.tsfile.external.commons.lang3.Validate; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import javax.annotation.Nullable; @@ -37,6 +38,9 @@ public class SimpleCaseExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SimpleCaseExpression.class); + private final Expression operand; private final List whenClauses; @Nullable private final Expression defaultValue; @@ -164,4 +168,16 @@ protected void serialize(DataOutputStream stream) throws IOException { } Expression.serialize(getDefaultValue().orElse(new NullLiteral()), stream); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(operand); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(whenClauses); + if (defaultValue != null) { + size += defaultValue.ramBytesUsed(); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SimpleGroupBy.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SimpleGroupBy.java index 88b80a6072b7d..2827480b86195 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SimpleGroupBy.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SimpleGroupBy.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,9 @@ public final class SimpleGroupBy extends GroupingElement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SimpleGroupBy.class); + private final List columns; public SimpleGroupBy(List simpleGroupByExpressions) { @@ -86,4 +90,12 @@ public String toString() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(columns); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SingleColumn.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SingleColumn.java index 9d8d0bb2b9db8..2c50791c509d7 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SingleColumn.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SingleColumn.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -31,6 +32,9 @@ public class SingleColumn extends SelectItem { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SingleColumn.class); + @Nullable private final Identifier alias; private final Expression expression; @@ -136,4 +140,21 @@ public boolean shallowEquals(Node other) { return alias.equals(((SingleColumn) other).alias); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(expression); + if (alias != null) { + size += alias.ramBytesUsed(); + } + if (expandedExpressions != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(expandedExpressions); + } + if (accordingColumnNames != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfStringList(accordingColumnNames); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SkipTo.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SkipTo.java index 9a5b9e809368f..2a340e3204540 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SkipTo.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SkipTo.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -34,6 +35,8 @@ import static org.apache.iotdb.db.queryengine.plan.relational.sql.ast.SkipTo.Position.PAST_LAST; public class SkipTo extends Node { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(SkipTo.class); + private final Position position; private final Optional identifier; @@ -130,4 +133,15 @@ public boolean shallowEquals(Node other) { return position == ((SkipTo) other).position; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (identifier.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(identifier.get()); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SortItem.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SortItem.java index f32b5ee356a6d..50fe12b2c5b07 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SortItem.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SortItem.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -33,6 +34,8 @@ public class SortItem extends Node { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(SortItem.class); + public enum Ordering { ASCENDING, DESCENDING @@ -143,4 +146,12 @@ public SortItem(ByteBuffer byteBuffer) { ordering = Ordering.values()[ReadWriteIOUtils.readByte(byteBuffer)]; nullOrdering = NullOrdering.values()[ReadWriteIOUtils.readByte(byteBuffer)]; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(sortKey); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StartPipe.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StartPipe.java index 15eb5b2413dd3..109c207fdfeda 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StartPipe.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StartPipe.java @@ -19,12 +19,16 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.Objects; import static com.google.common.base.MoreObjects.toStringHelper; import static java.util.Objects.requireNonNull; public class StartPipe extends PipeStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(StartPipe.class); private final String pipeName; @@ -62,4 +66,12 @@ public boolean equals(final Object obj) { public String toString() { return toStringHelper(this).add("pipeName", pipeName).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(pipeName); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StartRepairData.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StartRepairData.java index 61623f8252331..58e668cbe01af 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StartRepairData.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StartRepairData.java @@ -22,7 +22,12 @@ import org.apache.iotdb.db.queryengine.common.MPPQueryContext; import org.apache.iotdb.db.queryengine.plan.statement.Statement; +import org.apache.tsfile.utils.RamUsageEstimator; + public class StartRepairData extends WrappedStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(StartRepairData.class); + public StartRepairData(Statement innerTreeStatement, MPPQueryContext context) { super(innerTreeStatement, context); } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StopPipe.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StopPipe.java index 6d1a629de8822..a5a537d10b235 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StopPipe.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StopPipe.java @@ -19,12 +19,15 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.Objects; import static com.google.common.base.MoreObjects.toStringHelper; import static java.util.Objects.requireNonNull; public class StopPipe extends PipeStatement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(StopPipe.class); private final String pipeName; @@ -62,4 +65,12 @@ public boolean equals(final Object obj) { public String toString() { return toStringHelper(this).add("pipeName", pipeName).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(pipeName); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StopRepairData.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StopRepairData.java index 92934a97e4ebb..187368224b9cb 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StopRepairData.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StopRepairData.java @@ -22,7 +22,12 @@ import org.apache.iotdb.db.queryengine.common.MPPQueryContext; import org.apache.iotdb.db.queryengine.plan.statement.Statement; +import org.apache.tsfile.utils.RamUsageEstimator; + public class StopRepairData extends WrappedStatement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(StopRepairData.class); + public StopRepairData(Statement innerTreeStatement, MPPQueryContext context) { super(innerTreeStatement, context); } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StringLiteral.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StringLiteral.java index 0bf9c7046fee4..39fcba5ccc3f1 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StringLiteral.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/StringLiteral.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import org.apache.tsfile.utils.Binary; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -32,6 +33,9 @@ public class StringLiteral extends Literal { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(StringLiteral.class); + private final String value; private final int length; @@ -109,4 +113,11 @@ public StringLiteral(ByteBuffer byteBuffer) { public Object getTsValue() { return new Binary(value.getBytes(StandardCharsets.UTF_8)); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfString(value); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SubqueryExpression.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SubqueryExpression.java index 703f2c9721cf2..97d2c9bc740e4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SubqueryExpression.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SubqueryExpression.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ public class SubqueryExpression extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SubqueryExpression.class); + private final Query query; public SubqueryExpression(Query query) { @@ -76,4 +80,12 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(query); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SubsetDefinition.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SubsetDefinition.java index 058eacdbde024..cd4a5adda9d0b 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SubsetDefinition.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SubsetDefinition.java @@ -19,6 +19,8 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.List; import java.util.Objects; @@ -27,6 +29,9 @@ import static java.util.Objects.requireNonNull; public class SubsetDefinition extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SubsetDefinition.class); + private final Identifier name; private final List identifiers; @@ -87,4 +92,13 @@ public boolean shallowEquals(Node other) { return Objects.equals(name, ((SubsetDefinition) other).name); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(name); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(identifiers); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SymbolReference.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SymbolReference.java index 23fba4aa4f5d4..db2e353864b86 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SymbolReference.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/SymbolReference.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -30,6 +31,9 @@ public class SymbolReference extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(SymbolReference.class); + private final String name; public SymbolReference(String name) { @@ -84,4 +88,11 @@ public SymbolReference(ByteBuffer byteBuffer) { super(null); this.name = ReadWriteIOUtils.readString(byteBuffer); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfString(name); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Table.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Table.java index cd726b22b6bf3..bf397932ffd85 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Table.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Table.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ import static java.util.Objects.requireNonNull; public class Table extends QueryBody { + + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Table.class); + private final QualifiedName name; public Table(QualifiedName name) { @@ -86,4 +90,11 @@ public boolean shallowEquals(Node other) { Table otherTable = (Table) other; return name.equals(otherTable.name); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + (name == null ? 0L : name.ramBytesUsed()); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableFunctionArgument.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableFunctionArgument.java index 5fac31abc4354..5faa76750d905 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableFunctionArgument.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableFunctionArgument.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,9 @@ import static java.util.Objects.requireNonNull; public class TableFunctionArgument extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(TableFunctionArgument.class); + private final Optional name; private final Node value; @@ -89,4 +93,16 @@ public boolean shallowEquals(Node o) { return Objects.equals(name, ((TableFunctionArgument) o).name); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (name.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(name.get()); + } + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(value); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableFunctionInvocation.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableFunctionInvocation.java index cda983b8c562f..38f362dc9142f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableFunctionInvocation.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableFunctionInvocation.java @@ -19,6 +19,8 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.List; import java.util.Objects; import java.util.stream.Collectors; @@ -26,6 +28,9 @@ import static java.util.Objects.requireNonNull; public class TableFunctionInvocation extends Relation { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(TableFunctionInvocation.class); + private final QualifiedName name; private final List arguments; @@ -89,4 +94,13 @@ public boolean shallowEquals(Node o) { TableFunctionInvocation other = (TableFunctionInvocation) o; return Objects.equals(name, other.name); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += name == null ? 0L : name.ramBytesUsed(); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(arguments); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableFunctionTableArgument.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableFunctionTableArgument.java index c6f1ee88d0c40..eaf4ce253d564 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableFunctionTableArgument.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableFunctionTableArgument.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -30,6 +31,9 @@ import static org.apache.iotdb.db.queryengine.plan.relational.sql.util.ExpressionFormatter.formatSortItems; public class TableFunctionTableArgument extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(TableFunctionTableArgument.class); + private final Relation table; private final Optional> partitionBy; // it is allowed to partition by empty list private Optional orderBy; @@ -120,4 +124,20 @@ public String toString() { public boolean shallowEquals(Node o) { return sameClass(this, o); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(table); + if (partitionBy.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(partitionBy.get()); + } + if (orderBy.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(orderBy.get()); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableSubquery.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableSubquery.java index a604a7e01fe54..1036959ea4c78 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableSubquery.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TableSubquery.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,9 @@ public class TableSubquery extends QueryBody { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(TableSubquery.class); + private final Query query; public TableSubquery(Query query) { @@ -82,4 +86,12 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(query); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TimeRange.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TimeRange.java index 0242547561f7a..9b756b61d048a 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TimeRange.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TimeRange.java @@ -19,12 +19,17 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.Collections; import java.util.List; import java.util.Objects; public class TimeRange extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(TimeRange.class); + // [startTime, endTime) private long startTime; private long endTime; @@ -104,4 +109,11 @@ public boolean isLeftCRightO() { public org.apache.tsfile.read.common.TimeRange toTsFileTimeRange() { return new org.apache.tsfile.read.common.TimeRange(this.startTime, this.endTime); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Trim.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Trim.java index 235e9e079c3f7..2586e59f0c3a9 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Trim.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Trim.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -30,6 +31,8 @@ import static java.util.Objects.requireNonNull; public class Trim extends Expression { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Trim.class); + private final Specification specification; private final Expression trimSource; @Nullable private final Expression trimCharacter; @@ -138,4 +141,15 @@ public String getFunctionName() { return functionName; } } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(trimSource); + if (trimCharacter != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(trimCharacter); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TypeParameter.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TypeParameter.java index 2c64f55229ba8..f691bd2ea5488 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TypeParameter.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/TypeParameter.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ public class TypeParameter extends DataTypeParameter { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(TypeParameter.class); + private final DataType type; public TypeParameter(DataType type) { @@ -75,4 +79,12 @@ public int hashCode() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(type); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Union.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Union.java index 0f6230028b893..cda978b0312c1 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Union.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Union.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -29,6 +30,8 @@ public class Union extends SetOperation { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Union.class); + private final List relations; public Union(List relations, boolean distinct) { @@ -89,4 +92,12 @@ public boolean shallowEquals(Node other) { return this.isDistinct() == ((Union) other).isDistinct(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(relations); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/UnloadModel.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/UnloadModel.java index 4922d248b593e..0a5fe3dec826a 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/UnloadModel.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/UnloadModel.java @@ -19,11 +19,16 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + import java.util.List; import java.util.Objects; public class UnloadModel extends Statement { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(UnloadModel.class); + private final String modelId; private final List deviceIdList; @@ -69,4 +74,17 @@ public int hashCode() { public String toString() { return "UnloadModel{" + "modelId='" + modelId + '\'' + ", deviceIdList=" + deviceIdList + '}'; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (modelId != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(modelId); + } + if (deviceIdList != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfStringList(deviceIdList); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Update.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Update.java index 9e737818edcc4..9eb0057bc5ad6 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Update.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Update.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -30,6 +31,8 @@ import static java.util.Objects.requireNonNull; public class Update extends AbstractTraverseDevice { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Update.class); + private List assignments; public Update( @@ -80,4 +83,27 @@ public String toString() { + " - " + super.toStringContent(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (table != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(table); + } + if (where != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(where); + } + if (tagFuzzyPredicate != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(tagFuzzyPredicate); + } + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(assignments); + if (database != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(database); + } + if (tableName != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfString(tableName); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/UpdateAssignment.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/UpdateAssignment.java index 27ea95a839350..a1db1cc694075 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/UpdateAssignment.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/UpdateAssignment.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.io.DataOutputStream; import java.io.IOException; @@ -30,6 +31,9 @@ import static java.util.Objects.requireNonNull; public class UpdateAssignment extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(UpdateAssignment.class); + private final Expression name; private final Expression value; @@ -99,4 +103,13 @@ public int hashCode() { public String toString() { return name + " = " + value; } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(name); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(value); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Use.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Use.java index 3de8a716f0734..1ada10d2aef93 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Use.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Use.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nonnull; @@ -31,6 +32,8 @@ public final class Use extends Statement { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Use.class); + private final Identifier db; public Use(@Nonnull Identifier db) { @@ -78,4 +81,12 @@ public int hashCode() { public String toString() { return toStringHelper(this).toString(); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(db); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Values.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Values.java index e2d3dd11d577e..4850571478de1 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Values.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/Values.java @@ -21,6 +21,7 @@ import com.google.common.base.Joiner; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,8 @@ import static java.util.Objects.requireNonNull; public final class Values extends QueryBody { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(Values.class); + private final List rows; public Values(List rows) { @@ -80,4 +83,12 @@ public boolean equals(Object obj) { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(rows); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/VariableDefinition.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/VariableDefinition.java index 5af4d5f59133d..b965e9154755e 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/VariableDefinition.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/VariableDefinition.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ import static java.util.Objects.requireNonNull; public class VariableDefinition extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(VariableDefinition.class); + private final Identifier name; private final Expression expression; @@ -86,4 +90,13 @@ public boolean shallowEquals(Node other) { return Objects.equals(name, ((VariableDefinition) other).name); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(name); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(expression); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WhenClause.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WhenClause.java index 19de50315c9f6..c46cb716ed6f3 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WhenClause.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WhenClause.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.io.DataOutputStream; import java.io.IOException; @@ -31,6 +32,9 @@ public class WhenClause extends Expression { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(WhenClause.class); + private final Expression operand; private final Expression result; @@ -109,4 +113,12 @@ protected void serialize(DataOutputStream stream) throws IOException { Expression.serialize(operand, stream); Expression.serialize(result, stream); } + + @Override + public long ramBytesUsed() { + return INSTANCE_SIZE + + AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(operand) + + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(result); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowDefinition.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowDefinition.java index fde2ef6c6268b..ada49ae37e8c4 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowDefinition.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowDefinition.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -28,6 +29,9 @@ import static java.util.Objects.requireNonNull; public class WindowDefinition extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(WindowDefinition.class); + private final Identifier name; private final WindowSpecification window; @@ -85,4 +89,13 @@ public boolean shallowEquals(Node other) { return name.equals(((WindowDefinition) other).name); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(name); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(window); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowFrame.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowFrame.java index 6cb790f99959f..afd3a7146cc40 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowFrame.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowFrame.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -33,6 +34,9 @@ import static java.util.Objects.requireNonNull; public class WindowFrame extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(WindowFrame.class); + public enum Type { RANGE, ROWS, @@ -140,4 +144,16 @@ public WindowFrame(ByteBuffer byteBuffer) { end = Optional.empty(); } } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(start); + if (end.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(end.get()); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowReference.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowReference.java index 6f54fee59ba54..9b797d812fa5a 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowReference.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowReference.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.io.DataOutputStream; import java.io.IOException; @@ -31,6 +32,9 @@ import static java.util.Objects.requireNonNull; public class WindowReference extends Node implements Window { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(WindowReference.class); + private final Identifier name; public WindowReference(NodeLocation location, Identifier name) { @@ -93,4 +97,12 @@ public WindowReference(ByteBuffer byteBuffer) { super(null); this.name = new Identifier(byteBuffer); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(name); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowSpecification.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowSpecification.java index 6982a46aea972..1b9d3f0d6dbad 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowSpecification.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WindowSpecification.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import org.apache.tsfile.utils.ReadWriteIOUtils; import java.io.DataOutputStream; @@ -34,6 +35,9 @@ import static java.util.Objects.requireNonNull; public class WindowSpecification extends Node implements Window { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(WindowSpecification.class); + private final Optional existingWindowName; private final List partitionBy; private final Optional orderBy; @@ -203,4 +207,25 @@ public WindowSpecification(ByteBuffer byteBuffer) { frame = Optional.empty(); } } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + if (existingWindowName.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += + AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(existingWindowName.get()); + } + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(partitionBy); + if (orderBy.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(orderBy.get()); + } + if (frame.isPresent()) { + size += AstMemoryEstimationHelper.OPTIONAL_INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(frame.get()); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/With.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/With.java index 58582d5dab700..3fd654b660753 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/With.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/With.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.List; import java.util.Objects; @@ -30,6 +31,8 @@ public class With extends Node { + private static final long INSTANCE_SIZE = RamUsageEstimator.shallowSizeOfInstance(With.class); + private final boolean recursive; private final List queries; @@ -97,4 +100,12 @@ public String toString() { public boolean shallowEquals(Node other) { return sameClass(this, other); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(queries); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WithQuery.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WithQuery.java index 5145083e64701..f45c5b63e0650 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WithQuery.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WithQuery.java @@ -20,6 +20,7 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; import com.google.common.collect.ImmutableList; +import org.apache.tsfile.utils.RamUsageEstimator; import javax.annotation.Nullable; @@ -32,6 +33,9 @@ public class WithQuery extends Node { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(WithQuery.class); + private final Identifier name; private final Query query; @@ -127,4 +131,16 @@ public boolean shallowEquals(Node other) { return name.equals(otherRelation.name) && Objects.equals(columnNames, otherRelation.columnNames); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(name); + size += AstMemoryEstimationHelper.getEstimatedSizeOfAccountableObject(query); + if (columnNames != null) { + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeList(columnNames); + } + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WrappedStatement.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WrappedStatement.java index af11be5ad73ba..1e7a8c92baafa 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WrappedStatement.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/WrappedStatement.java @@ -80,4 +80,9 @@ public MPPQueryContext getContext() { public void setContext(MPPQueryContext context) { this.context = context; } + + @Override + public long ramBytesUsed() { + throw new UnsupportedOperationException(); + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ZeroOrMoreQuantifier.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ZeroOrMoreQuantifier.java index c55091ba75e12..019906e025824 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ZeroOrMoreQuantifier.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ZeroOrMoreQuantifier.java @@ -19,7 +19,12 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + public class ZeroOrMoreQuantifier extends PatternQuantifier { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ZeroOrMoreQuantifier.class); + public ZeroOrMoreQuantifier(NodeLocation location, boolean greedy) { super(location, greedy); } @@ -28,4 +33,11 @@ public ZeroOrMoreQuantifier(NodeLocation location, boolean greedy) { public R accept(AstVisitor visitor, C context) { return visitor.visitZeroOrMoreQuantifier(this, context); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ZeroOrOneQuantifier.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ZeroOrOneQuantifier.java index de4d6b8298481..791a5dd705f2f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ZeroOrOneQuantifier.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/ZeroOrOneQuantifier.java @@ -19,7 +19,12 @@ package org.apache.iotdb.db.queryengine.plan.relational.sql.ast; +import org.apache.tsfile.utils.RamUsageEstimator; + public class ZeroOrOneQuantifier extends PatternQuantifier { + private static final long INSTANCE_SIZE = + RamUsageEstimator.shallowSizeOfInstance(ZeroOrOneQuantifier.class); + public ZeroOrOneQuantifier(NodeLocation location, boolean greedy) { super(location, greedy); } @@ -28,4 +33,11 @@ public ZeroOrOneQuantifier(NodeLocation location, boolean greedy) { public R accept(AstVisitor visitor, C context) { return visitor.visitZeroOrOneQuantifier(this, context); } + + @Override + public long ramBytesUsed() { + long size = INSTANCE_SIZE; + size += AstMemoryEstimationHelper.getEstimatedSizeOfNodeLocation(getLocationInternal()); + return size; + } } diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/read/resp/info/impl/ShowDevicesResult.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/read/resp/info/impl/ShowDevicesResult.java index ce8057987152e..4a9dfdc4f955f 100644 --- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/read/resp/info/impl/ShowDevicesResult.java +++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/schemaregion/read/resp/info/impl/ShowDevicesResult.java @@ -24,7 +24,9 @@ import org.apache.iotdb.db.queryengine.plan.relational.metadata.DeviceEntry; import org.apache.iotdb.db.schemaengine.schemaregion.read.resp.info.IDeviceSchemaInfo; +import org.apache.tsfile.utils.Accountable; import org.apache.tsfile.utils.Binary; +import org.apache.tsfile.utils.RamUsageEstimator; import java.util.Arrays; import java.util.HashMap; @@ -33,7 +35,7 @@ import java.util.Objects; import java.util.function.Function; -public class ShowDevicesResult extends ShowSchemaResult implements IDeviceSchemaInfo { +public class ShowDevicesResult extends ShowSchemaResult implements IDeviceSchemaInfo, Accountable { private Boolean isAligned; private int templateId; @@ -137,4 +139,24 @@ public boolean equals(final Object o) { public int hashCode() { return Objects.hash(path, isAligned, templateId); } + + @Override + public long ramBytesUsed() { + long size = RamUsageEstimator.shallowSizeOfInstance(ShowDevicesResult.class); + if (path != null) { + size += RamUsageEstimator.sizeOf(path); + } + if (isAligned != null) { + size += RamUsageEstimator.shallowSizeOfInstance(Boolean.class); + } + if (rawNodes != null) { + size += RamUsageEstimator.shallowSizeOf(rawNodes); + for (String node : rawNodes) { + if (node != null) { + size += RamUsageEstimator.sizeOf(node); + } + } + } + return size; + } } diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/sql/AstMemoryEstimatorTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/sql/AstMemoryEstimatorTest.java new file mode 100644 index 0000000000000..62a5d3886a87a --- /dev/null +++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/sql/AstMemoryEstimatorTest.java @@ -0,0 +1,892 @@ +/* + * 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.plan.relational.sql; + +import org.apache.iotdb.db.protocol.session.IClientSession; +import org.apache.iotdb.db.protocol.session.InternalClientSession; +import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Statement; +import org.apache.iotdb.db.queryengine.plan.relational.sql.parser.SqlParser; + +import org.junit.Before; +import org.junit.Test; + +import java.time.ZoneId; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +public class AstMemoryEstimatorTest { + + private SqlParser sqlParser; + private IClientSession clientSession; + + @Before + public void setUp() { + sqlParser = new SqlParser(); + clientSession = new InternalClientSession("testClient"); + clientSession.setDatabaseName("testdb"); + } + + private Statement parseSQL(String sql) { + return sqlParser.createStatement(sql, ZoneId.systemDefault(), clientSession); + } + + private long estimateMemorySize(Statement statement) { + return statement == null ? 0L : statement.ramBytesUsed(); + } + + // ==================== Basic Tests ==================== + + @Test + public void testNullStatement() { + assertEquals(0L, estimateMemorySize(null)); + } + + // ==================== Literal Types ==================== + + @Test + public void testStringLiteral() { + Statement statement = parseSQL("SELECT 'hello world' FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testLongLiteral() { + Statement statement = parseSQL("SELECT 123456789 FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testDoubleLiteral() { + Statement statement = parseSQL("SELECT 3.14159 FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testBooleanLiteral() { + Statement statement = parseSQL("SELECT true, false FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testNullLiteral() { + Statement statement = parseSQL("SELECT NULL FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Identifiers ==================== + + @Test + public void testIdentifier() { + Statement statement = parseSQL("SELECT column_name FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testQuotedIdentifier() { + Statement statement = parseSQL("SELECT \"my column\" FROM \"my table\""); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Function Calls ==================== + + @Test + public void testAggregateFunctions() { + Statement statement = parseSQL("SELECT count(*), sum(a), avg(b), max(c), min(d) FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testFunctionWithDistinct() { + Statement statement = parseSQL("SELECT count(DISTINCT a) FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Comparison and Logical Expressions ==================== + + @Test + public void testComparisonOperators() { + Statement statement = + parseSQL("SELECT * FROM table1 WHERE a > 10 AND b < 20 AND c >= 5 AND d <= 15"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testLogicalOperators() { + Statement statement = parseSQL("SELECT * FROM table1 WHERE a > 10 AND b < 20 OR c > 5"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testNotExpression() { + Statement statement = parseSQL("SELECT * FROM table1 WHERE NOT (a > 10)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Predicates ==================== + + @Test + public void testBetweenPredicate() { + Statement statement = parseSQL("SELECT * FROM table1 WHERE a BETWEEN 10 AND 20"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testNotBetweenPredicate() { + Statement statement = parseSQL("SELECT * FROM table1 WHERE a NOT BETWEEN 10 AND 20"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testInPredicate() { + Statement statement = parseSQL("SELECT * FROM table1 WHERE a IN (1, 2, 3, 4, 5)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testNotInPredicate() { + Statement statement = parseSQL("SELECT * FROM table1 WHERE a NOT IN (1, 2, 3)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testLikePredicate() { + Statement statement = parseSQL("SELECT * FROM table1 WHERE name LIKE '%test%'"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testLikeWithEscape() { + Statement statement = parseSQL("SELECT * FROM table1 WHERE name LIKE '%\\%%' ESCAPE '\\'"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testIsNullPredicate() { + Statement statement = parseSQL("SELECT * FROM table1 WHERE a IS NULL"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testIsNotNullPredicate() { + Statement statement = parseSQL("SELECT * FROM table1 WHERE a IS NOT NULL"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Case Expressions ==================== + + @Test + public void testSimpleCaseExpression() { + Statement statement = + parseSQL("SELECT CASE a WHEN 1 THEN 'one' WHEN 2 THEN 'two' ELSE 'other' END FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testSimpleCaseWithoutElse() { + Statement statement = + parseSQL("SELECT CASE a WHEN 1 THEN 'one' WHEN 2 THEN 'two' END FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testSearchedCaseExpression() { + Statement statement = + parseSQL( + "SELECT CASE WHEN a > 10 THEN 'big' WHEN a > 5 THEN 'medium' ELSE 'small' END FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Other Expressions ==================== + + @Test + public void testCoalesceExpression() { + Statement statement = parseSQL("SELECT coalesce(a, b, c) FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testDereferenceExpression() { + Statement statement = parseSQL("SELECT t1.column_name FROM table1 AS t1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testTrimExpression() { + Statement statement = parseSQL("SELECT trim(name) FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testTrimWithSpecification() { + Statement statement = parseSQL("SELECT trim(BOTH ' ' FROM name) FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testIfExpression() { + Statement statement = parseSQL("SELECT if(a > 10, 'big', 'small') FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testNullIfExpression() { + Statement statement = parseSQL("SELECT nullif(a, 0) FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testExtractExpression() { + Statement statement = parseSQL("SELECT EXTRACT(YEAR FROM time) FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testSubqueryExpression() { + Statement statement = parseSQL("SELECT * FROM (SELECT a, b FROM table1 WHERE a > 10) AS sub"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testInSubquery() { + Statement statement = parseSQL("SELECT * FROM table1 WHERE a IN (SELECT b FROM table2)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testExistsPredicate() { + Statement statement = parseSQL("SELECT * FROM table1 WHERE EXISTS (SELECT 1 FROM table2)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testCastExpression() { + Statement statement = parseSQL("SELECT cast(a AS STRING) FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testTryCastExpression() { + Statement statement = parseSQL("SELECT try_cast(a AS INT64) FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Special Functions ==================== + + @Test + public void testCurrentDatabase() { + Statement statement = parseSQL("SELECT CURRENT_DATABASE FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testCurrentUser() { + Statement statement = parseSQL("SELECT CURRENT_USER FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testNowFunction() { + Statement statement = parseSQL("SELECT now() FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Row and Values ==================== + + @Test + public void testRowConstructor() { + Statement statement = parseSQL("SELECT ROW(1, 'a', 100) FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testValuesClause() { + Statement statement = parseSQL("VALUES (1, 'a'), (2, 'b'), (3, 'c')"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Query Structure ==================== + + @Test + public void testSimpleSelectQuery() { + Statement statement = parseSQL("SELECT * FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testSelectWithColumns() { + Statement statement = parseSQL("SELECT a, b, c FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testSelectWithAlias() { + Statement statement = parseSQL("SELECT a AS col_a, b AS col_b FROM table1 AS t1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testSelectWithDistinct() { + Statement statement = parseSQL("SELECT DISTINCT a, b FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testSelectAll() { + Statement statement = parseSQL("SELECT ALL a, b FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testTableSubquery() { + Statement statement = parseSQL("SELECT * FROM (SELECT a FROM table1) AS sub"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== WITH Query ==================== + + @Test + public void testWithQuery() { + Statement statement = parseSQL("WITH cte AS (SELECT a FROM table1) SELECT * FROM cte"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testWithQueryWithColumnNames() { + Statement statement = + parseSQL("WITH cte (col1, col2) AS (SELECT a, b FROM table1) SELECT * FROM cte"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testMultipleWithQueries() { + Statement statement = + parseSQL( + "WITH cte1 AS (SELECT a FROM table1), cte2 AS (SELECT b FROM table2) " + + "SELECT * FROM cte1, cte2"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== ORDER BY, LIMIT, OFFSET ==================== + + @Test + public void testOrderBy() { + Statement statement = parseSQL("SELECT * FROM table1 ORDER BY a"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testLimitOffset() { + Statement statement = parseSQL("SELECT * FROM table1 LIMIT 10 OFFSET 5"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testLimitOnly() { + Statement statement = parseSQL("SELECT * FROM table1 LIMIT 100"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testOffsetOnly() { + Statement statement = parseSQL("SELECT * FROM table1 OFFSET 10"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== GROUP BY and HAVING ==================== + + @Test + public void testGroupBy() { + Statement statement = parseSQL("SELECT a, count(*) FROM table1 GROUP BY a"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testGroupByMultipleColumns() { + Statement statement = parseSQL("SELECT a, b, count(*) FROM table1 GROUP BY a, b"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testGroupingSets() { + Statement statement = + parseSQL("SELECT a, b, count(*) FROM table1 GROUP BY GROUPING SETS ((a), (b), (a, b), ())"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testRollup() { + Statement statement = parseSQL("SELECT a, b, count(*) FROM table1 GROUP BY ROLLUP (a, b)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testCube() { + Statement statement = parseSQL("SELECT a, b, count(*) FROM table1 GROUP BY CUBE (a, b)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testHaving() { + Statement statement = parseSQL("SELECT a, count(*) FROM table1 GROUP BY a HAVING count(*) > 5"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== FILL Clause ==================== + + @Test + public void testFillLinear() { + Statement statement = parseSQL("SELECT * FROM table1 FILL METHOD LINEAR"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testFillPrevious() { + Statement statement = parseSQL("SELECT * FROM table1 FILL METHOD PREVIOUS"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testFillConstant() { + Statement statement = parseSQL("SELECT * FROM table1 FILL METHOD CONSTANT 0"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== JOIN ==================== + + @Test + public void testCrossJoin() { + Statement statement = parseSQL("SELECT * FROM table1 CROSS JOIN table2"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testJoinUsing() { + Statement statement = parseSQL("SELECT * FROM table1 JOIN table2 USING (id)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testJoinOn() { + Statement statement = parseSQL("SELECT * FROM table1 JOIN table2 ON table1.id > table2.id"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testLeftJoin() { + Statement statement = parseSQL("SELECT * FROM table1 LEFT JOIN table2 USING (id)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testRightJoin() { + Statement statement = parseSQL("SELECT * FROM table1 RIGHT JOIN table2 USING (id)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testFullJoin() { + Statement statement = parseSQL("SELECT * FROM table1 FULL JOIN table2 USING (id)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Window Functions ==================== + + @Test + public void testWindowFunctionWithOver() { + Statement statement = + parseSQL("SELECT a, sum(b) OVER (PARTITION BY a ORDER BY time) FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testNamedWindow() { + Statement statement = + parseSQL("SELECT a, sum(b) OVER w FROM table1 WINDOW w AS (PARTITION BY a ORDER BY time)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testMultipleNamedWindows() { + Statement statement = + parseSQL( + "SELECT a, sum(b) OVER w1, avg(c) OVER w2 FROM table1 " + + "WINDOW w1 AS (PARTITION BY a), w2 AS (PARTITION BY a ORDER BY time)"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== MATCH_RECOGNIZE (Pattern Recognition) ==================== + + @Test + public void testMatchRecognize() { + Statement statement = + parseSQL( + "SELECT * FROM table1 " + + "MATCH_RECOGNIZE ( " + + " PARTITION BY a " + + " ORDER BY time " + + " MEASURES A.b AS ab " + + " PATTERN (A B+) " + + " DEFINE A AS A.c > 10, B AS B.c < 5 " + + ")"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testMatchRecognizeWithQuantifiers() { + Statement statement = + parseSQL( + "SELECT * FROM table1 " + + "MATCH_RECOGNIZE ( " + + " PATTERN (A* B+ C? D{2,5}) " + + " DEFINE A AS A.x > 0, B AS B.x > 0, C AS C.x > 0, D AS D.x > 0 " + + ")"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testMatchRecognizeWithAlternation() { + Statement statement = + parseSQL( + "SELECT * FROM table1 " + + "MATCH_RECOGNIZE ( " + + " PATTERN ((A | B) C) " + + " DEFINE A AS A.x > 0, B AS B.x < 0, C AS C.x > 0 " + + ")"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testMatchRecognizeWithSubset() { + Statement statement = + parseSQL( + "SELECT * FROM table1 " + + "MATCH_RECOGNIZE ( " + + " PATTERN (A B C) " + + " SUBSET AB = (A, B) " + + " DEFINE A AS A.x > 0, B AS B.x > 0, C AS C.x > 0 " + + ")"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testMatchRecognizeWithRowsPerMatch() { + Statement statement = + parseSQL( + "SELECT * FROM table1 " + + "MATCH_RECOGNIZE ( " + + " ONE ROW PER MATCH " + + " PATTERN (A B) " + + " DEFINE A AS A.x > 0, B AS B.x > 0 " + + ")"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testMatchRecognizeWithSkipTo() { + Statement statement = + parseSQL( + "SELECT * FROM table1 " + + "MATCH_RECOGNIZE ( " + + " AFTER MATCH SKIP TO NEXT ROW " + + " PATTERN (A B) " + + " DEFINE A AS A.x > 0, B AS B.x > 0 " + + ")"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Statements ==================== + + @Test + public void testExplain() { + Statement statement = parseSQL("EXPLAIN SELECT * FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testExplainAnalyze() { + Statement statement = parseSQL("EXPLAIN ANALYZE SELECT * FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testExplainAnalyzeVerbose() { + Statement statement = parseSQL("EXPLAIN ANALYZE VERBOSE SELECT * FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testInsert() { + Statement statement = parseSQL("INSERT INTO table1 (a, b) SELECT a, b FROM table2"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testDelete() { + Statement statement = parseSQL("DELETE FROM table1 WHERE a > 10"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testDeleteWithoutWhere() { + Statement statement = parseSQL("DELETE FROM table1"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testUpdate() { + Statement statement = parseSQL("UPDATE table1 SET a = 100 WHERE b > 50"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testUpdateMultipleColumns() { + Statement statement = parseSQL("UPDATE table1 SET a = 100, b = 'new' WHERE c > 50"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Prepared Statements ==================== + + @Test + public void testPrepare() { + Statement statement = parseSQL("PREPARE myquery FROM SELECT * FROM table1 WHERE a > 10"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testExecute() { + Statement statement = parseSQL("EXECUTE myquery"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testExecuteWithParams() { + Statement statement = parseSQL("EXECUTE myquery USING 10, 'test'"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testExecuteImmediate() { + Statement statement = parseSQL("EXECUTE IMMEDIATE 'SELECT * FROM table1'"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testExecuteImmediateWithParams() { + Statement statement = parseSQL("EXECUTE IMMEDIATE 'SELECT * FROM table1' USING 10, 'test'"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testDeallocate() { + Statement statement = parseSQL("DEALLOCATE PREPARE myquery"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + // ==================== Complex Query Tests ==================== + + @Test + public void testMemorySizeIncreasesWithComplexity() { + Statement simple = parseSQL("SELECT * FROM table1"); + Statement medium = parseSQL("SELECT a, b FROM table1 WHERE a > 10"); + Statement complex = + parseSQL( + "SELECT a, b, count(*) FROM table1 WHERE a > 10 AND b < 20 " + + "GROUP BY a, b HAVING count(*) > 5 LIMIT 100 OFFSET 10"); + + long simpleSize = estimateMemorySize(simple); + long mediumSize = estimateMemorySize(medium); + long complexSize = estimateMemorySize(complex); + + assertTrue("Simple query should have smaller memory than medium", simpleSize < mediumSize); + assertTrue("Medium query should have smaller memory than complex", mediumSize < complexSize); + } + + @Test + public void testDeepNestedQuery() { + String sql = + "SELECT * FROM (" + + "SELECT * FROM (" + + "SELECT * FROM (" + + "SELECT * FROM table1" + + ") AS l3" + + ") AS l2" + + ") AS l1"; + Statement statement = parseSQL(sql); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive for nested queries", memorySize > 0); + } + + @Test + public void testComplexWhereClause() { + Statement statement = + parseSQL( + "SELECT * FROM table1 WHERE " + + "(a > 10 AND b < 20) OR (c BETWEEN 5 AND 15) " + + "AND d IN (1, 2, 3) AND e LIKE '%test%' " + + "AND f IS NOT NULL"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testComplexSelectWithManyFunctions() { + Statement statement = + parseSQL( + "SELECT " + + "count(*), sum(a), avg(b), max(c), min(d), " + + "coalesce(e, f, g), nullif(h, 0), " + + "CASE WHEN i > 10 THEN 'big' ELSE 'small' END, " + + "cast(j AS STRING), trim(k) " + + "FROM table1 " + + "GROUP BY l"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testComplexJoinQuery() { + Statement statement = + parseSQL( + "SELECT t1.a, t2.b, t3.c " + + "FROM table1 AS t1 " + + "LEFT JOIN table2 AS t2 USING (id) " + + "CROSS JOIN table3 AS t3 " + + "WHERE t1.x > 10 AND t2.y < 20"); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testVeryLongInList() { + StringBuilder sb = new StringBuilder("SELECT * FROM table1 WHERE a IN ("); + for (int i = 0; i < 100; i++) { + if (i > 0) sb.append(", "); + sb.append(i); + } + sb.append(")"); + Statement statement = parseSQL(sb.toString()); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } + + @Test + public void testLongStringLiteral() { + StringBuilder sb = new StringBuilder("SELECT '"); + for (int i = 0; i < 1000; i++) { + sb.append("x"); + } + sb.append("' FROM table1"); + Statement statement = parseSQL(sb.toString()); + long memorySize = estimateMemorySize(statement); + assertTrue("Memory size should be positive", memorySize > 0); + } +}