5 maneiras de implementar a pesquisa que não diferencia maiúsculas de minúsculas no SQLite com suporte total a Unicode

Recursos SQLite integrados e suas desvantagens

-- 1. Use a NOCASE collation
-- (we will look at other ways for applying collations later):
SELECT * 
    FROM items 
    WHERE text = "String in AnY case" COLLATE NOCASE;

-- 2. Normalize all strings to the same case,
-- does not matter lower or upper:
SELECT * 
    FROM items 
    WHERE LOWER(text) = "string in lower case";

-- 3. Use LIKE operator which is case insensitive by default:
SELECT * 
    FROM items 
    WHERE text LIKE "String in AnY case";

from sqlalchemy import func
from sqlalchemy.orm.query import Query

from package.models import YourModel


text_to_find = "Text in AnY case"

# NOCASE collation
Query(YourModel)
.filter(
    YourModel.field_name.collate("NOCASE") == text_to_find
)

# Normalizing text to the same case
Query(YourModel)
.filter(
    func.lower(YourModel.field_name) == text_to_find.lower()
).all()

# LIKE operator. No need to use SQLAlchemy's ilike
# since SQLite LIKE is already case-insensitive.
Query(YourModel)
.filter(YourModel.field_name.like(text_to_find))

SQLite só entende maiúsculas/minúsculas para caracteres ASCII por padrão. O operador LIKE é diferencia maiúsculas de minúsculas por padrão para caracteres unicode que estão além do intervalo ASCII. Por exemplo, a expressão 'a' LIKE 'A' é TRUE mas 'æ' LIKE 'Æ' é FALSE.

Soluções

1. Extensão UTI

1. 
   É um novo tipo de dependência:não uma biblioteca Python, mas uma extensão que deve ser distribuída junto com a aplicação.
   
2. 
   O ICU precisa ser compilado antes do uso, potencialmente para diferentes sistemas operacionais e plataformas (não testado).
   
3. 
   O ICU não implementa conversões Unicode, mas depende do sistema operacional sublinhado – já vi várias menções a problemas específicos do sistema operacional, especialmente com Windows e macOS.
   

Escolhendo a função python correta para comparação que não diferencia maiúsculas de minúsculas

Retorne uma cópia em maiúsculas e minúsculas da string. Strings dobradas em maiúsculas podem ser usadas para correspondência sem maiúsculas e minúsculas.

A dobragem de maiúsculas e minúsculas é semelhante a letras minúsculas, mas mais agressiva porque se destina a remover todas as distinções de maiúsculas e minúsculas em uma string. Por exemplo, a letra minúscula alemã 'ß' é equivalente a "ss". Como já está em minúsculas, lower() não faria nada para 'ß'; casefold() converte para "ss".

2. Agrupamento definido pelo aplicativo

import sqlite3

# Custom collation, maybe it is more efficient
# to store strings
def unicode_nocase_collation(a: str, b: str):
    if a.casefold() == b.casefold():
        return 0
    if a.casefold() < b.casefold():
        return -1
    return 1

connection.create_collation(
    "UNICODE_NOCASE", unicode_nocase_collation
)

# Connect to the DB and register the function
connection = sqlite3.connect("your_db_path")
connection.create_collation(
    "UNICODE_NOCASE", unicode_nocase_collation
)

# Or, if you use SQLAlchemy you need to register
# the collation via an event
@sa.event.listens_for(sa.engine.Engine, 'connect')
def sqlite_engine_connect(connection, _):
    connection.create_collation(
    "UNICODE_NOCASE", unicode_nocase_collation
)

1. 
   Eles são fáceis de usar. Você pode especificar o agrupamento no esquema da tabela e ele será aplicado automaticamente a todas as consultas e índices neste campo, a menos que você especifique o contrário:
   
   

   CREATE TABLE test (text VARCHAR COLLATE UNICODE_NOCASE);
   

   
   Por uma questão de completude, vamos ver mais duas maneiras de usar agrupamentos:
   
   

   -- In a particular query:
   SELECT * FROM items
       WHERE text = "Text in AnY case" COLLATE UNICODE_NOCASE;
   
   -- In an index:
   CREATE INDEX IF NOT EXISTS idx1 
       ON test (text COLLATE UNICODE_NOCASE);
   
   -- Word of caution: your query and index 
   -- must match exactly,including collation, 
   -- otherwise, SQLite will perform a full table scan.
   -- More on indexes below.
   EXPLAIN QUERY PLAN
       SELECT * FROM test WHERE text = 'something';
   -- Output: SCAN TABLE test
   EXPLAIN QUERY PLAN
       SELECT * FROM test WHERE text = 'something' COLLATE NOCASE;
   -- Output: SEARCH TABLE test USING COVERING INDEX idx1 (text=?)
   

2. 
   O agrupamento fornece classificação sem distinção entre maiúsculas e minúsculas com ORDER BY sai da caixa. É especialmente fácil de obter se você definir o agrupamento no esquema da tabela.
   

3. Função SQL definida pelo aplicativo

import sqlite3

# Custom function
def casefold(s: str):
    return s.casefold()

# Connect to the DB and register the function
connection = sqlite3.connect("your_db_path")
connection.create_function("CASEFOLD", 1, casefold)

# Or, if you use SQLAlchemy you need to register 
# the function via an event
@sa.event.listens_for(sa.engine.Engine, 'connect')
def sqlite_engine_connect(connection, _):
    connection.create_function("CASEFOLD", 1, casefold)

• nome da função como ela será usada nas consultas SQL
• número de argumentos que a função aceita
• a própria função
• bool opcional deterministic , padrão False (adicionado no Python 3.8) – é importante para índices, que discutiremos abaixo.

4. Compare no aplicativo

5. Armazene o campo normalizado separadamente

• 
  Ele dissocia completamente o aplicativo e o banco de dados – você pode alternar facilmente.
  
• 
  Você pode pré-processar o arquivo normalizado se suas consultas exigirem (recortar, remover pontuação ou espaços, etc.).
  

Você deve sobrecarregar funções e agrupamentos internos?

• 
  Sobrecarga:o banco de dados ainda funcionará, mas os resultados podem não estar corretos:
  
  • a função/agrupamento integrado se comportará de maneira diferente de suas contrapartes personalizadas;
  • se você usou o agrupamento agora ausente em um índice, ele parecerá funcionar, mas os resultados podem estar errados mesmo durante a leitura;
  • se a tabela com índice e índice usando a função/agrupamento personalizado for atualizada, o índice poderá ficar corrompido (atualizado usando a implementação integrada), mas continue funcionando como se nada tivesse acontecido.
• 
  Não sobrecarregar:o banco de dados não funcionará em nenhum aspecto onde as funções ou agrupamentos ausentes forem usados:
  
  • se você usar um índice em uma função ausente, poderá usá-lo para leitura, mas não para atualizações;
  • índices com ordenação definida pelo aplicativo não funcionarão, pois eles usam a ordenação ao pesquisar no índice.

• 
  Sobrecarga:você poderá modificar o banco de dados sem problemas, tendo em mente o risco de corromper os índices.
  
• 
  Sem sobrecarga:em muitos casos, você precisará registrar essas funções ou agrupamentos ou realizar etapas extras para evitar partes do banco de dados que dependem dele.
  

-- Rebuild all indexes using this collation
REINDEX YOUR_COLLATION_NAME;

-- Rebuild particular index
REINDEX index_name;

-- Rebuild all indexes
REINDEX;

Desempenho de funções e agrupamentos definidos pelo aplicativo

counter = 0

def casefold(a: str):
    global counter
    counter += 1
    return a.casefold()

# Work with the database

print(counter)
# Number of times the function has been called

Índices e pesquisa que não diferencia maiúsculas de minúsculas

Índices e funções

CREATE TABLE table_name (id INTEGER, name VARCHAR);
CREATE INDEX idx1 ON table_name (name);
EXPLAIN QUERY PLAN
    SELECT id, name FROM table_name WHERE LOWER(name) = 'test';
-- Output: SCAN TABLE table_name

CREATE INDEX idx1 ON table_name (LOWER(name));
EXPLAIN QUERY PLAN
    SELECT id, name 
        FROM table_name WHERE LOWER(name) = 'test';
-- Output: SEARCH TABLE table_name USING INDEX idx1 (<expr>=?)

connection.create_function(
    "CASEFOLD", 1, casefold, deterministic=True
)

CREATE INDEX idx1 
    ON table_name (CASEFOLD(name));
EXPLAIN QUERY PLAN
    SELECT id, name 
        FROM table_name WHERE CASEFOLD(name) = 'test';
-- Output: SEARCH TABLE table_name USING INDEX idx1 (<expr>=?)

Índices e agrupamentos

-- Table without specified collation will use BINARY
CREATE TABLE test (id INTEGER, text VARCHAR);

-- Create an index with a different collation
CREATE INDEX IF NOT EXISTS idx1 ON test (text COLLATE NOCASE);


-- Query will use default column collation -- BINARY
-- and the index will not be used
EXPLAIN QUERY PLAN
    SELECT * FROM test WHERE text = 'test';
-- Output: SCAN TABLE test


-- Now collations match and index is used
EXPLAIN QUERY PLAN
    SELECT * FROM test WHERE text = 'test' COLLATE NOCASE;
-- Output: SEARCH TABLE test USING INDEX idx1 (text=?)

-- Using application defined collation UNICODE_NOCASE from above
CREATE TABLE test (text VARCHAR COLLATE UNICODE_NOCASE);

-- Index will be built using the collation
CREATE INDEX idx1 ON test (text);

-- Query will utilize index and collation automatically
EXPLAIN QUERY PLAN
    SELECT * FROM test WHERE text = 'something';
-- Output: SEARCH TABLE test USING COVERING INDEX idx1 (text=?)

Qual solução escolher?

1. 
   Simplicidade – quão difícil é implementá-lo e mantê-lo
   
2. 
   Desempenho – quão rápido suas consultas serão
   
3. 
   Espaço extra – quanto espaço de banco de dados adicional a solução requer
   
4. 
   Acoplamento – o quanto sua solução entrelaça o código e o armazenamento