KS DB Merge Tools
for MS Access
aka AccdbMerge
for SQL Server
aka MssqlMerge
for MySQL
for SQLite
for PostgreSQL
for Oracle
for Cross-DBMS

Known issues


Merge and delete actions are script-based

All merge/delete statements are executed as SQL commands. That's convenient for action review and such script can be saved for later use. But large scripts (for example for huge blob values) can produce some issues. Application may fail with out-of-memory or it may exceed some limitations on the database engine. Even if database engine provides an API to handle such blobs as stream, this API is not used by application.

Merge and delete actions may fail

Failure can be caused by different reasons, for example foreign key constraints of some other dependencies. Please check the execution log.

Settings, diff profiles and multiple application instances

Application settings and diff profiles are saved as regular XML files. Before saving, the application does not check if any other changes could be made by any other application instance and can overwrite these changes.

Schema and data are processed separately

When you merge table definition, the application produces only table definition changes, it does not merge the data. Data needs to be merged separately if needed.

Mouse-driven interface

As a GUI application, it has most actions designed to be performed using a mouse. Application has some keyboard shortcuts, complex dialogs were adjusted to have expected tab order, but there was no comprehensive keyboard usability testing.

Documentation is not versioned

Application has online documentation, but it corresponds only to the latest application version. Sometimes documentation can be updated with delay. For our small dev team it is hard to support versioned documentation. However, the application is designed to support offline documentation and if you're a Pro active free-upgrades client then you may contact Support to get instructions to set up offline documentation.

Updates are backward-compatible but can be not rollback-tolerant

Application updates can be safely installed over the previous version, even with some gaps in the version sequence (for example install v 1.5.4 over 1.2.2). Any non-backward-compatible behavior changes are listed in the release notes. But the application is not designed to be downgradable. In most cases rollback to the previous version does not cause any issues. But in rare cases newer application settings may have some items which are not supported by previous versions and this may cause application crashes in case of rollback. In such cases application settings need to be deleted and for the Pro version license key should be entered again.

Local cache

Application is using some space in the user profile. It caches large strings, binary values and generated scripts. These temporary files are removed when no longer needed.

Schema and programming objects

Non-supported object types and object properties

If some object type or property is not presented on UI then most likely it is not supported. Example of unsupported object type is fulltext index, example of unsupported object property are table partition options and sparse columns. Information about such objects and properties is not read from database metadata, not shown anywhere and can not be compared or synchronized.

Only ALTER TABLE merge for table definitions

If you want to merge some table definition changes, the application can merge only those which are supported by the ALTER TABLE statement. Changes that are not supported by ALTER TABLE require table re-creation. Such scenarios can have pretty complex logic and are currently not supported by the application. For example, you can't change the order of columns (however in the Pro version you can ignore column order changes).


String keys and sorting on other data types which have no natural sort order

Application is using a sort-merge join algorithm to compare data in the regular tables with a common primary key ("common" means defined on the same columns with same data types). It requests data from both databases sorted by key, reads record by record and then compares these keys on the application side, expecting that comparison logic is the same on the application side and on both databases. This allows it to process huge amounts of data without significant memory impact on the application side. But that same-comparison-logic assumption is correct only for data types with a natural sort order, like numbers or dates. Particularly, this assumption can be wrong for some string collations. If database collations are different, or if application string comparison logic is other than database collation, then such cases can produce false-positive changes. If you think you face this issue, and if you use a Pro version - then you may try to use Query result diff to get better diff results. Query result diff does all sorting on the application side, which means that comparison logic will be the same for all steps of sort-merge join. But this approach has some limitations: it can't be used for large amounts of data and changes identified by Query result diff can not be merged.

Last updated: 2023-09-22