The upload may not contain more than one operation (insert, update, or delete) for a single row. However, you can combine multiple operations into a single upload operation; for example, if a row is inserted and then updated you can replace the two operations with a single insert of the final values.
When the upload is applied to the consolidated database, insert and update operations are applied before delete operations. You cannot make any other assumptions about the order of operations within a given table.
A conflict occurs when a row is updated on more than one database between synchronizations. The MobiLink server can identify conflicts because each update operation in an upload contains the pre-image of the row being updated. The pre-image is the value of all the columns in the row the last time it was successfully uploaded or downloaded. The MobiLink server identifies a conflict when the pre-image does not match the values in the consolidated database when the upload is applied.
If your application needs conflict detection and you are using scripted upload, then on the remote database you need to keep track of the value of each row the last time it was successfully uploaded or downloaded. This allows you to upload the correct pre-images.
One way to maintain pre-image data is to create a pre-image table that is identical to your synchronization table. You can then create a trigger on your synchronization table that populates the pre-image table each time an update executes. After a successful upload you can delete the rows in the pre-image table.
For an example that implements conflict resolution, see Scripted upload example.
If you do not need to handle conflict detection, you can simplify your application considerably by not tracking pre-images. Instead, you upload updates as insert operations. You can then write an upload_insert script on the consolidated database that inserts a row if it does not already exist or updates the row if it does exist. If you are using a SQL Anywhere consolidated database, you can achieve this with the ON EXISTING clause in the INSERT statement in your upload_insert script.
See INSERT statement.
When you do not handle conflicts and two or more remote databases change the same row, the last one to synchronize overrides the earlier changes.
For delete operations, it is essential that the primary key of a row that is uploaded is correct. However, in most cases it doesn't matter if the values of the non-primary key columns match those in the consolidated database. The only case where the value of non-primary key columns is important is when forced conflict mode is used at the MobiLink server. In that case, all the column values are passed to the upload_old_row_insert script on the consolidated database. Depending on how you have implemented this script, it may be necessary for non-primary key column values to be correct.
See Forced conflicts.
You can avoid many problems with scripted uploads by using the default setting for the dbmlsync extended option LockTables, which causes dbmlsync to obtain exclusive locks on all synchronization tables before the upload is built. This prevents other connections from changing the synchronization tables while your scripts are building the upload. It also ensures that there are no uncommitted transactions that affect synchronization tables open while your scripts are building the upload.
If you must turn off table locking, see Scripted upload with no table locking.
In most cases, you will want to upload each operation on the remote database exactly once. To help you with this, MobiLink maintains a progress value for each subscription. By default the progress value is the time at which dbmlsync began building the last successful upload. This progress value can be overridden with a different value using the sp_hook_dbmlsync_set_upload_end_progress hook.
Each time one of your upload procedures is called, values are passed to it through the #hook_dict table. Among these are the 'start progress' and 'end progress' values. These define the period of time for which the upload being built should include changes to the remote database. Operations that occurred before the 'start progress' have already been uploaded. Those that occur after the 'end progress' should be uploaded during the next synchronization.
A common mistake in the implementation of scripted upload is creating stored procedures that can only tell whether an upload was successfully applied to the consolidated database by using the sp_hook_dbmlsync_upload_end or sp_hook_dbmlsync_end hooks. This approach is unreliable.
For example, the following example tries to handle inserts by using a bit on each row to keep track of whether the row needs to be uploaded. The bit is set when a row is inserted, and it is cleared in the sp_hook_dbmlsync_upload_end hook when the upload is successfully committed.
// // DO NOT DO THIS! // CREATE TABLE t1 ( pk integer primary key, val varchar( 256 ), to_upload bit DEFAULT 1 ); CREATE PROCEDURE t1_ins() RESULT( pk integer, val varchar(256) ) BEGIN SELECT pk, val FROM t1 WHERE to_upload = 1; END; CREATE PROCEDURE sp_hook_dbmlsync_upload_end() BEGIN DECLARE upload_status varchar(256); SELECT value INTO upload_status FROM #hook_dict WHERE name = 'upload status'; if upload_status = 'committed' THEN UPDATE t1 SET to_upload = 0; END IF END; CREATE PUBLICATION p1 WITH SCRIPTED UPLOAD ( TABLE t1 USING ( PROCEDURE t1_ins FOR UPLOAD INSERT ) );
This approach will work most—but not all—of the time. It fails when a hardware or software failure occurs that stops dbmlsync after the upload has been sent but before it has been acknowledged by the server. In that case, the upload may be applied to the consolidated database but the sp_hook_dbmlsync_upload_end hook will not be called and the to_upload bits will not be cleared. As a result, in the next synchronization, inserts are uploaded for rows that have already been uploaded. Usually this causes the synchronization to fail because it generates a duplicate primary key error on the consolidated database.
The other case where problems can occur is when communication with the MobiLink server is lost after the upload is sent but before it has been acknowledged. In this case dbmlsync cannot tell if the upload was successfully applied. Dbmlsync calls the sp_hook_dbmlsync_upload_end hook and sets the upload status to unknown. As the hook is written this will prevent it from clearing the to_upload bits. If the upload was not applied by the server, this is correct. However, if the upload was applied then the same problem occurs as in the previous paragraph. In both of these cases, the affected remote database is unable to synchronize again until someone manually intervenes to resolve the problem.
When using scripted uploads, it is possible for data in the remote database that needs to be uploaded to be overwritten by data being downloaded from the consolidated database. This results in the loss of changes made to the remote database. Dbmlsync will prevent this data loss if each upload built by your upload procedures includes all changes that were committed in the remote database before the sp_hook_dbmlsync_set_upload_end_progress hook was called.
The following example shows how data can be lost if you violate this rule:
|1:05:00||A row, R, that exists both in the consolidated and remote databases is updated with some new values, R1, in the remote database and the change is committed.|
|1:06:00||The row R is updated in the consolidated database to some new values R2 and the change is committed.|
|1:07:00||A synchronization occurs. The upload scripts are written so that the upload only contains operations committed before 1:00:00. This violates our rule because it prevents all operations that occurred before the upload was built from being uploaded. The change to row R is not included upload because it occurred after 1:00:00. The download received from the server contains the row R2. When the download is applied, the row R2 will replace the row R1 in the remote database. The update on the remote database will be lost.|
Dbmlsync uses a number of mechanisms to ensure that the download does not overwrite any change the was uncommitted when the sp_hook_dbmlsync_set_upload_end_progress hook was called or was committed after the sp_hook_dbmlsync_set_upload_end_progress hook was called.
Any change committed before the hook was called is not protected and may be overwritten when the download is applied. However, as long as the change was included in the upload (which is sent before the download is built) the change will be sent to the MobiLink server and your server-side scripts will be able to resolve it with the data in the consolidated database before the download is built.
Scripted upload with no table locking