Discussion :

[Boulken]

Salut à tous and happy new year everybody

Toujours dans mon développement d'un outil de gestion de production pour un site d'abattage de volailles, je suis à la recherche d'une méthode qui me permettrait de disposer d'une copie d'une table liée à une autre base de données. Ceci pourrait paraître relativement simple si ce n'est que je voudrais pouvoir disposer des données de cette table en temps réel (toutes les modifications faîtes sur la table source seraient répercutées sur ma copie de cette table en continu) tout en pouvant y appliquer des modifications dans ma deuxième base qui, elles, ne seront pas appliquées sur la table source. En bref, est il envisageable de disposer d'une copie en temps réel d'une table attachée modifiable dont les mises à jour dans ma base de destination n'auraient pas de répercution sur la table source. Un pur casse-tête pour ma part afin de démarrer 2008 en beauté.

J'èspère que l'un d'entre vous aurait un début de piste à me soumettre.

Tous mes voeux pour cette nouvelle année avec plein de codes aussi rapides qu'efficaces à vous tous..

Banzaï.

[loufab]

Ami du Canard Gras et voisin Bonjour !

En effet pas simple comme problème.

En régle générale pas de mise à jour possible en tant réel native. Donc il faut le programmer.

La Réplication peut être une solution cependant là non plus pas de temps réel, uniquement du déclenché (heureusement on peut le faire par code).

Le problème est que (sauf erreur de ma part, n'étant pas un spécialiste de la réplication) la mise à jour concerne Ajout et Modification.

Le moyen restant est un attachement de la table et lancement de requete sur celle-ci au moment des modifications/ajout via l'interface utilisateur.

Donc du code entre 2 gavages en perspective !

Longue vie au Canard Gras !

[Boulken]

Amateur de bonne chair et bon vivant, salutations.

Me voici donc dans une situation quelque peu délicate car cela reviendrait à créer des requêtes de mise à jour d'une base à l'autre dès qu'une modification à lieu sur mes tables source. Bref, cela va me nécessiter un retour sur toutes les requêtes et macros dans lesquelles mes tables sont impliquées. L'utilisation d'une telle méthode ne mettra-t'elle pas en péril les temps de réponse de mon appli?
Autant de questions existentielles venant torturer l'esprit de tout développeur...
Y'a du pain sur la planche quoi. L'usine à requêtes est en marche.
Je vais tenter cette option sur une petite partie de mon appli et voir ce que ca donne en espérant que cela n'aura pas trop d'impact sur les opérateurs en production.

Si l'illumination vient à éclairer l'un de vos esprits productifs, n'hésitez pas à me faire signe.

Merci à toi Loufab et vive le sud-ouest...

[loufab]

Sur une application en réseau ça risque de peiner un peu... tout dépend de la qualité de l'infrastructure.

Quel but recherches-tu ?

[Boulken]

Le but de l'opération est de permettre de palier aux aléas de la production et de disposer d'une marge de manoeuvre vis à vis des commandes clients.
En effet, il est très difficile de faire coincider parfaitement des mises en places d'élevages de volailles qui demandent plusieurs semaines avant d'être matures pour l'abattage et la réactivité requise pour répondre aux commandes qui varient à des échelles de temps extrèmement restreintes.
De ce fait, il nous faut pouvoir modifier temporairement l'affectation d'une partie d'un lot de volailles pouvant être déclarées en lieu et place d'un autre lot. Mais tous ceci doit être fait sans pour autant perdre l'information de son origine première tout en conservant les éventuelles réaffectations en vue d'audits internes. On se retrouve par conséquent avec une base exempte de toute modifications et d'une autre modifiable mais conservant malgré tout une cohérence d'un bout à l'autre.
Bref, une bonne cuisine interne dans la limite des marges de manoeuve autorisées par les groupements d'éleveurs avec l'accord desquels ces procédures sont possibles.

Pour ce qui est de l'infrastructure, elle peine déjà avec de nombreuses applications client-serveur et une administration distante peu réactive et peu encleinte à permettre le développement en interne d'application access maison.

[loufab]

A ce que je comprend ça ressemble à une gestion de stock.

Il faudrait gérer les mouvements temporaires de pièces (lots) (une table liée supplémentaire). ça évitera ce système de mise à jour (grosse usine à gaz) qui sur un réseau à bout de souffle posera de sérieux problèmes de temps de réponse.

Attention qu'à vouloir économiser du temps d'une refonte vous ne tombiez dans une grosse impasse.

[Boulken]

Bonjour et bienvenue dans un monde où l'on croit que tout est clean.

Pour être vraiment précis, je dirais qu'il s'agit plus de disposer d'une version "officielle" de la base, c'est à dire celle qui est modifiée, et d'une autre officieuse non modifiée qui nous premet de cibler les sources de disfonctionnements internes et par conséquent de pertes en terme de productivité. Ces dernières données ne doivent donc pas être consultables par les personnes extérieures au site.
Bref, c'est très délicat comme sujet.

[loufab]

En effet le problème n'est pas simple.

[Boulken]

En fait, je me rends compte que la solution ne sera pas aisée à trouver dans un tel environnement de développement. Malheureusement, je n'ai que celui-ci à ma disposition. Il faut donc que je me résigne à trouver une autre méthode pour arriver à satisfaire aux objectifs qui me sont demandés et, pour ce faire, oublier le doux rêve de pouvoir tout gérer en temps réel, ce qui, pour ma part, ést la condition essentielle à une réactivité optimale et des processus décisionnels facilités. Bref un boulot sans trop de stress pour ceux qui doivent gérer la production au quotidien. Snif!
On touche donc aux limites de ce produit qui pourtant rend déjà de fiers services.

Toutefois, pour ma culture personnelle, existe-t-il des environnements capables de réaliser la prouesse tant recherchée par mes responsables et moi-même?

Pour conclure, est-ce que le tag [résolu] est de circonstance?

Merci à toi, Loufab et à très bientôt pour de nouvelles aventures gersoises

[Boulken]

Bonjour à tous

Suite au problème rencontré quant à la possibilé de disposer d'une réplique d'un base que l'on peut modifier sans impact sur la base source, la solution que l'on a retenu est de faire une copie de la base une fois la journée de production terminée. On se limitera donc à une seule copie de la base en lieu et place du temps réel tant convoité. Il me reste néanmoins à résoudre un dernier point.
En effet, il faut que je puisse, d'un jour sur l'autre, répercuter les modifs faites sur la base source tout en n'écrasant pas les éventuelles corrections faites sur la base de destination. Heureusement, ces modifications ne se limitent qu'à deux tables. Il faut que je ponde une requête qui me permette un ajout des données crées lors de la production du jour tout en répercutant les mouvements de stocks des productions antérieures.
A suivre la super requête qui va bien...

[loufab]

Bonjour,

On en revient au système de requêtes.

Pour la copie, tu faire de l'automatique via le plannificateur de tâche de Windows (présent aussi bien sur les postes client que serveur).

Sans écrasement de donnée tu vas devoir faire un système d'ajout chronologique (champ date/heure supplémentaire pour identifier l'ordre des modifs).

Cordialement,

[Boulken]

Bonjour Loufab

Effectivement, seule la requête nous sauvera. Dans le cas présent, la duplication de la base ne peut se faire à heure fixe car la fin de la production n'est que trop rarement prévisible. De ce fait, seule une duplication déclenchée par l'utilisateur est envisageable. Pour ce qui est du tri des données, les tables qui m'intéressent possèdent un champ correspondant à la date de production. A partir de là, une requête d'ajout basée sur ce critère me permettra d'ajouter les données de la production du jour.
Dans la seconde base de donnée, j'attache toutes les tables de la première base et je crée deux nouvelles tables à partir de celles que je désire modifier.
Ensuite, seules sont répercutées sur ces deux nouvelles tables les données générées depuis le début de la journée en cours.
Malheureusement, si je veux que ma seconde base donne des résultats équivalents à la première en terme d'éditions et d'utilisation des formulaires, je doit remplacer dans tous les scripts, macros et requêtes le nom des deux tables source par celui des deux tables générées dans la deuxième version de ma base.
Bref, je ne peux échapper à un travail de fourmi méticuleux.
Sauf si je déniche La baguette magique qui va bien pour faire du rechercher/remplacer dans les moindres recoins sans en oublier.
C'est beau de rêver.

[loufab]

Il me semble qu'on a un truc comme ça (recherche/remplace) dans les outils. à voir.

En tout cas je l'ai vu quelques part un jour sur le net.

[Boulken]

Salut

Il y a bien V-Tools qui semble convenir parfaitement à la situation à l'exception d'un petit détail fort fâcheux ma foi.
Il n'existe pour le moment qu'en version compatible avec access 2003 et antérieurs et une tentative d'install sous access 2007 est sans appel.
Bref, je nage dedans...

[Boulken]

Salut à tous

Pour palier au problème de mise à jour d'une base par une autre (A vers B)possédant les mêmes tables et pour lesquelles les modifications de A doivent être appliquées à B sans pour autant écraser les modifications faites dans B et uniquement dans B, j'ai dupliqué la base A en la renommant B.
Ensuite, j'ai lier les tables de B dans A qui sont renommées avec un indice 1 à la fin du nom de ces tables. Ainsi, j'obtient la table LOT dans A et la table LOT1 dans A qui est le lien vers la table LOT de B.
Ensuite, une série de requêtes de non-correspondance permet de définir les jeux de nouveaux enregistrements saisis dans A à copier dans B pour les tables qui ne subissent pas de mises à jour après saisie.
Pour les autres tables, qui peuvent évoluer après la première saisie (typiquement entrée/sortie de stock), des requêtes d'update avec des critères bien sélectionnés permettent de ne transmettre que les modifications utiles.
On obtient un code VBA à rallonge sur clic d'un bouton accessible par mot de passe (visible true/false) connu de la seule personne abilitée pour cette manipulation. Et roule. Seul point critique : Respecter l'ordre des mises à jour en fonction des relations entre les tables sinon

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
 
 
Private Sub Form_Load()
    Commande29.Visible = False
    Commande30.Visible = False
End Sub
 
Private Sub MDP_AfterUpdate()
    If Me.MDP = "*****" Then
        Me.Commande29.Visible = True
        Me.Commande30.Visible = True
        Me.Commande29.SetFocus
    Else
        Me.Commande29.Visible = False
        Me.Commande30.Visible = False
    End If
End Sub
 
Private Sub Commande29_Click()
 
    DoCmd.Hourglass True
    DoCmd.SetWarnings False
 
    Dim SQL3 As String
    SQL3 = "INSERT INTO [MOTDECLA1]"
    SQL3 = SQL3 & " SELECT MOTDECLA.[Motif déclassé]"
    SQL3 = SQL3 & " FROM MOTDECLA LEFT JOIN MOTDECLA1 ON MOTDECLA.[Motif déclassé] = MOTDECLA1.[Motif déclassé]"
    SQL3 = SQL3 & " WHERE (((MOTDECLA1.[Motif déclassé]) Is Null));"
    DoCmd.RunSQL SQL3
    Dim SQL4 As String
    SQL4 = "INSERT INTO [ORGACERT1]"
    SQL4 = SQL4 & " SELECT ORGACERT.[Code OC], ORGACERT.[Libellé OC], ORGACERT.[Adresse OC], ORGACERT.[Code Postal OC], ORGACERT.[Ville OC], ORGACERT.[N° tel OC], ORGACERT.[N° fax OC], ORGACERT.[Mail OC]"
    SQL4 = SQL4 & " FROM ORGACERT LEFT JOIN ORGACERT1 ON ORGACERT.[Code OC] = ORGACERT1.[Code OC]"
    SQL4 = SQL4 & " WHERE (((ORGACERT1.[Code OC]) Is Null));"
    DoCmd.RunSQL SQL4
    Dim SQL5 As String
    SQL5 = "INSERT INTO [TYPCLASS1]"
    SQL5 = SQL5 & " SELECT TYPCLASS.[Code Classement], TYPCLASS.[Libellé Classement]"
    SQL5 = SQL5 & " FROM TYPCLASS LEFT JOIN TYPCLASS1 ON TYPCLASS.[Code Classement] = TYPCLASS1.[Code Classement]"
    SQL5 = SQL5 & " WHERE (((TYPCLASS1.[Code Classement]) Is Null));"
    DoCmd.RunSQL SQL5
    Dim SQL6 As String
    SQL6 = "INSERT INTO [MARQUES1]"
    SQL6 = SQL6 & " SELECT MARQUES.[Code Marque], MARQUES.[Libellé Marque]"
    SQL6 = SQL6 & " FROM MARQUES LEFT JOIN MARQUES1 ON MARQUES.[Code Marque] = MARQUES1.[Code Marque]"
    SQL6 = SQL6 & " WHERE (((MARQUES1.[Code Marque]) Is Null));"
    DoCmd.RunSQL SQL6
    Dim SQL7 As String
    SQL7 = "INSERT INTO [PRESENTA1]"
    SQL7 = SQL7 & " SELECT PRESENTA.[Code Présentation], PRESENTA.[Libellé Présentation]"
    SQL7 = SQL7 & " FROM PRESENTA LEFT JOIN PRESENTA1 ON PRESENTA.[Code Présentation] = PRESENTA1.[Code Présentation]"
    SQL7 = SQL7 & " WHERE (((PRESENTA1.[Code Présentation]) Is Null));"
    DoCmd.RunSQL SQL7
    Dim SQL8 As String
    SQL8 = "INSERT INTO [TYPESITE1]"
    SQL8 = SQL8 & " SELECT TYPESITE.[Code Type Site], TYPESITE.[Libellé Type Site]"
    SQL8 = SQL8 & " FROM TYPESITE LEFT JOIN TYPESITE1 ON TYPESITE.[Code Type Site] = TYPESITE1.[Code Type Site]"
    SQL8 = SQL8 & " WHERE (((TYPESITE1.[Code Type Site]) Is Null));"
    DoCmd.RunSQL SQL8
    Dim SQL9 As String
    SQL9 = "INSERT INTO [TRANSPOR1]"
    SQL9 = SQL9 & " SELECT TRANSPOR.[Code Transporteur], TRANSPOR.[Nom Transporteur], TRANSPOR.[Adresse Transporteur], TRANSPOR.[Code Postal Transporteur], TRANSPOR.[Ville Transporteur], TRANSPOR.[N° tel Transporteur], TRANSPOR.[N° fax Transporteur], TRANSPOR.[Mail Transporteur], TRANSPOR.[Date Contrat], TRANSPOR.[Coût H Chauffeur jour], TRANSPOR.[Coût H Chauffeur nuit], TRANSPOR.[Coût Fixe Structure], TRANSPOR.[Forfait dep ab], TRANSPOR.[Forfait arr élev], TRANSPOR.[Forfait dep élev], TRANSPOR.[Forfait arr ab ac lav], TRANSPOR.[Forfait arr ab ss lav], TRANSPOR.[Tps charg décharg pesée cont], TRANSPOR.[Tarif en cours], TRANSPOR.[Pénalité Bascule]"
    SQL9 = SQL9 & " FROM TRANSPOR LEFT JOIN TRANSPOR1 ON TRANSPOR.[Code Transporteur] = TRANSPOR1.[Code Transporteur]"
    SQL9 = SQL9 & " WHERE (((TRANSPOR1.[Code Transporteur]) Is Null));"
    DoCmd.RunSQL SQL9
    Dim SQL10 As String
    SQL10 = "INSERT INTO [CHAUFEUR1]"
    SQL10 = SQL10 & " SELECT CHAUFEUR.[Code Chauffeur], CHAUFEUR.[Nom Chauffeur], CHAUFEUR.[Adresse Chauffeur], CHAUFEUR.[Code Postal Chauffeur], CHAUFEUR.[Ville Chauffeur], CHAUFEUR.[N° tel Chauffeur], CHAUFEUR.[N° fax Chauffeur], CHAUFEUR.[Mail Chauffeur]"
    SQL10 = SQL10 & " FROM CHAUFEUR LEFT JOIN CHAUFEUR1 ON CHAUFEUR.[Code Chauffeur] = CHAUFEUR1.[Code Chauffeur]"
    SQL10 = SQL10 & " WHERE (((CHAUFEUR1.[Code Chauffeur]) Is Null));"
    DoCmd.RunSQL SQL10
    Dim SQL12 As String
    SQL12 = "INSERT INTO [FALIMVOL1]"
    SQL12 = SQL12 & " SELECT FALIMVOL.[Code Fournisseur AlimVol], FALIMVOL.[Nom Fournisseur AlimVol], FALIMVOL.[Adresse Fournisseur AlimVol], FALIMVOL.[Code Postal Fournisseur AlimVol], FALIMVOL.[Ville Fournisseur AlimVol], FALIMVOL.[N° tel Fournisseur AlimVol], FALIMVOL.[N° fax Fournisseur AlimVol], FALIMVOL.[Mail Fournisseur AlimVol]"
    SQL12 = SQL12 & " FROM FALIMVOL LEFT JOIN FALIMVOL1 ON FALIMVOL.[Code Fournisseur AlimVol] = FALIMVOL1.[Code Fournisseur AlimVol]"
    SQL12 = SQL12 & " WHERE (((FALIMVOL1.[Code Fournisseur AlimVol]) Is Null));"
    DoCmd.RunSQL SQL12
    Dim SQL13 As String
    SQL13 = "INSERT INTO [COUVOIRS1]"
    SQL13 = SQL13 & " SELECT COUVOIRS.[Code Couvoir], COUVOIRS.[Libellé Couvoir], COUVOIRS.[Adresse Couvoir], COUVOIRS.[Code Postal Couvoir], COUVOIRS.[Ville Couvoir], COUVOIRS.[N° tel Couvoir], COUVOIRS.[N° fax Couvoir], COUVOIRS.[Mail Couvoir]"
    SQL13 = SQL13 & " FROM COUVOIRS LEFT JOIN COUVOIRS1 ON COUVOIRS.[Code Couvoir] = COUVOIRS1.[Code Couvoir]"
    SQL13 = SQL13 & " WHERE (((COUVOIRS1.[Code Couvoir]) Is Null));"
    DoCmd.RunSQL SQL13
    Dim SQL14 As String
    SQL14 = "INSERT INTO [TYPEPROD1]"
    SQL14 = SQL14 & " SELECT TYPEPROD.[Code type prod], TYPEPROD.[Type produit]"
    SQL14 = SQL14 & " FROM TYPEPROD LEFT JOIN TYPEPROD1 ON TYPEPROD.[Code type prod] = TYPEPROD1.[Code type prod]"
    SQL14 = SQL14 & " WHERE (((TYPEPROD1.[Code type prod]) Is Null));"
    DoCmd.RunSQL SQL14
    Dim SQL15 As String
    SQL15 = "INSERT INTO [CONDITIO1]"
    SQL15 = SQL15 & " SELECT CONDITIO.[Code Conditionnement], CONDITIO.[Libellé Conditionnement], CONDITIO.[Poids Conditionnement], CONDITIO.[Coût Unitaire], CONDITIO.[Nbre conditionnemnt par Unité]"
    SQL15 = SQL15 & " FROM CONDITIO LEFT JOIN CONDITIO1 ON CONDITIO.[Code Conditionnement] = CONDITIO1.[Code Conditionnement]"
    SQL15 = SQL15 & " WHERE (((CONDITIO1.[Code Conditionnement]) Is Null));"
    DoCmd.RunSQL SQL15
    Dim SQL17 As String
    SQL17 = "INSERT INTO [OPERATOR1]"
    SQL17 = SQL17 & " SELECT OPERATOR.[Code Opérateur], OPERATOR.[Nom Opérateur]"
    SQL17 = SQL17 & " FROM OPERATOR LEFT JOIN OPERATOR1 ON OPERATOR.[Code Opérateur] = OPERATOR1.[Code Opérateur]"
    SQL17 = SQL17 & " WHERE (((OPERATOR1.[Code Opérateur]) Is Null));"
    DoCmd.RunSQL SQL17
    Dim SQL18 As String
    SQL18 = "INSERT INTO [TYPRECLA1]"
    SQL18 = SQL18 & " SELECT TYPRECLA.[Code Type Réclamation], TYPRECLA.[Libellé Type Réclamation]"
    SQL18 = SQL18 & " FROM TYPRECLA LEFT JOIN TYPRECLA1 ON TYPRECLA.[Code Type Réclamation] = TYPRECLA1.[Code Type Réclamation]"
    SQL18 = SQL18 & " WHERE (((TYPRECLA1.[Code Type Réclamation]) Is Null));"
    DoCmd.RunSQL SQL18
    Dim SQL19 As String
    SQL19 = "INSERT INTO [PLANNIFS1]"
    SQL19 = SQL19 & " SELECT PLANNIFS.[Code Plannificateur], PLANNIFS.[Nom Plannificateur], PLANNIFS.[N° Fax Plannificateur], PLANNIFS.[Actif]"
    SQL19 = SQL19 & " FROM PLANNIFS LEFT JOIN PLANNIFS1 ON PLANNIFS.[Code Plannificateur] = PLANNIFS1.[Code Plannificateur]"
    SQL19 = SQL19 & " WHERE (((PLANNIFS1.[Code Plannificateur]) Is Null));"
    DoCmd.RunSQL SQL19
    Dim SQL20 As String
    SQL20 = "INSERT INTO [TYPEDLC1]"
    SQL20 = SQL20 & " SELECT TYPEDLC.[Code DLC], TYPEDLC.[Nbre Jours DLC]"
    SQL20 = SQL20 & " FROM TYPEDLC LEFT JOIN TYPEDLC1 ON TYPEDLC.[Code DLC] = TYPEDLC1.[Code DLC]"
    SQL20 = SQL20 & " WHERE (((TYPEDLC1.[Code DLC]) Is Null));"
    DoCmd.RunSQL SQL20
    Dim SQL36 As String
    SQL36 = "INSERT INTO [TYPTRANS1]"
    SQL36 = SQL36 & " SELECT TYPTRANS.[Code Type Transfert], TYPTRANS.[Type Transfert], TYPTRANS.Labelisable"
    SQL36 = SQL36 & " FROM TYPTRANS LEFT JOIN TYPTRANS1 ON TYPTRANS.[Code Type Transfert] = TYPTRANS1.[Code Type Transfert]"
    SQL36 = SQL36 & " WHERE (((TYPTRANS1.[Code Type Transfert]) Is Null));"
    DoCmd.RunSQL SQL36
    Dim SQL11 As String
    SQL11 = "INSERT INTO [GROUPEMT1]"
    SQL11 = SQL11 & " SELECT GROUPEMT.[Code Groupement], GROUPEMT.[Nom Groupement], GROUPEMT.[Adresse Groupement], GROUPEMT.[Code Postal Groupement], GROUPEMT.[Ville Groupement], GROUPEMT.[N° tel Groupement], GROUPEMT.[N° fax Groupement], GROUPEMT.[Mail Groupement], GROUPEMT.Contrat"
    SQL11 = SQL11 & " FROM GROUPEMT LEFT JOIN GROUPEMT1 ON GROUPEMT.[Code Groupement] = GROUPEMT1.[Code Groupement]"
    SQL11 = SQL11 & " WHERE (((GROUPEMT1.[Code Groupement]) Is Null));"
    DoCmd.RunSQL SQL11
    Dim SQL21 As String
    SQL21 = "INSERT INTO [LABELS1]"
    SQL21 = SQL21 & " SELECT LABELS.[Code Label], LABELS.[Code OC], LABELS.[N° Label]"
    SQL21 = SQL21 & " FROM LABELS LEFT JOIN LABELS1 ON LABELS.[Code Label] = LABELS1.[Code Label]"
    SQL21 = SQL21 & " WHERE (((LABELS1.[Code Label]) Is Null));"
    DoCmd.RunSQL SQL21
    Dim SQL22 As String
    SQL22 = "INSERT INTO [SITE1]"
    SQL22 = SQL22 & " SELECT SITE.[Code Site], SITE.[Type Site], SITE.[Nom Site], SITE.[Adresse Site], SITE.[Code Postal Site], SITE.[Ville Site], SITE.[N° tel Site], SITE.[N° fax Site], SITE.[Mail Site], SITE.[N° Agrément Site]"
    SQL22 = SQL22 & " FROM SITE LEFT JOIN SITE1 ON SITE.[Code Site] = SITE1.[Code Site]"
    SQL22 = SQL22 & " WHERE (((SITE1.[Code Site]) Is Null));"
    DoCmd.RunSQL SQL22
    Dim SQL23 As String
    SQL23 = "INSERT INTO [CAMIONS1]"
    SQL23 = SQL23 & " SELECT CAMIONS.[Code Camion], CAMIONS.[Code Transporteur], CAMIONS.[Modèle Camion], CAMIONS.[Immatriculation Camion], CAMIONS.[Nbre Containers mini Camion], CAMIONS.[Nbre Containers maxi Camion], CAMIONS.[Nbre Palettes mini Camion], CAMIONS.[Nbre Palettes maxi Camion], CAMIONS.[Coût base 24H], CAMIONS.[Coût KM]"
    SQL23 = SQL23 & " FROM CAMIONS LEFT JOIN CAMIONS1 ON CAMIONS.[Code Camion] = CAMIONS1.[Code Camion]"
    SQL23 = SQL23 & " WHERE (((CAMIONS1.[Code Camion]) Is Null));"
    DoCmd.RunSQL SQL23
    Dim SQL24 As String
    SQL24 = "INSERT INTO [ELEVEUR1]"
    SQL24 = SQL24 & " SELECT ELEVEUR.[Code Eleveur], ELEVEUR.[Nom Eleveur], ELEVEUR.[Eleveur base AVILOG], ELEVEUR.[Adresse Eleveur], ELEVEUR.[Code Postal Eleveur], ELEVEUR.[Ville Eleveur], ELEVEUR.[N° tel Eleveur], ELEVEUR.[N° tel Eleveur 2], ELEVEUR.[N° tel Eleveur 3], ELEVEUR.[N° fax Eleveur]"
    SQL24 = SQL24 & " FROM ELEVEUR LEFT JOIN ELEVEUR1 ON ELEVEUR.[Code Eleveur] = ELEVEUR1.[Code Eleveur]"
    SQL24 = SQL24 & " WHERE (((ELEVEUR1.[Code Eleveur]) Is Null));"
    DoCmd.RunSQL SQL24
    Dim SQL25 As String
    SQL25 = "INSERT INTO [ESPECES1]"
    SQL25 = SQL25 & " SELECT ESPECES.[Code Espèce], ESPECES.[Code Label], ESPECES.[Libellé Espèce], ESPECES.[Age mini Espèce], ESPECES.[Age maxi Espèce], ESPECES.[Poids mini Espèce], ESPECES.[Poids maxi Espèce], ESPECES.[Réf Tx Déclassement Espèce], ESPECES.[Réf Tx Saisie Espèce], ESPECES.[Réf Rdt Mort Vif Espèce], ESPECES.GMQ, ESPECES.[Code Group Abat], ESPECES.Label"
    SQL25 = SQL25 & " FROM ESPECES LEFT JOIN ESPECES1 ON ESPECES.[Code Espèce] = ESPECES1.[Code Espèce]"
    SQL25 = SQL25 & " WHERE (((ESPECES1.[Code Espèce]) Is Null));"
    DoCmd.RunSQL SQL25
    Dim SQL26 As String
    SQL26 = "INSERT INTO [ETIQUETT1]"
    SQL26 = SQL26 & " SELECT ETIQUETT.[N° Etiquette], ETIQUETT.[Libellé Etiquette], ETIQUETT.[Code Etiquette], ETIQUETT.[Code Label], ETIQUETT.[Code Présentation], ETIQUETT.[Code Marque], ETIQUETT.[Nbre Etiquettes], ETIQUETT.Stock"
    SQL26 = SQL26 & " FROM ETIQUETT LEFT JOIN ETIQUETT1 ON ETIQUETT.[N° Etiquette] = ETIQUETT1.[N° Etiquette]"
    SQL26 = SQL26 & " WHERE (((ETIQUETT1.[N° Etiquette]) Is Null));"
    DoCmd.RunSQL SQL26
    Dim SQL28 As String
    SQL28 = "INSERT INTO [STOCROUL1]"
    SQL28 = SQL28 & " SELECT STOCROUL.[Code achat], STOCROUL.[N° Etiquette], STOCROUL.[1er N°], STOCROUL.[Der N°], STOCROUL.[Date achat], STOCROUL.Valide"
    SQL28 = SQL28 & " FROM STOCROUL LEFT JOIN STOCROUL1 ON STOCROUL.[Code achat] = STOCROUL1.[Code achat]"
    SQL28 = SQL28 & " WHERE (((STOCROUL1.[Code achat]) Is Null));"
    DoCmd.RunSQL SQL28
    Dim SQL29 As String
    SQL29 = "INSERT INTO [ENLEVEMT1]"
    SQL29 = SQL29 & " SELECT ENLEVEMT.[Code Enlèvement], ENLEVEMT.[Date Enlèvement], ENLEVEMT.[Code Camion], ENLEVEMT.[N° Tournée], ENLEVEMT.[Code Chauffeur], ENLEVEMT.Eleveur, ENLEVEMT.Espèce, ENLEVEMT.Groupement, ENLEVEMT.[Nbre pers ramassage], ENLEVEMT.[Poids brut Camion], ENLEVEMT.[Tare Camion], ENLEVEMT.[Poids net Camion], ENLEVEMT.[Quantité ramassée], ENLEVEMT.[Quantité prévue], ENLEVEMT.[Temps route], ENLEVEMT.[Temps bascule], ENLEVEMT.[Pesée élev], ENLEVEMT.[Temps préparation], ENLEVEMT.[Temps chargement], ENLEVEMT.[Distance parcourue], ENLEVEMT.[Nbre conteneurs], ENLEVEMT.[Charg cont], ENLEVEMT.[Décharg cont], ENLEVEMT.[Forfait dép ab], ENLEVEMT.[Forfait arr ab ss lav], ENLEVEMT.[Forfait arr ab ac lav], ENLEVEMT.[Nbre conteneurs rechargés], ENLEVEMT.[Heure dép ab élev1], ENLEVEMT.[Heure arr élev1], ENLEVEMT.[Heure déb charg], ENLEVEMT.[Heure fin charg], ENLEVEMT.[Heure dép élev1], ENLEVEMT.[Heure arr ab élev2]"
    SQL29 = SQL29 & " FROM ENLEVEMT LEFT JOIN ENLEVEMT1 ON ENLEVEMT.[Code Enlèvement] = ENLEVEMT1.[Code Enlèvement]"
    SQL29 = SQL29 & " WHERE (((ENLEVEMT1.[Code Enlèvement]) Is Null));"
    DoCmd.RunSQL SQL29
    Dim SQL30 As String
    SQL30 = "INSERT INTO [PRODUITS1]"
    SQL30 = SQL30 & " SELECT PRODUITS.[Code Produit], PRODUITS.[Code type prod], PRODUITS.[Code Agrostar], PRODUITS.[Libellé Produit], PRODUITS.[N° Etiquette], PRODUITS.[Nbre Vol par Produit], PRODUITS.Congélation, PRODUITS.[Poids mini Produit], PRODUITS.[Poids maxi Produit], PRODUITS.[Code Conditionnement], PRODUITS.[Colisage Produit], PRODUITS.[Nbre Colis par Palette], PRODUITS.PRI, PRODUITS.PRC, PRODUITS.Entiers, PRODUITS.Ailes, PRODUITS.RDTAiles, PRODUITS.Supremes, PRODUITS.RDTSupremes, PRODUITS.Pilons, PRODUITS.RDTPilons, PRODUITS.HDC, PRODUITS.RDTHDC, PRODUITS.Cuisses, PRODUITS.RDTCuisses, PRODUITS.Filets, PRODUITS.RDTFilets, PRODUITS.Aiguillettes, PRODUITS.RDTAiguillettes"
    SQL30 = SQL30 & " FROM PRODUITS LEFT JOIN PRODUITS1 ON PRODUITS.[Code Produit] = PRODUITS1.[Code Produit]"
    SQL30 = SQL30 & " WHERE (((PRODUITS1.[Code Produit]) Is Null));"
    DoCmd.RunSQL SQL30
    Dim SQL1 As String
    SQL1 = "INSERT INTO [CADENCE CHARGEMENT1]"
    SQL1 = SQL1 & " SELECT [CADENCE CHARGEMENT].[Code Cadence], [CADENCE CHARGEMENT].ESPECE, [CADENCE CHARGEMENT].[Code Espèce], [CADENCE CHARGEMENT].CADENCE, [CADENCE CHARGEMENT].[VOL MINI], [CADENCE CHARGEMENT].[VOL MAXI], [CADENCE CHARGEMENT].[PENALITE PAR H]"
    SQL1 = SQL1 & " FROM [CADENCE CHARGEMENT] LEFT JOIN [CADENCE CHARGEMENT1] ON [CADENCE CHARGEMENT].[Code Cadence] = [CADENCE CHARGEMENT1].[Code Cadence]"
    SQL1 = SQL1 & " WHERE ((([CADENCE CHARGEMENT1].[Code Cadence]) Is Null));"
    DoCmd.RunSQL SQL1
    Dim SQL27 As String
    SQL27 = "INSERT INTO [CALIBRES1]"
    SQL27 = SQL27 & " SELECT CALIBRES.[Code Calibre], CALIBRES.[Code Espèce], CALIBRES.[Code Présentation], CALIBRES.[Code Classement], CALIBRES.[Libellé Calibre], CALIBRES.[Nbre par Caisse]"
    SQL27 = SQL27 & " FROM CALIBRES LEFT JOIN CALIBRES1 ON CALIBRES.[Code Calibre] = CALIBRES1.[Code Calibre]"
    SQL27 = SQL27 & " WHERE (((CALIBRES1.[Code Calibre]) Is Null));"
    DoCmd.RunSQL SQL27
    Dim SQL37 As String
    SQL37 = "INSERT INTO [LOT1]"
    SQL37 = SQL37 & " SELECT LOT.[Code lot], LOT.[Code Espèce], LOT.[N° lot], LOT.[Code Groupement], LOT.[Code Couvoir], LOT.[Code Fournisseur AlimVol], LOT.[Code Eleveur], LOT.[Date Abattage], LOT.[Code DLC], LOT.[Ordre Abattage], LOT.[Nbre prévu], LOT.[PAC prévu], LOT.[Découpe prévu], LOT.[Poids annoncé], LOT.[Nbre enlevé], LOT.[Poids enlevé], LOT.[Nbre abattu], LOT.[Poids départ élev], LOT.[Poids abattoir], LOT.[Poids facturé], LOT.[Nbre Mise à jeun], LOT.[Nbre Etouffés], LOT.[Poids Etouffés], LOT.[Nbre Calibreuse], LOT.[Poids Calibreuse], LOT.[N° BEP], LOT.[N° BANDE], LOT.Sexe, LOT.Age, LOT.Foies, LOT.Coeurs, LOT.Gésiers, LOT.Freinte, LOT.[Poids moyen vif], LOT.[Poids moyen mort], LOT.[RDT Mort Vif], LOT.[Nbre classés BA], LOT.[% classés BA], LOT.[Nbre classés BE], LOT.[% classés BE], LOT.[Nbre classés AB], LOT.[% classés AB], LOT.[Nbre classés petit], LOT.[% classés petit], LOT.[% total déclassés élev], LOT.[Motif 1], LOT.[% Motif 1], LOT.[Motif 2], LOT.[% Motif 2], LOT.[Motif 3], LOT.[% Motif 3]"
    SQL37 = SQL37 & ", LOT.[Motif 4], LOT.[% Motif 4], LOT.[Nbre saisies élev], LOT.[Poids saisies élev], LOT.[Nbre saisies abat], LOT.[Poids saisies abat vif], LOT.[Poids saisies abat mort], LOT.[Poids saisies part vif], LOT.[Poids saisies part mort], LOT.[Motif saisie 1], LOT.[Motif saisie 2], LOT.Paille, LOT.Jaune, LOT.Blanc, LOT.[Nbre Jabots], LOT.[Poids par jabot], LOT.Farines, LOT.Céréales, LOT.Pénalité, LOT.[Poids à déduire en kg], LOT.[Mise à jeun], LOT.Observations, LOT.[Eleveur prévenu], LOT.[Fiche Ante Mortem], LOT.[Heure déb abat], LOT.[Poids tracé dec], LOT.[Poids tracé entier], LOT.[RDT Découpe], LOT.[Remarques qualité], LOT.[Class froid]"
    SQL37 = SQL37 & " FROM LOT LEFT JOIN LOT1 ON LOT.[Code lot] = LOT1.[Code lot]"
    SQL37 = SQL37 & " WHERE (((LOT.[Date Abattage])<=Date()) AND ((LOT1.[Code lot]) Is Null));"
    DoCmd.RunSQL SQL37
    Dim SQL31 As String
    SQL31 = "INSERT INTO [RECLAMAT1]"
    SQL31 = SQL31 & " SELECT RECLAMAT.[Code Réclamation], RECLAMAT.[Date Réclamation], RECLAMAT.[Nom Opérateur], RECLAMAT.Mois, RECLAMAT.[Type Réclamation], RECLAMAT.[Nom Plannificateur], RECLAMAT.[Libellé Espèce], RECLAMAT.[Nom Eleveur], RECLAMAT.[Nom Groupement], RECLAMAT.[Nom Demandeur], RECLAMAT.Produit, RECLAMAT.[Code Lot], RECLAMAT.[Date Livraison], RECLAMAT.[Non Conformités], RECLAMAT.[Impact Financier], RECLAMAT.Formalisation, RECLAMAT.Reclam, RECLAMAT.[Réponse Fournisseur], RECLAMAT.Montant"
    SQL31 = SQL31 & " FROM RECLAMAT LEFT JOIN RECLAMAT1 ON RECLAMAT.[Code Réclamation] = RECLAMAT1.[Code Réclamation]"
    SQL31 = SQL31 & " WHERE (((RECLAMAT1.[Code Réclamation]) Is Null));"
    DoCmd.RunSQL SQL31
    Dim SQL32 As String
    SQL32 = "INSERT INTO [PESEEVIF1]"
    SQL32 = SQL32 & " SELECT PESEEVIF.[N° Pesée], PESEEVIF.[Code lot], PESEEVIF.[Code Enlèvement], PESEEVIF.[Nbre Containers], PESEEVIF.[Age Volailles], PESEEVIF.[Poids enlevé], PESEEVIF.[Nbre prévu Enlèvement], PESEEVIF.[Nbre enlevé], PESEEVIF.[Poids annoncé], PESEEVIF.[Poids autorisé]"
    SQL32 = SQL32 & " FROM PESEEVIF LEFT JOIN PESEEVIF1 ON PESEEVIF.[N° Pesée] = PESEEVIF1.[N° Pesée]"
    SQL32 = SQL32 & " WHERE (((PESEEVIF1.[N° Pesée]) Is Null));"
    DoCmd.RunSQL SQL32
    Dim SQL33 As String
    SQL33 = "INSERT INTO [TRANSFER1]"
    SQL33 = SQL33 & " SELECT TRANSFER.[Code Transfert], TRANSFER.[Code Lot], TRANSFER.[Code Type Transfert], TRANSFER.[Date Production], TRANSFER.[Poids Cuisses], TRANSFER.[Poids Filets], TRANSFER.[Rdt Cuisses], TRANSFER.[Rdt Filets], TRANSFER.[Nbre Entiers], TRANSFER.[Poids Entiers]"
    SQL33 = SQL33 & " FROM TRANSFER LEFT JOIN TRANSFER1 ON TRANSFER.[Code Transfert] = TRANSFER1.[Code Transfert]"
    SQL33 = SQL33 & " WHERE (((TRANSFER1.[Code Transfert]) Is Null));"
    DoCmd.RunSQL SQL33
    Dim SQL34 As String
    SQL34 = "INSERT INTO [MOTIFCLA1]"
    SQL34 = SQL34 & " SELECT MOTIFCLA.[Code Lot], MOTIFCLA.[Motif 1], MOTIFCLA.[% motf 1], MOTIFCLA.[Motif 2], MOTIFCLA.[% motf 2], MOTIFCLA.[Motif 3], MOTIFCLA.[% motf 3], MOTIFCLA.[Motif 4], MOTIFCLA.[% motf 4], MOTIFCLA.[Motif saisies 1], MOTIFCLA.[Motif saisies 2]"
    SQL34 = SQL34 & " FROM MOTIFCLA LEFT JOIN MOTIFCLA1 ON MOTIFCLA.[Code Lot] = MOTIFCLA1.[Code Lot]"
    SQL34 = SQL34 & " WHERE (((MOTIFCLA1.[Code Lot]) Is Null));"
    DoCmd.RunSQL SQL34
    Dim SQL38 As String
    SQL38 = "INSERT INTO [ROLLER1]"
    SQL38 = SQL38 & " SELECT ROLLER.[N° Roller], ROLLER.[Code lot], ROLLER.[N° lot], ROLLER.[Code Calibre], ROLLER.[Heure entrée ressuage], ROLLER.[Heure sortie ressuage], ROLLER.[Nbre Clayettes], ROLLER.[Nbre Vol Roller], ROLLER.[Poids froid Roller], ROLLER.[Poids chaud Roller], ROLLER.[Température sortie ressuage], ROLLER.[Poids Clayette], ROLLER.[Poids Rollbac], ROLLER.[Date Production], ROLLER.[Heure Production], ROLLER.[Température mise en prod], ROLLER.[Etat stock], ROLLER.Affectation, ROLLER.[Poste Appro], ROLLER.[Poids Brut]"
    SQL38 = SQL38 & " FROM ROLLER LEFT JOIN ROLLER1 ON ROLLER.[N° Roller] = ROLLER1.[N° Roller]"
    SQL38 = SQL38 & " WHERE (((ROLLER1.[N° Roller]) Is Null));"
    DoCmd.RunSQL SQL38
    Dim SQL39 As String
    SQL39 = "UPDATE ROLLER1 INNER JOIN ROLLER ON ROLLER1.[N° Roller] = ROLLER.[N° Roller]"
    SQL39 = SQL39 & " SET ROLLER1.[Heure sortie ressuage] = [ROLLER].[Heure sortie ressuage], ROLLER1.[Température sortie ressuage] = [ROLLER].[Température sortie ressuage], ROLLER1.[Date Production] = [ROLLER].[Date Production], ROLLER1.[Heure Production] = [ROLLER].[Heure Production], ROLLER1.[Etat stock] = [ROLLER].[Etat stock], ROLLER1.Affectation = [ROLLER].[Affectation], ROLLER1.[Poste Appro] = [ROLLER].[Poste Appro]"
    SQL39 = SQL39 & " WHERE (((ROLLER1.[Date Production])<Date()) AND ((ROLLER1.[Etat stock])<>0));"
    DoCmd.RunSQL SQL39
    Dim SQL40 As String
    SQL40 = "INSERT INTO [ROULEAUX1]"
    SQL40 = SQL40 & " SELECT ROULEAUX.[N° Rouleau], ROULEAUX.[Code Achat], ROULEAUX.[1er N°], ROULEAUX.[Der N°], ROULEAUX.Terminé, ROULEAUX.[Nbre Etiqu Detruites], ROULEAUX.[Der N° utilisé], ROULEAUX.[Etat stock], ROULEAUX.Affectation, ROULEAUX.[Code Site], ROULEAUX.[Date Cession]"
    SQL40 = SQL40 & " FROM ROULEAUX LEFT JOIN ROULEAUX1 ON ROULEAUX.[N° Rouleau] = ROULEAUX1.[N° Rouleau]"
    SQL40 = SQL40 & " WHERE (((ROULEAUX1.[N° Rouleau]) Is Null));"
    DoCmd.RunSQL SQL40
    Dim SQL41 As String
    SQL41 = "UPDATE ROULEAUX INNER JOIN ROULEAUX1 ON ROULEAUX.[N° Rouleau] = ROULEAUX1.[N° Rouleau]"
    SQL41 = SQL41 & " SET ROULEAUX1.Terminé = [ROULEAUX].[Terminé], ROULEAUX1.[Etat stock] = [ROULEAUX].[Etat stock], ROULEAUX1.[Code Site] = [ROULEAUX].[Code Site], ROULEAUX1.[Date Cession] = [ROULEAUX].[Date Cession]"
    SQL41 = SQL41 & " WHERE (((ROULEAUX.[Date Cession]) Is Not Null));"
    DoCmd.RunSQL SQL41
    Dim SQL35 As String
    SQL35 = "INSERT INTO [PRODUCTI1]"
    SQL35 = SQL35 & " SELECT PRODUCTI.[Code Production], PRODUCTI.[Code Produit], PRODUCTI.[Date Production], PRODUCTI.[Code Lot], PRODUCTI.[N° Rouleau], PRODUCTI.[1er Num], PRODUCTI.[Der Num], PRODUCTI.[Nbre étiq détruites], PRODUCTI.[Nbre Produit], PRODUCTI.[Poids Produit], PRODUCTI.[Nbre Opérateurs], PRODUCTI.[Heure Début], PRODUCTI.[Heure Fin], PRODUCTI.Attribution"
    SQL35 = SQL35 & " FROM PRODUCTI LEFT JOIN PRODUCTI1 ON PRODUCTI.[Code Production] = PRODUCTI1.[Code Production]"
    SQL35 = SQL35 & " WHERE (((PRODUCTI1.[Code Production]) Is Null));"
    DoCmd.RunSQL SQL35
    DoCmd.Hourglass False
End Sub