La maggior parte dei principali DBMS ci fornisce un modo per trovare una stringa all'interno di una stringa utilizzando SQL. Con questo, intendo utilizzare una query SQL per trovare la posizione di una sottostringa all'interno di una stringa.
Esistono diverse funzioni SQL che ci consentono di farlo, incluso INSTR() , LOCATE() , POSITION() e CHARINDEX() . La funzione che utilizzi dipenderà dal tuo DBMS ed eventualmente dalla necessità o meno di specificare una posizione di partenza.
Oracolo
Oracle ha un INSTR() funzione che restituisce la posizione iniziale di una determinata sottostringa all'interno di una stringa.
Esempio:
SELECT INSTR('Big fat cat', 'fat')
FROM DUAL;Risultato:
5
Questo ci mostra che la sottostringa fat inizia dalla posizione 5 nella stringa Big fat cat .
È possibile specificare una posizione iniziale passando un terzo argomento. Possiamo anche passare un quarto argomento per specificare quale occorrenza trovare:
SELECT INSTR('That fat cat', 'at', 1, 2)
FROM DUAL;Risultato:
7
In questo caso ho iniziato la ricerca dalla posizione 1 e cercato la seconda occorrenza (usando 2 come quarto argomento).
Oracle ha anche un INSTRB() funzione che fa una cosa simile, tranne per il fatto che restituisce la posizione in byte.
MySQL
MySQL ha un INSTR() funzione che fa una cosa simile all'omonima funzione di Oracle Database:
SELECT INSTR('Cats and dogs like to run', 'dogs');Risultato:
10
Tuttavia, se devi specificare una posizione iniziale, dovrai utilizzare LOCATE() o POSITION() :
SELECT LOCATE('cat', 'One cat jumped over the other cat', 6);Risultato:
31
Qui, la prima occorrenza di cat inizia dalla posizione 5, ma ho specificato che la ricerca inizia dalla posizione 6. Pertanto, la posizione dell'occorrenza successiva di quella stringa era quella che è stata restituita.
Si noti che, sebbene la ricerca sia iniziata alla posizione 6, la funzione restituisce comunque la posizione della sottostringa all'interno della stringa, non dalla posizione iniziale.
Il POSITION() function è sinonimo della sintassi a due argomenti di LOCATE() , ma con una sintassi leggermente diversa (POSITION() non ci permette di specificare una posizione di partenza).
MySQL ha anche un REGEX_INSTR() funzione che restituisce l'indice iniziale della sottostringa della stringa che corrisponde all'espressione regolare specificata dal modello specificato.
MariaDB
Come MySQL, anche MariaDB ha un INSTR() funzione, così come una a LOCATE() e POSITION() funzione:
SELECT
INSTR('No news is good news', 'news') AS "INSTR",
POSITION('news' IN 'No news is good news') AS "POSITION",
LOCATE('news', 'No news is good news') AS "LOCATE 1",
LOCATE('news', 'No news is good news', 5) AS "LOCATE 2";Risultato:
+-------+----------+----------+----------+ | INSTR | POSITION | LOCATE 1 | LOCATE 2 | +-------+----------+----------+----------+ | 4 | 4 | 4 | 17 | +-------+----------+----------+----------+
MariaDB ha anche un REGEX_INSTR() funzione che restituisce l'indice iniziale della sottostringa della stringa che corrisponde all'espressione regolare specificata dal modello specificato.
SQL Server
Quando si tratta di SQL Server, il CHARINDEX() la funzione è ciò che stiamo cercando:
SELECT CHARINDEX('Bob', 'Bob likes beer. Bob also likes beef.', 16);Risultato:
17
In questo caso ho usato il terzo argomento facoltativo per specificare una posizione iniziale.
SQL Server dispone anche di un PATINDEX() funzione che ricerca un pattern all'interno di una stringa.
SQLite
SQLite ha un INSTR() funzione per soddisfare le nostre esigenze:
SELECT INSTR('Black cat', 'lack');Risultato:
2
PostgreSQL
In PostgreSQL, dobbiamo usare POSITION() funzione:
SELECT POSITION('Break' IN 'Bangkok Breaking');Risultato:
9
