Ejecutar una consulta en paralelo / establecer el grado de paralelismo

Oracle

-- At query level with a hint:
SELECT /*+ PARALLEL(t, 4) */ * FROM big_table t;
-- Force at session level:
ALTER SESSION FORCE PARALLEL QUERY PARALLEL 4;

El hint PARALLEL aplica un recorrido paralelo a la tabla; degree=DOP. Un DOP excesivo agota los recursos del servidor; elíjalo con cuidado. parallel_degree_policy=AUTO lo gestiona automáticamente.

PostgreSQL

-- Set the number of parallel workers for the session:
SET max_parallel_workers_per_gather = 4;
-- The planner adds a Gather/Gather Merge node:
EXPLAIN (ANALYZE) SELECT count(*) FROM big_table;

Si aparece Gather/Parallel Seq Scan en el plan, el paralelismo está activo. max_parallel_workers y min_parallel_table_scan_size también influyen.

MySQL

-- Limited InnoDB parallelism (certain operations only):
SET GLOBAL innodb_parallel_read_threads = 4;
-- Effective for COUNT(*) and primary key scans.

MySQL no ofrece ejecución de consultas en paralelo de forma general; innodb_parallel_read_threads solo paraleliza los recorridos del índice clustered (p. ej., COUNT(*)). Los JOIN complejos son de un solo hilo.

SQL Server

-- MAXDOP hint at query level:
SELECT * FROM dbo.big_table OPTION (MAXDOP 4);
-- Instance level: sp_configure 'max degree of parallelism', 4;

MAXDOP limita el número de hilos paralelos; MAXDOP 1 desactiva el paralelismo. Una vez superado el 'cost threshold for parallelism', el plan pasa a ser paralelo.

MongoDB

// Allow disk use for a large aggregation:
db.sale.aggregate([ { $group: { _id: "$city", t: { $sum: "$amount" } } } ], { allowDiskUse: true })
// A sharded cluster processes each shard in parallel.

En un clúster con sharding la consulta se ejecuta en paralelo en cada shard; en un solo nodo las etapas de agregación son mayoritariamente secuenciales. allowDiskUse permite operaciones que superan el límite de memoria.

Redis

# Not applicable: there is no concept of query parallelism.

La ejecución de comandos es de un solo hilo; escale con Cluster (sharding) o use io-threads para el paralelismo de E/S de red.

Elasticsearch

# Shard count = unit of parallelism; a query runs in parallel across shards.
# Parallelism by slicing within a single shard (with scroll/PIT):
GET <index>/_search
{ "slice": { "id": 0, "max": 4 }, "query": { "match_all": {} } }

Una búsqueda se ejecuta de forma concurrente en todos los shards relevantes; el número de primary shards fija el nivel básico de paralelismo. slices dividen las operaciones grandes de scroll/reindex.