You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by sb...@apache.org on 2023/09/28 04:46:28 UTC

[hive] branch master updated: HIVE-27672: Iceberg: Truncate partition support (#4672) (Sourabh Badhya, reviewed by Krisztian Kasa, Denys Kuzmenko)

This is an automated email from the ASF dual-hosted git repository.

sbadhya pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/hive.git


The following commit(s) were added to refs/heads/master by this push:
     new fcd1ef193d5 HIVE-27672: Iceberg: Truncate partition support (#4672) (Sourabh Badhya, reviewed by Krisztian Kasa, Denys Kuzmenko)
fcd1ef193d5 is described below

commit fcd1ef193d57c10be3d879edb5a8b610203a15ad
Author: Sourabh Badhya <ia...@gmail.com>
AuthorDate: Thu Sep 28 10:16:22 2023 +0530

    HIVE-27672: Iceberg: Truncate partition support (#4672) (Sourabh Badhya, reviewed by Krisztian Kasa, Denys Kuzmenko)
---
 .../iceberg/mr/hive/HiveIcebergMetaHook.java       |   53 +-
 .../iceberg/mr/hive/HiveIcebergStorageHandler.java |  209 ++-
 .../apache/iceberg/mr/hive/IcebergTableUtil.java   |    7 +
 .../hive/TestHiveIcebergStorageHandlerNoScan.java  |    3 +-
 .../mr/hive/TestHiveIcebergTruncateTable.java      |   36 +-
 .../truncate_iceberg_table_with_partition_spec.q   |    1 +
 ...cate_table_partition_spec_with_part_evolution.q |    6 +
 .../queries/positive/iceberg_truncate_partition.q  |  152 +++
 .../iceberg_truncate_partition_with_evolution.q    |  114 ++
 ...runcate_iceberg_table_with_partition_spec.q.out |    2 +-
 ..._table_partition_spec_with_part_evolution.q.out |   32 +
 .../positive/iceberg_truncate_partition.q.out      |  900 +++++++++++++
 ...iceberg_truncate_partition_with_evolution.q.out | 1371 ++++++++++++++++++++
 .../table/misc/truncate/TruncateTableAnalyzer.java |   77 +-
 .../org/apache/hadoop/hive/ql/metadata/Hive.java   |    5 +-
 .../hive/ql/metadata/HiveStorageHandler.java       |   18 +
 .../hive/ql/parse/AcidExportSemanticAnalyzer.java  |    4 +-
 .../hadoop/hive/ql/parse/BaseSemanticAnalyzer.java |   17 +
 .../hive/ql/parse/MergeSemanticAnalyzer.java       |    3 +-
 .../apache/hadoop/hive/ql/parse/ParseUtils.java    |   46 +
 .../hive/ql/parse/RewriteSemanticAnalyzer.java     |   45 -
 .../hadoop/hive/ql/parse/SemanticAnalyzer.java     |   16 -
 .../hive/ql/parse/SplitUpdateSemanticAnalyzer.java |    6 +-
 .../apache/hadoop/hive/ql/parse/TransformSpec.java |   12 +
 .../ql/parse/UpdateDeleteSemanticAnalyzer.java     |    5 +-
 .../hadoop/hive/serde2/typeinfo/TypeInfoUtils.java |   32 +
 .../apache/hadoop/hive/metastore/HiveMetaHook.java |    4 +
 .../hadoop/hive/metastore/HiveMetaStoreClient.java |    2 +-
 28 files changed, 3070 insertions(+), 108 deletions(-)

diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergMetaHook.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergMetaHook.java
index 33f2743483f..14ccd429ce1 100644
--- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergMetaHook.java
+++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergMetaHook.java
@@ -20,6 +20,8 @@
 package org.apache.iceberg.mr.hive;
 
 import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
@@ -30,13 +32,16 @@ import java.util.Objects;
 import java.util.Optional;
 import java.util.Properties;
 import java.util.Set;
+import java.util.function.Function;
 import java.util.stream.Collectors;
+import org.apache.commons.collections.CollectionUtils;
 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.fs.FileSystem;
 import org.apache.hadoop.fs.Path;
 import org.apache.hadoop.hive.common.TableName;
 import org.apache.hadoop.hive.metastore.HiveMetaHook;
 import org.apache.hadoop.hive.metastore.PartitionDropOptions;
+import org.apache.hadoop.hive.metastore.Warehouse;
 import org.apache.hadoop.hive.metastore.api.EnvironmentContext;
 import org.apache.hadoop.hive.metastore.api.FieldSchema;
 import org.apache.hadoop.hive.metastore.api.MetaException;
@@ -65,6 +70,7 @@ import org.apache.iceberg.BaseMetastoreTableOperations;
 import org.apache.iceberg.BaseTable;
 import org.apache.iceberg.CatalogUtil;
 import org.apache.iceberg.DeleteFiles;
+import org.apache.iceberg.PartitionField;
 import org.apache.iceberg.PartitionSpec;
 import org.apache.iceberg.PartitionSpecParser;
 import org.apache.iceberg.Schema;
@@ -81,6 +87,7 @@ import org.apache.iceberg.UpdateSchema;
 import org.apache.iceberg.catalog.TableIdentifier;
 import org.apache.iceberg.exceptions.NoSuchTableException;
 import org.apache.iceberg.exceptions.NotFoundException;
+import org.apache.iceberg.expressions.Expression;
 import org.apache.iceberg.expressions.Expressions;
 import org.apache.iceberg.hive.CachedClientPool;
 import org.apache.iceberg.hive.HiveSchemaUtil;
@@ -99,6 +106,7 @@ import org.apache.iceberg.relocated.com.google.common.collect.ImmutableMap;
 import org.apache.iceberg.relocated.com.google.common.collect.ImmutableSet;
 import org.apache.iceberg.relocated.com.google.common.collect.Lists;
 import org.apache.iceberg.relocated.com.google.common.collect.Maps;
+import org.apache.iceberg.types.Conversions;
 import org.apache.iceberg.types.Type;
 import org.apache.iceberg.util.Pair;
 import org.apache.thrift.TException;
@@ -597,12 +605,51 @@ public class HiveIcebergMetaHook implements HiveMetaHook {
   }
 
   @Override
-  public void preTruncateTable(org.apache.hadoop.hive.metastore.api.Table table, EnvironmentContext context)
+  public void preTruncateTable(org.apache.hadoop.hive.metastore.api.Table table, EnvironmentContext context,
+      List<String> partNames)
       throws MetaException {
     this.catalogProperties = getCatalogProperties(table);
     this.icebergTable = Catalogs.loadTable(conf, catalogProperties);
+    Map<String, PartitionField> partitionFieldMap = icebergTable.spec().fields().stream()
+        .collect(Collectors.toMap(PartitionField::name, Function.identity()));
+    Expression finalExp = CollectionUtils.isEmpty(partNames) ? Expressions.alwaysTrue() : Expressions.alwaysFalse();
+    if (partNames != null) {
+      for (String partName : partNames) {
+        Map<String, String> specMap = Warehouse.makeSpecFromName(partName);
+        Expression subExp = Expressions.alwaysTrue();
+        for (Map.Entry<String, String> entry : specMap.entrySet()) {
+          String partColValue;
+          // Since Iceberg encodes the values in UTF-8, we need to decode it.
+          try {
+            partColValue = URLDecoder.decode(entry.getValue(), "UTF-8");
+          } catch (UnsupportedEncodingException e) {
+            throw new MetaException(String.format("Unable to decode partition path values due to: %s", e));
+          }
+          if (partitionFieldMap.containsKey(entry.getKey())) {
+            PartitionField partitionField = partitionFieldMap.get(entry.getKey());
+            Type resultType = partitionField.transform().getResultType(icebergTable.schema()
+                    .findField(partitionField.sourceId()).type());
+            TransformSpec.TransformType transformType = TransformSpec.fromString(partitionField.transform().toString());
+            Object value = Conversions.fromPartitionString(resultType, partColValue);
+            Iterable iterable = () -> Collections.singletonList(value).iterator();
+            if (TransformSpec.TransformType.IDENTITY.equals(transformType)) {
+              Expression boundPredicate = Expressions.in(partitionField.name(), iterable);
+              subExp = Expressions.and(subExp, boundPredicate);
+            } else {
+              throw new MetaException(
+                  String.format("Partition transforms are not supported via truncate operation: %s", entry.getKey()));
+            }
+          } else {
+            throw new MetaException(String.format("No partition column/transform name by the name: %s",
+                entry.getKey()));
+          }
+        }
+        finalExp = Expressions.or(finalExp, subExp);
+      }
+    }
+
     DeleteFiles delete = icebergTable.newDelete();
-    delete.deleteFromRowFilter(Expressions.alwaysTrue());
+    delete.deleteFromRowFilter(finalExp);
     delete.commit();
     context.putToProperties("truncateSkipDataDeletion", "true");
   }
@@ -929,7 +976,7 @@ public class HiveIcebergMetaHook implements HiveMetaHook {
     // Hive only supports merge-on-read delete mode, it will actually throw an error if DML operations are attempted on
     // tables that don't have this (the default is copy-on-write). We set this at table creation and v1->v2 conversion.
     if ((icebergTable == null || ((BaseTable) icebergTable).operations().current().formatVersion() == 1) &&
-        "2".equals(newProps.get(TableProperties.FORMAT_VERSION))) {
+        IcebergTableUtil.isV2Table(newProps)) {
       newProps.put(TableProperties.DELETE_MODE, HiveIcebergStorageHandler.MERGE_ON_READ);
       newProps.put(TableProperties.UPDATE_MODE, HiveIcebergStorageHandler.MERGE_ON_READ);
       newProps.put(TableProperties.MERGE_MODE, HiveIcebergStorageHandler.MERGE_ON_READ);
diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java
index 1e61ebcc86b..bb9356df251 100644
--- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java
+++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/HiveIcebergStorageHandler.java
@@ -41,6 +41,7 @@ import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Collectors;
+import org.apache.commons.collections.MapUtils;
 import org.apache.commons.collections4.ListUtils;
 import org.apache.commons.lang3.SerializationUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -71,6 +72,7 @@ import org.apache.hadoop.hive.ql.ddl.table.AbstractAlterTableDesc;
 import org.apache.hadoop.hive.ql.ddl.table.AlterTableType;
 import org.apache.hadoop.hive.ql.ddl.table.create.like.CreateTableLikeDesc;
 import org.apache.hadoop.hive.ql.ddl.table.misc.properties.AlterTableSetPropertiesDesc;
+import org.apache.hadoop.hive.ql.exec.ColumnInfo;
 import org.apache.hadoop.hive.ql.exec.FetchOperator;
 import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
 import org.apache.hadoop.hive.ql.exec.Utilities;
@@ -109,6 +111,10 @@ import org.apache.hadoop.hive.serde2.AbstractSerDe;
 import org.apache.hadoop.hive.serde2.DefaultFetchFormatter;
 import org.apache.hadoop.hive.serde2.Deserializer;
 import org.apache.hadoop.hive.serde2.FetchFormatter;
+import org.apache.hadoop.hive.serde2.SerDeException;
+import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
+import org.apache.hadoop.hive.serde2.objectinspector.StructField;
+import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector;
 import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeInfo;
 import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory;
 import org.apache.hadoop.io.Writable;
@@ -124,13 +130,20 @@ import org.apache.hadoop.mapred.RecordReader;
 import org.apache.hadoop.mapred.Reporter;
 import org.apache.iceberg.BaseMetastoreTableOperations;
 import org.apache.iceberg.BaseTable;
+import org.apache.iceberg.DataFile;
 import org.apache.iceberg.ExpireSnapshots;
 import org.apache.iceberg.FileFormat;
+import org.apache.iceberg.FileScanTask;
+import org.apache.iceberg.FindFiles;
 import org.apache.iceberg.ManifestFile;
+import org.apache.iceberg.MetadataTableType;
+import org.apache.iceberg.MetadataTableUtils;
 import org.apache.iceberg.NullOrder;
+import org.apache.iceberg.PartitionData;
 import org.apache.iceberg.PartitionField;
 import org.apache.iceberg.PartitionSpec;
 import org.apache.iceberg.PartitionSpecParser;
+import org.apache.iceberg.PartitionsTable;
 import org.apache.iceberg.RowLevelOperationMode;
 import org.apache.iceberg.Schema;
 import org.apache.iceberg.SchemaParser;
@@ -143,7 +156,11 @@ import org.apache.iceberg.SortOrder;
 import org.apache.iceberg.Table;
 import org.apache.iceberg.TableProperties;
 import org.apache.iceberg.exceptions.NoSuchTableException;
+import org.apache.iceberg.expressions.Expression;
+import org.apache.iceberg.expressions.Expressions;
+import org.apache.iceberg.expressions.ResidualEvaluator;
 import org.apache.iceberg.hadoop.HadoopConfigurable;
+import org.apache.iceberg.io.CloseableIterable;
 import org.apache.iceberg.mr.Catalogs;
 import org.apache.iceberg.mr.InputFormatConfig;
 import org.apache.iceberg.puffin.Blob;
@@ -163,10 +180,12 @@ import org.apache.iceberg.relocated.com.google.common.collect.Maps;
 import org.apache.iceberg.relocated.com.google.common.collect.Sets;
 import org.apache.iceberg.relocated.com.google.common.collect.Streams;
 import org.apache.iceberg.types.Conversions;
+import org.apache.iceberg.types.Type;
 import org.apache.iceberg.types.Types;
 import org.apache.iceberg.util.ByteBuffers;
 import org.apache.iceberg.util.Pair;
 import org.apache.iceberg.util.SerializationUtil;
+import org.apache.iceberg.util.StructProjection;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -377,16 +396,12 @@ public class HiveIcebergStorageHandler implements HiveStoragePredicateHandler, H
       return true;
     }
     // If it is a table which has undergone partition evolution, return false;
-    if (icebergTbl.currentSnapshot() != null) {
-      if (icebergTbl.currentSnapshot().allManifests(icebergTbl.io()).parallelStream()
-          .map(ManifestFile::partitionSpecId)
-          .anyMatch(id -> id < icebergTbl.spec().specId())) {
-        if (withPartClause) {
-          throw new SemanticException("Can not Load into an iceberg table, which has undergone partition evolution " +
-              "using the PARTITION clause");
-        }
-        return false;
+    if (hasUndergonePartitionEvolution(icebergTbl)) {
+      if (withPartClause) {
+        throw new SemanticException("Can not Load into an iceberg table, which has undergone partition evolution " +
+            "using the PARTITION clause");
       }
+      return false;
     }
     return withPartClause;
   }
@@ -977,14 +992,11 @@ public class HiveIcebergStorageHandler implements HiveStoragePredicateHandler, H
       if (IcebergTableUtil.isBucketed(table)) {
         throw new SemanticException("Cannot perform insert overwrite query on bucket partitioned Iceberg table.");
       }
-      if (table.currentSnapshot() != null) {
-        if (table.currentSnapshot().allManifests(table.io()).parallelStream().map(ManifestFile::partitionSpecId)
-            .anyMatch(id -> id < table.spec().specId())) {
-          throw new SemanticException(
-              "Cannot perform insert overwrite query on Iceberg table where partition evolution happened. In order " +
-              "to successfully carry out any insert overwrite operation on this table, the data has to be rewritten " +
-              "conforming to the latest spec. ");
-        }
+      if (hasUndergonePartitionEvolution(table)) {
+        throw new SemanticException(
+            "Cannot perform insert overwrite query on Iceberg table where partition evolution happened. In order " +
+            "to successfully carry out any insert overwrite operation on this table, the data has to be rewritten " +
+            "conforming to the latest spec. ");
       }
     }
   }
@@ -992,7 +1004,7 @@ public class HiveIcebergStorageHandler implements HiveStoragePredicateHandler, H
   @Override
   public AcidSupportType supportsAcidOperations(org.apache.hadoop.hive.ql.metadata.Table table,
       boolean isWriteOperation) {
-    if (table.getParameters() != null && "2".equals(table.getParameters().get(TableProperties.FORMAT_VERSION))) {
+    if (IcebergTableUtil.isV2Table(table.getParameters())) {
       if (isWriteOperation) {
         checkDMLOperationMode(table);
       }
@@ -1639,7 +1651,7 @@ public class HiveIcebergStorageHandler implements HiveStoragePredicateHandler, H
       throws SemanticException {
     Table table = IcebergTableUtil.getTable(conf, hmsTable.getTTable());
 
-    if (table.spec().isUnpartitioned()) {
+    if (table.spec().isUnpartitioned() && MapUtils.isNotEmpty(partitionSpec)) {
       throw new SemanticException("Writing data into a partition fails when the Iceberg table is unpartitioned.");
     }
 
@@ -1660,4 +1672,163 @@ public class HiveIcebergStorageHandler implements HiveStoragePredicateHandler, H
       }
     }
   }
+
+  /**
+   * A function to decide whether a given truncate query can perform a metadata delete or not.
+   * If its not possible to perform metadata delete then try to perform a delete based on the mode.
+   * The steps to decide whether truncate is possible is as follows - <br>
+   * a. Create an expression based on the partition spec columns and partition spec values. <br>
+   * b. Find files which match the expression using Apache Iceberg's FindFiles API. <br>
+   * c. Do evaluation on whether the expression can match the partition value in the file. <br>
+   * If for all files, the strict evaluation returns true, it means that we safely delete all files
+   * by performing a metadata delete operation. If not, we must convert the truncate to delete query
+   * which eventually performs a delete based on the mode.
+   * @param hmsTable A Hive table instance.
+   * @param partitionSpec Map containing partition specification given by user.
+   * @return true if we can perform metadata delete, otherwise false.
+   * @throws SemanticException Exception raised when a partition transform is being used
+   * or when partition column is not present in the table.
+   */
+  @Override
+  public boolean canUseTruncate(org.apache.hadoop.hive.ql.metadata.Table hmsTable, Map<String, String> partitionSpec)
+      throws SemanticException {
+    Table table = IcebergTableUtil.getTable(conf, hmsTable.getTTable());
+    if (MapUtils.isEmpty(partitionSpec) || !hasUndergonePartitionEvolution(table)) {
+      return true;
+    }
+
+    Expression finalExp = generateExpressionFromPartitionSpec(table, partitionSpec);
+    FindFiles.Builder builder = new FindFiles.Builder(table).withRecordsMatching(finalExp);
+    Set<DataFile> dataFiles = Sets.newHashSet(builder.collect());
+    boolean result = true;
+    for (DataFile dataFile : dataFiles) {
+      PartitionData partitionData = (PartitionData) dataFile.partition();
+      Expression residual = ResidualEvaluator.of(table.spec(), finalExp, false)
+          .residualFor(partitionData);
+      if (!residual.isEquivalentTo(Expressions.alwaysTrue())) {
+        result = false;
+        break;
+      }
+    }
+
+    boolean isV2Table = IcebergTableUtil.isV2Table(hmsTable.getParameters());
+    if (!result && !isV2Table) {
+      throw new SemanticException("Truncate conversion to delete is not possible since its not an Iceberg V2 table." +
+          " Consider converting the table to Iceberg's V2 format specification.");
+    }
+    return result;
+  }
+
+  private boolean hasUndergonePartitionEvolution(Table table) {
+    // If it is a table which has undergone partition evolution, return true.
+    return table.currentSnapshot() != null &&
+        table.currentSnapshot().allManifests(table.io()).parallelStream()
+        .map(ManifestFile::partitionSpecId)
+        .anyMatch(id -> id < table.spec().specId());
+  }
+
+  /**
+   * Returns a list of partitions which are corresponding to the table based on the partition spec provided.
+   * @param hmsTable A Hive table instance.
+   * @param partitionSpec Map containing partition specification.
+   * @return A list of partition values which satisfies the partition spec provided corresponding to the table.
+   * @throws SemanticException Exception raised when there is an issue performing a scan on the partitions table.
+   */
+  @Override
+  public List<String> getPartitionNames(org.apache.hadoop.hive.ql.metadata.Table hmsTable,
+      Map<String, String> partitionSpec) throws SemanticException {
+    Table icebergTable = IcebergTableUtil.getTable(conf, hmsTable.getTTable());
+    PartitionsTable partitionsTable = (PartitionsTable) MetadataTableUtils
+            .createMetadataTableInstance(icebergTable, MetadataTableType.PARTITIONS);
+    Expression expression = generateExpressionFromPartitionSpec(icebergTable, partitionSpec);
+    Set<PartitionData> partitionList = Sets.newHashSet();
+    try (CloseableIterable<FileScanTask> fileScanTasks = partitionsTable.newScan().planFiles()) {
+      fileScanTasks.forEach(task -> {
+        partitionList.addAll(Sets.newHashSet(CloseableIterable.transform(task.asDataTask().rows(), row -> {
+          StructProjection data = row.get(PART_IDX, StructProjection.class);
+          PartitionSpec pSpec = icebergTable.spec();
+          PartitionData partitionData = new PartitionData(pSpec.partitionType());
+          for (int index = 0; index < pSpec.fields().size(); index++) {
+            partitionData.set(index, data.get(index, Object.class));
+          }
+          return partitionData;
+        })));
+      });
+
+      List<String> partPathList = partitionList.stream().filter(partitionData -> {
+        ResidualEvaluator resEval = ResidualEvaluator.of(icebergTable.spec(), expression, false);
+        return resEval.residualFor(partitionData).isEquivalentTo(Expressions.alwaysTrue());
+      }).map(partitionData -> icebergTable.spec().partitionToPath(partitionData)).collect(Collectors.toList());
+
+      return partPathList;
+    } catch (IOException e) {
+      throw new SemanticException(String.format("Error while fetching the partitions due to: %s", e));
+    }
+  }
+
+  private Expression generateExpressionFromPartitionSpec(Table table, Map<String, String> partitionSpec)
+      throws SemanticException {
+    Map<String, PartitionField> partitionFieldMap = table.spec().fields().stream()
+        .collect(Collectors.toMap(PartitionField::name, Function.identity()));
+    Expression finalExp = Expressions.alwaysTrue();
+    for (Map.Entry<String, String> entry : partitionSpec.entrySet()) {
+      String partColName = entry.getKey();
+      if (partitionFieldMap.containsKey(partColName)) {
+        PartitionField partitionField = partitionFieldMap.get(partColName);
+        Type resultType = partitionField.transform().getResultType(table.schema()
+                .findField(partitionField.sourceId()).type());
+        Object value = Conversions.fromPartitionString(resultType, entry.getValue());
+        TransformSpec.TransformType transformType = TransformSpec.fromString(partitionField.transform().toString());
+        Iterable iterable = () -> Collections.singletonList(value).iterator();
+        if (TransformSpec.TransformType.IDENTITY == transformType) {
+          Expression boundPredicate = Expressions.in(partitionField.name(), iterable);
+          finalExp = Expressions.and(finalExp, boundPredicate);
+        } else {
+          throw new SemanticException(
+                  String.format("Partition transforms are not supported via truncate operation: %s", partColName));
+        }
+      } else {
+        throw new SemanticException(String.format("No partition column/transform by the name: %s", partColName));
+      }
+    }
+    return finalExp;
+  }
+
+  /**
+   * A function to fetch the column information of the underlying column defined by the table format.
+   * @param hmsTable A Hive table instance
+   * @param colName Column name
+   * @return An instance of ColumnInfo.
+   * @throws SemanticException An exception is thrown when the column is not present, or if we unable to fetch
+   * column type due to SerDeException, or if the associated field object inspector is not present.
+   */
+  @Override
+  public ColumnInfo getColumnInfo(org.apache.hadoop.hive.ql.metadata.Table hmsTable, String colName)
+      throws SemanticException {
+    Table icebergTbl = IcebergTableUtil.getTable(conf, hmsTable.getTTable());
+    Deserializer deserializer = hmsTable.getDeserializer();
+    Types.NestedField field = icebergTbl.schema().findField(colName);
+    if (field != null) {
+      try {
+        ObjectInspector fieldObjInspector = null;
+        StructObjectInspector structObjectInspector = (StructObjectInspector) deserializer.getObjectInspector();
+        for (StructField structField : structObjectInspector.getAllStructFieldRefs()) {
+          if (field.name().equalsIgnoreCase(structField.getFieldName())) {
+            fieldObjInspector = structField.getFieldObjectInspector();
+            break;
+          }
+        }
+        if (fieldObjInspector != null) {
+          return new ColumnInfo(field.name(), fieldObjInspector, hmsTable.getTableName(), false);
+        } else {
+          throw new SemanticException(String.format("Unable to fetch column type of column %s " +
+              "since we are not able to infer its object inspector.", colName));
+        }
+      } catch (SerDeException e) {
+        throw new SemanticException(String.format("Unable to fetch column type of column %s due to: %s", colName, e));
+      }
+    } else {
+      throw new SemanticException(String.format("Unable to find a column with the name: %s", colName));
+    }
+  }
 }
diff --git a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java
index d225c442db3..9bcd321bf70 100644
--- a/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java
+++ b/iceberg/iceberg-handler/src/main/java/org/apache/iceberg/mr/hive/IcebergTableUtil.java
@@ -20,6 +20,7 @@
 package org.apache.iceberg.mr.hive;
 
 import java.util.List;
+import java.util.Map;
 import java.util.Properties;
 import java.util.function.Function;
 import org.apache.hadoop.conf.Configuration;
@@ -32,6 +33,7 @@ import org.apache.iceberg.ManageSnapshots;
 import org.apache.iceberg.PartitionSpec;
 import org.apache.iceberg.Schema;
 import org.apache.iceberg.Table;
+import org.apache.iceberg.TableProperties;
 import org.apache.iceberg.UpdatePartitionSpec;
 import org.apache.iceberg.catalog.TableIdentifier;
 import org.apache.iceberg.expressions.Expressions;
@@ -258,4 +260,9 @@ public class IcebergTableUtil {
     LOG.debug("Cherry-Picking {} to {}", snapshotId, table.name());
     table.manageSnapshots().cherrypick(snapshotId).commit();
   }
+
+  public static boolean isV2Table(Map<String, String> props) {
+    return props != null &&
+        "2".equals(props.get(TableProperties.FORMAT_VERSION));
+  }
 }
diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergStorageHandlerNoScan.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergStorageHandlerNoScan.java
index 933bd8ce67e..225aefb9250 100644
--- a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergStorageHandlerNoScan.java
+++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergStorageHandlerNoScan.java
@@ -1469,8 +1469,7 @@ public class TestHiveIcebergStorageHandlerNoScan {
         spec, FileFormat.PARQUET, ImmutableList.of());
 
     String[] commands = {
-        "DESCRIBE target PARTITION (last_name='Johnson')",
-        "TRUNCATE target PARTITION (last_name='Johnson')"
+        "DESCRIBE target PARTITION (last_name='Johnson')"
     };
 
     for (String command : commands) {
diff --git a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergTruncateTable.java b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergTruncateTable.java
index e63ab78db0b..ae7fe59ec6e 100644
--- a/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergTruncateTable.java
+++ b/iceberg/iceberg-handler/src/test/java/org/apache/iceberg/mr/hive/TestHiveIcebergTruncateTable.java
@@ -128,7 +128,8 @@ public class TestHiveIcebergTruncateTable extends HiveIcebergStorageHandlerWithE
   }
 
   @Test
-  public void testTruncateTableWithPartitionSpec() throws IOException, TException, InterruptedException {
+  public void testTruncateTableWithPartitionSpecOnUnpartitionedTable() throws IOException, TException,
+      InterruptedException {
     // Create an Iceberg table with some record and try to run a truncate table command with partition
     // spec. The command should fail as the table is unpartitioned in Hive. Then check if the
     // initial data and the table statistics are not changed.
@@ -141,8 +142,7 @@ public class TestHiveIcebergTruncateTable extends HiveIcebergStorageHandlerWithE
     shell.executeStatement("ANALYZE TABLE " + identifier + " COMPUTE STATISTICS");
 
     AssertHelpers.assertThrows("should throw exception", IllegalArgumentException.class,
-        "Using partition spec in query is unsupported for non-native table backed by: " +
-            "org.apache.iceberg.mr.hive.HiveIcebergStorageHandler",
+        "Writing data into a partition fails when the Iceberg table is unpartitioned.",
         () -> {
           shell.executeStatement("TRUNCATE " + identifier + " PARTITION (customer_id=1)");
         });
@@ -155,7 +155,35 @@ public class TestHiveIcebergTruncateTable extends HiveIcebergStorageHandlerWithE
   }
 
   @Test
-  public void testTruncateTablePartitionedIcebergTable() throws IOException, TException, InterruptedException {
+  public void testTruncateTableWithPartitionSpecOnPartitionedTable() throws IOException, TException,
+      InterruptedException {
+    // Create an Iceberg table with some record and try to run a truncate table command with partition
+    // spec. The command should fail as the table is unpartitioned in Hive. Then check if the
+    // initial data and the table statistics are not changed.
+    String databaseName = "default";
+    String tableName = "customers";
+    TableIdentifier identifier = TableIdentifier.of(databaseName, tableName);
+    PartitionSpec spec =
+        PartitionSpec.builderFor(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA).identity("customer_id").build();
+    testTables.createTable(shell, tableName, HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA,
+        spec, fileFormat, HiveIcebergStorageHandlerTestUtils.CUSTOMER_RECORDS);
+    shell.executeStatement("ALTER TABLE " + identifier + " SET TBLPROPERTIES('external.table.purge'='true')");
+    shell.executeStatement("ANALYZE TABLE " + identifier + " COMPUTE STATISTICS");
+
+    shell.executeStatement("TRUNCATE " + identifier + " PARTITION (customer_id=1)");
+
+    List<Object[]> rows = shell.executeStatement("SELECT * FROM " + identifier);
+    List<Record> truncatedRecords = TestHelper.RecordsBuilder
+        .newInstance(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA)
+        .add(0L, "Alice", "Brown")
+        .add(2L, "Trudy", "Pink")
+        .build();
+    HiveIcebergTestUtils.validateData(truncatedRecords,
+        HiveIcebergTestUtils.valueForRow(HiveIcebergStorageHandlerTestUtils.CUSTOMER_SCHEMA, rows), 0);
+  }
+
+  @Test
+  public void testTruncateTablePartitionedIcebergTable() throws TException, InterruptedException {
     // Create a partitioned Iceberg table with some initial data and run a truncate table command on this table.
     // Then check if the data is deleted and the table statistics are reset to 0.
     String databaseName = "default";
diff --git a/iceberg/iceberg-handler/src/test/queries/negative/truncate_iceberg_table_with_partition_spec.q b/iceberg/iceberg-handler/src/test/queries/negative/truncate_iceberg_table_with_partition_spec.q
index 4eda745020f..5ca91095d96 100644
--- a/iceberg/iceberg-handler/src/test/queries/negative/truncate_iceberg_table_with_partition_spec.q
+++ b/iceberg/iceberg-handler/src/test/queries/negative/truncate_iceberg_table_with_partition_spec.q
@@ -1,5 +1,6 @@
 set hive.vectorized.execution.enabled=false;
 
+-- Truncate table on an unpartitioned table must result in an exception.
 drop table if exists test_truncate_neg2;
 create external table test_truncate_neg2 (id int, value string) stored by iceberg stored as orc;
 alter table test_truncate_neg2 set tblproperties('external.table.purge'='true');
diff --git a/iceberg/iceberg-handler/src/test/queries/negative/truncate_table_partition_spec_with_part_evolution.q b/iceberg/iceberg-handler/src/test/queries/negative/truncate_table_partition_spec_with_part_evolution.q
new file mode 100644
index 00000000000..3ed5d3d9308
--- /dev/null
+++ b/iceberg/iceberg-handler/src/test/queries/negative/truncate_table_partition_spec_with_part_evolution.q
@@ -0,0 +1,6 @@
+-- Truncate table on an partitioned Iceberg V1 table with partition evolution must result in an exception since deletes are not possible on Iceberg V1 table.
+create external table test_truncate_part_evolution (id int, value string) stored by iceberg stored as orc;
+insert into test_truncate_part_evolution values (1, 'one'),(2,'two'),(3,'three'),(4,'four'),(5,'five');
+alter table test_truncate_part_evolution set partition spec(id);
+alter table test_truncate_part_evolution set tblproperties('external.table.purge'='true');
+truncate test_truncate_part_evolution partition(id=1);
diff --git a/iceberg/iceberg-handler/src/test/queries/positive/iceberg_truncate_partition.q b/iceberg/iceberg-handler/src/test/queries/positive/iceberg_truncate_partition.q
new file mode 100644
index 00000000000..c8beba744cb
--- /dev/null
+++ b/iceberg/iceberg-handler/src/test/queries/positive/iceberg_truncate_partition.q
@@ -0,0 +1,152 @@
+-- SORT_QUERY_RESULTS
+create external table ice_parquet_str_date (
+  strcol string,
+  intcol integer,
+  pcol string,
+  datecol date
+) partitioned by spec (pcol, datecol)
+stored by iceberg;
+
+insert into ice_parquet_str_date values ('str', 1, 'xya', '2027-01-20');
+insert into ice_parquet_str_date values ('str', 1, 'xyz', '2026-07-19');
+insert into ice_parquet_str_date values ('str', 1, 'xyb', '2025-07-18');
+insert into ice_parquet_str_date values ('str', 1, 'yzb', '2022-02-07');
+insert into ice_parquet_str_date values ('str', 1, 'yab', '2023-07-26');
+insert into ice_parquet_str_date values ('str', 1, 'yzb', '2023-07-26');
+insert into ice_parquet_str_date values ('str', 1, 'xyz', '2022-02-07');
+insert into ice_parquet_str_date values ('str', 1, 'abc', '2019-02-07');
+insert into ice_parquet_str_date values ('str', 1, 'a"ab', '2019-02-07');
+insert into ice_parquet_str_date values ('str', 1, "a'ab", '2019-02-07');
+
+select `partition` from default.ice_parquet_str_date.partitions;
+truncate table ice_parquet_str_date partition (datecol = '2022-02-07');
+select `partition` from default.ice_parquet_str_date.partitions;
+truncate table ice_parquet_str_date partition (pcol = 'yzb', datecol = '2023-07-26');
+select `partition` from default.ice_parquet_str_date.partitions;
+truncate table ice_parquet_str_date partition (pcol = 'xyz');
+truncate table ice_parquet_str_date partition (pcol = 'a"ab');
+truncate table ice_parquet_str_date partition (pcol = "a'ab");
+
+select * from ice_parquet_str_date;
+
+create external table ice_parquet_str_int (
+  strcol string,
+  intcol integer,
+  pcol integer
+) partitioned by spec (strcol, pcol)
+stored by iceberg;
+
+insert into ice_parquet_str_int values ('str', 1, 14);
+insert into ice_parquet_str_int values ('str', 1, 16);
+insert into ice_parquet_str_int values ('str', 1, 15);
+insert into ice_parquet_str_int values ('str', 1, 17);
+insert into ice_parquet_str_int values ('abc', 1, 18);
+insert into ice_parquet_str_int values ('def', 1, 18);
+
+select * from ice_parquet_str_int;
+select `partition` from default.ice_parquet_str_int.partitions;
+truncate table ice_parquet_str_int partition (pcol = 18);
+select `partition` from default.ice_parquet_str_int.partitions;
+
+create external table ice_parquet_int (
+  strcol string,
+  intcol integer,
+  pcol integer
+) partitioned by spec (pcol)
+stored by iceberg;
+
+insert into ice_parquet_int values ('str', 1, 14);
+insert into ice_parquet_int values ('str', 1, 14);
+insert into ice_parquet_int values ('str', 1, 14);
+insert into ice_parquet_int values ('str', 1, 15);
+insert into ice_parquet_int values ('abc', 1, 15);
+insert into ice_parquet_int values ('def', 1, 15);
+
+select * from ice_parquet_int;
+select `partition` from default.ice_parquet_int.partitions;
+truncate table ice_parquet_int partition (pcol = 14);
+select `partition` from default.ice_parquet_int.partitions;
+
+create external table ice_parquet_bigint (
+  strcol string,
+  intcol integer,
+  pcol bigint
+) partitioned by spec (pcol)
+stored by iceberg;
+
+insert into ice_parquet_bigint values ('str', 1, 144565734992765839);
+insert into ice_parquet_bigint values ('str', 1, 144565734992765839);
+insert into ice_parquet_bigint values ('str', 1, 144565734992765839);
+insert into ice_parquet_bigint values ('str', 1, 144565734992765839);
+insert into ice_parquet_bigint values ('abc', 1, 2345578903479709);
+insert into ice_parquet_bigint values ('def', 1, 2345578903479709);
+
+select * from ice_parquet_bigint;
+select `partition` from default.ice_parquet_bigint.partitions;
+truncate table ice_parquet_bigint partition (pcol = 2345578903479709);
+select `partition` from default.ice_parquet_bigint.partitions;
+
+create external table ice_parquet_str (
+  strcol string,
+  intcol integer,
+  pcol string
+) partitioned by spec (pcol)
+stored by iceberg;
+
+insert into ice_parquet_str values ('str', 1, 'ghutihkklfng');
+insert into ice_parquet_str values ('str', 1, 'ghutihkklfng');
+insert into ice_parquet_str values ('str', 1, 'iyoorpiyujn');
+insert into ice_parquet_str values ('str', 1, 'iyoorpiyujn');
+insert into ice_parquet_str values ('abc', 1, 'ghutihkklfng');
+insert into ice_parquet_str values ('def', 1, 'iyoorpiyujn');
+
+select * from ice_parquet_str;
+select `partition` from default.ice_parquet_str.partitions;
+truncate table ice_parquet_str partition (pcol = 'ghutihkklfng');
+select `partition` from default.ice_parquet_str.partitions;
+
+create external table ice_parquet_date (
+  strcol string,
+  intcol integer,
+  pcol date
+) partitioned by spec (pcol)
+stored by iceberg;
+
+insert into ice_parquet_date values ('str', 1, '2022-01-01');
+insert into ice_parquet_date values ('str', 1, '2022-02-02');
+insert into ice_parquet_date values ('str', 1, '2022-03-03');
+insert into ice_parquet_date values ('str', 1, '2022-01-01');
+insert into ice_parquet_date values ('abc', 1, '2022-02-02');
+insert into ice_parquet_date values ('def', 1, '2022-03-03');
+
+select * from ice_parquet_date;
+select `partition` from default.ice_parquet_date.partitions;
+truncate table ice_parquet_date partition (pcol = '2022-02-02');
+select `partition` from default.ice_parquet_date.partitions;
+
+create external table ice_parquet_double (
+  strcol string,
+  intcol integer,
+  pcol double
+) partitioned by spec (pcol)
+stored by iceberg;
+
+insert into ice_parquet_double values ('str', 1, '2.45');
+insert into ice_parquet_double values ('str', 1, '3.1567');
+insert into ice_parquet_double values ('str', 1, '2.45');
+insert into ice_parquet_double values ('str', 1, '3.1567');
+insert into ice_parquet_double values ('abc', 1, '2.45');
+insert into ice_parquet_double values ('def', 1, '3.1567');
+
+select * from ice_parquet_double;
+select `partition` from default.ice_parquet_double.partitions;
+truncate table ice_parquet_double partition (pcol = '2.45');
+select `partition` from default.ice_parquet_double.partitions;
+
+drop table ice_parquet_str_date;
+drop table ice_parquet_str_int;
+drop table ice_parquet_int;
+drop table ice_parquet_bigint;
+drop table ice_parquet_str;
+drop table ice_parquet_date;
+drop table ice_parquet_double;
diff --git a/iceberg/iceberg-handler/src/test/queries/positive/iceberg_truncate_partition_with_evolution.q b/iceberg/iceberg-handler/src/test/queries/positive/iceberg_truncate_partition_with_evolution.q
new file mode 100644
index 00000000000..0f3a7524b91
--- /dev/null
+++ b/iceberg/iceberg-handler/src/test/queries/positive/iceberg_truncate_partition_with_evolution.q
@@ -0,0 +1,114 @@
+-- SORT_QUERY_RESULTS
+set hive.explain.user=false;
+create table test_ice_int (a int, b string) stored by iceberg stored as orc tblproperties ('format-version'='2');
+insert into test_ice_int values (11, 'ddd'), (22, 'eefe');
+alter table test_ice_int set partition spec(a);
+insert into test_ice_int values (33, 'rrfdfdf');
+insert into table test_ice_int select * from test_ice_int;
+
+select * from test_ice_int;
+select `partition` from default.test_ice_int.partitions;
+explain truncate table test_ice_int partition (a = 22);
+truncate table test_ice_int partition (a = 22);
+select * from test_ice_int;
+select `partition` from default.test_ice_int.partitions;
+explain truncate table test_ice_int partition (a = 33);
+truncate table test_ice_int partition (a = 33);
+select * from test_ice_int;
+select `partition` from default.test_ice_int.partitions;
+
+create table test_ice_bigint (a bigint, b string) stored by iceberg stored as orc tblproperties ('format-version'='2');
+insert into test_ice_bigint values (115674892756, 'ddd'), (226784902765739, 'eefe');
+alter table test_ice_bigint set partition spec(a);
+insert into test_ice_bigint values (3367849937755673, 'rrfdfdf');
+insert into table test_ice_bigint select * from test_ice_bigint;
+
+select * from test_ice_bigint;
+select `partition` from default.test_ice_bigint.partitions;
+explain truncate table test_ice_bigint partition (a = 226784902765739);
+truncate table test_ice_bigint partition (a = 226784902765739);
+select * from test_ice_bigint;
+select `partition` from default.test_ice_bigint.partitions;
+explain truncate table test_ice_bigint partition (a = 3367849937755673);
+truncate table test_ice_bigint partition (a = 3367849937755673);
+select * from test_ice_bigint;
+select `partition` from default.test_ice_bigint.partitions;
+
+create table test_ice_str (a bigint, b string) stored by iceberg stored as orc tblproperties ('format-version'='2');
+insert into test_ice_str values (115674892756, 'ddd'), (2267849027657399057, 'eefe');
+insert into test_ice_str values (115674892756, 'a"ab'), (2267849027657399057, 'eefe');
+insert into test_ice_str values (115674892756, "a'ab"), (2267849027657399057, "eefe");
+alter table test_ice_str set partition spec(b);
+insert into test_ice_str values (33678499377556738, 'rrfdfdf');
+insert into table test_ice_str select * from test_ice_str;
+
+select * from test_ice_str;
+select `partition` from default.test_ice_str.partitions;
+explain truncate table test_ice_str partition (b = 'ddd');
+truncate table test_ice_str partition (b = 'ddd');
+select * from test_ice_str;
+select `partition` from default.test_ice_str.partitions;
+explain truncate table test_ice_str partition (b = 'rrfdfdf');
+truncate table test_ice_str partition (b = 'rrfdfdf');
+select * from test_ice_str;
+select `partition` from default.test_ice_str.partitions;
+truncate table test_ice_str partition (b = 'a"ab');
+truncate table test_ice_str partition (b = "a'ab");
+select * from test_ice_str;
+select `partition` from default.test_ice_str.partitions;
+
+create table test_ice_date (a bigint, b date) stored by iceberg stored as orc tblproperties ('format-version'='2');
+insert into test_ice_date values (115674892756, '2022-02-07'), (2267849027657399057, '2022-08-07');
+alter table test_ice_date set partition spec(b);
+insert into test_ice_date values (33678499377556738, '2022-08-09');
+
+select * from test_ice_date;
+select `partition` from default.test_ice_date.partitions;
+explain truncate table test_ice_date partition (b = '2022-02-07');
+truncate table test_ice_date partition (b = '2022-02-07');
+select * from test_ice_date;
+select `partition` from default.test_ice_date.partitions;
+explain truncate table test_ice_date partition (b = '2022-08-09');
+truncate table test_ice_date partition (b = '2022-08-09');
+select * from test_ice_date;
+select `partition` from default.test_ice_date.partitions;
+
+create table test_ice_double (a double, b date) stored by iceberg stored as orc tblproperties ('format-version'='2');
+insert into test_ice_double values (115674892756.67590946, '2022-02-07'), (2267849027.657399057, '2022-08-07');
+alter table test_ice_double set partition spec(a);
+insert into test_ice_double values (33678499.377556738, '2022-08-09');
+insert into table test_ice_double select * from test_ice_double;
+
+select * from test_ice_double;
+select `partition` from default.test_ice_double.partitions;
+explain truncate table test_ice_double partition (a = 115674892756.67590946);
+truncate table test_ice_double partition (a = 115674892756.67590946);
+select * from test_ice_double;
+select `partition` from default.test_ice_double.partitions;
+explain truncate table test_ice_double partition (a = 33678499.377556738);
+truncate table test_ice_double partition (a = 33678499.377556738);
+select * from test_ice_double;
+select `partition` from default.test_ice_double.partitions;
+
+create table test_ice_double_date (a double, b date) stored by iceberg stored as orc tblproperties ('format-version'='2');
+insert into test_ice_double_date values (115674892756.67590946, '2022-02-07'), (2267849027.657399057, '2022-08-07');
+alter table test_ice_double_date set partition spec(a, b);
+insert into test_ice_double_date values (33678499.377556738, '2022-08-09');
+
+select * from test_ice_double_date;
+select `partition` from default.test_ice_double_date.partitions;
+explain truncate table test_ice_double_date partition (a = 115674892756.67590946, b = '2022-02-07');
+truncate table test_ice_double_date partition (a = 115674892756.67590946, b = '2022-02-07');
+select * from test_ice_double_date;
+select `partition` from default.test_ice_double_date.partitions;
+explain truncate table test_ice_double_date partition (a = 33678499.377556738, b = '2022-08-09');
+truncate table test_ice_double_date partition (a = 33678499.377556738, b = '2022-08-09');
+select * from test_ice_double_date;
+select `partition` from default.test_ice_double_date.partitions;
+
+drop table test_ice_int;
+drop table test_ice_bigint;
+drop table test_ice_str;
+drop table test_ice_date;
+drop table test_ice_double;
+drop table test_ice_double_date;
diff --git a/iceberg/iceberg-handler/src/test/results/negative/truncate_iceberg_table_with_partition_spec.q.out b/iceberg/iceberg-handler/src/test/results/negative/truncate_iceberg_table_with_partition_spec.q.out
index 929fdbcb37f..3b1c208a4e3 100644
--- a/iceberg/iceberg-handler/src/test/results/negative/truncate_iceberg_table_with_partition_spec.q.out
+++ b/iceberg/iceberg-handler/src/test/results/negative/truncate_iceberg_table_with_partition_spec.q.out
@@ -28,4 +28,4 @@ POSTHOOK: query: insert into test_truncate_neg2 values (1, 'one'),(2,'two'),(3,'
 POSTHOOK: type: QUERY
 POSTHOOK: Input: _dummy_database@_dummy_table
 POSTHOOK: Output: default@test_truncate_neg2
-FAILED: UnsupportedOperationException Using partition spec in query is unsupported for non-native table backed by: org.apache.iceberg.mr.hive.HiveIcebergStorageHandler
+FAILED: SemanticException Writing data into a partition fails when the Iceberg table is unpartitioned.
diff --git a/iceberg/iceberg-handler/src/test/results/negative/truncate_table_partition_spec_with_part_evolution.q.out b/iceberg/iceberg-handler/src/test/results/negative/truncate_table_partition_spec_with_part_evolution.q.out
new file mode 100644
index 00000000000..a89f81c1e7b
--- /dev/null
+++ b/iceberg/iceberg-handler/src/test/results/negative/truncate_table_partition_spec_with_part_evolution.q.out
@@ -0,0 +1,32 @@
+PREHOOK: query: create external table test_truncate_part_evolution (id int, value string) stored by iceberg stored as orc
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_truncate_part_evolution
+POSTHOOK: query: create external table test_truncate_part_evolution (id int, value string) stored by iceberg stored as orc
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_truncate_part_evolution
+PREHOOK: query: insert into test_truncate_part_evolution values (1, 'one'),(2,'two'),(3,'three'),(4,'four'),(5,'five')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_truncate_part_evolution
+POSTHOOK: query: insert into test_truncate_part_evolution values (1, 'one'),(2,'two'),(3,'three'),(4,'four'),(5,'five')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_truncate_part_evolution
+PREHOOK: query: alter table test_truncate_part_evolution set partition spec(id)
+PREHOOK: type: ALTERTABLE_SETPARTSPEC
+PREHOOK: Input: default@test_truncate_part_evolution
+POSTHOOK: query: alter table test_truncate_part_evolution set partition spec(id)
+POSTHOOK: type: ALTERTABLE_SETPARTSPEC
+POSTHOOK: Input: default@test_truncate_part_evolution
+POSTHOOK: Output: default@test_truncate_part_evolution
+PREHOOK: query: alter table test_truncate_part_evolution set tblproperties('external.table.purge'='true')
+PREHOOK: type: ALTERTABLE_PROPERTIES
+PREHOOK: Input: default@test_truncate_part_evolution
+PREHOOK: Output: default@test_truncate_part_evolution
+POSTHOOK: query: alter table test_truncate_part_evolution set tblproperties('external.table.purge'='true')
+POSTHOOK: type: ALTERTABLE_PROPERTIES
+POSTHOOK: Input: default@test_truncate_part_evolution
+POSTHOOK: Output: default@test_truncate_part_evolution
+FAILED: SemanticException Truncate conversion to delete is not possible since its not an Iceberg V2 table. Consider converting the table to Iceberg's V2 format specification.
diff --git a/iceberg/iceberg-handler/src/test/results/positive/iceberg_truncate_partition.q.out b/iceberg/iceberg-handler/src/test/results/positive/iceberg_truncate_partition.q.out
new file mode 100644
index 00000000000..cb136afa846
--- /dev/null
+++ b/iceberg/iceberg-handler/src/test/results/positive/iceberg_truncate_partition.q.out
@@ -0,0 +1,900 @@
+PREHOOK: query: create external table ice_parquet_str_date (
+  strcol string,
+  intcol integer,
+  pcol string,
+  datecol date
+) partitioned by spec (pcol, datecol)
+stored by iceberg
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_str_date
+POSTHOOK: query: create external table ice_parquet_str_date (
+  strcol string,
+  intcol integer,
+  pcol string,
+  datecol date
+) partitioned by spec (pcol, datecol)
+stored by iceberg
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_str_date
+PREHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'xya', '2027-01-20')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_date
+POSTHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'xya', '2027-01-20')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_date
+PREHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'xyz', '2026-07-19')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_date
+POSTHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'xyz', '2026-07-19')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_date
+PREHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'xyb', '2025-07-18')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_date
+POSTHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'xyb', '2025-07-18')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_date
+PREHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'yzb', '2022-02-07')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_date
+POSTHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'yzb', '2022-02-07')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_date
+PREHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'yab', '2023-07-26')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_date
+POSTHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'yab', '2023-07-26')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_date
+PREHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'yzb', '2023-07-26')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_date
+POSTHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'yzb', '2023-07-26')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_date
+PREHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'xyz', '2022-02-07')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_date
+POSTHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'xyz', '2022-02-07')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_date
+PREHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'abc', '2019-02-07')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_date
+POSTHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'abc', '2019-02-07')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_date
+PREHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'a"ab', '2019-02-07')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_date
+POSTHOOK: query: insert into ice_parquet_str_date values ('str', 1, 'a"ab', '2019-02-07')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_date
+PREHOOK: query: insert into ice_parquet_str_date values ('str', 1, "a'ab", '2019-02-07')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_date
+POSTHOOK: query: insert into ice_parquet_str_date values ('str', 1, "a'ab", '2019-02-07')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_date
+PREHOOK: query: select `partition` from default.ice_parquet_str_date.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_str_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_str_date.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_str_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":"a'ab","datecol":"2019-02-07"}
+{"pcol":"a\"ab","datecol":"2019-02-07"}
+{"pcol":"abc","datecol":"2019-02-07"}
+{"pcol":"xya","datecol":"2027-01-20"}
+{"pcol":"xyb","datecol":"2025-07-18"}
+{"pcol":"xyz","datecol":"2022-02-07"}
+{"pcol":"xyz","datecol":"2026-07-19"}
+{"pcol":"yab","datecol":"2023-07-26"}
+{"pcol":"yzb","datecol":"2022-02-07"}
+{"pcol":"yzb","datecol":"2023-07-26"}
+PREHOOK: query: truncate table ice_parquet_str_date partition (datecol = '2022-02-07')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@ice_parquet_str_date@datecol=2022-02-07
+POSTHOOK: query: truncate table ice_parquet_str_date partition (datecol = '2022-02-07')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@ice_parquet_str_date@datecol=2022-02-07
+PREHOOK: query: select `partition` from default.ice_parquet_str_date.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_str_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_str_date.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_str_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":"a'ab","datecol":"2019-02-07"}
+{"pcol":"a\"ab","datecol":"2019-02-07"}
+{"pcol":"abc","datecol":"2019-02-07"}
+{"pcol":"xya","datecol":"2027-01-20"}
+{"pcol":"xyb","datecol":"2025-07-18"}
+{"pcol":"xyz","datecol":"2026-07-19"}
+{"pcol":"yab","datecol":"2023-07-26"}
+{"pcol":"yzb","datecol":"2023-07-26"}
+PREHOOK: query: truncate table ice_parquet_str_date partition (pcol = 'yzb', datecol = '2023-07-26')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@ice_parquet_str_date@pcol=yzb/datecol=2023-07-26
+POSTHOOK: query: truncate table ice_parquet_str_date partition (pcol = 'yzb', datecol = '2023-07-26')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@ice_parquet_str_date@pcol=yzb/datecol=2023-07-26
+PREHOOK: query: select `partition` from default.ice_parquet_str_date.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_str_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_str_date.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_str_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":"a'ab","datecol":"2019-02-07"}
+{"pcol":"a\"ab","datecol":"2019-02-07"}
+{"pcol":"abc","datecol":"2019-02-07"}
+{"pcol":"xya","datecol":"2027-01-20"}
+{"pcol":"xyb","datecol":"2025-07-18"}
+{"pcol":"xyz","datecol":"2026-07-19"}
+{"pcol":"yab","datecol":"2023-07-26"}
+PREHOOK: query: truncate table ice_parquet_str_date partition (pcol = 'xyz')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@ice_parquet_str_date@pcol=xyz
+POSTHOOK: query: truncate table ice_parquet_str_date partition (pcol = 'xyz')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@ice_parquet_str_date@pcol=xyz
+PREHOOK: query: truncate table ice_parquet_str_date partition (pcol = 'a"ab')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@ice_parquet_str_date@pcol=a%22ab
+POSTHOOK: query: truncate table ice_parquet_str_date partition (pcol = 'a"ab')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@ice_parquet_str_date@pcol=a%22ab
+PREHOOK: query: truncate table ice_parquet_str_date partition (pcol = "a'ab")
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@ice_parquet_str_date@pcol=a%27ab
+POSTHOOK: query: truncate table ice_parquet_str_date partition (pcol = "a'ab")
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@ice_parquet_str_date@pcol=a%27ab
+PREHOOK: query: select * from ice_parquet_str_date
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_str_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from ice_parquet_str_date
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_str_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+str	1	abc	2019-02-07
+str	1	xya	2027-01-20
+str	1	xyb	2025-07-18
+str	1	yab	2023-07-26
+PREHOOK: query: create external table ice_parquet_str_int (
+  strcol string,
+  intcol integer,
+  pcol integer
+) partitioned by spec (strcol, pcol)
+stored by iceberg
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_str_int
+POSTHOOK: query: create external table ice_parquet_str_int (
+  strcol string,
+  intcol integer,
+  pcol integer
+) partitioned by spec (strcol, pcol)
+stored by iceberg
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_str_int
+PREHOOK: query: insert into ice_parquet_str_int values ('str', 1, 14)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_int
+POSTHOOK: query: insert into ice_parquet_str_int values ('str', 1, 14)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_int
+PREHOOK: query: insert into ice_parquet_str_int values ('str', 1, 16)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_int
+POSTHOOK: query: insert into ice_parquet_str_int values ('str', 1, 16)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_int
+PREHOOK: query: insert into ice_parquet_str_int values ('str', 1, 15)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_int
+POSTHOOK: query: insert into ice_parquet_str_int values ('str', 1, 15)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_int
+PREHOOK: query: insert into ice_parquet_str_int values ('str', 1, 17)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_int
+POSTHOOK: query: insert into ice_parquet_str_int values ('str', 1, 17)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_int
+PREHOOK: query: insert into ice_parquet_str_int values ('abc', 1, 18)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_int
+POSTHOOK: query: insert into ice_parquet_str_int values ('abc', 1, 18)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_int
+PREHOOK: query: insert into ice_parquet_str_int values ('def', 1, 18)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str_int
+POSTHOOK: query: insert into ice_parquet_str_int values ('def', 1, 18)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str_int
+PREHOOK: query: select * from ice_parquet_str_int
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_str_int
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from ice_parquet_str_int
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_str_int
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+abc	1	18
+def	1	18
+str	1	14
+str	1	15
+str	1	16
+str	1	17
+PREHOOK: query: select `partition` from default.ice_parquet_str_int.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_str_int
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_str_int.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_str_int
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"strcol":"abc","pcol":18}
+{"strcol":"def","pcol":18}
+{"strcol":"str","pcol":14}
+{"strcol":"str","pcol":15}
+{"strcol":"str","pcol":16}
+{"strcol":"str","pcol":17}
+PREHOOK: query: truncate table ice_parquet_str_int partition (pcol = 18)
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@ice_parquet_str_int@pcol=18
+POSTHOOK: query: truncate table ice_parquet_str_int partition (pcol = 18)
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@ice_parquet_str_int@pcol=18
+PREHOOK: query: select `partition` from default.ice_parquet_str_int.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_str_int
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_str_int.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_str_int
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"strcol":"str","pcol":14}
+{"strcol":"str","pcol":15}
+{"strcol":"str","pcol":16}
+{"strcol":"str","pcol":17}
+PREHOOK: query: create external table ice_parquet_int (
+  strcol string,
+  intcol integer,
+  pcol integer
+) partitioned by spec (pcol)
+stored by iceberg
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_int
+POSTHOOK: query: create external table ice_parquet_int (
+  strcol string,
+  intcol integer,
+  pcol integer
+) partitioned by spec (pcol)
+stored by iceberg
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_int
+PREHOOK: query: insert into ice_parquet_int values ('str', 1, 14)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_int
+POSTHOOK: query: insert into ice_parquet_int values ('str', 1, 14)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_int
+PREHOOK: query: insert into ice_parquet_int values ('str', 1, 14)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_int
+POSTHOOK: query: insert into ice_parquet_int values ('str', 1, 14)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_int
+PREHOOK: query: insert into ice_parquet_int values ('str', 1, 14)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_int
+POSTHOOK: query: insert into ice_parquet_int values ('str', 1, 14)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_int
+PREHOOK: query: insert into ice_parquet_int values ('str', 1, 15)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_int
+POSTHOOK: query: insert into ice_parquet_int values ('str', 1, 15)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_int
+PREHOOK: query: insert into ice_parquet_int values ('abc', 1, 15)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_int
+POSTHOOK: query: insert into ice_parquet_int values ('abc', 1, 15)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_int
+PREHOOK: query: insert into ice_parquet_int values ('def', 1, 15)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_int
+POSTHOOK: query: insert into ice_parquet_int values ('def', 1, 15)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_int
+PREHOOK: query: select * from ice_parquet_int
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_int
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from ice_parquet_int
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_int
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+abc	1	15
+def	1	15
+str	1	14
+str	1	14
+str	1	14
+str	1	15
+PREHOOK: query: select `partition` from default.ice_parquet_int.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_int
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_int.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_int
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":14}
+{"pcol":15}
+PREHOOK: query: truncate table ice_parquet_int partition (pcol = 14)
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@ice_parquet_int@pcol=14
+POSTHOOK: query: truncate table ice_parquet_int partition (pcol = 14)
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@ice_parquet_int@pcol=14
+PREHOOK: query: select `partition` from default.ice_parquet_int.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_int
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_int.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_int
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":15}
+PREHOOK: query: create external table ice_parquet_bigint (
+  strcol string,
+  intcol integer,
+  pcol bigint
+) partitioned by spec (pcol)
+stored by iceberg
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_bigint
+POSTHOOK: query: create external table ice_parquet_bigint (
+  strcol string,
+  intcol integer,
+  pcol bigint
+) partitioned by spec (pcol)
+stored by iceberg
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_bigint
+PREHOOK: query: insert into ice_parquet_bigint values ('str', 1, 144565734992765839)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_bigint
+POSTHOOK: query: insert into ice_parquet_bigint values ('str', 1, 144565734992765839)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_bigint
+PREHOOK: query: insert into ice_parquet_bigint values ('str', 1, 144565734992765839)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_bigint
+POSTHOOK: query: insert into ice_parquet_bigint values ('str', 1, 144565734992765839)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_bigint
+PREHOOK: query: insert into ice_parquet_bigint values ('str', 1, 144565734992765839)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_bigint
+POSTHOOK: query: insert into ice_parquet_bigint values ('str', 1, 144565734992765839)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_bigint
+PREHOOK: query: insert into ice_parquet_bigint values ('str', 1, 144565734992765839)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_bigint
+POSTHOOK: query: insert into ice_parquet_bigint values ('str', 1, 144565734992765839)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_bigint
+PREHOOK: query: insert into ice_parquet_bigint values ('abc', 1, 2345578903479709)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_bigint
+POSTHOOK: query: insert into ice_parquet_bigint values ('abc', 1, 2345578903479709)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_bigint
+PREHOOK: query: insert into ice_parquet_bigint values ('def', 1, 2345578903479709)
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_bigint
+POSTHOOK: query: insert into ice_parquet_bigint values ('def', 1, 2345578903479709)
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_bigint
+PREHOOK: query: select * from ice_parquet_bigint
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_bigint
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from ice_parquet_bigint
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_bigint
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+abc	1	2345578903479709
+def	1	2345578903479709
+str	1	144565734992765839
+str	1	144565734992765839
+str	1	144565734992765839
+str	1	144565734992765839
+PREHOOK: query: select `partition` from default.ice_parquet_bigint.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_bigint
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_bigint.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_bigint
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":144565734992765839}
+{"pcol":2345578903479709}
+PREHOOK: query: truncate table ice_parquet_bigint partition (pcol = 2345578903479709)
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@ice_parquet_bigint@pcol=2345578903479709
+POSTHOOK: query: truncate table ice_parquet_bigint partition (pcol = 2345578903479709)
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@ice_parquet_bigint@pcol=2345578903479709
+PREHOOK: query: select `partition` from default.ice_parquet_bigint.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_bigint
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_bigint.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_bigint
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":144565734992765839}
+PREHOOK: query: create external table ice_parquet_str (
+  strcol string,
+  intcol integer,
+  pcol string
+) partitioned by spec (pcol)
+stored by iceberg
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_str
+POSTHOOK: query: create external table ice_parquet_str (
+  strcol string,
+  intcol integer,
+  pcol string
+) partitioned by spec (pcol)
+stored by iceberg
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_str
+PREHOOK: query: insert into ice_parquet_str values ('str', 1, 'ghutihkklfng')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str
+POSTHOOK: query: insert into ice_parquet_str values ('str', 1, 'ghutihkklfng')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str
+PREHOOK: query: insert into ice_parquet_str values ('str', 1, 'ghutihkklfng')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str
+POSTHOOK: query: insert into ice_parquet_str values ('str', 1, 'ghutihkklfng')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str
+PREHOOK: query: insert into ice_parquet_str values ('str', 1, 'iyoorpiyujn')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str
+POSTHOOK: query: insert into ice_parquet_str values ('str', 1, 'iyoorpiyujn')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str
+PREHOOK: query: insert into ice_parquet_str values ('str', 1, 'iyoorpiyujn')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str
+POSTHOOK: query: insert into ice_parquet_str values ('str', 1, 'iyoorpiyujn')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str
+PREHOOK: query: insert into ice_parquet_str values ('abc', 1, 'ghutihkklfng')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str
+POSTHOOK: query: insert into ice_parquet_str values ('abc', 1, 'ghutihkklfng')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str
+PREHOOK: query: insert into ice_parquet_str values ('def', 1, 'iyoorpiyujn')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_str
+POSTHOOK: query: insert into ice_parquet_str values ('def', 1, 'iyoorpiyujn')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_str
+PREHOOK: query: select * from ice_parquet_str
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_str
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from ice_parquet_str
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_str
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+abc	1	ghutihkklfng
+def	1	iyoorpiyujn
+str	1	ghutihkklfng
+str	1	ghutihkklfng
+str	1	iyoorpiyujn
+str	1	iyoorpiyujn
+PREHOOK: query: select `partition` from default.ice_parquet_str.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_str
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_str.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_str
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":"ghutihkklfng"}
+{"pcol":"iyoorpiyujn"}
+PREHOOK: query: truncate table ice_parquet_str partition (pcol = 'ghutihkklfng')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@ice_parquet_str@pcol=ghutihkklfng
+POSTHOOK: query: truncate table ice_parquet_str partition (pcol = 'ghutihkklfng')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@ice_parquet_str@pcol=ghutihkklfng
+PREHOOK: query: select `partition` from default.ice_parquet_str.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_str
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_str.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_str
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":"iyoorpiyujn"}
+PREHOOK: query: create external table ice_parquet_date (
+  strcol string,
+  intcol integer,
+  pcol date
+) partitioned by spec (pcol)
+stored by iceberg
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_date
+POSTHOOK: query: create external table ice_parquet_date (
+  strcol string,
+  intcol integer,
+  pcol date
+) partitioned by spec (pcol)
+stored by iceberg
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_date
+PREHOOK: query: insert into ice_parquet_date values ('str', 1, '2022-01-01')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_date
+POSTHOOK: query: insert into ice_parquet_date values ('str', 1, '2022-01-01')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_date
+PREHOOK: query: insert into ice_parquet_date values ('str', 1, '2022-02-02')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_date
+POSTHOOK: query: insert into ice_parquet_date values ('str', 1, '2022-02-02')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_date
+PREHOOK: query: insert into ice_parquet_date values ('str', 1, '2022-03-03')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_date
+POSTHOOK: query: insert into ice_parquet_date values ('str', 1, '2022-03-03')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_date
+PREHOOK: query: insert into ice_parquet_date values ('str', 1, '2022-01-01')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_date
+POSTHOOK: query: insert into ice_parquet_date values ('str', 1, '2022-01-01')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_date
+PREHOOK: query: insert into ice_parquet_date values ('abc', 1, '2022-02-02')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_date
+POSTHOOK: query: insert into ice_parquet_date values ('abc', 1, '2022-02-02')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_date
+PREHOOK: query: insert into ice_parquet_date values ('def', 1, '2022-03-03')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_date
+POSTHOOK: query: insert into ice_parquet_date values ('def', 1, '2022-03-03')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_date
+PREHOOK: query: select * from ice_parquet_date
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from ice_parquet_date
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+abc	1	2022-02-02
+def	1	2022-03-03
+str	1	2022-01-01
+str	1	2022-01-01
+str	1	2022-02-02
+str	1	2022-03-03
+PREHOOK: query: select `partition` from default.ice_parquet_date.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_date.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":"2022-01-01"}
+{"pcol":"2022-02-02"}
+{"pcol":"2022-03-03"}
+PREHOOK: query: truncate table ice_parquet_date partition (pcol = '2022-02-02')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@ice_parquet_date@pcol=2022-02-02
+POSTHOOK: query: truncate table ice_parquet_date partition (pcol = '2022-02-02')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@ice_parquet_date@pcol=2022-02-02
+PREHOOK: query: select `partition` from default.ice_parquet_date.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_date.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":"2022-01-01"}
+{"pcol":"2022-03-03"}
+PREHOOK: query: create external table ice_parquet_double (
+  strcol string,
+  intcol integer,
+  pcol double
+) partitioned by spec (pcol)
+stored by iceberg
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_double
+POSTHOOK: query: create external table ice_parquet_double (
+  strcol string,
+  intcol integer,
+  pcol double
+) partitioned by spec (pcol)
+stored by iceberg
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_double
+PREHOOK: query: insert into ice_parquet_double values ('str', 1, '2.45')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_double
+POSTHOOK: query: insert into ice_parquet_double values ('str', 1, '2.45')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_double
+PREHOOK: query: insert into ice_parquet_double values ('str', 1, '3.1567')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_double
+POSTHOOK: query: insert into ice_parquet_double values ('str', 1, '3.1567')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_double
+PREHOOK: query: insert into ice_parquet_double values ('str', 1, '2.45')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_double
+POSTHOOK: query: insert into ice_parquet_double values ('str', 1, '2.45')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_double
+PREHOOK: query: insert into ice_parquet_double values ('str', 1, '3.1567')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_double
+POSTHOOK: query: insert into ice_parquet_double values ('str', 1, '3.1567')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_double
+PREHOOK: query: insert into ice_parquet_double values ('abc', 1, '2.45')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_double
+POSTHOOK: query: insert into ice_parquet_double values ('abc', 1, '2.45')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_double
+PREHOOK: query: insert into ice_parquet_double values ('def', 1, '3.1567')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@ice_parquet_double
+POSTHOOK: query: insert into ice_parquet_double values ('def', 1, '3.1567')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@ice_parquet_double
+PREHOOK: query: select * from ice_parquet_double
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_double
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from ice_parquet_double
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_double
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+abc	1	2.45
+def	1	3.1567
+str	1	2.45
+str	1	2.45
+str	1	3.1567
+str	1	3.1567
+PREHOOK: query: select `partition` from default.ice_parquet_double.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_double
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_double.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_double
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":2.45}
+{"pcol":3.1567}
+PREHOOK: query: truncate table ice_parquet_double partition (pcol = '2.45')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@ice_parquet_double@pcol=2.45
+POSTHOOK: query: truncate table ice_parquet_double partition (pcol = '2.45')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@ice_parquet_double@pcol=2.45
+PREHOOK: query: select `partition` from default.ice_parquet_double.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@ice_parquet_double
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.ice_parquet_double.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@ice_parquet_double
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"pcol":3.1567}
+PREHOOK: query: drop table ice_parquet_str_date
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@ice_parquet_str_date
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_str_date
+POSTHOOK: query: drop table ice_parquet_str_date
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@ice_parquet_str_date
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_str_date
+PREHOOK: query: drop table ice_parquet_str_int
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@ice_parquet_str_int
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_str_int
+POSTHOOK: query: drop table ice_parquet_str_int
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@ice_parquet_str_int
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_str_int
+PREHOOK: query: drop table ice_parquet_int
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@ice_parquet_int
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_int
+POSTHOOK: query: drop table ice_parquet_int
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@ice_parquet_int
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_int
+PREHOOK: query: drop table ice_parquet_bigint
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@ice_parquet_bigint
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_bigint
+POSTHOOK: query: drop table ice_parquet_bigint
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@ice_parquet_bigint
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_bigint
+PREHOOK: query: drop table ice_parquet_str
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@ice_parquet_str
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_str
+POSTHOOK: query: drop table ice_parquet_str
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@ice_parquet_str
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_str
+PREHOOK: query: drop table ice_parquet_date
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@ice_parquet_date
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_date
+POSTHOOK: query: drop table ice_parquet_date
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@ice_parquet_date
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_date
+PREHOOK: query: drop table ice_parquet_double
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@ice_parquet_double
+PREHOOK: Output: database:default
+PREHOOK: Output: default@ice_parquet_double
+POSTHOOK: query: drop table ice_parquet_double
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@ice_parquet_double
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@ice_parquet_double
diff --git a/iceberg/iceberg-handler/src/test/results/positive/iceberg_truncate_partition_with_evolution.q.out b/iceberg/iceberg-handler/src/test/results/positive/iceberg_truncate_partition_with_evolution.q.out
new file mode 100644
index 00000000000..25d1246361e
--- /dev/null
+++ b/iceberg/iceberg-handler/src/test/results/positive/iceberg_truncate_partition_with_evolution.q.out
@@ -0,0 +1,1371 @@
+PREHOOK: query: create table test_ice_int (a int, b string) stored by iceberg stored as orc tblproperties ('format-version'='2')
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_ice_int
+POSTHOOK: query: create table test_ice_int (a int, b string) stored by iceberg stored as orc tblproperties ('format-version'='2')
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_ice_int
+PREHOOK: query: insert into test_ice_int values (11, 'ddd'), (22, 'eefe')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_int
+POSTHOOK: query: insert into test_ice_int values (11, 'ddd'), (22, 'eefe')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_int
+PREHOOK: query: alter table test_ice_int set partition spec(a)
+PREHOOK: type: ALTERTABLE_SETPARTSPEC
+PREHOOK: Input: default@test_ice_int
+POSTHOOK: query: alter table test_ice_int set partition spec(a)
+POSTHOOK: type: ALTERTABLE_SETPARTSPEC
+POSTHOOK: Input: default@test_ice_int
+POSTHOOK: Output: default@test_ice_int
+PREHOOK: query: insert into test_ice_int values (33, 'rrfdfdf')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_int
+POSTHOOK: query: insert into test_ice_int values (33, 'rrfdfdf')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_int
+PREHOOK: query: insert into table test_ice_int select * from test_ice_int
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_int
+PREHOOK: Output: default@test_ice_int
+POSTHOOK: query: insert into table test_ice_int select * from test_ice_int
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_int
+POSTHOOK: Output: default@test_ice_int
+PREHOOK: query: select * from test_ice_int
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_int
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_int
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_int
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+11	ddd
+11	ddd
+22	eefe
+22	eefe
+33	rrfdfdf
+33	rrfdfdf
+PREHOOK: query: select `partition` from default.test_ice_int.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_int
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_int.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_int
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"a":11}
+{"a":22}
+{"a":33}
+{"a":null}
+PREHOOK: query: explain truncate table test_ice_int partition (a = 22)
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_int@a=22
+POSTHOOK: query: explain truncate table test_ice_int partition (a = 22)
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_int@a=22
+STAGE DEPENDENCIES:
+  Stage-1 is a root stage
+  Stage-2 depends on stages: Stage-1
+  Stage-0 depends on stages: Stage-2
+  Stage-3 depends on stages: Stage-0
+
+STAGE PLANS:
+  Stage: Stage-1
+    Tez
+#### A masked pattern was here ####
+      Edges:
+        Reducer 2 <- Map 1 (SIMPLE_EDGE)
+#### A masked pattern was here ####
+      Vertices:
+        Map 1 
+            Map Operator Tree:
+                TableScan
+                  alias: test_ice_int
+                  filterExpr: (a = 22) (type: boolean)
+                  Statistics: Num rows: 6 Data size: 570 Basic stats: COMPLETE Column stats: COMPLETE
+                  Filter Operator
+                    predicate: (a = 22) (type: boolean)
+                    Statistics: Num rows: 2 Data size: 190 Basic stats: COMPLETE Column stats: COMPLETE
+                    Select Operator
+                      expressions: PARTITION__SPEC__ID (type: int), PARTITION__HASH (type: bigint), FILE__PATH (type: string), ROW__POSITION (type: bigint), b (type: string)
+                      outputColumnNames: _col0, _col1, _col2, _col3, _col5
+                      Statistics: Num rows: 2 Data size: 590 Basic stats: COMPLETE Column stats: COMPLETE
+                      Reduce Output Operator
+                        key expressions: _col0 (type: int), _col1 (type: bigint), _col2 (type: string), _col3 (type: bigint)
+                        null sort order: zzzz
+                        sort order: ++++
+                        Statistics: Num rows: 2 Data size: 590 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col5 (type: string)
+            Execution mode: vectorized
+        Reducer 2 
+            Execution mode: vectorized
+            Reduce Operator Tree:
+              Select Operator
+                expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: bigint), KEY.reducesinkkey2 (type: string), KEY.reducesinkkey3 (type: bigint), 22 (type: int), VALUE._col0 (type: string)
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                Statistics: Num rows: 2 Data size: 598 Basic stats: COMPLETE Column stats: COMPLETE
+                File Output Operator
+                  compressed: false
+                  Statistics: Num rows: 2 Data size: 598 Basic stats: COMPLETE Column stats: COMPLETE
+                  table:
+                      input format: org.apache.iceberg.mr.hive.HiveIcebergInputFormat
+                      output format: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat
+                      serde: org.apache.iceberg.mr.hive.HiveIcebergSerDe
+                      name: default.test_ice_int
+
+  Stage: Stage-2
+    Dependency Collection
+
+  Stage: Stage-0
+    Move Operator
+      tables:
+          replace: false
+          table:
+              input format: org.apache.iceberg.mr.hive.HiveIcebergInputFormat
+              output format: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat
+              serde: org.apache.iceberg.mr.hive.HiveIcebergSerDe
+              name: default.test_ice_int
+
+  Stage: Stage-3
+    Stats Work
+      Basic Stats Work:
+
+PREHOOK: query: truncate table test_ice_int partition (a = 22)
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_int@a=22
+POSTHOOK: query: truncate table test_ice_int partition (a = 22)
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_int@a=22
+PREHOOK: query: select * from test_ice_int
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_int
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_int
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_int
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+11	ddd
+11	ddd
+33	rrfdfdf
+33	rrfdfdf
+PREHOOK: query: select `partition` from default.test_ice_int.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_int
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_int.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_int
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"a":11}
+{"a":22}
+{"a":33}
+{"a":null}
+PREHOOK: query: explain truncate table test_ice_int partition (a = 33)
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@test_ice_int@a=33
+POSTHOOK: query: explain truncate table test_ice_int partition (a = 33)
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@test_ice_int@a=33
+STAGE DEPENDENCIES:
+  Stage-0 is a root stage
+
+STAGE PLANS:
+  Stage: Stage-0
+    Truncate Table or Partition
+      partition spec:
+        a 33
+      table name: default.test_ice_int
+
+PREHOOK: query: truncate table test_ice_int partition (a = 33)
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@test_ice_int@a=33
+POSTHOOK: query: truncate table test_ice_int partition (a = 33)
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@test_ice_int@a=33
+PREHOOK: query: select * from test_ice_int
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_int
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_int
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_int
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+11	ddd
+11	ddd
+PREHOOK: query: select `partition` from default.test_ice_int.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_int
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_int.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_int
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"a":11}
+{"a":22}
+{"a":null}
+PREHOOK: query: create table test_ice_bigint (a bigint, b string) stored by iceberg stored as orc tblproperties ('format-version'='2')
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_ice_bigint
+POSTHOOK: query: create table test_ice_bigint (a bigint, b string) stored by iceberg stored as orc tblproperties ('format-version'='2')
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_ice_bigint
+PREHOOK: query: insert into test_ice_bigint values (115674892756, 'ddd'), (226784902765739, 'eefe')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_bigint
+POSTHOOK: query: insert into test_ice_bigint values (115674892756, 'ddd'), (226784902765739, 'eefe')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_bigint
+PREHOOK: query: alter table test_ice_bigint set partition spec(a)
+PREHOOK: type: ALTERTABLE_SETPARTSPEC
+PREHOOK: Input: default@test_ice_bigint
+POSTHOOK: query: alter table test_ice_bigint set partition spec(a)
+POSTHOOK: type: ALTERTABLE_SETPARTSPEC
+POSTHOOK: Input: default@test_ice_bigint
+POSTHOOK: Output: default@test_ice_bigint
+PREHOOK: query: insert into test_ice_bigint values (3367849937755673, 'rrfdfdf')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_bigint
+POSTHOOK: query: insert into test_ice_bigint values (3367849937755673, 'rrfdfdf')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_bigint
+PREHOOK: query: insert into table test_ice_bigint select * from test_ice_bigint
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_bigint
+PREHOOK: Output: default@test_ice_bigint
+POSTHOOK: query: insert into table test_ice_bigint select * from test_ice_bigint
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_bigint
+POSTHOOK: Output: default@test_ice_bigint
+PREHOOK: query: select * from test_ice_bigint
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_bigint
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_bigint
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_bigint
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+115674892756	ddd
+115674892756	ddd
+226784902765739	eefe
+226784902765739	eefe
+3367849937755673	rrfdfdf
+3367849937755673	rrfdfdf
+PREHOOK: query: select `partition` from default.test_ice_bigint.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_bigint
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_bigint.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_bigint
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"a":115674892756}
+{"a":226784902765739}
+{"a":3367849937755673}
+{"a":null}
+PREHOOK: query: explain truncate table test_ice_bigint partition (a = 226784902765739)
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_bigint@a=226784902765739
+POSTHOOK: query: explain truncate table test_ice_bigint partition (a = 226784902765739)
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_bigint@a=226784902765739
+STAGE DEPENDENCIES:
+  Stage-1 is a root stage
+  Stage-2 depends on stages: Stage-1
+  Stage-0 depends on stages: Stage-2
+  Stage-3 depends on stages: Stage-0
+
+STAGE PLANS:
+  Stage: Stage-1
+    Tez
+#### A masked pattern was here ####
+      Edges:
+        Reducer 2 <- Map 1 (SIMPLE_EDGE)
+#### A masked pattern was here ####
+      Vertices:
+        Map 1 
+            Map Operator Tree:
+                TableScan
+                  alias: test_ice_bigint
+                  filterExpr: (a = 226784902765739L) (type: boolean)
+                  Statistics: Num rows: 6 Data size: 594 Basic stats: COMPLETE Column stats: COMPLETE
+                  Filter Operator
+                    predicate: (a = 226784902765739L) (type: boolean)
+                    Statistics: Num rows: 2 Data size: 198 Basic stats: COMPLETE Column stats: COMPLETE
+                    Select Operator
+                      expressions: PARTITION__SPEC__ID (type: int), PARTITION__HASH (type: bigint), FILE__PATH (type: string), ROW__POSITION (type: bigint), b (type: string)
+                      outputColumnNames: _col0, _col1, _col2, _col3, _col5
+                      Statistics: Num rows: 2 Data size: 590 Basic stats: COMPLETE Column stats: COMPLETE
+                      Reduce Output Operator
+                        key expressions: _col0 (type: int), _col1 (type: bigint), _col2 (type: string), _col3 (type: bigint)
+                        null sort order: zzzz
+                        sort order: ++++
+                        Statistics: Num rows: 2 Data size: 590 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col5 (type: string)
+            Execution mode: vectorized
+        Reducer 2 
+            Execution mode: vectorized
+            Reduce Operator Tree:
+              Select Operator
+                expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: bigint), KEY.reducesinkkey2 (type: string), KEY.reducesinkkey3 (type: bigint), 226784902765739L (type: bigint), VALUE._col0 (type: string)
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                Statistics: Num rows: 2 Data size: 606 Basic stats: COMPLETE Column stats: COMPLETE
+                File Output Operator
+                  compressed: false
+                  Statistics: Num rows: 2 Data size: 606 Basic stats: COMPLETE Column stats: COMPLETE
+                  table:
+                      input format: org.apache.iceberg.mr.hive.HiveIcebergInputFormat
+                      output format: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat
+                      serde: org.apache.iceberg.mr.hive.HiveIcebergSerDe
+                      name: default.test_ice_bigint
+
+  Stage: Stage-2
+    Dependency Collection
+
+  Stage: Stage-0
+    Move Operator
+      tables:
+          replace: false
+          table:
+              input format: org.apache.iceberg.mr.hive.HiveIcebergInputFormat
+              output format: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat
+              serde: org.apache.iceberg.mr.hive.HiveIcebergSerDe
+              name: default.test_ice_bigint
+
+  Stage: Stage-3
+    Stats Work
+      Basic Stats Work:
+
+PREHOOK: query: truncate table test_ice_bigint partition (a = 226784902765739)
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_bigint@a=226784902765739
+POSTHOOK: query: truncate table test_ice_bigint partition (a = 226784902765739)
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_bigint@a=226784902765739
+PREHOOK: query: select * from test_ice_bigint
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_bigint
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_bigint
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_bigint
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+115674892756	ddd
+115674892756	ddd
+3367849937755673	rrfdfdf
+3367849937755673	rrfdfdf
+PREHOOK: query: select `partition` from default.test_ice_bigint.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_bigint
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_bigint.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_bigint
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"a":115674892756}
+{"a":226784902765739}
+{"a":3367849937755673}
+{"a":null}
+PREHOOK: query: explain truncate table test_ice_bigint partition (a = 3367849937755673)
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@test_ice_bigint@a=3367849937755673
+POSTHOOK: query: explain truncate table test_ice_bigint partition (a = 3367849937755673)
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@test_ice_bigint@a=3367849937755673
+STAGE DEPENDENCIES:
+  Stage-0 is a root stage
+
+STAGE PLANS:
+  Stage: Stage-0
+    Truncate Table or Partition
+      partition spec:
+        a 3367849937755673
+      table name: default.test_ice_bigint
+
+PREHOOK: query: truncate table test_ice_bigint partition (a = 3367849937755673)
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@test_ice_bigint@a=3367849937755673
+POSTHOOK: query: truncate table test_ice_bigint partition (a = 3367849937755673)
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@test_ice_bigint@a=3367849937755673
+PREHOOK: query: select * from test_ice_bigint
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_bigint
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_bigint
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_bigint
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+115674892756	ddd
+115674892756	ddd
+PREHOOK: query: select `partition` from default.test_ice_bigint.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_bigint
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_bigint.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_bigint
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"a":115674892756}
+{"a":226784902765739}
+{"a":null}
+PREHOOK: query: create table test_ice_str (a bigint, b string) stored by iceberg stored as orc tblproperties ('format-version'='2')
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_ice_str
+POSTHOOK: query: create table test_ice_str (a bigint, b string) stored by iceberg stored as orc tblproperties ('format-version'='2')
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_ice_str
+PREHOOK: query: insert into test_ice_str values (115674892756, 'ddd'), (2267849027657399057, 'eefe')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_str
+POSTHOOK: query: insert into test_ice_str values (115674892756, 'ddd'), (2267849027657399057, 'eefe')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_str
+PREHOOK: query: insert into test_ice_str values (115674892756, 'a"ab'), (2267849027657399057, 'eefe')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_str
+POSTHOOK: query: insert into test_ice_str values (115674892756, 'a"ab'), (2267849027657399057, 'eefe')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_str
+PREHOOK: query: insert into test_ice_str values (115674892756, "a'ab"), (2267849027657399057, "eefe")
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_str
+POSTHOOK: query: insert into test_ice_str values (115674892756, "a'ab"), (2267849027657399057, "eefe")
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_str
+PREHOOK: query: alter table test_ice_str set partition spec(b)
+PREHOOK: type: ALTERTABLE_SETPARTSPEC
+PREHOOK: Input: default@test_ice_str
+POSTHOOK: query: alter table test_ice_str set partition spec(b)
+POSTHOOK: type: ALTERTABLE_SETPARTSPEC
+POSTHOOK: Input: default@test_ice_str
+POSTHOOK: Output: default@test_ice_str
+PREHOOK: query: insert into test_ice_str values (33678499377556738, 'rrfdfdf')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_str
+POSTHOOK: query: insert into test_ice_str values (33678499377556738, 'rrfdfdf')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_str
+PREHOOK: query: insert into table test_ice_str select * from test_ice_str
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_str
+PREHOOK: Output: default@test_ice_str
+POSTHOOK: query: insert into table test_ice_str select * from test_ice_str
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_str
+POSTHOOK: Output: default@test_ice_str
+PREHOOK: query: select * from test_ice_str
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_str
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_str
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_str
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+115674892756	a"ab
+115674892756	a"ab
+115674892756	a'ab
+115674892756	a'ab
+115674892756	ddd
+115674892756	ddd
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+33678499377556738	rrfdfdf
+33678499377556738	rrfdfdf
+PREHOOK: query: select `partition` from default.test_ice_str.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_str
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_str.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_str
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"b":"a'ab"}
+{"b":"a\"ab"}
+{"b":"ddd"}
+{"b":"eefe"}
+{"b":"rrfdfdf"}
+{"b":null}
+PREHOOK: query: explain truncate table test_ice_str partition (b = 'ddd')
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_str@b=ddd
+POSTHOOK: query: explain truncate table test_ice_str partition (b = 'ddd')
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_str@b=ddd
+STAGE DEPENDENCIES:
+  Stage-1 is a root stage
+  Stage-2 depends on stages: Stage-1
+  Stage-0 depends on stages: Stage-2
+  Stage-3 depends on stages: Stage-0
+
+STAGE PLANS:
+  Stage: Stage-1
+    Tez
+#### A masked pattern was here ####
+      Edges:
+        Reducer 2 <- Map 1 (SIMPLE_EDGE)
+#### A masked pattern was here ####
+      Vertices:
+        Map 1 
+            Map Operator Tree:
+                TableScan
+                  alias: test_ice_str
+                  filterExpr: (b = 'ddd') (type: boolean)
+                  Statistics: Num rows: 14 Data size: 1386 Basic stats: COMPLETE Column stats: COMPLETE
+                  Filter Operator
+                    predicate: (b = 'ddd') (type: boolean)
+                    Statistics: Num rows: 3 Data size: 297 Basic stats: COMPLETE Column stats: COMPLETE
+                    Select Operator
+                      expressions: PARTITION__SPEC__ID (type: int), PARTITION__HASH (type: bigint), FILE__PATH (type: string), ROW__POSITION (type: bigint), a (type: bigint)
+                      outputColumnNames: _col0, _col1, _col2, _col3, _col4
+                      Statistics: Num rows: 3 Data size: 636 Basic stats: COMPLETE Column stats: COMPLETE
+                      Reduce Output Operator
+                        key expressions: _col0 (type: int), _col1 (type: bigint), _col2 (type: string), _col3 (type: bigint)
+                        null sort order: zzzz
+                        sort order: ++++
+                        Statistics: Num rows: 3 Data size: 636 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col4 (type: bigint)
+            Execution mode: vectorized
+        Reducer 2 
+            Execution mode: vectorized
+            Reduce Operator Tree:
+              Select Operator
+                expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: bigint), KEY.reducesinkkey2 (type: string), KEY.reducesinkkey3 (type: bigint), VALUE._col0 (type: bigint), 'ddd' (type: string)
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                Statistics: Num rows: 3 Data size: 897 Basic stats: COMPLETE Column stats: COMPLETE
+                File Output Operator
+                  compressed: false
+                  Statistics: Num rows: 3 Data size: 897 Basic stats: COMPLETE Column stats: COMPLETE
+                  table:
+                      input format: org.apache.iceberg.mr.hive.HiveIcebergInputFormat
+                      output format: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat
+                      serde: org.apache.iceberg.mr.hive.HiveIcebergSerDe
+                      name: default.test_ice_str
+
+  Stage: Stage-2
+    Dependency Collection
+
+  Stage: Stage-0
+    Move Operator
+      tables:
+          replace: false
+          table:
+              input format: org.apache.iceberg.mr.hive.HiveIcebergInputFormat
+              output format: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat
+              serde: org.apache.iceberg.mr.hive.HiveIcebergSerDe
+              name: default.test_ice_str
+
+  Stage: Stage-3
+    Stats Work
+      Basic Stats Work:
+
+PREHOOK: query: truncate table test_ice_str partition (b = 'ddd')
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_str@b=ddd
+POSTHOOK: query: truncate table test_ice_str partition (b = 'ddd')
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_str@b=ddd
+PREHOOK: query: select * from test_ice_str
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_str
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_str
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_str
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+115674892756	a"ab
+115674892756	a"ab
+115674892756	a'ab
+115674892756	a'ab
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+33678499377556738	rrfdfdf
+33678499377556738	rrfdfdf
+PREHOOK: query: select `partition` from default.test_ice_str.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_str
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_str.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_str
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"b":"a'ab"}
+{"b":"a\"ab"}
+{"b":"ddd"}
+{"b":"eefe"}
+{"b":"rrfdfdf"}
+{"b":null}
+PREHOOK: query: explain truncate table test_ice_str partition (b = 'rrfdfdf')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@test_ice_str@b=rrfdfdf
+POSTHOOK: query: explain truncate table test_ice_str partition (b = 'rrfdfdf')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@test_ice_str@b=rrfdfdf
+STAGE DEPENDENCIES:
+  Stage-0 is a root stage
+
+STAGE PLANS:
+  Stage: Stage-0
+    Truncate Table or Partition
+      partition spec:
+        b rrfdfdf
+      table name: default.test_ice_str
+
+PREHOOK: query: truncate table test_ice_str partition (b = 'rrfdfdf')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@test_ice_str@b=rrfdfdf
+POSTHOOK: query: truncate table test_ice_str partition (b = 'rrfdfdf')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@test_ice_str@b=rrfdfdf
+PREHOOK: query: select * from test_ice_str
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_str
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_str
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_str
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+115674892756	a"ab
+115674892756	a"ab
+115674892756	a'ab
+115674892756	a'ab
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+PREHOOK: query: select `partition` from default.test_ice_str.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_str
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_str.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_str
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"b":"a'ab"}
+{"b":"a\"ab"}
+{"b":"ddd"}
+{"b":"eefe"}
+{"b":null}
+PREHOOK: query: truncate table test_ice_str partition (b = 'a"ab')
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_str@b=a%22ab
+POSTHOOK: query: truncate table test_ice_str partition (b = 'a"ab')
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_str@b=a%22ab
+PREHOOK: query: truncate table test_ice_str partition (b = "a'ab")
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_str@b=a%27ab
+POSTHOOK: query: truncate table test_ice_str partition (b = "a'ab")
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_str@b=a%27ab
+PREHOOK: query: select * from test_ice_str
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_str
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_str
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_str
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+2267849027657399057	eefe
+PREHOOK: query: select `partition` from default.test_ice_str.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_str
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_str.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_str
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"b":"a'ab"}
+{"b":"a\"ab"}
+{"b":"ddd"}
+{"b":"eefe"}
+{"b":null}
+PREHOOK: query: create table test_ice_date (a bigint, b date) stored by iceberg stored as orc tblproperties ('format-version'='2')
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_ice_date
+POSTHOOK: query: create table test_ice_date (a bigint, b date) stored by iceberg stored as orc tblproperties ('format-version'='2')
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_ice_date
+PREHOOK: query: insert into test_ice_date values (115674892756, '2022-02-07'), (2267849027657399057, '2022-08-07')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_date
+POSTHOOK: query: insert into test_ice_date values (115674892756, '2022-02-07'), (2267849027657399057, '2022-08-07')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_date
+PREHOOK: query: alter table test_ice_date set partition spec(b)
+PREHOOK: type: ALTERTABLE_SETPARTSPEC
+PREHOOK: Input: default@test_ice_date
+POSTHOOK: query: alter table test_ice_date set partition spec(b)
+POSTHOOK: type: ALTERTABLE_SETPARTSPEC
+POSTHOOK: Input: default@test_ice_date
+POSTHOOK: Output: default@test_ice_date
+PREHOOK: query: insert into test_ice_date values (33678499377556738, '2022-08-09')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_date
+POSTHOOK: query: insert into test_ice_date values (33678499377556738, '2022-08-09')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_date
+PREHOOK: query: select * from test_ice_date
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_date
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+115674892756	2022-02-07
+2267849027657399057	2022-08-07
+33678499377556738	2022-08-09
+PREHOOK: query: select `partition` from default.test_ice_date.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_date.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"b":"2022-08-09"}
+{"b":null}
+PREHOOK: query: explain truncate table test_ice_date partition (b = '2022-02-07')
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_date@b=2022-02-07
+POSTHOOK: query: explain truncate table test_ice_date partition (b = '2022-02-07')
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_date@b=2022-02-07
+STAGE DEPENDENCIES:
+  Stage-1 is a root stage
+  Stage-2 depends on stages: Stage-1
+  Stage-0 depends on stages: Stage-2
+  Stage-3 depends on stages: Stage-0
+
+STAGE PLANS:
+  Stage: Stage-1
+    Tez
+#### A masked pattern was here ####
+      Edges:
+        Reducer 2 <- Map 1 (SIMPLE_EDGE)
+#### A masked pattern was here ####
+      Vertices:
+        Map 1 
+            Map Operator Tree:
+                TableScan
+                  alias: test_ice_date
+                  filterExpr: (b = DATE'2022-02-07') (type: boolean)
+                  Statistics: Num rows: 3 Data size: 192 Basic stats: COMPLETE Column stats: COMPLETE
+                  Filter Operator
+                    predicate: (b = DATE'2022-02-07') (type: boolean)
+                    Statistics: Num rows: 1 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE
+                    Select Operator
+                      expressions: PARTITION__SPEC__ID (type: int), PARTITION__HASH (type: bigint), FILE__PATH (type: string), ROW__POSITION (type: bigint), a (type: bigint)
+                      outputColumnNames: _col0, _col1, _col2, _col3, _col4
+                      Statistics: Num rows: 1 Data size: 212 Basic stats: COMPLETE Column stats: COMPLETE
+                      Reduce Output Operator
+                        key expressions: _col0 (type: int), _col1 (type: bigint), _col2 (type: string), _col3 (type: bigint)
+                        null sort order: zzzz
+                        sort order: ++++
+                        Statistics: Num rows: 1 Data size: 212 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col4 (type: bigint)
+            Execution mode: vectorized
+        Reducer 2 
+            Execution mode: vectorized
+            Reduce Operator Tree:
+              Select Operator
+                expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: bigint), KEY.reducesinkkey2 (type: string), KEY.reducesinkkey3 (type: bigint), VALUE._col0 (type: bigint), DATE'2022-02-07' (type: date)
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                Statistics: Num rows: 1 Data size: 268 Basic stats: COMPLETE Column stats: COMPLETE
+                File Output Operator
+                  compressed: false
+                  Statistics: Num rows: 1 Data size: 268 Basic stats: COMPLETE Column stats: COMPLETE
+                  table:
+                      input format: org.apache.iceberg.mr.hive.HiveIcebergInputFormat
+                      output format: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat
+                      serde: org.apache.iceberg.mr.hive.HiveIcebergSerDe
+                      name: default.test_ice_date
+
+  Stage: Stage-2
+    Dependency Collection
+
+  Stage: Stage-0
+    Move Operator
+      tables:
+          replace: false
+          table:
+              input format: org.apache.iceberg.mr.hive.HiveIcebergInputFormat
+              output format: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat
+              serde: org.apache.iceberg.mr.hive.HiveIcebergSerDe
+              name: default.test_ice_date
+
+  Stage: Stage-3
+    Stats Work
+      Basic Stats Work:
+
+PREHOOK: query: truncate table test_ice_date partition (b = '2022-02-07')
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_date@b=2022-02-07
+POSTHOOK: query: truncate table test_ice_date partition (b = '2022-02-07')
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_date@b=2022-02-07
+PREHOOK: query: select * from test_ice_date
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_date
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+2267849027657399057	2022-08-07
+33678499377556738	2022-08-09
+PREHOOK: query: select `partition` from default.test_ice_date.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_date.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"b":"2022-08-09"}
+{"b":null}
+PREHOOK: query: explain truncate table test_ice_date partition (b = '2022-08-09')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@test_ice_date@b=2022-08-09
+POSTHOOK: query: explain truncate table test_ice_date partition (b = '2022-08-09')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@test_ice_date@b=2022-08-09
+STAGE DEPENDENCIES:
+  Stage-0 is a root stage
+
+STAGE PLANS:
+  Stage: Stage-0
+    Truncate Table or Partition
+      partition spec:
+        b 2022-08-09
+      table name: default.test_ice_date
+
+PREHOOK: query: truncate table test_ice_date partition (b = '2022-08-09')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@test_ice_date@b=2022-08-09
+POSTHOOK: query: truncate table test_ice_date partition (b = '2022-08-09')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@test_ice_date@b=2022-08-09
+PREHOOK: query: select * from test_ice_date
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_date
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+2267849027657399057	2022-08-07
+PREHOOK: query: select `partition` from default.test_ice_date.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_date.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"b":null}
+PREHOOK: query: create table test_ice_double (a double, b date) stored by iceberg stored as orc tblproperties ('format-version'='2')
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_ice_double
+POSTHOOK: query: create table test_ice_double (a double, b date) stored by iceberg stored as orc tblproperties ('format-version'='2')
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_ice_double
+PREHOOK: query: insert into test_ice_double values (115674892756.67590946, '2022-02-07'), (2267849027.657399057, '2022-08-07')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_double
+POSTHOOK: query: insert into test_ice_double values (115674892756.67590946, '2022-02-07'), (2267849027.657399057, '2022-08-07')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_double
+PREHOOK: query: alter table test_ice_double set partition spec(a)
+PREHOOK: type: ALTERTABLE_SETPARTSPEC
+PREHOOK: Input: default@test_ice_double
+POSTHOOK: query: alter table test_ice_double set partition spec(a)
+POSTHOOK: type: ALTERTABLE_SETPARTSPEC
+POSTHOOK: Input: default@test_ice_double
+POSTHOOK: Output: default@test_ice_double
+PREHOOK: query: insert into test_ice_double values (33678499.377556738, '2022-08-09')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_double
+POSTHOOK: query: insert into test_ice_double values (33678499.377556738, '2022-08-09')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_double
+PREHOOK: query: insert into table test_ice_double select * from test_ice_double
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double
+PREHOOK: Output: default@test_ice_double
+POSTHOOK: query: insert into table test_ice_double select * from test_ice_double
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double
+POSTHOOK: Output: default@test_ice_double
+PREHOOK: query: select * from test_ice_double
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_double
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+1.156748927566759E11	2022-02-07
+1.156748927566759E11	2022-02-07
+2.267849027657399E9	2022-08-07
+2.267849027657399E9	2022-08-07
+3.367849937755674E7	2022-08-09
+3.367849937755674E7	2022-08-09
+PREHOOK: query: select `partition` from default.test_ice_double.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_double.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"a":1.156748927566759E11}
+{"a":2.267849027657399E9}
+{"a":3.367849937755674E7}
+{"a":null}
+PREHOOK: query: explain truncate table test_ice_double partition (a = 115674892756.67590946)
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_double@a=115674892756.67590946
+POSTHOOK: query: explain truncate table test_ice_double partition (a = 115674892756.67590946)
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_double@a=115674892756.67590946
+STAGE DEPENDENCIES:
+  Stage-1 is a root stage
+  Stage-2 depends on stages: Stage-1
+  Stage-0 depends on stages: Stage-2
+  Stage-3 depends on stages: Stage-0
+
+STAGE PLANS:
+  Stage: Stage-1
+    Tez
+#### A masked pattern was here ####
+      Edges:
+        Reducer 2 <- Map 1 (SIMPLE_EDGE)
+#### A masked pattern was here ####
+      Vertices:
+        Map 1 
+            Map Operator Tree:
+                TableScan
+                  alias: test_ice_double
+                  filterExpr: (a = 1.156748927566759E11D) (type: boolean)
+                  Statistics: Num rows: 6 Data size: 384 Basic stats: COMPLETE Column stats: COMPLETE
+                  Filter Operator
+                    predicate: (a = 1.156748927566759E11D) (type: boolean)
+                    Statistics: Num rows: 2 Data size: 128 Basic stats: COMPLETE Column stats: COMPLETE
+                    Select Operator
+                      expressions: PARTITION__SPEC__ID (type: int), PARTITION__HASH (type: bigint), FILE__PATH (type: string), ROW__POSITION (type: bigint), b (type: date)
+                      outputColumnNames: _col0, _col1, _col2, _col3, _col5
+                      Statistics: Num rows: 2 Data size: 520 Basic stats: COMPLETE Column stats: COMPLETE
+                      Reduce Output Operator
+                        key expressions: _col0 (type: int), _col1 (type: bigint), _col2 (type: string), _col3 (type: bigint)
+                        null sort order: zzzz
+                        sort order: ++++
+                        Statistics: Num rows: 2 Data size: 520 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col5 (type: date)
+            Execution mode: vectorized
+        Reducer 2 
+            Execution mode: vectorized
+            Reduce Operator Tree:
+              Select Operator
+                expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: bigint), KEY.reducesinkkey2 (type: string), KEY.reducesinkkey3 (type: bigint), 1.156748927566759E11D (type: double), VALUE._col0 (type: date)
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                Statistics: Num rows: 2 Data size: 536 Basic stats: COMPLETE Column stats: COMPLETE
+                File Output Operator
+                  compressed: false
+                  Statistics: Num rows: 2 Data size: 536 Basic stats: COMPLETE Column stats: COMPLETE
+                  table:
+                      input format: org.apache.iceberg.mr.hive.HiveIcebergInputFormat
+                      output format: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat
+                      serde: org.apache.iceberg.mr.hive.HiveIcebergSerDe
+                      name: default.test_ice_double
+
+  Stage: Stage-2
+    Dependency Collection
+
+  Stage: Stage-0
+    Move Operator
+      tables:
+          replace: false
+          table:
+              input format: org.apache.iceberg.mr.hive.HiveIcebergInputFormat
+              output format: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat
+              serde: org.apache.iceberg.mr.hive.HiveIcebergSerDe
+              name: default.test_ice_double
+
+  Stage: Stage-3
+    Stats Work
+      Basic Stats Work:
+
+PREHOOK: query: truncate table test_ice_double partition (a = 115674892756.67590946)
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_double@a=115674892756.67590946
+POSTHOOK: query: truncate table test_ice_double partition (a = 115674892756.67590946)
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_double@a=115674892756.67590946
+PREHOOK: query: select * from test_ice_double
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_double
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+2.267849027657399E9	2022-08-07
+2.267849027657399E9	2022-08-07
+3.367849937755674E7	2022-08-09
+3.367849937755674E7	2022-08-09
+PREHOOK: query: select `partition` from default.test_ice_double.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_double.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"a":1.156748927566759E11}
+{"a":2.267849027657399E9}
+{"a":3.367849937755674E7}
+{"a":null}
+PREHOOK: query: explain truncate table test_ice_double partition (a = 33678499.377556738)
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@test_ice_double@a=33678499.377556738
+POSTHOOK: query: explain truncate table test_ice_double partition (a = 33678499.377556738)
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@test_ice_double@a=33678499.377556738
+STAGE DEPENDENCIES:
+  Stage-0 is a root stage
+
+STAGE PLANS:
+  Stage: Stage-0
+    Truncate Table or Partition
+      partition spec:
+        a 33678499.377556738
+      table name: default.test_ice_double
+
+PREHOOK: query: truncate table test_ice_double partition (a = 33678499.377556738)
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@test_ice_double@a=33678499.377556738
+POSTHOOK: query: truncate table test_ice_double partition (a = 33678499.377556738)
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@test_ice_double@a=33678499.377556738
+PREHOOK: query: select * from test_ice_double
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_double
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+2.267849027657399E9	2022-08-07
+2.267849027657399E9	2022-08-07
+PREHOOK: query: select `partition` from default.test_ice_double.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_double.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"a":1.156748927566759E11}
+{"a":2.267849027657399E9}
+{"a":null}
+PREHOOK: query: create table test_ice_double_date (a double, b date) stored by iceberg stored as orc tblproperties ('format-version'='2')
+PREHOOK: type: CREATETABLE
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_ice_double_date
+POSTHOOK: query: create table test_ice_double_date (a double, b date) stored by iceberg stored as orc tblproperties ('format-version'='2')
+POSTHOOK: type: CREATETABLE
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_ice_double_date
+PREHOOK: query: insert into test_ice_double_date values (115674892756.67590946, '2022-02-07'), (2267849027.657399057, '2022-08-07')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_double_date
+POSTHOOK: query: insert into test_ice_double_date values (115674892756.67590946, '2022-02-07'), (2267849027.657399057, '2022-08-07')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_double_date
+PREHOOK: query: alter table test_ice_double_date set partition spec(a, b)
+PREHOOK: type: ALTERTABLE_SETPARTSPEC
+PREHOOK: Input: default@test_ice_double_date
+POSTHOOK: query: alter table test_ice_double_date set partition spec(a, b)
+POSTHOOK: type: ALTERTABLE_SETPARTSPEC
+POSTHOOK: Input: default@test_ice_double_date
+POSTHOOK: Output: default@test_ice_double_date
+PREHOOK: query: insert into test_ice_double_date values (33678499.377556738, '2022-08-09')
+PREHOOK: type: QUERY
+PREHOOK: Input: _dummy_database@_dummy_table
+PREHOOK: Output: default@test_ice_double_date
+POSTHOOK: query: insert into test_ice_double_date values (33678499.377556738, '2022-08-09')
+POSTHOOK: type: QUERY
+POSTHOOK: Input: _dummy_database@_dummy_table
+POSTHOOK: Output: default@test_ice_double_date
+PREHOOK: query: select * from test_ice_double_date
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_double_date
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+1.156748927566759E11	2022-02-07
+2.267849027657399E9	2022-08-07
+3.367849937755674E7	2022-08-09
+PREHOOK: query: select `partition` from default.test_ice_double_date.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_double_date.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"a":3.367849937755674E7,"b":"2022-08-09"}
+{"a":null,"b":null}
+PREHOOK: query: explain truncate table test_ice_double_date partition (a = 115674892756.67590946, b = '2022-02-07')
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_double_date@a=115674892756.67590946/b=2022-02-07
+POSTHOOK: query: explain truncate table test_ice_double_date partition (a = 115674892756.67590946, b = '2022-02-07')
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_double_date@a=115674892756.67590946/b=2022-02-07
+STAGE DEPENDENCIES:
+  Stage-1 is a root stage
+  Stage-2 depends on stages: Stage-1
+  Stage-0 depends on stages: Stage-2
+  Stage-3 depends on stages: Stage-0
+
+STAGE PLANS:
+  Stage: Stage-1
+    Tez
+#### A masked pattern was here ####
+      Edges:
+        Reducer 2 <- Map 1 (SIMPLE_EDGE)
+#### A masked pattern was here ####
+      Vertices:
+        Map 1 
+            Map Operator Tree:
+                TableScan
+                  alias: test_ice_double_date
+                  filterExpr: ((a = 1.156748927566759E11D) and (b = DATE'2022-02-07')) (type: boolean)
+                  Statistics: Num rows: 3 Data size: 192 Basic stats: COMPLETE Column stats: COMPLETE
+                  Filter Operator
+                    predicate: ((a = 1.156748927566759E11D) and (b = DATE'2022-02-07')) (type: boolean)
+                    Statistics: Num rows: 1 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE
+                    Select Operator
+                      expressions: PARTITION__SPEC__ID (type: int), PARTITION__HASH (type: bigint), FILE__PATH (type: string), ROW__POSITION (type: bigint)
+                      outputColumnNames: _col0, _col1, _col2, _col3
+                      Statistics: Num rows: 1 Data size: 204 Basic stats: COMPLETE Column stats: COMPLETE
+                      Reduce Output Operator
+                        key expressions: _col0 (type: int), _col1 (type: bigint), _col2 (type: string), _col3 (type: bigint)
+                        null sort order: zzzz
+                        sort order: ++++
+                        Statistics: Num rows: 1 Data size: 204 Basic stats: COMPLETE Column stats: COMPLETE
+            Execution mode: vectorized
+        Reducer 2 
+            Execution mode: vectorized
+            Reduce Operator Tree:
+              Select Operator
+                expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: bigint), KEY.reducesinkkey2 (type: string), KEY.reducesinkkey3 (type: bigint), 1.156748927566759E11D (type: double), DATE'2022-02-07' (type: date)
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                Statistics: Num rows: 1 Data size: 268 Basic stats: COMPLETE Column stats: COMPLETE
+                File Output Operator
+                  compressed: false
+                  Statistics: Num rows: 1 Data size: 268 Basic stats: COMPLETE Column stats: COMPLETE
+                  table:
+                      input format: org.apache.iceberg.mr.hive.HiveIcebergInputFormat
+                      output format: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat
+                      serde: org.apache.iceberg.mr.hive.HiveIcebergSerDe
+                      name: default.test_ice_double_date
+
+  Stage: Stage-2
+    Dependency Collection
+
+  Stage: Stage-0
+    Move Operator
+      tables:
+          replace: false
+          table:
+              input format: org.apache.iceberg.mr.hive.HiveIcebergInputFormat
+              output format: org.apache.iceberg.mr.hive.HiveIcebergOutputFormat
+              serde: org.apache.iceberg.mr.hive.HiveIcebergSerDe
+              name: default.test_ice_double_date
+
+  Stage: Stage-3
+    Stats Work
+      Basic Stats Work:
+
+PREHOOK: query: truncate table test_ice_double_date partition (a = 115674892756.67590946, b = '2022-02-07')
+PREHOOK: type: QUERY
+PREHOOK: Output: default@test_ice_double_date@a=115674892756.67590946/b=2022-02-07
+POSTHOOK: query: truncate table test_ice_double_date partition (a = 115674892756.67590946, b = '2022-02-07')
+POSTHOOK: type: QUERY
+POSTHOOK: Output: default@test_ice_double_date@a=115674892756.67590946/b=2022-02-07
+PREHOOK: query: select * from test_ice_double_date
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_double_date
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+2.267849027657399E9	2022-08-07
+3.367849937755674E7	2022-08-09
+PREHOOK: query: select `partition` from default.test_ice_double_date.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_double_date.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"a":3.367849937755674E7,"b":"2022-08-09"}
+{"a":null,"b":null}
+PREHOOK: query: explain truncate table test_ice_double_date partition (a = 33678499.377556738, b = '2022-08-09')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@test_ice_double_date@a=33678499.377556738/b=2022-08-09
+POSTHOOK: query: explain truncate table test_ice_double_date partition (a = 33678499.377556738, b = '2022-08-09')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@test_ice_double_date@a=33678499.377556738/b=2022-08-09
+STAGE DEPENDENCIES:
+  Stage-0 is a root stage
+
+STAGE PLANS:
+  Stage: Stage-0
+    Truncate Table or Partition
+      partition spec:
+        a 33678499.377556738
+        b 2022-08-09
+      table name: default.test_ice_double_date
+
+PREHOOK: query: truncate table test_ice_double_date partition (a = 33678499.377556738, b = '2022-08-09')
+PREHOOK: type: TRUNCATETABLE
+PREHOOK: Output: default@test_ice_double_date@a=33678499.377556738/b=2022-08-09
+POSTHOOK: query: truncate table test_ice_double_date partition (a = 33678499.377556738, b = '2022-08-09')
+POSTHOOK: type: TRUNCATETABLE
+POSTHOOK: Output: default@test_ice_double_date@a=33678499.377556738/b=2022-08-09
+PREHOOK: query: select * from test_ice_double_date
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select * from test_ice_double_date
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+2.267849027657399E9	2022-08-07
+PREHOOK: query: select `partition` from default.test_ice_double_date.partitions
+PREHOOK: type: QUERY
+PREHOOK: Input: default@test_ice_double_date
+PREHOOK: Output: hdfs://### HDFS PATH ###
+POSTHOOK: query: select `partition` from default.test_ice_double_date.partitions
+POSTHOOK: type: QUERY
+POSTHOOK: Input: default@test_ice_double_date
+POSTHOOK: Output: hdfs://### HDFS PATH ###
+{"a":null,"b":null}
+PREHOOK: query: drop table test_ice_int
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@test_ice_int
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_ice_int
+POSTHOOK: query: drop table test_ice_int
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@test_ice_int
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_ice_int
+PREHOOK: query: drop table test_ice_bigint
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@test_ice_bigint
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_ice_bigint
+POSTHOOK: query: drop table test_ice_bigint
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@test_ice_bigint
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_ice_bigint
+PREHOOK: query: drop table test_ice_str
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@test_ice_str
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_ice_str
+POSTHOOK: query: drop table test_ice_str
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@test_ice_str
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_ice_str
+PREHOOK: query: drop table test_ice_date
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@test_ice_date
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_ice_date
+POSTHOOK: query: drop table test_ice_date
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@test_ice_date
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_ice_date
+PREHOOK: query: drop table test_ice_double
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@test_ice_double
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_ice_double
+POSTHOOK: query: drop table test_ice_double
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@test_ice_double
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_ice_double
+PREHOOK: query: drop table test_ice_double_date
+PREHOOK: type: DROPTABLE
+PREHOOK: Input: default@test_ice_double_date
+PREHOOK: Output: database:default
+PREHOOK: Output: default@test_ice_double_date
+POSTHOOK: query: drop table test_ice_double_date
+POSTHOOK: type: DROPTABLE
+POSTHOOK: Input: default@test_ice_double_date
+POSTHOOK: Output: database:default
+POSTHOOK: Output: default@test_ice_double_date
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/ddl/table/misc/truncate/TruncateTableAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/ddl/table/misc/truncate/TruncateTableAnalyzer.java
index 40b00e0c84e..1b6a1c6e4ec 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/ddl/table/misc/truncate/TruncateTableAnalyzer.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/ddl/table/misc/truncate/TruncateTableAnalyzer.java
@@ -29,9 +29,11 @@ import org.apache.hadoop.fs.Path;
 import org.apache.hadoop.hive.common.TableName;
 import org.apache.hadoop.hive.conf.HiveConf;
 import org.apache.hadoop.hive.metastore.TableType;
+import org.apache.hadoop.hive.metastore.Warehouse;
 import org.apache.hadoop.hive.metastore.api.FieldSchema;
-import org.apache.hadoop.hive.metastore.conf.MetastoreConf;
+import org.apache.hadoop.hive.metastore.api.MetaException;
 import org.apache.hadoop.hive.metastore.utils.MetaStoreUtils;
+import org.apache.hadoop.hive.ql.Context;
 import org.apache.hadoop.hive.ql.ErrorMsg;
 import org.apache.hadoop.hive.ql.QueryState;
 import org.apache.hadoop.hive.ql.ddl.DDLSemanticAnalyzerFactory.DDLType;
@@ -41,25 +43,34 @@ import org.apache.hadoop.hive.ql.ddl.table.AlterTableUtils;
 import org.apache.hadoop.hive.ql.ddl.table.partition.PartitionUtils;
 import org.apache.hadoop.hive.ql.ddl.DDLWork;
 import org.apache.hadoop.hive.ql.exec.ArchiveUtils;
+import org.apache.hadoop.hive.ql.exec.ColumnInfo;
 import org.apache.hadoop.hive.ql.exec.Task;
 import org.apache.hadoop.hive.ql.exec.TaskFactory;
 import org.apache.hadoop.hive.ql.exec.Utilities;
 import org.apache.hadoop.hive.ql.hooks.WriteEntity;
 import org.apache.hadoop.hive.ql.io.AcidUtils;
 import org.apache.hadoop.hive.ql.io.RCFileInputFormat;
+import org.apache.hadoop.hive.ql.metadata.DummyPartition;
 import org.apache.hadoop.hive.ql.metadata.HiveException;
+import org.apache.hadoop.hive.ql.metadata.HiveUtils;
 import org.apache.hadoop.hive.ql.metadata.Partition;
 import org.apache.hadoop.hive.ql.metadata.Table;
 import org.apache.hadoop.hive.ql.parse.ASTNode;
+import org.apache.hadoop.hive.ql.parse.BaseSemanticAnalyzer;
 import org.apache.hadoop.hive.ql.parse.HiveParser;
 import org.apache.hadoop.hive.ql.parse.HiveTableName;
+import org.apache.hadoop.hive.ql.parse.ParseUtils;
+import org.apache.hadoop.hive.ql.parse.SemanticAnalyzerFactory;
 import org.apache.hadoop.hive.ql.parse.SemanticException;
+import org.apache.hadoop.hive.ql.parse.ParseUtils.ReparseResult;
 import org.apache.hadoop.hive.ql.plan.BasicStatsWork;
 import org.apache.hadoop.hive.ql.plan.ListBucketingCtx;
 import org.apache.hadoop.hive.ql.plan.LoadTableDesc;
 import org.apache.hadoop.hive.ql.plan.MoveWork;
 import org.apache.hadoop.hive.ql.plan.StatsWork;
 import org.apache.hadoop.hive.ql.plan.TableDesc;
+import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector;
+import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoUtils;
 import org.apache.hadoop.mapred.InputFormat;
 
 /**
@@ -82,7 +93,26 @@ public class TruncateTableAnalyzer extends AbstractBaseAlterTableAnalyzer {
     Map<String, String> partitionSpec = getPartSpec((ASTNode) tableNode.getChild(1));
     addTruncateTableOutputs(tableNode, table, partitionSpec);
 
-    Task<?> truncateTask = null;
+    if (table.getStorageHandler() != null && !table.getStorageHandler().canUseTruncate(table, partitionSpec)) {
+      // Transform the truncate query to delete query.
+      StringBuilder rewrittenQuery = constructDeleteQuery(getFullTableNameForSQL((ASTNode) tableNode.getChild(0)),
+          table, partitionSpec);
+      ReparseResult rr = ParseUtils.parseRewrittenQuery(ctx, rewrittenQuery);
+      Context rewrittenCtx = rr.rewrittenCtx;
+      ASTNode rewrittenTree = rr.rewrittenTree;
+      rewrittenCtx.setOperation(Context.Operation.DELETE);
+      rewrittenCtx.addDestNamePrefix(1, Context.DestClausePrefix.DELETE);
+
+      BaseSemanticAnalyzer deleteAnalyzer = SemanticAnalyzerFactory.get(queryState, rewrittenTree);
+      // Note: this will overwrite this.ctx with rewrittenCtx
+      rewrittenCtx.setEnableUnparse(false);
+      deleteAnalyzer.analyze(rewrittenTree, rewrittenCtx);
+
+      rootTasks = deleteAnalyzer.getRootTasks();
+      return;
+    }
+
+    Task<?> truncateTask;
     ASTNode colNamesNode = (ASTNode) root.getFirstChildWithType(HiveParser.TOK_TABCOLNAME);
     if (colNamesNode == null) {
       truncateTask = getTruncateTaskWithoutColumnNames(tableName, partitionSpec, table);
@@ -95,7 +125,6 @@ public class TruncateTableAnalyzer extends AbstractBaseAlterTableAnalyzer {
 
   private void checkTruncateEligibility(ASTNode ast, ASTNode root, String tableName, Table table)
       throws SemanticException {
-    validateUnsupportedPartitionClause(table, root.getChildCount() > 1);
 
     if (table.isNonNative()) {
       if (table.getStorageHandler() == null || !table.getStorageHandler().supportsTruncateOnNonNativeTables()) {
@@ -137,9 +166,19 @@ public class TruncateTableAnalyzer extends AbstractBaseAlterTableAnalyzer {
       }
     } else {
       if (AlterTableUtils.isFullPartitionSpec(table, partitionSpec)) {
-        validatePartSpec(table, partitionSpec, (ASTNode) root.getChild(1), conf, true);
-        Partition partition = PartitionUtils.getPartition(db, table, partitionSpec, true);
-        outputs.add(new WriteEntity(partition, writeType));
+        if (table.getStorageHandler() != null && table.getStorageHandler().alwaysUnpartitioned()) {
+          table.getStorageHandler().validatePartSpec(table, partitionSpec);
+          try {
+            String partName = Warehouse.makePartName(partitionSpec, false);
+            Partition partition = new DummyPartition(table, partName, partitionSpec);
+            outputs.add(new WriteEntity(partition, writeType));
+          } catch (MetaException e) {
+            throw new SemanticException("Unable to construct name for dummy partition due to: ", e);
+          }
+        } else {
+          Partition partition = PartitionUtils.getPartition(db, table, partitionSpec, true);
+          outputs.add(new WriteEntity(partition, writeType));
+        }
       } else {
         validatePartSpec(table, partitionSpec, (ASTNode) root.getChild(1), conf, false);
         for (Partition partition : PartitionUtils.getPartitions(db, table, partitionSpec, false)) {
@@ -182,7 +221,7 @@ public class TruncateTableAnalyzer extends AbstractBaseAlterTableAnalyzer {
 
   @SuppressWarnings("rawtypes")
   private Task<?> truncatePartitionedTableWithColumnNames(ASTNode root, TableName tableName, Table table,
-      Map<String, String> partitionSpec, List<String> columnNames) throws HiveException, SemanticException {
+      Map<String, String> partitionSpec, List<String> columnNames) throws HiveException {
     Partition partition = db.getPartition(table, partitionSpec, false);
 
     Path tablePath = table.getPath();
@@ -338,4 +377,28 @@ public class TruncateTableAnalyzer extends AbstractBaseAlterTableAnalyzer {
       moveTask.addDependentTask(statTask);
     }
   }
+
+  public StringBuilder constructDeleteQuery(String qualifiedTableName, Table table, Map<String, String> partitionSpec)
+      throws SemanticException {
+    StringBuilder sb = new StringBuilder().append("delete from ").append(qualifiedTableName)
+            .append(" where ");
+    boolean first = true;
+    for (String key : partitionSpec.keySet()) {
+      ColumnInfo columnInfo = table.getStorageHandler().getColumnInfo(table, key);
+      if (columnInfo.getObjectInspector() instanceof PrimitiveObjectInspector) {
+        PrimitiveObjectInspector primitiveObjInspector = (PrimitiveObjectInspector) columnInfo.getObjectInspector();
+        String value = partitionSpec.get(key);
+        if (value != null) {
+          sb.append(first ? "" : " and ").append(HiveUtils.unparseIdentifier(key, conf)).append(" = ")
+            .append(TypeInfoUtils.convertStringToLiteralForSQL(value, primitiveObjInspector.getPrimitiveCategory()));
+        }
+      } else {
+        throw new SemanticException(String.format(
+            "Only primitive partition column type is supported via TRUNCATE operation " +
+            " but column %s is not a primitive category.", key));
+      }
+      first = false;
+    }
+    return sb;
+  }
 }
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java b/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java
index eed17ff0738..7632ffd9141 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java
@@ -1528,7 +1528,7 @@ public class Hive {
 
       // TODO: APIs with catalog names
       List<String> partNames = ((null == partSpec)
-        ? null : getPartitionNames(table.getDbName(), table.getTableName(), partSpec, (short) -1));
+              ? null : getPartitionNames(table.getDbName(), table.getTableName(), partSpec, (short) -1));
       if (snapshot == null) {
         getMSC().truncateTable(table.getDbName(), table.getTableName(), partNames);
       } else {
@@ -4036,6 +4036,9 @@ private void constructOneLBLocationMap(FileStatus fSta,
       Map<String, String> partSpec, short max) throws HiveException {
     List<String> names = null;
     Table t = getTable(dbName, tblName);
+    if (t.getStorageHandler() != null && t.getStorageHandler().alwaysUnpartitioned()) {
+      return t.getStorageHandler().getPartitionNames(t, partSpec);
+    }
 
     List<String> pvals = MetaStoreUtils.getPvals(t.getPartCols(), partSpec);
 
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/metadata/HiveStorageHandler.java b/ql/src/java/org/apache/hadoop/hive/ql/metadata/HiveStorageHandler.java
index 0b6d7ecf8dd..4d89b0d8114 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/metadata/HiveStorageHandler.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/metadata/HiveStorageHandler.java
@@ -42,6 +42,7 @@ import org.apache.hadoop.hive.ql.ErrorMsg;
 import org.apache.hadoop.hive.ql.ddl.table.AbstractAlterTableDesc;
 import org.apache.hadoop.hive.ql.ddl.table.AlterTableType;
 import org.apache.hadoop.hive.ql.ddl.table.create.like.CreateTableLikeDesc;
+import org.apache.hadoop.hive.ql.exec.ColumnInfo;
 import org.apache.hadoop.hive.ql.hooks.WriteEntity;
 import org.apache.hadoop.hive.ql.io.StorageFormatDescriptor;
 import org.apache.hadoop.hive.ql.parse.AlterTableSnapshotRefSpec;
@@ -700,4 +701,21 @@ public interface HiveStorageHandler extends Configurable {
     throw new UnsupportedOperationException("Storage handler does not support validation of partition values");
   }
 
+  default boolean canUseTruncate(org.apache.hadoop.hive.ql.metadata.Table hmsTable, Map<String, String> partitionSpec)
+      throws SemanticException {
+    return true;
+  }
+
+  default List<String> getPartitionNames(org.apache.hadoop.hive.ql.metadata.Table hmsTable,
+      Map<String, String> partitionSpec) throws SemanticException {
+    throw new UnsupportedOperationException("Storage handler does not support getting partitions " +
+            "by a partition specification.");
+  }
+
+  default ColumnInfo getColumnInfo(org.apache.hadoop.hive.ql.metadata.Table hmsTable, String colName)
+      throws SemanticException {
+    throw new UnsupportedOperationException("Storage handler does not support getting column type " +
+            "for a specific column.");
+  }
+
 }
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/AcidExportSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/AcidExportSemanticAnalyzer.java
index 301bbbdddbf..8fbb6c2ae60 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/parse/AcidExportSemanticAnalyzer.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/AcidExportSemanticAnalyzer.java
@@ -17,7 +17,6 @@
  */
 package org.apache.hadoop.hive.ql.parse;
 
-import java.io.IOException;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -50,6 +49,7 @@ import org.apache.hadoop.hive.ql.metadata.Hive;
 import org.apache.hadoop.hive.ql.metadata.HiveException;
 import org.apache.hadoop.hive.ql.metadata.HiveUtils;
 import org.apache.hadoop.hive.ql.metadata.Table;
+import org.apache.hadoop.hive.ql.parse.ParseUtils.ReparseResult;
 import org.apache.hadoop.hive.ql.plan.ExportWork;
 import org.apache.hadoop.hive.ql.session.SessionState;
 
@@ -174,7 +174,7 @@ public class AcidExportSemanticAnalyzer extends RewriteSemanticAnalyzer {
     //insert into newTableName select * from ts <where partition spec>
     StringBuilder rewrittenQueryStr = generateExportQuery(
             newTable.getPartCols(), tokRefOrNameExportTable, (ASTNode) tokRefOrNameExportTable.parent, newTableName);
-    ReparseResult rr = parseRewrittenQuery(rewrittenQueryStr, ctx.getCmd());
+    ReparseResult rr = ParseUtils.parseRewrittenQuery(ctx, rewrittenQueryStr);
     Context rewrittenCtx = rr.rewrittenCtx;
     rewrittenCtx.setIsUpdateDeleteMerge(false); //it's set in parseRewrittenQuery()
     ASTNode rewrittenTree = rr.rewrittenTree;
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/BaseSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/BaseSemanticAnalyzer.java
index f7230432000..0989c412dfa 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/parse/BaseSemanticAnalyzer.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/BaseSemanticAnalyzer.java
@@ -76,6 +76,7 @@ import org.apache.hadoop.hive.ql.io.IgnoreKeyTextOutputFormat;
 import org.apache.hadoop.hive.ql.lib.Node;
 import org.apache.hadoop.hive.ql.lockmgr.HiveTxnManager;
 import org.apache.hadoop.hive.ql.metadata.Hive;
+import org.apache.hadoop.hive.ql.metadata.HiveUtils;
 import org.apache.hadoop.hive.ql.metadata.HiveException;
 import org.apache.hadoop.hive.ql.metadata.InvalidTableException;
 import org.apache.hadoop.hive.ql.metadata.Partition;
@@ -2062,4 +2063,20 @@ public abstract class BaseSemanticAnalyzer {
     return oSpec;
   }
 
+  /**
+   * @return table name in db.table form with proper quoting/escaping to be used in a SQL statement
+   */
+  protected String getFullTableNameForSQL(ASTNode n) throws SemanticException {
+    switch (n.getType()) {
+      case HiveParser.TOK_TABNAME:
+        TableName tableName = getQualifiedTableName(n);
+        return HiveTableName.ofNullable(HiveUtils.unparseIdentifier(tableName.getTable(), this.conf),
+                HiveUtils.unparseIdentifier(tableName.getDb(), this.conf), tableName.getTableMetaRef()).getNotEmptyDbTable();
+      case HiveParser.TOK_TABREF:
+        return getFullTableNameForSQL((ASTNode) n.getChild(0));
+      default:
+        throw raiseWrongType("TOK_TABNAME", n);
+    }
+  }
+
 }
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/MergeSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/MergeSemanticAnalyzer.java
index 74158d1619e..1a3d8bdeec8 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/parse/MergeSemanticAnalyzer.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/MergeSemanticAnalyzer.java
@@ -39,6 +39,7 @@ import org.apache.hadoop.hive.ql.lib.Node;
 import org.apache.hadoop.hive.ql.metadata.HiveException;
 import org.apache.hadoop.hive.ql.metadata.HiveUtils;
 import org.apache.hadoop.hive.ql.metadata.Table;
+import org.apache.hadoop.hive.ql.parse.ParseUtils.ReparseResult;
 import org.apache.hadoop.hive.ql.session.SessionState;
 
 
@@ -227,7 +228,7 @@ public class MergeSemanticAnalyzer extends RewriteSemanticAnalyzer {
 
     boolean validating = handleCardinalityViolation(rewrittenQueryStr, targetNameNode, onClauseAsText, targetTable,
         numWhenMatchedDeleteClauses == 0 && numWhenMatchedUpdateClauses == 0, columnAppender);
-    ReparseResult rr = parseRewrittenQuery(rewrittenQueryStr, ctx.getCmd());
+    ReparseResult rr = ParseUtils.parseRewrittenQuery(ctx, rewrittenQueryStr);
     Context rewrittenCtx = rr.rewrittenCtx;
     ASTNode rewrittenTree = rr.rewrittenTree;
     rewrittenCtx.setOperation(Context.Operation.MERGE);
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/ParseUtils.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/ParseUtils.java
index 04483dc9ff3..9eefe23d147 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/parse/ParseUtils.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/ParseUtils.java
@@ -672,4 +672,50 @@ public final class ParseUtils {
     }
     return val;
   }
+
+  /**
+   * Parse the newly generated SQL statement to get a new AST.
+   */
+  public static ReparseResult parseRewrittenQuery(Context ctx,
+      StringBuilder rewrittenQueryStr)
+      throws SemanticException {
+    // Set dynamic partitioning to nonstrict so that queries do not need any partition
+    // references.
+    // TODO: this may be a perf issue as it prevents the optimizer.. or not
+    HiveConf.setVar(ctx.getConf(), HiveConf.ConfVars.DYNAMICPARTITIONINGMODE, "nonstrict");
+    // Disable LLAP IO wrapper; doesn't propagate extra ACID columns correctly.
+    HiveConf.setBoolVar(ctx.getConf(), HiveConf.ConfVars.LLAP_IO_ROW_WRAPPER_ENABLED, false);
+    // Parse the rewritten query string
+    Context rewrittenCtx;
+    rewrittenCtx = new Context(ctx.getConf());
+    rewrittenCtx.setHDFSCleanup(true);
+    // We keep track of all the contexts that are created by this query
+    // so we can clear them when we finish execution
+    ctx.addSubContext(rewrittenCtx);
+    rewrittenCtx.setExplainConfig(ctx.getExplainConfig());
+    rewrittenCtx.setExplainPlan(ctx.isExplainPlan());
+    rewrittenCtx.setStatsSource(ctx.getStatsSource());
+    rewrittenCtx.setPlanMapper(ctx.getPlanMapper());
+    rewrittenCtx.setIsUpdateDeleteMerge(true);
+    rewrittenCtx.setCmd(rewrittenQueryStr.toString());
+
+    ASTNode rewrittenTree;
+    try {
+      LOG.info("Going to reparse <" + ctx.getCmd() + "> as \n<" + rewrittenQueryStr.toString() + ">");
+      rewrittenTree = ParseUtils.parse(rewrittenQueryStr.toString(), rewrittenCtx);
+    } catch (ParseException e) {
+      throw new SemanticException(ErrorMsg.UPDATEDELETE_PARSE_ERROR.getMsg(), e);
+    }
+    return new ReparseResult(rewrittenTree, rewrittenCtx);
+  }
+
+  public static final class ReparseResult {
+    public final ASTNode rewrittenTree;
+    public final Context rewrittenCtx;
+    ReparseResult(ASTNode n, Context c) {
+      rewrittenTree = n;
+      rewrittenCtx = c;
+    }
+  }
+
 }
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/RewriteSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/RewriteSemanticAnalyzer.java
index d5350feb543..469e85b3906 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/parse/RewriteSemanticAnalyzer.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/RewriteSemanticAnalyzer.java
@@ -29,7 +29,6 @@ import org.antlr.runtime.TokenRewriteStream;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hadoop.hive.common.TableName;
 import org.apache.hadoop.hive.conf.HiveConf;
-import org.apache.hadoop.hive.conf.HiveConf.ConfVars;
 import org.apache.hadoop.hive.metastore.TableType;
 import org.apache.hadoop.hive.metastore.api.FieldSchema;
 import org.apache.hadoop.hive.ql.Context;
@@ -296,41 +295,6 @@ public abstract class RewriteSemanticAnalyzer extends CalcitePlanner {
     }
   }
 
-  /**
-   * Parse the newly generated SQL statement to get a new AST.
-   */
-  protected ReparseResult parseRewrittenQuery(StringBuilder rewrittenQueryStr, String originalQuery)
-      throws SemanticException {
-    // Set dynamic partitioning to nonstrict so that queries do not need any partition
-    // references.
-    // TODO: this may be a perf issue as it prevents the optimizer.. or not
-    HiveConf.setVar(conf, HiveConf.ConfVars.DYNAMICPARTITIONINGMODE, "nonstrict");
-    // Disable LLAP IO wrapper; doesn't propagate extra ACID columns correctly.
-    HiveConf.setBoolVar(conf, ConfVars.LLAP_IO_ROW_WRAPPER_ENABLED, false);
-    // Parse the rewritten query string
-    Context rewrittenCtx;
-    rewrittenCtx = new Context(conf);
-    rewrittenCtx.setHDFSCleanup(true);
-    // We keep track of all the contexts that are created by this query
-    // so we can clear them when we finish execution
-    ctx.addSubContext(rewrittenCtx);
-    rewrittenCtx.setExplainConfig(ctx.getExplainConfig());
-    rewrittenCtx.setExplainPlan(ctx.isExplainPlan());
-    rewrittenCtx.setStatsSource(ctx.getStatsSource());
-    rewrittenCtx.setPlanMapper(ctx.getPlanMapper());
-    rewrittenCtx.setIsUpdateDeleteMerge(true);
-    rewrittenCtx.setCmd(rewrittenQueryStr.toString());
-
-    ASTNode rewrittenTree;
-    try {
-      LOG.info("Going to reparse <" + originalQuery + "> as \n<" + rewrittenQueryStr.toString() + ">");
-      rewrittenTree = ParseUtils.parse(rewrittenQueryStr.toString(), rewrittenCtx);
-    } catch (ParseException e) {
-      throw new SemanticException(ErrorMsg.UPDATEDELETE_PARSE_ERROR.getMsg(), e);
-    }
-    return new ReparseResult(rewrittenTree, rewrittenCtx);
-  }
-
   private void validateTxnManager(Table mTable) throws SemanticException {
     if (!AcidUtils.acidTableWithoutTransactions(mTable) && !getTxnMgr().supportsAcid()) {
       throw new SemanticException(ErrorMsg.ACID_OP_ON_NONACID_TXNMGR.getMsg());
@@ -476,15 +440,6 @@ public abstract class RewriteSemanticAnalyzer extends CalcitePlanner {
     return HiveUtils.unparseIdentifier(getSimpleTableNameBase(n), this.conf);
   }
 
-  protected static final class ReparseResult {
-    final ASTNode rewrittenTree;
-    final Context rewrittenCtx;
-    ReparseResult(ASTNode n, Context c) {
-      rewrittenTree = n;
-      rewrittenCtx = c;
-    }
-  }
-
   // Patch up the projection list for updates, putting back the original set expressions.
   // Walk through the projection list and replace the column names with the
   // expressions from the original update.  Under the TOK_SELECT (see above) the structure
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java
index cdebdc5ff47..13a1491b373 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java
@@ -15874,22 +15874,6 @@ public class SemanticAnalyzer extends BaseSemanticAnalyzer {
     JOIN_INSERT_DELETE_REBUILD
   }
 
-  /**
-   * @return table name in db.table form with proper quoting/escaping to be used in a SQL statement
-   */
-  protected String getFullTableNameForSQL(ASTNode n) throws SemanticException {
-    switch (n.getType()) {
-    case HiveParser.TOK_TABNAME:
-      TableName tableName = getQualifiedTableName(n);
-      return HiveTableName.ofNullable(HiveUtils.unparseIdentifier(tableName.getTable(), this.conf),
-          HiveUtils.unparseIdentifier(tableName.getDb(), this.conf), tableName.getTableMetaRef()).getNotEmptyDbTable();
-    case HiveParser.TOK_TABREF:
-      return getFullTableNameForSQL((ASTNode) n.getChild(0));
-    default:
-      throw raiseWrongType("TOK_TABNAME", n);
-    }
-  }
-
   /**
    * Append list of partition columns to Insert statement, i.e. the 1st set of partCol1,partCol2
    * INSERT INTO T PARTITION(partCol1,partCol2...) SELECT col1, ... partCol1,partCol2...
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/SplitUpdateSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/SplitUpdateSemanticAnalyzer.java
index 8aa8beae853..7bf93b819aa 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/parse/SplitUpdateSemanticAnalyzer.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/SplitUpdateSemanticAnalyzer.java
@@ -17,14 +17,13 @@
  */
 package org.apache.hadoop.hive.ql.parse;
 
-import org.apache.hadoop.hive.conf.HiveConf;
 import org.apache.hadoop.hive.metastore.api.FieldSchema;
 import org.apache.hadoop.hive.ql.Context;
 import org.apache.hadoop.hive.ql.QueryState;
-import org.apache.hadoop.hive.ql.io.AcidUtils;
 import org.apache.hadoop.hive.ql.lib.Node;
 import org.apache.hadoop.hive.ql.metadata.HiveUtils;
 import org.apache.hadoop.hive.ql.metadata.Table;
+import org.apache.hadoop.hive.ql.parse.ParseUtils.ReparseResult;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -32,7 +31,6 @@ import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 /**
  * A subclass of the {@link SemanticAnalyzer} that just handles
@@ -157,7 +155,7 @@ public class SplitUpdateSemanticAnalyzer extends RewriteSemanticAnalyzer {
     List<String> sortKeys = columnAppender.getSortKeys();
     appendSortBy(rewrittenQueryStr, sortKeys);
 
-    ReparseResult rr = parseRewrittenQuery(rewrittenQueryStr, ctx.getCmd());
+    ReparseResult rr = ParseUtils.parseRewrittenQuery(ctx, rewrittenQueryStr);
     Context rewrittenCtx = rr.rewrittenCtx;
     ASTNode rewrittenTree = rr.rewrittenTree;
 
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/TransformSpec.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/TransformSpec.java
index f25cbda5af8..6008a5f9a9e 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/parse/TransformSpec.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/TransformSpec.java
@@ -17,10 +17,14 @@
  */
 package org.apache.hadoop.hive.ql.parse;
 
+import java.util.Locale;
 import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class TransformSpec {
 
+  private static final Pattern HAS_WIDTH = Pattern.compile("(\\w+)\\[(\\d+)\\]");
   public enum TransformType {
     IDENTITY, YEAR, MONTH, DAY, HOUR, TRUNCATE, BUCKET, VOID
   }
@@ -61,4 +65,12 @@ public class TransformSpec {
   public void setTransformParam(Optional<Integer> transformParam) {
     this.transformParam = transformParam;
   }
+
+  public static TransformType fromString(String transformString) {
+    Matcher widthMatcher = HAS_WIDTH.matcher(transformString);
+    if (widthMatcher.matches()) {
+      transformString = widthMatcher.group(1);
+    }
+    return TransformType.valueOf(transformString.toUpperCase(Locale.ROOT));
+  }
 }
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/UpdateDeleteSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/UpdateDeleteSemanticAnalyzer.java
index 8caca5f5471..b8a7ad16b15 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/parse/UpdateDeleteSemanticAnalyzer.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/UpdateDeleteSemanticAnalyzer.java
@@ -34,6 +34,7 @@ import org.apache.hadoop.hive.ql.lib.Node;
 import org.apache.hadoop.hive.ql.metadata.HiveStorageHandler;
 import org.apache.hadoop.hive.ql.metadata.HiveUtils;
 import org.apache.hadoop.hive.ql.metadata.Table;
+import org.apache.hadoop.hive.ql.parse.ParseUtils.ReparseResult;
 
 /**
  * A subclass of the {@link org.apache.hadoop.hive.ql.parse.SemanticAnalyzer} that just handles
@@ -104,7 +105,7 @@ public class UpdateDeleteSemanticAnalyzer extends RewriteSemanticAnalyzer {
       && children.size() == 1 && deleting();
     if (shouldTruncate) {
       StringBuilder rewrittenQueryStr = new StringBuilder("truncate ").append(getFullTableNameForSQL(tabNameNode));
-      ReparseResult rr = parseRewrittenQuery(rewrittenQueryStr, ctx.getCmd());
+      ReparseResult rr = ParseUtils.parseRewrittenQuery(ctx, rewrittenQueryStr);
       Context rewrittenCtx = rr.rewrittenCtx;
       ASTNode rewrittenTree = rr.rewrittenTree;
 
@@ -210,7 +211,7 @@ public class UpdateDeleteSemanticAnalyzer extends RewriteSemanticAnalyzer {
       // Add a sort by clause so that the row ids come out in the correct order
       appendSortBy(rewrittenQueryStr, columnAppender.getSortKeys());
     }
-    ReparseResult rr = parseRewrittenQuery(rewrittenQueryStr, ctx.getCmd());
+    ReparseResult rr = ParseUtils.parseRewrittenQuery(ctx, rewrittenQueryStr);
     Context rewrittenCtx = rr.rewrittenCtx;
     ASTNode rewrittenTree = rr.rewrittenTree;
 
diff --git a/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoUtils.java b/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoUtils.java
index 4788558d4b8..4517dbb200c 100644
--- a/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoUtils.java
+++ b/serde/src/java/org/apache/hadoop/hive/serde2/typeinfo/TypeInfoUtils.java
@@ -1009,4 +1009,36 @@ public final class TypeInfoUtils {
     }
     return false;
   }
+
+  public static String convertStringToLiteralForSQL(String value, PrimitiveCategory category) {
+    if (shouldEncloseQuotes(category)) {
+      return "'" + value.replace("'", "\\'") + "'";
+    }
+    return value;
+  }
+
+  private static boolean shouldEncloseQuotes(PrimitiveCategory category) {
+    switch(category) {
+      case STRING:
+      case DATE:
+      case TIMESTAMP:
+      case TIMESTAMPLOCALTZ:
+      case BINARY:
+      case INTERVAL_DAY_TIME:
+      case INTERVAL_YEAR_MONTH:
+        return true;
+      case VOID:
+      case BOOLEAN:
+      case BYTE:
+      case SHORT:
+      case INT:
+      case LONG:
+      case FLOAT:
+      case DOUBLE:
+      case DECIMAL:
+      case UNKNOWN:
+      default:
+        return false;
+    }
+  }
 }
diff --git a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaHook.java b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaHook.java
index 6a534c1669a..5986015a513 100644
--- a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaHook.java
+++ b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaHook.java
@@ -175,6 +175,10 @@ public interface HiveMetaHook {
    * @throws MetaException
    */
   public default void preTruncateTable(Table table, EnvironmentContext context) throws MetaException {
+    preTruncateTable(table, context, null);
+  }
+
+  public default void preTruncateTable(Table table, EnvironmentContext context, List<String> partNames) throws MetaException {
     // Do nothing
   }
 
diff --git a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
index 58c83417a87..228baed81ae 100644
--- a/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
+++ b/standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
@@ -2098,7 +2098,7 @@ public class HiveMetaStoreClient implements IMetaStoreClient, AutoCloseable {
     EnvironmentContext context = new EnvironmentContext();
     context.putToProperties(TRUNCATE_SKIP_DATA_DELETION, Boolean.toString(!deleteData));
     if (hook != null) {
-      hook.preTruncateTable(table, context);
+      hook.preTruncateTable(table, context, partNames);
     }
     TruncateTableRequest req = new TruncateTableRequest(
         prependCatalogToDbName(catName, dbName, conf), tableName);