<\/p>\n
Neulich wollte ich meine Shopsoftware aktualisieren. Allerdings ging dies nicht mit den vom Hersteller dafür bereitgestellten Plug-In – zumindest nicht mit allen Daten, die ich von der alten in die neue Version überführen wollte. Also musste ich manuell ermitteln, welche Daten der alten Version benötigt werden, damit die neue Version läuft. Damit erhielt ich recht schnell eine lauffähige Version des neuen Systems. Allerdings kam mir dann etwas dazwischen, wodurch zum alten, noch aktiven System wieder neue Kunden und Bestellungen hinzukamen – die Arbeit war also umsonst. Um das Übertragen der Daten beim nächsten Mal einfacher zu gestalten, wollte ich nun das alte und das neue Datenmodell nun automatisch analysieren und die SQL-Befehle erstellen lassen, um diese danach ebenfalls automatisch ausführen zu können. Wie das gelingt, zeigt der vorliegende Beitrag.<\/b><\/p>\n
Bei der Shopsoftware handelt es sich um ein Produkt namens Shopware<\/b>. Es verwendet eine MySQL-Datenbank.<\/p>\n
Die hier vorgestellten Techniken lassen sich jedoch auch auf andere Systeme übertragen – und auch auf andere Anwendungen.<\/p>\n
Auch MySQL als Datenbanksystem kann durch andere Systeme ersetzt werden – Sie müssen dann schlicht den Treiber in der Verbindungszeichenfolge austauschen und gegebenenfalls ein paar Abfragen auf spezifische Eigenarten des jeweiligen Dialekts anpassen. Voraussetzung für die Nutzung der hier vorgestellten Technik ist der Zugriff auf die Datenbank. Ob dies möglich ist, müssen Sie mit dem jeweiligen Provider klären.<\/p>\n
Zugriff per ADODB<\/b><\/p>\n
Damit wir per ODBC auf die Daten der beiden zu vergleichenden MySQL-Datenbanken zugreifen können, fügen wir der Datenbank einen Verweis auf die Bibliothek Microsoft ActiveX Data Objects 2.8 Library <\/b>zum VBA-Projekt einer neuen Access-Datenbank hinzu (siehe Bild 1).<\/p>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2019_05\/pic_1208_001.png\")
<\/p>\n
Bild 1: Verweis auf die ADODB-Bibliothek<\/span><\/b><\/p>\n Tabellen abgleichen<\/b><\/p>\n Als Erstes wollen wir die Tabellen der beiden Datenbanken abgleichen, also prüfen, ob es in der ersten Datenbank Tabellen gibt, die nicht in der zweiten Datenbank vorkommen und umgekehrt.<\/p>\n Dazu legen wir zwei Konstanten mit den Verbindungszeichenfolgen der beiden Datenbanken in einem neuen Modul namens mdlADODB <\/b>an:<\/p>\n Die Funktion GetConnection <\/b>erwartet die Angabe der zu verwendenden Verbindungszeichenfolge als Parameter. Sie erstellt ein neues Objekt des Typs ADODB.Connection <\/b>und öffnet diese unter Angabe der Verbindungszeichenfolge (siehe Listing 1).<\/p>\n Listing 1: Die Funktion GetConnection<\/span><\/b><\/p>\n Die Funktion GetRecordset <\/b>erwartet ein ADODB.Connection<\/b>-Objekt, das wir zuvor beispielsweise mit der Funktion GetConnection <\/b>ermitteln, sowie eine SQL-Anweisung mit der zu verwendenden Abfrage (siehe Listing 2). Die Funktion erstellt ein neues ADODB.Recordset<\/b>-Objekt und stellt seine Eigenschaften ein, darunter auch die SQL-Abfrage für die Eigenschaft Source<\/b>. Das Ergebnis wird dann als ADODB.Recordset<\/b>-Objekt zurückgegeben.<\/p>\n Listing 2: Die Funktion GetRecordset<\/span><\/b><\/p>\n Danach nutzen wir diese beiden Funktionen in einer neuen Prozedur namens TabellenAbgleichen<\/b> (siehe Listing 3). Diese Prozedur verwendet zwei ADODB.Recordset<\/b>-Objekte namens rstAlt <\/b>und rstNeu<\/b>, um die Namen der Tabellen der alten und der neuen Version der Datenbank zu speichern. Diese füllen wir jeweils mit einem Aufruf der Funktion GetRecordset<\/b>, wobei wir einmal die Verbindungszeichenfolge aus cStrVerbindungszeichenfolgeAlt <\/b>und einmal die aus cStrVerbindungszeichenfolgeNeu <\/b>übergeben. In beiden Fällen geben wir als SQL-Anweisung keine einfache SELECT<\/b>-Anweisung an, sondern die Anweisung Show Tables<\/b>. Dies ist eine MySQL-spezifische Anweisung, die alle Tabellen einer Datenbank liefert. Danach sortieren wir die Inhalte der beiden Recordsets rstAlt <\/b>und rstNeu <\/b>aufsteigend nach dem Inhalt des einzigen Feldes.<\/p>\n Listing 3: Die Prozedur TabellenAbgleichen<\/span><\/b><\/p>\n Schließlich durchlaufen wir das Recordset rstAlt <\/b>in einer Do While<\/b>-Schleife, bis die Datensatzmarkierung des auf EOF <\/b>steht. In dieser Schleife durchlaufen wir auf bestimmte Weise beide Recordsets, wobei gegebenenfalls noch ein oder mehrere Datensätze im Recordset rstNeu <\/b>übrig bleiben.<\/p>\n Dabei prüfen wir zunächst, ob rstNeu.EOF <\/b>wahr ist. Das ist zu Beginn in der Regel noch nicht der Fall – außer, die neue Datenbank enthält gar keine Tabellen. Anderenfalls prüfen wir, ob der aktuelle Datensatz von rstAlt <\/b>und rstNeu <\/b>den gleichen Wert aufweisen, was darauf hindeutet, dass die Tabelle in beiden Datenbanken vorhanden ist. In diesem Fall geben wir im Direktbereich den Namen der Tabelle zwei Mal aus und verschieben die Datensatzzeiger beider Recordsets mit MoveNext<\/b> zur nächsten Position. Ist rstAlt.Fields(0) > rstNeu.Fields(0)<\/b>, dann stimmen die aktuellen Tabellennamen nicht überein und der Tabellenname aus rstNeu<\/b> liegt im Alphabet vor dem aus rstAlt<\/b>. In diesem Fall geben wir eine Zeichenkette aus vier Minuszeichen (—-<\/b>) aus und den Namen der Tabelle aus rstNeu<\/b>. Außerdem verschieben wir den Datensatzzeiger von rstNeu <\/b>um eine Position weiter.<\/p>\n Das heißt, wir bleiben bei dem Tabellennamen von rstAlt <\/b>und wechseln zum nächsten Eintrag von rstNeu<\/b>. Die nächst ElseIf<\/b>-Bedingung behandelt den umgekehrten Fall, nämlich dass der Eintrag aus rstAlt <\/b>im Alphabet vor dem Eintrag aus rstNeu <\/b>liegt. Dann geben wir den aus rstAlt <\/b>aus und vier Minuszeichen statt des Eintrags aus rstNeu <\/b>und verschieben den Datensatzzeiger in rstAlt <\/b>um eine Position weiter nach hinten.<\/p>\n Wenn also etwa in beiden Datenbanken tblA <\/b>und tblB <\/b>vorhanden sind, werden diese so ausgegeben:<\/p>\n Wenn in tblA <\/b>nur in rstNeu <\/b>vorhanden ist, erhalten wir dieses Ergebnis:<\/p>\n Ist tblA <\/b>in beiden Datenbanken vorhanden und tblB <\/b>nur in der alten, sieht das Ergebnis so aus:<\/p>\n Nun gibt es drei Fälle für das Ende des Durchlaufens der Datensätze mit den Tabellenamen in der ersten Do While<\/b>-Schleife:<\/p>\n In allen Fällen wird die Bedingung der zweiten Do While<\/b>-Schleife noch einmal geprüft, nämlich Not rstNeu.EOF<\/b>. Sollten also nach dem Durchlaufen von rstAlt <\/b>noch Datensätze in rstNeu <\/b>vorhanden sein, durchläuft die Prozedur diese in der zweiten Do While<\/b>-Schleife. Dort gibt sie für die übrigen Tabellen der neuen Version der Datenbank die Tabellennamen aus, also etwa so:<\/p>\n Interpretation des Ergebnisses<\/b><\/p>\n Damit erhalten wir nun eine Gegenüberstellung der Tabellen der alten und der neuen Version der Datenbank, die etwa so aussehen könnte:<\/p>\n Die Tabelle tblC <\/b>kommt nicht in der alten Datenbank vor, aber in der neuen Version. tblD <\/b>hingegen kommt nur in der alten, aber nicht in der neuen Version vor. Alle anderen Tabellen sind in beiden Versionen der Datenbank vorhanden.<\/p>\n Die Interpretation könnte wie folgt lauten:<\/p>\n <\/p>\n Felder vergleichen<\/b><\/p>\n Wenn wir nun die Daten aus der alten Version der Datenbank in die neue Version übertragen wollen, könnten wir theoretisch für jede Tabelle, die in der alten und in der neuen Version vorhanden ist, folgende Anweisung schreiben (vorausgesetzt, die Datenbanken befinden sich auf dem gleichen MySQL-Server):<\/p>\n Das klappt aber auch nur, wenn die Struktur der Tabelle in der alten und der neuen Version der Datenbank identisch ist, also wenn die Tabellen die gleichen Felder enthalten. Anderenfalls gibt es eine Fehlermeldung.<\/p>\n In diesem Fall müssen wir untersuchen, welche der Felder der Tabelle der alten Version der Datenbank in der Tabelle der neuen Version der Datenbank vorkommen und diese statt des Platzhalters Sternchen (*<\/b>) in die SELECT…INTO<\/b>-Anweisung einfügen.<\/p>\n Gemeinsame Felder ermitteln<\/b><\/p>\n Um diese gemeinsamen Felder zu ermitteln, fügen wir dem If<\/b>-Zweig der inneren If…Then<\/b>-Bedingung den Aufruf der Funktion FelderAbgleichen <\/b>mit dem Namen der Tabelle als Parameter hinzu. Das Ergebnis der Aufrufe dieser Funktion fügen wir in der Variablen strSQLInsert <\/b>zusammen. Auf die gleiche Weise fügen wir in der Variablen strSQLDelete <\/b>jeweils eine DELETE<\/b>-Anweisung für die betroffenen Tabellen der neuen Version der Datenbank zusammen:<\/p>\n Die Funktion FelderAbgleichen <\/b>finden Sie in Listing 4. Sie erwartet den Namen der zu untersuchenden Tabelle als Parameter. Sie ist grundsätzlich so aufgebaut wie die Prozedur TabellenAbgleichen<\/b>, nur dass sie diesmal nicht die Tabellen der beiden Datenbanken, sondern die Felder der beiden Tabellen untersucht.<\/p>\n Listing 4: Die Funktion FelderAbgleichen<\/span><\/b><\/p>\n Daher verwenden wir wieder zwei Recordsets, welche die Verbindungszeichenfolgen aus den Konstanten nutzen. Als Datenquelle verwenden wir diesmal wieder keine klassische SELECT<\/b>-Abfrage, sondern die Anweisung DESCRIBE <\/b>mit den Namen der zu beschreibenden Tabelle. Dies liefert die Namen der Felder der angegebenen Tabelle zurück – neben einigen anderen Feldern. Uns interessiert aber nur der Feldname, den wir im Feld Field <\/b>finden.<\/p>\n Deshalb sortieren wir die Datensätze beider Recordsets zuerst aufsteigend nach dem Inhalt des Feldes Field<\/b>. Dann durchlaufen wir in einer Do While<\/b>-Schleife die Datensätze des Recordsets rstAlt<\/b>. Solange der Datensatzzeiger für rstNeu <\/b>nun nicht auf EOF <\/b>steht, was bedeutet, dass wir zwar noch nicht alle Datensätze von rstAlt<\/b>, aber schon alle Datensätze von rstNeu <\/b>durchlaufen haben – und dementsprechend im Else<\/b>-Teil die erste Do While<\/b>-Schleife verlassen -, bleiben wir in dieser Schleife. Zu Beginn dürfte der Datensatzzeiger von rstNeu <\/b>allerdings noch am Anfang stehen, weshalb wir erst den If<\/b>-Teil der Bedingung durchlaufen. Die untergeordnete If…Then<\/b>-Bedingung ähnelt der aus der Prozedur TabellenAbgleichen<\/b>.<\/p>\n Sie prüft, ob ein Feld in beiden Tabellen oder nur in einer der beiden Tabellen vorhanden ist und liefert entsprechende Ausgaben im Direktbereich und schiebt den Datensatzzeiger des jeweils betroffenen Recordsets weiter. Im If<\/b>-Teil haben wir eine Anweisung eingebaut, die der Variablen strFelder <\/b>ein Komma und den Namen des in beiden Tabellen vorkommenden Feldes hinzufügt.<\/p>\n Dadurch erhalten wir so Schritt für Schritt eine komma-separierte Liste der Feldnamen. In der zweiten Do While<\/b>-Schleife durchlaufen wir schließlich noch alle Datensätze von rstNeu<\/b>, die nach dem vollständigen Durchlaufen von rstAlt <\/b>noch übrig sind.<\/p>\n Danach prüfen wir, ob mindestens ein Feldname in strFelder<\/b> vorhanden ist – etwa so:<\/p>\n Dann schneiden wir das führende Komma ab, damit der Inhalt von strFelder <\/b>etwa wie folgt aussieht:<\/p>\n Den Inhalt von strFelder <\/b>fügen wir dann in den Rückgabewert der Funktion FelderAbgleichen<\/b>.<\/p>\n Dort verwenden wir den Wert zweier weiterer Konstanten namens cStrNeueDatenbank <\/b>und cStrAlteDatenbank<\/b>, die wir wie folgt deklarieren:<\/p>\n Das Ergebnis sieht dann etwa wie folgt aus:<\/p>\n Die Prozedur TabellenAbgleichen <\/b>stellt durch einen Aufruf der Funktion FelderAbgleichen <\/b>für jede Tabelle, die in der alten und der neuen Version der Datenbank auftaucht, eine INSERT INTO<\/b>-Abfrage zusammen. Diese werden dann mithilfe der Prozedur InZwischenablage<\/b> aus dem Modul mdlZwischenablage <\/b>in die Zwischenablage kopiert, damit Sie diese weiterverwenden können.<\/p>\n SQL-Anweisungen einsetzen<\/b><\/p>\n Im Falle meines Shops steht die phpMyAdmin<\/b>-Benutzeroberfläche für den Zugriff auf die Datenbank des Internetservers zur Verfügung.<\/p>\n Hier können wir eine Datenbank auswählen und unter SQL den Inhalt der Zwischenablage einfügen (siehe Bild 2).<\/p>\n Bild 2: Ausführen von SQL-Anweisungen auf dem Webserver<\/span><\/b><\/p>\n Reihenfolge beachten<\/b><\/p>\n In unserem Fall treten Fehler auf, weil zwischen den Tabellen Beziehungen definiert sind und wir versucht haben, Datensätze einer Tabelle zu löschen, mit denen noch Datensätze anderer Tabellen verknüpft sind:<\/p>\n Wir müssen also noch die Reihenfolge beim Löschen und auch beim Kopieren der Datensätze berücksichtigen. Wie bekommen wir das möglichst automatisiert hin<\/p>\n Den größten Teil der Aufgabe haben wir bereits einmal erledigt, und zwar im Beitrag Lösch- und Kopierreihenfolge für Tabellen <\/b>(www.access-im-unternehmen.de\/926<\/b>). Allerdings haben wir hier auf die Tabellen einer Access-Datenbank zugegriffen, und zwar über die Auflistung TableDefs<\/b>. Und wir konnten dort per DAO auf die Verknüpfungseigenschaften der Tabellen zugreifen, was wir auch bei per ODBC verknüpften Tabellen nicht erledigen können.<\/p>\n Wie Sie die Reihenfolge von Tabellen zum Kopieren oder Löschen in einer MySQL-Datenbank ermitteln, erläutern wir im Beitrag Lösch- und Kopierreihenfolge in MySQL <\/b>(www.access-im-unternehmen.de\/1207<\/b>). Hier haben wir zwei Funktionen programmiert:<\/p>\n Bisher hat unsere Prozedur TabellenAbgleichen <\/b>das Ergebnis in Form der DELETE<\/b>– und INSERT<\/b>-Anweisungen in die Zwischenablage geschrieben. Wenn wir nun die von den beiden oben genannten Funktionen gelieferten Collection<\/b>-Objekte mit den Tabellen in der richtigen Reihenfolge nutzen wollen, haben wir zwei Möglichkeiten:<\/p>\nConst cStrVerbindungszeichenfolgeAlt As String<\/span> = \"DRIVER={MySQL ODBC 5.3 ANSI Driver};SERVER=xxx.xxx.xxx.xxx;DATABASE=<Datenbankname>;UID=<Benutzername>;PWD=<Kennwort>\"\r\nConst cStrVerbindungszeichenfolgeNeu As String<\/span> = \"DRIVER={MySQL ODBC 5.3 ANSI Driver};SERVER=xxx.xxx.xxx.xxx;DATABASE=<Datenbankname>;UID=<Benutzername>;PWD=<Kennwort>\"<\/pre>\nPublic Function <\/span>GetConnection(strConnection As String<\/span>) As <\/span>ADODB.Connection\r\n Dim <\/span>objConnection As <\/span>ADODB.Connection\r\n Set<\/span> objConnection = New<\/span> ADODB.Connection\r\n objConnection.Open strConnection\r\n Set<\/span> GetConnection = objConnection\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>GetRecordset(objConnection As <\/span>ADODB.Connection, strSQL As String<\/span>) _\r\n As <\/span>ADODB.Recordset\r\n Dim <\/span>rst As <\/span>ADODB.Recordset\r\n Set<\/span> rst = New<\/span> ADODB.Recordset\r\n With<\/span> rst\r\n .ActiveConnection = objConnection\r\n .CursorLocation = adUseClient\r\n .CursorType = adOpenDynamic\r\n .LockType = adLockBatchOptimistic\r\n .Source = strSQL\r\n .Open , , , , adCmdText\r\n Set<\/span> GetRecordset = rst\r\n End With<\/span>\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>TabellenAbgleichen()\r\n Dim <\/span>rstAlt As <\/span>ADODB.Recordset\r\n Dim <\/span>rstNeu As <\/span>ADODB.Recordset\r\n Dim <\/span>strKriterium As String<\/span>\r\n Dim <\/span>fld As <\/span>ADODB.Field\r\n Set<\/span> rstAlt = GetRecordset(GetConnection(cStrVerbindungszeichenfolgeAlt), \"SHOW TABLES\")\r\n Set<\/span> rstNeu = GetRecordset(GetConnection(cStrVerbindungszeichenfolgeNeu), \"SHOW TABLES\")\r\n rstAlt.Sort = rstAlt.Fields(0).Name & \" ASC\"\r\n rstNeu.Sort = rstNeu.Fields(0).Name & \" ASC\"\r\n Do While<\/span> Not<\/span> rstAlt.EOF\r\n If <\/span>Not<\/span> rstNeu.EOF Then<\/span>\r\n If <\/span>rstAlt.Fields(0) = rstNeu.Fields(0) Then<\/span>\r\n Debug.Print<\/span> rstAlt.Fields(0), rstNeu.Fields(0)\r\n rstAlt.MoveNext<\/span>\r\n rstNeu.MoveNext<\/span>\r\n Else<\/span>If rstAlt.Fields(0) > rstNeu.Fields(0) Then\r\n Debug.Print<\/span> \"----\", rstNeu.Fields(0)\r\n rstNeu.MoveNext<\/span>\r\n Else<\/span>If rstAlt.Fields(0) < rstNeu.Fields(0) Then\r\n Debug.Print<\/span> rstAlt.Fields(0), \"----\"\r\n rstAlt.MoveNext<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n Debug.Print<\/span> rstAlt.Fields(0), \"----\"\r\n rstAlt.MoveNext<\/span>\r\n End If<\/span>\r\n Loop<\/span>\r\n Do While<\/span> Not<\/span> rstNeu.EOF\r\n Debug.Print<\/span> \"----\", rstNeu.Fields(0)\r\n rstNeu.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\ntblA tblA\r\ntblB tblB<\/pre>\n
---- tblA\r\ntblB tblB<\/pre>\n
tblA tblA\r\ntblB ----<\/pre>\n
\n
...\r\n---- tblY\r\n---- tblZ<\/pre>\n
tblA tblA\r\ntblB tblB\r\n---- tblC\r\ntblD ----\r\n...\r\ntblY tblY\r\ntblZ tblZ<\/pre>\n
\n
INSERT INTO <Neue Datenbank>.<Tabellenname> SELECT * FROM <Alte Datenbank>.<Tabellenname><\/pre>\n
Public Sub <\/span>TabellenAbgleichen()\r\n ...\r\n Dim <\/span>strSQLDelete As String<\/span>\r\n Dim <\/span>strSQLInsert As String<\/span>\r\n ...\r\n Do While<\/span> Not<\/span> rstAlt.EOF\r\n If <\/span>Not<\/span> rstNeu.EOF Then<\/span>\r\n If <\/span>rstAlt.Fields(0) = rstNeu.Fields(0) Then<\/span>\r\n Debug.Print<\/span> rstAlt.Fields(0), rstNeu.Fields(0)\r\n strSQLDelete = strSQLDelete _\r\n & \"DELETE FROM \" & cStrNeueDatenbank _\r\n & \".\" & rstAlt.Fields(0) & vbCrLf<\/span>\r\n strSQLInsert = strSQLInsert _\r\n & FelderAbgleichen(rstAlt.Fields(0)) _\r\n & vbCrLf<\/span>\r\n ...<\/pre>\nPublic Function <\/span>FelderAbgleichen(strTabelle As String<\/span>) As String<\/span>\r\n Dim <\/span>rstAlt As <\/span>ADODB.Recordset\r\n Dim <\/span>rstNeu As <\/span>ADODB.Recordset\r\n Dim <\/span>strKriterium As String<\/span>\r\n Dim <\/span>fld As <\/span>ADODB.Field\r\n Dim <\/span>strFelder As String<\/span>\r\n Set<\/span> rstAlt = GetRecordset(GetConnection(cStrVerbindungszeichenfolgeAlt), \"DESCRIBE \" & strTabelle)\r\n Set<\/span> rstNeu = GetRecordset(GetConnection(cStrVerbindungszeichenfolgeNeu), \"DESCRIBE \" & strTabelle)\r\n rstAlt.Sort = rstAlt.Fields(\"Field\").Name & \" ASC\"\r\n rstNeu.Sort = rstNeu.Fields(\"Field\").Name & \" ASC\"\r\n Do While<\/span> Not<\/span> rstAlt.EOF\r\n If <\/span>Not<\/span> rstNeu.EOF Then<\/span>\r\n If <\/span>rstAlt.Fields(\"Field\") = rstNeu.Fields(\"Field\") Then<\/span>\r\n Debug.Print<\/span> rstAlt.Fields(\"Field\"), rstNeu.Fields(\"Field\")\r\n strFelder = strFelder & \", \" & rstAlt.Fields(\"Field\")\r\n rstAlt.MoveNext<\/span>\r\n rstNeu.MoveNext<\/span>\r\n Else<\/span>If rstAlt.Fields(\"Field\") > rstNeu.Fields(\"Field\") Then\r\n Debug.Print<\/span> \"----\", rstNeu.Fields(\"Field\")\r\n rstNeu.MoveNext<\/span>\r\n Else<\/span>If rstAlt.Fields(\"Field\") < rstNeu.Fields(\"Field\") Then\r\n Debug.Print<\/span> rstAlt.Fields(\"Field\"), \"----\"\r\n rstAlt.MoveNext<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n Debug.Print<\/span> rstAlt.Fields(\"Field\"), \"----\"\r\n rstAlt.MoveNext<\/span>\r\n End If<\/span>\r\n Loop<\/span>\r\n Do While<\/span> Not<\/span> rstNeu.EOF\r\n Debug.Print<\/span> \"----\", rstNeu.Fields(\"Field\")\r\n rstNeu.MoveNext<\/span>\r\n Loop<\/span>\r\n If <\/span>Len<\/span>(strFelder) > 0 Then<\/span>\r\n strFelder = Mid<\/span>(strFelder, 3)\r\n End If<\/span>\r\n FelderAbgleichen = \"INSERT INTO \" & cStrNeueDatenbank & \".\" & strTabelle & \"(\" & strFelder & \") SELECT \" _\r\n & strFelder & \" FROM \" & cStrAlteDatenbank & \".\" & strTabelleEnd Function<\/pre>\n, datum, id, referer<\/pre>\n
datum, id, referer<\/pre>\n
Const cStrAlteDatenbank As String<\/span> = \"<Alte Datenbank>\"\r\nConst cStrNeueDatenbank As String<\/span> = \"<Neue Datenbank>\"<\/pre>\nINSERT INTO <Neue Datenbank>.<Tabelle>(<Feld1>, <Feld2>, ..., <FeldN>) SELECT <Feld1>, <Feld2>, ..., <FeldN> FROM <Alte Datenbank>.<Tabelle><\/pre>\n
![\"Ausführen](\"..\/fileadmin\/_temp_\/2019_05\/pic_1208_002.png\")
<\/p>\n#1451 - Kann Eltern-Zeile nicht löschen oder aktualisieren: eine Fremdschlüsselbedingung schlägt fehl ('amvshop_sw54'.'s_user_addresses', CONSTRAINT 's_user_addresses_ibfk_1' FOREIGN KEY ('country_id') REFERENCES 's_core_countries' ('id') ON UPDATE CASCADE)<\/pre>\n\n
\n