Búsqueda de Texto Completo

Visión General

La búsqueda de texto completo permite que los usuarios encuentren documentos por relevancia en lugar de coincidencia exacta de subcadenas. A diferencia de LIKE '%query%', que escanea tablas completas, los índices de texto completo tokenizan el contenido y clasifican resultados. Aqui se explica como las implementaciones de PostgreSQL tsvector, Elasticsearch y Meilisearch en Python, JavaScript y Java.

Cuándo Usar

Usa este recurso cuando:

• Los usuarios necesiten buscar artículos, productos o documentos con tolerancia a errores tipográficos. Consulta Parse JSON para indexación de documentos.
• Tu app requiera resultados clasificados, búsqueda facetada o resaltado
• Las consultas LIKE sean demasiado lentas en tablas con >100k filas. Consulta Query Optimization para ajuste de índices.
• Quieras comportamiento de búsqueda mientras escribes (autocompletado). Consulta Input Validation para sanitización de consultas.

Solución

Python (PostgreSQL + SQLAlchemy)

from sqlalchemy import create_engine, Column, Integer, String, Text, func
from sqlalchemy.orm import declarative_base, Session

Base = declarative_base()

class Article(Base):
    __tablename__ = "articles"
    id = Column(Integer, primary_key=True)
    title = Column(String)
    content = Column(Text)

engine = create_engine("postgresql://user:pass@localhost/db")

# Crear índice GIN para tsvector
with engine.connect() as conn:
    conn.execute("""
        CREATE INDEX IF NOT EXISTS idx_articles_search
        ON articles USING GIN (to_tsvector('english', title || ' ' || content));
    """)

def search(query: str):
    with Session(engine) as session:
        tsquery = func.plainto_tsquery("english", query)
        return session.query(Article).filter(
            func.to_tsvector("english", Article.title + " " + Article.content)
            .op("@@")(tsquery)
        ).all()

JavaScript (Meilisearch)

const { MeiliSearch } = require("meilisearch");

const client = new MeiliSearch({ host: "http://localhost:7700", apiKey: "masterKey" });
const index = client.index("articles");

async function setup() {
  await index.updateSettings({
    searchableAttributes: ["title", "content"],
    rankingRules: [
      "words",
      "typo",
      "proximity",
      "attribute",
      "sort",
      "exactness",
    ],
  });
}

async function search(query) {
  return await index.search(query, {
    attributesToHighlight: ["title", "content"],
    limit: 20,
  });
}

setup();
search("distributed systems").then(console.log);

Java (Elasticsearch + RestHighLevelClient)

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.builder.SearchSourceBuilder;

import java.io.IOException;

public class ArticleSearch {
    private final RestHighLevelClient client;

    public ArticleSearch(RestHighLevelClient client) {
        this.client = client;
    }

    public SearchResponse search(String query) throws IOException {
        SearchSourceBuilder source = SearchSourceBuilder.searchSource()
            .query(QueryBuilders.multiMatchQuery(query, "title", "content"))
            .size(20);

        SearchRequest request = new SearchRequest("articles").source(source);
        return client.search(request, RequestOptions.DEFAULT);
    }
}

Explicación

La búsqueda de texto completo funciona en tres etapas:

1. Tokenización: El texto se divide en palabras, se normaliza (minúsculas, stemming) y se eliminan stop words (“el”, “la”, “y”).
2. Indexación: Los tokens se almacenan en un índice invertido que mapea cada término a los documentos que lo contienen.
3. Consulta: La consulta se tokeniza de la misma forma, y el índice se consulta para documentos coincidentes, clasificados por algoritmos de relevancia.

PostgreSQL tsvector es excelente para casos simples sin infraestructura adicional. Meilisearch ofrece tolerancia a errores tipográficos, facetado y sinónimos listos para usar. Elasticsearch es el más potente pero también el más complejo de operar.

Variantes

Motor	Ideal Para	Complejidad de Setup	Tolerancia a Errores
PostgreSQL tsvector	Búsqueda simple sobre datos PG existentes	Baja	No
Meilisearch	Setup rápido, API moderna	Baja	Sí
Elasticsearch	Escala, agregaciones complejas	Alta	Sí (fuzzy)
SQLite FTS5	Apps embebidas/móviles	Ninguna	Limitada
Typesense	Búsqueda instantánea, tolerancia a errores	Baja	Sí

Lo que funciona

• Usa índices GIN en PostgreSQL: Las consultas to_tsvector sin índice son escaneos completos de tabla. Consulta Query Optimization para indexación.
• Limita campos buscables: Indexar cada columna desperdicia espacio y degrada relevancia.
• Aplica stemming antes de indexar: “corriendo” y “correr” deberían coincidir con el mismo documento.
• Resalta términos coincidentes: Los usuarios necesitan confirmación visual de por qué un resultado coincidió.
• Monitorea el tamaño del índice: Los índices de texto completo pueden crecer 2-5x respecto a los datos fuente.

Errores Comunes

• Usar LIKE '%term%' en tablas grandes: Los escaneos secuenciales matan el rendimiento pasadas las 100k filas.
• No configurar stop words: “El” no debería influir en el ranking.
• Ignorar la latencia de refresco del índice: Elasticsearch es casi en tiempo real, no instantáneo.
• Almacenar todos los datos en el motor de búsqueda: Usa IDs de búsqueda para obtener registros completos de la base de datos. Consulta Data Validation para integridad de datos.
• Sin timeout en consultas: Una consulta malformada puede colgar por minutos en índices no optimizados.

Tips de Rendimiento

1. Usa size: 0 cuando solo necesitas agregaciones. Esto omite obtener documentos hits, reduciendo tamaño de respuesta y uso de memoria.

2. Establece timeout en consultas de búsqueda. Previene que consultas long-running bloqueen:

GET /articles/_search
{
  "timeout": "5s",
  "query": { "match_all": {} }
}

3. Usa preference para routing de shards consistente. Rutea consultas repetidas del mismo usuario a los mismos shards para mejor utilización de caché:

GET /articles/_search?preference=user_123

4. Monitorea pg_stat_statements para consultas de búsqueda lentas. Identifica consultas full-text que necesitan optimización:

SELECT query, mean_exec_time, calls
FROM pg_stat_statements
WHERE query LIKE '%to_tsvector%'
ORDER BY mean_exec_time DESC;

5. Usa index_options para controlar el comportamiento de posting lists. Para campos que necesitan consultas phrase, establece index_options: "positions":

"content": {
  "type": "text",
  "index_options": "positions"
}