Es gibt verschiedene Gründe, warum man Ordner und Dateien aus dem Filesystem in eine entsprechende Datenstruktur einlesen sollte. Der Erste ist offensichtlich: Weil man die Laufwerke, Ordner und Dateien oder auch nur Teile davon innerhalb der Datenbank anzeigen möchte, beispielsweise um zu sehen, welche Dateien zu einem bestimmten Projekt oder Kunden gehören. Der erste Schritt auf dem Weg zu einer solchen Anzeige ist das Einlesen der gewünschten Struktur – unabhängig davon, ob man den kompletten Inhalt einer Festplatte in seinen Tabellen abbilden möchte oder auch nur den Inhalt eines Unterverzeichnisses. Zum Einlesen von Laufwerken, Ordnern und Dateien gibt es verschiedene Möglichkeiten auf beiden Seiten. Auf der Seite des Dateisystems können wir mit der Dir-Funktion oder alternativ mit dem FileSystemObject arbeiten, und beim Schreiben in die Tabellen der Datenbank bietet sich unter DAO das Schreiben mit AddNew\/Update oder mit der Execute-Methode an. In diesem Artikel stellen wir die schnellsten Versionen vor, damit das Einlesen umfangreicher Verzeichnis- und Dateistrukturen nicht unnötig lange dauert. <\/b><\/p>\n
Alles oder nur einen Teil einlesen?<\/h2>\n
Technisch haben wir alle Möglichkeiten. Wir können mit den Elementen und Methoden der FileSystemObject<\/b>-Klasse auf alle Laufwerke zugreifen und uns von dort auch durch die einzelnen Verzeichnisse arbeiten und schließlich die darin enthaltenen Dateien ermitteln.<\/p>\n
Das ist jedoch nur bedingt sinnvoll, da die Datenmengen schnell riesig werden und wir den in unserer Datenbank gespeicherten Bestand möglichst synchron mit der Festplatte halten wollen. Das erfordert regelmäßige Aktualisierungen, was jeweils Minuten oder sogar Stunden dauern kann.<\/p>\n
Also entscheiden wir uns bereits an dieser Stelle, immer nur einen Teil des Dateisystems einzulesen – in diesem Fall beginnend mit der Angabe des Verzeichnisses, dessen Inhalte wir erfassen wollen.<\/p>\n
Den Ausgangspunkt für den zu entwickelnden Algorithmus bildet also die Auswahl des Verzeichnisses, dessen Unterelemente wir in unser Datenmodell überführen wollen.<\/p>\n
Um die Struktur des Dateisystems bezüglich des von uns gewählten Ordners in einer Datenbank zu speichern, haben wir ebenfalls mehrere Möglichkeiten.<\/p>\n
Wir können einfach eine Tabelle erstellen, in die wir immer den vollständigen Pfad der Verzeichnisse und Dateien schreiben. Das macht es aber aufwendiger, etwa ein TreeView mit diesen Daten zu füllen.<\/p>\n
Wir müssten uns dann mit vielen Zeichenkettenoperationen durch die einzelnen Verzeichnisebenen eines Pfades arbeiten, was sehr viel Zeit kostet. Außerdem ist es nicht unbedingt sehr platzsparend, wenn wir immer wieder die gleichen übergeordneten Verzeichnisse in einem Datensatz ablegen.<\/p>\n
Also wählen wir die Alternative, die aus einem Satz von drei Tabellen besteht. Hier benötigen wir zunächst eine Tabelle, um die Verzeichnisse zu speichern, beginnend mit den Verzeichnissen der ersten Ebene. Die dazu benötigten Felder lauten beispielsweise FolderID <\/b>und Foldername<\/b>. Damit sind wir allerdings darauf beschränkt, nur Ordnernamen speichern zu können – wir müssen also noch einen Weg finden, die Zuordnung der einzelnen Verzeichnisse zum jeweils übergeordneten Verzeichnis zu markieren.<\/p>\n
Also fügen wir der Tabelle noch ein Feld namens ParentID <\/b>hinzu, mit dem wir für einen Ordner jeweils den Datensatz mit dem übergeordneten Ordner angeben können. Wir speichern also in einer Tabelle sowohl die Ordnernamen als auch die Information über die Hierarchie dieser Ordner.<\/p>\n
Über das Feld ParentID<\/b> erzeugen wir eine reflexive Beziehung der Datensätze der Tabelle auf sich selbst. Schließlich fügen wir der Tabelle, die wir tblFolder <\/b>nennen und deren Entwurf wie in Bild 1 aussieht, noch ein Feld namens UID <\/b>hinzu.<\/p>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2026_01\/pic_1583_001.png\")
<\/p>\n
Bild 1: Tabelle zum Speichern der Ordner<\/span><\/b><\/p>\n In NTFS-Dateisystemen (New Technology File System), die bereits mit Windows 3.1 eingeführt wurden, können wir mit API-Funktionen eine eindeutige ID für Ordner und Dateien ermitteln. Wozu wir diese benötigen und wie wir diese auslesen, erläutern wir später.<\/p>\n Zunächst kümmern wir uns aber um die Tabelle zum Speichern der Dateiinformationen. Diese enthält wiederum ein Primärschlüsselfeld (FileID<\/b>), ein Feld zum Speichern des Dateinamens (Filename<\/b>) sowie ein Feld, mit dem wir die Beziehung zu dem Ordner herstellen, in dem sich die Datei befindet, und die wir wiederum ParentID <\/b>nennen. Außerdem fügen wir auch hier ein Feld namens UID für den eindeutigen Identifizierer für die Datei sowie zwei Felder zum Speichern der Dateigröße und des Anlage- beziehungsweise letzten Änderungsdatums hinzu (siehe Bild 2).<\/p>\n Bild 2: Tabelle zum Speichern der Dateien<\/span><\/b><\/p>\n Schließlich fügen wir im Beziehungen-Fenster noch die notwendigen Beziehungen hinzu (siehe Bild 3). Hier ziehen wir zunächst die Tabelle tblFolder<\/b> zwei Mal hinein und erstellen eine Beziehung des Feldes ParentID<\/b> des im Beziehungen-Fenster mit tblFolders_1 <\/b>benannten zweiten Exemplars der Tabelle tblFolders <\/b>zu dem mit tblFolder <\/b>benannten Exemplar. Damit realisieren wir die Beziehung von Unterordnern zum übergeordneten Ordner. Außerdem ziehen wir noch einen Beziehungspfeil vom Feld ParentID <\/b>der Tabelle tblDateien <\/b>zum Feld FolderID <\/b>der Tabelle tblFolders<\/b>.<\/p>\n Bild 3: Beziehungen zwischen den Tabellen<\/span><\/b><\/p>\n Die intuitive Vorgehensweise zum Einlesen der Ordner und Dateien des gewünschten Ordners würde sich nach dem Aufbau des Dateisystems und unserer Tabellenstruktur richten.<\/p>\n Wir würden also etwa die Klassen und Methoden der FileSystemObject<\/b>-Klasse nutzen, um ausgehend vom Basisordner zunächst die darin enthaltenen Ordner einzulesen und in die Tabelle tblOrdner <\/b>zu schreiben. Beim Durchlaufen dieser Ordner würden wir in einer rekursiven Prozedur die untergeordneten Ordner und die Dateien dieses Ordners einlesen und so weiter.<\/p>\n Diese Vorgehensweise ist jedoch nicht schnell genug. Beim Einlesen umfangreicher Ordnerstrukturen wollen wir schließlich nicht ewig warten. Deshalb wählen wir hier einen alternativen Ansatz, der allerdings etwas komplexer ist und wie in Listing 1 beginnt.<\/p>\n Listing 1: Die Prozedur OrdnerstrukturEinlesen (Teil 1)<\/span><\/b><\/p>\n Was macht die Prozedur OrdnerUndDateienEinlesen <\/b>überhaupt?<\/p>\n Danach können wir mit diesen Tabellen bequem arbeiten, zum Beispiel zum Füllen eines TreeView<\/b>-Steuerelements.<\/p>\n Die Prozedur bekommt mit dem Parameter strRoot <\/b>einen Startpfad. Als Erstes deklarieren wir die Variablen:<\/p>\n Zu Beginn speichern wir den aktuellen Timer-Wert in lngTimer<\/b>, um später die Gesamtzeit für den Vorgang ausgeben zu können. Außerdem schneiden wir vom Root-Ordner in strRoot <\/b>noch ein eventuell am Ende befindliches Backslash-Zeichen ab, falls dieses noch vorhanden ist.<\/p>\n Danach initialisieren wir die Workspace<\/b>-Variable wrk<\/b> und die Database<\/b>-Variable db<\/b>. Das Workspace<\/b>-Objekt benötigen wir, weil wir damit die vielen Anlegevorgänge in einer Transaktion bündeln können, was wesentlich schneller funktioniert, als wenn wir jeden Vorgang einzeln durchführen.<\/p>\n Danach rufen wir die Prozedur TabellenZuruecksetzen <\/b>auf. Diese löscht nicht nur einfach die Daten, sondern fügt zuvor einen neuen Datensatz in die beiden Tabellen tblFolders <\/b>und tblFiles <\/b>ein, der im Primärschlüsselfeld den Wert 0 <\/b>enthält. Damit setzen wir den Autowert der beiden Tabellen zurück, sodass beim Neuanlegen von Datensätzen nachfolgend wieder mit dem Wert 1 <\/b>gestartet wird. Anschließend löschen wir alle Datensätze aus diesen beiden Tabellen:<\/p>\n Danach öffnen wir zwei Recordsets: rstFolders <\/b>für die Ordner und rstFiles <\/b>für die Dateien. Außerdem legen wir ein Collection<\/b>-Objekt namens colToDo <\/b>an, mit dem wir noch zu bearbeitende Ordner speichern.<\/p>\n Hier legen wir als Erstes den Startordner aus dem Parameter strRoot <\/b>mit dem Wert 0 <\/b>ab. Das geschieht in einer weiteren Hilfsprozedur namens TodoAdd<\/b>.<\/p>\n Dieser übergeben wir das Collection<\/b>-Objekt, den Pfad und die ID des übergeordneten Ordners als Parameter.<\/p>\n Wir fügen der Collection dann einen Eintrag hinzu, der aus der ID des übergeordneten Ordners, dem Pipe-Zeichen (|<\/b>) und dem Pfad besteht. Im ersten Aufruf tragen wir also den Wert 0|[Pfad] <\/b>ein:<\/p>\n Der Wert 0 <\/b>bedeutet in diesem Fall, dass es keinen übergeordneten Ordner gibt.<\/p>\n Da dieser erste Ordner eine Spezialbehandlung erfahren soll, stellen wir außerdem die Variable bolIsRoot <\/b>auf True <\/b>ein.<\/p>\n Schließlich deaktivieren wir die Bildschirmaktualisierung mit DoCmd.Echo False <\/b>und aktivieren die Sanduhr mit DoCmd.Hourglass True<\/b>.<\/p>\n Nun starten wir die Transaktion und integrieren die Fehlerbehandlung (siehe Listing 2).<\/p>\n Listing 2: Die Prozedur OrdnerstrukturEinlesen (Teil 2)<\/span><\/b><\/p>\n Anschließend starten wir eine Do While<\/b>-Schleife, in der wir alle Elemente der Collection colToDo <\/b>durchlaufen. Die Informationen aus der Collection holen wir uns mit der Hilfsfunktion ToDoPop<\/b>:<\/p>\n Sie schreibt den ersten Eintrag der Collection in die Variant<\/b>-Variable v <\/b>und entfernt dieses Element aus der Collection.<\/p>\n Dann liest sie die Position des Pipe-Zeichens mit der InStr<\/b>-Funktion aus und schreibt anschließend den Teil vor dem Pipe-Zeichen in den Rückgabeparameter lngParentID <\/b>und den Teil dahinter in den Rückgabeparameter strPfad<\/b>.<\/p>\n Danach prüfen wir, ob der Pfad einen abschließenden Backslash enthält, und fügen diesen gegebenenfalls an.<\/p>\n Nun folgt in einer If…Then<\/b>-Bedingung die Unterscheidung, ob wir gerade mit dem Root-Ordner arbeiten (bolIsRoot <\/b>ist dann True<\/b>) oder ob wir bereits in einer untergeordneten Ebene gelandet sind.<\/p>\n Im Falle des Root-Ordners tragen wir lediglich den Wert 0 <\/b>in die Variable lngCurrentFolderID <\/b>ein und setzen bolIsRoot <\/b>auf False<\/b>.<\/p>\n Falls wir bereits einen untergeordneten Ordner bearbeiten, speichern wir diesen direkt in der Tabelle tblFolders<\/b>. Dazu rufen wir die AddNew<\/b>-Methode von rstFolders <\/b>auf und tragen die Werte ein. Für das Feld FolderName <\/b>ermitteln wir den letzten Teil des Pfads mit der Funktion GetFolderNameFromPath<\/b>, die wie folgt aussieht:<\/p>\n Die Funktion erhält den Pfad aus strPfad <\/b>als Parameter und entfernt zunächst ein eventuell vorhandenes abschließendes Backslash-Zeichen.<\/p>\n Dann lesen wir den Teil des Pfades hinter dem letzten vorhandenen Backslash-Zeichen ein und geben diesen als Funktionsergebnis zurück.<\/p>\n Außerdem tragen wir die FolderID <\/b>des übergeordneten Ordners in das Feld ParentID <\/b>und die eindeutige ID des Ordners aus dem NTFS-System in das Feld UID.<\/p>\n Diese ermitteln wir mit der Funktion GetFileID<\/b>, die wir weiter unten beschreiben. <\/p>\n In der Variablen lngCurrentFolderID <\/b>speichern wir schließlich den Primärschlüsselwert des neuen Datensatzes. Diesen benötigen wir, um weitere untergeordnete Ordner- und Dateidatensätze mit dem angelegten Eintrag in tblFolders <\/b>verknüpfen zu können.<\/p>\n Nun holen wir uns mit der Dir<\/b>-Funktion den ersten Unterordner des Ordners aus strPfad<\/b>. Damit Dir <\/b>tatsächlich nur Ordner liefert und keine Dateien, geben wir als zweiten Parameter den Wert vbDirectory <\/b>an.<\/p>\n Wenn die so befüllte Variable strEintrag <\/b>keine leere Zeichenkette enthält, steigen wir in die folgende Do While<\/b>-Schleife ein, die genau dies als Abbruchkriterium nutzt.<\/p>\n Sollte der von Dir <\/b>gelieferte Wert einen oder zwei Punkte enthalten, handelt es sich um Platzhalter für das aktuelle Verzeichnis oder für das Elternverzeichnis. Diese beiden ignorieren wir durch eine If…Then<\/b>-Bedingung.<\/p>\n Ist strEintrag <\/b>aber ungleich „.“<\/b> oder „..“<\/b>, schreiben wir den aktuellen Pfad aus strPfad <\/b>plus den gefundenen Ordner durch einen Backslash getrennt in die Variable strVollPfad<\/b>. Außerdem ermitteln wir mit GetFileID <\/b>die eindeutige ID dieses Verzeichnisses und tragen diese in strUID <\/b>ein. Wenn wir die ID ermitteln konnten, was zum Beispiel bei temporären Ordnern oder Dateien nicht gelingt, schreiben wir das Ergebnis der Funktion GetAttr <\/b>in die Variable lngAttr<\/b>.<\/p>\n Wir prüfen in einer weiteren If…Then<\/b>-Bedingung, ob der in lngAttr <\/b>gespeicherte Wert die Konstante vbDirectory <\/b>enthält. In diesem Fall rufen wir erneut die Prozedur TodoAdd <\/b>auf und fügen damit das Verzeichnis aus strVollpfad <\/b>und die ID des aktuellen Ordners aus lngCurrentFolderID <\/b>als neuen Eintrag zur Collection colTodo<\/b> hinzu.<\/p>\n Falls es sich nicht um ein Verzeichnis handelt, legen wir mit der AddNew<\/b>-Methode einen neuen Datensatz in der Tabelle tblFiles <\/b>an. Dabei füllen wir die Felder FileName <\/b>mit dem Wert aus strEintrag<\/b>, ParentID<\/b> mit dem Wert aus lngCurrentFolderID <\/b>und UID <\/b>mit der eindeutigen Datei-ID aus strUID<\/b>.<\/p>\n Außerdem ermitteln wir mit den VBA-Funktionen FileLen <\/b>und FileDateTime <\/b>noch die Werte für die Felder Filesize <\/b>und FileDateTime<\/b>. Danach speichern wir den Datensatz und erhöhen den Wert der Variablen lngCounter<\/b>, mit der wir die hinzugefügten Dateien zählen, um 1<\/b>.<\/p>\n Schließlich beenden wir den Schleifendurchlauf, indem wir uns mit einem erneuten Aufruf der Dir<\/b>-Funktion das nächste Element aus dem aktuellen Ordner holen – also das nächste Verzeichnis oder die nächste Datei, mit der wir dann in den nächsten Schleifendurchlauf starten.<\/p>\n Zusammengefasst: Wir durchlaufen alle Elemente des aktuellen Ordners, fügen für die enthaltenen Dateien jeweils einen neuen Datensatz zur Tabelle tblFiles <\/b>hinzu und legen die gefundenen Ordner als neue Elemente in der Collection colToDo <\/b>an, die wir anschließend abarbeiten.<\/p>\n Nach jeweils 5.000 Einträgen beenden wir jeweils die aktuelle Transaktion mit der Commit<\/b>-Methode, was die angesammelten Anfügungen ausführt, und starten mit BeginTrans <\/b>eine neue Transaktion (siehe Listing 3).<\/p>\n Listing 3: Die Prozedur OrdnerstrukturEinlesen (Teil 3)<\/span><\/b><\/p>\n Wenn die Collection colTodo<\/b> an dieser Stelle leer ist, ist das Einlesen erledigt, anderenfalls startet die äußere Do While<\/b>-Schleife erneut mit dem nächsten Verzeichnis, das wir uns wieder mit TodoPop <\/b>aus der Collection holen.<\/p>\n Sind keine Einträge mehr in colToDo <\/b>enthalten, schließen wir die Transaktion mit CommitTrans <\/b>ab.<\/p>\n Schließlich landen wir unter der Sprungmarke Aufraeumen<\/b> beim Abschluss der Prozedur. Hier tragen wir die Anzahl der gelesenen Dateien, den Zeitpunkt des Abschlusses und die verbrauchte Zeit in die Tabelle tblLogs <\/b>ein, die im Entwurf wie in Bild 4 aussieht.<\/p>\n Bild 4: Tabelle zum Loggen der Einlesevorgänge<\/span><\/b><\/p>\n Dies haben wir zum Beispiel genutzt, um die Dauer verschiedener Varianten zu testen, wie zum Beispiel mit und ohne Transaktionen, mit AddNew <\/b>oder INSERT INTO <\/b>und so weiter.<\/p>\n Danach geben wir eine Erfolgsmeldung aus, schließen alle geöffneten Objekte und leeren die Objektvariablen.<\/p>\n Schließlich kommt noch die Sprungmarke Fehler<\/b>, zu der wir im Falle eines Laufzeitfehlers gelangen. Hier geben wir eine Fehlermeldung aus und machen die letzte Transaktion mit Rollback <\/b>rückgängig.<\/p>\n Damit kommen wir zum ersten Test. Wir übergeben der Prozedur OrdnerUndDateienEinlesen <\/b>den Pfad zu dem Ordner, dessen Unterordner und Dateien wir einlesen wollen, zum Beispiel:<\/p>\n Danach liest die Prozedur die enthaltenen Unterordner und Dateien ein und präsentiert dann eine Meldung mit der Anzahl der eingelesenen Dateien. Außerdem trägt sie einen neuen Datensatz in die Tabelle tblLogs <\/b>ein (siehe Bild 5).<\/p>\n Bild 5: Geloggte Einlesevorgänge<\/span><\/b><\/p>\n Wir haben uns einen kleinen Verzeichnisbaum mit einer Hilfsprozedur erstellt, die wie in Listing 4 aussieht.<\/p>\n Listing 4: Prozedur zum Erstellen einer Beispielhierarchie im aktuellen Datenbankordner<\/span><\/b><\/p>\n Diese legt im aktuellen Datenbankverzeichnis einen Ordner namens Test an und dort zwei Ebenen von Unterordnern plus einigen Dateien. Das Ergebnis sehen wir in Bild 6.<\/p>\n Bild 6: Beispielordner mit Unterordnern und Dateien<\/span><\/b><\/p>\n Wenn wir den Ordner Test samt Pfad als Parameter der Prozedur OrdnerUndDateienEinlesen<\/b> übergeben, erhalten wir die entsprechenden Einträge in den beiden Tabellen. In der Tabelle ![\"Tabelle](\"..\/fileadmin\/_temp_\/2026_01\/pic_1583_002.png\")
<\/p>\n![\"Beziehungen](\"..\/fileadmin\/_temp_\/2026_01\/pic_1583_004.png\")
<\/p>\nEinlesen der Ordner und Dateien<\/h2>\n
Public Sub <\/span>OrdnerUndDateienEinlesen(ByVal strRoot As String<\/span>)\r\n Dim <\/span>wrk As <\/span>DAO.Workspace\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstFolders As <\/span>DAO.Recordset\r\n Dim <\/span>rstFiles As <\/span>DAO.Recordset\r\n Dim <\/span>colTodo As <\/span>Collection\r\n Dim <\/span>strPfad As String<\/span>\r\n Dim <\/span>strEintrag As String<\/span>\r\n Dim <\/span>strVollPfad As String<\/span>\r\n Dim <\/span>lngAttr As Long<\/span>\r\n Dim <\/span>lngCounter As Long<\/span>\r\n Dim <\/span>strUID As String<\/span>\r\n Dim <\/span>lngParentID As Long<\/span>\r\n Dim <\/span>lngCurrentFolderID As Long<\/span>\r\n Dim <\/span>lngTimer As Long<\/span>\r\n Dim <\/span>booIsRoot As Boolean<\/span>\r\n \r\n lngTimer = Timer\r\n \r\n If <\/span>Right$(strRoot, 1) = \"\\\" Then<\/span>\r\n strRoot = Left$(strRoot, Len<\/span>(strRoot) - 1)\r\n End If<\/span>\r\n \r\n Set<\/span> wrk = DBEngine(0)\r\n Set<\/span> db = wrk.Databases(0)\r\n \r\n Call<\/span> TabellenZuruecksetzen(db)\r\n \r\n Set<\/span> rstFolders = db.OpenRecordset(\"tblFolders\", dbOpenDynaset)\r\n Set<\/span> rstFiles = db.OpenRecordset(\"tblFiles\", dbOpenDynaset)\r\n Set<\/span> colTodo = New<\/span> Collection\r\n Call<\/span> TodoAdd(colTodo, strRoot, 0)\r\n bolIsRoot = True<\/span>\r\n DoCmd.Echo False<\/span>\r\n DoCmd.Hourglass True<\/span>\r\n wrk.BeginTrans\r\n On Error GoTo<\/span> Fehler\r\n ...<\/pre>\n\n
Die Prozedur OrdnerUndDateienEinlesen Schritt für Schritt erklärt<\/h2>\n
\n
Workspace und Transaktion für schnelleres Schreiben<\/h2>\n
Tabellen zurücksetzen und leeren<\/h2>\n
Public Sub <\/span>TabellenZuruecksetzen(db As <\/span>DAO.Database)\r\n db.Execute _\r\n \"INSERT INTO tblFiles(FileID, Filename) \" _\r\n & \"VALUES(0, '''')\", dbFailOnError\r\n db.Execute _\r\n \"INSERT INTO tblFolders(FolderID, Foldername) \" _\r\n & \"VALUES(0, '''')\", dbFailOnError\r\n \r\n db.Execute \"DELETE FROM tblFiles\", dbFailOnError\r\n db.Execute \"DELETE FROM tblFolders\", dbFailOnError\r\nEnd Sub<\/span><\/pre>\nWeitere Initialisierungen<\/h2>\n
Private Sub <\/span>TodoAdd(ByRef col As <\/span>Collection, _\r\n ByVal strPfad As String<\/span>, ByVal lngParentID As Long<\/span>)\r\n col.Add CStr(lngParentID) & \"|\" & strPfad\r\nEnd Sub<\/span><\/pre>\nStarten der Transaktion und der Do While-Schleife<\/h2>\n
...\r\n Do While<\/span> colTodo.Count > 0\r\n Call<\/span> TodoPop(colTodo, strPfad, lngParentID)\r\n If <\/span>Right$(strPfad, 1) <> \"\\\" Then<\/span>\r\n strPfad = strPfad & \"\\\"\r\n End If<\/span>\r\n If <\/span>Not<\/span> bolIsRoot Then<\/span>\r\n rstFolders.AddNew<\/span>\r\n rstFolders!FolderName = GetFolderNameFromPath(strPfad)\r\n If <\/span>lngParentID > 0 Then<\/span>\r\n rstFolders!ParentID = lngParentID\r\n Else<\/span>\r\n rstFolders!ParentID = Null\r\n End If<\/span>\r\n rstFolders!UID = GetFileID(strPfad)\r\n lngCurrentFolderID = rstFolders!FolderID\r\n \r\n rstFolders.Update\r\n Else<\/span>\r\n lngCurrentFolderID = 0\r\n bolIsRoot = False<\/span>\r\n End If<\/span>\r\n strEintrag = Dir$(strPfad & \"*\", vbDirectory)\r\n Do While<\/span> strEintrag <> \"\"\r\n If <\/span>strEintrag <> \".\" And strEintrag <> \"..\" Then<\/span>\r\n strVollPfad = strPfad & strEintrag\r\n strUID = GetFileID(strVollPfad)\r\n If <\/span>Len<\/span>(strUID) > 0 Then<\/span>\r\n lngAttr = GetAttr(strVollPfad)\r\n If <\/span>(lngAttr And vbDirectory) = vbDirectory Then<\/span>\r\n Call<\/span> TodoAdd(colTodo, strVollPfad, lngCurrentFolderID)\r\n Else<\/span>\r\n rstFiles.AddNew<\/span>\r\n rstFiles!FileName = strEintrag\r\n rstFiles!ParentID = lngCurrentFolderID\r\n rstFiles!UID = strUID\r\n rstFiles!Filesize = FileLen<\/span>(strVollPfad)\r\n rstFiles!FileDateTime = FileDateTime(strVollPfad)\r\n rstFiles.Update\r\n lngCounter = lngCounter + 1\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n strEintrag = Dir$()\r\n Loop<\/span>\r\n ...<\/pre>\nPrivate Sub <\/span>TodoPop(ByRef col As <\/span>Collection, _\r\n ByRef strPfad As String<\/span>, ByRef lngParentID As Long<\/span>)\r\n Dim <\/span>v As Variant<\/span>\r\n Dim <\/span>p As Long<\/span>\r\n \r\n v = col(1)\r\n col.Remove 1\r\n \r\n p = InStr<\/span>(1, v, \"|\")\r\n lngParentID = CLng(Left$(v, p - 1))\r\n strPfad = Mid$(v, p + 1)\r\nEnd Sub<\/span><\/pre>\nOrdner in tblFolders eintragen<\/h2>\n
Private Function <\/span>GetFolderNameFromPath( _\r\n ByVal strPfad As String<\/span>) As String<\/span>\r\n If <\/span>Right$(strPfad, 1) = \"\\\" Then<\/span>\r\n strPfad = Left$(strPfad, Len<\/span>(strPfad) - 1)\r\n End If<\/span>\r\n GetFolderNameFromPath = _\r\n Mid$(strPfad, InStrRev<\/span>(strPfad, \"\\\") + 1)\r\nEnd Function<\/span><\/pre>\nDateien und Unterordner des aktuellen Ordners einlesen<\/h2>\n
Transaktion zwischendurch beenden und neu starten<\/h2>\n
...\r\n If <\/span>lngCounter > 0 And lngCounter Mod<\/span> 5000 = 0 Then<\/span>\r\n wrk.CommitTrans\r\n wrk.BeginTrans\r\n End If<\/span>\r\n Loop<\/span>\r\n wrk.CommitTrans\r\nAufraeumen:\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblLogs(AnzahlEintraege, Logdatum, Dauer) VALUES (\" & lngCounter & \", \" _\r\n & ISODatum(Now) & \", \" & Replace<\/span>(Timer - lngTimer, \",\", \".\") & \")\", dbFailOnError\r\n MsgBox<\/span> \"Fertig. \" & lngCounter & \" Dateien erfasst.\", vbInformation\r\n If <\/span>Not<\/span> rstFiles Is Nothing Then<\/span>\r\n rstFiles.Close\r\n End If<\/span>\r\n If <\/span>Not<\/span> rstFolders Is Nothing Then<\/span>\r\n rstFolders.Close\r\n End If<\/span>\r\n Set<\/span> rstFiles = Nothing\r\n Set<\/span> rstFolders = Nothing\r\n Set<\/span> db = Nothing\r\n Set<\/span> colTodo = Nothing\r\n DoCmd.Echo True<\/span>\r\n Exit Sub<\/span>\r\nFehler:\r\n MsgBox<\/span> \"Fehler: \" & Err.Number & \" - \" & Err.Description, vbExclamation\r\n wrk.Rollback\r\n Resume Aufraeumen\r\nEnd Sub<\/span><\/pre>\nAufräumen, loggen und Meldung ausgeben<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2026_01\/pic_1583_003.png\")
<\/p>\nEinlesen der Ordner und Dateien<\/h2>\n
Dim <\/span>strRoot As String<\/span>\r\nstrRoot = \"C:\\Users\\User\\Test\"\r\nCall<\/span> OrdnerstrukturEinlesen(strRoot)<\/pre>\n![\"Geloggte](\"..\/fileadmin\/_temp_\/2026_01\/pic_1583_005.png\")
<\/p>\nPublic Sub <\/span>BeispieldateienUndOrdner()\r\n Dim <\/span>i As Integer<\/span>, j As Integer<\/span>, f As Integer<\/span>, k As Integer<\/span>\r\n Dim <\/span>strBasis As String<\/span>, strFile As String<\/span>\r\n \r\n strBasis = CurrentProject.Path & \"\\Test\\\"\r\n \r\n On Error Resume Next<\/span>\r\n Kill strBasis & \"*\"\r\n On Error GoTo<\/span> 0\r\n \r\n For i = 1 To 3\r\n MkDir strBasis & \"\\Dir\" & Format(i, \"00\")\r\n For k = 1 To 3\r\n f = FreeFile\r\n strFile = strBasis & \"\\Dir\" & Format(i, \"00\") & \"\\Test\" & Format(i, \"00\") & Format(k, \"00\") & \".txt\"\r\n Open strFile For Output As <\/span>#f\r\n Print #f, \"Hallo Welt\"\r\n Close #f\r\n Next<\/span> k\r\n For j = 1 To 3\r\n MkDir strBasis & \"\\Dir\" & Format(i, \"00\") & \"\\Dir\" & Format(i, \"00\") & Format(j, \"00\")\r\n For k = 1 To 3\r\n f = FreeFile\r\n strFile = strBasis & \"\\Dir\" & Format(i, \"00\") & \"\\Dir\" & Format(i, \"00\") & Format(j, \"00\") & \"\\Test\" _\r\n & Format(i, \"00\") & Format(j, \"00\") & Format(k, \"00\") & \".txt\"\r\n Open strFile For Output As <\/span>#f\r\n Print #f, \"Hallo Welt\"\r\n Close #f\r\n Next<\/span> k\r\n Next<\/span> j\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n![\"Beispielordner](\"..\/fileadmin\/_temp_\/2026_01\/pic_1583_006.png\")
<\/p>\n