Wie man Bilder in Access speichert, ist seit der Version 2010 eindeutig vorgegeben – nämlich in Anlagefeldern. Die Inhalte dieser Felder können auch leicht im Bild-Steuerelement angezeigt werden, dazu braucht man nur eine einfache Bindung an das entsprechende Feld. Allerdings bietet der SQL Server keinen solchen Datentyp, sondern nur verschiedene Alternativen. Dabei handelt es sich beispielsweise um den Datentyp varbinary(max) oder um FILESTREAM. Die erstgenannte Alternative schauen wir uns im vorliegenden Beitrag an.<\/b><\/p>\n
Beispielmaterial<\/h2>\n
Wir starten mit einer einfachen Beispieldatenbank, der wir eine Tabelle namens tblBilder <\/b>hinzugefügt haben. Diese enthält die Felder wie in Bild 1.<\/p>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_001.png\")
<\/p>\n
Bild 1: Tabelle zum Speichern von Bildern<\/span><\/b><\/p>\n Dazu haben wir unter anderem ein Anlagefeld eingefügt, dem wir nicht nur Bilder, sondern auch noch andere Dateien zuweisen können.<\/p>\n Hier können wir in der Datenblattansicht durch einen Doppelklick auf das im Anlagefeld angezeigt Büroklammer-Symbol einen Dialog namens Anlagen <\/b>öffnen, mit dem wir die enthaltenen Anlagen verwalten können (siehe Bild 2).<\/p>\n Bild 2: Einfügen eines Bildes<\/span><\/b><\/p>\n Ein so eingefügtes Bild möchten wir auch im Formular anzeigen können. Dazu erstellen wir ein neues, leeres Formular, fügen diesem unsere Tabelle als Datensatzquelle hinzu und ziehen alle gewünschten Felder in den Formularentwurf.<\/p>\n Das Anlagefeld wird hier als Steuerelement des Typs Anlage <\/b>hinzugefügt, das an das Anlagefeld der Tabelle gebunden ist.<\/p>\n Alternativ können wir auch ein Steuerelement des Typs Bild <\/b>einfügen.<\/p>\n Der Unterschied zwischen diesen beiden Steuerelementen ist im Wesentlichen, dass wir mit dem Anlagefeld auch die enthaltenen Dateien verwalten können.<\/p>\n Dazu brauchen wir nur das Steuerelement anzuklicken und sehen dann das Menü wie in Bild 3.<\/p>\n Bild 3: Ein Bild im Anlage-Steuerelement<\/span><\/b><\/p>\n Hier können wir zwischen den Bildern wechseln, wenn das Anlagefeld mehrere enthalten sollte, und mit einem Klick auf die Büroklammer den Dialog Anlagen <\/b>zum Verwalten der Anlagen aufrufen.<\/p>\n Das Bild-Steuerelement zeigt einfach nur das erste Bild im Anlagefeld an.<\/p>\n Es wäre praktisch, wenn es im SQL Server einen entsprechenden Datentyp gäbe. Den gibt es allerdings nicht in dieser Form. Das erfahren wir auf die harte Tour, wenn wir versuchen, unsere Beispieldatenbank mit dem SQL Server Migration Assistant zu migrieren.<\/p>\n Die Fehlerliste aus Bild 4 zeigt, dass der Datentyp Attachment <\/b>nicht unterstützt wird.<\/p>\n Bild 4: Meldung beim Versuch, ein Anlagefeld zum SQL Server zu migrieren<\/span><\/b><\/p>\n Es wird auch keine Alternative aufgezeigt, sondern das Feld wird einfach in eines mit dem Datentyp varchar(8000) <\/b>migriert – das entnehmen wir dem Entwurf der neu erzeugten Tabelle im SQL Server Management Studio (siehe Bild 5).<\/p>\n Bild 5: Das Anlagefeld wird in ein Feld mit dem Datentyp varchar(8000) migriert.<\/span><\/b><\/p>\n Allerdings ist die Größe von 8.000 Zeichen etwas übertrieben – tatsächlich speichert die Tabelle nach der Migration nur noch den Namen der Datei in diesem Feld (siehe Bild 6).<\/p>\n Bild 6: Das Feld Bild enthält nun nur noch den Dateinamen.<\/span><\/b><\/p>\n Das heißt, dass der Ansatz über den SQL Server Migration Assistant hier nicht brauchbar ist und wir nacharbeiten müssen.<\/p>\n Navigieren wir im SQL Server Management Studio durch die Datentypen, die uns die Entwurfsansicht für Tabellen anbietet, finden wir schnell den Eintrag image<\/b>. Ist das nicht der passende Datentyp?<\/p>\n Schauen wir uns das einmal an. Zunächst einmal betrachten wir den Weg, dort ein Bild zu speichern. Dieser ist relativ einfach umzusetzen.<\/p>\n Wir nutzen eine einfache INSERT INTO<\/b>-Anweisung, um dem image<\/b>-Feld namens Bild2 <\/b>ein Bild hinzuzufügen. Diese sieht wie folgt aus:<\/p>\n Die OPENROWSET<\/b>-Funktion liest die angegebene Datei als einzelnen Datenblock (SINGLE_BLOB<\/b>) und schreibt das Ergebnis in das Feld Bild2<\/b>. Das Ergebnis sehen wir in Bild 7.<\/p>\n Bild 7: Hinzufügen eines Bildes per INSERT INTO-Anweisung<\/span><\/b><\/p>\n Zum Hinzufügen eines Bildes zu einem bestehenden Datensatz nutzen wir folgende Syntax:<\/p>\n Damit kehren wir zur Access-Datenbank zurück. Hier finden wir, da wir weiter oben die Tabelle tblBilder <\/b>zum SQL Server migriert haben, nunmehr die Originaltabelle mit dem Namen SSMA$tblBilder$local <\/b>vor sowie die verknüpfte Tabelle namens tblBilder<\/b>.<\/p>\n Damit das Feld Bild2<\/b>, das wir soeben zur SQL Server-Tabelle tblBilder <\/b>hinzugefügt haben, auch in Access sichtbar wird, müssen wir die Verknüpfung aktualisieren. Das gelingt für eine einzelne Tabelle am einfachsten, indem wir für den Eintrag im Navigationsbereich den Kontextmenü-Befehl Link aktualisieren <\/b>aufrufen (siehe Bild 8).<\/p>\n Bild 8: Aktualisieren einer verknüpften Tabelle<\/span><\/b><\/p>\n Wenn wir uns nun die aktualisierte Tabellenverknüpfung ansehen, finden wir das Feld Bild2<\/b> mit dem Datentyp OLE-Objekt <\/b>vor (siehe Bild 9).<\/p>\n Bild 9: Das image-Feld erscheint in Access als OLE-Objekt<\/span><\/b><\/p>\n Wechseln wir nun zur Datenblattansicht, um uns den Inhalt anzusehen, finden wir lediglich den Text OLE-Objekt vor (siehe Bild 10). Hier war nicht viel mehr zu erwarten, denn Tabellen können eben nur Texte und gegebenenfalls noch ein Kontrollkästchen anzeigen.<\/p>\n Bild 10: Der Inhalt wird ebenfalls als OLE-Objekt angezeigt.<\/span><\/b><\/p>\n Wie aber sieht es im Formular aus? Hier konnten wir die über den SQL Server eingefügten Bilddateien in keinem der verfügbaren Steuerelemente sichtbar machen.<\/p>\n Neben der Tatsache, dass es keinen einfachen Weg zu geben scheint, den Inhalt unseres image<\/b>-Feldes in einem Access-Formular sichtbar zu machen, ist der image<\/b>-Datentyp auch noch als veraltet gekennzeichnet.<\/p>\n Das heißt, er wird nur noch aus Gründen der Kompatibilität beibehalten. Der Datentyp kann aber auch in einer der folgenden SQL Server-Versionen schlicht entfallen.<\/p>\n Also schauen wir uns direkt nach Alternativen um.<\/p>\n Eine weitere Möglichkeit, Bilder oder Dateien in einem Feld einer SQL Server-Datenbank zu speichern, ist der Datentyp varbinary(max)<\/b>.<\/p>\n Dieser erlaubt es ebenfalls, Bilder mit der folgenden Anweisung hineinzuschreiben:<\/p>\n Im Gegensatz zum Datentyp image <\/b>ist der Datentyp varbinary(max) <\/b>nicht veraltet.<\/p>\n Das Anzeigen von Bildern aus varbinary(max)<\/b>-Feldern ist, soviel können wir bereits vorwegnehmen, auf verschiedene Arten möglich.<\/p>\n Damit allein ist es jedoch nicht getan, denn wir müssen uns um folgende Aufgaben kümmern:<\/p>\n Der erste Punkt ist etwas komplizierter, als er aussieht. Wir können hier nicht einfach die Methoden nutzen, die das Anlegefeld uns bietet, sondern müssen direkt auf den SQL Server zugreifen. Wie das gelingt, schauen wir uns nun an. Danach schauen wir uns zwei Methoden an, um Bilder im Bild-Steuerelement anzuzeigen.<\/p>\n Wir werden in diesem Beitrag auf die Methoden der ADODB-Bibliothek zugreifen. Diese bietet für unseren Anwendungsfall deutlich einfachere Methoden als die DAO-Bibliothek.<\/p>\n Dazu öffnen wir im VBA-Editor den Verweise<\/b>-Dialog, in dem wir den Eintrag Microsoft ActiveX Data Objects 6.1 Library <\/b>auswählen (siehe Bild 11).<\/p>\n Bild 11: Verweis auf die ADODB-Bibliothek<\/span><\/b><\/p>\n In dem Zuge legen wir auch gleich noch einen Verweis auf die Bibliothek Microsoft Office 16.0 Object Library <\/b>an, den wir später für die Verwendung von Dateidialogen benötigen.<\/p>\n In den folgenden Abschnitten schauen wir uns zwei Varianten an, um ein Bild aus einem varbinary(max)<\/b>-Feld einer SQL Server-Tabelle in einem Bild-Steuerelement anzuzeigen.<\/p>\n Die erste speichert das Bild im Dateisystem und referenziert dieses dann mit dem Bild-Steuerelement.<\/p>\n Die zweite liest das Bild aus dem varbinary(max)<\/b>-Feld ein und weist es direkt dem Bild-Steuerelement zu.<\/p>\n Wir beginnen mit der Variante, mit der wir das Bild zunächst in der aktuellen Datenbank speichern. Dazu legen wir erst einmal das Formular frmBildVarBinary_Temp <\/b>an. Diesem weisen wir die per ODBC verknüpfte Tabelle tblBilder <\/b>als Datensatzquelle zu.<\/p>\n Wir fügen die beiden Felder BildID <\/b>und Bezeichnung <\/b>aus dieser Tabelle ein und legen zusätzlich eine Schaltfläche und ein Bild-Steuerelement an (siehe Bild 12).<\/p>\n Bild 12: Entwurf des Formulars zur Anzeige von Dateien aus dem varbinary(max)-Feld<\/span><\/b><\/p>\n Für das Bild<\/b>-Steuerelement stellen wir die Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>jeweils auf Beide <\/b>ein. So wird das Steuerelement vergrößert, wenn wir das Formular vergrößern.<\/p>\n Zum Hinzufügen eines Bildes programmieren wir die Schaltfläche cmdBildAuswaehlen<\/b> wie in Listing 1.<\/p>\n Listing 1: Start der Auswahl und der Anzeige einer Bilddatei<\/span><\/b><\/p>\n Diese Prozedur ruft zunächst die Funktion ChooseAttachment <\/b>auf, die wie in Listing 2 aussieht und einen Dateidialog zur Auswahl der gewünschten Bilddatei öffnet.<\/p>\n Listing 2: Prozedur zum Auswählen einer Bilddatei<\/span><\/b><\/p>\n Das Ergebnis speichert die Prozedur cmdBildAuswaehlen <\/b>in der Variablen strPfad<\/b>. Dann prüft sie als Erstes, ob strPfad <\/b>überhaupt eine Datei enthält. Dazu nutzen wir die Dir<\/b>-Funktion und untersuchen damit strPfad<\/b>.<\/p>\n Dir <\/b>liefert in diesem Fall den Namen der Datei aus dem Pfad zurück und wenn dieser eine Länge größer als 0 <\/b>hat, ist die Datei vorhanden.<\/p>\n Dann prüft die Prozedur, ob BildID <\/b>den Wert Null <\/b>hat. Das ist nur der Fall, wenn es sich um einen neuen, leeren Datensatz handelt.<\/p>\n In diesem Fall ermitteln wir den Namen der Bilddatei, tragen diesen in das Feld Bezeichnung <\/b>ein und speichern den Datensatz, indem wir die Eigenschaft Dirty <\/b>auf den Wert False <\/b>einstellen.<\/p>\n Wir erreichen damit, dass nun bereits ein Datensatz vorliegt und dass wir dessen Wert aus dem Feld BildID <\/b>auslesen können.<\/p>\n Dies nutzen wir nun aus, wenn wir die Prozedur SpeichereBildInDatenbank <\/b>aufrufen. Diese erwartet zwei Parameter und wird weiter unten beschreiben:<\/p>\n Danach liegt uns ein Datensatz vor, der ein Bild im Feld Bild<\/b> enthält. Damit können wir schließlich die Prozedur BildInBildSteuerelement <\/b>aufrufen, dem wir lediglich den Primärschlüsselwert des betroffenen Datensatzes übergeben. Diese sorgt dafür, dass das Bild auf der Festplatte gespeichert und im Bild-Steuerelement angezeigt wird.<\/p>\n Damit erhalten wir ein Ergebnis wie in Bild 13. Für diese Darstellung haben wir die Eigenschaft Größenanpassung <\/b>übrigens auf Zoomen <\/b>eingestellt.<\/p>\n Bild 13: Formular mit Bild aus dem SQL Server im Bild-Steuerelement<\/span><\/b><\/p>\n Das Speichern des Bildes in der Datenbank übernimmt die Prozedur SpeichereBildInDatenbank<\/b> (siehe Listing 3). Diese Prozedur verwendet Elemente der ADODB-Bibliothek, um auf die SQL Server-Datenbank zuzugreifen. Voraussetzung hierfür ist, dass eine geeignete Verbindungszeichenfolge vorhanden ist. Da wir diese noch an weiteren Stellen benötigen, speichern wir sie in einer Konstanten namens cStrConnection<\/b>, und zwar im Standardmodul mdlTools<\/b>:<\/p>\n Listing 3: Prozedur zum Speichern eines Bildes in der SQL Server-Tabelle<\/span><\/b><\/p>\n Hier sind unser Server und unsere Datenbank namens Bilder angegeben, diese Daten müssen noch durch Ihre Daten ersetzt werden.<\/p>\n Wie deklarieren in der Prozedur ein Connection<\/b>– und ein Command<\/b>-Objekt sowie ein Stream<\/b>-Objekt aus der ADODB<\/b>-Bibliothek.<\/p>\n Außerdem benötigen wir ein Byte-Array und eine String-Variable zum Speichern der SQL-Anweisung, mit der wir das Bild speichern.<\/p>\n Die Prozedur erstellt ein neues Connection<\/b>-Objekt und referenziert es mit der Variablen cnn<\/b>. Es öffnet eine Verbindung auf Basis der Verbindungszeichenfolge aus cStrConnection<\/b>.<\/p>\n Dann erstellt sie für die Variable objStream <\/b>ein neues Stream<\/b>-Objekt und stellt den Typ auf adTypeBinary <\/b>ein. Dann öffnet sie die Verbindung mit der Open<\/b>-Methode und verwendet die LoadFromFile<\/b>-Methode, um die mit strDateiPfad <\/b>angegebene Bilddatei einzulesen.<\/p>\n Das Ergebnis der Read<\/b>-Funktion landet schließlich im Byte<\/b>-Array bytBild<\/b>, sodass die Verbindung wieder geschlossen und das Stream-Objekt geleert werden kann.<\/p>\n Dann stellt die Prozedur die SQL-Anweisung zum Speichern der Bilddatei in der Variablen strSQL <\/b>zusammen. Dabei verwenden wir zwei Fragezeichen als Platzhalter für das zu füllende Feld BildVarBinary <\/b>und für die Bedingung BildID<\/b>.<\/p>\n Nun wird das Command<\/b>-Objekt in der Variablen cmd <\/b>erstellt. Als Verbindung weisen wir die Variable cnn <\/b>zu. Den CommandText <\/b>beziehen wir aus der zuvor gefüllten Variablen strSQL<\/b>. Den CommandType <\/b>legen wir auf acCmdText <\/b>fest.<\/p>\n Schließlich hinterlegen wir zwei Parameter namens BildDaten <\/b>und BildID<\/b>. Der ersten Append<\/b>-Anweisung der Parameters<\/b>-Auflistung des Command<\/b>-Objekts übergeben wir das Ergebnis der CreateParameter<\/b>-Methode des Command<\/b>-Objekts. Diese erwartet die folgenden Einstellungen:<\/p>\n Beim ersten Parameter, mit dem wir den Inhalt für das Feld BildVarBinary <\/b>übergeben wollen, geben wir als Name BildDaten<\/b>, als Typ adVarBinary<\/b>, als Richtung adParamInput<\/b>, als Größe die Anzahl der Elemente des Byte-Arrays und als Inhalt den Wert der Variablen bytBild<\/b>.<\/p>\n Für den Vergleichsparameter für das Feld BildID <\/b>geben wir als Name BildID<\/b>, als Typ adInteger<\/b>, als Richtung ebenfalls adParamInput<\/b>, keine Größe und als Wert den mit dem Parameter lngBildID <\/b>der Prozedur übergebenen Primärschlüsselwert des Datensatzes, der das Bild erhalten soll.<\/p>\n Diese werden in dieser Reihenfolge den Fragezeichen-Platzhaltern (?<\/b>) der SQL-Anweisung in strSQL<\/b> zugewiesen.<\/p>\n Schließlich führen wir das Command<\/b>-Objekt mit der Execute<\/b>-Methode aus.<\/p>\n Zu guter Letzt schließen wir die Verbindung und leeren die Objektvariablen cmd <\/b>und cnn<\/b>.<\/p>\n Ausgehend von einer leeren Tabelle tblBilder <\/b>können wir durch das Anklicken der Schaltfläche cmdBildAuswaehlen <\/b>des Formulars frmBildVarBinary_Temp <\/b>den Dateiauswahl-Dialog öffnen, mit diesem eine Bilddatei auswählen und die Datei im varbinary(max)<\/b>-Feld speichern.<\/p>\n In der Access-Tabellenverknüpfung sieht das erst einmal recht spartanisch aus (siehe Bild 14).<\/p>\n Bild 14: Ein Bild im varbinary(max)-Feld in Access<\/span><\/b><\/p>\n Im SQL Server Management Studio wird uns immerhin ein etwas aussagekräftigerer Text geboten (siehe Bild 15). Davon abgesehen ist es aber letztlich nur eine Menge an Bytes, die wir in das Feld gespeichert haben. Ob hier tatsächlich das Bild gelandet ist und wie wir es weiterverwenden können, schauen wir uns in den nächsten Abschnitten an.<\/p>\n Bild 15: Ein Bild im varbinary(max)-Feld im SQL Server Management Studio<\/span><\/b><\/p>\n Nun wollen wir das Bild aus dem varbinary(max)<\/b>-Feld im Bild-Steuerelement anzeigen. Dazu wählen wir im ersten Anlauf den Umweg über das Dateisystem.<\/p>\n Das heißt, wir speichern die Datei aus dem Tabellenfeld im Verzeichnis der Datenbankdatei und stellen die Eigenschaft Picture <\/b>des Bild-Steuerelements auf diesen Pfad ein.<\/p>\n Dazu rufen wir die Prozedur BildInBildsteuerelement_Pfad<\/b> auf, der wir wiederum den Wert des Primärschlüsselfeldes des aktuellen Datensatzes übergeben.<\/p>\n Die Prozedur aus Listing 4 deklariert ein Recordset<\/b>– und ein Connection<\/b>-Objekt für den Zugriff auf die Datenbanktabelle, ein Byte-Array, um das Bild einzulesen, den Pfad der temporären Bilddatei, ein Stream<\/b>-Objekt und eine String<\/b>-Variable für die SQL-Abfrage.<\/p>\n Listing 4: Prozedur zum Anzeigen eines Bildes aus einem varbinary(max)-Feld über das Speichern im Dateisystem<\/span><\/b><\/p>\n Da es auch sein kann, dass wir einen neuen, leeren Datensatz vorliegen haben oder einen, für den noch kein Bild gespeichert ist, stellen wir eingangs die Eigenschaft Picture <\/b>für das Bild-Steuerelement namens pic <\/b>auf eine leere Zeichenkette ein.<\/p>\n Danach erstellen und öffnen wir die Verbindung, wieder auf Basis der Verbindungszeichenfolge aus der Konstanten cStrConnection<\/b>. Die SQL-Anweisung stellen wir diesmal direkt zusammen und ohne Verwendung von Parametern. Dazu fügen wir als Vergleichswert des Kriteriums den Primärschlüsselwert aus lngBildID <\/b>hinzu.<\/p>\n Damit ausgestattet, können wir nun ein neues Recordset erstellen und dieses mit der Open<\/b>-Anweisung und der Übergabe der SQL-Anweisung, der Verbindung und weiteren Informationen öffnen.<\/p>\n In einer If…Then<\/b>-Bedingung prüfen wir, ob das Recordset nicht leer ist. Sollte der Datensatz leer sein, was in der Regel nicht geschehen sollte, wird die Prozedur beendet und vorsichtshalber nochmals Me.pic.Picture <\/b>auf eine leere Zeichenfolge eingestellt.<\/p>\n Enthält das Recordset jedoch einen Datensatz, prüft eine weitere If…Then<\/b>-Bedingung, ob das Feld BildVarBinary<\/b> gefüllt ist. Ist das der Fall, lesen wir dieses in die Variable für das Byte-Array namens bytBild <\/b>ein.<\/p>\n Dazu brauchen wir dieser lediglich die Eigenschaft Value <\/b>dieses Feldes zuzuweisen.<\/p>\n Danach stellen wir in strTempDatei <\/b>den Pfad für die temporäre Datei für dieses Bild zusammen. Diese besteht aus dem Ordner, in dem sich auch die aktuelle Datenbank befindet, und den wir mit CurrentProject.Path <\/b>ermitteln. Außerdem fügen wir noch den Dateinamen mit \\tempbild.png <\/b>hinzu.<\/p>\n Hinweis<\/b>: Wir gehen in diesem Beitrag davon aus, dass nur Bilder mit dem Datentyp .png <\/b>gespeichert werden sollen. Für andere Datentypen muss der Code entsprechend angepasst werden.<\/p>\n Nun folgt der Auftritt des Stream<\/b>-Objekts. Dieses erstellen wir mit dem Schlüsselwort New <\/b>und weisen es der Variablen objStream <\/b>zu.<\/p>\n Dann stellen wir den Typ auf adTypeBinary <\/b>ein, öffnen es mit der Open<\/b>-Methode, schreiben mit der Write<\/b>-Methode den Inhalt der Variablen bytBild <\/b>hinein und speichern die Datei mit der SaveToFile<\/b>-Methode unter dem angegebenen Dateinamen. Dabei geben wir als zweiten Parameter die Konstante adSaveCreateOverWrite <\/b>an und sorgen so dafür, dass eine eventuell bereits vorhandene Datei gleichen Namens überschrieben wird. Danach schließen wir das Stream<\/b>-Objekt mit der Close<\/b>-Methode.<\/p>\n Der letzte Schritt besteht darin, der Picture<\/b>-Eigenschaft des Bild-Steuerelements pic<\/b> den Pfad zu der anzuzeigenden Datei zuzuweisen. Damit erhalten wir im Formular die Anzeige der gespeicherten Datei.<\/p>\n Nun wären wir nicht Access im Unternehmen, wenn wir nicht noch eine etwas elegantere Lösung für diese Aufgabe hätten. Diese besteht darin, die Bilddatei ohne Umweg über das Dateisystem direkt im Bild-Steuerelement anzuzeigen.<\/p>\n Wie das gelingt, sehen wir in der Prozedur in Listing 5. Die Prozedur benötigt eine Recordset<\/b>– und eine Connection<\/b>-Variable für den Zugriff auf die Datenbank. Außerdem benötigen wir ein Byte-Array und eine String<\/b>-Variable für die SQL-Abfrage.<\/p>\n Listing 5: Prozedur zum Anzeigen eines Bildes aus einem varbinary(max)-Feld ohne Umweg über das Dateisystem<\/span><\/b><\/p>\n In diesem Fall leeren wir das Bild-Steuerelement, indem wir seine Eigenschaft PictureData <\/b>auf den Wert Null <\/b>einstellen. Dann erstellen wir die Verbindung zur Datenbank und speichern diese in der Variablen cnn<\/b>.<\/p>\n In der Variablen strSQL <\/b>hinterlegen wir die Abfrage, um das Bild aus dem Feld BildVarBinary <\/b>auszulesen. Als Kriterium geben wir wieder den Primärschlüsselwert des Datensatzes an, für den wir das Bild anzeigen wollen.<\/p>\n Danach öffnen wir das Recordset für diesen SQL-Ausdruck. In einer ersten If…Then<\/b>-Bedingung prüfen wir, ob das Recordset nicht leer ist. Enthält dieses einen Datensatz, prüfen wir, ob das Feld BildVarBinary <\/b>den Wert Null <\/b>enthält.<\/p>\n Ist auch das nicht der Fall, können wir den Inhalt einlesen. Dazu weisen wir einfach dem Byte-Array namens bytBild <\/b>den Inhalt des Feldes BildVarBinary <\/b>zu. Den Inhalt des Byte-Arrays schreiben wir danach in die Eigenschaft PictureData<\/b>.<\/p>\n Danach erscheint das Bild, soweit eines vorhanden ist, automatisch wie im vorherigen Beispiel im Bild-Steuerelement.<\/p>\n Mit dieser zweiten Methode umgehen wir noch einige potenzielle Probleme, die durch das Speichern des Bildes im Dateisystem entstehen können. Außerdem dürfte diese Methode, auch wenn man es bei kleineren Bilddateien kaum merken dürfte, performanter sein als die mit dem Umweg über das Dateisystem.<\/p>\n Wenn man die Tabellen seiner Access-Anwendung zum SQL Server migriert, kann man die meisten Tabellen und die enthaltenen Felder mit mehr oder weniger vorbereitenden Schritten oder nachträglichen Anpassungen mit dem SQL Server Migration Assistant zum SQL Server übertragen. Bei Bildern, die beispielsweise im Anlage-Feld einer Access-Tabelle gespeichert sind, haben wir jedoch nicht nur das Problem, dass die Daten gar nicht erst migriert werden. Wir haben auch keine Möglichkeit, genau wie zuvor die Bilder direkt im Bild-Steuerelement anzuzeigen.<\/p>\n In diesem Beitrag haben wir deshalb gleich zwei Techniken vorgestellt, die in diesem Zusammenhang wichtig sind:<\/p>\n Damit ist die Arbeit jedoch noch nicht getan. Immerhin haben wir hier erst einmal nur gezeigt, wie eine Bilddatei aus dem Dateisystem in einem varbinary(max)-Feld landet.<\/p>\n Wenn wir jedoch die Daten aus einer Tabelle mit einem Anlagefeld in eine SQL Server-Tabelle übertragen wollen, sind dazu noch weitere Schritte nötig.<\/p>\n Die erste Frage ist: Können wir überhaupt aus einem Migrationsprozess, der gegebenenfalls über den SQL Server Migration Assistant gesteuert wird, eine Tabelle herausnehmen, die wir komplett selbst migrieren?<\/p>\n In der Regel wird dies nicht gut funktionieren, weil man über die Migration mit dem Migrationsassistenten bereits die Tabelle inklusive aller Beziehungen und weiterer Informationen in einem Rutsch übertragen möchte.<\/p>\n Da ist es unpraktisch, wenn man eine Tabelle herausnimmt und sich zusätzlich auch noch um das Herstellen der ganzen Beziehungen kümmern muss, die mit dieser Tabelle zusammenhängen.<\/p>\n Wir würden also eher eine Vorgehensweise vorschlagen, bei der wir die Tabelle zunächst ganz einfach mit den übrigen Tabellen per SQL Server Migration Assistant migrieren und das Anlage-Feld einfach als varchar(8000) <\/b>übertragen, wie vom SSMA vorgeschlagen.<\/p>\n Danach können wir uns um das Anlage-Feld kümmern und die Inhalte Datensatz für Datensatz übertragen.<\/p>\n Gegebenenfalls ist hier auch noch zusätzlicher Aufwand zu erwarten. Dieser tritt auf, wenn das Anlage-Feld nicht nur ein Bild je Datensatz speichert, sondern der Entwickler vorgesehen hat, dass mehrere Bilder zu jedem Datensatz hinterlegt werden können.<\/p>\n In diesem Fall würde man eine weitere Tabelle hinterlegen, in der die Anlagen zu den verschiedenen Datensätzen gespeichert werden und die über ein Fremdschlüsselfeld mit dem Hauptdatensatz verknüpft sind.<\/p>\n Die zum Migrieren eines Anlage-Feldes in ein varbinary(max)<\/b>-Feld nötigen Schritte erläutern wir im Beitrag Anlagefeld zum SQL Server migrieren <\/b>(www.access-im-unternehmen.de\/1542<\/b>) in der folgenden Ausgabe.<\/p>\n Enthaltene Beispieldateien:<\/p>\n BilderImSQLServer.accdb<\/p>\n![\"Einfügen](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_002.png\")
<\/p>\nAccess-Bilder im Formular<\/h2>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_003.png\")
<\/p>\nAnlagefeld im SQL Server?<\/h2>\n
![\"Meldung](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_004.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_005.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_006.png\")
<\/p>\nWo und wie Bilder im SQL Server speichern?<\/h2>\n
INSERT INTO tblBilder(Bild2) \r\nSELECT BulkColumn FROM OPENROWSET(BULK ''C:\\...\\pic001.png'', SINGLE_BLOB) AS Bild2<\/pre>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_007.png\")
<\/p>\nUPDATE tblBilder \r\nSET Bild2 = (\r\n SELECT bulkcolumn \r\n FROM OPENROWSET(\r\n BULK ''C:\\...\\pic002.png'', \r\n SINGLE_BLOB) AS Bild2)\r\nWHERE BildID = 1<\/pre>\n
Bild von image-Feld in Access anzeigen<\/h2>\n
![\"Aktualisieren](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_008.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_009.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_010.png\")
<\/p>\nimage-Datentyp ist veraltet<\/h2>\n
Der Datentyp varbinary(max)<\/h2>\n
INSERT INTO tblBilder(BildVarBinary) \r\nSELECT BulkColumn \r\nFROM OPENROWSET(BULK ''C:\\...\\pic001.png'', SINGLE_BLOB) \r\n AS BildVarBinary<\/pre>\n
\n
Verweis auf die ADODB-Bibliothek hinzufügen<\/h2>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_011.png\")
<\/p>\nZwei Methoden: Umweg über Datei oder direkter Weg<\/h2>\n
Formular anlegen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_012.png\")
<\/p>\nHinzufügen eines Bildes<\/h2>\n
Private Sub <\/span>cmdBildAuswaehlen_Click()\r\n Dim <\/span>strPfad As String<\/span>\r\n Dim <\/span>strDateiname As String<\/span>\r\n strPfad = ChooseAttachment\r\n If <\/span>Not<\/span> Len<\/span>(Dir(strPfad)) = 0 Then<\/span>\r\n If <\/span>IsNull(Me.BildID) Then<\/span>\r\n strDateiname = Mid<\/span>(strPfad, InStrRev<\/span>(strPfad, \"\\\") + 1)\r\n Me.Bezeichnung = strDateiname\r\n Me.Dirty = False<\/span>\r\n End If<\/span>\r\n SpeichereBildInDatenbank strPfad, Me.BildID\r\n BildInBildSteuerelement Me.BildID\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>ChooseAttachment()\r\n Dim <\/span>objFileDialog As <\/span>Office.FileDialog\r\n Dim <\/span>strTemp As String<\/span>\r\n Set<\/span> objFileDialog = Application.FileDialog(msoFileDialogFilePicker)\r\n With<\/span> objFileDialog\r\n .Title = \"Datei auswählen\"\r\n .ButtonName = \"Auswählen\"\r\n .InitialFilename = CurrentProject.Path & \"\\\"\r\n .Filters.Clear\r\n .Filters.Add \"Alle Dateitypen\", \"*.*\"\r\n .Filters.Add \"PNG-Datei\", \"*.png\"\r\n If <\/span>.Show = True<\/span> Then<\/span>\r\n strTemp = .SelectedItems(1)\r\n End If<\/span>\r\n End With<\/span>\r\n ChooseAttachment = strTemp\r\nEnd Function<\/span><\/pre>\nBild in Datenbank speichern<\/h2>\n
\n
![\"Formular](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_013.png\")
<\/p>\nBild in der Datenbank speichern<\/h2>\n
Public Sub <\/span>SpeichereBildInDatenbank(strDateiPfad As String<\/span>, lngBildID As Long<\/span>)\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Dim <\/span>cmd As <\/span>ADODB.Command\r\n Dim <\/span>objStream As <\/span>ADODB.Stream\r\n Dim <\/span>bytBild() As Byte<\/span>\r\n Dim <\/span>strSQL As String<\/span>\r\n '' Verbindung zur SQL Server-Datenbank herstellen\r\n Set<\/span> cnn = New<\/span> ADODB.Connection\r\n cnn.Open cStrConnection\r\n '' Datei in ein Byte-Array laden\r\n Set<\/span> objStream = New<\/span> ADODB.Stream\r\n With<\/span> objStream\r\n .Type = adTypeBinary\r\n .Open\r\n .LoadFromFile strDateiPfad\r\n bytBild = .Read\r\n .Close\r\n End With<\/span>\r\n Set<\/span> objStream = Nothing\r\n '' SQL-UPDATE zum Speichern der Datei in der Datenbank\r\n strSQL = \"UPDATE tblBilder SET BildVarBinary = ? WHERE BildID = ?\"\r\n '' SQL-Befehl vorbereiten und ausführen\r\n Set<\/span> cmd = New<\/span> ADODB.Command\r\n cmd.ActiveConnection = cnn\r\n cmd.CommandText = strSQL\r\n cmd.CommandType = adCmdText\r\n cmd.Parameters.Append cmd.CreateParameter(\"BildDaten\", adVarBinary, adParamInput, UBound<\/span>(bytBild) - _\r\n LBound<\/span>(bytBild) + 1, bytBild)\r\n cmd.Parameters.Append cmd.CreateParameter(\"BildID\", adInteger, adParamInput, , lngBildID)\r\n cmd.Execute\r\n '' Objekte freigeben\r\n cnn.Close\r\n Set<\/span> cmd = Nothing\r\n Set<\/span> cnn = Nothing\r\nEnd Sub<\/span><\/pre>\nPublic <\/span>Const cStrConnection As String<\/span> = \"Provider=SQLOLEDB;Data Source=amvdesktop2023;Initial Catalog=Bilder;Integrated Security=SSPI;\"<\/pre>\n\n
Prozedur zum Hinzufügen eines Bildes testen<\/h2>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_014.png\")
<\/p>\n![\"Ein](\"..\/fileadmin\/_temp_\/2025_02\/pic_1538_015.png\")
<\/p>\nBild aus varbinary(max)-Feld im Ordner speichern und anzeigen<\/h2>\n
Private Sub <\/span>BildInBildsteuerelement_Pfad(lngBildID As Long<\/span>)\r\n Dim <\/span>rst As <\/span>ADODB.Recordset\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Dim <\/span>bytBild() As Byte<\/span>\r\n Dim <\/span>strTempDatei As String<\/span>\r\n Dim <\/span>objStream As <\/span>ADODB.Stream\r\n Dim <\/span>strSQL As String<\/span>\r\n \r\n Me!pic.Picture = \"\" ''Sicherstellen, dass das Bildsteuerelement erst einmal leer ist\r\n '' Verbindung zur SQL Server-Datenbank herstellen\r\n Set<\/span> cnn = New<\/span> ADODB.Connection\r\n cnn.Open cStrConnection\r\n '' SQL-Abfrage für das gewünschte Bild\r\n strSQL = \"SELECT BildVarBinary FROM tblBilder WHERE BildID = \" & lngBildID\r\n '' Daten abrufen\r\n Set<\/span> rst = New<\/span> ADODB.Recordset\r\n rst.Open strSQL, cnn, adOpenKeyset, adLockOptimistic\r\n '' Prüfen, ob Daten vorhanden sind und ob das Feld nicht NULL ist\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n If <\/span>Not<\/span> IsNull(rst!BildVarBinary) Then<\/span>\r\n bytBild = rst.Fields(\"BildVarBinary\").Value '' Binärdaten auslesen\r\n '' Temporäre Datei im Windows-Temp-Ordner erstellen\r\n strTempDatei = CurrentProject.Path & \"\\tempbild.jpg\"\r\n '' Binärdaten in Datei speichern\r\n Set<\/span> objStream = New<\/span> ADODB.Stream\r\n With<\/span> objStream\r\n .Type = adTypeBinary\r\n .Open\r\n .Write bytBild\r\n .SaveToFile strTempDatei, adSaveCreateOverWrite\r\n .Close\r\n End With<\/span>\r\n Set<\/span> objStream = Nothing\r\n '' Bild in Access anzeigen\r\n Me!pic.Picture = strTempDatei\r\n Else<\/span>\r\n Me.pic.Picture = \"\"\r\n End If<\/span>\r\n Else<\/span>\r\n Me.pic.Picture = \"\"\r\n End If<\/span>\r\n '' Objekte freigeben\r\n rst.Close: cnn.Close\r\n Set<\/span> rst = Nothing: Set<\/span> cnn = Nothing\r\nEnd Sub<\/span><\/pre>\nBild aus varbinary(max)-Feld direkt im Bild-Steuerelement anzeigen<\/h2>\n
Private Sub <\/span>BildInBildSteuerelement(lngBildID As Long<\/span>)\r\n Dim <\/span>rst As <\/span>ADODB.Recordset\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Dim <\/span>bytBild() As Byte<\/span>\r\n Dim <\/span>strSQL As String<\/span>\r\n \r\n '' Stelle sicher, dass das Bildsteuerelement leer ist\r\n Me!pic.PictureData = Null\r\n '' Verbindung zur SQL Server-Datenbank herstellen\r\n Set<\/span> cnn = New<\/span> ADODB.Connection\r\n cnn.Open cStrConnection\r\n '' SQL-Abfrage für das gewünschte Bild\r\n strSQL = \"SELECT BildVarBinary FROM tblBilder WHERE BildID = \" & lngBildID\r\n \r\n '' Daten abrufen\r\n Set<\/span> rst = New<\/span> ADODB.Recordset\r\n rst.Open strSQL, cnn, adOpenKeyset, adLockOptimistic\r\n '' Prüfen, ob Daten vorhanden sind\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n If <\/span>Not<\/span> IsNull(rst!BildVarBinary) Then<\/span>\r\n bytBild = rst.Fields(\"BildVarBinary\").Value '' Binärdaten auslesen\r\n \r\n '' Binärdaten direkt in das Image-Steuerelement laden\r\n Me!pic.PictureData = bytBild\r\n \r\n Else<\/span>\r\n Me!pic.PictureData = Null '' Falls kein Bild vorhanden ist\r\n End If<\/span>\r\n Else<\/span>\r\n Me!pic.PictureData = Null\r\n End If<\/span>\r\n '' Objekte freigeben\r\n rst.Close\r\n cnn.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> cnn = Nothing\r\nEnd Sub<\/span><\/pre>\nZusammenfassung und Ausblick<\/h2>\n
\n
Downloads zu diesem Beitrag<\/h2>\n