Caideyipi commented on code in PR #17079: URL: https://github.com/apache/iotdb/pull/17079#discussion_r2939047361
########## iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/tsfile/evolution/EvolvedSchema.java: ########## @@ -0,0 +1,538 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * <p> + * http://www.apache.org/licenses/LICENSE-2.0 + * <p> + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.iotdb.db.storageengine.dataregion.tsfile.evolution; + +import org.apache.iotdb.db.storageengine.dataregion.modification.DeletionPredicate; +import org.apache.iotdb.db.storageengine.dataregion.modification.ModEntry; +import org.apache.iotdb.db.storageengine.dataregion.modification.ModEntry.ModType; +import org.apache.iotdb.db.storageengine.dataregion.modification.TableDeletionEntry; +import org.apache.iotdb.db.storageengine.dataregion.modification.TagPredicate; +import org.apache.iotdb.db.utils.io.IOUtils; + +import org.apache.tsfile.enums.ColumnCategory; +import org.apache.tsfile.file.metadata.AbstractAlignedChunkMetadata; +import org.apache.tsfile.file.metadata.IChunkMetadata; +import org.apache.tsfile.file.metadata.IDeviceID; +import org.apache.tsfile.file.metadata.IDeviceID.Factory; +import org.apache.tsfile.file.metadata.TableSchema; +import org.apache.tsfile.file.metadata.TimeseriesMetadata; +import org.apache.tsfile.utils.Accountable; +import org.apache.tsfile.utils.PublicBAOS; +import org.apache.tsfile.utils.RamUsageEstimator; +import org.apache.tsfile.utils.ReadWriteForEncodingUtils; +import org.apache.tsfile.utils.ReadWriteIOUtils; +import org.apache.tsfile.write.schema.IMeasurementSchema; +import org.apache.tsfile.write.schema.MeasurementSchema; +import org.apache.tsfile.write.schema.Schema; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Objects; +import java.util.function.Function; +import java.util.stream.Collectors; + +public class EvolvedSchema implements Accountable, SchemaEvolution { + + private static final Logger LOGGER = LoggerFactory.getLogger(EvolvedSchema.class); + // the evolved table names after applying all schema evolution operations + private Map<String, String> finalToOriginalTableNames = new LinkedHashMap<>(); + + /** + * the first key is the evolved table name, the second key is the evolved column name, and the + * value is the original column name before any schema evolution. + */ + private Map<String, Map<String, String>> finalToOriginalColumnNames = new LinkedHashMap<>(); + + // the reversed version of finalToOriginalTableNames + private Map<String, String> originalToFinalTableNames = new LinkedHashMap<>(); + + // the reversed version of finalToOriginalColumnNames + private Map<String, Map<String, String>> originalToFinalColumnNames = new LinkedHashMap<>(); + + public void renameTable(String oldTableName, String newTableName) { + if (!finalToOriginalTableNames.containsKey(oldTableName) + || finalToOriginalTableNames.get(oldTableName).isEmpty()) { + finalToOriginalTableNames.put(newTableName, oldTableName); + finalToOriginalTableNames.put(oldTableName, ""); + originalToFinalTableNames.put(oldTableName, newTableName); + } else { + // mark the old table name as non-exists (empty) + String originalName = finalToOriginalTableNames.put(oldTableName, ""); + finalToOriginalTableNames.put(newTableName, originalName); + originalToFinalTableNames.put(originalName, newTableName); + } + + if (finalToOriginalColumnNames.containsKey(oldTableName)) { + Map<String, String> columnMap = finalToOriginalColumnNames.remove(oldTableName); + finalToOriginalColumnNames.put(newTableName, columnMap); + } + } + + public void renameColumn(String newTableName, String oldColumnName, String newColumnName) { + Map<String, String> finalToOriginalMap = + finalToOriginalColumnNames.computeIfAbsent(newTableName, t -> new LinkedHashMap<>()); + String originalTableName = getOriginalTableName(newTableName); + if (!finalToOriginalMap.containsKey(oldColumnName) + || finalToOriginalMap.get(oldColumnName).isEmpty()) { + finalToOriginalMap.put(newColumnName, oldColumnName); + finalToOriginalMap.put(oldColumnName, ""); + originalToFinalColumnNames + .computeIfAbsent(originalTableName, t -> new LinkedHashMap<>()) + .put(oldColumnName, newColumnName); + } else { + // mark the old column name as non-exists + String originalName = finalToOriginalMap.put(oldColumnName, ""); + if (!newColumnName.equals(originalName)) { + finalToOriginalMap.put(newColumnName, originalName); + originalToFinalColumnNames + .computeIfAbsent(originalTableName, t -> new LinkedHashMap<>()) + .put(originalName, newColumnName); + } else { + // the new name is the same as the original name, remove the mapping + finalToOriginalMap.remove(newColumnName); + finalToOriginalMap.remove(oldColumnName); + if (finalToOriginalMap.isEmpty()) { + finalToOriginalColumnNames.remove(newTableName); + } + + Map<String, String> originalToFinalMap = originalToFinalColumnNames.get(originalTableName); + if (originalToFinalMap != null) { + originalToFinalMap.remove(originalName); + if (originalToFinalMap.isEmpty()) { + originalToFinalColumnNames.remove(originalTableName); + } + } + } + } + } + + public String getOriginalTableName(String finalTableName) { + return finalToOriginalTableNames.getOrDefault(finalTableName, finalTableName); + } + + public String getFinalTableName(String originalTableName) { + return originalToFinalTableNames.getOrDefault(originalTableName, originalTableName); + } + + public String getOriginalColumnName(String tableName, String evolvedColumnName) { + Map<String, String> columnNameMap = finalToOriginalColumnNames.get(tableName); + if (columnNameMap == null) { + return evolvedColumnName; + } + return columnNameMap.getOrDefault(evolvedColumnName, evolvedColumnName); + } + + public String getFinalColumnName(String originalTableName, String originalColumnName) { + return originalToFinalColumnNames + .getOrDefault(originalTableName, Collections.emptyMap()) + .getOrDefault(originalColumnName, originalColumnName); + } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + EvolvedSchema that = (EvolvedSchema) o; + return Objects.equals(finalToOriginalTableNames, that.finalToOriginalTableNames) + && Objects.equals(finalToOriginalColumnNames, that.finalToOriginalColumnNames); + } + + @Override + public int hashCode() { + return Objects.hash(finalToOriginalTableNames, finalToOriginalColumnNames); + } + + @Override + public String toString() { + return "EvolvedSchema{" + + "finalToOriginalTableNames=" + + finalToOriginalTableNames + + ", finalToOriginalColumnNames=" + + finalToOriginalColumnNames + + ", originalToFinalTableNames=" + + originalToFinalTableNames + + ", originalToFinalColumnNames=" + + originalToFinalColumnNames + + '}'; + } + + public ByteBuffer toSchemaEvolutionFileBuffer() { + PublicBAOS publicBAOS = new PublicBAOS(); + try { + ReadWriteIOUtils.write(0L, publicBAOS); + this.serialize(publicBAOS); + } catch (IOException e) { + // ignored + } + + ByteBuffer buffer = ByteBuffer.wrap(publicBAOS.getBuf(), 0, publicBAOS.size()); + buffer.putLong(0, buffer.limit()); + buffer.position(0); + return buffer; + } + + public ModEntry rewriteToOriginal(ModEntry entry) { + if (entry.getType() == ModType.TABLE_DELETION) { + return rewriteToOriginal(((TableDeletionEntry) entry)); + } + return entry; + } + + public ModEntry rewriteToFinal(ModEntry entry) { + if (entry.getType() == ModType.TABLE_DELETION) { + return rewriteToFinal(((TableDeletionEntry) entry)); + } + return entry; + } + + public TableDeletionEntry rewriteToOriginal(TableDeletionEntry entry) { + DeletionPredicate deletionPredicate = rewriteToOriginal(entry.getPredicate()); + return new TableDeletionEntry(deletionPredicate, entry.getTimeRange()); + } + + public TableDeletionEntry rewriteToFinal(TableDeletionEntry entry) { + DeletionPredicate deletionPredicate = rewriteToFinal(entry.getPredicate()); + return new TableDeletionEntry(deletionPredicate, entry.getTimeRange()); + } + + private DeletionPredicate rewriteToFinal(DeletionPredicate predicate) { + String finalTableName = getFinalTableName(predicate.getTableName()); + TagPredicate tagPredicate = predicate.getTagPredicate(); + tagPredicate = tagPredicate.rewriteToOriginal(this); Review Comment: Is it really "original"? -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
