<\/p>\n
André Minhorst, Duisburg<\/b><\/p>\n
MySQL ist ein Open Source-SQL-Server, der wegen seiner Geschwindigkeit und seiner guten Sicherheitseigenschaften oft für Internetanwendungen im Einsatz ist. Da sehr viele Internetprovider MySQL in mittleren bis großen Hosting-Paketen als Datenbankserver anbieten, besitzt es eine Sonderstellung unter den freien SQL-Servern. Das ist ein Grund mehr, die Verwendung von Access als Frontend von Datenbanken unter MySQL unter die Lupe zu nehmen – sowohl mit lokalem MySQL als auch auf dem Internetserver.<\/b><\/p>\n
Access und MySQL sind grundverschieden. Während sich Access eher für Einzelplatzanwendungen und für Datenbankanwendungen in Mehrbenutzerumgebungen mit begrenzter Datenmenge und Benutzeranzahl eignet, ist MySQL für den Einsatz in Internetanwendungen und anderen Anwendungen in Mehrbenutzerumgebungen vorgesehen. Dieser Vergleich deutet auch den zweiten großen Unterschied an: Access ist ein All-In-One-Paket mit eigener Benutzeroberfläche, während MySQL – für Internetanwendungen genau ausreichend – als reiner Datenbankserver daherkommt.<\/p>\n
Kombinieren Sie beide miteinander, erhalten Sie eine Datenbankanwendung mit einem sicheren und performanten Backend und einer je nach Anforderung gestalteten Benutzeroberfläche. Die Verbindung stellen Sie einfach her, indem Sie die Access-Benutzeroberfläche via ODBC mit der MySQL-Datenbank verknüpften. Wie sich später zeigen wird, sind die beiden aber nicht in allen Aspekten wie füreinander geschaffen – der Export eines bestehenden Datenmodells nach MySQL ist unter Umständen mühselig, weil keine Informationen über Indexfelder oder Beziehungen übernommen werden oder die Datentypen nicht kompatibel sind, die lasche Handhabung von Tabellen- und Feldnamen unter Access kann beim Export zu Schwierigkeiten führen, weil MySQL dort wesentlich restriktiver ist und beispielsweise keine Sonderzeichen wie Minus- oder Leerzeichen erlaubt.<\/p>\n
Wesentlich interessanter ist aber ohnehin der Anwendungsfall, dass eine MySQL-Datenbank als Datenquelle für eine Internetanwendung oder ähnliches dient. Aufgrund der gegenüber Windows-Anwendungen wesentlich aufwändiger zu entwickelnden Internet-Anwendungen sind Administrationstools meist Mangelware oder nur rudimentär vorhanden, eventuell notwendige änderungen werden dann unter Umständen per Kommandozeile durchgeführt. Was liegt da näher, als schnell eine Access-Anwendung mit den gewünschten Tabellen zu verknüpfen und die benötigten Formulare zum Bearbeiten und Berichte zur Ausgabe der Daten zu erstellen Die gleiche Aufgabe per Web-Interface zu lösen, dürfte ein Vielfaches an Arbeit bedeuten.<\/p>\n
Hier stellt sich die Frage, wie Sie eine sichere Verbindung zwischen dem lokalen Access-Frontend und dem beispielsweise auf einem Internetserver befindlichen MySQL-Backend herstellen.<\/p>\n
Die Antwort finden Sie gegen Ende dieses Beitrags und vorher erfahren Sie, wie Sie MySQL und MyODBC installieren, wie Sie MySQL zum Laufen bringen, was dabei zu beachten ist und wie Sie eine lokale Verbindung zwischen einer Access- und einer MySQL-Datenbank herstellen. Bleibt das Thema Upsizing: Aufgrund der vielen Fallstricke lässt es sich kaum in diesem Rahmen abhaken, aber wir bringen Sie zumindest auf den richtigen Weg.<\/p>\n
Für den Betrieb von MySQL als Backend für Access ist neben MySQL selbst ein entsprechender ODBC-Treiber erforderlich.<\/p>\n
Die Installationsdateien von MySQL finden Sie unter folgender Adresse im Bereich Download: http:\/\/www.mysql.org<\/p>\n
Die im Rahmen der nachfolgenden Beispiele verwendete Version lautet 4.0.21. <\/p>\n
Der Start der Installation erfolgt über den Aufruf der Datei Setup.exe. Die in den einzelnen Installationsschritten angebotenen Optionen können Sie problemlos übernehmen. Nach der Installation zeigt sich das System äußerlich unverändert, MySQL legt keine Einträge im Startmenü oder auf dem Desktop an. Das ist auch kein Wunder, denn es handelt sich bei MySQL um ein reines Datenbank-Backend, das meist als SQL-Server für Internetanwendungen dient.<\/p>\n
Der ODBC-Treiber für MySQL heißt treffenderweise MyODBC. Sie finden ihn unter der gleichen Internetadresse wie MySQL im Bereich Download unter Connectors. Der Beitrag basiert auf der Version 3.51.9 des ODBC-Treibers für MySQL. Die Setup-Routine kopiert lediglich vier Dateien auf den Zielrechner und registriert eine von ihnen als .dll-Datei.<\/p>\n
Die Installationsroutine hat alle Dateien in ein Verzeichnis namens c:\\mysql installiert (soweit Sie kein anderes Verzeichnis angegeben haben). Im Unterverzeichnis bin befinden sich alle wichtigen ausführbaren Dateien von MySQL, darunter auch ein grafisches Administrationstool – dazu später mehr. Im Rahmen der vorgesehenen Anwendung sollten Sie außerdem wissen, dass das Unterverzeichnis data alle MySQL-Datenbanken enthält.<\/p>\n
Für Informationen über MySQL, die über die in diesem Beitrag enthaltenen hinausgehen, bietet sich die Lektüre des im Verzeichnis Docs enthaltenen Benutzerhandbuchs von MySQL an.<\/p>\n
Unter Linux-Anwendern gang und gäbe ist die Verwendung der Kommandozeile für alle möglichen Aufgaben, unter anderem auch für die Administration von MySQL. Als verwöhnter Access-Anwender fiele eine Umstellung vermutlich schwer, aber wie bei vielen anderen Anwendungen bieten Kommandozeile und Konfigurationsdateien eine Menge mehr Kontrolle und übersicht als die unter Windows teilweise tief verschachtelten Dialoge – ganz davon abgesehen, dass deren Aufbau sich gerne mal mit Veröffentlichung einer neuen Windows- oder Office-Version ändert. Dennoch erfolgen die ersten Schritte mit MySQL mit der Kommandozeile. Dort wechseln Sie zunächst in das bin-Verzeichnis:<\/p>\n
cd \\mysql\\bin<\/pre>\nStarten Sie dann MySQL mit der gleichnamigen Anweisung:<\/p>\n
mysql<\/pre>\nNormalerweise ist MySQL noch nicht gestartet, was in folgender Meldung resultiert:<\/p>\n
ERROR 2003: Can''t connect to MySQL server on ''localhost'' (10061)<\/pre>\nMySQL als Systemdienst<\/h3>\n
Wenn Sie MySQL als Systemdienst installieren, können Sie es wie andere Systemdienste starten, stoppen und festlegen, ob es beim Systemstart automatisch mitgestartet werden soll. Die Installation als Systemdienst erfolgt über folgende Anweisung aus dem bin-Verzeichnis des MySQL-Ordners heraus:<\/p>\n
mysqld-nt -install<\/pre>\n
<\/p>\n
<\/b><\/p>\n
Bild 1: MySQL als Systemdienst<\/span><\/b><\/p>\n
Anschließend können Sie den MySQL-Server entweder über den Dienst-Dialog (siehe Bild 1) oder per Kommandozeile starten und stoppen.<\/p>\n
NET START mysql\r\nNET STOP mysql<\/pre>\nMySQL-Anweisungen<\/h2>\n
Sobald MySQL läuft, können Sie das Kommandozeilentool mysql in der Eingabeaufforderung starten.<\/p>\n
Sie melden sich dann automatisch als Benutzer mit dem Benutzernamen ODBC an und haben dann – im frisch installierten Zustand – lediglich Zugriff auf die Datenbank test. Wenn Sie sich im Kontext eines anderen Benutzers anmelden möchten, verwenden Sie beispielsweise folgenden Aufruf:<\/p>\n
mysql -user root<\/pre>\nMySQL begrüßt Sie wie in Bild 2 und bietet seine eigene Eingabeaufforderung mysql> an.<\/p>\n
Praxis-Tipp<\/h3>\n
Mit der Anweisung status erfahren Sie unter anderem, unter welchem Benutzernamen die aktuelle Session läuft. <\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 2: Anmelden an MySQL und Anzeigen der vorhandenen Datenbanken<\/span><\/b><\/p>\n
Als Benutzer root können Sie direkt einmal einen Blick auf die vorhandenen Datenbanken werfen. Die folgende Anweisung bewirkt die Ausgabe einer Liste wie in Bild 2.<\/p>\n
show databases;<\/pre>\nUm die Tabellen einer der Datenbanken anzuzeigen, wechseln Sie zunächst zu dieser:<\/p>\n
use mysql<\/pre>\nAnschließend zeigen Sie mit folgender Anweisung eine Liste der Tabellen dieser Datenbank an (siehe Bild 3):<\/p>\n
show tables;<\/pre>\n
<\/p>\n
<\/b><\/p>\n
Bild 3: Anzeige der Tabellen einer Datenbank<\/span><\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 4: Der Windows-MySQL-Administrator<\/span><\/b><\/p>\n
An dieser Stelle können Sie mit dem Kommandozeilentool MySQL alles mit einer Datenbank machen, was Sie unter Access mit der Benutzeroberfläche erledigen würden: Datenbanken erstellen, Tabellen erstellen und löschen, den Entwurf der Tabellen bearbeiten und mit entsprechenden Auswahl- und Aktionsabfragen Daten ausgeben und bearbeiten.<\/p>\n
Die dazu erforderlichen Anweisungen entsprechen weitgehend denen, die Sie auch unter Access verwenden, daher gehen wir an dieser Stelle nicht weiter darauf ein. Zu beachten ist eigentlich nur, dass Sie die Anweisungen in mehreren Zeilen eingeben können und MySQL diese erst beim Auftauchen eines Semikolons abarbeitet.<\/p>\n
Nur einige Anweisungen, die entweder gar keine oder nur wenige Parameter erwarten, werden direkt ausgeführt – wie beispielsweise die Anweisung exit, mit der Sie eine Session beenden.<\/p>\n
Sicherheit<\/h2>\n
Sicherheit wird unter MySQL groß geschrieben. Da MySQL im Gegensatz zu Microsoft Access auch hauptsächlich für den Mehrbenutzerbetrieb und für den Einsatz im Internet gedacht ist, ist das nicht weiter verwunderlich.<\/p>\n
An dieser Stelle erfahren Sie nun, wie Sie Benutzer auf eine Datenbank zugreifen lassen oder auch nicht; für weitere Informationen verweisen wir auf die Dokumentation von MySQL.<\/p>\n
Hinweis<\/h3>\n
Eine detaillierte Dokumentation von MySQL finden Sie unter http:\/\/dev.mysql.com\/doc\/mysql\/de\/index.html (in einer Zeile). <\/p>\n
Um das öffnen von Datenbanken unter dem Benutzernamen root und ohne Kennwort zu verhindern, setzen Sie ein solches. Dazu verwenden Sie die Anwendung mysqladmin (ohne Zeilenumbruch).<\/p>\n
mysqladmin -u root -h localhost password <Kennwort><\/pre>\nBei einer Anmeldung unter dem Benutzernamen root fragt MySQL nun das Kennwort ab.<\/p>\n
Das Administrations-Tool<\/h2>\n
Unter dem Dateinamen WinMySQLAdmin.exe finden Sie im Verzeichnis bin das Administrationstool von MySQL. Damit können Sie beispielsweise Datenbanken, Tabellen und Tabellendetails einsehen (siehe Bild 4).<\/p>\n
Die Verwendung von Access als Frontend einer MySQL-Datenbank setzt das Vorhandensein einer entsprechenden MySQL-Datenbank voraus. Sollte diese Voraussetzung nicht gegeben sein, erfahren Sie im Abschnitt 4.1, wie Sie eine bestehende Access-Datenbank nach MySQL upsizen. Anderenfalls fahren Sie mit Abschnitt 4.2 fort, wo Sie erfahren, wie Sie ein Access-Frontend mit Tabellen einer MySQL-Datenbank verknüpfen.<\/p>\n
Upsizing von Access-Datenbanken auf MySQL<\/h2>\n
Das Upsizing einer Datenbank von Access auf MySQL kann, um direkt auf eventuelle Schwierigkeiten hinzuweisen, alles andere als trivial sein. Unter Upsizing ist in diesem Zusammenhang die Erstellung einer neuen MySQL-Datenbank zu verstehen, der alle Tabellen der für das Upsizing vorgesehenen Datenbank hinzugefügt werden, sodass die Access-Anwendung nicht mehr auf die in der Access-Datenbank gespeicherten, sondern auf die in der neuen MySQL-Datenbank gespeicherten Tabellen zugreift.<\/p>\n
Für dieses Vorhaben sind prinzipiell drei Wege denkbar:<\/p>\n
Alle betroffenen Tabellen werden per Exportieren…-Funktion in die Zieldatenbank exportiert.<\/li>\n Die Definition und die Inhalte der Tabellen werden in ein Skript exportiert, das MySQL per SQL-Dump in die gewünschte SQL-Datenbank importiert.<\/li>\n Sie verwenden ein Tool, das Ihnen die Arbeit mehr oder weniger abnimmt.<\/li>\n Aus Platzgründen können wir leider nicht alle drei Möglichkeiten vorstellen. Die erste der drei scheint aber zunächst am einfachsten zu sein; außerdem bietet sie Gelegenheit, sich ein wenig in den Sprachumfang von SQL unter MySQL einzuarbeiten. Sie beinhaltet allerdings ein wenig Handarbeit. Wenn Sie beispielsweise die Tabellen der Nordwind-Datenbank inklusive Beziehungen, Indizes und Daten exportieren möchten, sind einige Nacharbeiten notwendig.<\/li>\n Export von Tabellen nach MySQL<\/h3>\n
Für diesen Ansatz erstellen Sie zunächst eine neue Datenbank in MySQL. Dazu gehen Sie folgendermaßen vor:<\/li>\n Starten Sie die Eingabeaufforderung und wechseln Sie in das Verzeichnis c:\\mysql\\bin (soweit Sie MySQL nicht in einem anderen Verzeichnis installiert haben).<\/li>\n Melden Sie sich mit der Anweisung mysql -u root -p<Kennwort> mysql beim MySQL-Server an (Achtung: kein Leerzeichen zwischen -p und <Kennwort>) und geben Sie das Kennwort an, soweit erforderlich.<\/li>\n Erstellen Sie mit der Anweisung create database Nordwind eine neue Datenbank namens Nordwind. (<\/li>\n Lassen Sie die Eingabeaufforderung geöffnet, da Sie diese später noch benötigen.<\/li>\n Nun öffnen Sie die Nordwind-Datenbank und exportieren eine Tabelle. Dazu verwenden Sie den Eintrag Exportieren… des Kontextmenüs der zu exportierenden Tabelle im Datenbankfenster. Anschließend gehen Sie wie folgt vor:<\/li>\n Wählen Sie im Exportieren…-Dialog als Datentyp den Eintrag ODBC-Datenbank aus.<\/li>\n Geben Sie den Namen der Zieldatenbank an.<\/li>\n Wählen Sie die Datenquelle aus. (<\/li>\n Fertig! Wenn Sie nun mit der Anweisung use Nordwind die neue Datenbank namens Nordwind aktivieren, können Sie dort die folgende Anweisung eingeben, um die vorhandenen Tabellen anzuzeigen:<\/li>\n show tables;<\/pre>\nDie Tabelle ist, wie die Ausgabe zeigt, erfolgreich exportiert worden. Nun schauen Sie sich die Struktur der Tabelle an und verwenden dazu die folgende Anweisung:<\/li>\n show columns from artikel;<\/pre>\nDas Ergebnis finden Sie in Bild 5. Es ist schnell zu erkennen, dass beispielsweise keine Informationen über den Primärschlüssel mitexportiert wurden.<\/li>\n <\/p>\n
Das lässt sich auch nicht so einfach nachholen, da MySQL im Vergleich zu Access keine Sonderzeichen – und auch keine Umlaute – in Feldnamen akzeptiert.<\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 5: Aufbau einer von Access nach MySQL exportierten Tabelle<\/span><\/b><\/p>\n
Hier beginnen die Probleme des Exports, denn eine änderung des Primärindexfeldes wäre zwar realisierbar und auch die Fremdschlüsselfelder der mit dieser Tabelle verknüpften Felder müssten ohnehin noch angepasst werden, aber letzten Endes müssen Sie auch alle in Formularen, Berichten und Modulen der Access-Anwendung vorhandenen Verweise noch anpassen.<\/p>\n
Eine Möglichkeit wäre, die Tabellen unter allgemein üblichen Namen wie tblArtikel statt Artikel zu exportieren, die kritischen Feldnamen beim Feintuning durch zulässige Namen zu ersetzen, eine Verknüpfung zu den Tabellen herzustellen und eine Abfrage mit dem eigentlichen Tabellennamen (also etwa Artikel) zu erstellen, die alle Felder der verknüpften Tabelle (also tblArtikel) enthält. Da Access Tabellen und Abfragen gleichberechtigt behandelt, funktioniert diese Vorgehensweise.<\/p>\n
Diese Probleme einmal außen vor gelassen, bietet MySQL alle sprachlichen Möglichkeiten, die entsprechenden Felder in Primärindexfelder umzuwandeln.<\/p>\n
Hinweis<\/h3>\n
Wenn Sie eine bestehende Datenbank nach MySQL exportieren und die Tabellen dieser Datenbank inklusive Primärschlüsseln, Indizes, Fremdschlüsselfeldern und so weiter so anpassen wollen, dass Sie die Access-Anwendung so mit dem neuen, in MySQL vorhandenen Backend verknüpfen können, ist eine Menge Feintuning erforderlich. Eine komplette Beschreibung dieser Schritte wäre zu umfangreich für diesen Beitrag, sodass wir Sie auf die deutsche Dokumentation der entsprechenden Anweisungen unter folgendem Link verweisen möchten: http:\/\/dev.mysql.com\/doc\/mysql\/de\/Reference.html <\/p>\n
Verwenden von MySQL-Datenbanken mit Access<\/h2>\n
Die Erstellung einer Datenbank unter Access und der anschließende Export nach MySQL zeugt in den meisten Fällen davon, dass dies nicht geplant war. Der Weg, zunächst eine MySQL-Datenbank etwa für eine Internetanwendung zu erstellen und anschließend Access als komfortables Frontend zu verwenden, ist wesentlich sinnvoller.<\/p>\n
Aber auch hierbei sind einige Punkte zu beachten:<\/p>\n
Legen Sie für jede Tabelle ein Primärschlüsselfeld fest, da sonst das Anlegen von Datensätzen in einer verknüpften Tabelle über Access nicht möglich ist.<\/li>\n Verwenden Sie auf keinen Fall BIGINT-Felder, da diese 64Bit enthalten, die Access nicht komplett auswerten kann.<\/li>\n Die Herstellung einer Verbindung zwischen Access und einer MySQL-Datenbank erfordert eine ODBC-Verbindung, die Sie mit MyODBC realisieren. Die nachfolgenden Beispiele gehen davon aus, dass Sie den MySQL-Server auf dem lokalen oder einem per Netzwerk verfügbaren Rechner installiert und zum Laufen gebracht haben und dass dort die zu verknüpfende Datenbank bereits vorhanden ist.<\/p>\n
Mit den folgenden Schritten erstellen Sie eine Verknüpfung zu einer Tabelle einer MySQL-Datenbank:<\/p>\n
Wählen Sie den Menüeintrag Datei\/Externe Daten\/Tabellen verknüpfen.<\/li>\n Stellen Sie im Dialog Verknüpfen den Datentyp auf ODBC-Datenbanken () ein.<\/li>\n Im nun erscheinenden Dialog Datenquelle auswählen wechseln Sie zum Registerblatt Computerdatenquelle und betätigen die Schaltfläche Neu (siehe Bild 6).<\/li>\n Im Assistenten Neue Datenquelle erstellen behalten Sie im ersten Schritt die Option Benutzerdatenquelle (nur für diesen Computer) bei.<\/li>\n Wählen Sie als Treiber den MySQL ODBC 3.51 Driver aus (Installation siehe oben).<\/li>\n
<\/p>\n
<\/b><\/p>\n
Bild 6: Erstellen einer neuen Datenquelle<\/span><\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 7: Eingabe der Verbindungsparameter<\/span><\/b><\/p>\n
Klicken Sie im nächsten Schritt auf Fertigstellen.<\/li>\n Geben Sie in der DSN-Konfiguration die Informationen etwa wie in Bild 7 ein. Zeigen Sie über die Schaltfläche Options >> die erweiterten Optionen an und überprüfen Sie, ob die Option Return Matching Rows aktiviert ist.<\/li>\n Testen Sie die Verbindung und schließen Sie den Dialog mit der Schaltfläche OK.<\/li>\n Der neue Eintrag erscheint nun im Dialog Datenquelle auswählen. Wählen Sie ihn aus und klicken Sie auf OK.<\/li>\n Wählen Sie im Dialog Tabellen verknüpfen die zu verknüpfenden Tabellen aus. (<\/li>\n Die verknüpften Tabellen erscheinen nun im Datenbankfenster. Sie können – sofern ein Primärschlüssel vorhanden ist – auf diese Tabellen wie auf Access-Tabellen zugreifen.<\/p>\n
Aktualisieren von Tabellen<\/h3>\n
Wenn Sie auf dem MySQL-Server änderungen an der Struktur der verknüpften Tabellen vornehmen – etwa durch Hinzufügen eines Feldes – werden diese nicht automatisch in der verknüpften Instanz dieser Tabelle angezeigt. Um die Verknüpfung zu aktualisieren, verwenden Sie den dafür vorgesehenen Assistenten, den Sie über den Menüeintrag Extras ( Datenbank-Dienstprogramme ( Tabellenverknüpfungs-Manager öffnen. Wählen Sie dort die zu aktualisierenden Verknüpfungen aus und klicken Sie auf OK (siehe Bild 8).<\/p>\n
Die Erstellung von Webfrontends ist immer noch wesentlich mühevoller als die Erstellung einer entsprechenden Windows-Anwendung. Dadurch sind die Funktionen zur Bearbeitung der Daten meist auf die Benutzerschnittstelle beschränkt; für die Administration der Datenbank verwendet man in der Regel ein fertiges Administrationsfrontend.<\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 8: Aktualisieren von verknüpften Tabellen<\/span><\/b><\/p>\n
Für ausgefallenere Funktionen bietet es sich an, eine Windows-basierte Anwendung zu erstellen, die über eine entsprechende ODBC-Schnittstelle auf die Datenbank auf dem Internetserver zugreift.<\/p>\n
Natürlich darf man hier den sicherheitstechnischen Aspekt nicht aus den Augen verlieren. Nachfolgend lernen Sie hier eine Möglichkeit kennen, per Secure Shell (SSH) über einen Tunnel vom Arbeitsplatz auf die Datenbank des Internetservers zuzugreifen.<\/p>\n
Hinweis<\/h3>\n
Die nachfolgende Lösung setzt voraus, dass auf dem Internetserver ein SSH-Server wie beispielsweise OpenSSH installiert ist und läuft und dass Sie über einen Benutzeraccount für den Zielrechner verfügen. <\/p>\n
SSH für die sichere Verbindung<\/h2>\n
Die verwendete Technik ist recht simpel: Mit PuTTY, einer Open Source-Software, und dem verwandten Programm Plink stellen Sie einen SSH-Tunnel zwischen dem Arbeitsplatzrechner und dem Internetserver her.<\/p>\n
Dieser Tunnel verbindet die beiden Rechner über den Port 3306 – das bedeutet, dass jede Anfrage an Port 3306 des Arbeitsplatzrechners an Port 3306 des Internetservers weitergeleitet wird.<\/p>\n
Hinweis<\/h3>\n
Die beiden Anwendungen PuTTY und Plink finden Sie im Internet unter anderem unter der folgenden Adresse: http:\/\/www.chiark.greenend.org.uk\/~sgtatham\/putty\/ <\/p>\n
Die beiden Tools können Sie direkt starten (PuTTY) beziehungsweise über die Kommandozeile bedienen (Plink). Es ist also keine Installation notwendig. Sie sollten allerdings Plink in ein Verzeichnis legen, das in der Path-Umgebungsvariablen enthalten ist oder einen entsprechenden Eintrag hinzufügen.<\/p>\n
Erstellen eines Profils mit PuTTY<\/h2>\n
PuTTY ist eigentlich ein Telnet- oder SSH-Client für den kommandozeilengesteuerten Zugriff auf andere Computer über das Netzwerk.<\/p>\n
Wir werden PuTTY hier ein wenig zweckentfremden und damit lediglich ein Profil anlegen, das Sie mit dem Kommandozeilentool Plink für die Portweiterleitung auf den Internetserver verwenden.<\/p>\n
Zum Anlegen des Profils gehen Sie folgendermaßen vor:<\/p>\n
Starten Sie PuTTY.<\/li>\n Tragen Sie unter Host Name die IP-Adresse oder die Internetadresse des Internetservers und unter Saved Sessions einen geeigneten Namen für die Session – etwa ODBCTunnel – ein (siehe Bild 9).<\/li>\n Wechseln Sie in den Bereich Connection\/SSH\/Tunnels und fügen Sie unter Port Forwarding die entsprechenden Daten ein – mit der gleichen IP wie im vorherigen Schritt (siehe Bild 10).<\/li>\n Wechseln Sie zurück in den Bereich Session und speichern Sie die Session durch einen Klick auf die Schaltfläche Save. (<\/li>\n
<\/p>\n
<\/b><\/p>\n
Bild 9: Eingabe der Server-Adresse<\/span><\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 10: Informationen für den Tunnel<\/span><\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 11: Einstellen der DSN-Eigenschaften<\/span><\/b><\/p>\n
Sie können testen, ob Sie alles richtig gemacht haben, indem Sie doppelt auf den soeben erzeugten Eintrag klicken.<\/p>\n
Es sollte eine Shell erscheinen und den Benutzernamen und das Kennwort abfragen. Wenn Sie sich hier erfolgreich einloggen können, sind die Voraussetzungen für den nachfolgend beschriebenen automatisierten Zugriff erfüllt.<\/p>\n
Testen des Tunnelns<\/h3>\n
Durch die Einstellungen im Bereich Tunnels werden bei bestehender Verbindung automatisch Daten an Port 3306 des lokalen Rechners an den entsprechenden Port des Internetrechners weitergeleitet. Um dies zu testen, benötigen Sie eine bestehende MySQL-Datenbank auf dem Zielrechner sowie eine bestehende Access-Datenbank. Als Test erstellen Sie eine Verknüpfung zu einer Tabelle der MySQL-Datenbank wie im Abschnitt 4.2 beschrieben.<\/p>\n
Nun müssen Sie nur noch die DSN konfigurieren und testen. Dazu tragen Sie in den Dialog aus Bild 11 die entsprechenden Werte ein. Wichtig ist, dass Sie für Host\/Server Name (or IP) auf jeden Fall localhost eintragen. Das ist schließlich der Sinn der Sache: Die Daten sollen erst an den lokalen Port 3306 und dann per SSH geschützt an den Internetserver geschickt werden. Für die Felder User und Password tragen Sie die Daten eines Benutzers der unter Database Name angegebenen Datenbank ein.<\/p>\n
Mit der Schaltfläche Test Data Source können Sie nun die Verbindung testen. Beachten Sie, dass das nur bei hergestelltem Tunnel funktionieren kann – Sie müssen sich also vorher per PuTTY am Internetserver angemeldet haben.<\/p>\n
Automatisiertes Erstellen des Tunnels<\/h2>\n
Wenn Sie regelmäßig mit einem lokalen Access-Frontend auf MySQL-Datenbanken auf dem Internetserver zugreifen möchten, ist es natürlich lästig, immer erst PuTTY zu starten, sich einzuloggen und dann auf die Daten zuzugreifen.<\/p>\n
Global Const SW_HIDE = 0\r\nGlobal Const SEE_MASK_NOCLOSEPROCESS = &H40\r\nType SHELLEXECUTEINFO\r\n cbSize As Long\r\n fMask As Long\r\n hwnd As Long\r\n lpVerb As String\r\n lpFile As String\r\n lpParameters As String\r\n lpDirectory As String\r\n nShow As Long\r\n hInstApp As Long\r\n lpIDList As Long\r\n lpClass As String\r\n hkeyClass As Long\r\n dwHotKey As Long\r\n hIcon As Long\r\n hProcess As Long\r\nEnd Type\r\nDeclare Function ShellExecuteEx Lib \"shell32.dll\" _ (lpExecInfo As SHELLEXECUTEINFO) As Boolean\r\nDeclare Function CloseHandle Lib \"kernel32\" _ (ByVal hObject As Long) As Long\r\nDeclare Function TerminateProcess Lib \"kernel32\" _ (ByVal hProcess As Long, ByVal uExitCode As Long) _ As Long<\/pre>\nQuellcode 1<\/b><\/p>\n
Daher entwickeln wir nun eine Routine, die automatisch eine Verbindung auf Basis der in PuTTY definierten Daten herstellt.<\/p>\n
Die Verbindung stellen Sie mit dem Kommandozeilentool Plink her. Dazu verwenden Sie etwa folgende Anweisung in der Kommandozeile (ohne Zeilenumbruch):<\/p>\n
plink -load ODBCTunnel -l <Benutzername> -pw <Kennwort><\/pre>\nDiese Anweisung müssen Sie nur noch in einer VBA-Routine unterbringen und dafür sorgen, dass diese zum gewünschten Zeitpunkt – etwa beim Start der Datenbankanwendung – aufgerufen wird. Um Sicherheitsrisiken zu vermeiden, sollten Sie ebenfalls einen Mechanismus unterbringen, der die Verbindung beim Schließen der Datenbank beendet.<\/p>\n
Praktisch wäre sicher ein komplett unsichtbarer An- und Abmeldevorgang, doch auch hier gebietet die Sicherheit das Verwenden einer Alternative: Bei voller Automatisierung müssen Sie (wenn Sie nicht mit öffentlichen und privaten Schlüsseln arbeiten) den Benutzernamen und das Kennwort für den Zugang zum Internetserver in der Datenbank speichern.<\/p>\n
Alternativ verwenden Sie ein Formular, das beim öffnen der Datenbank die Zugangsdaten abfragt und die Verbindung herstellt. Die Verwendung eines Formulars hat den zusätzlichen Vorteil, dass Sie es nach der Anmeldung unsichtbar machen und darin auch den Mechanismus zum Schließen der Verbindung unterbringen können. Dazu legen Sie einfach für die Beim Entladen-Ereigniseigenschaft eine entsprechende Prozedur an.<\/p>\n
Da das Formular nach der Anmeldung nur unsichtbar gemacht, aber nicht geschlossen wird, erfolgt das Schließen spätestens beim Schließen der Datenbankanwendung, was wiederum das Entladen des unsichtbaren Formulars und – damit verbunden – die entsprechende Ereignisprozedur auslöst.<\/p>\n
Damit erlangt man einen weiteren Vorteil: Zum Kappen der Verbindung beendet man einfach den entsprechenden Prozess. Dazu benötigen Sie die Prozess-ID, die Sie unter anderen Umständen in einer globalen Variablen speichern müssen.<\/p>\n
Bei Verwendung des Formulars können Sie diese einfach in einer lokalen Variablen des Klassenmoduls des Formulars ablegen und nachher bequem wieder abrufen.<\/p>\n
Benötigte API-Funktionen<\/h3>\n
Für das Herstellen und Beenden der Verbindung benötigen Sie drei API-Funktionen sowie die dazugehörigen Konstanten und eine Struktur (s. Quellcode 1). Speichern Sie diese einfach in einem Modul namens mdlAPI.<\/p>\n
Formular zum Herstellen und Beenden der Verbindung<\/h3>\n
Anschließend legen Sie das Formular für die Eingabe der Zugangsdaten zum Server an. Das Formular enthält folgende Steuerelemente:<\/p>\n
Textfeld txtBenutzername mit der Beschriftung Benutzername<\/li>\n Textfeld txtKennwort mit der Beschriftung Kennwort<\/li>\n Schaltfläche cmdAnmelden mit der Beschriftung Anmelden<\/li>\n Schaltfläche cmdAbbrechen mit der Beschriftung Abbrechen<\/li>\n Das Formular könnte etwa wie in Bild 12 aussehen. Damit das Kennwort durch Sternchen verborgen wird, stellen Sie die Eigenschaft Eingabeformat des Textfeldes auf den Wert Kennwort ein.<\/p>\n
<\/p>\n
<\/b><\/p>\n
Bild 12: Anmeldeformular<\/span><\/b><\/p>\n
Funktion zum Anmelden<\/h3>\n
Die Ereignisprozedur Click der Schaltfläche cmdAnmelden enthält den für das Herstellen der Verbindung benötigten Code. Sie verwendet die Struktur SHELLEXECUTEINFO, um die für den Aufruf von Plink mit den entsprechenden Parametern benötigten Informationen zusammenzustellen (s. Quellcode 2).<\/p>\n
Der eigentliche Aufruf erfolgt über die API-Funktion ShellExecuteEx, die als Parameter die genannte Struktur erwartet. Die in den Textfeldern eingegebenen Anmeldeinformationen fügt die Routine mit einigen weiteren Informationen zur Parameterliste für den Aufruf von Plink zusammen.<\/p>\n
Einer dieser Parameter heißt load und enthält den Namen der Session, die Sie weiter oben mit PuTTY gespeichert haben.<\/p>\n
Hinweis<\/h3>\n
Sie können die dort gespeicherten Informationen auch direkt in den Aufruf integrieren. Die notwendigen Parameter finden Sie in der Dokumentation. Der Grund, warum wir hier die in der Session gespeicherten Parameter verwenden, ist folgender: Wenn Sie nicht nur eine, sondern mehrere MySQL-Datenbanken auf dem Server per Access-Frontend verwalten möchten, sind die Daten für die Herstellung der Verbindung zentral gespeichert. Sollten sich einmal änderungen ergeben, müssen Sie diese nur an einer Stelle durchführen. <\/p>\n
Trennen der Verbindung<\/h3>\n
Die Verbindung soll, wie oben erwähnt, beim Schließen der Datenbankanwendung und damit beim Entladen des Formulars automatisch getrennt werden.<\/p>\n
Dazu legen Sie die Prozedur aus Quellcode 3 für die Ereigniseigenschaft Beim Entladen an. Sie liest aus der Struktur SHELLEXECUTEINFO die Nummer des Plink-Prozesses aus, beendet den Prozess und schließt das Handle.<\/p>\n
Das Meldungsfenster für den Fall, dass der Vorgang nicht erfolgreich verläuft, sollte eigentlich nur erscheinen, falls die Verbindung schon vorher unterbrochen wurde. Anderenfalls kontrollieren Sie kurz, ob sich unter den Prozessen im Taskmanager noch ein oder mehrere Prozesse namens Plink befinden, und beenden diese.<\/p>\n
Option Compare Database\r\nOption Explicit\r\nDim si As SHELLEXECUTEINFO\r\nPrivate Sub cmdAnmelden_Click()\r\n si.cbSize = Len(si)\r\n si.fMask = SEE_MASK_NOCLOSEPROCESS\r\n si.hwnd = Me.hwnd\r\n si.lpVerb = \"open\"\r\n si.lpFile = \"plink.exe\"\r\n si.lpParameters = \"-load ODBCTunnel -l \" & Me.txtBenutzername & \" -pw \" _ & Me.txtKennwort\r\n si.lpDirectory = Anwendungspfad\r\n si.nShow = SW_HIDE\r\n If ShellExecuteEx(si) = False Then\r\n MsgBox \"Die Verbindung konnte nicht hergestellt werden.\"\r\n End If\r\n Me.Visible = False\r\nEnd Sub<\/pre>\nQuellcode 2<\/b><\/p>\n
Private Sub Form_Unload(Cancel As Integer)\r\n Dim exitCode As Long\r\n If TerminateProcess(si.hProcess, exitCode) <> 0 Then\r\n CloseHandle (si.hProcess)\r\n Else\r\n MsgBox \"Die Verbindung konnte nicht getrennt werden!\"\r\n End If\r\nEnd Sub<\/pre>\nQuellcode 3<\/b><\/p>\n
Dem sicheren Zugriff auf MySQL-Datenbanken auf einem Internet-Server steht damit nichts mehr im Wege.<\/p>\n
Sie können nun, wie weiter oben beschrieben, Tabellen verknüpfen und über Abfragen, Formulare und Berichte auf die enthaltenen Daten zugreifen.<\/p>\n
In den vorangegangenen Kapiteln haben Sie gelernt, wie Sie einen MySQL-Server installieren und zum Laufen bringen, und ansatzweise erfahren, wie Sie eine bestehende Access-Datenbank in eine MySQL-Datenbank überführen.<\/p>\n
Wesentlich interessanter sind aber die Möglichkeiten, Access als Benutzerfrontend für MySQL-Datenbanken zu verwenden und sogar auf Internetservern liegende Datenbanken über eine sichere SSH-Verbindung zu administrieren.<\/p>\n
Mit dem vorgestellten Access-Formular und der dahinter stehenden Funktionalität erledigen Sie den Verbindungsaufbau per Mausklick. <\/p>\n
Natürlich konnten die Eigenschaften von MySQL nur oberflächlich beschrieben werden; das Upsizing von Access zu MySQL könnte beispielsweise Thema eines eigenen Beitrags sein.<\/p>\n","protected":false},"excerpt":{"rendered":"
MySQL ist ein Open Source-SQL-Server, der wegen seiner Geschwindigkeit und seiner guten Sicher-heitseigenschaften oft für Internetanwendungen im Einsatz ist. Da sehr viele Internetprovider MySQL in mittleren bis großen Hosting-Paketen als Datenbankserver anbieten, besitzt es eine Sonderstellung unter den freien SQL-Servern. Das ist ein Grund mehr, die Verwendung von Access als Frontend von Datenbanken unter MySQL unter die Lupe zu nehmen – sowohl mit lokalem MySQL als auch auf dem Internetserver<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662004,66062004,44000026,44000022],"tags":[],"class_list":["post-55000240","post","type-post","status-publish","format-standard","hentry","category-662004","category-66062004","category-Interaktiv","category-SQL_Server_und_Co"],"yoast_head":"\n
Access und MySQL - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Access und MySQL\" \/>\n<meta property=\"og:description\" content=\"MySQL ist ein Open Source-SQL-Server, der wegen seiner Geschwindigkeit und seiner guten Sicher-heitseigenschaften oft für Internetanwendungen im Einsatz ist. Da sehr viele Internetprovider MySQL in mittleren bis großen Hosting-Paketen als Datenbankserver anbieten, besitzt es eine Sonderstellung unter den freien SQL-Servern. Das ist ein Grund mehr, die Verwendung von Access als Frontend von Datenbanken unter MySQL unter die Lupe zu nehmen - sowohl mit lokalem MySQL als auch auf dem Internetserver\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2020-05-06T15:17:52+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg05.met.vgwort.de\/na\/26db64198606421688da07d4378eae59\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"23\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"Access und MySQL\",\"datePublished\":\"2020-05-06T15:17:52+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/\"},\"wordCount\":4385,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg05.met.vgwort.de\\\/na\\\/26db64198606421688da07d4378eae59\",\"articleSection\":[\"2004\",\"6\\\/2004\",\"Interaktiv\",\"SQL Server und Co.\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/\",\"name\":\"Access und MySQL - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg05.met.vgwort.de\\\/na\\\/26db64198606421688da07d4378eae59\",\"datePublished\":\"2020-05-06T15:17:52+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg05.met.vgwort.de\\\/na\\\/26db64198606421688da07d4378eae59\",\"contentUrl\":\"http:\\\/\\\/vg05.met.vgwort.de\\\/na\\\/26db64198606421688da07d4378eae59\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Access_und_MySQL\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Access und MySQL\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Access und MySQL - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/","og_locale":"de_DE","og_type":"article","og_title":"Access und MySQL","og_description":"MySQL ist ein Open Source-SQL-Server, der wegen seiner Geschwindigkeit und seiner guten Sicher-heitseigenschaften oft für Internetanwendungen im Einsatz ist. Da sehr viele Internetprovider MySQL in mittleren bis großen Hosting-Paketen als Datenbankserver anbieten, besitzt es eine Sonderstellung unter den freien SQL-Servern. Das ist ein Grund mehr, die Verwendung von Access als Frontend von Datenbanken unter MySQL unter die Lupe zu nehmen - sowohl mit lokalem MySQL als auch auf dem Internetserver","og_url":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/","og_site_name":"Access im Unternehmen","article_published_time":"2020-05-06T15:17:52+00:00","og_image":[{"url":"http:\/\/vg05.met.vgwort.de\/na\/26db64198606421688da07d4378eae59","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"23\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"Access und MySQL","datePublished":"2020-05-06T15:17:52+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/"},"wordCount":4385,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/#primaryimage"},"thumbnailUrl":"http:\/\/vg05.met.vgwort.de\/na\/26db64198606421688da07d4378eae59","articleSection":["2004","6\/2004","Interaktiv","SQL Server und Co."],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/","url":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/","name":"Access und MySQL - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/#primaryimage"},"thumbnailUrl":"http:\/\/vg05.met.vgwort.de\/na\/26db64198606421688da07d4378eae59","datePublished":"2020-05-06T15:17:52+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/#primaryimage","url":"http:\/\/vg05.met.vgwort.de\/na\/26db64198606421688da07d4378eae59","contentUrl":"http:\/\/vg05.met.vgwort.de\/na\/26db64198606421688da07d4378eae59"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/Access_und_MySQL\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"Access und MySQL"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000240","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55000240"}],"version-history":[{"count":0,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000240\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55000240"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55000240"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55000240"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}