{"id":55000733,"date":"2010-08-01T00:00:00","date_gmt":"2020-05-22T22:06:40","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=733"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Fehlertolerantes_Suchen","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/","title":{"rendered":"Fehlertolerantes Suchen"},"content":{"rendered":"

\"\"<\/p>\n

„Firma Waren-Paradies, Konstanze Meyer am Apparat. Was kann ich für Sie tun“ – „Ja, Katschmarek. Ich hatte letzte Woche eine Bestellung aufgegeben; die möchte ich gerne stornieren.“ – „Wie war der Name“ – „Katschmarek!“ Die Kundenbetreuerin Frau Meyer gibt den Namen in die Suchmaske des Kundenformulars ihrer Datenbank zur Bestellabwicklung ein. Die Datenbank findet den Kunden nicht. „Würden Sie den Namen bitte buchstabieren“ – „K-A-C-S-M-A-R-E-K“ – „Mit C-S“ – „Ja, genau!€ Ein Glück, dass Herr Kacsmarek nicht mit „Kaufmann-Anton-Cäsar-Samuel-Martha-…“ antwortete, denn dann hätte Frau Meyer wahrscheinlich nochmals nachgefragt …<\/b><\/p>\n

Dieser Fall ist wohl nicht selten. Hat man nur das gesprochene Wort zur Verfügung, so dürfte man mit der korrekten Schreibweise gerade von Namen häufig überfordert sein. Eine Datenbank, die Begriffe nur anhand exakter Übereinstimmung vergleicht, wird dem nicht gerecht.<\/p>\n

Dabei hätte der Entwickler der Datenbank Frau Meyer die Sache leichter machen können, wenn er Methoden zur fehlertoleranten Suche, eine „Unscharfsuche“, eingebaut hätte. Solche Routinen versuchen, zwei Begriffe auf größtmögliche Übereinstimmung zu vergleichen, und geben die plausibelsten Treffer in einer Liste zurück, aus der man schließlich den wahrscheinlichsten auswählen kann.<\/p>\n

Anwendungsbereiche für eine solche fehlertolerante Suche gibt es viele: Außer Nachnamen wären etwa Straßennamen Kandidaten, Bezeichnungen von Artikeln, Ländernamen oder selbst Telefonnummern, die Zahlendreher enthalten. Wenn auch Sie den Benutzern Ihrer Datenbanken ähnlichen Komfort bieten möchten, dann integrieren Sie einfach eine Lösung, wie die nachfolgend vorgestellte.<\/p>\n

Was ist ähnlich<\/b><\/p>\n

Bevor man einen Algorithmus entwickelt, der zwei Strings auf ähnlichkeit untersucht, muss man sich zunächst fragen, was unter „ähnlichkeit“ überhaupt zu verstehen ist. Was für den Cortex eines Menschen kein Problem zu sein scheint, bereitet dem Linguisten und erst recht dem Programmierer erhebliches Kopfzerbrechen.<\/p>\n

Zudem kann die Fehlerquelle für falsche Schreibweise auch noch ganz unterschiedlich sein. Im Beispiel oben handelt es sich um ein phonetisches Problem: die Aussprache beider Begriffe ist identisch, ihre Länge unterscheidet sich aber um zwei Buchstaben. Von den Lauten her hat Frau Meyer nichts falsch gemacht.<\/p>\n

Doch selbst dann, wenn sie ungarische Vorfahren hätte und die richtige Schreibweise wüsste, hätte ihr ein Schreibfehler unterlaufen und die Eingabe „Kascmarek“ sein können – sie hat sich schlicht vertippt. Die Aufgabe liegt also darin, einerseits Schreib- und Tippfehler aufzufangen und andererseits phonetische ähnlichkeiten zu erkennen.<\/p>\n

Die rein programmtechnische Frage ist außerdem, wie eine ähnlichkeitsfunktion das Maß der Übereinstimmung widergeben soll. Es haben sich hier zwei Verfahren eingebürgert, die sinnbildlich so aussehen:<\/p>\n

fuSimilar (\"Begriff1\" , \"Begriff2\") = TRUE oder FALSE\r\nfuSimilar (\"Begriff1\" , \"Begriff2\") = 0...100<\/pre>\n
Im ersten Fall sagt die Funktion lediglich, ob die Begriffe überhaupt ähnlich sind oder nicht (Ja oder Nein).<\/p>\n
Im zweiten wird ein Wert zurückgegeben, der mit 100 völlige Übereinstimmung, mit 0 überhaupt keine und dazwischen teilweise Übereinstimmung feststellt.<\/p>\n
Phonetik<\/b><\/p>\n
Viele Algorithmen spezialisieren sich darauf, Begriffe zu vergleichen, die gleich oder möglichst ähnlich ausgesprochen werden. Dazu werden, bevor es zum eigentlichen String-Vergleich kommt, zunächst beide Begriffe einer phonetischen Analyse unterzogen. <\/p>\n
Nehmen wir mal den Namen „Becker“. Hier besteht die deutsche Eigentümlichkeit darin, dass ein „CK“ genau so ausgesprochen wird, wie das „K“ allein. Man könnte den String also analysieren und das „CK“ zunächst durch ein „K“ ersetzen.<\/p>\n
Nach dieser Vorbehandlung wären die beiden Begriffe „Becker“ und „Beker“ identisch. Ein Algorithmus mit phonetischem Präprozessor würde nun den Wert 100 für den Vergleich zurückgeben.<\/p>\n
Da dies nicht wirklich zutrifft, ziehen die gängigen Algorithmen hier einfach einen kleinen Ausgleichswert ab – etwa 10 -, falls der Präprozessor tatsächlich an den Eingangs-Strings geschraubt hat. In diesem Fall wäre das Ergebnis folglich 90, was man als „so gut wie, aber nicht identisch“ interpretieren könnte.<\/p>\n
Das Beispiel bietet noch mehr Potenzial: Im Deutschen lauten „E“ und „ä“ gleich. Somit kann ein „ä“ ebenfalls durch ein „E“ ersetzt werden. Das „ä“ wiederum könnte auch umlautlos als „AE“ daherkommen. Folgende Namen wären dann nach Durchlaufen des Präprozessors identisch:<\/p>\n
\"Becker\", \"Beker\", \"Bäker\", \"Bäcker\", \"Baeker\", \"Baecker\"<\/pre>\n
Alle sechs resultierten im vorbehandelten String „Beker“.<\/p>\n
Zu überlegen wäre auch, ob nicht Vokalverdoppelungen reduziert werden könnten:<\/p>\n
\"Beeker\" > \"Beker\"<\/pre>\n
Das Spiel kann beliebig fortgesetzt werden. So ist die Endung „er“ im Deutschen etwa weitgehend lautgleich mit „a“. Aus „Becker“ würde „Beka“.<\/p>\n
Damit das funktioniert, reicht ein einfaches Replace auf die Eingangs-Strings allerdings nicht aus. Soll alles korrekt laufen, so muss ein Begriff eigentlich in Silben aufgetrennt, die Position einer Zeichenkombination ermittelt und außerdem analysiert werden, ob vor einer Konsonantenkombination ein Vokal steht oder nicht.<\/p>\n
Und damit wären wir schon bei den Nachteilen eines phonetischen Präprozessors: Die Berechnung kostet sehr viel Zeit und ist nicht sehr zuverlässig, weil etwa eine Silbentrennung nicht mit hinreichender Performance zu bewerkstelligen ist.<\/p>\n
Außerdem funktioniert der phonetische Präprozessor nur für eine bestimmte Sprache. Im Slawischen etwa würde der Name „Becker“ eher wie „Betschker“ ausgesprochen. Wäre die Zielsprache also Serbisch, so benötigte man dafür einen völlig anderen Präprozessor.<\/p>\n
Gerade für Namensvergleiche eignet sich das Verfahren daher weniger, weil – siehe Eingangsbeispiel „Kacsmarek“ – internationale Namen im deutschen Sprachraum immer häufiger vorkommen.<\/p>\n
Aus Performancegründen verwenden ähnlichkeitsalgorithmen deshalb normalerweise nur sehr einfache phonetische Präprozessoren. Im Ergebnis sind sie dann mal besser, mal schlechter als Algorithmen ohne Präprozessor. Es kommt immer auf den genauen Anwendungsbereich an, ob man sie einsetzen sollte oder nicht.<\/p>\n
In der später vorgestellten Demo können Sie sich selbst ein Bild davon machen. Zwei der verwendeten Algorithmen können optional auch mit phonetischem Präprozessor betrieben werden. Testen Sie einfach, ob die phonetische Vorbehandlung etwas bringt.<\/p>\n
Vertippt<\/b><\/p>\n
Sie kennen das sicher: Sie tippen schnell mal ein Wort in die Tastatur und haben schließlich statt „Becker“ den Text „Bekcer“ auf dem Schirm – ein Verdreher. Oder die letzte Taste wurde nicht richtig gedrückt, was „Becke“ zum Ergebnis hat.<\/p>\n
Aufgabe der Datenbank soll nun sein, trotzdem den beabsichtigten Begriff zu finden. Wie kann man das anstellen<\/p>\n
ähnlichkeitsalgorithmen<\/b><\/p>\n
Fast alle gängigen Algorithmen verwenden für unseren Zweck das sogenannte Distanz-Verfahren. Am bekanntesten ist die Levenshtein-Distanz, benannt nach ihrem Schöpfer.<\/p>\n
Dabei wird ermittelt, wie viele Zeichen der Eingangs-Strings jeweils an der gleichen Position genau übereinstimmen, beziehungsweise, ob sich eine übereinstimmende Position möglicherweise in der Nähe befindet.<\/p>\n
Sehen wir uns „Becker“ vs. „Bekcer“ näher an (s. Bild 1). An vier Positionen befinden sich übereinstimmende Zeichen, die den Gewichtungsfaktor 1 bekommen. Bei zwei Zeichen gibt es jeweils Übereinstimmung an um eins verschobenen Positionen. Diese werden nun willkürlich mit dem Faktor 0.5 belegt, was aussagen soll, dass eine mögliche Gleichheit besteht.<\/p>\n
\"becker.png\"<\/p>\n
Bild 1: Vergleich von Becker und Bekcer<\/span><\/b><\/p>\n
Bereits hier wird sichtbar, dass solche Berechnungen die Realität nur annähernd widerspiegeln und auf reinen, zum Teil stochastischen Annahmen beruhen. Und genau dies ist die Kunst solcher Algorithmen: Sie sollen dem, was ein Mensch als ähnlich empfindet, möglichst nahekommen.<\/p>\n
Deshalb gibt es auch Hunderte solcher Verfahren, die sich manchmal nur in kleinen, aber wichtigen Details unterscheiden, und ganze Studienprojekte beschäftigen ihre Eleven mit der Optimierung solcher Routinen.<\/p>\n
Wer hier einen näheren Blick riskieren will, der schaue sich auf der Seite von SimMetrics<\/b> [1] um, einem Open-Source-Projekt der englischen Universität Sheffield. Dort sind zahlreiche Algorithmen in einem Projekt zusammengefasst und bewertet worden, das auch als Visual Studio.NET-Paket zur Verfügung steht.<\/p>\n
Die jeweiligen Algorithmen sind darin übersichtlich in einzelnen C-Libraries abgelegt. Zur Warnung: Wie bei Uni-Projekten üblich, ist der Verständnis-Level hier nur eine Sache für wissenschaftlich Interessierte.<\/p>\n
Um beim Beispiel zu bleiben – in Bild 2 hat sich jemand noch mehr vertan. Die Buchstaben sind ziemlich durcheinander und doch erkennt man mit dem Auge auf einen Blick, dass ähnlichkeit zwischen beiden Begriffen besteht, obwohl nur drei Zeichen an der korrekten Position übereinstimmen. Die anderen sind mehr oder weniger verschoben und dem tragen die Faktoren 0.5 und 0.25 Rechnung.<\/p>\n
\"becker2.png\"<\/p>\n
Bild 2: Vergleich von Becker und Bekecr<\/span><\/b><\/p>\n
Letztlich summiert man nun die Gewichtungsfaktoren und setzt sie in Beziehung zur durchschnittlichen Gesamtzahl an Zeichen beider Strings. Im letzten Beispiel:<\/p>\n
f = 4.25\/6 = 0.7083<\/pre>\n
Da die Rückgabewerte im Bereich von 0 bis 100 liegen sollen, wird dieses Ergebnis noch mit 100 multipliziert, gerundet und Sie erhalten 71.<\/p>\n
In der praktischen Auswertung würde man nun ein Limit setzen und annehmen, dass etwa alle Ergebnisse oberhalb von 75 als hinreichend ähnlich anzusehen seien. In diesem Fall fiele das letzte Beispiel aus der Liste der plausiblen Ergebnisse heraus, das vorige aber genügte der Bedingung:<\/p>\n
f = Round (5\/6 * 100) = 83<\/pre>\n
Übrigens kommt derselbe Wert auch dann heraus, wenn man „Becker“ und „Wecker“ vergleicht. Dieses Ergebnis kann man schon weniger akzeptieren. Doch dafür gibt es leider keine Regel: Es hat sich stochastisch schlicht ergeben, dass der Anfangsbuchstabe seltener falsch geschrieben wird.<\/p>\n
<\/p>\n
Also belegen viele Verfahren den ersten oder die ersten Zeichen beim Vergleich mit höheren Gewichtungsfaktoren. Würde man etwa die Übereinstimmung des ersten Zeichens mit dem Faktor 2 versehen, dann sähe die Rechnung wie folgt aus:<\/p>\n
\"BECKER\" vs. \"BECLER\"<\/pre>\n
Fünf Zeichen stimmen überein, eines nicht. Das erste Zeichen bekommt aber den Faktor 2, sodass die Summe 6 ergibt. Der eine Faktor 2 muss nun natürlich in den Längendivisor mit einbezogen werden, weshalb als Ergebnis 6\/(6+1) = 86 steht.<\/p>\n
\"BECKER\" vs. \"WECKER\"<\/pre>\n
Auch hier stimmen fünf Zeichen überein. Da der Anfangsbuchstabe jedoch falsch ist, fehlt nun der Faktor 2: 5\/6 = 83. <\/p>\n
In einer Liste möglicher Treffer, die absteigend nach dem ähnlichkeitswert sortiert wäre, befände sich also „BECLER“ weiter oben.<\/p>\n
Abschließend der Hinweis, dass diese Darstellung lediglich das Grundprinzip des Distanzverfahrens widergibt. Die tatsächlichen Implementationen sind deutlich komplexer. Um diese brauchen Sie sich allerdings auch nicht weiter zu kümmern, denn Sie selbst werden wahrscheinlich keine eigenen Algorithmen entwickeln wollen. Überlassen Sie das ruhig den Professoren an den Instituten.<\/p>\n
Es ist nur gut zu wissen, wie die Verfahren prinzipiell arbeiten, um deren Ergebnisse besser interpretieren zu können.<\/p>\n
Implementationen<\/b><\/p>\n
Von den Verfahren, die weite Verbreitung erfahren haben, ist in erster Linie der uralte Soundex-Algorithmus (1918!) zu erwähnen. Dieser abstrahiert Eingabe-Strings stark, indem er daraus einen Zeichencode mit genau vier Zeichen erzeugt.<\/p>\n
Dabei werden nur die vorderen Buchstaben berücksichtigt, die hinteren abgeschnitten und außerdem Buchstabengruppen Zahlen zugeordnet. Es werden auch nur Konsonanten in die Berechnung einbezogen.<\/p>\n
Aus „Becker“ wird etwa „B226“. Den exakt gleichen Code erhält man auch mit der Eingabe „Busserl“. Soundex sieht zwei Strings als ähnlich an und gibt dann eine 1 aus, wenn die errechneten Codes genau übereinstimmen, und andernfalls eine 0. Im Grunde handelt es sich damit bei Soundex um einen Präprozessor.<\/p>\n
Ob „Becker“ und „Busserl“ tatsächlich ähnlich sind, mag jeder selbst entscheiden, und außerdem, ob die Ausgabewerte 1 <\/b>und 0 <\/b>den Anforderungen an eine fehlertolerante Suche wirklich genügen. Abgesehen davon, dass Soundex nur den Anfang eines Begriffs untersucht, die Konsonanten stark reduziert und Vokale außen vor lässt, ist er auch noch auf die englische Sprache „optimiert“.<\/p>\n
Ich mache keinen Hehl aus meiner Einschätzung, dass Soundex für eine ernsthafte ähnlichkeitssuche nicht zu gebrauchen ist, obwohl er sogar in die SQL-Funktionen von DBMS wie MSSQL, Oracle und MySQL aufgenommen wurde – warum auch immer.<\/p>\n
Daran ändert leider auch der abgeleitete und etwas verbesserte Metaphone-Algorithmus nichts. Metaphone erzeugt nicht nur vier Zeichencodes, sondern beliebig lange, und teilt die Konsonanten nicht nur in sechs Gruppen ein. Er ist aber ebenso auf die englische Sprache abgestimmt und gibt als Ergebnis lediglich eine 1 <\/b>oder eine 0 <\/b>zurück.<\/p>\n
Diese beiden Algorithmen sind hier nur der weiten Verbreitung wegen erwähnt worden. Mit dem oben dargestellten Distanzverfahren haben sie nichts zu tun. Dessen wichtigster Vertreter wiederum ist der bereits 1965 entwickelte Levenshtein-Algorithmus. <\/p>\n
Er arbeitet im Prinzip ziemlich genau so, wie im „Becker-Beispiel“ erläutert, hat aber den Nachteil, dass keine variablen Gewichtungen eingerechnet werden und kein Präprozessor vorgesehen ist.<\/p>\n
Deshalb haben sich Myriaden von Entwicklern an seine Verbesserung gemacht. Daraus haben sich Verfahren wie Ratcliff\/Obershelp und die von Jaro und Winkler ergeben. Beide sind relativ neueren Datums – entwickelt Mitte der Neunziger Jahre – und kommen in der Demo zu diesem Beitrag zum Einsatz.<\/p>\n
Wie sie genau funktionieren, lasse ich außen vor und ebenso die ganzen anderen Verfahren, die Sie etwa im SimMetrics-Paket [1] finden können.<\/p>\n
Beispieldatenbank<\/p>\n
Starten Sie die Beispieldatenbank similar.mdb<\/b>, die lediglich ein Formular (s. Bild 3) enthält, in dem ein wählbarer Name nach verschiedenen Methoden mit 10.000 Stammdatensätzen auf ähnlichkeit verglichen wird. Als Ergebnis erhalten Sie eine gefilterte Liste der zutreffendsten Nachnamen aus der Stammdatentabelle.<\/p>\n
\"demoform.png\"<\/p>\n
Bild 3: ähnlichkeitsvergleich eines Namens mit den Stammdaten einer Tabelle<\/span><\/b><\/p>\n
Die Datenbank greift teilweise auf externe Komponenten zu, auf die Verweise gesetzt sind. Das sind die beiden ActiveX-DLLs dbstrings.dll <\/b>und mSimilarity.dll<\/b>. Damit beim Start der Demo keine Fehlermeldungen wegen nicht vorhandener Verweise auftauchen, müssen diese beiden DLLs zunächst im System registriert werden.<\/p>\n
Dazu führen Sie einfach die Datei register_dll.bat <\/b>aus. Unter Vista und Windows 7 muss sie dezidiert mit Als Administrator ausführen<\/b> aufgerufen werden, unter Windows XP sollten Sie unter einem Administrator-Account arbeiten.<\/p>\n
Die Stammdatentabelle, auf die das Formular aufsetzt, ist sehr einfach gestrickt: Neben der Primärschlüssel-ID gibt es nur ein Feld für Nachname (Name<\/b>) und eins für den Vornamen einer Person.<\/p>\n
Auf das Nachname-Feld ist ein Index gesetzt – das sollte man grundsätzlich tun, wenn dieses Feld später in Such- und Vergleichsoperationen einbezogen werden soll.<\/p>\n
Schreiten Sie zur Tat: In das oberste Textfeld des Formulars geben Sie einen beliebigen Namen ein, wahlweise mit falscher Schreibweise, oder belassen es beim voreingetragenen Katschmarek. Wählen Sie ein Vergleichsverfahren über die Optionsgruppe aus und klicken Sie auf die Schaltfläche Suchen<\/b>.<\/p>\n
Daraufhin wird eine Abfrage ausgeführt, die ähnlichkeitsfunktionen des Moduls mdlPhonetics <\/b>aufruft.<\/p>\n
Das Ergebnis der nach ähnlichkeit absteigend sortierten Abfrage bekommen Sie anschließend im Unterformular zu Gesicht, und außerdem wird noch angezeigt, wie lange die Abfrage für ihre Berechnung in Millisekunden brauchte, sodass Sie die Performance der einzelnen Verfahren beurteilen können. Auf die Funktionsweise der Methoden wird im Folgenden noch näher eingegangen.<\/p>\n
Warum, werden Sie vielleicht fragen, braucht es da wieder einmal externe Komponenten, deren Weitergabe und Registrierung dem Entwickler das Leben schwer machen<\/p>\n
Die Antwort finden Sie schnell, wenn Sie die beiden Methoden Ratcliff Schmidt Prepared <\/b>und Ratcliff Schmidt Prepared VBA <\/b>ausführen. Beide verwenden den gleichen Code, nur dass im einen Fall der Code rein in VBA gehalten ist (clsRatcliffSchmidtVBA<\/b>), im anderen in einer unter VB6 erstellten und kompilierten DLL untergebracht ist. Die Ausführungszeit unterscheidet sich um den Faktor 7! <\/p>\n
Da VBA nur halbkompilierten P-Code erzeugt, eine VB6-DLL bei entsprechender Einstellung aber nativen Prozessor-Code, kann es in der Performance gerade bei einfachen Operationen nicht mithalten.<\/p>\n
Und das auch dann, wenn, wie in der Klasse clsRatcliffSchmidtVBA<\/b>, ausschließlich mit Integer-Arrays gearbeitet wird und nicht direkt mit String-Operationen, was die Sache nochmals langsamer machen würde.<\/p>\n
Kommen wir zum Beispielformular zurück. Alle Optionen, bis auf das nur der Vollständigkeit hinzugefügte LIKE<\/b>, verwenden als Basis eine Abfrage, die wie in Bild 4 aussieht. Der SQL-Ausdruck dieser Abfrage ist hier wiedergegeben:<\/p>\n
\"abfrage.png\"<\/p>\n
Bild 4: Abfrage zum Filtern der Stammdatentabelle über eine ähnlichkeitsfunktion<\/span><\/b><\/p>\n
SELECT TOP 25 Stammdaten.[Name],\r\nFirst(Stammdaten.Vorname) AS Vorname, RatcliffSchmidt([Name]) AS n\r\nFROM Stammdaten\r\nGROUP BY Stammdaten.[Name]\r\nHAVING (RatcliffSchmidt([Name]))>=MinSim())\r\nORDER BY RatcliffSchmidt([Name]) DESC;<\/pre>\n
Damit im Ergebnis nur eindeutige Nachnamen erscheinen, also Datensätze mit dem gleichen Nachnamen nicht mehrfach auftreten, ist die Abfrage nach diesem Feld gruppiert. Außerdem wird die Ergebnisliste abgeschnitten, damit sie nicht zu viele Datensätze zurückgibt, was über den TOP<\/b>-Operator geschieht.<\/p>\n
Auf die Ausgabe des Vornamens hätte man auch verzichten können. Sie ist nur kosmetischer Natur.<\/p>\n
Der Kern der Abfrage steht in der dritten Spalte, in der der Vergleichswert n <\/b>zwischen dem Feld Nachname <\/b>und dem in das Formular eingegebenen Text errechnet wird – hier mittels der Funktion RatcliffMoss<\/b>. Doch wo findet sich in der Abfrage dieser im Formular eingegebene Begriff als Vergleichsparameter<\/p>\n
Gar nicht, denn er wurde in eine VBA-Routine ausgelagert:<\/p>\n
Public Function RatcliffMoss(S1 As String) _\r\n    As Integer\r\n    RatcliffMoss = _\r\n    dbstrings.RatcliffSimilar(S1, sComp)\r\nEnd Function<\/pre>\n
Da Abfragen nicht Funktionen aus verwiesenen Bibliotheken direkt ansprechen können, braucht man ohnehin eine VBA-Funktion als Mittler. Die Funktion RatcliffMoss <\/b>verwendet dabei die Bibliothek dbstrings <\/b>aus der gleichnamigen DLL.<\/p>\n
Als Eingabeparameter erwartet sie einen String, der hier aus dem Namensfeld der Tabelle kommt, und vergleicht ihn mit einem String der Variablen sComp<\/b>. Diese Variable ist global deklariert und wurde zuvor mit dem im Formular eingegebenen Text besetzt.<\/p>\n
Auf diese Weise schlägt man zwei Fliegen mit einer Klappe.<\/p>\n
Bliebe noch der als Kriterium für den Vergleichswert in der Abfrage vorhandene Ausdruck MinSim()<\/b>. Auch das ist eine VBA-Funktion, die lediglich den Wert einer globalen Integer-Variablen m_factor <\/b>zurückgibt, welche vorher über das Kombinationsfeld Limit<\/b> im Formular gesetzt wurde:<\/p>\n
Public Function MinSim() As Integer\r\n    MinSim = m_factor\r\nEnd Function<\/pre>\n
Damit kann man schon im Formular einstellen, wie groß die Trefferliste sein soll. Je kleiner dieser Limit<\/b>-Wert ist, desto größere Abweichungen der ähnlichkeit werden berücksichtigt. Zur Erinnerung: Der Wert 100 <\/b>symbolisiert vollständige Übereinstimmung, der Wert 0 <\/b>sagt aus, dass keinerlei ähnlichkeit vorhanden ist. Alle Werte dazwischen versinnbildlichen „mehr oder weniger ähnlich“.<\/p>\n
Als plausible Limits haben sich Werte um die 70<\/b> herum herausgestellt.<\/p>\n
Jedes der Verfahren im Formular benutzt eine Abfrage nach diesem Aufbau, die ihrerseits jeweils eine eigene VBA-Funktion für den String-Vergleich aufruft. Das Abfrageergebnis wird schließlich einfach dem Unterformular sfrmDemo<\/b> als RecordSource <\/b>zugewiesen, was die Liste zur Anzeige bringt.<\/p>\n
Ratcliff und Konsorten<\/b><\/p>\n
Ich habe mich aus Gründen der Verfügbarkeit und der Leistungsfähigkeit für zwei Verfahren entschieden: Ratcliff und Jaro-Winkler. Für den Ratcliff-Algorithmus gibt es dabei mehrere Varianten, die sich auch ein wenig im Ergebnis unterschieden, weil der Algorithmus in verschiedenen Modifikationen implementiert sein kann.<\/p>\n
Die dbstrings.dll <\/b>wurde in Delphi programmiert und enthält nur eine einzige Funktion: RatcliffSimilar<\/b>.<\/p>\n
Nach Übergabe zweier Strings gibt sie den Übereinstimmungswert zurück:<\/p>\n
n = RatCliffSimilar ( String1, String2)<\/pre>\n
Statt in Abfragen kann man sie natürlich auch sonst wo in VBA-Routinen einsetzen und etwa Recordsets durchlaufen.<\/p>\n
Der Quellcode für die Bibliothek stammt übrigens aus Routinen der inzwischen verschollenen Schmiede Mindsprings Corp., wobei Teile in Assembler ausgeführt sind. RatcliffSimilar <\/b>bewertet den Anfangsbuchstaben und vollständige Vorkommen von Substrings höher.<\/p>\n
Dass VB6 nicht langsamer sein muss als Assembler oder C, zeigt die DLL mSimilarity<\/b>, welche alle weiteren Verfahren beherbergt. <\/p>\n
Die Methode RatcliffSchmidt <\/b>wurde von Olaf Schmidt [2] entwickelt, sicherlich einen der gewieftesten VB6-Programmierer überhaupt. Den Quellcode seiner Routinen können Sie sich im Klassenmodul clsRatcliffSchmidtVBA <\/b>ansehen.<\/p>\n
Die Eingabe-Strings werden hier zunächst in Integer-Arrays überführt und anschließend werden Vergleichoperationen ausschließlich über numerische Werte vorgenommen, was die Performance erheblich erhöht, weil VB bei String-Operationen sehr langsam ist.<\/p>\n
Im Grunde arbeiten die Routinen damit ähnlich wie Codes auf C-Basis, die mit Zeigern hantieren. Eine erschöpfende Darstellung der Programmiertechniken würde an dieser Stelle den Rahmen sprengen.<\/p>\n
RatcliffSchmidt <\/b>enthält einen Präprozessor, der in der DLL-Ausführung optional auch ausgeschaltet werden kann. Der Aufruf geschähe dann so:<\/p>\n
n = RatcliffSchmidt( String1, String2, False)<\/pre>\n
Mit True<\/b> statt False <\/b>ist er eingeschaltet. Dieser optionale Parameter stellt eine Erweiterung meinerseits dar.<\/p>\n
Jaro-Winkler ist ebenfalls ein Distanzverfahren. Meine Implementation in der mSimilarity.dll <\/b>leitet sich von verschiedenen C-Sources ab. Die internen Gewichtungsfaktoren und der hier ebenfalls optionale Präprozessor sind Marke Eigenbau.<\/p>\n
Beim Präprozessor, der die Routine etwas verlangsamt, wurde versucht, besser auf den Wechsel von Vokalen und Konsonanten in den Strings zu reagieren, was Fehler bei zusammengesetzten Wörtern verringern soll. Zudem wurden mehr Konsonanten- und Vokalkombinationen berücksichtigt als bei Schmidts Präprozessor.<\/p>\n
Ansonsten arbeitet auch diese Methode intern mit Integer-Arrays und Pseudo-Zeigern und ist hinreichend schnell.<\/p>\n
Performance<\/b><\/p>\n
Zur Messung der Geschwindigkeiten aller Verfahren befindet sich in der Demo das Modul mdlPerformance<\/b>, in dem die beiden Prozeduren CheckPerformance1 <\/b>und CheckPerformance2<\/b> aufgerufen werden können.<\/p>\n
Die zweite Prozedur vergleicht in einer Schleife dauernd zwei feste Strings, die erste durchläuft alle Datensätze eines Recordsets, was eher den Aufgaben einer Datenbank gerecht wird.<\/p>\n
Der Spitzenreiter ist Schmidts Ratcliff-Verfahren, etwas langsamer ist die dbstrings-Variante. Jaro-Winkler hält gut mit, kann aufgrund des etwas komplexeren Distanzverfahrens aber Ratcliff nicht ganz das Wasser reichen. Mit eingeschaltetem Präprozessor verdoppelt sich dessen Laufzeit.<\/p>\n
Das Schlusslicht bildet die reine VBA-Variante, die hier glatt um den Faktor 25 langsamer ist als die identische Implementation in der DLL.<\/p>\n
RatcliffSchmidt<\/b> schafft in einer Sekunde durchschnittlich circa 700.000 Vergleichsaufrufe. Das hängt aber auch davon ab, wie lang die Eingabe-Strings sind!<\/p>\n
In eine Abfrage aufgenommen, relativieren sich diese Werte deutlich, weil JET schließlich noch Zeit für ganz andere Berechnungen benötigt. Bis auf die VBA-Variante lassen sich alle Verfahren gut in Datenbanken einsetzen.<\/p>\n
Ergebnisse<\/b><\/p>\n
Geschwindigkeit allein nützt nichts, wenn das Ergebnis schwach ausfällt. Geben Sie in das Demoformular verschiedene Namen ein, überprüfen Sie die Ergebnisliste mit den vorhandenen Verfahren und ändern Sie gegebenenfalls den Limit-Parameter, denn die Rückgabewerte der Algorithmen sind nicht exakt übertragbar.<\/p>\n
Sowohl die absoluten Werte machen änderungen am Limit notwendig, wie auch die „Spreizung“ nach ähnlichkeit. Der voreingestellte Wert 70 <\/b>ist schon mal ein guter Default für die meisten Zwecke. Nur Jaro-Winkler mit Präprozessor braucht manchmal ein niedrigeres Limit von etwa 60<\/b>.<\/p>\n
Sie werden feststellen, dass es kein Verfahren gibt, dem grundsätzlich der Vorzug zu geben wäre. Jedes hat seine Stärken und Schwächen. <\/p>\n
So führen die Prepared-Varianten (Präprozessor eingeschaltet) manchmal gar zu schlechteren Werten, weil Zeichenkombinationen falsch interpretiert werden.<\/p>\n
Gut sind Präprozessoren, wenn in der Quelle häufig Schreibweisen ohne Umlaute vorkommen, wie etwa „Gäbler“ vs. „Gaebler“. Schlechter hingegen können sie sein, wenn viele nichtdeutsche Begriffe vorkommen. Oben hatten wir diesen Fall mit „Kacsmarek“. <\/p>\n
RatCliffMoss <\/b>ist guter Allrounder, während bei RatcliffSchmidt <\/b>die Spreizung der ähnlichkeitswerte etwas größer ist, sodass weniger unplausible Begriffe in der Ergebnisliste auftauchen.<\/p>\n
Jaro-Winkler <\/b>ist vielleicht noch etwas treffgenauer, aber dafür auch langsamer.<\/p>\n
Jaro-Winkler <\/b>mit Präprozessor eliminiert wahrscheinlich am besten unsinnige Ergebnisse, braucht dafür aber auch einen ziemlich genau justierten Limit-Parameter. <\/p>\n
Einsatz<\/b><\/p>\n
Wenn Sie die Lösungen in Ihre eigenen Datenbanken aufnehmen wollen, dann verwenden Sie als Basis am besten das Modul mdlPhonetics<\/b>.<\/p>\n
Und denken Sie daran, die jeweilige DLL weiterzugeben und zu registrieren – mit einer Ausnahme: Das Registrieren auf dem Zielsystem können Sie sich ersparen, wenn Sie die DirectCOM<\/b>-Lösung nehmen.<\/p>\n
Dazu ist wiederum die Zusatz-DLL directcom.dll <\/b>von Olaf Schmidt nötig, die das Instanzieren von Klassenobjekten in externen Komponenten über API-Funktionen auch ohne deren Registrierung schafft.<\/p>\n
Dann benötigen Sie auch zusätzlich das Klassenmodul clsRatcliffDirectCOM <\/b>der Demodatenbank. Wer also auf dem Zielsystem keine Administratorrechte vorfindet, sollte diese Lösung erwägen.<\/p>\n
Alles Weitere bleibt Ihnen überlassen. Als Anregung hier der Aufbau einer realistischen Lösungsvariante:<\/p>\n
Anforderung war, dass in Klienten-Datensätzen nach Eingabe des Straßennamens und der Hausnummer automatisch von der Datenbank die Postleitzahl in das entsprechende Formularfeld eingetragen werden soll. Dazu gleicht die eingebaute Routine den Straßennamen mit einer Tabelle ab, die beispielsweise alle Straßennamen Berlins enthält.<\/p>\n
Findet sie keine exakte Übereinstimmung, so tritt die ähnlichkeitssuche auf den Plan. Die Straßennamen werden nun analog zum Demoformular der Beispieldatenbank mit der RatcliffSimilar<\/b>-Methode abgeglichen, die Ergebnisliste wird in einem Popup-Formular präsentiert und mit dem Hinweis versehen, dass keine solche Straße existiere und man nun bitte in der Liste den zutreffenden Eintrag anklicken möge. Erst danach wird aus einer weiteren Hausnummerntabelle die zur Straße gehörige Postleitzahl ermittelt und ins Formularfeld eingetragen. <\/p>\n
Zusammenfassung<\/b><\/p>\n
ähnlichkeitsvergleiche werden eigentlich in fast jeder Datenbank benötigt. Dass sie nur selten implementiert werden, liegt wohl daran, dass Access und JET von Haus aus keine entsprechenden Funktionen vorhalten.<\/p>\n
Mit den hier vorgestellten Lösungen rund um zwei frei verfügbare ActiveX-DLLs wird diesem Umstand abgeholfen. Testen Sie die Ergebnisse und entscheiden sich am besten für einen passenden Algorithmus für Ihren Einsatzbereich. Die Entscheidung wird davon beeinflusst, ob Sie etwa nach Nachnamen, Straßennamen oder Artikelbezeichnungen suchen möchten.<\/p>\n
Sie können uns gerne mitteilen, welche Lösung Sie für die leistungsfähigste halten.<\/p>\n
Quellen:<\/p>\n
[1] SimMetrics: http:\/\/www.dcs.shef.ac.uk\/~sam\/simmetrics.html<\/p>\n
[2] Olaf Schmidt: http:\/\/www.thecommon.net<\/p>\n
Downloads zu diesem Beitrag<\/h3>\n
Enthaltene Beispieldateien:<\/p>\n
Demo.zip<\/p>\n
Download<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
„Firma Waren-Paradies, Konstanze Meyer am Apparat. Was kann ich für Sie tun“ – „Ja, Katschmarek. Ich hatte letzte Woche eine Bestellung aufgegeben; die möchte ich gerne stornieren.“ – „Wie war der Name“ – „Katschmarek!“ Die Kundenbetreuerin Frau Meyer gibt den Namen in die Suchmaske des Kundenformulars ihrer Datenbank zur Bestellabwicklung ein. Die Datenbank findet den Kunden nicht. „Würden Sie den Namen bitte buchstabieren“ – „K-A-C-S-M-A-R-E-K“ – „Mit C-S“ – „Ja, genau!“ Ein Glück, dass Herr Kacsmarek nicht mit „Kaufmann-Anton-Cäsar-Samuel-Martha-…“ antwortete, denn dann hätte Frau Meyer wahrscheinlich nochmals nachgefragt …<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662010,66042010,44000025],"tags":[],"class_list":["post-55000733","post","type-post","status-publish","format-standard","hentry","category-662010","category-66042010","category-VBA_und_Programmiertechniken"],"yoast_head":"\nFehlertolerantes Suchen - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Fehlertolerantes Suchen\" \/>\n<meta property=\"og:description\" content=\""Firma Waren-Paradies, Konstanze Meyer am Apparat. Was kann ich für Sie tun" - "Ja, Katschmarek. Ich hatte letzte Woche eine Bestellung aufgegeben; die möchte ich gerne stornieren." - "Wie war der Name" - "Katschmarek!" Die Kundenbetreuerin Frau Meyer gibt den Namen in die Suchmaske des Kundenformulars ihrer Datenbank zur Bestellabwicklung ein. Die Datenbank findet den Kunden nicht. "Würden Sie den Namen bitte buchstabieren" - "K-A-C-S-M-A-R-E-K" - "Mit C-S" - "Ja, genau!" Ein Glück, dass Herr Kacsmarek nicht mit "Kaufmann-Anton-Cäsar-Samuel-Martha-..." antwortete, denn dann hätte Frau Meyer wahrscheinlich nochmals nachgefragt ...\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2020-05-22T22:06:40+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg06.met.vgwort.de\/na\/c493928b7cec4a60a4a8fda88b8c459a\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"22\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"Fehlertolerantes Suchen\",\"datePublished\":\"2020-05-22T22:06:40+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/\"},\"wordCount\":4281,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg06.met.vgwort.de\\\/na\\\/c493928b7cec4a60a4a8fda88b8c459a\",\"articleSection\":[\"2010\",\"4\\\/2010\",\"VBA und Programmiertechniken\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/\",\"name\":\"Fehlertolerantes Suchen - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg06.met.vgwort.de\\\/na\\\/c493928b7cec4a60a4a8fda88b8c459a\",\"datePublished\":\"2020-05-22T22:06:40+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg06.met.vgwort.de\\\/na\\\/c493928b7cec4a60a4a8fda88b8c459a\",\"contentUrl\":\"http:\\\/\\\/vg06.met.vgwort.de\\\/na\\\/c493928b7cec4a60a4a8fda88b8c459a\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Fehlertolerantes_Suchen\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Fehlertolerantes Suchen\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Fehlertolerantes Suchen - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/","og_locale":"de_DE","og_type":"article","og_title":"Fehlertolerantes Suchen","og_description":"\"Firma Waren-Paradies, Konstanze Meyer am Apparat. Was kann ich für Sie tun\" - \"Ja, Katschmarek. Ich hatte letzte Woche eine Bestellung aufgegeben; die möchte ich gerne stornieren.\" - \"Wie war der Name\" - \"Katschmarek!\" Die Kundenbetreuerin Frau Meyer gibt den Namen in die Suchmaske des Kundenformulars ihrer Datenbank zur Bestellabwicklung ein. Die Datenbank findet den Kunden nicht. \"Würden Sie den Namen bitte buchstabieren\" - \"K-A-C-S-M-A-R-E-K\" - \"Mit C-S\" - \"Ja, genau!\" Ein Glück, dass Herr Kacsmarek nicht mit \"Kaufmann-Anton-Cäsar-Samuel-Martha-...\" antwortete, denn dann hätte Frau Meyer wahrscheinlich nochmals nachgefragt ...","og_url":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/","og_site_name":"Access im Unternehmen","article_published_time":"2020-05-22T22:06:40+00:00","og_image":[{"url":"http:\/\/vg06.met.vgwort.de\/na\/c493928b7cec4a60a4a8fda88b8c459a","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"22\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"Fehlertolerantes Suchen","datePublished":"2020-05-22T22:06:40+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/"},"wordCount":4281,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/#primaryimage"},"thumbnailUrl":"http:\/\/vg06.met.vgwort.de\/na\/c493928b7cec4a60a4a8fda88b8c459a","articleSection":["2010","4\/2010","VBA und Programmiertechniken"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/","url":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/","name":"Fehlertolerantes Suchen - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/#primaryimage"},"thumbnailUrl":"http:\/\/vg06.met.vgwort.de\/na\/c493928b7cec4a60a4a8fda88b8c459a","datePublished":"2020-05-22T22:06:40+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/#primaryimage","url":"http:\/\/vg06.met.vgwort.de\/na\/c493928b7cec4a60a4a8fda88b8c459a","contentUrl":"http:\/\/vg06.met.vgwort.de\/na\/c493928b7cec4a60a4a8fda88b8c459a"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/Fehlertolerantes_Suchen\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"Fehlertolerantes Suchen"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000733","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55000733"}],"version-history":[{"count":0,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000733\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55000733"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55000733"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55000733"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}