diff --git a/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/DiffActionReasonDifferent.java b/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/DiffActionReasonDifferent.java index 75451bf0..df3f8d89 100644 --- a/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/DiffActionReasonDifferent.java +++ b/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/DiffActionReasonDifferent.java @@ -5,11 +5,13 @@ import org.eclipse.emf.ecore.EStructuralFeature; +import de.opitzconsulting.orcas.diff.RecreateNeededBuilder.Difference; + public class DiffActionReasonDifferent extends DiffActionReason { - private List diffReasonDetails = new ArrayList<>(); + private List diffReasonDetails = new ArrayList<>(); - public List getDiffReasonDetails() + public List getDiffReasonDetails() { return diffReasonDetails; } @@ -19,16 +21,18 @@ public DiffActionReasonDifferent( DiffReasonKey pDiffReasonKey ) super( pDiffReasonKey ); } - public DiffActionReasonDifferent( DiffReasonKey pDiffReasonKey, List pDiffReasonDetails ) + public DiffActionReasonDifferent( DiffReasonKey pDiffReasonKey, List pDiffReasonDetails ) { super( pDiffReasonKey ); diffReasonDetails = pDiffReasonDetails; } - public void addDiffReasonDetail( EStructuralFeature pDiffReasonDetail ) + public void addDiffReasonDetail( Difference pDifference ) { - diffReasonDetails.add( pDiffReasonDetail.getName() ); + if(pDifference.getEAttribute()!=null) { + diffReasonDetails.add(new DiffDifference(pDifference.getEAttribute().getName(),pDifference.getOldValue(), pDifference.getNewValue())); + } } @Override @@ -49,4 +53,28 @@ public boolean equals( Object pOther ) return diffReasonDetails.equals( lOther.diffReasonDetails ); } + + public static class DiffDifference{ + private String difference; + private String oldValue; + private String newValue; + + public DiffDifference(String pDifference, Object pOldValue, Object pNewValue) { + difference = pDifference; + oldValue = pOldValue == null ? null : pOldValue.toString(); + newValue = pNewValue == null ? null : pNewValue.toString(); + } + + public String getDifference() { + return difference; + } + + public String getOldValue() { + return oldValue; + } + + public String getNewValue() { + return newValue; + } + } } diff --git a/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/OrcasDiff.java b/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/OrcasDiff.java index b5841cb7..862e9cd1 100644 --- a/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/OrcasDiff.java +++ b/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/OrcasDiff.java @@ -23,6 +23,9 @@ import de.opitzconsulting.orcas.diff.DiffAction.DiffReasonType; import de.opitzconsulting.orcas.diff.DiffReasonKey.DiffReasonKeyRegistry; +import de.opitzconsulting.orcas.diff.RecreateNeededBuilder.Difference; +import de.opitzconsulting.orcas.diff.RecreateNeededBuilder.DifferenceImpl; +import de.opitzconsulting.orcas.diff.RecreateNeededBuilder.DifferenceImplAttributeOnly; import de.opitzconsulting.orcas.orig.diff.AbstractDiff; import de.opitzconsulting.orcas.orig.diff.ColumnDiff; import de.opitzconsulting.orcas.orig.diff.ColumnRefDiff; @@ -90,41 +93,41 @@ private List getIndexRecreate( TableDiff pTableDiff, String pI throw new RuntimeException( "index not found: " + pIndexname + " " + pTableDiff.nameNew ); } - private List isRecreateColumn( ColumnDiff pColumnDiff ) + private List isRecreateColumn( ColumnDiff pColumnDiff ) { - List lReturn = new ArrayList<>(); + List lReturn = new ArrayList<>(); if( pColumnDiff.data_typeNew != null && pColumnDiff.data_typeOld != null ) { if( !pColumnDiff.data_typeIsEqual ) { - lReturn.add( COLUMN__DATA_TYPE ); + lReturn.add(new DifferenceImpl(COLUMN__DATA_TYPE, pColumnDiff)); } if( isLessTahnOrNull( pColumnDiff.precisionNew, pColumnDiff.precisionOld ) ) { - lReturn.add( COLUMN__PRECISION ); + lReturn.add(new DifferenceImpl(COLUMN__PRECISION, pColumnDiff)); } if( isLessTahnOrNull( pColumnDiff.scaleNew, pColumnDiff.scaleOld ) ) { - lReturn.add( COLUMN__SCALE ); + lReturn.add(new DifferenceImpl(COLUMN__SCALE, pColumnDiff)); } } if( !pColumnDiff.object_typeIsEqual ) { - lReturn.add( COLUMN__OBJECT_TYPE ); + lReturn.add(new DifferenceImpl(COLUMN__OBJECT_TYPE, pColumnDiff)); } if( !pColumnDiff.unsignedIsEqual ) { - lReturn.add( COLUMN__UNSIGNED ); + lReturn.add(new DifferenceImpl(COLUMN__UNSIGNED, pColumnDiff)); } if( !pColumnDiff.virtualIsEqual ) { - lReturn.add( COLUMN__VIRTUAL ); + lReturn.add(new DifferenceImpl(COLUMN__VIRTUAL, pColumnDiff)); } return lReturn; @@ -252,7 +255,7 @@ private void updateIsRecreateNeeded( ModelDiff pModelDiff ) setRecreateNeededFor( lColumnDiff )// .ifX( p -> { - List lRecreateColumn = isRecreateColumn( p.getDiff() ); + List lRecreateColumn = isRecreateColumn( p.getDiff() ); if( !lRecreateColumn.isEmpty() ) { p.setRecreateNeededDifferent( lRecreateColumn ); @@ -341,13 +344,13 @@ private void updateIsRecreateNeeded( ModelDiff pModelDiff ) { if( lTableDiff.mviewLogDiff.rowidNew == null && !"primary".equalsIgnoreCase( lTableDiff.mviewLogDiff.primaryKeyOld ) ) { - p.setRecreateNeededDifferent( Collections.singletonList( MVIEW_LOG__PRIMARY_KEY ) ); + p.setRecreateNeededDifferentAttributes( Collections.singletonList( MVIEW_LOG__PRIMARY_KEY ) ); } } )// .ifDifferent( MVIEW_LOG__ROWID )// .ifDifferent( MVIEW_LOG__WITH_SEQUENCE )// .ifDifferent( MVIEW_LOG__COMMIT_SCN )// - .ifDifferent( MVIEW_LOG__TABLESPACE )// + //.ifDifferent( MVIEW_LOG__TABLESPACE )// // these changes should by applied with alter statements, but it results // in ORA-27476 .ifDifferent( MVIEW_LOG__START_WITH )// @@ -377,7 +380,7 @@ private void updateIsRecreateNeeded( ModelDiff pModelDiff ) { if( !replaceLinefeedBySpace( lMviewDiff.viewSelectCLOBNew ).equals( replaceLinefeedBySpace( lMviewDiff.viewSelectCLOBOld ) ) ) { - p.setRecreateNeededDifferent( Collections.singletonList( MVIEW__VIEW_SELECT_CLOB ) ); + p.setRecreateNeededDifferentAttributes( Collections.singletonList( MVIEW__VIEW_SELECT_CLOB ) ); } } )// .calculate(); @@ -964,7 +967,7 @@ private void handleComment( TableDiff pTableDiff, InlineCommentDiff pInlineComme { lDiffReasonType = DiffReasonType.ALTER; DiffActionReasonDifferent lDiffActionReasonDifferent = new DiffActionReasonDifferent( diffReasonKeyRegistry.getDiffReasonKey( pInlineCommentDiff ) ); - lDiffActionReasonDifferent.addDiffReasonDetail( INLINE_COMMENT__COMMENT ); + lDiffActionReasonDifferent.addDiffReasonDetail( new DifferenceImplAttributeOnly(INLINE_COMMENT__COMMENT) ); lDiffActionReasonList = Collections.singletonList( lDiffActionReasonDifferent ); } else diff --git a/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/RecreateNeededBuilder.java b/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/RecreateNeededBuilder.java index 6bd6dc54..872064ff 100644 --- a/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/RecreateNeededBuilder.java +++ b/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/RecreateNeededBuilder.java @@ -5,203 +5,251 @@ import java.util.List; import java.util.Map; import java.util.function.Consumer; +import java.util.stream.Collectors; import org.eclipse.emf.ecore.EStructuralFeature; import de.opitzconsulting.orcas.diff.DiffReasonKey.DiffReasonKeyRegistry; import de.opitzconsulting.orcas.orig.diff.AbstractDiff; import de.opitzconsulting.orcas.orig.diff.ColumnRefDiff; +import sun.util.resources.th.CalendarData_th; -class RecreateNeededBuilder implements RecreateNeededBuilderHandler -{ - interface RecreateNeededBuilderRunnable extends Consumer> - { - } - - private T diff; - private List eAttributes = new ArrayList<>(); - private List> additionalHandlers = new ArrayList<>(); - private DiffReasonKeyRegistry diffReasonKeyRegistry; - private Map> recreateDiffDiffActionReasonMap = new HashMap<>(); - - @Override - public T getDiff() - { - return diff; - } - - @Override - public void setRecreateNeededDifferent( List pDiffReasonDetails ) - { - DiffActionReasonDifferent lDiffActionReasonDifferent = new DiffActionReasonDifferent( diffReasonKeyRegistry.getDiffReasonKey( diff ) ); - - for( EStructuralFeature lEAttribute : pDiffReasonDetails ) - { - if( lEAttribute != null ) - { - lDiffActionReasonDifferent.addDiffReasonDetail( lEAttribute ); - } - } - - addRecreateNeeded( lDiffActionReasonDifferent ); - } - - private void addRecreateNeeded( DiffActionReason pDiffActionReason ) - { - List lDiffActionReasonList = recreateDiffDiffActionReasonMap.get( diff ); - - if( lDiffActionReasonList == null ) - { - lDiffActionReasonList = new ArrayList<>(); - recreateDiffDiffActionReasonMap.put( diff, lDiffActionReasonList ); - } - - lDiffActionReasonList.add( pDiffActionReason ); - } - - @Override - public void setRecreateNeededDependsOn( List pDiffActionReasonDependsOnList ) - { - addRecreateNeeded( new DiffActionReasonDependsOn( diffReasonKeyRegistry.getDiffReasonKey( diff ), pDiffActionReasonDependsOnList ) ); - } - - public RecreateNeededBuilder( T pDiff, DiffReasonKeyRegistry pDiffReasonKeyRegistry, Map> pRecreateDiffDiffActionReasonMap ) - { - diff = pDiff; - diffReasonKeyRegistry = pDiffReasonKeyRegistry; - recreateDiffDiffActionReasonMap = pRecreateDiffDiffActionReasonMap; - } - - public RecreateNeededBuilder ifX( RecreateNeededBuilderRunnable pObject ) - { - additionalHandlers.add( pObject ); - - return this; - } - - public RecreateNeededBuilder ifColumnDependentRecreate( Map> pRecreateColumnNames, List pColumnRefDiff ) - { - return ifX( p -> - { - handleColumnDependentRecreate( pRecreateColumnNames, pColumnRefDiff ); - } ); - } - - private void handleColumnDependentRecreate( Map> pRecreateColumnNames, List pColumnDiffList ) - { - List lDependsOnList = new ArrayList<>(); - - for( ColumnRefDiff lColumnRefDiff : pColumnDiffList ) - { - if( lColumnRefDiff.isOld ) - { - if( pRecreateColumnNames.keySet().contains( lColumnRefDiff.column_nameOld ) ) +class RecreateNeededBuilder implements RecreateNeededBuilderHandler { + interface RecreateNeededBuilderRunnable extends Consumer> { + } + + private T diff; + private List eAttributes = new ArrayList<>(); + private List> additionalHandlers = new ArrayList<>(); + private DiffReasonKeyRegistry diffReasonKeyRegistry; + private Map> recreateDiffDiffActionReasonMap = new HashMap<>(); + + @Override + public T getDiff() { + return diff; + } + + @Override + public void setRecreateNeededDifferent(List pDiffReasonDetails) { + DiffActionReasonDifferent lDiffActionReasonDifferent = new DiffActionReasonDifferent(diffReasonKeyRegistry.getDiffReasonKey(diff)); + + for (Difference lDifference : pDiffReasonDetails) { + lDiffActionReasonDifferent.addDiffReasonDetail(lDifference); + } + + addRecreateNeeded(lDiffActionReasonDifferent); + } + + private void addRecreateNeeded(DiffActionReason pDiffActionReason) { + List lDiffActionReasonList = recreateDiffDiffActionReasonMap.get(diff); + + if (lDiffActionReasonList == null) { + lDiffActionReasonList = new ArrayList<>(); + recreateDiffDiffActionReasonMap.put(diff, lDiffActionReasonList); + } + + lDiffActionReasonList.add(pDiffActionReason); + } + + @Override + public void setRecreateNeededDependsOn(List pDiffActionReasonDependsOnList) { + addRecreateNeeded(new DiffActionReasonDependsOn(diffReasonKeyRegistry.getDiffReasonKey(diff), pDiffActionReasonDependsOnList)); + } + + @Override + public void setRecreateNeededDifferentAttributes(List pDiffReasonDetails) { + setRecreateNeededDifferent(pDiffReasonDetails.stream().map(p -> new DifferenceImplAttributeOnly(p)).collect(Collectors.toList())); + } + + public RecreateNeededBuilder( + T pDiff, + DiffReasonKeyRegistry pDiffReasonKeyRegistry, + Map> pRecreateDiffDiffActionReasonMap) { + diff = pDiff; + diffReasonKeyRegistry = pDiffReasonKeyRegistry; + recreateDiffDiffActionReasonMap = pRecreateDiffDiffActionReasonMap; + } + + public RecreateNeededBuilder ifX(RecreateNeededBuilderRunnable pObject) { + additionalHandlers.add(pObject); + + return this; + } + + public RecreateNeededBuilder ifColumnDependentRecreate( + Map> pRecreateColumnNames, + List pColumnRefDiff) { + return ifX(p -> { - lDependsOnList.addAll( pRecreateColumnNames.get( lColumnRefDiff.column_nameOld ) ); + handleColumnDependentRecreate(pRecreateColumnNames, pColumnRefDiff); + }); + } + + private void handleColumnDependentRecreate(Map> pRecreateColumnNames, List pColumnDiffList) { + List lDependsOnList = new ArrayList<>(); + + for (ColumnRefDiff lColumnRefDiff : pColumnDiffList) { + if (lColumnRefDiff.isOld) { + if (pRecreateColumnNames.keySet().contains(lColumnRefDiff.column_nameOld)) { + lDependsOnList.addAll(pRecreateColumnNames.get(lColumnRefDiff.column_nameOld)); + } + } + } + + if (!lDependsOnList.isEmpty()) { + setRecreateNeededDependsOn(lDependsOnList); } - } } - if( !lDependsOnList.isEmpty() ) - { - setRecreateNeededDependsOn( lDependsOnList ); + public RecreateNeededBuilder ifColumnDependentRecreate(Map> pRecreateColumnNames, String pColumnName) { + return ifX(p -> + { + handleColumnDependentRecreate(pRecreateColumnNames, pColumnName); + }); } - } - public RecreateNeededBuilder ifColumnDependentRecreate( Map> pRecreateColumnNames, String pColumnName ) - { - return ifX( p -> - { - handleColumnDependentRecreate( pRecreateColumnNames, pColumnName ); - } ); - } + private void handleColumnDependentRecreate(Map> pRecreateColumnNames, String pColumnName) { + List lDependsOnList = new ArrayList<>(); - private void handleColumnDependentRecreate( Map> pRecreateColumnNames, String pColumnName ) - { - List lDependsOnList = new ArrayList<>(); + if (pRecreateColumnNames.keySet().contains(pColumnName)) { + lDependsOnList.addAll(pRecreateColumnNames.get(pColumnName)); + } - if( pRecreateColumnNames.keySet().contains( pColumnName ) ) - { - lDependsOnList.addAll( pRecreateColumnNames.get( pColumnName ) ); + if (!lDependsOnList.isEmpty()) { + setRecreateNeededDependsOn(lDependsOnList); + } } - if( !lDependsOnList.isEmpty() ) - { - setRecreateNeededDependsOn( lDependsOnList ); + public RecreateNeededBuilder ifDifferent(EStructuralFeature pEAttribute, boolean pCheckThis) { + if (pCheckThis) { + eAttributes.add(pEAttribute); + } + + return this; } - } - public RecreateNeededBuilder ifDifferent( EStructuralFeature pEAttribute, boolean pCheckThis ) - { - if( pCheckThis ) - { - eAttributes.add( pEAttribute ); + public RecreateNeededBuilder ifDifferent(EStructuralFeature pEAttribute) { + eAttributes.add(pEAttribute); + + return this; } - return this; - } + public RecreateNeededBuilder ifDifferentName( + EStructuralFeature pEAttribute, + List pOldNames, + String pNewName, + String pOldName, + boolean pIsRenamePossible) { + if (pNewName == null || pOldName == null || pOldNames.contains(pNewName) || !pIsRenamePossible) { + ifDifferent(pEAttribute); + } - public RecreateNeededBuilder ifDifferent( EStructuralFeature pEAttribute ) - { - eAttributes.add( pEAttribute ); + return this; + } - return this; - } + public RecreateNeededBuilder ifDifferentName( + EStructuralFeature pEAttribute, + Map> pOldNames, + String pNewName, + String pOldName, + boolean pIsRenamePossible) { + if (pNewName == null || pOldName == null || !pIsRenamePossible) { + ifDifferent(pEAttribute); + } - public RecreateNeededBuilder ifDifferentName( EStructuralFeature pEAttribute, List pOldNames, String pNewName, String pOldName, boolean pIsRenamePossible ) - { - if( pNewName == null || pOldName == null || pOldNames.contains( pNewName ) || !pIsRenamePossible ) - { - ifDifferent( pEAttribute ); + if (pOldNames.values().stream().filter(p -> p.contains(pNewName)).findAny().isPresent()) { + ifDifferent(pEAttribute); + } + + return this; } - return this; - } + public void calculate() { + if (diff.isMatched) { + List lDifferentEAttributes = getDifferentEAttributes(diff, eAttributes); + if (!lDifferentEAttributes.isEmpty()) { + setRecreateNeededDifferent(lDifferentEAttributes); + } - public RecreateNeededBuilder ifDifferentName( EStructuralFeature pEAttribute, Map> pOldNames, String pNewName, String pOldName, boolean pIsRenamePossible ) - { - if( pNewName == null || pOldName == null || !pIsRenamePossible ) - { - ifDifferent( pEAttribute ); + for (RecreateNeededBuilderRunnable lRunnable : additionalHandlers) { + lRunnable.accept(this); + } + } } - if( pOldNames.values().stream().filter( p -> p.contains( pNewName ) ).findAny().isPresent() ) - { - ifDifferent( pEAttribute ); + public interface Difference { + EStructuralFeature getEAttribute(); + + Object getOldValue(); + + Object getNewValue(); } - return this; - } + public static class DifferenceImpl implements Difference { + private EStructuralFeature eattribute; + private AbstractDiff abstractDiff; + + public DifferenceImpl(EStructuralFeature pEattribute, AbstractDiff pAbstractDiff) { + eattribute = pEattribute; + abstractDiff = pAbstractDiff; + } + + @Override + public EStructuralFeature getEAttribute() { + return eattribute; + } - public void calculate() - { - if( diff.isMatched ) - { - List lDifferentEAttributes = getDifferentEAttributes( diff, eAttributes ); - if( !lDifferentEAttributes.isEmpty() ) - { - setRecreateNeededDifferent( lDifferentEAttributes ); - } + @Override + public Object getOldValue() { + try { + return abstractDiff.getValue(eattribute, false); + } catch (Exception e) { + return "object"; + } + } - for( RecreateNeededBuilderRunnable lRunnable : additionalHandlers ) - { - lRunnable.accept( this ); - } + @Override + public Object getNewValue() { + try { + return abstractDiff.getValue(eattribute, true); + } catch (Exception e) { + return "object"; + } + } } - } - static List getDifferentEAttributes( AbstractDiff pDiff, List pEAttributes ) - { - List lReturn = new ArrayList<>(); + public static class DifferenceImplAttributeOnly implements Difference { + private EStructuralFeature eattribute; + + public DifferenceImplAttributeOnly(EStructuralFeature pEattribute) { + eattribute = pEattribute; + } + + @Override + public EStructuralFeature getEAttribute() { + return eattribute; + } - for( EStructuralFeature lEAttribute : pEAttributes ) - { - if( !pDiff.isFieldEqual( lEAttribute ) ) - { - lReturn.add( lEAttribute ); - } + @Override + public Object getOldValue() { + return null; + } + + @Override + public Object getNewValue() { + return null; + } } - return lReturn; - } + static List getDifferentEAttributes(AbstractDiff pDiff, List pEAttributes) { + List lReturn = new ArrayList<>(); + + for (EStructuralFeature lEAttribute : pEAttributes) { + if (!pDiff.isFieldEqual(lEAttribute)) { + lReturn.add(new DifferenceImpl(lEAttribute, pDiff)); + } + } + + return lReturn; + } } diff --git a/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/RecreateNeededBuilderHandler.java b/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/RecreateNeededBuilderHandler.java index 3e65e069..d50a0083 100644 --- a/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/RecreateNeededBuilderHandler.java +++ b/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/RecreateNeededBuilderHandler.java @@ -2,8 +2,10 @@ import java.util.List; +import org.eclipse.emf.ecore.EAttribute; import org.eclipse.emf.ecore.EStructuralFeature; +import de.opitzconsulting.orcas.diff.RecreateNeededBuilder.Difference; import de.opitzconsulting.orcas.orig.diff.AbstractDiff; public interface RecreateNeededBuilderHandler @@ -12,5 +14,7 @@ public interface RecreateNeededBuilderHandler void setRecreateNeededDependsOn( List pDiffActionReasonDependsOnList ); - void setRecreateNeededDifferent( List pDiffReasonDetails ); + void setRecreateNeededDifferentAttributes( List pDiffReasonDetails ); + + void setRecreateNeededDifferent( List pDiffReasonDetails ); } diff --git a/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/StatementBuilderAlter.java b/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/StatementBuilderAlter.java index 1512056b..e1d8c2d0 100644 --- a/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/StatementBuilderAlter.java +++ b/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/StatementBuilderAlter.java @@ -4,9 +4,12 @@ import java.util.List; import java.util.function.Consumer; import java.util.function.Supplier; +import java.util.stream.Collectors; import org.eclipse.emf.ecore.EStructuralFeature; +import de.opitzconsulting.orcas.diff.RecreateNeededBuilder.Difference; +import de.opitzconsulting.orcas.diff.RecreateNeededBuilder.DifferenceImplAttributeOnly; import de.opitzconsulting.orcas.orig.diff.AbstractDiff; public class StatementBuilderAlter @@ -98,14 +101,14 @@ public AlterBuilder ifDifferent( EStructuralFeature pEStructuralFeature, boolean public void handle( Consumer pHanlder ) { - List lDifferentEAttributes = RecreateNeededBuilder.getDifferentEAttributes( diff, checkDifferentEStructuralFeatureList ); - lDifferentEAttributes.addAll( forceDifferentEStructuralFeatureList ); + List lDifferentEAttributes = RecreateNeededBuilder.getDifferentEAttributes( diff, checkDifferentEStructuralFeatureList ); + lDifferentEAttributes.addAll( forceDifferentEStructuralFeatureList.stream().map(p->new DifferenceImplAttributeOnly(p)).collect(Collectors.toList()) ); if( !lDifferentEAttributes.isEmpty() ) { - for( EStructuralFeature lEStructuralFeature : lDifferentEAttributes ) + for( Difference lDifference : lDifferentEAttributes ) { - diffActionReasonDifferent.addDiffReasonDetail( lEStructuralFeature ); + diffActionReasonDifferent.addDiffReasonDetail( lDifference ); } StatementBuilder lStatementBuilder = new StatementBuilder( diffActionSupplier, isAdditionsOnlyMode, alterTableCombiner ); diff --git a/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/XmlLogFileHandler.java b/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/XmlLogFileHandler.java index 067c4d8a..965e1ed6 100644 --- a/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/XmlLogFileHandler.java +++ b/orcas_core/build_source/orcas_diff/src/main/java/de/opitzconsulting/orcas/diff/XmlLogFileHandler.java @@ -16,11 +16,15 @@ import org.jdom2.output.XMLOutputter; import de.opitzconsulting.orcas.diff.DiffAction.Statement; +import de.opitzconsulting.orcas.diff.DiffActionReasonDifferent.DiffDifference; import de.opitzconsulting.orcas.diff.OrcasDiff.DiffResult; +import de.opitzconsulting.orcas.diff.RecreateNeededBuilder.Difference; public class XmlLogFileHandler { private static final String TAG_REASON_DETAIL = "reason-detail"; + private static final String TAG_REASON_DETAIL_ATTRIBUTE_OLD_VALUE = "old-value"; + private static final String TAG_REASON_DETAIL_ATTRIBUTE_NEW_VALUE = "new-value"; private static final String TAG_DIFF_ACTION_REASON = "diff-action-reason"; @@ -149,11 +153,17 @@ private Element convertDiffActionReasonToXml( DiffActionReason pDiffActionReason { DiffActionReasonDifferent lDiffActionReasonDifferent = (DiffActionReasonDifferent) pDiffActionReason; - for( String lDiffReasonDetail : lDiffActionReasonDifferent.getDiffReasonDetails() ) + for( DiffDifference lDiffReasonDetail : lDiffActionReasonDifferent.getDiffReasonDetails() ) { Element lStatementElement = new Element( TAG_REASON_DETAIL ); lReturn.addContent( lStatementElement ); - lStatementElement.addContent( lDiffReasonDetail ); + lStatementElement.addContent( lDiffReasonDetail.getDifference() ); + if(lDiffReasonDetail.getOldValue()!=null) { + lStatementElement.setAttribute(TAG_REASON_DETAIL_ATTRIBUTE_OLD_VALUE, lDiffReasonDetail.getOldValue()); + } + if(lDiffReasonDetail.getNewValue()!=null) { + lStatementElement.setAttribute(TAG_REASON_DETAIL_ATTRIBUTE_NEW_VALUE, lDiffReasonDetail.getNewValue()); + } } } @@ -178,11 +188,11 @@ private List parseDependsOnDiffActionReasons( Element pDiffAct .collect( Collectors.toList() ); } - private List parseDiffReasonDetails( Element pDiffActionReasonElement ) + private List parseDiffReasonDetails( Element pDiffActionReasonElement ) { return pDiffActionReasonElement.getChildren( TAG_REASON_DETAIL )// .stream()// - .map( this::getContentsAsString )// + .map( p-> new DiffDifference(getContentsAsString(p),p.getAttributeValue(TAG_REASON_DETAIL_ATTRIBUTE_OLD_VALUE),p.getAttributeValue(TAG_REASON_DETAIL_ATTRIBUTE_NEW_VALUE)) )// .collect( Collectors.toList() ); } diff --git a/orcas_integrationstest/src/test/java/com/opitzconsulting/orcas/diff/OrcasCoreIntegrationTest.java b/orcas_integrationstest/src/test/java/com/opitzconsulting/orcas/diff/OrcasCoreIntegrationTest.java index 5e4aa688..a99471b5 100644 --- a/orcas_integrationstest/src/test/java/com/opitzconsulting/orcas/diff/OrcasCoreIntegrationTest.java +++ b/orcas_integrationstest/src/test/java/com/opitzconsulting/orcas/diff/OrcasCoreIntegrationTest.java @@ -443,6 +443,7 @@ private void executeOrcasStatics( JdbcConnectParameters pJdbcConnectParameters, lParametersCall.setLogonly( false ); lParametersCall.setLogname( pSpoolName ); lParametersCall.setSpoolfolder( getSpoolFolder( pSpoolName ) ); + lParametersCall.setXmlLogFile( orcasCoreIntegrationConfig.getWorkfolder() + testName + "/xmllog_" + pSpoolName + ".xml" ); lParametersCall.setTablemovetablespace( _testSetup._tablemovetablespace ); lParametersCall.setIndexmovetablespace( _testSetup._indexmovetablespace ); lParametersCall.setIndexparallelcreate( _testSetup._indexparallelcreate ); diff --git a/orcas_integrationstest/tests/test_minimize_statement_count/reference_log.xml b/orcas_integrationstest/tests/test_minimize_statement_count/reference_log.xml index 9b658ff3..f4947804 100644 --- a/orcas_integrationstest/tests/test_minimize_statement_count/reference_log.xml +++ b/orcas_integrationstest/tests/test_minimize_statement_count/reference_log.xml @@ -51,11 +51,11 @@ - logging - parallel_degree + logging + parallel_degree - deferrtype + deferrtype @@ -70,7 +70,7 @@ - deferrtype + deferrtype alter table TAB_MAX_COMBINE