{"id":55001236,"date":"2020-06-01T00:00:00","date_gmt":"2020-07-10T09:41:09","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1236"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Merkwuerdiges_KombinationsfeldVerhalten","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Merkwuerdiges_KombinationsfeldVerhalten\/","title":{"rendered":"Merkwürdiges Kombinationsfeld-Verhalten"},"content":{"rendered":"

\"\"<\/p>\n

Das Problem, das sich hinter dem Titel verbirgt, ist möglicherweise nicht auf das Verhalten von Kombinationsfeldern beschränkt – es ist jedoch der Punkt, an dem es uns dank einer Leseranfrage aufgefallen ist. Diese enthielt die Frage, warum die „Automatisch ergänzen“-Funktion für Kombinationsfelder nicht mehr funktionierte. Das haben wir uns einmal genauer angeschaut und waren verblüfft über die Lösung: Eine Access-Option hat uns einen Strich durch die Rechnung gemacht.<\/b><\/p>\n

Um das Problem nachzustellen (wenn es in Ihrer aktuellen Access-Konfiguration besteht), erstellen Sie eine Tabelle namens tblAnreden <\/b>mit den beiden Feldern ID <\/b>(Primärschlüsselfeld mit Autowert) und Anrede <\/b>(Textfeld) und füllen diese mit zwei Datensätzen mit den Werten Herr <\/b>und Frau<\/b>.<\/p>\n

Dann erstellen Sie ein neues, leeres Formular und fügen diesem ein Kombinationsfeld hinzu. Stellen Sie für die Eigenschaft Datensatzherkunft <\/b>die soeben erstellte Tabelle tblAnreden <\/b>ein. Legen Sie für die beiden Eigenschaften Spaltenanzahl <\/b>und Spaltenbreiten <\/b>die Werte 2 <\/b>und 0cm <\/b>fest.<\/p>\n

Wenn Sie nun das Formular in der Formularansicht anzeigen und den ersten Buchstaben eines der Einträge eingeben, sollte das Kombinationsfeld wie in Bild 1 reagieren und den Inhalt automatisch ergänzen.<\/p>\n

\"So<\/p>\n

Bild 1: So soll die automatische Ergänzung funktionieren. <\/span><\/b><\/p>\n

Sollte Ihr Access-System jedoch eine bestimmte Einstellung aufweisen, dann geschieht genau das nicht – dann müssen Sie den Wert wie in Bild 2 komplett selbst eingeben oder halt per Kombinationsfeld auswählen.<\/p>\n

\"Unter<\/p>\n

Bild 2: Unter bestimmten Umständen funktioniert es jedoch nicht.<\/span><\/b><\/p>\n

Was die Lösung erschwert hat: Es konnte kein allgemeiner Bug sein, denn auf all meinen anderen Datenbanken hat das Kombinationsfeld wie erwartet funktioniert.<\/p>\n

Die Suche nach der Lösung<\/b><\/p>\n

Wie findet man nun die Lösung für ein solches Problem In Kurzform: Als erstes prüft man natürlich, ob die naheliegenden Eigenschaften unterschiedlich sind – also zum Beispiel ob Automatisch ergänzen <\/b>überhaupt aktiviert ist. Das war jedoch der Fall. <\/p>\n

Da die Kombinationsfelder in allen Datenbanken funktionierten außer in der meines Kunden, habe ich erst einmal ein einfaches Formular wie das zuvor beschriebene mit dem Kombinationsfeld zur Auswahl der Anreden erst in der Anwendung des Kunden erstellt und dann in einer meiner eigenen Anwendungen.<\/p>\n

Das Verhalten blieb gleich: In der Kundenanwendung keine automatische Ergänzung, in meinen Anwendungen schon.<\/p>\n

Dann habe ich die Formulare der beiden Anwendungen mit der folgenden Anweisung in Textdateien exportiert:<\/p>\n

Application.SaveAsText acForm, \"<Formularname>\", \"<Pfad>\"<\/pre>\n
Die so entstandenen Textdateien habe ich dann verglichen und keine nennenswerten Unterschiede gefunden.<\/p>\n
Danach habe ich mir überlegt, welche Eigenschaften einer Datenbank sich noch auf das Verhalten von Steuerelementen auswirken könnten und bin auf die Access-Optionen für die aktuelle Datenbank gekommen.<\/p>\n
Diese habe ich dann geöffnet und ein wenig herumexperimentiert. Ich dachte erst, ich hätte die Lösung, als ich die Eigenschaft Cacheformat verwenden, das mit Microsoft Access 2010 und höher kompatibel ist <\/b>deaktiviert habe (siehe Bild 3).<\/p>\n
\"Diese<\/p>\n
<\/p>\n
Bild 3: Diese Option führte kurzzeitig zum Erfolg.<\/span><\/b><\/p>\n
Direkt danach funktionierte die automatische Ergänzung wieder! Allerdings nur solange, bis ich die Datenbank geschlossen und wieder geöffnet habe. Auch wenn danach die oben genannte Option immer noch deaktiviert war, blieb die automatische Ergänzung aus. Der Verdacht, dass das Verhalten etwas mit den Optionen der Access-Datenbank zu tun hatte, erhärtete sich.<\/p>\n
Allerdings brachten Experimente mit den übrigen Eigenschaften aus dem Bereich Aktuelle Datenbank <\/b>keine neuen Erkenntnisse. Also holte ich die Holzhammer-Methode heraus. Ich wollte alle Optionen leeren beziehungsweise die, hinter denen eine Property der aktuellen Datenbank stand, löschen. Viele der Optionen kann man über die Properties<\/b>-Auflistung des Database<\/b>-Objekts der aktuellen Datenbankdatei einstellen.<\/p>\n
Dazu verwendete ich die folgende Prozedur. Diese deklariert zunächst eine Variable für das aktuelle Database<\/b>-Objekt namens db <\/b>und eine Laufvariable namens i<\/b>:<\/p>\n
Public Sub <\/span>DeleteAllCustomProperties()\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>i As Integer<\/span><\/pre>\n
Dann füllt sie die Database<\/b>-Variable db <\/b>und durchläuft in einer Schleife von der Anzahl der Elemente der Properties<\/b>-Auflistung minus 1 <\/b>bis zur Zahl 0<\/b>, wozu die Schrittweite mit Step -1 <\/b>festgelegt wird:<\/p>\n
     Set<\/span> db = CurrentDb\r\n     For i = db.Properties.Count - 1 To 0 Step -1<\/pre>\n
Innerhalb der Schleife geben wir den Namen des gerade durchlaufenen Property<\/b>-Elements im Direktfenster aus, allerdings ohne Zeilenumbruch. Wir wollen gleich noch einen Text zur jeweiligen Zeile hinzufügen. Dann deaktivieren wir die Fehlerbehandlung und versuchen das aktuelle Property<\/b>-Element zu löschen.<\/p>\n
Gelingt dies ohne Fehler, hängen wir den Text (gelöscht) <\/b>an den Namen des Property<\/b>-Elements. Gelingt dies nicht, handelt es sich vermutlich um ein eingebautes Property<\/b>-Element. In diesem Fall hängen wir den Text (nicht gelöscht) <\/b>an:<\/p>\n
         Debug.Print<\/span> db.Properties(i).Name;\r\n         On Error Resume Next<\/span>\r\n         db.Properties.Delete db.Properties(i).Name\r\n         If <\/span>Err.Number = 0 Then<\/span>\r\n             Debug.Print<\/span> \" (gelöscht)\"\r\n         Else<\/span>\r\n             Debug.Print<\/span> \" (nicht gelöscht)\"\r\n         End If<\/span>\r\n         On Error GoTo<\/span> 0\r\n     Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n
Nachdem wir auf diese Weise alle benutzerdefinierten Property<\/b>-Elemente des Database<\/b>-Objekts gelöscht haben, versuchen wir erneut, ob das automatische Ergänzen nun funktioniert. Und das ist tatsächlich der Fall! Nebenbei erhalten wir noch eine Liste aller gelöschten und nicht gelöschten Eigenschaften im Direktbereich.<\/p>\n
Bleibt nur noch eine Aufgabe: Welche der gelöschten Properties war nun verantwortlich für die Fehlfunktion der automatischen Ergänzung<\/p>\n
Dazu haben wir die Datenbank des Kunden wiederhergestellt und jede einzelne der Properties gelöscht, die Datenbank geschlossen, da sich Änderungen von Properties meist erst beim nächsten Öffnen der Datenbank auswirken, die Datenbank geöffnet und probiert, ob das automatische Ergänzen nun wieder funktioniert.<\/p>\n
Die fragliche Property war schließlich ANSI Query Mode<\/b>. Huh Genau: Das ist die Eigenschaft, die Sie im Bereich Objekt-Designer <\/b>der Access-Optionen unter Abfrageentwurf <\/b>finden und die dort SQL Server-kompatible Syntax (ANSI 92) <\/b>mit der Option In dieser Datenbank verwenden <\/b>heißt (siehe Bild 4).<\/p>\n
\"Die<\/p>\n
Bild 4: Die Option zum Einstellen von ANSI Query Mode<\/span><\/b><\/p>\n
Was genau hat diese Option mit der automatischen Ergänzung zu tun Dazu schauen wir uns erst einmal an, was diese Optionen überhaupt tun:<\/p>\n