- \n
- PDFID:<\/b> der Primärschlüssel vom Datentyp int<\/b> mit der Eigenschaft IDENTITY<\/b>, die dem AutoWert in Access entspricht<\/li>\n
- Dateiname:<\/b> der Name der Datei vom Datentyp nvarchar(255)<\/b><\/li>\n
- Dateiinhalt:<\/b> der Inhalt der Datei vom Datentyp varbinary(max)<\/b><\/li>\n<\/ul>\n
Die Tabelle legen wir mit der folgenden Anweisung an, wobei dbo<\/b> das Standardschema des SQL Servers ist. Das Skript PDFInVarCharMax.sql<\/b> aus dem Download legt zusätzlich die Datenbank an.<\/p>\n
Wir führen es im SQL Server Management Studio (SSMS) aus. Das Skript prüft vor jeder Anweisung, ob das Objekt schon existiert. Deshalb können wir es mehrmals ausführen.<\/p>\n
CREATE TABLE dbo.tblPDFs (\r\n PDFID int IDENTITY(1, 1) NOT NULL\r\n CONSTRAINT PK_tblPDFs PRIMARY KEY,\r\n Dateiname nvarchar(255) NOT NULL,\r\n Dateiinhalt varbinary(max) NULL\r\n);<\/pre>\n
Das Feld Dateiinhalt<\/b> erlaubt den Wert NULL<\/b>. Damit können wir auch Datensätze anlegen, die kein PDF-Dokument enthalten. Diesen Fall behandeln wir im Formular zur Anzeige der PDF-Dokumente gesondert.<\/p>\n
Der Datentyp varbinary(max)<\/h2>\n
Der Datentyp varbinary(n)<\/b> speichert höchstens 8.000 Byte. Geben wir statt n<\/b> den Wert max<\/b> an, nimmt das Feld bis zu 2.147.483.647 Byte auf, was knapp 2 Gigabyte entspricht.<\/p>\n
Der SQL Server speichert die Datei als Folge von Bytes, ohne ihre Struktur zu kennen. Dass es sich um ein PDF-Dokument handelt, erkennen wir in der Tabelle nur am Dateinamen.<\/p>\n
Die Länge eines Werts in Byte liefert die Funktion DATALENGTH()<\/b>. Enthält das Feld den Wert NULL<\/b>, liefert sie ebenfalls NULL<\/b>. Die folgende Abfrage zeigt die Größe der gespeicherten Dateien:<\/p>\n
SELECT PDFID, Dateiname,\r\n DATALENGTH(Dateiinhalt) AS Groesse\r\nFROM dbo.tblPDFs;<\/pre>\n
Ein Feld mit der Länge 0 Byte, geschrieben als 0x<\/b>, unterscheidet sich vom Wert NULL<\/b>, der für einen fehlenden Wert steht.<\/p>\n
Für die Anzeige im Formular behandeln wir beide Fälle gleich. Enthält das Feld keine Bytes, haben wir kein PDF-Dokument gespeichert.<\/p>\n
Die Verbindung zum SQL Server<\/h2>\n
Die Beispiele verwenden ADODB<\/b>. Dafür braucht das Projekt einen Verweis auf die Microsoft ActiveX Data Objects 6.1 Library<\/b>. Die Funktionen und Prozeduren dieses Beitrags stehen im Modul mdlPDFInVarBinaryMax<\/b>.<\/p>\n
Am Anfang des Moduls legen wir den Server und die Datenbank als Konstanten fest. Hier tragen wir den Namen des eigenen Servers ein. In den Beispielen heißt er amvDesktop2023<\/b>:<\/p>\n
Private <\/span>Const cstrServer As String<\/span> = \"amvDesktop2023\"\r\nPrivate <\/span>Const cstrDatenbank _\r\n As String<\/span> = \"PDFInVarCharMax\"<\/pre>\nDie Funktion Verbindung<\/b> setzt daraus die Verbindungszeichenfolge für den ODBC-Treiber zusammen (siehe Listing 1).<\/p>\n
Public Function <\/span>Verbindung(Optional<\/span> ByVal strDatenbank As String<\/span> = cstrDatenbank) As String<\/span>\r\n Verbindung = \"Driver={ODBC Driver 18 for SQL Server};Server=\" & cstrServer & _\r\n \";Database=\" & strDatenbank & _\r\n \";Trusted_Connection=Yes;Encrypt=yes;TrustServerCertificate=yes;\"\r\nEnd Function<\/span><\/pre>\nListing 1: Verbindung liefert die Verbindungszeichenfolge<\/span><\/b><\/p>\n
Mit Trusted_Connection=Yes<\/b> verwenden wir die Windows-Anmeldung.<\/p>\n
Der ODBC-Treiber 18 verschlüsselt die Verbindung standardmäßig, wobei TrustServerCertificate=yes<\/b> die Prüfung des Serverzertifikats unterdrückt. Das genügt für die Beispiele. Auf einem Produktivserver installieren wir ein vertrauenswürdiges Zertifikat. Übergeben wir der Funktion keinen Datenbanknamen, verwendet sie die Konstante cstrDatenbank<\/b>.<\/p>\n
Die Datenbank und die Tabelle per VBA-Prozedur anlegen<\/h2>\n
Wer das Skript nicht im SSMS ausführen möchte, legt die Datenbank und die Tabelle per VBA-Prozedur an. Die Prozedur DatenbankAnlegen<\/b> verbindet sich dazu mit der Systemdatenbank master<\/b> und legt die Datenbank an (siehe Listing 2).<\/p>\n
Public Sub <\/span>DatenbankAnlegen(Optional<\/span> ByVal strDatenbank As String<\/span> = cstrDatenbank)\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Set<\/span> cnn = New<\/span> ADODB.Connection\r\n cnn.Open Verbindung(\"master\")\r\n cnn.Execute \"IF DB_ID(N'\" & strDatenbank & \"') IS NULL \" & _\r\n \"CREATE DATABASE [\" & strDatenbank & \"]\"\r\n cnn.Close\r\n cnn.Open Verbindung(strDatenbank)\r\n cnn.Execute \"IF OBJECT_ID(N'dbo.tblPDFs', N'U') IS NULL \" & _\r\n \"CREATE TABLE dbo.tblPDFs (\" & _\r\n \"PDFID int IDENTITY(1, 1) NOT NULL CONSTRAINT PK_tblPDFs PRIMARY KEY, \" & _\r\n \"Dateiname nvarchar(255) NOT NULL, \" & _\r\n \"Dateiinhalt varbinary(max) NULL)\"\r\n cnn.Close\r\nEnd Sub<\/span><\/pre>\nListing 2: DatenbankAnlegen legt die Datenbank und die Tabelle an<\/span><\/b><\/p>\n
Anschließend öffnet sie eine Verbindung zu dieser Datenbank und legt die Tabelle an. Beide Anweisungen führt sie nur aus, falls das Objekt noch nicht existiert. Für die Datenbank braucht das Konto, mit dem wir uns anmelden, das Recht CREATE DATABASE<\/b>. Die Prozedur setzt den Datenbanknamen unverändert in die Anweisung ein. Daher übergeben wir nur eigene, feste Namen.<\/p>\n
Im Direktbereich rufen wir die Prozedur auf. Fehlen die Datenbank und die Tabelle, legt der Aufruf beide an. Existieren sie bereits, ändert er nichts:<\/p>\n
DatenbankAnlegen<\/pre>\n
Ein PDF-Dokument speichern<\/h2>\n
Die Funktion PDFInSQLSpeichern<\/b> liest eine Datei und schreibt sie in die Tabelle (siehe Listing 3). Zuerst prüft sie mit der Methode FileExists<\/b> des Objekts FileSystemObject<\/b>, ob die Datei existiert. Falls nicht, löst sie einen benutzerdefinierten Fehler aus (vbObjectError + 1000<\/b>).<\/p>\n
Public Function <\/span>PDFInSQLSpeichern(ByVal strDateipfad As String<\/span>, Optional<\/span> ByVal strConnection As String<\/span>) 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>rst As <\/span>ADODB.Recordset\r\n Dim <\/span>stm As <\/span>ADODB.Stream\r\n Dim <\/span>fso As Object<\/span>\r\n Dim <\/span>varData As Variant<\/span>\r\n Dim <\/span>strDateiname As String<\/span>\r\n Set<\/span> fso = CreateObject(\"Scripting.FileSystemObject\")\r\n If <\/span>Not<\/span> fso.FileExists(strDateipfad) Then<\/span>\r\n Err.Raise vbObjectError + 1000, \"PDFInSQLSpeichern\", \"Die Datei \" & strDateipfad & \" existiert nicht.\"\r\n End If<\/span>\r\n If <\/span>Len<\/span>(strConnection) = 0 Then<\/span> strConnection = Verbindung()\r\n Set<\/span> stm = New<\/span> ADODB.Stream\r\n With<\/span> stm\r\n .Type = adTypeBinary\r\n .Open\r\n .LoadFromFile strDateipfad\r\n varData = .Read\r\n .Close\r\n End With<\/span>\r\n If <\/span>IsNull(varData) Then<\/span>\r\n Err.Raise vbObjectError + 1001, \"PDFInSQLSpeichern\", \"Die Datei \" & strDateipfad & \" ist leer.\"\r\n End If<\/span>\r\n strDateiname = fso.GetFileName(strDateipfad)\r\n Set<\/span> cnn = New<\/span> ADODB.Connection\r\n cnn.Open strConnection\r\n Set<\/span> cmd = New<\/span> ADODB.Command\r\n With<\/span> cmd\r\n .ActiveConnection = cnn\r\n .CommandType = adCmdText\r\n .CommandText = \"SET NOCOUNT ON; \" _\r\n & \"INSERT INTO dbo.tblPDFs (Dateiname, Dateiinhalt) VALUES (?, ?); \" _\r\n & \"SELECT CAST(SCOPE_IDENTITY() AS int);\"\r\n .Parameters.Append .CreateParameter(\"pDateiname\", adVarWChar, adParamInput, 255, strDateiname)\r\n .Parameters.Append .CreateParameter(\"pDateiinhalt\", adLongVarBinary, adParamInput, UBound<\/span>(varData) + 1, varData)\r\n Set<\/span> rst = .Execute\r\n End With<\/span>\r\n PDFInSQLSpeichern = rst.Fields(0).Value\r\n rst.Close\r\n cnn.Close\r\nEnd Function<\/span><\/pre>\nListing 3: PDFInSQLSpeichern schreibt eine Datei in die Tabelle<\/span><\/b><\/p>\n
Danach öffnet sie einen ADODB.Stream<\/b> vom Typ adTypeBinary<\/b> und lädt die Datei mit LoadFromFile<\/b>. Den gesamten Inhalt liest sie mit Read<\/b> in eine Variant-Variable. Bei einer leeren Datei liefert Read<\/b> den Wert Null<\/b>. Dann löst die Funktion den benutzerdefinierten Fehler vbObjectError + 1001<\/b> aus.<\/p>\n
Den Dateinamen ermittelt die Funktion mit der Methode GetFileName<\/b> aus dem Pfad. Die Anweisung INSERT<\/b> führt sie über ein Objekt vom Typ ADODB.Command<\/b> mit zwei Parametern aus. Der Parameter für den Dateinamen hat den Typ adVarWChar<\/b>, der Parameter für den Inhalt den Typ adLongVarBinary<\/b> mit der Länge des Byte-Arrays. Den Inhalt übergeben wir als Parameter, weil ein Hexadezimalliteral in der SQL-Anweisung bei großen Dateien unpraktisch wäre.<\/p>\n
Die Anweisung beginnt mit SET NOCOUNT ON<\/b>. Damit sendet der Server keine Meldung über die Zahl der geänderten Zeilen, und das Recordset enthält das Ergebnis des SELECT<\/b>. Dieses SELECT<\/b> gibt mit SCOPE_IDENTITY()<\/b> die neue PDFID<\/b> zurück. Die Funktion liefert sie als Ergebnis.<\/p>\n
Mit dem optionalen Parameter strConnection<\/b> können wir eine andere Verbindungszeichenfolge übergeben.<\/p>\n
Übergeben wir keine, verwendet die Funktion die Zeichenfolge, die Verbindung<\/b> liefert.<\/p>\n
Im Direktbereich speichern wir die Datei test.pdf<\/b> aus dem Ordner der Datenbank:<\/p>\n
PDFInSQLSpeichern(CurrentProject.Path & \"\\test.pdf\")\r\n 1<\/pre>\n
In einer neuen Tabelle erhält das Dokument die PDFID<\/b> 1. Die Abfrage mit DATALENGTH()<\/b> liefert für diesen Datensatz den Wert 155.264<\/b>, die Größe der Datei in Byte. Für die Bilder speichern wir auf demselben Weg die Datei vbe_517.pdf<\/b> als zweiten Datensatz. Den dritten Datensatz legen wir ohne PDF-Dokument an. Das Feld Dateiinhalt<\/b> bleibt dabei leer:<\/p>\n
INSERT INTO dbo.tblPDFs (Dateiname)\r\nVALUES (N'ohne_Inhalt.pdf');<\/pre>\n
Ein PDF-Dokument auf die Festplatte schreiben<\/h2>\n
Die Funktion PDFAusSQLSpeichern<\/b> schreibt den Inhalt zurück in eine Datei (siehe Listing 4). Sie liest das Feld Dateiinhalt<\/b> des Datensatzes mit der übergebenen PDFID<\/b> mit einem Objekt vom Typ ADODB.Recordset<\/b>. Da wir die Daten nur einmal lesen, genügen die Cursorart adOpenForwardOnly<\/b> und die Sperrart adLockReadOnly<\/b>.<\/p>\n
Public Function <\/span>PDFAusSQLSpeichern(ByVal lngPDFID As Long<\/span>, _\r\n ByVal strZieldatei As String<\/span>, _\r\n Optional<\/span> ByVal strConnection As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>cnn As <\/span>ADODB.Connection\r\n Dim <\/span>rst As <\/span>ADODB.Recordset\r\n Dim <\/span>stm As <\/span>ADODB.Stream\r\n If <\/span>Len<\/span>(strConnection) = 0 Then<\/span> strConnection = Verbindung()\r\n Set<\/span> cnn = New<\/span> ADODB.Connection\r\n cnn.Open strConnection\r\n Set<\/span> rst = New<\/span> ADODB.Recordset\r\n rst.Open \"SELECT Dateiinhalt FROM dbo.tblPDFs WHERE PDFID = \" & lngPDFID, _\r\n cnn, adOpenForwardOnly, adLockReadOnly\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n If <\/span>rst.Fields(\"Dateiinhalt\").ActualSize > 0 Then<\/span>\r\n Set<\/span> stm = New<\/span> ADODB.Stream\r\n With<\/span> stm\r\n .Type = adTypeBinary\r\n .Open\r\n .Write rst.Fields(\"Dateiinhalt\").Value\r\n .SaveToFile strZieldatei, adSaveCreateOverWrite\r\n .Close\r\n End With<\/span>\r\n PDFAusSQLSpeichern = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n rst.Close\r\n cnn.Close\r\nEnd Function<\/span><\/pre>\nListing 4: PDFAusSQLSpeichern schreibt den Inhalt in eine Datei<\/span><\/b><\/p>\n
Ob das Feld ein PDF-Dokument enthält, entscheidet die Eigenschaft ActualSize<\/b> des Felds. Sie liefert die Länge in Byte. In unseren Tests lieferte sie sowohl beim Wert NULL<\/b> als auch bei einem Feld mit 0 Byte den Wert 0.<\/p>\n
Nur wenn sie größer als 0 ist, schreibt die Funktion den Inhalt in die Zieldatei. Dazu verwendet sie einen ADODB.Stream<\/b> und ruft SaveToFile<\/b> mit der Option adSaveCreateOverWrite<\/b> auf. Eine vorhandene Datei überschreibt sie dabei.<\/p>\n
Die Funktion liefert True<\/b>, wenn sie die Datei geschrieben hat. Andernfalls liefert sie False<\/b>. Der Direktbereich zeigt die Werte in der deutschen Fassung als Wahr<\/b> und Falsch<\/b> an.<\/p>\n
Auch hier können wir mit dem Parameter strConnection<\/b> eine andere Verbindungszeichenfolge übergeben.<\/p>\n
Im Direktbereich geben wir den Aufruf in einer Zeile ein. Zur besseren Lesbarkeit haben wir ihn hier umgebrochen:<\/p>\n
Debug.Print<\/span> PDFAusSQLSpeichern(1, CurrentProject.Path _\r\n & \"\\export.pdf\")\r\nWahr<\/pre>\nIn unseren Tests war die Datei export.pdf<\/b> danach genauso groß wie test.pdf<\/b>, und ein Vergleich der Bytes ergab keinen Unterschied. Existiert zur PDFID<\/b> kein Datensatz oder enthält das Feld Dateiinhalt<\/b> keine Bytes, liefert der Aufruf Falsch<\/b>. In diesem Fall legt die Funktion die Zieldatei nicht an und ändert sie nicht.<\/p>\n
Beide Funktionen halten die Datei vollständig im Arbeitsspeicher. In unseren Tests haben wir Dateien bis 25 Megabyte fehlerfrei gespeichert und gelesen.<\/p>\n
In einer 32-Bit-Anwendung begrenzt der Arbeitsspeicher die Dateigröße weit unterhalb der 2 Gigabyte des Datentyps. Mit 100 Megabyte gelang das Speichern noch, bei 150 Megabyte trat ein Speicherfehler auf.<\/p>\n
Damit die Listings übersichtlich bleiben, enthalten sie keine Fehlerbehandlung. Im Produktivcode schließen wir den Stream, das Recordset und die Verbindung in einer Fehlerbehandlung.<\/p>\n
Die Tabelle in Access verknüpfen<\/h2>\n
Für das Formular verknüpfen wir die Tabelle mit der Access-Datenbank. Die Prozedur TabelleVerknuepfen<\/b> legt dazu ein Objekt vom Typ TableDef<\/b> mit der ODBC-Verbindung an und setzt die Eigenschaft SourceTableName<\/b> auf dbo.tblPDFs<\/b>.<\/p>\n
Danach hängt sie es an die Auflistung TableDefs<\/b> an (siehe Listing 5). Eine vorhandene Verknüpfung mit diesem Namen löscht sie zuvor. Eine lokale Tabelle mit diesem Namen löscht sie nicht.<\/p>\n
Public Sub <\/span>TabelleVerknuepfen(Optional<\/span> ByVal strDatenbank As String<\/span> = cstrDatenbank)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Set<\/span> db = CurrentDb\r\n For Each tdf In db.TableDefs\r\n If <\/span>tdf.Name = \"tblPDFs\" And Len<\/span>(tdf.Connect) > 0 Then<\/span>\r\n db.TableDefs.Delete \"tblPDFs\"\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> tdf\r\n Set<\/span> tdf = db.CreateTableDef(\"tblPDFs\")\r\n tdf.Connect = \"ODBC;DRIVER=ODBC Driver 18 for SQL Server;SERVER=\" & cstrServer & _\r\n \";DATABASE=\" & strDatenbank & \";Trusted_Connection=Yes;TrustServerCertificate=Yes;\"\r\n tdf.SourceTableName = \"dbo.tblPDFs\"\r\n db.TableDefs.Append tdf\r\n db.TableDefs.Refresh\r\nEnd Sub<\/span><\/pre>\nListing 5: TabelleVerknuepfen verknüpft die Tabelle tblPDFs<\/span><\/b><\/p>\n
Wie wir Tabellen allgemein per VBA verknüpfen, beschreibt der Beitrag SQL Server: Tabellen per VBA verknüpfen (www.vbentwickler.de\/485)<\/b>.<\/p>\n
Die Verknüpfung heißt tblPDFs<\/b>. Verknüpfen wir die Tabelle von Hand, nennt Access sie dbo_tblPDFs<\/b>. In Access hat das Feld Dateiinhalt<\/b> den DAO-Datentyp dbLongBinary<\/b> (11).<\/p>\n
In der Oberfläche steht dafür OLE-Objekt<\/b>. In unseren Beispieldaten zeigt das Datenblatt in jeder Zeile den Eintrag OLE-Objekt<\/b>, auch beim dritten Datensatz, bei dem das Feld Dateiinhalt<\/b> den Wert NULL<\/b> enthält (siehe Bild 1). Ob ein PDF-Dokument gespeichert ist, erkennen wir im Datenblatt daher nicht.<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2026_04\/pic_520_001.png\")
<\/p>\nBild 1: Die verknüpfte Tabelle tblPDFs im Datenblatt von Access<\/span><\/b><\/p>\n
Das Listenfeld des Formulars fragt deshalb nur die Felder PDFID<\/b> und Dateiname<\/b> ab, damit Access nicht alle Dokumente überträgt. Den Inhalt laden wir erst, wenn wir einen Datensatz wählen.<\/p>\n
Das Formular<\/h2>\n
Das Formular zeigt links die Datensätze der Tabelle und rechts das gewählte PDF-Dokument.<\/p>\n
Es besteht aus vier Steuerelementen:<\/p>\n
- \n
- lstPDFs:<\/b> ein Listenfeld mit zwei Spalten und der Datensatzherkunft SELECT PDFID, Dateiname FROM tblPDFs ORDER BY PDFID;<\/b>, wobei die erste Spalte die gebundene Spalte ist<\/li>\n
- ctlEdge:<\/b> das Edge-Steuerelement, das das PDF-Dokument anzeigt<\/li>\n
- cmdHinzufuegen:<\/b> die Schaltfläche PDF hinzufügen<\/b><\/li>\n
- lblHinweis:<\/b> ein Bezeichnungsfeld mit dem Text Zu diesem Datensatz ist kein PDF gespeichert.<\/b><\/li>\n<\/ul>\n
Das Formular hat keine eigene Datensatzherkunft. In der Ereignisprozedur zum Ereignis Beim Laden<\/b> blenden wir den Hinweis aus. Er erscheint dadurch nur bei einem Datensatz ohne PDF-Dokument.<\/p>\n
Das Edge-Steuerelement<\/h2>\n
Das Edge-Steuerelement zeigt Webseiten und Dokumente mit dem Browser Microsoft Edge an. Es steht nur in Access mit Microsoft 365 zur Verfügung. Wir verwenden Access 16.0 mit dem Build 20430. Die Eigenschaft Steuerelementinhalt<\/b> (ControlSource<\/b>) nimmt eine Adresse auf.<\/p>\n
Für eine lokale Datei stellen wir dem Pfad das Präfix https:\/\/msaccess\/<\/b> voran. In unseren Tests zeigte das Steuerelement die Datei im Ordner der Beispieldatenbank an. Es verwendet dafür den PDF-Viewer von Edge mit der Symbolleiste (siehe Bild 2).<\/p>\n
![\"Das](\"..\/fileadmin\/_temp_\/2026_04\/pic_520_002.png\")
<\/p>\nBild 2: Das Formular zeigt das PDF-Dokument des gewählten Datensatzes im Edge-Steuerelement<\/span><\/b><\/p>\n
Die Prozedur PDFAnzeigen<\/b> steht im Klassenmodul des Formulars (siehe Listing 6). Sie schreibt das PDF-Dokument des Datensatzes in die Datei export.pdf<\/b> im Ordner der Datenbank und setzt die Eigenschaft ControlSource<\/b> auf die Adresse dieser Datei.<\/p>\n
Public Sub <\/span>PDFAnzeigen(ByVal lngPDFID As Long<\/span>)\r\n Dim <\/span>strZiel As String<\/span>\r\n strZiel = CurrentProject.Path & \"\\export.pdf\"\r\n If <\/span>PDFAusSQLSpeichern(lngPDFID, strZiel) Then<\/span>\r\n Me.lblHinweis.Visible = False<\/span>\r\n Me.ctlEdge.Visible = True<\/span>\r\n Me.ctlEdge.ControlSource = \"https:\/\/msaccess\/\" & strZiel\r\n Else<\/span>\r\n Me.lblHinweis.Visible = True<\/span>\r\n Me.ctlEdge.Visible = False<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nListing 6: PDFAnzeigen zeigt das PDF-Dokument eines Datensatzes im Formular an<\/span><\/b><\/p>\n
Das Ergebnis des Aufrufs von PDFAusSQLSpeichern<\/b> bestimmt die Anzeige. Liefert er True<\/b>, blenden wir den Hinweis aus und zeigen das Steuerelement an. Liefert er False<\/b>, blenden wir das Steuerelement aus und zeigen den Hinweis an (siehe Bild 3).<\/p>\n
![\"Zu](\"..\/fileadmin\/_temp_\/2026_04\/pic_520_003.png\")
<\/p>\nBild 3: Zu einem Datensatz ohne PDF-Dokument zeigt das Formular einen Hinweis<\/span><\/b><\/p>\n
Das Steuerelement blenden wir mit der Eigenschaft Visible<\/b> aus, die in der Oberfläche Sichtbar<\/b> heißt.<\/p>\n
Die Datei export.pdf<\/b> schreiben wir bei jeder Auswahl eines Datensatzes mit PDF-Dokument neu. In unseren Tests schlug das Überschreiben nicht fehl, während das Steuerelement die Datei anzeigte. Hält eine andere Anwendung die Datei geöffnet und erlaubt keinen Schreibzugriff, löst SaveToFile<\/b> einen Fehler aus. Außerdem muss der Ordner der Datenbank für den Benutzer beschreibbar sein.<\/p>\n
Mehrere Benutzer sollten nicht dasselbe Frontend im selben Ordner verwenden. Andernfalls überschreiben sie dieselbe Datei.<\/p>\n
Wir rufen die Prozedur im Ereignis Nach Aktualisierung<\/b> des Listenfelds auf. Der Wert des Listenfelds ist die PDFID<\/b>. Haben wir keinen Datensatz gewählt, hat er den Wert Null<\/b>.<\/p>\n
Die Funktion Nz<\/b> ersetzt ihn durch den Wert 0, und das Formular zeigt in diesem Fall den Hinweis an:<\/p>\n
Private Sub <\/span>lstPDFs_AfterUpdate()\r\n PDFAnzeigen Nz(Me.lstPDFs, 0)\r\nEnd Sub<\/span><\/pre>\nEin PDF-Dokument aus dem Formular hinzufügen<\/h2>\n
Mit der Schaltfläche PDF hinzufügen<\/b> wählen wir eine Datei aus und speichern sie in der Tabelle. Die Funktion PDFAuswaehlen<\/b> öffnet dazu den Dateiauswahldialog von Access. Sie steht im selben Standardmodul wie die Funktionen aus den Listings:<\/p>\n
Public Function <\/span>PDFAuswaehlen() As String<\/span>\r\n With<\/span> Application.FileDialog(msoFileDialogFilePicker)\r\n .Title = \"PDF auswählen\"\r\n .AllowMultiSelect = False<\/span>\r\n .Filters.Clear\r\n .Filters.Add \"PDF-Dateien\", \"*.pdf\"\r\n If <\/span>.Show Then<\/span> PDFAuswaehlen = .SelectedItems(1)\r\n End With<\/span>\r\nEnd Function<\/span><\/pre>\nDer Dialog zeigt nur PDF-Dateien an und erlaubt eine einzelne Auswahl. Bricht der Benutzer den Dialog ab, liefert die Funktion eine leere Zeichenfolge.<\/p>\n
Die Ereignisprozedur zum Ereignis Beim Klicken<\/b> der Schaltfläche steht im Klassenmodul des Formulars:<\/p>\n
Private Sub <\/span>cmdHinzufuegen_Click()\r\n Dim <\/span>strPfad As String<\/span>\r\n Dim <\/span>lngID As Long<\/span>\r\n strPfad = PDFAuswaehlen()\r\n If <\/span>Len<\/span>(strPfad) = 0 Then<\/span> Exit Sub<\/span>\r\n lngID = PDFInSQLSpeichern(strPfad)\r\n Me.lstPDFs.Requery\r\n Me.lstPDFs = lngID\r\n PDFAnzeigen lngID\r\nEnd Sub<\/span><\/pre>\nDie Prozedur speichert die gewählte Datei mit PDFInSQLSpeichern<\/b> und aktualisiert die Liste mit Requery<\/b>.<\/p>\n
Anschließend wählt sie den neuen Datensatz über die zurückgegebene PDFID<\/b> aus und zeigt dessen PDF-Dokument an.<\/p>\n
Das Setzen des Listenfelds per Code löst das Ereignis Nach Aktualisierung<\/b> nicht aus. Deshalb rufen wir PDFAnzeigen<\/b> selbst auf. Enthält die gewählte Datei keine Bytes, löst PDFInSQLSpeichern<\/b> den Fehler
- ctlEdge:<\/b> das Edge-Steuerelement, das das PDF-Dokument anzeigt<\/li>\n
- Dateiname:<\/b> der Name der Datei vom Datentyp nvarchar(255)<\/b><\/li>\n