Jak używać wyrażenia regularnego w zapytaniu SQLite?

Chciałbym użyć wyrażenia regularnego w sqlite, ale nie wiem jak.

Moja tabela ma kolumnę z ciągami takimi jak ten: "3,12,13,14,19,28,32" Teraz jeśli wpiszę "gdzie x LIKE '3'" Otrzymuję również wiersze zawierające wartości takie jak 13 lub 32 , ale chciałbym uzyskać tylko te wiersze, które mają dokładnie wartość 3 w tym ciągu.

Czy ktoś wie, jak to rozwiązać?

SQLite3 obsługuje operator REGEXP:

WHERE x REGEXP <regex>

http://www.sqlite.org/lang_expr.html#regexp

Jak inni już zauważyli, REGEXP wywołuje funkcję zdefiniowaną przez użytkownika, którą należy najpierw zdefiniować i załadować do bazy danych. Może niektóre dystrybucje sqlite lub narzędzia GUI zawierają to domyślnie, ale moja instalacja Ubuntu nie. Rozwiązaniem było

sudo apt-get install sqlite3-pcre

który implementuje wyrażenia regularne Perla w ładowalnym module w /usr/lib/sqlite3/pcre.so

Aby móc z niego korzystać, musisz go ładować za każdym razem, gdy otwierasz bazę danych:

.load /usr/lib/sqlite3/pcre.so

Lub możesz umieścić tę linię w swoim ~/.sqliterc.

Teraz możesz zapytać w ten sposób:

SELECT fld FROM tbl WHERE fld REGEXP '\b3\b';

Jeśli chcesz wykonywać zapytania bezpośrednio z wiersza poleceń, możesz użyć -cmdprzełącznika, aby załadować bibliotekę przed SQL:

sqlite3 "$filename" -cmd ".load /usr/lib/sqlite3/pcre.so" "SELECT fld FROM tbl WHERE fld REGEXP '\b3\b';"

Jeśli korzystasz z systemu Windows, myślę, że podobny plik .dll powinien być gdzieś dostępny.

Sprytnym sposobem rozwiązania tego problemu bez wyrażenia regularnego jest where ',' || x || ',' like '%,3,%'

SQLite domyślnie nie zawiera funkcji wyrażeń regularnych.

Definiuje REGEXPoperator, ale zakończy się niepowodzeniem z komunikatem o błędzie, chyba że Ty lub Twoja struktura zdefiniujesz funkcję użytkownika o nazwie regexp(). Sposób, w jaki to zrobisz, zależy od Twojej platformy.

Jeśli masz regexp()zdefiniowaną funkcję, możesz dopasować dowolną liczbę całkowitą z listy oddzielonej przecinkami, na przykład:

... WHERE your_column REGEXP "\b" || your_integer || "\b";

Ale naprawdę wygląda na to, że byłoby dużo łatwiej, gdybyś znormalizował strukturę bazy danych, zastępując te grupy w jednej kolumnie oddzielnym wierszem dla każdej liczby na liście oddzielonej przecinkami. Wtedy możesz nie tylko użyć =operatora zamiast wyrażenia regularnego, ale także użyć potężniejszych narzędzi relacyjnych, takich jak sprzężenia, które zapewnia SQL.

SQLite UDF w PHP / PDO dla REGEXPsłowa kluczowego, które naśladuje zachowanie w MySQL:

$pdo->sqliteCreateFunction('regexp',
    function ($pattern, $data, $delimiter = '~', $modifiers = 'isuS')
    {
        if (isset($pattern, $data) === true)
        {
            return (preg_match(sprintf('%1$s%2$s%1$s%3$s', $delimiter, $pattern, $modifiers), $data) > 0);
        }

        return null;
    }
);

uModyfikator nie jest zaimplementowany w MySQL, ale uważam, że warto go mieć domyślnie. Przykłady:

SELECT * FROM "table" WHERE "name" REGEXP 'sql(ite)*';
SELECT * FROM "table" WHERE regexp('sql(ite)*', "name", '#', 's');

Jeśli albo $dataalbo $patternjest NULL, wynikiem jest NULL - tak jak w MySQL.

moje rozwiązanie w Pythonie z sqlite3:

   import sqlite3
   import re

   def match(expr, item):
        return re.match(expr, item) is not None

   conn = sqlite3.connect(':memory:')
   conn.create_function("MATCHES", 2, match)
   cursor = conn.cursor()
   cursor.execute("SELECT MATCHES('^b', 'busy');")
   print cursor.fetchone()[0]

   cursor.close()
   conn.close()

jeśli wyrażenie regularne jest zgodne, wynikiem będzie 1, w przeciwnym razie 0.

Nie, dobrze jest odpowiedzieć na pytanie, które pojawiło się prawie rok temu. Ale piszę to dla tych, którzy myślą, że Sqlite sam zapewnia funkcję REGEXP .

Jednym z podstawowych wymagań do wywołania funkcji REGEXP w sqlite jest
„Należy utworzyć własną funkcję w aplikacji, a następnie podać łącze wywołania zwrotnego do sterownika sqlite” .
W tym celu musisz użyć sqlite_create_function (interfejs C). Szczegóły można znaleźć tutaj i tutaj

UPDATE TableName
 SET YourField = ''
WHERE YourField REGEXP 'YOUR REGEX'

I :

SELECT * from TableName
 WHERE YourField REGEXP 'YOUR REGEX'

Wyczerpująca klauzula or'ed where może to zrobić bez konkatenacji ciągów:

WHERE ( x == '3' OR
        x LIKE '%,3' OR
        x LIKE '3,%' OR
        x LIKE '%,3,%');

Obejmuje dokładne dopasowanie czterech przypadków, koniec listy, początek listy i środek listy.

Jest to bardziej szczegółowe, nie wymaga rozszerzenia wyrażenia regularnego.

W Pythonie, zakładając conpołączenie z SQLite, możesz zdefiniować wymagany UDF pisząc:

con.create_function('regexp', 2, lambda x, y: 1 if re.search(x,y) else 0)

Oto bardziej kompletny przykład:

import re
import sqlite3

with sqlite3.connect(":memory:") as con:
    con.create_function('regexp', 2, lambda x, y: 1 if re.search(x,y) else 0)
    cursor = con.cursor()
    # ...
    cursor.execute("SELECT * from person WHERE surname REGEXP '^A' ")

Możesz użyć wyrażenia regularnego z REGEXP , ale jest to głupi sposób na dokładne dopasowanie.

Powinieneś po prostu powiedzieć WHERE x = '3'.

Rozważ użycie tego

WHERE x REGEXP '(^|,)(3)(,|$)'

Dopasuje dokładnie 3, gdy x jest w:

• 3
• 3,12,13
• 12,13,3
• 12,3,13

Inne przykłady:

WHERE x REGEXP '(^|,)(3|13)(,|$)'

To będzie pasować w 3 lub 13

W przypadku, gdy ktoś szuka warunku innego niż wyrażenie regularne dla systemu Android Sqlite , takiego jak ten ciąg [1,2,3,4,5], nie zapomnij dodać nawiasu ( [] ) tego samego dla innych znaków specjalnych, takich jak nawias ( {} ) w warunku @phyatt

WHERE ( x == '[3]' OR
        x LIKE '%,3]' OR
        x LIKE '[3,%' OR
        x LIKE '%,3,%');

Jeśli używasz php, możesz dodać dowolną funkcję do swojej instrukcji sql, używając: SQLite3 :: createFunction . W PDO możesz użyć PDO :: sqliteCreateFunction i zaimplementować preg_match w swojej instrukcji:

Zobacz, jak zostało to zrobione przez Havalite ( RegExp w SqLite przy użyciu PHP )

Możesz również rozważyć

WHERE x REGEXP '(^|\D{1})3(\D{1}|$)'

Pozwoli to znaleźć numer 3 w dowolnym łańcuchu na dowolnej pozycji

U Julii model do naśladowania można zilustrować następująco:

using SQLite
using DataFrames

db = SQLite.DB("<name>.db")

register(db, SQLite.regexp, nargs=2, name="regexp")

SQLite.Query(db, "SELECT * FROM test WHERE name REGEXP '^h';") |> DataFrame

do szyn

            db = ActiveRecord::Base.connection.raw_connection
            db.create_function('regexp', 2) do |func, pattern, expression|
              func.result = expression.to_s.match(Regexp.new(pattern.to_s, Regexp::IGNORECASE)) ? 1 : 0
            end