Come si usa regex in una query SQLite?

Vorrei usare un'espressione regolare in sqlite, ma non so come.

La mia tabella ha una colonna con stringhe come questa: "3,12,13,14,19,28,32" Ora se digito "dove x LIKE '3'" ottengo anche le righe che contengono valori come 13 o 32 , ma vorrei ottenere solo le righe che hanno esattamente il valore 3 in quella stringa.

Qualcuno sa come risolvere questo problema?

SQLite3 supporta l'operatore REGEXP:

WHERE x REGEXP <regex>

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

Come altri hanno già sottolineato, REGEXP chiama una funzione definita dall'utente che deve essere prima definita e caricata nel database. Forse alcune distribuzioni sqlite o strumenti GUI lo includono per impostazione predefinita, ma la mia installazione di Ubuntu no. La soluzione era

sudo apt-get install sqlite3-pcre

che implementa le espressioni regolari Perl in un modulo caricabile in /usr/lib/sqlite3/pcre.so

Per poterlo utilizzare, devi caricarlo ogni volta che apri il database:

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

Oppure potresti mettere quella linea nel tuo file ~/.sqliterc.

Ora puoi eseguire query in questo modo:

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

Se desideri eseguire una query direttamente dalla riga di comando, puoi utilizzare il file -cmd opzione per caricare la libreria prima del tuo SQL:

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

Se sei su Windows, immagino che un file .dll simile dovrebbe essere disponibile da qualche parte.

Un modo hacky per risolverlo senza regex è where ',' || x || ',' like '%,3,%'

SQLite non contiene funzionalità di espressioni regolari per impostazione predefinita.

Definisce un REGEXPoperatore, ma fallirà con un messaggio di errore a meno che tu o il tuo framework non definiate una funzione utente chiamataregexp() . Il modo in cui lo fai dipenderà dalla tua piattaforma.

Se hai una regexp()funzione definita, puoi trovare un numero intero arbitrario da un elenco separato da virgole in questo modo:

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

Ma in realtà, sembra che troverai le cose molto più semplici se normalizzassi la struttura del tuo database sostituendo quei gruppi all'interno di una singola colonna con una riga separata per ogni numero nell'elenco separato da virgole. Quindi non solo potresti usare l' =operatore invece di un'espressione regolare, ma anche usare strumenti relazionali più potenti come i join che SQL ti fornisce.

Una UDF SQLite in PHP / PDO per la REGEXPparola chiave che imita il comportamento in 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;
    }
);

Il umodificatore non è implementato in MySQL, ma trovo utile averlo di default. Esempi:

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

Se $datao $patternè NULL, il risultato è NULL, proprio come in MySQL.

la mia soluzione in python con 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()

se regex corrisponde, l'output sarebbe 1, altrimenti 0.

Non è bene rispondere a una domanda che è stata posta quasi un anno fa. Ma sto scrivendo questo per coloro che pensano che Sqlite stesso fornisca la funzione REGEXP .

Un requisito di base per richiamare la funzione REGEXP in sqlite è
"È necessario creare la propria funzione nell'applicazione e quindi fornire il collegamento di richiamata al driver sqlite" .
Per questo devi usare sqlite_create_function (interfaccia C). Puoi trovare i dettagli da qui e qui

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

E :

SELECT * from TableName
 WHERE YourField REGEXP 'YOUR REGEX'

Una clausola or'ed where esaustiva può farlo senza concatenazione di stringhe:

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

Include la corrispondenza esatta dei quattro casi, la fine della lista, l'inizio della lista e la metà della lista.

Questo è più dettagliato, non richiede l'estensione regex.

Con python, supponendo che consia la connessione a SQLite, puoi definire l'UDF richiesta scrivendo:

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

Ecco un esempio più completo:

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' ")

È possibile utilizzare un'espressione regolare con REGEXP , ma questo è un modo sciocco per fare una corrispondenza esatta.

Dovresti solo dire WHERE x = '3'.

Considera l'idea di usarlo

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

Questo corrisponderà esattamente a 3 quando x è in:

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

Altri esempi:

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

Questo corrisponderà al 3 o al 13

Nel caso in cui qualcuno cerchi una condizione non regex per Android Sqlite , come questa stringa [1,2,3,4,5], non dimenticare di aggiungere la parentesi ( [] ) stessa per altri caratteri speciali come le parentesi ( {} ) nella condizione @phyatt

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

Se stai usando php puoi aggiungere qualsiasi funzione alla tua istruzione sql usando: SQLite3 :: createFunction . In PDO puoi usare PDO :: sqliteCreateFunction e implementare la funzione preg_match all'interno della tua istruzione:

Guarda come è fatto da Havalite ( RegExp in SqLite usando Php )

Puoi anche considerare

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

Ciò consentirà di trovare il numero 3 in qualsiasi stringa in qualsiasi posizione

In Julia, il modello da seguire può essere illustrato come segue:

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

per rotaie

            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