Anlage-Felder erlauben es seit Access 2010, Bilder und andere Dateien direkt in Access-Tabellen zu speichern. Sie bieten ein praktisches Popup-Menü, mit dem man die enthaltenen Dateien verwalten kann. Enthält ein Anlage-Feld Bilddateien, können diese mit dem Bild-Steuerelement von Access direkt in Formularen und Berichten angezeigt werden. Wenn man seine Tabellen zum SQL Server migrieren möchte, wird dies jedoch zu einem Problem: Im SQL Server gibt es nämlich kein Pendant zum Anlage-Feld, sondern nur Alternativen wie beispielsweise den varbinary(max)-Datentyp. Damit können wir zwar die Dateien im binären Format im SQL Server speichern, aber rundherum ergeben sich einige Fragen: Wie zeige ich Bilddateien an, die in einem solchen Feld gespeichert sind? Wie gehe ich mit Anlage-Feldern um, die nicht nur eine Anlage enthalten? All dies erläutern wir in diesem und weiteren Beiträgen.<\/b><\/p>\n
Anlage-Felder sind flexibel einsetzbar. Grundsätzlich kann man in ihnen Dateien speichern, und zwar so viele, wie man möchte. Der Grund dafür ist, dass Access im Hintergrund eine eigene Tabelle für die einzelnen Anlagen eines Anlage-Feldes bereithält.<\/p>\n
Das dies der Fall ist, werden wir später sehen, wenn wir mit zwei verschachtelten Recordsets auf die einzelnen Datensätze eines Anlage-Feldes zugreifen.<\/p>\n
Aber man kann nicht nur einfach Dateien in Anlage-Feldern speichern. Wenn es sich bei den Dateien um Bilddateien handelt, können wir diese sogar beispielsweise im Anlage-Steuerelement oder im Bild-Steuerelement (mit wesentlich mehr Aufwand) anzeigen.<\/p>\n
Um die in einem Anlage-Feld enthaltenen Dateien in einem Formular zu verwalten, brauchen wir nur das Anlagefeld in den Tabellenentwurf zu ziehen. Klicken wir dieses dann an, sehen wir ein kleines Popup-Menü mit drei Befehlen, von denen die ersten beiden zum Navigieren zwischen den enthaltenen Dateien und die dritte zum Öffnen des Dialogs zum Verwalten der enthaltenen Dateien verwendet wird (siehe Bild 1).<\/p>\n
![\"Anzeigen](\"..\/fileadmin\/_temp_\/2025_03\/pic_1542_001.png\")
<\/p>\n
Bild 1: Anzeigen von Bildern aus einem Anlage-Feld<\/span><\/b><\/p>\n Wir gehen an dieser Stelle davon aus, dass wir bereits eine Beispieltabelle mit den drei Feldern AnlageID <\/b>(Primärschlüsselfeld), Bezeichnung <\/b>(Textfeld) und Anlagefeld <\/b>(Anlage-Feld) erstellt haben, die wir als Datensatzquelle des Formulars verwenden.<\/p>\n Zum Problem werden Anlage-Felder, wenn wir sie zum SQL Server migrieren wollen. Im Beitrag Bilder im SQL Server mit varbinary(max)<\/b> (www.access-im-unternehmen.de\/1538<\/b>) zeigen wir, wie man Bild-Dateien in einem varbinary(max)<\/b>-Feld des SQL Servers speichert und wie man die Bilder daraus in einem Bild-Steuerelement in Access anzeigt.<\/p>\n Im vorliegenden Artikel schauen wir uns genauer an, wie eine Tabelle mit Anlage-Feld zu einer entsprechenden SQL Server-Tabelle migriert werden kann. Dabei ist auch hier unser Ziel, ein entsprechendes varbinary(max)<\/b>-Feld zu erstellen und die Inhalte unseres Anlage-Feldes automatisiert zum SQL Server zu übertragen.<\/p>\n Zuvor müssen wir jedoch ein wenig planen.<\/p>\n Der SQL Server Migration Assistant ist das beste Werkzeug, wenn es um eine weitgehend automatisierte Migration der Tabellen von Access zu einer SQL Server-Datenbank geht.<\/p>\n Es werden mögliche Probleme angezeigt und es können alle Tabellen, Felder, Beziehungen, weitere Eigenschaften und auch noch die Daten migriert werden.<\/p>\n Leider bietet der SQL Server Migration Assistant keine Möglichkeit, ein Feld mit dem Datentyp Anlage <\/b>in ein entsprechendes Feld zu migrieren. Der Workaround des SQL Server Migration Assistant ist es, eine Meldung anzuzeigen, dass der Attachment<\/b>-Datentyp nicht migriert werden kann, und stattdessen immerhin das Feld als varchar(8000)<\/b>-Feld anzulegen.<\/p>\n Hier haben wir nun zwei Möglichkeiten:<\/p>\n Außerdem müssen wir noch beachten, dass ein Anlage-Feld auch immer mehr als eine Datei enthalten kann. Wie oben erwähnt, befindet sich hinter einem Anlage-Feld immer eine intern gepflegte Tabelle, die für jede enthaltene Datei einen eigenen Datensatz anlegt.<\/p>\n Wenn wir dies korrekt im SQL Server abbilden wollen, brauchen wir also eigentlich sogar eine eigene Tabelle für die Dateien. <\/p>\n Da es jedoch auch Fälle gibt, in denen die Anzahl der enthaltenen Dateien auf eine begrenzt ist, schauen wir uns zunächst diese einfachere Methode an.<\/p>\n Nochmal zusammengefasst die Ausgangssituation: Wir haben eine Migration durchgeführt und es fehlen nur noch die Anlage-Felder und ihre Daten, die als varbinary(max)<\/b>-Felder angelegt werden sollen.<\/p>\n Also lauten die Voraussetzungen:<\/p>\n Wir werden also zunächst eine Prozedur erstellen, der wir den Namen der Tabelle und des Feldes auf Access-Seite übergeben sowie den Namen der Tabelle und des Feldes in der SQL Server-Datenbank.<\/p>\n Diese Prozedur soll nun folgende Schritte ausführen:<\/p>\n Wir benötigen einen Verweis auf die Bibliothek Microsoft ActiveX Data Objects 6.1 Library<\/b>, den wir über den Verweise<\/b>-Dialog des VBA-Editors hinzufügen können.<\/p>\n Aus Gründen der Wartbarkeit wollen wir die Funktion auf mehrere Routinen aufteilen. Die erste, die wir uns anschauen, soll die Voraussetzungen liefern, um überhaupt Bilddaten in die SQL Server-Tabelle schreiben zu können.<\/p>\n Zuallererst legen wir jedoch die Verbindungszeichenfolge fest, die wir für den Zugriff per ADODB auf die Datenbank benötigen. Sie sieht wie folgt aus und erfordert noch das Ersetzen der Platzhalter [SERVER]<\/b> und [DATABASE] <\/b>durch die bei Ihnen vorliegenden Werte:<\/p>\n Danach erstellen wir die erste Funktion namens VarbinaryFeldAnlegenOderAnpassen<\/b> (siehe Listing 1).<\/p>\n Listing 1: Funktion zum Anlegen von varbinary(max)-Feldern oder Umwandeln von anderen Felddatentypen in varbinary(max)<\/span><\/b><\/p>\n Sie erwartet die folgenden Parameter:<\/p>\n Die Funktion liefert den Wert True <\/b>zurück, wenn das Feld vorhanden ist (gegebenenfalls durch Anpassung oder Erstellung).<\/p>\n Die Funktion erstellt als Erstes ein neues ADODB.Recordset <\/b>und referenziert es mit der Variablen rst<\/b>.<\/p>\n Dann stellt es in der Variablen strSQL <\/b>eine Abfrage zusammen, die in unserem Beispiel wie folgt aussieht:<\/p>\n Diese Abfrage ermittelt den Datentyp und die Anzahl Zeichen des Feldes, das noch den Datentyp varchar(8000) <\/b>hat und das wir ersetzen wollen.<\/p>\n Diese Abfrage öffnen wir mit der Open<\/b>-Methode des Recordsets und prüfen in einer If…Then<\/b>-Bedingung, ob überhaupt ein entsprechender Datensatz gefunden wurde, sprich: ob das Feld überhaupt vorhanden ist.<\/p>\n Falls ja, prüft die zweite If…Then<\/b>-Bedingung, ob der Datentyp des Feldes ungleich varbinary <\/b>ist oder ob die maximale Zeichenanzahl für dieses Feld ungleich -1 <\/b>ist (was MAX entspricht). In diesem Fall erscheint eine Meldung, die fragt, ob der Datentyp des Feldes geändert werden soll.<\/p>\n Antwortet der Benutzer mit Ja<\/b>, führt die Funktion bei deaktivierter Fehlerbehandlung zwei SQL-Anweisungen aus. <\/p>\n Löst dies einen Fehler aus, werden die beiden Rückgabeparameter lngErrNumber <\/b>und strErrDescription <\/b>mit den entsprechenden Werten aus der Err<\/b>-Klasse gefüllt und die Funktion wird verlassen.<\/p>\n Es kann auch geschehen, dass das Feld, dessen Name wir mit strSQLFeld <\/b>übergeben haben, noch nicht vorhanden ist. Dann erscheint eine Meldung, die den Benutzer fragt, ob es mit den Datentyp varbinary(max) <\/b>angelegt werden soll. Antwortet der Benutzer mit Ja<\/b>, wird dieses Feld zur Tabelle aus strSQLTabelle <\/b>hinzugefügt. Tritt hier ein Fehler auf, verfahren wir mit den Fehlerinformationen wie oben.<\/p>\n Damit haben wir bereits das benötigte Feld mit dem Datentyp varbinary(max)<\/b> vorbereitet.<\/p>\n Hier stellt sich die Frage, wie wir im Detail beim Kopieren vorgehen wollen. Der Prozess ist ohnehin individuell, weil jedes Bild einzeln vom Anlage-Feld in ein Byte-Array übertragen und dann in das varbinary(max)<\/b>-Feld eingetragen werden muss.<\/p>\n Wir können nun verschiedene Möglichkeiten wählen. Die erste Frage ist:<\/p>\n Es wird vermutlich im Laufe der Zeit mal den einen, mal den anderen Fall geben. Weiter oben haben wir bereits diskutiert, dass es vermutlich oft vorkommt, dass das vollständige Datenmodell bis auf die Anlage-Felder mit Tools wie dem SQL Server Migration Assistant zum SQL Server übertragen wird.<\/p>\n Wir tun uns also in den meisten Fällen einen Gefallen, indem wir den Teil, der das Anlage-Feld in das varbinary(max)<\/b>-Feld überträgt, in einer eigenen Funktion realisieren.<\/p>\n Wir können dann beispielsweise die folgenden Varianten für aufrufende Funktionen wählen:<\/p>\n In beiden Fällen benötigen wir eine eigene Prozedur, die davon ausgeht, dass der eigentliche Datensatz bereits kopiert wurde und nur noch der Inhalt der Anlage-Felder übertragen werden muss.<\/p>\n Daher programmieren wir die Funktion namens CopyAttachmentToVarBinaryMax <\/b>so, dass wir mit den Parametern die folgenden Informationen übergeben:<\/p>\n Die Funktion ist die Steuerzentrale für verschiedene Schritte (siehe Listing 2). Sie sorgt zunächst dafür, dass die im Anlagefeld gespeicherte Datei auf der Festplatte gespeichert wird. Dazu nutzt sie die Funktion SaveAttachmentToFile<\/b>. Das Ergebnis ist der Pfad zu dieser Datei.<\/p>\n Listing 2: Funktion zum Kopieren von Attachment-Inhalten in ein varbinary(max)-Feld<\/span><\/b><\/p>\n War der Aufruf dieser Funktion erfolgreich, folgt die nächste Funktion, mit der wir den Inhalt der Datei in ein Byte<\/b>-Array einlesen. Diese Funktion heißt LoadFileToByteArray<\/b>. Sie liefert mit dem Parameter bytData <\/b>das Byte<\/b>-Array zurück.<\/p>\n War auch dies erfolgreich, folgt der nächste Funktionsaufruf, diesmal für die Funktion AddByteArrayToVarBinaryMax<\/b>. Diese soll schließlich das Byte<\/b>-Array in das angegebene Feld der entsprechenden Tabelle eintragen.<\/p>\n Die Funktion SaveAttachmentToFile <\/b>(siehe Listing 3) erwartet die dazu notwendigen Parameter, hier strAccessTable<\/b>, strAccessField<\/b>, strAccessPKField <\/b>und lngAccessPKID<\/b>. <\/p>\n Listing 3: Funktion zum Speichern einer Datei aus einem Anlagefeld in eine Datei auf der Festplatte<\/span><\/b><\/p>\n Die folgenden beiden Parameter sind Rückgabeparameter:<\/p>\n Die Funktion stellt in strSQL<\/b> eine Abfrage zusammen, die das Anlagefeld der übergebenen Tabelle für den angegebenen Primärschlüsselwert zurückliefern soll. Dieses öffnet die Funktion per OpenRecordset<\/b>.<\/p>\n Danach prüft sie, ob das Recordset nicht leer ist und weist dann dem Recordset rstAttach <\/b>das Feld mit dem Anlagefeld hinzu.<\/p>\n Dieses enthält eine intern gespeicherte Tabelle mit den einzelnen Anlagen. Um auf das enthaltene Recordset zuzugreifen, müssen wir die Value<\/b>-Eigenschaft verwenden.<\/p>\n Nun prüfen wir, ob das Recordset rstAttach <\/b>nicht leer ist. Ist das nicht der Fall, werten wir die Datensatzanzahl in einer Select Case<\/b>-Anweisung aus.<\/p>\n Im Falle genau eines Datensatzes referenzieren wir das im Recordset enthaltene Feld FileData <\/b>mit der Variablen fld<\/b>. Außerdem ermitteln wir den Dateinamen aus dem Feld FileName<\/b>. Aus diesem extrahieren wir mit der Mid<\/b>– und der InStrRev<\/b>-Funktion die Dateiendung und speichern sie in der Variablen strFileExtension<\/b>.<\/p>\n Die Namen dieser Felder können wir aus Bild 2 entnehmen.<\/p>\n Bild 2: Quellfelder für die Dateien-Tabelle<\/span><\/b><\/p>\n Wir stellen den Pfad, unter dem die Datei gespeichert werden soll, aus dem aktuellen Datenbankverzeichnis (CurrentProject.Path<\/b>), der Zeichenkette \\temp <\/b>und der Dateiendung zusammen.<\/p>\n Danach versuchen wir, eine eventuell bereits vorhandene Datei gleichen Namens bei deaktiverter Fehlerbehandlung zu löschen. Ist das erledigt, können wir die Datei mit der SaveToFile<\/b>-Methode unter dem mit strFilepath <\/b>angegebenen Pfad speichern. In diesem Fall stellen wir das Funktionsergebnis auf True <\/b>ein.<\/p>\n Wenn das Recordset mehr als eine Anlage enthält, verlassen wir die Funktion und geben eine entsprechende Meldung zurück.<\/p>\n Es kann auch sein, dass das Anlagefeld gar keine Daten enthält, was wir ebenfalls mit einer entsprechenden Meldung adressieren.<\/p>\n Zuletzt schließen wir alle Recordsets wieder und leeren die Objektvariablen.<\/p>\n Die nächste Funktion heißt LoadFileToByteArray<\/b> (siehe Listing 4). Sie erwartet die folgenden Parameter:<\/p>\n Listing 4: Funktion zum Erzeugen eines Byte-Arrays aus einer gespeicherten Datei<\/span><\/b><\/p>\n Die Funktion deklariert und erstellt ein ADODB.Stream<\/b>-Objekt in der Variablen objStream<\/b>.<\/p>\n Dieses füllen wir mit der LoadFromFile<\/b>-Methode mit dem Inhalt der Datei aus strFilePath<\/b>. Dieses können wir dem Byte-Array bytData <\/b>über die Read<\/b>-Funktion zuweisen.<\/p>\n Die nächste Funktion namens AddByteArrayToVarBinaryMax <\/b>schreibt schließlich den Inhalt des Byte-Arrays in das varbinary(max)<\/b>-Feld der SQL Server-Tabelle (siehe Listing 5).<\/p>\nAnlage-Felder im SQL Server?<\/h2>\n
Migration mit dem SQL Server Migration-Assistant: Wie Anlage-Felder berücksichtigen?<\/h2>\n
\n
\n
\n
Vorbereitung<\/h2>\n
Prozeduren zum Anlegen und Übertragen erstellen<\/h2>\n
Public <\/span>Const cStrConnection As String<\/span> = \"Provider=MSOLEDBSQL;Data Source=[SERVER];Initial Catalog=[DATABASE];Integrated Security=SSPI;\"<\/pre>\nPublic Function <\/span>VarbinaryFeldAnlegenOderAnpassen(cnn As <\/span>ADODB.Connection, strSQLTabelle As String<\/span>, _\r\n strSQLFeld As String<\/span>, Optional<\/span> lngErrNumber As Long<\/span>, Optional<\/span> strErrDescription As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>rst As <\/span>ADODB.Recordset\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>intResult As <\/span>VbMsgBoxResult\r\n Set<\/span> rst = New<\/span> ADODB.Recordset\r\n strSQL = \"SELECT DATA_TYPE, CHARACTER_MAXIMUM_LENGTH FROM INFORMATION_SCHEMA.COLUMNS \" & _\r\n \"WHERE TABLE_NAME = ''\" & strSQLTabelle & \"'' AND COLUMN_NAME = ''\" & strSQLFeld & \"''\"\r\n rst.Open strSQL, cnn, adOpenStatic, adLockReadOnly\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n If <\/span>rst.Fields(\"DATA_TYPE\").Value <> \"varbinary\" Or rst.Fields(\"CHARACTER_MAXIMUM_LENGTH\").Value <> -1 Then<\/span>\r\n intResult = MsgBox<\/span>(\"Das Feld \" & strSQLFeld & \" ist kein varbinary(max). Soll es geändert werden?\", _\r\n vbYesNo + vbQuestion, \"Feld anpassen?\")\r\n If <\/span>intResult = vbYes Then<\/span>\r\n On Error Resume Next<\/span>\r\n cnn.Execute \"ALTER TABLE \" & strSQLTabelle & \" DROP COLUMN \" & strSQLFeld\r\n cnn.Execute \"ALTER TABLE \" & strSQLTabelle & \" ADD \" & strSQLFeld & \" varbinary(max)\"\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n lngErrNumber = Err.Number\r\n strErrDescription = Err.Description\r\n Exit Function<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n End If<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n intResult = MsgBox<\/span>(\"Das Feld ''\" & strSQLFeld & \"'' ist noch nicht vorhanden. Soll es mit dem \" _\r\n & \"Datentyp varbinarx(max) angelegt werden?\", vbYesNo, \"Feld nicht vorhanden\")\r\n If <\/span>intResult = vbYes Then<\/span>\r\n On Error Resume Next<\/span>\r\n cnn.Execute \"ALTER TABLE \" & strSQLTabelle & \" ADD \" & strSQLFeld & \" varbinary(max)\"\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n strErrDescription = Err.Description\r\n lngErrNumber = Err.Number\r\n Exit Function<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n End If<\/span>\r\n End If<\/span>\r\n VarbinaryFeldAnlegenOderAnpassen = True<\/span>\r\n rst.Close\r\nEnd Function<\/span><\/pre>\n\n
SELECT DATA_TYPE, CHARACTER_MAXIMUM_LENGTH FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = ''tblBilder'' AND COLUMN_NAME = ''Bild''<\/pre>\n
\n
Kopieren der Daten von Anlagefeld zum varbinary(max)-Feld<\/h2>\n
\n
\n
Funktion zum Übertragen der Anlage-Felder<\/h2>\n
\n
Public Function <\/span>CopyAttachmentToVarBinaryMax(strAccessTable As String<\/span>, strAccessField As String<\/span>, _\r\n strAccessPKField As String<\/span>, lngAccessPKID As Long<\/span>, strSQLTable As String<\/span>, strSQLField As String<\/span>, _\r\n strSQLPKField As String<\/span>, lngSQLPKID As Long<\/span>, cnn As <\/span>ADODB.Connection, _\r\n Optional<\/span> strErrorMessage As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>bytData() As Byte<\/span>\r\n Dim <\/span>strFilepath As String<\/span>\r\n \r\n If SaveAttachmentToFile(strAccessTable, strAccessField, strAccessPKField, lngAccessPKID, strFilepath, _\r\n strErrorMessage) = False<\/span> Then\r\n Exit Function<\/span>\r\n Else<\/span>\r\n If <\/span>LoadFileToByteArray(strFilepath, bytData) = True<\/span> Then<\/span>\r\n If AddByteArrayToVarBinaryMax(cnn, strSQLTable, strSQLField, strSQLPKField, lngSQLPKID, bytData, _\r\n strErrorMessage) = True<\/span> Then\r\n CopyAttachmentToVarBinaryMax = True<\/span>\r\n Else<\/span>\r\n CopyAttachmentToVarBinaryMax = False<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nFunktion zum Speichern einer Anlage im Dateisystem<\/h2>\n
Public Function <\/span>SaveAttachmentToFile(strAccessTable As String<\/span>, strAccessField As String<\/span>, strAccessPKField As <\/span>_\r\n String, lngAccessPKID As Long<\/span>, strFilepath As String<\/span>, Optional<\/span> strErrorMessage As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>rstAttach As <\/span>DAO.Recordset\r\n Dim <\/span>fld As <\/span>DAO.Field2\r\n Dim <\/span>strFilename As String<\/span>\r\n Dim <\/span>strFileExtension As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n strSQL = \"SELECT \" & strAccessField & \" FROM \" & strAccessTable & \" WHERE \" & strAccessPKField & \" = \" _\r\n & lngAccessPKID\r\n Set<\/span> rst = db.OpenRecordset(strSQL, dbOpenDynaset)\r\n \r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n Set<\/span> rstAttach = rst.Fields(strAccessField).Value\r\n If <\/span>Not<\/span> rstAttach.EOF Then<\/span>\r\n Select Case rstAttach.RecordCount\r\n Case <\/span>1\r\n Set<\/span> fld = rstAttach.Fields(\"FileData\")\r\n strFilename = rstAttach.Fields(\"FileName\")\r\n strFileExtension = Mid<\/span>(strFilename, InStrRev<\/span>(strFilename, \".\"))\r\n strFilepath = CurrentProject.Path & \"\\temp\" & strFileExtension\r\n On Error Resume Next<\/span>\r\n Kill strFilepath\r\n On Error GoTo<\/span> 0\r\n fld.SaveToFile strFilepath\r\n SaveAttachmentToFile = True<\/span>\r\n Case Else<\/span>\r\n strErrorMessage = \"Mehr als ein Anhang im Datensatz vorhanden.\"\r\n GoTo Exit_Function\r\n End Select<\/span>\r\n Else<\/span>\r\n strErrorMessage = \"Kein Anhang im Datensatz vorhanden.\"\r\n GoTo Exit_Function\r\n End If<\/span>\r\n Else<\/span>\r\n strErrorMessage = \"Kein Datensatz gefunden.\"\r\n GoTo Exit_Function\r\n End If<\/span>\r\nExit_Function:\r\n rstAttach.Close\r\n Set<\/span> rstAttach = Nothing\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Function<\/span><\/pre>\n\n
![\"Quellfelder](\"..\/fileadmin\/_temp_\/2025_03\/pic_1542_004.png\")
<\/p>\nByte-Array aus Datei generieren<\/h2>\n
Public Function <\/span>LoadFileToByteArray(strFilepath As String<\/span>, bytData() As Byte<\/span>) As Boolean<\/span>\r\n Dim <\/span>objStream As <\/span>ADODB.Stream\r\n Set<\/span> objStream = New<\/span> ADODB.Stream\r\n With<\/span> objStream\r\n .Type = adTypeBinary\r\n .Open\r\n .LoadFromFile strFilepath\r\n bytData = .Read\r\n .Close\r\n LoadFileToByteArray = True<\/span>\r\n End With<\/span>\r\nEnd Function<\/span><\/pre>\n\n
Byte-Array in varbinary(max)-Feld schreiben<\/h2>\n
Public Function <\/span>AddByteArrayToVarBinaryMax(cnn As <\/span>ADODB.Connection, strSQLTable As String<\/span>, strSQLField As String<\/span>, _\r\n strSQLPKField