feat: support version diff (#52)

* feat: implementation diff processor

* fix: checkstyle

* feat: ignore sync if without change

* fix: checkstyle

* feat:add databasir diff api

* feat:update frontend resources

plugin/src/main/java/com/databasir/core/diff/Diffs.java

@@ -0,0 +1,17 @@
+package com.databasir.core.diff;
+
+import com.databasir.core.diff.data.RootDiff;
+import com.databasir.core.diff.processor.DatabaseDiffProcessor;
+import com.databasir.core.meta.data.DatabaseMeta;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class Diffs {
+
+    private static final DatabaseDiffProcessor databaseDiffProcessor = new DatabaseDiffProcessor();
+
+    public static RootDiff diff(DatabaseMeta original, DatabaseMeta current) {
+        return databaseDiffProcessor.process(original, current);
+    }
+
+}

plugin/src/main/java/com/databasir/core/diff/data/Diff.java

@@ -0,0 +1,11 @@
+package com.databasir.core.diff.data;
+
+public interface Diff {
+
+    DiffType getDiffType();
+
+    Object getOriginal();
+
+    Object getCurrent();
+
+}

plugin/src/main/java/com/databasir/core/diff/data/DiffType.java

@@ -0,0 +1,9 @@
+package com.databasir.core.diff.data;
+
+public enum DiffType {
+    NONE, ADDED, REMOVED, MODIFIED;
+
+    public static boolean isModified(DiffType type) {
+        return type != null && type != NONE;
+    }
+}

plugin/src/main/java/com/databasir/core/diff/data/FieldDiff.java

@@ -0,0 +1,24 @@
+package com.databasir.core.diff.data;
+
+import lombok.Builder;
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@Builder
+public class FieldDiff implements Diff {
+
+    private String fieldName;
+
+    private DiffType diffType;
+
+    private Object original;
+
+    private Object current;
+
+    @Builder.Default
+    private List<FieldDiff> fields = new ArrayList<>();
+
+}

plugin/src/main/java/com/databasir/core/diff/data/RootDiff.java

@@ -0,0 +1,15 @@
+package com.databasir.core.diff.data;
+
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+public class RootDiff {
+
+    private DiffType diffType;
+
+    private List<FieldDiff> fields = new ArrayList<>();
+
+}

plugin/src/main/java/com/databasir/core/diff/processor/ColumnDiffProcessor.java

@@ -0,0 +1,14 @@
+package com.databasir.core.diff.processor;
+
+import com.databasir.core.diff.data.FieldDiff;
+import com.databasir.core.meta.data.ColumnMeta;
+
+import java.util.List;
+
+public class ColumnDiffProcessor implements DiffProcessor<ColumnMeta> {
+
+    @Override
+    public FieldDiff process(String fieldName, List<ColumnMeta> original, List<ColumnMeta> current) {
+        return diffTableField(original, current, fieldName, ColumnMeta::getName);
+    }
+}

plugin/src/main/java/com/databasir/core/diff/processor/DatabaseDiffProcessor.java

@@ -0,0 +1,81 @@
+package com.databasir.core.diff.processor;
+
+import com.databasir.core.diff.data.DiffType;
+import com.databasir.core.diff.data.FieldDiff;
+import com.databasir.core.diff.data.RootDiff;
+import com.databasir.core.meta.data.DatabaseMeta;
+import lombok.extern.slf4j.Slf4j;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+@Slf4j
+public class DatabaseDiffProcessor {
+
+    private final TableDiffProcessor tableDiffProcessor = new TableDiffProcessor();
+
+    private static final DatabaseMeta EMPTY = DatabaseMeta.builder().build();
+
+    public RootDiff process(DatabaseMeta original, DatabaseMeta current) {
+        DiffType diffType = null;
+        if (original == null && current != null) {
+            diffType = DiffType.ADDED;
+        }
+        if (original != null && current == null) {
+            diffType = DiffType.REMOVED;
+        }
+        List<FieldDiff> fields = diffDatabaseFields(
+                Objects.requireNonNullElse(original, EMPTY),
+                Objects.requireNonNullElse(current, EMPTY)
+        );
+        boolean isModified = fields.stream().anyMatch(f -> DiffType.isModified(f.getDiffType()));
+        if (diffType == null) {
+            diffType = isModified ? DiffType.MODIFIED : DiffType.NONE;
+        }
+        RootDiff diff = new RootDiff();
+        diff.setFields(fields);
+        diff.setDiffType(diffType);
+        return diff;
+    }
+
+    private List<FieldDiff> diffDatabaseFields(DatabaseMeta original, DatabaseMeta current) {
+        Class<DatabaseMeta> clazz = DatabaseMeta.class;
+        Field[] fields = clazz.getDeclaredFields();
+        List<FieldDiff> diffs = new ArrayList<>(32);
+        // ignore tables diff
+        Arrays.stream(fields)
+                .filter(field -> !Objects.equals(field.getName(), "tables"))
+                .forEach(field -> {
+                    try {
+                        field.setAccessible(true);
+                        Object originalValue = original == null ? null : field.get(original);
+                        Object currentValue = current == null ? null : field.get(current);
+                        if (!Objects.equals(originalValue, currentValue)) {
+                            DiffType diffType;
+                            if (originalValue == null) {
+                                diffType = DiffType.ADDED;
+                            } else if (currentValue == null) {
+                                diffType = DiffType.REMOVED;
+                            } else {
+                                diffType = DiffType.MODIFIED;
+                            }
+                            diffs.add(FieldDiff.builder()
+                                    .diffType(diffType)
+                                    .fieldName(field.getName())
+                                    .original(originalValue)
+                                    .current(currentValue)
+                                    .build());
+                        }
+                    } catch (IllegalAccessException e) {
+                        log.error("diff field failed", e);
+                    }
+                });
+
+        FieldDiff tablesField = tableDiffProcessor.process("tables", original.getTables(), current.getTables());
+        diffs.add(tablesField);
+        return diffs;
+    }
+}

plugin/src/main/java/com/databasir/core/diff/processor/DiffProcessor.java

@@ -0,0 +1,94 @@
+package com.databasir.core.diff.processor;
+
+import com.databasir.core.diff.data.DiffType;
+import com.databasir.core.diff.data.FieldDiff;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public interface DiffProcessor<T> {
+
+    FieldDiff process(String fieldName, List<T> original, List<T> current);
+
+    default FieldDiff diffTableField(List<T> original,
+                                     List<T> current,
+                                     String fieldName,
+                                     Function<T, String> identity) {
+        Map<String, T> originalMap = toMap(original, identity);
+        Map<String, T> currentMap = toMap(current, identity);
+        List<FieldDiff> columnFieldDiffs = new ArrayList<>(32);
+        // removed
+        List<FieldDiff> removedFields = originalRemovedField(originalMap, currentMap);
+        columnFieldDiffs.addAll(removedFields);
+        // added
+        List<FieldDiff> addedFields = currentAddedField(originalMap, currentMap);
+        columnFieldDiffs.addAll(addedFields);
+        // modified
+        List<FieldDiff> modifiedFields = modifiedField(originalMap, currentMap);
+        columnFieldDiffs.addAll(modifiedFields);
+        return FieldDiff.builder()
+                .fieldName(fieldName)
+                .diffType(columnFieldDiffs.isEmpty() ? DiffType.NONE : DiffType.MODIFIED)
+                .fields(columnFieldDiffs)
+                .build();
+
+    }
+
+    default Map<String, T> toMap(List<T> content, Function<T, String> idMapping) {
+        return content
+                .stream()
+                .collect(Collectors.toMap(idMapping, Function.identity()));
+    }
+
+    default List<FieldDiff> originalRemovedField(Map<String, T> originalMapById,
+                                                 Map<String, T> currentMapById) {
+        return originalMapById.entrySet()
+                .stream()
+                .filter(entry -> !currentMapById.containsKey(entry.getKey()))
+                .map(entry -> FieldDiff.builder()
+                        .fieldName(entry.getKey())
+                        .original(entry.getValue())
+                        .diffType(DiffType.REMOVED)
+                        .build())
+                .collect(Collectors.toList());
+    }
+
+    default List<FieldDiff> currentAddedField(Map<String, T> originalMapById,
+                                              Map<String, T> currentMapById) {
+        return currentMapById.entrySet()
+                .stream()
+                .filter(entry -> !originalMapById.containsKey(entry.getKey()))
+                .map(entry -> FieldDiff.builder()
+                        .fieldName(entry.getKey())
+                        .current(entry.getValue())
+                        .diffType(DiffType.ADDED)
+                        .build())
+                .collect(Collectors.toList());
+    }
+
+    default List<FieldDiff> modifiedField(Map<String, T> original,
+                                          Map<String, T> current) {
+        List<FieldDiff> diff = new ArrayList<>();
+        original.entrySet()
+                .stream()
+                .filter(entry -> current.containsKey(entry.getKey()))
+                .forEach(entry -> {
+                    T originalValue = entry.getValue();
+                    T currentValue = current.get(entry.getKey());
+                    if (!Objects.equals(originalValue, currentValue)) {
+                        FieldDiff fieldDiff = FieldDiff.builder()
+                                .fieldName(entry.getKey())
+                                .original(originalValue)
+                                .current(currentValue)
+                                .diffType(DiffType.MODIFIED)
+                                .build();
+                        diff.add(fieldDiff);
+                    }
+                });
+        return diff;
+    }
+}

plugin/src/main/java/com/databasir/core/diff/processor/ForeignKeyDiffProcessor.java

@@ -0,0 +1,24 @@
+package com.databasir.core.diff.processor;
+
+import com.databasir.core.diff.data.FieldDiff;
+import com.databasir.core.meta.data.ForeignKeyMeta;
+
+import java.util.List;
+
+public class ForeignKeyDiffProcessor implements DiffProcessor<ForeignKeyMeta> {
+
+    @Override
+    public FieldDiff process(String fieldName, List<ForeignKeyMeta> original, List<ForeignKeyMeta> current) {
+        return diffTableField(
+                original,
+                current,
+                "foreignKeys",
+                fk -> {
+                    if (fk.getFkName() == null) {
+                        return fk.getFkTableName() + "." + fk.getFkColumnName() + "." + fk.getKeySeq();
+                    } else {
+                        return fk.getFkName();
+                    }
+                });
+    }
+}

plugin/src/main/java/com/databasir/core/diff/processor/IndexDiffProcessor.java

@@ -0,0 +1,14 @@
+package com.databasir.core.diff.processor;
+
+import com.databasir.core.diff.data.FieldDiff;
+import com.databasir.core.meta.data.IndexMeta;
+
+import java.util.List;
+
+public class IndexDiffProcessor implements DiffProcessor<IndexMeta> {
+
+    @Override
+    public FieldDiff process(String fieldName, List<IndexMeta> original, List<IndexMeta> current) {
+        return diffTableField(original, current, fieldName, IndexMeta::getName);
+    }
+}

plugin/src/main/java/com/databasir/core/diff/processor/TableDiffProcessor.java

@@ -0,0 +1,158 @@
+package com.databasir.core.diff.processor;
+
+import com.databasir.core.diff.data.DiffType;
+import com.databasir.core.diff.data.FieldDiff;
+import com.databasir.core.meta.data.TableMeta;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Slf4j
+public class TableDiffProcessor implements DiffProcessor<TableMeta> {
+
+    private final IndexDiffProcessor indexDiffProcessor = new IndexDiffProcessor();
+
+    private final ColumnDiffProcessor columnDiffProcessor = new ColumnDiffProcessor();
+
+    private final TriggerDiffProcessor triggerDiffProcessor = new TriggerDiffProcessor();
+
+    private final ForeignKeyDiffProcessor foreignKeyDiffProcessor = new ForeignKeyDiffProcessor();
+
+    private static final TableMeta EMPTY = new TableMeta();
+
+    @Override
+    public FieldDiff process(String fieldName, List<TableMeta> original, List<TableMeta> current) {
+        // diff tables field
+        Map<String, TableMeta> originalMap = toMap(original, TableMeta::getName);
+        Map<String, TableMeta> currentMap = toMap(current, TableMeta::getName);
+        List<FieldDiff> tables = new ArrayList<>();
+        List<TableMeta> added = added(originalMap, currentMap);
+        List<TableMeta> removed = removed(originalMap, currentMap);
+        // added
+        List<FieldDiff> addedFields = added.stream()
+                .map(table -> diffTableField(EMPTY, table))
+                .collect(Collectors.toList());
+        tables.addAll(addedFields);
+        // removed
+        List<FieldDiff> removedFields = removed.stream()
+                .map(table -> diffTableField(table, EMPTY))
+                .collect(Collectors.toList());
+        tables.addAll(removedFields);
+        // modified
+        List<FieldDiff> modified = originalMap.entrySet()
+                .stream()
+                .filter(entry -> currentMap.containsKey(entry.getKey()))
+                .filter(entry -> !Objects.equals(entry.getValue(), currentMap.get(entry.getKey())))
+                .map(entry -> {
+                    TableMeta originalValue = entry.getValue();
+                    TableMeta currentValue = currentMap.get(entry.getKey());
+                    return diffTableField(originalValue, currentValue);
+                })
+                .collect(Collectors.toList());
+        tables.addAll(modified);
+        DiffType tablesDiffType;
+        if (!modified.isEmpty()) {
+            tablesDiffType = DiffType.MODIFIED;
+        } else if (!addedFields.isEmpty()) {
+            tablesDiffType = DiffType.ADDED;
+        } else if (!removedFields.isEmpty()) {
+            tablesDiffType = DiffType.REMOVED;
+        } else {
+            tablesDiffType = DiffType.NONE;
+        }
+        FieldDiff tablesField = FieldDiff.builder()
+                .diffType(tablesDiffType)
+                .fieldName(fieldName)
+                .fields(tables)
+                .build();
+        return tablesField;
+    }
+
+    private List<TableMeta> added(Map<String, TableMeta> originalMap,
+                                  Map<String, TableMeta> currentMap) {
+        return currentMap.entrySet()
+                .stream()
+                .filter(entry -> !originalMap.containsKey(entry.getKey()))
+                .map(Map.Entry::getValue)
+                .collect(Collectors.toList());
+    }
+
+    private List<TableMeta> removed(Map<String, TableMeta> originalMap,
+                                    Map<String, TableMeta> currentMap) {
+        return originalMap.entrySet()
+                .stream()
+                .filter(entry -> !currentMap.containsKey(entry.getKey()))
+                .map(Map.Entry::getValue)
+                .collect(Collectors.toList());
+    }
+
+    private FieldDiff diffTableField(TableMeta original, TableMeta current) {
+        FieldDiff columns =
+                columnDiffProcessor.process("columns", original.getColumns(), current.getColumns());
+        FieldDiff indexes =
+                indexDiffProcessor.process("indexes", original.getIndexes(), current.getIndexes());
+        FieldDiff triggers =
+                triggerDiffProcessor.process("triggers", original.getTriggers(), current.getTriggers());
+        FieldDiff foreignKeys =
+                foreignKeyDiffProcessor.process("foreignKeys", original.getForeignKeys(), current.getForeignKeys());
+        List<FieldDiff> otherFields = fields(original, current);
+
+        List<FieldDiff> fields = new ArrayList<>();
+        fields.add(columns);
+        fields.add(indexes);
+        fields.add(foreignKeys);
+        fields.add(triggers);
+        fields.addAll(otherFields);
+        DiffType diffType;
+        if (original == EMPTY) {
+            diffType = DiffType.ADDED;
+        } else if (current == EMPTY) {
+            diffType = DiffType.REMOVED;
+        } else {
+            diffType = DiffType.MODIFIED;
+        }
+        return FieldDiff.builder()
+                .diffType(diffType)
+                .fieldName(original == EMPTY ? current.getName() : original.getName())
+                .original(current == EMPTY ? original : null)
+                .current(original == EMPTY ? current : null)
+                .fields(fields)
+                .build();
+    }
+
+    private List<FieldDiff> fields(TableMeta original, TableMeta current) {
+        List<FieldDiff> fields = new ArrayList<>();
+        // ignore tables diff
+        Class<TableMeta> clazz = TableMeta.class;
+        List<String> ignoredFields = List.of("columns", "indexes", "triggers", "foreignKeys");
+        Arrays.stream(clazz.getDeclaredFields())
+                .filter(field -> !ignoredFields.contains(field.getName()))
+                .forEach(field -> {
+                    try {
+                        field.setAccessible(true);
+                        Object originalValue = original == null ? null : field.get(original);
+                        Object currentValue = current == null ? null : field.get(current);
+                        if (!Objects.equals(originalValue, currentValue)) {
+                            DiffType diffType;
+                            if (originalValue == null) {
+                                diffType = DiffType.ADDED;
+                            } else if (currentValue == null) {
+                                diffType = DiffType.REMOVED;
+                            } else {
+                                diffType = DiffType.MODIFIED;
+                            }
+                            fields.add(FieldDiff.builder()
+                                    .diffType(diffType)
+                                    .fieldName(field.getName())
+                                    .original(originalValue)
+                                    .current(currentValue)
+                                    .build());
+                        }
+                    } catch (IllegalAccessException e) {
+                        log.error("diff field failed", e);
+                    }
+                });
+        return fields;
+    }
+}

plugin/src/main/java/com/databasir/core/diff/processor/TriggerDiffProcessor.java

@@ -0,0 +1,14 @@
+package com.databasir.core.diff.processor;
+
+import com.databasir.core.diff.data.FieldDiff;
+import com.databasir.core.meta.data.TriggerMeta;
+
+import java.util.List;
+
+public class TriggerDiffProcessor implements DiffProcessor<TriggerMeta> {
+
+    @Override
+    public FieldDiff process(String fieldName, List<TriggerMeta> original, List<TriggerMeta> current) {
+        return diffTableField(original, current, fieldName, TriggerMeta::getName);
+    }
+}

plugin/src/main/java/com/databasir/core/meta/data/ColumnMeta.java

@@ -1,10 +1,14 @@
 package com.databasir.core.meta.data;
 
+import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
-@Data
 @Builder
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
 public class ColumnMeta {
 
     private String name;

plugin/src/main/java/com/databasir/core/meta/data/DatabaseMeta.java

@@ -1,12 +1,16 @@
 package com.databasir.core.meta.data;
 
+import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 import java.util.Collections;
 import java.util.List;
 
 @Data
+@NoArgsConstructor
+@AllArgsConstructor
 @Builder
 public class DatabaseMeta {
 

plugin/src/main/java/com/databasir/core/meta/data/ForeignKeyMeta.java

@@ -1,12 +1,18 @@
 package com.databasir.core.meta.data;
 
+import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
-@Data
 @Builder
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
 public class ForeignKeyMeta {
 
+    private Integer keySeq;
+
     /**
      * may null
      */

plugin/src/main/java/com/databasir/core/meta/data/IndexMeta.java

@@ -1,13 +1,17 @@
 package com.databasir.core.meta.data;
 
+import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 import java.util.Collections;
 import java.util.List;
 
-@Data
 @Builder
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
 public class IndexMeta {
 
     private String name;

plugin/src/main/java/com/databasir/core/meta/data/TableMeta.java

@@ -1,13 +1,17 @@
 package com.databasir.core.meta.data;
 
+import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 import java.util.Collections;
 import java.util.List;
 
-@Data
 @Builder
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
 public class TableMeta {
 
     private String name;
@@ -27,6 +31,4 @@ public class TableMeta {
 
     @Builder.Default
     private List<ForeignKeyMeta> foreignKeys = Collections.emptyList();
-
-    private String remark;
 }

plugin/src/main/java/com/databasir/core/meta/data/TriggerMeta.java

@@ -1,13 +1,17 @@
 package com.databasir.core.meta.data;
 
+import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 /**
  * now: only support mysql, postgresql.
  */
-@Data
 @Builder
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
 public class TriggerMeta {
 
     private String name;

plugin/src/main/java/com/databasir/core/meta/repository/impl/jdbc/JdbcForeignKeyMetaRepository.java

@@ -41,8 +41,10 @@ public class JdbcForeignKeyMetaRepository implements ForeignKeyMetaRepository {
                 String pkColumnName = keyResult.getString("PKCOLUMN_NAME");
                 String pkName = keyResult.getString("PK_NAME");
                 int updateRule = keyResult.getInt("UPDATE_RULE");
+                int keySeq = keyResult.getInt("KEY_SEQ");
                 int deleteRule = keyResult.getInt("DELETE_RULE");
                 ForeignKeyMeta meta = ForeignKeyMeta.builder()
+                        .keySeq(keySeq)
                         .fkTableName(fkTableName)
                         .fkColumnName(fkColumnName)
                         .fkName(fkName)

plugin/src/main/java/com/databasir/core/render/markdown/MarkdownRender.java

@@ -51,7 +51,7 @@ public class MarkdownRender implements Render {
 
     private void buildTableName(MarkdownBuilder contentBuilder, TableMeta table) {
         String tableName;
-        if (table.getComment() == null || table.getComment().trim().isEmpty()) {
+        if (table.getComment().isEmpty()) {
             tableName = table.getName();
         } else {
             tableName = table.getName() + "(" + table.getComment() + ")";