<\/p>\n
Der Import-Assistent für Excel-Dateien hat einen entscheidenden Nachteil: Er erlaubt nicht, den zu importierenden Bereich des ausgewählten Tabellenblatts manuell auszuwählen. Diese Aufgabe müssen Sie vorher direkt in Excel erledigen, indem Sie einen sogenannten „benannten Bereich“ definieren. Dieser ist dann im Import-Assistenten namentlich verfügbar. Unser Assistent enthält eine solche Funktion, und generell lernt man eine Menge, wenn man sich die Funktionsweise eines Excel-Imports einmal in Ruhe ansieht.<\/b><\/p>\n
Der eingebaute Import-Assistent unterscheidet prinzipiell zwischen dem Importieren von Daten aus Excel in eine neue und in eine bestehende Tabelle. In technischer Hinsicht ist der Unterschied schnell beschrieben: Beim Erstellen einer neuen Tabelle muss zuvor eine entsprechende SQL-Aktionsabfrage ausgeführt werden, die mit den DDL-Befehlen von SQL eine passende, leere Tabelle erzeugt.<\/p>\n
Importieren in eine bestehende Tabelle<\/b><\/p>\n
Der Import-Assistent von Access 2007, der sich nur in Details von denen vorheriger Access-Versionen unterscheidet, gibt dem Benutzer gleich auf der ersten Dialogseite die Gelegenheit, die gewünschte Quelldatei auszuwählen und anzugeben, ob die Daten in einer bestehenden oder in einer neuen Tabelle landen sollen.<\/p>\n
Bei einer bestehenden Tabelle reduzieren sich die folgenden Schritte darauf, die Zieltabelle auszuwählen und das als Quelle zu verwendende Tabellenblatt oder den entsprechenden benannten Bereich auszuwählen – der Rest läuft automatisch ab, und das auch nur, wenn dabei kein Fehler auftritt. Hier gibt es Nachbesserungsbedarf, den unser Assistent liefern soll: Wir möchten zumindest die Möglichkeit bieten, dass der Benutzer für jede Spalte des betroffenen Bereichs der Excel-Tabelle das entsprechende Feld der Zieltabelle zuordnen kann.<\/p>\n
Importieren in eine neue Tabelle<\/b><\/p>\n
Hier bietet der eingebaute Import-Assistent von Access schon deutlich mehr Möglichkeiten:<\/p>\n
ExcelImport.mda<\/p>\n
Der im Rahmen dieses Beitrags erstellte Assistent soll den Import in bestehende und neu erstellte Tabellen ermöglichen. Dabei soll er den Import in bestehende Tabellen insofern erweitern, dass der Benutzer zunächst den Bereich festlegt, aus dem die Daten importiert werden sollen.<\/p>\n
Dies soll innerhalb des Formulars des Import-Assistenten geschehen, das (sichtbare) Öffnen einer Excel-Instanz soll unbedingt vermieden werden.<\/p>\n
Diese Funktion soll auch in dem Bereich des Assistenten zur Verfügung stehen, der Excel-Daten in neue Tabellen importiert.<\/p>\n
Für den Import in bestehende Tabellen soll der neue Assistent es außerdem erlauben, den Spalten der Quelldatei Felder der Zieltabelle zuzuweisen, damit die Daten auch dort landen, wo sie hingehören. Der Aufbau der Zieltabelle muss somit nicht identisch mit dem des Excel-Tabellenblatts sein, aus dem die Daten stammen.<\/p>\n
Grundsätzliche Vorgehensweise<\/b><\/p>\n
Beim neuen Import-Assistenten für Excel-Daten soll der Import in neue und bestehende Tabellen ähnlich aufgebaut sein. Der Benutzer wählt die Excel-Datei und das Tabellenblatt aus, aus dem die Daten importiert werden sollen. Der Assistent zeigt dann das komplette Tabellenblatt an und bietet dem Benutzer die Möglichkeit, den zu importierenden Bereich gleich im Assistenten auszuwählen.<\/p>\n
Genau wie im eingebauten Assistenten kann er dabei festlegen, ob die Daten mit oder ohne Spaltenüberschriften importiert werden sollen. Im Anschluss legt der Benutzer für die einzelnen Spalten fest, wie der Feldname in der Zieltabelle heißt.<\/p>\n
Beim Import in eine bestehende Tabelle kann er zwischen den vorhandenen Feldern wählen. Soll der Assistent die Daten hingegen in eine neue Tabelle schreiben, gibt der Benutzer die Namen der Felder an, wobei gegebenenfalls die Spaltenüberschriften als Standardwert dienen.<\/p>\n
Beim Import in eine neue Tabelle muss der Benutzer außerdem den Datentyp für jedes Zielfeld festlegen und angeben, ob das Feld indiziert werden soll. Zuletzt legt der Benutzer beim Import in eine neue Tabelle noch fest, welches der Felder als Primärschlüsselfeld dienen soll.<\/p>\n
Alternativ kann er angeben, dass er gar kein Primärschlüsselfeld wünscht oder dass der Assistent ein von den zu importierenden Daten unabhängiges Primärschlüsselfeld zur Tabelle hinzufügen soll.<\/p>\n
Resultat des Assistenten<\/b><\/p>\n
Ein Ergebnis des Assistenten soll natürlich der erfolgreiche Import der gewünschten Daten in die Zieltabelle sein. Technisch betrachtet steckt die Hauptarbeit auf diesem Wege aber darin, dem Benutzer folgende Arbeiten abzunehmen, die wiederum von der Importart abhängen:<\/p>\n
Aufbau des Assistenten-Formulars<\/b><\/p>\n
Wir wollen den Excel-Import-Assistenten so wie klassische Assistenten aufbauen. Der Benutzer soll damit also mehrere Schritte durchlaufen können und dabei die benötigten Daten zusammenstellen. Um dem Benutzer das Gefühl zu geben, dass er die ganze Zeit mit einem einzigen Formular arbeitet, verwenden wir einfach ein einziges Formular – zumindest als Hauptformular.<\/p>\n
Die einzelnen Schritte des Assistenten laufen natürlich in verschiedenen Unterformularen ab, die je nach dem Fortschritt ein- und ausgeblendet werden. Das Hauptformular sieht etwa wie in Bild 1 aus. Es enthält vier Schaltflächen namens cmdAbbrechen<\/b>, cmdZurueck<\/b>, cmdWeiter <\/b>und cmdFertigstellen <\/b>sowie ein Unterformularsteuerelement namens sfmExcelImportWizard<\/b>. Die Beschriftungen beginnen jeweils mit einem Kaufmanns-Und (&), damit der erste Buchstabe unterstrichen dargestellt wird und die Schaltfläche durch die Kombination aus Alt<\/b>-Schaltfläche und unterstrichenem Buchstaben über die Tastatur angesteuert werden kann.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic001_opt.jpeg\")
<\/p>\n
Bild 1: Das Grundgerüst des Excel-Import-Assistenten<\/span><\/b><\/p>\n Desweiteren enthält das Formular ein Unterformular-Steuerelement namens sfmExcelImportWizard<\/b>, das die eigentlichen Elemente der Benutzeroberfläche des Assistenten liefert.<\/p>\n Die Größe des Hauptformulars und vor allem des Unterformularsteuerelements werden wir sicher in den folgenden Schritten noch anpassen müssen, weil etwa das Formular zur Auswahl des Bereichs der zu importierenden Excel-Datei etwas mehr Platz in Anspruch nehmen wird.<\/p>\n Stellen Sie für alle Formulare und Unterformulare die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>grundsätzlich auf Nein <\/b>ein. Außerdem soll die Eigenschaft Rahmenart <\/b>des Unterformulars den Wert Transparent <\/b>erhalten.<\/p>\n Schritt 1: Auswählen der Quelldatei<\/b><\/p>\n Egal, ob der Import in eine vorhandene oder eine neue Tabelle erfolgen soll, muss der Benutzer zunächst die Excel-Datei und dort das Tabellenblatt auswählen, aus dem die Daten für den Import stammen. Dateipfad und -name sollen in einem Textfeld namens txtExcelDatei <\/b>landen, allerdings nicht durch eine manuelle Eingabe des Benutzers. Vielmehr soll dieser auf eine Schaltfläche rechts neben dem Textfeld mit dem Dateinamen klicken, um einen Datei öffnen<\/b>-Dialog anzuzeigen und damit die Quelldatei auszuwählen.<\/p>\n Nach Auswahl der Datei zeigt das darunter befindliche Kombinationsfeld cboTabellenblaetter <\/b>alle in der ausgewählten Excel-Datei enthaltenen Tabellenblätter an. Das Unterformular für diesen ersten Schritt des Assistenten heißt sfmDateiUndBlatt <\/b>und sieht bislang wie in Bild 2 aus.<\/p>\n Bild 2: Auswählen der Quelldatei und des Tabellenblatts<\/span><\/b><\/p>\n Die Schaltfläche zum Auswählen der Excel-Datei heißt cmdDateiAuswaehlen <\/b>und ihre Ereigniseigenschaft Beim Klicken <\/b>löst die Ereignisprozedur aus Listing 1 aus. Diese ruft die bereits oft in Beiträgen von Access im Unternehmen <\/b>verwendete Funktion zum Anzeigen eines Datei öffnen<\/b>-Dialogs auf (s. Beispieldatenbank, Modul mdlTools<\/b>, Funktion OpenFileName<\/b>) und schreibt das Ergebnis in das Textfeld txtExcelDatei<\/b>.<\/p>\n Listing 1: Auswählen der Quelldatei und Füllen und Öffnen des Kombinationsfelds zur Auswahl des Tabellenblatts<\/p>\n Anschließend geschehen noch weitere Aktionen: Zunächst ruft die Prozedur eine Funktion namens TabellennamenEinlesen <\/b>auf und schreibt das Ergebnis, das etwa in der Form Tabelle1;Tabelle2;Tabelle3; <\/b>kommt, in die Eigenschaft RowSource <\/b>des Kombinationsfelds, dessen Herkunftstyp zuvor über die Eigenschaft RowSourceType <\/b>auf Wertliste <\/b>eingestellt wurde. <\/p>\n Die vorletzte Anweisung setzt den Fokus auf das Kombinationsfeld, was lediglich eine Voraussetzung für den letzten Befehl ist – und dieser klappt das Kombinationsfeld mit der DropDown<\/b>-Methode auf. So kann der Benutzer gleich mit einem Mausklick das Quelltabellenblatt festlegen.<\/p>\n Die Funktion TabellennamenEinlesen <\/b>erwartet den Dateinamen der Excel-Datei als Parameter und liefert die oben beschriebene, durch Semikola getrennte Auflistung zurück. Den Quelltext dieser Funktion finden Sie in Listing 2. Die Funktion greift ohne Umschweife auf ein Objekt namens objWorkbook<\/b> zu, obwohl dieses zuvor noch gar nicht deklariert oder instanziert und auch nicht per Parameter übergeben wurde.<\/p>\n Listing 2: Diese Funktion liefert eine Liste der in der angegebenen Excel-Datei enthaltenen Tabellenblätter zurück.<\/p>\n Da wir im Rahmen des Assistenten möglichst nur eine Excel-Instanz erstellen und auch die Quelldatei für den Import nur einmal öffnen möchten, verwenden wir einige globale Funktionen, welche die benötigten Objekte bei Bedarf erstmalig erzeugen und diese anschließend jederzeit bereitstellen.<\/p>\n All diese finden Sie wie auch die Funktion TabellennamenEinlesen<\/b> im Modul mdlExcel<\/b>. Dort sind auch zwei Objektvariablen für die Excel-Instanz und für das Workbook deklariert:<\/p>\n Für den einfachen Zugriff auf das Objektmodell von Excel benötigen wir zunächst einen Verweis auf die entsprechende Objektbibliothek (siehe Bild 3).<\/p>\n Bild 3: Festlegen eines Verweises auf die Excel-Objektbibliothek<\/span><\/b><\/p>\n Die Deklaration der Variablen m_Excel <\/b>und m_Workbook<\/b> erfolgt privat, weil der Zugriff nur über entsprechende Funktionen möglich sein soll, die gleichzeitig prüfen, ob bereits Instanzen von Excel und der Importdatei bestehen. Die Excel-Instanz liefert die folgende Funktion:<\/p>\n Sie prüft zunächst, ob die private Variable m_Excel <\/b>bereits einmal mit einer Excel-Instanz gefüllt wurde und holt dies gegebenenfalls nach. Die vorhandene oder neu erstellte Instanz wird dann als Funktionswert zurückgegeben.<\/p>\n ähnlich arbeitet die Funktion objWorkbook<\/b>. Sie füllt die zuständige Variable m_Workbook <\/b>jedoch in zwei Fällen neu – erstens, wenn diese noch komplett leer ist, und zweitens, wenn diese eine andere Datei als die im Parameter angegebene enthält (s. Listing 3).<\/p>\n Listing 3: Die Funktion objWorkbook prüft, ob schon ein Workbook geöffnet ist. Falls nein oder falls dieses nicht das richtige ist, öffnet sie die gewünschte Datei und liefert einen Verweis darauf zurück.<\/p>\n Auf diese Weise haben wir gleich mehrere Dinge erledigt: Wir haben eine Excel-Instanz erzeugt und den Verweis darauf gespeichert, und außerdem das Gleiche mit einer potenziellen Importdatei erledigt. Wann immer wir später auf diese beiden Objekte zugreifen wollen – sie sind stets parat.<\/p>\n Nun geht es an die nächste Aufgabe: Das Anzeigen der Tabellenblätter der ausgewählten Excel-Datei.<\/p>\n Hierzu müssen Sie wissen, dass es etwas unbequem ist, mit einer in ein Formular eingebundenen Excel-Instanz umzugehen.<\/p>\n Beim Laden eines Dokuments flackert es ordentlich und auch danach wirkt das Excel-Dokument nicht wirklich integriert.<\/p>\n Eine Alternative ist das Spreadsheet-Steuerelement der Office Web Components, die mit Office bis zur Version 2003 ausgeliefert wurden, für spätere Versionen jedoch ebenfalls zusätzlich heruntergeladen werden können (schlagen Sie zu – wer weiß, wie lange noch!).<\/p>\n Wir widmen diesem Steuerelement einen eigenen, kleinen Beitrag namens Tabellen wie unter Excel <\/b>(Shortlink 694), in dem Sie weitere Informationen finden.<\/p>\n Falls die Komponente nicht auf Ihrem Rechner installiert ist, können Sie diese unter http:\/\/www.microsoft.com\/downloads\/details.aspxFamilyId=7287252C-402E-4F72-97A5-E0FD290D4B76&displaylang=en<\/b> herunterladen (hier in der Version für Office 2003).<\/p>\n Die Komponente fügen Sie nun über den Dialog zum Einfügen von ActiveX-Steuerelementen in das Formular sfmDateiUndBlatt <\/b>ein, sodass dieses wie in Bild 4 aussieht. Weisen Sie der Komponente den Namen ctlSpreadsheet <\/b>zu.<\/p>\n Bild 4: Das Spreadsheet-Steuerelement im Unterformular für den ersten Schritt des Assistenten<\/span><\/b><\/p>\n Fügen Sie dann dem Formular sfmDateiUndBlatt <\/b>eine Ereignisprozedur für das Ereignis Beim Laden <\/b>hinzu, die wie folgt aussieht:<\/p>\n Die hier verwendete Objektvariable objSpreadsheet<\/b> deklarieren Sie im Kopf des gleichen Moduls:<\/p>\n Und jetzt kommt€\u00cbœs: Das Unterformular soll nun nach der Auswahl einer Excel-Datei und des gewünschten Tabellenblatts den Inhalt genau dieses Tabellenblatts im Spreadsheet-Steuerelement anzeigen.<\/p>\n Dies geschieht genau nach der Auswahl eines Eintrags im Kombinationsfeld, wodurch das Ereignis Nach Aktualisierung <\/b>dieses Steuerelements ausgelöst wird.<\/p>\n Die passende Ereignisprozedur finden Sie in Listing 4. Sie prüft zunächst, ob das Kombinationsfeld überhaupt einen Wert enthält. Falls ja, füllt sie das Objekt objWorksheet <\/b>mit einem Verweis auf das angegebene Tabellenblatt der Importdatei. Dazu referenziert sie wiederum die weiter oben beschriebene Funktion objWorkbook <\/b>mit dem angegebenen Dateinamen als Parameter und verwendet die Auflistung Worksheets<\/b>, um an das gewünschte Tabellenblatt heranzukommen. Sie sehen hier bereits einen der Vorteile der Funktion objWorkbook<\/b>: Sie brauchen (und sollen) das Ergebnis nicht erst einer Variablen zuzuweisen, sondern greifen gleich über die Punkt-Syntax auf die Eigenschaften und Methoden des zurückgelieferten Objekts zu.<\/p>\n Listing 4: Füllen des Spreadsheet-Steuerelements mit dem ausgewählten Tabellenblatt<\/p>\n Ist das Tabellenblatt erst einmal in Form der Objektvariablen objWorksheet <\/b>referenziert, geht der Rest ganz schnell: Wir kopieren den kompletten Inhalt, den wir mit der Cells<\/b>-Eigenschaft erfassen, mit der Copy<\/b>-Methode und schreiben alles mit der Paste<\/b>-Methode in unser Spreadsheet-Steuerelement. Das Ergebnis kann sich sehen lassen: Die Kopie des Excel-Tabellenblatts wird im Formular des Assistenten angezeigt und Sie können mit der Maus Bereiche markieren, ohne dass es wie bei einer per OLE eingeblendeten Excel-Instanz flackert (siehe Bild 5).<\/p>\n Bild 5: Der erste Schritt des Assistenten ist vollendet.<\/span><\/b><\/p>\n Schritt für Schritt<\/b><\/p>\n Nach diesem Schritt widmen wir uns ein wenig dem Ablauf des Assistenten und seiner Steuerung. Im aktuellen Zustand sind beispielsweise alle Schaltflächen beim Anzeigen des ersten Schritts aktiviert, was zumindest für die Zurück<\/b>-Schaltfläche keinen Sinn macht, aber auch nicht für die Fertigstellen<\/b>-Schaltfläche.<\/p>\n Betrachten wir zunächst, wie viele und welche Schritte wir überhaupt benötigen:<\/p>\n <\/p>\n Für die so definierten Schritte brauchen wir zunächst einige Unterformulare, die Sie gleich in Form von Kopien des ersten Unterformulars sfmDateiUndBlatt <\/b>erstellen können – wir sparen uns so das wiederholte Hinzufügen des Spreadsheet-Steuerelements, das wir noch in weiteren Unterformularen benötigen. Die neuen Unterformulare sollen die folgenden Bezeichnungen erhalten:<\/p>\n Danach wenden wir uns wieder dem Hauptformular zu, mit dessen Schaltflächen der Benutzer schließlich die Anzeige der jeweiligen Unterformulare steuern soll. Zunächst deklarieren wir im Klassenformular des Formulars (Form_frmExcelImportWizard<\/b>) eine Variable, welche die Nummer des aktuellen Schritts speichert:<\/p>\n Danach füllen wir die vier Schaltflächen mit Leben. Am einfachsten ist dies bei der Schaltfläche cmdAbbrechen<\/b>, die einfach nur das Formular schließt:<\/p>\n Die Prozedur Restarbeiten<\/b> löscht die Zwischenablage, leert Objektvariablen und beendet die verwendete Excel-Instanz, damit diese nicht unsichtbar in den Untiefen des Task Managers umherirrt und unnötig Ressourcen belegt:<\/p>\n Die beiden Schaltflächen mit den Beschriftungen Weiter <\/b>und Zurück<\/b>, die Sie von jedem Assistenten kennen, enthalten nur minimal viel Code, nämlich jeweils zwei Anweisungen. Die Weiter<\/b>-Schaltfläche erhöht intStep <\/b>um eins und ruft dann die Funktion DoStep <\/b>auf:<\/p>\n Was die Zurück<\/b>-Schaltfläche erledigt, können Sie sich vermutlich schon denken:<\/p>\n Die Hauptfunktion bezüglich der Steuerung des Assistenten befindet sich in der Prozedur DoStep<\/b> (s. Listing 5). Diese wird ja, wie oben gesehen, nach jedem Klick auf eine der beiden Schaltflächen cmdZurueck <\/b>und cmdWeiter <\/b>je einmal aufgerufen, wobei sich jeweils der Wert von intStep <\/b>ändert und somit ein anderer Zweig der in DoStep <\/b>enthaltenen Select Case<\/b>-Anweisung ausgeführt wird.<\/p>\n Listing 5: Diese Prozedur steuert den Ablauf des Assistenten und lädt die Unterformulare für die einzelnen Schritte.<\/p>\n Innerhalb der Select Case<\/b>-Zweige legt die Prozedur jeweils das Unterformular für den aktuellen Schritt fest und lädt dieses in das Hauptformular. Außerdem aktiviert beziehungsweise deaktiviert sie die vier Schaltflächen des Hauptformulars in Abhängigkeit von intStep<\/b>.<\/p>\n Eine Besonderheit gibt es bei Schritt 4: Hier wird noch der Wert der Variablen bolNeueTabelle <\/b>geprüft, die im Unterformular von Schritt 3 gefüllt wird. Abhängig vom Wert wird entweder das Unterformular zum Anlegen einer neuen Tabelle oder das zum Füllen einer bestehenden Tabelle angezeigt.<\/p>\n Bereich auswählen<\/b><\/p>\n Das Unterformular zum Auswählen eines Bereichs sieht wie in Bild 6 aus. Es enthält ein Kontrollkästchen namens chkSpaltenueberschriften<\/b>, mit dem der Benutzer angeben kann, ob der ausgewählte Bereich Spaltenüberschriften enthält oder nicht.<\/p>\n Bild 6: Das Unterformular zum Definieren des zu importierenden Bereichs in der Entwurfsansicht<\/span><\/b><\/p>\n Hier stellt sich eine erste Design-Frage: Wir haben ja bereits im ersten Unterformular des Assistenten ein Spreadsheet-Steuerelement eingebaut. Ein solches befindet sich nun auch im zweiten Unterformular. Im ersten Formular soll das Spreadsheet-Steuerelement nur die Daten im ausgewählten Tabellenblatt anzeigen, damit der Benutzer sichergehen kann, dass er die richtigen Daten importiert. Im zweiten Schritt des Assistenten soll er im Spreadsheet-Steuerelement den Bereich des Tabellenblatts festlegen, der importiert werden soll. Nun müssen wir irgendwie dafür sorgen, dass das Spreadsheet<\/b>-Steuerelements des Unterformulars im zweiten Schritt mit dem Inhalt des Spreadsheet-Steuerelements des ersten Unterformulars gefüllt wird. Wir könnten dies erledigen, indem wir die Daten aus dem ersten Unterformular kopieren und im zweiten Unterformular einfügen, aber das dauert fast genauso lange wie das Füllen des Spreadsheets im ersten Unterformular – bei größeren Datenmengen also durchaus mehrere Sekunden.<\/p>\n Die Alternative wäre, doch nicht mit verschiedenen Unterformularen zu arbeiten, sondern die Steuerelemente je nach aktuellem Schritt ein- und auszublenden. Dazu ist jedoch anzumerken, dass bei vielen Steuerelementen ein ziemliches Durcheinander im Entwurfsmodus herrscht.<\/p>\n Vielleicht funktioniert eine Mischlösung – eine, bei der zwar alle übrigen Steuerelemente in separaten Unterformularen stecken, aber nicht das Spreadsheet-Steuerelement Wir müssen dann nur sicherstellen, dass das Spreadsheet-Steuerelement in der Z-Reihenfolge über dem Unterformular liegt und zu den richtigen Zeitpunkten ein- und ausgeblendet wird.<\/p>\n Schneiden wir also das Steuerelement ctlSpreadsheet <\/b>aus dem Unterformular sfmDateiUndTabelle <\/b>aus und fügen diese im Hauptformular frmExcelImportWizard <\/b>ein. Möglicherweise verschwindet das Steuerelement gleich hinter dem Unterformularsteuerelement sfmExcelImportWizard<\/b>, was Sie leicht beheben können: Dazu markieren Sie einfach das Unterformularsteuerelement und wählen aus seinem Kontextmenü den Eintrag Position|In den Vordergrund <\/b>aus (siehe Bild 7).<\/p>\n Bild 7: Anpassen der Z-Reihenfolge der Steuerelemente<\/span><\/b><\/p>\n Dies macht sich interessanterweise nicht bemerkbar: In der Entwurfsansicht wird das Unterformular nach wie vor über dem Spreadsheet-Steuerelement angezeigt. Dies ändert sich jedoch, wenn Sie zur Formularansicht wechseln: Dort schiebt sich das ActiveX-Steuerelement nach vorn und überdeckt das Unterformular-Steuerelement wie geplant.<\/p>\n Gehen wir also zu dieser Strategie über: Das Spreadsheet-Steuerelement wird ins Hauptformular verschoben, aber über das von Schritt zu Schritt wechselnde Unterformular gelegt und gegebenenfalls ausgeblendet – so sparen wir das Kopieren beziehungsweise erneute Einlesen des Tabellenblatts zwischen den einzelnen Schritten. <\/p>\n Kommen wir nun endlich zum Auswählen des Bereichs: Hier muss der Benutzer tätig werden und mit der Maus oder auch der Tastatur die Zellen markieren, deren Inhalt importiert werden soll. Außerdem soll er angeben, ob dieser Bereich Spaltenüberschriften enthält oder nicht. Mit einem Klick auf die Schaltfläche Weiter<\/b> ist dieser Schritt für den Benutzer erledigt – für uns aber noch nicht. Wir müssen erst noch die Angaben des Benutzers speichern, was wir mithilfe entsprechender Variablen im Hauptformular erledigen. Dazu brauchen wir fünf Variablen:<\/p>\n Die Variablen werden im Klassenmodul Form_frmExcelImportWizard <\/b>wie folgt deklariert:<\/p>\n Gefüllt werden diese erst, wenn der Benutzer die Weiter<\/b>-Schaltfläche des zweiten Schritts verwendet, um zum dritten Schritt zu wechseln. Dies schlägt sich im Case<\/b>-Zweig für diesen Schritt in der bereits weiter oben vorgestellten Prozedur DoStep <\/b>nieder:<\/p>\n Wir wollen die Koordinaten des gewählten Bereichs als absolute, numerische Werte speichern. Dabei helfen die Eigenschaften Column <\/b>und Row<\/b>, welche die Koordinaten des linken, oberen Feldes des Bereichs liefern. Die Koordinate des rechten Rands erhalten wir über die Koordinate des linken Rands plus der Anzahl der in der Auswahl enthaltenen Spalten (Columns.Count<\/b>) minus eins, die Koordinate des unteren Rands ermitteln wir analog.<\/p>\n Zieltabelle angeben<\/b><\/p>\n Als Zieltabelle soll der Benutzer entweder eine vorhandene Tabelle angeben können oder die Daten werden in eine neue Tabelle importiert – dann erwartet der Assistent die Eingabe des gewünschten Tabellennamens. Das hier anzuzeigende Unterformular namens sfmZieltabelleFestlegen <\/b>aus und besitzt folgende Steuerelemente (siehe Bild 8):<\/p>\n Bild 8: Mit diesem Unterformular gibt der Benutzer die Zieltabelle für den Import an.<\/span><\/b><\/p>\n Das Kombinationsfeld cboZieltabelle<\/b> bezieht seine Daten aus der Systemtabelle MSysObjects<\/b>. Diese Tabelle enthält beispielsweise für jede Tabelle einen Eintrag. Mit folgender Abfrage als Datensatzherkunft zeigt das Kombinationsfeld alle Tabellen an, die nicht das für Systemtabellen typische Präfix enthalten:<\/p>\n Je nach der Auswahl des Benutzers soll entweder das Kombinationsfeld cboZieltabelle <\/b>oder das Textfeld txtZieltabelle <\/b>aktiviert werden. Dies erreichen wir durch eine Ereignisprozedur, die durch das Ereignis Nach Aktualisierung <\/b>der Optionsgruppe ausgelöst wird:<\/p>\n Natürlich müssen wir auch dafür sorgen, dass die Steuerelemente beim Erreichen dieses Schritts richtig konfiguriert werden. Grob sieht das wie folgt aus und geschieht in der Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>des Unterformulars ausgelöst wird:<\/p>\n Import in neue\/bestehende Tabelle steuern<\/b><\/p>\n Der vierte und nächste Schritt des Assistenten ist zweigeteilt: Er behandelt sowohl den Import in eine bestehende als auch in eine neue Tabelle. Beide Teilschritte laufen im Wesentlichen in eigenen Unterformularen ab. Den nachfolgend ausschnittsweise beschriebenen Abschnitt finden Sie im Klassenmodul des Formulars frmExcelImportWizard <\/b>in der Select Case<\/b>-Anweisung der Prozedur DoStep <\/b>unter Case 4<\/b>.<\/p>\n Wie bei den anderen Schritten wird dieser Schritt noch vom Unterformular des vorherigen Schritts aufgerufen, hier also von den unter Case 3 <\/b>zu findenden Anweisungen. Zu diesem Zeitpunkt ist noch das Unterformular sfmZieltabelleFestlegen <\/b>zur Auswahl der Zieltabelle aktiviert. Daher kann zu Beginn des Abschnitts unter Case 4 <\/b>noch geprüft werden, ob der Benutzer eine Zieltabelle angegeben hat und der Sprung zum nächsten Unterformular gegebenenfalls unterbunden werden muss:<\/p>\n Anderenfalls können wir uns einem der beiden möglichen Fälle zuwenden: dem Import in eine bestehende oder in eine neue Tabelle. In beiden Fällen soll das Spreadsheet-Steuerelement eingeblendet werden; anschließend wird das entsprechende Unterformular angezeigt:<\/p>\n Die folgenden Abschnitte beschreiben diese beiden Varianten.<\/p>\n Import in eine neue Tabelle<\/p>\n Beim Import in eine neue Tabelle müssen Sie nicht nur erfassen, wie die neue Tabelle heißen soll, sondern auch noch die Zielfelder für die ausgewählten Spalten definieren. Dies geschieht mit dem Unterformular sfmFelderDefinieren<\/b>, das Abb. 9 in der Entwurfsansicht zeigt. Das Unterformular enthält zwei Schaltflächen, mit denen Sie zwischen den Spalten des Excel-Sheets wechseln können. Zur optischen Hervorhebung der aktuell bearbeiteten Spalte soll diese im Spreadsheet-Steuerelement markiert werden (siehe Bild 10).<\/p>\n Bild 9: Das Unterformular sfmFelderDefinieren in der Entwurfsansicht<\/span><\/b><\/p>\n Bild 10: Die aktuell bearbeitete Spalte wird markiert dargestellt.<\/span><\/b><\/p>\n Damit dies gelingt, wird erstmal das passende Unterformular eingestellt:<\/p>\n Dann wird gleich die erste Spalte des für den Import ausgewählten Bereichs markiert:<\/p>\n Gleich im Anschluss prüft die Prozedur, ob der zu importierende Bereich Spaltenüberschriften enthält. Falls ja, wird das Feld txtFeldname <\/b>des Unterformulars mit dem im Spaltenkopf der ersten Spalte enthaltenen Text gefüllt:<\/p>\n Danach wird eine WithEvents<\/b>-Objektvariable mit einem Verweis auf das aktuelle Unterformular gefüllt und gleich danach die Beim Entladen<\/b>-Ereigniseigenschaft mit dem Ausdruck [Event Procedure] <\/b>gefüllt:<\/p>\n Das Gleiche geschieht mit den beiden Schaltflächen cmdNaechsteSpalte <\/b>und cmdVorherigeSpalte <\/b>– hier ist allerdings die Ereigniseigenschaft Beim Klicken <\/b>betroffen:<\/p>\n Da wir uns aktuell in der ersten Spalte befinden, wird eine Variable entsprechend eingestellt:<\/p>\n Außerdem setzen wir den Fokus auf die Schaltfläche cmdNaechsteSpalte <\/b>und deaktivieren die Schaltfläche cmdVorherigeSpalte<\/b>:<\/p>\n Es kann auch geschehen, dass der zu importierende Bereich nur eine Spalte umfasst. Dann muss natürlich auch die Schaltfläche cmdNaechsteSpalte <\/b>deaktiviert werden. Vorher verschieben wir den Fokus auf txtFeldname<\/b>, weil Steuerelemente mit Fokus nicht deaktiviert werden können:<\/p>\n Das waren schon die Vorbereitungen. Die restlichen Aktionen dieses Formulars befinden sich in den Ereignisprozeduren, die durch das Anklicken von cmdNaechsteSpalte <\/b>und cmdVorherigeSpalte <\/b>sowie das Entladen des Unterformulars ausgelöst werden.<\/p>\n Tabelle zum Speichern der Feldeigenschaften<\/b><\/p>\n Die beiden Unterformulare sfmFelderDefinieren <\/b>und sfmFelderZuweisen <\/b>weisen gegebenüber den übrigen Unterformularen die Besonderheit auf, dass sie an eine Tabelle als Datenherkunft gebunden sind. Der Hintergrund ist, dass diese Unterformulare zu jeder Spalte des zu importierenden Bereiche der Excel-Tabelle Informationen über die Zielfelder aufnehmen sollen – und die müssen schließlich irgendwo landen. Wo sollte dies unter Access sonst geschehen als in einer Tabelle Diese heißt tblZuordnungen<\/b> und sieht im Entwurf wie in Bild 11 aus. Das Feld Indiziert<\/b> ist als Kombinationsfeld ausgelegt und enthält eine Wertliste als Datensatzherkunft, welche die Werte Nein<\/b>, Ja (Duplikate möglich) <\/b>und Ja (Ohne Duplikate) <\/b>zur Auswahl bereitstellt.<\/p>\n Bild 11: Diese Tabelle speichert die Eigenschaften der Zielfelder des Imports.<\/span><\/b><\/p>\n Auf diesem Hintergrund können wir uns eine der beiden Routinen ansehen, die durch die Schaltflächen cmdVorherigeSpalte <\/b>und cmdNaechsteSpalte <\/b>ausgelöst werden. Diese führen nämlich lediglich diese Aktionen aus:<\/p>\n Stellt sich nur eine Frage: Wo wird die Tabelle tblZuordnungen<\/b> überhaupt gefüllt Wenn diese je nach Spalte gefiltert wird, muss sie ja bereits Daten enthalten.<\/p>\n Das Füllen dieser Tabelle geschieht in der Ereignisprozedur frmBereichFestlegen_Unload<\/b>, die beim Entladen des Unterformulars frmBereichFestlegen <\/b>ausgelöst wird.<\/p>\n In diesem Unterformular wird, Sie erinnern sich, der zu importierende Bereich festgelegt und auch angegeben, ob dieser Spaltenüberschriften enthält oder auch nicht. Hat der Benutzer die Auswahl getroffen, schreibt diese Routine die entsprechenden Datensätze in die Tabelle tblZuordnungen<\/b>.<\/p>\n Kehrt der Benutzer nach dem Zuweisen der Spalten zu den Feldern der Zieltabelle zur Auswahl des zu importierenden Bereichs zurück und ändert diesen, werden automatisch auch alle Datensätze der Tabelle tblZuordnungen <\/b>gelöscht.<\/p>\n Import in eine bestehende Tabelle<\/b><\/p>\n Bei einer bestehenden Tabelle besteht die Aufgabe des vierten Schritts des Assistenten darin, den ausgewählten Spalten die entsprechenden Felder der Zieltabelle zuzuweisen. Dies geschieht im Unterformular sfmFelderZuweisen<\/b>, das mit folgender Anweisung in das Unterformularsteuerelement sfmExcelImportWizard <\/b>geladen wird:<\/p>\n Die übrigen Anweisungen in diesem Teil der If…Then<\/b>-Bedingung unterhalb von Case 4 <\/b>stimmen prinzipiell mit denen überein, die auch beim Aufnehmen der Daten für eine bestehende Tabelle verwendet werden – eine genauere Betrachtung ist daher an dieser Stelle nicht notwendig.<\/p>\n Unterschiede finden sich beim Unterformular sfmFelderZuweisen<\/b>, das neben den beiden Schaltflächen zum Blättern zwischen den Spalten des zu importierenden Bereichs lediglich ein Kombinationsfeld zur Auswahl eines der Felder der im vorherigen Schritt ausgewählten Datenherkunft anbietet (siehe Bild 12).<\/p>\n Bild 12: Dieses Unterformular dient der Zuordnung der Felder der Zieltabelle zu den zu importierenden Spalten.<\/span><\/b><\/p>\n Damit dies funktioniert, enthält die Eigenschaft Herkunftsart <\/b>den Eintrag Feldliste <\/b>und die Eigenschaft Datensatzherkunft <\/b>wird zur Laufzeit per VBA über die folgende Anweisung mit dem in der Variablen strZieltabelle <\/b>enthaltenen Namen der Zieltabelle gefüllt:<\/p>\n Hiermit sind die Vorbereitungen abgeschlossen: Wir können uns nun darum kümmern, wie der Import-Assistent die neue Tabelle anlegt und diese oder eine bestehende auf Basis der durch den Benutzer angegebenen Parameter mit den Daten aus der Excel-Tabelle füllt.<\/p>\n Erzeugen einer neuen Tabelle<\/b><\/p>\n Eine der größeren Herausforderungen beim Erstellen dieses Assistenten ist das Formulieren der SQL-Abfrage, welche die Benutzerangaben in eine Erzeugung einer kompletten Tabelle umwandelt. Dies geschieht auf Basis der in der Tabelle tblZuordnungen <\/b>gemachten Angaben.<\/p>\n Zum Verständnis der folgenden Abschnitte ist der Beitrag Datenbanken und Tabellen per SQL anpassen <\/b>(Shortlink 609) hilfreich.<\/p>\n Das letzte Unterformular heißt sfmFertigstellen <\/b>und enthält ein Steuerelement namens txtPrimaerschluessel<\/b>, in das der Benutzer den Namen eines Primärschlüsselfelds mit Autowert<\/b>-Funktion eingeben soll – wenn er denn eines möchte.<\/p>\n Das Textfeld wird auch überhaupt nur aktiviert, wenn der Benutzer noch keines der bisherigen Felder als Primärschlüsselfeld festgelegt hat (siehe Bild 13).<\/p>\n Bild 13: Der letzte Schritt im Excel-Import-Assistenten<\/span><\/b><\/p>\n Die eigentliche Arbeit übernimmt die Prozedur NeueTabelleErstellen <\/b>aus Listing 6. Sie liest alle vorhandenen Daten aus und erzeugt SQL-Anweisungen, welche die Tabelle und gegebenenfalls zusätzliche Indizes erstellen.<\/p>\n Listing 6: Diese Prozedur erstellt eine neue Tabelle auf Basis der durch den Benutzer eingestellten Parameter.<\/p>\n Dabei durchläuft die Routine alle Datensätze der Tabelle tblZuordnungen <\/b>und stellt so die SQL-Ausdrücke für die einzelnen Felder zusammen. Gleichzeitig prüft sie, ob eindeutige oder einfache Indizes für die Felder angelegt werden sollen, und fügt gegebenenfalls je eine DDL-Anweisung pro Index zum String<\/b>-Array strIndizes <\/b>hinzu.<\/p>\n Dabei kommen dann beispielsweise solche DDL-Anweisungen heraus, die nur noch per Execute<\/b>-Methode des Connection<\/b>-Objekts der aktuellen Datenbank ausgeführt werden:<\/p>\n Als Namen für die Indizes werden jeweils frisch erzeugte GUID-Werte verwendet, um deren Eindeutigkeit zu gewährleisten.<\/p>\n Daten importieren<\/b><\/p>\n Mit der obigen Prozedur zum Erstellen einer neuen Tabelle entsprechend den Vorgaben des Benutzers haben wir die Voraussetzung geschaffen, dass beide Import-Varianten, sowohl der Import in eine bestehende als auch in eine neue Tabelle, gleich behandelt werden können.<\/p>\n Nun brauchen wir also nur noch eine kleine Prozedur, welche die Daten aus der Excel-Tabelle importiert. Technisch betrachtet gibt es verschiedene Möglichkeiten, um den Inhalt einer Excel-Tabelle in eine Access-Tabelle zu übertragen.<\/p>\n Beide Varianten fallen für unsere Zwecke jedoch flach. Die DoCmd.TransferSpreadsheet<\/b>-Methode ist zwar die schnellere Methode, taugt aber nur für den Einsatz in bestimmten Konstellationen – nämlich dort, wo ein zusammenhängender Block aus einem Excel-Tabellenblatt importiert werden soll. Wenn wir von einer Auswahl von drei Spalten die mittlere vom Import ausschließen möchten, scheitert diese Variante.<\/p>\n Die Methode per VBA über das Excel-Objektmodell kann flexibler gestaltet werden und ermöglicht auch den Import nicht zusammenhängender Bereiche. Allerdings fällt diese Vorgehensweise geschwindigkeitsmäßig weit hinter DoCmd.TransferSpreadsheet <\/b>zurück.<\/p>\n Zum Glück gibt es eine dritte, weitgehend unbekannte, aber ungleich flexiblere Methode. Mit dieser greifen Sie über eine SELECT<\/b>-Anweisung auf die Excel-Tabelle zu – fast genau so, wie Sie es auch bei einer Access-Tabelle tun würden. An dieser Stelle kommt implizit der ISAM-Treiber von JET zum Einsatz. Die Methode bietet einige speziell für den Zugriff auf Excel-Tabellen zugeschnittene Möglichkeiten. So kann man in dieser SELECT<\/b>-Anweisung den Namen der Excel-Datei und des Tabellenblatts und sogar den gewünschten Bereich angeben. Ein Beispiel für eine solche Anweisung sieht so aus:<\/p>\n Diese Anweisung enthält die Zieltabelle und die zu füllenden Felder wie in einer handelsüblichen INSERT INTO<\/b>-Abfrage. Danach folgt unbekanntes Terrain: Die SELECT<\/b>-Anweisung liest die erste und dritte Spalte (F1 <\/b>und F3<\/b>) des Bereichs A6:C8 <\/b>des Tabellenblatts Tabelle1 <\/b>aus der Datei c:\\beispieldatei.xls <\/b>ein.<\/p>\n Dabei werden die zum Schluss in eckigen Klammern eingefassten Optionsparameter beachtet. Der erste gibt die Excel-Version an, der zweite, ob Spaltenüberschriften zu beachten sind, der dritte, dass ein Import aus dieser Datei stattfinden soll.<\/p>\n Die Prozedur InBestehendeTabelleImportieren <\/b>aus Listing 7 erwartet genau diese Informationen von der aufrufenden Instanz. Einzig der zu importierende Bereich wird nicht in Form einer Zeichenkette wie A1:B2<\/b>, sondern durch vier absolute Zahlenwerte repräsentiert.<\/p>\n Listing 7: Füllen einer vorhandenen oder neu erstellten Tabelle aus einem Excel-Bereich<\/p>\n Die zu erstellende SQL-Anweisung enthält an zwei Stellen Auflistungen: erstens die Liste der in der Zieltabelle zu füllenden Felder und zweitens die entsprechenden Quellfelder der Excel-Tabelle.<\/p>\n Die Option HDR<\/b>, die angibt, ob der angegebene Bereich der Excel-Tabelle Spaltenüberschriften enthält, setzt die Prozedur immer auf No<\/b>. Der Hintergrund ist, dass die zu importierenden Spalten dann über die generischen Spaltenüberschriften F1<\/b>, F2<\/b>, … anzusprechen sind statt über tatsächlich vorhandene Spaltenüberschriften.<\/p>\n Wenn der Benutzer im Assistenten festlegt, dass Spaltenüberschriften verwendet werden sollen, registriert die Prozedur dies nur insofern, als dass sie den Bereich, der ja die Spaltenüberschriften enthält, um die obere Zeile kürzt.<\/p>\n Durch die generischen Spaltenüberschriften können wir in der Do While<\/b>-Schleife, welche alle Datensätze der Tabelle tblZuordnungen <\/b>durchläuft und die Liste der zu importierenden Spalten zusammenstellt, genau die Spalten berücksichtigen, für die der Benutzer den Parameter Auslassen <\/b>nicht aktiviert hat und die Spaltenüberschriften gleich aus dem Buchstaben F <\/b>und der Laufvariablen i <\/b>zusammenstellen.<\/p>\n Der Import über die SELECT<\/b>-Methode ist im Regelfall genauso schnell wie bei der TransferSpreadsheet<\/b>-Methode (bei 5.000 Zeilen mit drei Spalten etwa ein bis zwei Sekunden), aber wesentlich flexibler. Es ist gut möglich, dass TransferSpreadsheet <\/b>intern auch auf die SELECT<\/b>-Methode zugreift.<\/p>\n Die Methode aus Listing 7 verwendet zwei Hilfsfunktionen. Die erste heißt GetExcelRangeFromLong <\/b>und wandelt vier absolute Zahlenwerte in einen Excel-Bereich wie A10:C100 <\/b>um.<\/p>\n Dabei kommt auch die Funktion GetExcelChar <\/b>zum Einsatz, die Spaltennummern in die entsprechenden Excel-Buchstaben umwandelt (1 <\/b>entspricht A<\/b>, 27 <\/b>entspricht AA <\/b>und so weiter).<\/p>\n Zusammenfassung und Ausblick<\/p>\n Mit dem ExcelImportWizard <\/b>haben Sie ein Werkzeug, mit dem Sie Excel-Daten komplett von Access gesteuert in eine Access-Tabelle importieren können. Dies ist auch mit dem eingebauten Assistenten möglich, jedoch kann man mit diesem selbst nicht den zu importierenden Bereich auswählen, wenn dieser nicht bereits als benannter Bereich definiert wurde.<\/p>\n Die hier vorgestellte Lösung nutzt das Spreadsheet<\/b>-Steuerelement, um die zu importierende Excel-Tabelle komplett anzuzeigen und dem Benutzer die Möglichkeit zu geben, den gewünschten Bereich direkt aus dem Assistenten heraus zu importieren.<\/p>\n Es bleibt noch ein wenig Arbeit offen, die wir im Rahmen dieses Beitrags nicht mehr beschreiben können. Dazu gehören einige Validierungen, die etwa abfragen, ob eine zu erstellende Tabelle bereits existiert.<\/p>\n Außerdem muss die Datenbank noch in eine Add-In-Datenbank konvertiert werden, damit Sie den Assistenten von jeder beliebigen Datenbank aus aufrufen können. Die dazu notwendigen Schritte werden im Beitrag Access-Add-Ins <\/b>(Shortlink 643) erläutert.<\/p>\n Es gibt noch weitere Funktionen, die wir dem Assistenten hinzufügen könnten: Beispielsweise würde eine Funktion zum Speichern eines Importvorgangs wiederkehrende Importe erleichtern.<\/p>\n Hierbei könnte auch die Ausgabe der verwendeten SQL-Ausdrücke zum Erstellen neuer Tabellen und zum Hinzufügen der zu importierenden Daten Sinn machen: Diese könnte man dann gleich in eigenen Code integrieren, ohne dass man auf den Wizard zugreifen muss.<\/p>\n Enthaltene Beispieldateien:<\/p>\n ExcelImportieren.mdb<\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic002_opt.jpeg\")
<\/p>\nPrivate Sub cmdDateiAuswaehlen_Click()\r\n Me!txtExcel-Datei = OpenFileName(CurrentProject.Path,\r\n \"Excel-Datei auswählen€, \"Excel 2002-2003 (*.xls)|\r\n Excel 2007 (*.xlsx)|Alle Dateien (*.*)€)\r\n If Len(Me!txtExcel-Date) > 0 Then\r\n If Len(Dir(Me!txtExcel-Date)) > 0 Then\r\n With Me!cboTabellenblaetter\r\n .RowSourceType = \"Value List€\r\n .RowSource = _\r\n TabellennamenEinlesen(Me!txtExcel-Date)\r\n .SetFocus\r\n .Dropdown\r\n End With\r\n End If\r\n End If\r\n End Sub<\/pre>\n
Public Function TabellennamenEinlesen(strExcel-Datei As\r\n String) As String\r\n Dim objWorksheet As Excel.Worksheet\r\n Dim strTabellen As String\r\n For Each objWorksheet In objWorkbook(strExcel-Date).\r\n Worksheets\r\n strTabellen = strTabellen & objWorksheet.Name & \";€\r\n Next objWorksheet\r\n TabellennamenEinlesen = strTabellen\r\n End Function<\/pre>\n
Private m_Excel As Excel.Application\r\nPrivate m_Workbook As Excel.Workbook<\/pre>\n
![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic010_opt.jpeg\")
<\/p>\nPublic Property Get objExcel() _\r\nAs Excel.Application\r\nIf m_Excel Is Nothing Then\r\n Set m_Excel = New Excel.Application\r\nEnd If\r\nSet objExcel = m_Excel\r\nEnd Property<\/pre>\n
Public Function objWorkbook(strExcel-Datei As String) As Excel.Workbook\r\n If m_Workbook Is Nothing Then\r\n Set m_Workbook = objExcel.Workbooks.Open(strExcel-Date)\r\n Else\r\n If Not m_Workbook.Path & \"\\€ & m_Workbook.Name = strExcel-Datei Then\r\n Set m_Workbook = objExcel.Workbooks.Open(strExcel-Date)\r\n End If\r\n End If\r\n Set objWorkbook = m_Workbook\r\nEnd Function<\/pre>\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic003_opt.jpeg\")
<\/p>\nPrivate Sub Form_Load()\r\n Set objSpreadsheet = _\r\n Me!ctlSpreadsheet.Object\r\n End Sub<\/pre>\n
Dim objSpreadsheet As OWC11.Spreadsheet<\/pre>\n
Private Sub cboTabellenblaetter_AfterUpdate()\r\n Dim objWorksheet As Excel.Worksheet\r\n If Not IsNull(Me!cboTabellenblaetter) Then\r\n Set objWorksheet = _\r\n objWorkbook(Me!txtExcel-Date). _\r\n Worksheets(CStr(Me!cboTabellenblaetter))\r\n objWorksheet.Cells.Copy\r\n objSpreadsheet.Cells.Paste\r\n End If\r\n End Sub<\/pre>\n
![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic004_opt.jpeg\")
<\/p>\n\n
\n
Dim intStep As Integer<\/pre>\n
Private Sub cmdAbbrechen_Click()\r\n Call Restarbeiten\r\n DoCmd.Close acForm, Me.Name\r\n End Sub<\/pre>\n
Public Function Restarbeiten()\r\n ZwischenablageLeeren\r\n Set m_Workbook = Nothing\r\n If Not m_Excel Is Nothing Then\r\n m_Excel.Quit\r\n Set m_Excel = Nothing\r\n End If\r\nEnd Function<\/pre>\n
Private Sub cmdWeiter_Click()\r\n intStep = intStep + 1\r\n DoStep\r\n End Sub<\/pre>\n
Private Sub cmdZurueck_Click()\r\n intStep = intStep - 1\r\n DoStep\r\n End Sub<\/pre>\n
Private Sub DoStep()\r\n Select Case intStep\r\n Case 1 €\u00cbœDatei und Tabelle festlegen\r\n Me!sfmExcelImportWizard.SourceObject = \"sfmDateiUndBlatt€\r\n Me!cmdAbbrechen.Enabled = True\r\n Me!cmdWeiter.SetFocus\r\n Me!cmdZurueck.Enabled = False\r\n Me!cmdWeiter.Enabled = True\r\n Me!cmdFertigstellen.Enabled = False\r\n Case 2 €\u00cbœBereich auswählen\r\n Me!sfmExcelImportWizard.SourceObject = \"sfmBereichAuswaehlen€\r\n Me!cmdAbbrechen.Enabled = True\r\n Me!cmdZurueck.Enabled = True\r\n Me!cmdWeiter.Enabled = True\r\n Me!cmdFertigstellen.Enabled = False\r\n Case 3 €\u00cbœZieltabelle festlegen\r\n Me!sfmExcelImportWizard.SourceObject = \"sfmZieltabelleFestlegen€\r\n Me!cmdAbbrechen.Enabled = True\r\n Me!cmdZurueck.Enabled = True\r\n Me!cmdWeiter.Enabled = True\r\n Me!cmdFertigstellen.Enabled = False\r\n Case 4 €\u00cbœFelder zuweisen (bei bestehender Tabelle) oder Felder definieren (bei neuer Tabelle)\r\n Select Case bolNeueTabelle\r\n Case True\r\n Me!sfmExcelImportWizard.SourceObject = \"sfmFelderDefinieren€\r\n Case False\r\n Me!sfmExcelImportWizard.SourceObject = \"sfmFelderZuweisen€\r\n End Select\r\n Me!cmdAbbrechen.Enabled = True\r\n Me!cmdZurueck.Enabled = True\r\n Me!cmdWeiter.Enabled = True\r\n Me!cmdFertigstellen.Enabled = False\r\n Case 5 €\u00cbœPrimärschlüssel festlegen, Importieren\/Fertigstellen\r\n Me!sfmExcelImportWizard.SourceObject = \"sfmFertigstellen€\r\n Me!cmdAbbrechen.Enabled = True\r\n Me!cmdZurueck.Enabled = True\r\n Me!cmdFertigstellen.Enabled = True\r\n Me!cmdFertigstellen.SetFocus\r\n Me!cmdWeiter.Enabled = False\r\n End Select\r\n End Sub<\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic005_opt.jpeg\")
<\/p>\n![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic006_opt.jpeg\")
<\/p>\n\n
Dim lngX1 As Long\r\n Dim lngY1 As Long\r\n Dim lngX2 As Long\r\n Dim lngY2 As Long\r\n Dim bolSpaltenueberschriften As Boolean<\/pre>\n
Case 3 €\u00cbœZieltabelle festlegen\r\n If intPreviousStep = 2 Then\r\n With Me!ctlSpreadsheet.Object.Selection\r\n lngX1 = .Column\r\n lngX2 = .Column + .Columns.Count - 1\r\n lngY1 = .Row\r\n lngY2 = .Row + .Rows.Count - 1\r\n End With\r\n bolSpaltenueberschriften = _\r\n Me!sfmExcelImportWizard. _\r\n Form!ctlSpaltenueberschriften\r\n End If\r\n €\u00cbœ...<\/pre>\n
![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic007_opt.jpeg\")
<\/p>\n\n
SELECT Name FROM MSysObjects\r\n WHERE Name Not Like €\u00cbœMSYS*€\"¢ AND Type = 1;<\/pre>\n
Private Sub ogrZieltabelle_AfterUpdate()\r\n Select Case Me.ogrZieltabelle\r\n Case 1\r\n Me!cboZieltabelle.Enabled = True\r\n Me!txtZieltabelle.Enabled = False\r\n Case 2\r\n Me!cboZieltabelle.Enabled = False\r\n Me!txtZieltabelle.Enabled = True\r\n End Select\r\n End Sub<\/pre>\n
Private Sub Form_Load()\r\n Me!ogrZieltabelle = 1\r\n Me!cboZieltabelle.Enabled = True\r\n Me!txtZieltabelle.Enabled = False\r\n End Sub<\/pre>\n
If intPreviousStep = 3 Then\r\n With frmZieltabelleFestlegen\r\n bolNeueTabelle = .ogrNeueTabelle\r\n If bolNeueTabelle Then\r\n strZieltabelle = Nz(!txtZieltabelle)\r\n Else\r\n strZieltabelle = Nz(!cboZieltabelle)\r\n End If\r\n End With\r\n If Len(strZieltabelle) = 0 Then\r\n MsgBox \"Geben Sie die Zieltabelle an.€, _\r\n vbOKOnly + vbExclamation, _\r\n \"Keine Zieltabelle angegeben.€\r\n intStep = 3\r\n Exit Sub\r\n End If\r\n End If<\/pre>\n
Me!ctlSpreadsheet.Visible = True\r\n Select Case bolNeueTabelle\r\n Case True\r\n €\u00cbœUnterformular sfmFelderDefinieren laden\r\n €\u00cbœund konfigurieren\r\n €\u00cbœ...\r\n Case False\r\n €\u00cbœUnterformular\r\n €\u00cbœsfmFelderZuweisen laden\r\n €\u00cbœund konfigurieren\r\n €\u00cbœ...\r\n End Select<\/pre>\n
![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic008_opt.jpeg\")
<\/p>\n![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic009_opt.jpeg\")
<\/p>\n Me!sfmExcelImportWizard.SourceObject =\r\n \"sfmFelderDefinieren€<\/pre>\n
With objSpreadsheet\r\n .Range(.Cells(lngY1, lngX1), .Cells(lngY2, lngX1)).Select<\/pre>\n
If bolSpaltenueberschriften Then\r\n Me!sfmExcelImportWizard.Form!txtFeldname\r\n = .Range(.Cells(lngY1, lngX1),\r\n .Cells(lngY1, lngX1))\r\n End If\r\n End With<\/pre>\n
Set frmFelderDefinieren =\r\n Me!sfmExcelImportWizard.Form\r\n With frmFelderDefinieren\r\n .OnUnload = \"[Event Procedure]€\r\n End With<\/pre>\n
Set cmdVorherigeSpalte = Nothing\r\n Set cmdVorherigeSpalte = frmFelderDefinieren!cmdVorherigeSpalte\r\n With cmdVorherigeSpalte\r\n .OnClick = \"[Event Procedure]€\r\n End With\r\n Set cmdNaechsteSpalte = frmFelderDefinieren.cmdNaechsteSpalte\r\n With cmdNaechsteSpalte\r\n .OnClick = \"[Event Procedure]€\r\n End With<\/pre>\n
intSpalte = 1<\/pre>\n
cmdNaechsteSpalte.SetFocus\r\n cmdVorherigeSpalte.Enabled = False<\/pre>\n
If lngY2 - lngY1 = 0 Then\r\n frmFelderDefinieren!txtFeldname.SetFocus\r\n cmdNaechsteSpalte.Enabled = False\r\n End If<\/pre>\n
![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic010_opt1.jpeg\")
<\/p>\n\n
Me!sfmExcelImportWizard.SourceObject = \"sfmFelderZuweisen€<\/pre>\n
![\"pic011.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic011_opt.jpeg\")
<\/p>\n cboFeldname.RowSource = strZieltabelle<\/pre>\n
![\"pic012.png\"](\"..\/fileadmin\/_temp_\/2009_06\/ExcelImport-web-images\/pic012_opt.jpeg\")
<\/p>\nPublic Sub NeueTabelleErstellen(strZieltabelle As String, strPrimaerschluessel As String)\r\n€\u00cbœDeklaration ...\r\nSet db = CurrentDb\r\nSet rst = db.OpenRecordset(\"SELECT * FROM tblZuordnungen€, dbOpenDynaset)\r\nSet cnn = CurrentProject.Connection\r\nstrSQL = \"DROP TABLE \" & strZieltabelle\r\nOn Error Resume Next\r\ncnn.Execute strSQL\r\nOn Error GoTo 0\r\nstrSQL = \"CREATE TABLE \" & strZieltabelle & \"(\"\r\nIf Len(strPrimaerschluessel) > 0 Then\r\n strFelder = strFelder & \"[\" & strPrimaerschluessel & \"] COUNTER CONSTRAINT [\" & CreateGUID _\r\n & \"] PRIMARY KEY, \"\r\nEnd If\r\nDo While Not rst.EOF\r\n With rst\r\n If Not rst!Auslassen Then\r\n If rst!Primaerschluessel Then\r\n strFelder = strFelder & \"[\" & !Feldname & \"] \" & DLookup(\"SQLText€, \"tblDatentypen€, _\r\n \"DatentypID = \" & !Datentyp) & \"CONSTRAINT [\" & CreateGUID & \"] PRIMARY KEY, \"\r\n Else\r\n strFelder = strFelder & \"[\" & !Feldname & \"] \" & DLookup(\"SQLText€, \"tblDatentypen€, _\r\n \"DatentypID = \" & !Datentyp) & \", \"\r\n End If\r\n End If\r\n Select Case !Indiziert\r\n Case 1, 2\r\n intConstraints = intConstraints + 1\r\n ReDim Preserve strIndizes(intConstraints)\r\n If !Indiziert = 2 Then\r\n strConstraint = \"UNIQUE \"\r\n Else\r\n strConstraint = \"\"\r\n End If\r\n strIndizes(intConstraints) = \"CREATE \" & strConstraint & \"INDEX [\" & CreateGUID & \"] ON [\" _\r\n & strZieltabelle & \"]([\" & !Feldname & \"])€\r\n End Select\r\n End With\r\n rst.MoveNext\r\nLoop\r\nstrFelder = Left(strFelder, Len(strFelder) - 2)\r\nstrSQL = strSQL & strFelder & \")€\r\ncnn.Execute strSQL\r\nOn Error Resume Next\r\nFor i = LBound(strIndizes) To UBound(strIndizes)\r\n cnn.Execute strIndizes(i)\r\nNext i\r\nApplication.RefreshDatabaseWindow\r\nOn Error GoTo 0\r\nrst.Close\r\nSet rst = Nothing\r\nSet db = Nothing\r\nEnd Sub<\/pre>\n
CREATE TABLE tblTaetigkeiten([TaetigkeitID] COUNTER CONSTRAINT [{5F719D56-1E79-4A46-99DF-EC3A47657085}] PRIMARY KEY, [Startzeit:] DATETIME, [Endzeit] DATETIME, [Beschreibung] TEXT(255))\r\n CREATE INDEX [{A843FEE7-E830-47D9-A205-43C99D3119C1}] ON [tblTaetigkeiten]([Startzeit:])<\/pre>\n\n
INSERT INTO tblTaetigkeiten(Startzeit,\r\n Beschreibung)\r\n SELECT F1, F3 FROM [Tabelle1$A6:C8]\r\n IN €\u00cbœC:\\beispieldatei.xls€\"¢\r\n [Excel 8.0;HDR=No;IMEX=1]<\/pre>\n
Public Sub InBestehendeTabelleImportieren(strZieltabelle As String, _\r\n bolSpaltenueberschriften As Boolean, _\r\n strExcelsheet As String, strDateiname As String, _\r\n lngX1 As Long, lngY1 As Long, lngX2 As Long, lngY2 As Long)\r\n €\u00cbœDeklarationen ...\r\n If bolSpaltenueberschriften Then\r\n lngY1 = lngY1 + 1\r\n End If\r\n strBereich = GetExcelRangeFromLong(lngX1, lngX2, lngY1, lngY2)\r\n Set db = CurrentDb\r\n Set cnn = CurrentProject.Connection\r\n Set rst = db.OpenRecordset(\"SELECT * FROM tblZuordnungen€, _\r\n dbOpenDynaset)\r\n strSQL = \"INSERT INTO [\" & strZieltabelle & \"](\"\r\n strSelect = \"SELECT \"\r\n Do While Not rst.EOF\r\n i = i + 1\r\n If Not rst!Auslassen Then\r\n strFelder = strFelder & \"[\" & rst!Feldname & \"], \"\r\n strSelectFelder = strSelectFelder & \"F€ & i & \", \"\r\n End If\r\n rst.MoveNext\r\n Loop\r\n strFelder = Left(strFelder, Len(strFelder) - 2)\r\n strSelectFelder = Left(strSelectFelder, Len(strSelectFelder) - 2)\r\n strSQL = strSQL & strFelder\r\n strSQL = strSQL & \")€\r\n strSelect = strSelect & strSelectFelder & \" FROM [\" _\r\n & strExcelsheet & \"$€ & strBereich & \"] IN €\u00cbœ\" _\r\n & strDateiname & \"€\u00cbœ [Excel 8.0;HDR=No;IMEX=1]€\r\n cnn.Execute strSQL & \" \" & strSelect\r\n rst.Close\r\n Set rst = Nothing\r\n Set db = Nothing\r\n End Sub<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n