J'ai donc, ce qui semble être une question courante à laquelle je n'arrive pas à trouver de réponse. J'essaie de trouver quelle est la "meilleure pratique" pour savoir comment architecturer une base de données qui conserve les données localement, puis synchronise ces données vers une base de données distante partagée entre de nombreux clients. Pour clarifier les choses, cette base de données distante aurait de nombreux clients qui l'utilisent.
Par exemple, si j'avais une application de bureau qui stockait des listes de tâches (en SQL) contenant des éléments individuels. Ensuite, je veux pouvoir envoyer ces données à un service Web qui avait une copie "principale" de toutes les informations des différents clients. Je ne suis pas autant préoccupé par la synchronisation des problèmes que j'essaie simplement de réfléchir à l'architecture réelle des tables du client et des tables des services Web
Voici un exemple de la façon dont j'y pensais:
Base de données clients
list
--list_client_id (primary key, auto-increment)
--list_name
list_item
--list_item_client_id (primary key, auto-increment)
--list_id
--list_item_text
Base de données principale basée sur le Web (Partagé entre plusieurs clients)
list
--list_master_id
--list_client_id (primary key, auto-increment)
--list_name
--user_id
list_item
--list_item_master_id (primary key, auto-increment)
--list_item_remote_id
--list_id
--list_item_text
--user_id
L'idée serait que le client puisse créer des listes de tâches avec des éléments et les synchroniser avec le service Web à tout moment (c'est-à-dire s'il perd la connectivité des données et ne peut envoyer les informations que plus tard, rien ne sortira de ordre). Le service Web enregistrerait les enregistrements avec les ID clients sous forme de champs supplémentaires. De cette façon, le client peut dire "mettre à jour la liste numéro 4 avec un nouveau nom" et le serveur veut dire "mettre à jour la liste numéro 4 de l'utilisateur 12 avec un nouveau nom".
Nous avons eu un cas similaire. La solution était plutôt inhabituelle, chaque base de données, quel que soit le serveur principal ou le client local, avait une copie de la même structure ou schéma de base de données. (Mêmes tables avec les mêmes champs et les mêmes types de champs).
Nous ajoutons un catalogue de tables client:
create table client
{
client_key int primary key,
client_title varchar(200)
}
La clé primaire de chaque table était un entier, mais, gérée, car c'était une chaîne/un caractère de type fixe, avec des entiers jusqu'à 9999 9999 9999 9999
Sa longueur était suffisamment grande pour supporter une grande quantité. des enregistrements.
Les nombres étaient stockés à l'envers, afin de prendre en charge le remplissage avec des zéros. Si nous voulons stocker un "4", cela devrait être comme ceci: "4000 0000 0000 0000".
Les 3 premiers chiffres stockent la clé de la table, complétée par 0. Le reste des 12 chiffres stockait la valeur incrémentielle de la clé complétée par des zéros.
Ainsi, les données suivantes:
Client Sequential Number <other fields>
1 1 ...
2 1 ...
3 1 ...
1 2 ...
2 2 ...
3 2 ...
1 3 ...
2 3 ...
3 3 ...
A été stocké dans la clé primaire, de chaque table, comme ceci:
Table_Key <other fields>
1000000000001000 ...
1000000000002000 ...
1000000000003000 ...
2000000000001000 ...
2000000000002000 ...
2000000000003000 ...
3000000000001000 ...
3000000000002000 ...
3000000000003000 ...
Afin d'éviter les collisions de clés primaires.
Je comprends que vous voulez un magasin local, par exemple copie locale de la liste des tâches, puis téléchargez les données, en les synchronisant avec la base de données principale. L'écriture des services n'est pas la partie difficile, mais la gestion de la synchronisation entre les bases de données. J'ai récemment étudié nServiceBus http://nservicebus.com/ pour améliorer la gestion de la synchronisation des données entre les systèmes. C'est un domaine qui m'intéresse, mais je n'ai pas encore trouvé la meilleure approche ou balle magique. Je recommanderais de jeter un œil à nServiceBus.