String-Vergleich ohne Berücksichtigung der Groß-/Kleinschreibung in Sqlite3

1. Implementieren Sie den Zeichenfolgenvergleich ohne Berücksichtigung der Groß-/Kleinschreibung in Sqlite3
2. Verwenden Sie das COLLATE NOCASE in der CREATE-Abfrage für den Groß- und Kleinschreibungs-String-Vergleich in Sqlite3
3. Verwenden Sie das COLLATE NOCASE in der SELECT-Abfrage für den Groß- und Kleinschreibungs-String-Vergleich in Sqlite3
4. Verwendung des LIKE-Operators für den Vergleich von Zeichenfolgen ohne Berücksichtigung der Groß-/Kleinschreibung in Sqlite3
5. Verwenden Sie die Funktionen LOWER() oder UPPER() für den String-Vergleich ohne Berücksichtigung der Groß-/Kleinschreibung in Sqlite3

Die SQLite-Datenbank-Engine wurde in der Sprache C entwickelt. Es ist keine Anwendung, die allein stehen kann; Vielmehr handelt es sich um eine Bibliothek, die die Anwendungsentwickler verwenden können, um ihre Anwendungen zu implementieren.

Wie MySQL ist auch SQLite ein relationales Datenbankmanagementsystem (RDBMS) und auf SQL (Structured Query Language) implementiert. In Version 3 von SQLite unterscheidet die Datenbank beim Abgleich von Zeichenfolgen zwischen Groß- und Kleinschreibung. Wenn ein Benutzer also einen Datensatz aus einer Datenbank mit dem Operator = (einfach gleich) in der Klausel where auswählt, zeigt die SQLite-Datenbank dies an Groß- und Kleinschreibung beachten.

Implementieren Sie den Zeichenfolgenvergleich ohne Berücksichtigung der Groß-/Kleinschreibung in Sqlite3

Wir haben verschiedene Möglichkeiten, mit der SQLite-Datenbank zu arbeiten, um eine solche Situation zu bewältigen:

1. Wir verwenden häufig die Klausel collate nocase in CREATE- oder SELECT-Abfrageanweisungen.
2. Eine weitere Möglichkeit ist die Verwendung des Operators LIKE, der beim Vergleich der String-Operanden die Groß- und Kleinschreibung nicht berücksichtigt.
3. Schließlich verwenden wir die Funktionen UPPER() und LOWER() auf beiden Seiten der Operanden, wenn wir eine Zeichenkette mit dem Operator = vergleichen.

Verwenden Sie das COLLATE NOCASE in der CREATE-Abfrage für den Groß- und Kleinschreibungs-String-Vergleich in Sqlite3

Angenommen, wir haben eine Datenbank mit verschiedenen Datensätzen, die mit dem Text (String) als Datentyp hinzugefügt wurden. Jetzt wollen wir einige Datensätze aus der Tabelle mit dem Operator = auswählen, und dann zeigt die Datenbank, dass bei den Datensätzen die Groß- und Kleinschreibung beachtet wird.

Im Allgemeinen können Sie in SQLite also erwähnen, dass bei einer Spalte die Groß-/Kleinschreibung nicht beachtet werden sollte, wenn Sie eine Tabelle mit einer collate nocase-Abfrage erstellen. Wir können auch collate nocase mit einer ID oder einem Indexwert in der Tabelle angeben.

Im folgenden Beispiel wird bei example.New_text nicht zwischen Groß- und Kleinschreibung unterschieden.

create table example
(
  New_text text collate nocase
);

insert into example values ('ABC');
insert into example values ('def');
insert into example values ('GHI');

create index example_New_text_Index
  on example (New_text collate nocase);

Nachdem wir einige Datensätze erstellt und in die Tabelle example eingefügt haben, können wir die Groß- und Kleinschreibung testen, indem wir die Datensätze in einer select-Abfrage abrufen. Die folgenden Ergebnisse zeigen uns, dass collate nocase immer dann gut funktioniert, wenn wir Groß- und Kleinschreibung für den Vergleich der String-Datentypen in der where-Klausel benötigen.

Beispiel 1:

SELECT New_Text FROM example WHERE New_Text = 'DEF';

Ausgang:

def

Beispiel 1 ergibt einen def-Wert, wenn wir den =-Operator in der where-Klausel verwenden, ohne uns um die Gross-/Kleinschreibung der Werte in der Tabelle zu kümmern. Der Grund dafür ist, dass die Verwendung von collate nocase zum Zeitpunkt der Tabellenerstellung die Werte der Spalte New_text case insensitive macht.

Beispiel 2:

SELECT New_Text FROM example ORDER BY New_Text;

Ausgang:

ABC
def
GHI

Beispiel 3:

SELECT New_Text FROM example ORDER BY New_Text DESC;

Ausgang:

GHI
def
ABC

Verwenden Sie den EXPLAIN-Befehl in der SQLite-Datenbank

Wir können auch nach Groß- und Kleinschreibung suchen und mithilfe eines Indexes in der Spalte suchen. Dazu verwenden wir den EXPLAIN-Befehl.

EXPLAIN SELECT New_Text FROM example WHERE New_Text = 'def';

Ausgang:

addr              opcode          p1          p2
1                 Integer         0           0
2                 OpenRead        1           3
3                 SetNumColumns   1           2
4                 String8         0           0
5                 IsNull          -1          14
6                 MakeRecord      1           0
7                 MemStore        0           0
8                 MoveGe          1           14
9                 MemLoad         0           0
10                IdxGE           1           14
11                Column          1           0
12                Callback        1           0
13                Next            1           9
14                Close           1           0
15                Halt            0           0
16                Transaction     0           0
17                VerifyCookie    0           4
18                Goto            0           1
19                Noop            0           0

Verwenden Sie das COLLATE NOCASE in der SELECT-Abfrage für den Groß- und Kleinschreibungs-String-Vergleich in Sqlite3

Angenommen, wir erstellen eine Tabelle, ohne die Groß-/Kleinschreibung zu berücksichtigen und die Klausel collate nocase nicht zu verwenden. Dann können wir immer noch die Klausel collate nocase verwenden, während wir die Datensätze mit der Abfrage SELECT abrufen.

In diesem Beispiel können wir sehen, dass die Klausel collate nocase mit der Anweisung SELECT in SQLite verwendet werden kann.

SELECT * FROM NameOfTheTable WHERE value = 'MatchingValue' COLLATE NOCASE

Verwendung des LIKE-Operators für den Vergleich von Zeichenfolgen ohne Berücksichtigung der Groß-/Kleinschreibung in Sqlite3

Ähnlich wie bei der collate nocase-Klausel können wir den LIKE-Operator für den case-insensitiven Vergleich des String-Typs in der SQLite-Datenbank verwenden.

Der LIKE-Operator ist ein Mustervergleichsoperator. Wie bei einem üblichen Operator gibt es linke und rechte Operanden zum Vergleich.

Die Operanden auf der linken Seite enthalten die übereinstimmende Zeichenfolge, während der Operand auf der rechten Seite das Muster enthält, das mit der übereinstimmenden Zeichenfolge abgeglichen werden soll. Dieser Operator enthält auch das Prozentzeichen % für beliebig viele Folgen eines gegebenen Zeichens.

Auch beim LIKE-Operator wird die Groß-/Kleinschreibung nicht beachtet, es spielt also keine Rolle, ob Klein- oder Großbuchstaben für den Abgleich verwendet werden; Groß-/Kleinschreibung wird nur bei Unicode-Zeichen beachtet, nicht bei ASCII-Codezeichen.

Beispielsweise sind beim Operator LIKE die ASCII-Zeichen A und a gleich, aber die Unicode-Zeichen Æ und æ sind unterschiedlich. Wir verwenden den Operator LIKE, um die Datensätze in der SQLite-Datenbank zu vergleichen, bei denen die Groß-/Kleinschreibung nicht berücksichtigt wird.

SELECT * FROM NameOFTheTable WHERE Value LIKE 'something'

Verwenden Sie die Funktionen LOWER() oder UPPER() für den String-Vergleich ohne Berücksichtigung der Groß-/Kleinschreibung in Sqlite3

Angenommen, wir haben Datensätze in einer bestimmten Spalte mit Werten in Klein- und Großbuchstaben. Wenn wir die Werte jedoch mit dem Operator = in der Anweisung SELECT vergleichen, haben wir im Ergebnis ein Problem mit der Unterscheidung zwischen Groß- und Kleinschreibung.

Um dieses Problem zu lösen, können wir die SQLite-Funktionen LOWER() und UPPER() implementieren, wobei die Funktion LOWER() für alle Zeichen kleingeschrieben wird und die Funktion UPPER() für alle Zeichen großgeschrieben wird der bereitgestellten Zeichenfolge. Wir verwenden diese Funktionen in der SELECT-Anweisung, um sie wirksam zu machen.

Das folgende Beispiel zeigt, dass der übereinstimmende String zuerst mit der Funktion LOWER() in Kleinbuchstaben und mit der Funktion UPPER() in Großbuchstaben umgewandelt wird.

Verwendung der Funktion UPPER() in SQLite:

SELECT * FROM NameOFTheTable WHERE UPPER(value) = UPPER('something')

Verwendung der Funktion LOWER() in SQLite:

SELECT * FROM NameOFTheTable WHERE LOWER(value) = LOWER('something')