Domine Consultas SQL no WordPress: Guia Completo para Desenvolvedores e Administradores

BY - Lucas Dalcolmo março 12, 2026 Comments (0) 20 Mins Read

Introdução ao SQL no WordPress

O WordPress é a plataforma de gerenciamento de conteúdo mais popular do mundo, e seu funcionamento depende diretamente do banco de dados MySQL ou MariaDB. Compreender como o SQL funciona dentro do WordPress é essencial para desenvolvedores e administradores que desejam personalizar, otimizar e garantir a segurança dos seus sites.

Arquitetura do Banco de Dados WordPress

O banco de dados do WordPress é estruturado em tabelas padrão que armazenam desde informações básicas do site até dados complexos de usuários, posts e configurações. Conhecer essas tabelas é o primeiro passo para manipular consultas SQL de forma eficaz.

wp_posts: Armazena posts, páginas e tipos personalizados.
wp_postmeta: Metadados relacionados aos posts.
wp_users: Dados dos usuários registrados.
wp_usermeta: Metadados dos usuários.
wp_options: Configurações gerais do site.

Executando Consultas SQL no WordPress

O WordPress oferece a classe $wpdb para executar consultas SQL de forma segura e integrada. Utilizar essa classe evita problemas comuns como injeção de SQL e garante compatibilidade com diferentes versões do banco de dados.

Exemplo Básico de Consulta

global $wpdb;
$results = $wpdb->get_results("SELECT * FROM {$wpdb->prefix}posts WHERE post_status = 'publish'");
foreach ($results as $post) {
    echo $post->post_title . "<br>";
}

Preparando Consultas com Placeholders

Para evitar vulnerabilidades, utilize o método prepare do $wpdb:

$post_id = 42;
$query = $wpdb->prepare("SELECT * FROM {$wpdb->prefix}postmeta WHERE post_id = %d", $post_id);
$meta = $wpdb->get_results($query);

Otimização de Consultas SQL no WordPress

A performance do seu site pode ser significativamente impactada por consultas SQL mal otimizadas. Veja algumas práticas recomendadas:

Use índices adequados: As tabelas padrão já possuem índices, mas ao criar tabelas personalizadas, defina índices nas colunas mais consultadas.
Evite SELECT *: Busque apenas as colunas necessárias para reduzir o tráfego de dados.
Limite resultados: Sempre que possível, utilize LIMIT para evitar consultas que retornem muitos registros.
Cache de consultas: Utilize plugins ou mecanismos internos para armazenar resultados frequentes.

Consultas SQL Avançadas no WordPress

Manipular consultas complexas pode ser necessário para criar funcionalidades exclusivas. Exemplos comuns incluem junções entre tabelas, subconsultas e agrupamentos.

Exemplo de JOIN entre wp_posts e wp_postmeta

global $wpdb;
$query = $wpdb->prepare(
    "SELECT p.ID, p.post_title, pm.meta_value
     FROM {$wpdb->prefix}posts p
     INNER JOIN {$wpdb->prefix}postmeta pm ON p.ID = pm.post_id
     WHERE pm.meta_key = %s AND p.post_status = 'publish'",
    'preco'
);
$results = $wpdb->get_results($query);
foreach ($results as $item) {
    echo "ID: {$item->ID} - Título: {$item->post_title} - Preço: {$item->meta_value}<br>";
}

Segurança em Consultas SQL no WordPress

SQL Injection é uma das ameaças mais comuns em aplicações web. No WordPress, usar o $wpdb->prepare() é fundamental para evitar esse tipo de ataque. Nunca insira dados diretamente em consultas sem tratamento.

Sanitize inputs com funções como sanitize_text_field() e intval().
Evite concatenar strings diretamente em queries.
Utilize privilégios mínimos para o usuário do banco de dados do WordPress.

Comparativo: Métodos para Executar Consultas SQL no WordPress

Método	Descrição	Vantagens	Desvantagens
`$wpdb->get_results()`	Executa uma consulta e retorna um array de objetos.	Fácil de usar, ideal para múltiplos resultados.	Requer cuidado com a preparação de queries para segurança.
`$wpdb->get_var()`	Retorna um único valor da consulta.	Prático para obter contagens ou valores únicos.	Limitado a resultados simples.
`$wpdb->query()`	Executa consultas que não retornam dados, como INSERT, UPDATE ou DELETE.	Versátil para manipulação de dados.	Não retorna resultados, apenas sucesso ou falha.
Consultas diretas via PHP PDO/MySQLi	Execução manual de SQL fora do escopo do WordPress.	Controle total sobre a conexão e query.	Risco maior de incompatibilidade e segurança.

Checklist para Consultas SQL Seguras e Eficientes no WordPress

Utilize $wpdb->prepare() para todas as consultas com parâmetros.
Prefira métodos do $wpdb em vez de conexões diretas.
Sanitize e valide todos os dados de entrada.
Evite consultas desnecessárias e otimize SELECTs.
Implemente cache para consultas frequentes.
Monitore o desempenho do banco com ferramentas como Query Monitor.

Links Úteis para Aprofundamento

Referências

WordPress Developer Resources – https://developer.wordpress.org/
MySQL Documentation – https://dev.mysql.com/doc/
Query Monitor Plugin – https://wordpress.org/plugins/query-monitor/

Estrutura das Tabelas Padrão do WordPress

Além das tabelas já mencionadas, o WordPress possui outras tabelas fundamentais para o seu funcionamento. Conhecer a estrutura e o propósito de cada uma ajuda a criar consultas mais precisas e eficientes.

Tabela	Descrição
`wp_comments`	Armazena comentários dos usuários em posts e páginas.
`wp_commentmeta`	Metadados relacionados aos comentários.
`wp_terms`	Termos para categorias, tags e taxonomias personalizadas.
`wp_term_taxonomy`	Define a taxonomia dos termos.
`wp_term_relationships`	Relaciona posts com termos.

Consultas SQL para Taxonomias e Categorias

Para trabalhar com categorias e tags, é comum realizar junções entre as tabelas wp_terms, wp_term_taxonomy e wp_term_relationships. Veja um exemplo prático para listar posts publicados em uma categoria específica:

global $wpdb;
$category_slug = 'noticias';
$query = $wpdb->prepare(
    "SELECT p.ID, p.post_title
     FROM {$wpdb->prefix}posts p
     INNER JOIN {$wpdb->prefix}term_relationships tr ON p.ID = tr.object_id
     INNER JOIN {$wpdb->prefix}term_taxonomy tt ON tr.term_taxonomy_id = tt.term_taxonomy_id
     INNER JOIN {$wpdb->prefix}terms t ON tt.term_id = t.term_id
     WHERE t.slug = %s AND tt.taxonomy = 'category' AND p.post_status = 'publish'",
    $category_slug
);
$results = $wpdb->get_results($query);
foreach ($results as $post) {
    echo "ID: {$post->ID} - Título: {$post->post_title}<br>";
}

Utilizando Transações SQL no WordPress

Embora o WordPress não tenha suporte nativo explícito para transações via $wpdb, é possível utilizá-las diretamente para garantir a atomicidade em operações complexas que envolvem múltiplas consultas.

global $wpdb;
$wpdb->query('START TRANSACTION');

$success1 = $wpdb->query($wpdb->prepare("INSERT INTO {$wpdb->prefix}posts (post_title, post_content, post_status) VALUES (%s, %s, %s)", 'Título Exemplo', 'Conteúdo do post', 'publish'));
$success2 = $wpdb->query($wpdb->prepare("INSERT INTO {$wpdb->prefix}postmeta (post_id, meta_key, meta_value) VALUES (%d, %s, %s)", $wpdb->insert_id, 'chave_personalizada', 'valor_personalizado'));

if ($success1 !== false && $success2 !== false) {
    $wpdb->query('COMMIT');
} else {
    $wpdb->query('ROLLBACK');
}

Esse controle manual é útil para garantir que todas as operações relacionadas sejam concluídas com sucesso ou revertidas em caso de falha, evitando inconsistências no banco de dados.

Monitoramento e Debug de Consultas SQL

Para identificar gargalos e otimizar o desempenho, o monitoramento das consultas SQL é fundamental. Plugins como Query Monitor permitem visualizar todas as consultas executadas, tempo de resposta e possíveis erros.

Além disso, é possível habilitar o modo de debug do WordPress para registrar consultas lentas e erros SQL adicionando as seguintes linhas no wp-config.php:

define('SAVEQUERIES', true);
define('WP_DEBUG', true);
define('WP_DEBUG_LOG', true);

Essas configurações armazenam as consultas em um array acessível via $wpdb->queries e registram erros no arquivo debug.log dentro da pasta wp-content.

Exemplo Prático: Criando uma Tabela Personalizada com SQL no WordPress

Para funcionalidades específicas, você pode precisar criar tabelas personalizadas. Veja como criar uma tabela para armazenar avaliações de produtos:

global $wpdb;
$table_name = $wpdb->prefix . 'product_reviews';

$charset_collate = $wpdb->get_charset_collate();

$sql = "CREATE TABLE $table_name (
  review_id mediumint(9) NOT NULL AUTO_INCREMENT,
  product_id mediumint(9) NOT NULL,
  user_id bigint(20) unsigned NOT NULL,
  rating tinyint(1) NOT NULL,
  review_text text NOT NULL,
  review_date datetime DEFAULT CURRENT_TIMESTAMP NOT NULL,
  PRIMARY KEY  (review_id),
  KEY product_id (product_id),
  KEY user_id (user_id)
) $charset_collate;";

require_once(ABSPATH . 'wp-admin/includes/upgrade.php');
dbDelta($sql);

A função dbDelta() executa a criação ou atualização da tabela de forma segura, respeitando a estrutura do banco.

Boas Práticas para Manutenção do Banco de Dados

Backup Regular: Sempre realize backups completos do banco antes de alterações significativas.
Atualizações: Mantenha o WordPress, plugins e temas atualizados para garantir compatibilidade e segurança.
Monitoramento de Erros: Utilize ferramentas para identificar erros e lentidão nas consultas.
Limpeza de Dados: Remova dados obsoletos, como revisões antigas de posts e transientes expirados.

Dominar o SQL no contexto do WordPress abre um leque de possibilidades para personalização, otimização e segurança dos seus projetos. Com a utilização adequada da classe $wpdb, práticas de segurança, e técnicas avançadas, é possível extrair o máximo do banco de dados, garantindo sites rápidos e confiáveis.

Tipos de Dados Comuns nas Tabelas do WordPress

Entender os tipos de dados utilizados nas tabelas auxilia na criação de consultas eficientes e na manipulação correta dos dados. Veja os tipos mais comuns:

Tipo de Dado	Descrição	Exemplo de Uso
`INT`	Números inteiros, geralmente usados para IDs e contadores.	ID do post, user_id
`BIGINT`	Inteiros maiores, usado para IDs de usuários e timestamps.	user_id, post_date_gmt (timestamp)
`VARCHAR`	Strings de comprimento variável, usado para nomes, slugs, e títulos.	post_title, user_login
`TEXT`	Texto longo, usado para conteúdo de posts e descrições.	post_content, review_text
`DATETIME`	Data e hora, usado para armazenar datas de criação e atualização.	post_date, review_date

Exemplo Prático: Atualizando Metadados de Usuário

Suponha que você queira atualizar um metadado personalizado para um usuário específico. Veja como realizar essa operação com segurança:

global $wpdb;
$user_id = 15;
$meta_key = 'telefone';
$meta_value = '(11) 99999-9999';

// Verifica se o meta já existe
$existing = $wpdb->get_var($wpdb->prepare(
    "SELECT umeta_id FROM {$wpdb->prefix}usermeta WHERE user_id = %d AND meta_key = %s",
    $user_id, $meta_key
));

if ($existing) {
    // Atualiza
    $wpdb->update(
        "{$wpdb->prefix}usermeta",
        array('meta_value' => $meta_value),
        array('umeta_id' => $existing),
        array('%s'),
        array('%d')
    );
} else {
    // Insere
    $wpdb->insert(
        "{$wpdb->prefix}usermeta",
        array(
            'user_id' => $user_id,
            'meta_key' => $meta_key,
            'meta_value' => $meta_value
        ),
        array('%d', '%s', '%s')
    );
}

Utilizando Consultas Preparadas com Múltiplos Parâmetros

Quando for necessário utilizar vários parâmetros em uma consulta, o $wpdb->prepare() aceita múltiplos argumentos para substituir os placeholders:

global $wpdb;
$post_status = 'publish';
$meta_key = 'preco';
$min_price = 50;
$max_price = 200;

$query = $wpdb->prepare(
    "SELECT p.ID, p.post_title, pm.meta_value
     FROM {$wpdb->prefix}posts p
     INNER JOIN {$wpdb->prefix}postmeta pm ON p.ID = pm.post_id
     WHERE pm.meta_key = %s AND CAST(pm.meta_value AS DECIMAL) BETWEEN %d AND %d AND p.post_status = %s",
    $meta_key, $min_price, $max_price, $post_status
);

$results = $wpdb->get_results($query);
foreach ($results as $item) {
    echo "ID: {$item->ID} - Título: {$item->post_title} - Preço: {$item->meta_value}<br>";
}

Manipulando Resultados: Objetos, Arrays e Arrays Associativos

O método get_results() retorna um array de objetos por padrão, mas você pode alterar o formato dos resultados para atender às suas necessidades:

ARRAY_A: Retorna um array associativo.
ARRAY_N: Retorna um array numérico.

Exemplo:

$results = $wpdb->get_results($query, ARRAY_A);
foreach ($results as $row) {
    echo $row['post_title'] . "<br>";
}

Paginação de Resultados com SQL no WordPress

Para exibir resultados paginados, utilize as cláusulas LIMIT e OFFSET. Veja um exemplo básico para buscar posts publicados na página 2, considerando 10 posts por página:

global $wpdb;
$posts_per_page = 10;
$page = 2;
$offset = ($page - 1) * $posts_per_page;

$query = $wpdb->prepare(
    "SELECT ID, post_title FROM {$wpdb->prefix}posts WHERE post_status = %s ORDER BY post_date DESC LIMIT %d OFFSET %d",
    'publish', $posts_per_page, $offset
);

$results = $wpdb->get_results($query);
foreach ($results as $post) {
    echo "ID: {$post->ID} - Título: {$post->post_title}<br>";
}

Trabalhando com Consultas SQL Assíncronas no WordPress

Embora o WordPress não ofereça suporte nativo para consultas SQL assíncronas, você pode implementar chamadas AJAX para executar consultas no backend e retornar os resultados sem recarregar a página, melhorando a experiência do usuário.

Exemplo básico de uso AJAX para buscar posts via SQL:

No PHP, registre a ação AJAX:

add_action('wp_ajax_buscar_posts', 'buscar_posts_callback');
add_action('wp_ajax_nopriv_buscar_posts', 'buscar_posts_callback');

function buscar_posts_callback() {
    global $wpdb;
    $search = isset($_POST['search']) ? sanitize_text_field($_POST['search']) : '';

    $query = $wpdb->prepare(
        "SELECT ID, post_title FROM {$wpdb->prefix}posts WHERE post_title LIKE %s AND post_status = 'publish'",
        '%' . $wpdb->esc_like($search) . '%'
    );

    $results = $wpdb->get_results($query);

    wp_send_json_success($results);
}

No JavaScript, faça a requisição AJAX:

jQuery(document).ready(function($) { $('#search-input').on('input', function() { var searchTerm = $(this).val(); $.post(ajaxurl, { action: 'buscar_posts', search: searchTerm }, function(response) { if(response.success) { var html = ''; response.data.forEach(function(post) { html += '<p>ID: ' + post.ID + ' - ' + post.post_title + '</p>   '; }); $('#results').html(html); } }); }); });

Considerações sobre Charset e Collation no Banco de Dados

Ao criar ou alterar tabelas, é importante definir o charset e collation corretos para evitar problemas com caracteres especiais e garantir compatibilidade com o idioma do site. O WordPress fornece o método $wpdb->get_charset_collate() para obter essa configuração automaticamente, conforme o banco de dados está configurado.

Ferramentas para Gerenciar o Banco de Dados do WordPress

phpMyAdmin: Interface web para gerenciar bancos MySQL/MariaDB.
Adminer: Alternativa leve ao phpMyAdmin.
WP-CLI: Interface de linha de comando para gerenciar WordPress, incluindo consultas SQL.
Plugins de otimização: Como WP-Optimize para limpeza e otimização do banco.

Resumo dos Principais Métodos do $wpdb

Método	Descrição	Retorno
`get_results()`	Executa uma consulta SELECT e retorna múltiplos resultados.	Array de objetos (ou arrays associativos/numericos se especificado)
`get_var()`	Retorna um único valor da consulta.	Valor simples (string, int, etc.)
`get_row()`	Retorna uma única linha da consulta.	Objeto ou array
`query()`	Executa qualquer consulta SQL (INSERT, UPDATE, DELETE, etc.).	Booleano (true para sucesso, false para falha)
`insert()`	Insere dados em uma tabela.	Booleano
`update()`	Atualiza dados em uma tabela.	Booleano
`delete()`	Remove dados de uma tabela.	Booleano

Links Adicionais para Aprimorar seu Conhecimento

Consultas SQL para Relacionamentos Muitos-para-Muitos no WordPress

Em muitos casos, é necessário lidar com relacionamentos muitos-para-muitos, como posts associados a múltiplas tags ou categorias. O WordPress gerencia isso através das tabelas de taxonomia, mas criar consultas eficientes para esses relacionamentos é fundamental.

global $wpdb;
$tag_slugs = ['tecnologia', 'wordpress'];

// Preparar placeholders para IN
$placeholders = implode(',', array_fill(0, count($tag_slugs), '%s'));

$query = $wpdb->prepare(
    "SELECT DISTINCT p.ID, p.post_title
     FROM {$wpdb->prefix}posts p
     INNER JOIN {$wpdb->prefix}term_relationships tr ON p.ID = tr.object_id
     INNER JOIN {$wpdb->prefix}term_taxonomy tt ON tr.term_taxonomy_id = tt.term_taxonomy_id
     INNER JOIN {$wpdb->prefix}terms t ON tt.term_id = t.term_id
     WHERE t.slug IN ($placeholders) AND tt.taxonomy = 'post_tag' AND p.post_status = 'publish'",
    ...$tag_slugs
);

$results = $wpdb->get_results($query);
foreach ($results as $post) {
    echo "ID: {$post->ID} - Título: {$post->post_title}<br>";
}

Utilizando Índices para Melhorar a Performance

Além dos índices padrão, é possível criar índices personalizados para acelerar consultas específicas, especialmente em tabelas personalizadas. Exemplo de criação de índice:

ALTER TABLE {$wpdb->prefix}product_reviews ADD INDEX idx_product_rating (product_id, rating);

Esse índice melhora consultas que filtram por product_id e rating.

Exemplo de Consulta com Subquery para Posts com Meta Específica

Subconsultas podem ajudar a filtrar resultados complexos. Por exemplo, listar posts que possuem um metadado personalizado com valor maior que 100:

global $wpdb;

$query = "SELECT * FROM {$wpdb->prefix}posts WHERE ID IN (
    SELECT post_id FROM {$wpdb->prefix}postmeta WHERE meta_key = 'vendas' AND CAST(meta_value AS UNSIGNED) > 100
) AND post_status = 'publish'";

$results = $wpdb->get_results($query);
foreach ($results as $post) {
    echo "ID: {$post->ID} - Título: {$post->post_title}<br>";
}

Utilização de Views no Banco de Dados para Simplificar Consultas

Embora o WordPress não crie views por padrão, você pode criar views no MySQL para facilitar consultas complexas e reutilizáveis. Exemplo:

CREATE VIEW wp_post_prices AS
SELECT p.ID, p.post_title, pm.meta_value AS preco
FROM wp_posts p
INNER JOIN wp_postmeta pm ON p.ID = pm.post_id
WHERE pm.meta_key = 'preco' AND p.post_status = 'publish';

Depois, basta consultar a view como uma tabela comum:

SELECT * FROM wp_post_prices WHERE preco > 100;

Exemplo de Uso do WP-CLI para Executar Consultas SQL

O WP-CLI é uma ferramenta poderosa para gerenciar o WordPress via linha de comando, incluindo a execução de consultas SQL diretamente no banco:

wp db query "SELECT ID, post_title FROM wp_posts WHERE post_status = 'publish' LIMIT 10;"

Isso facilita a administração e depuração sem acessar diretamente o phpMyAdmin.

Automatizando Limpeza de Dados com Consultas SQL

Manter o banco limpo é essencial para performance. Veja um exemplo para deletar revisões antigas de posts:

global $wpdb;

$deleted = $wpdb->query(
    "DELETE FROM {$wpdb->prefix}posts WHERE post_type = 'revision' AND post_date < DATE_SUB(NOW(), INTERVAL 30 DAY)"
);
echo "Revisões deletadas: " . $deleted;

Considerações sobre Charset UTF8MB4

Desde a versão 4.2, o WordPress recomenda o uso do charset utf8mb4, que suporta caracteres Unicode completos, incluindo emojis. Certifique-se que seu banco está configurado para usar utf8mb4 e collation utf8mb4_unicode_ci para evitar problemas com caracteres especiais.

Referências Complementares

Consultas SQL para Filtragem Avançada com LIKE e Operadores

Além do uso básico do operador =, é possível utilizar o operador LIKE para realizar buscas parciais em campos de texto, o que é útil para filtros dinâmicos.

global $wpdb;
$search_term = 'tutorial';
$query = $wpdb->prepare(
    "SELECT ID, post_title FROM {$wpdb->prefix}posts WHERE post_title LIKE %s AND post_status = 'publish'",
    '%' . $wpdb->esc_like($search_term) . '%'
);
$results = $wpdb->get_results($query);
foreach ($results as $post) {
    echo "ID: {$post->ID} - Título: {$post->post_title}<br>";
}

Utilizando Funções Agregadas em Consultas SQL no WordPress

Funções agregadas como COUNT(), SUM(), AVG() são úteis para obter estatísticas diretamente do banco. Veja um exemplo para contar posts publicados:

global $wpdb;
$count = $wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->prefix}posts WHERE post_status = 'publish'");
echo "Total de posts publicados: " . $count;

Exemplo Prático: Atualizando Vários Registros com Condições

Para atualizar vários registros com uma condição específica, utilize o método query() com SQL direto:

global $wpdb;
$updated = $wpdb->query($wpdb->prepare(
    "UPDATE {$wpdb->prefix}posts SET post_status = %s WHERE post_status = %s",
    'draft', 'pending'
));
echo "Posts atualizados: " . $updated;

Manipulando Dados JSON no Banco de Dados WordPress

Com versões recentes do MySQL/MariaDB, é possível armazenar e consultar dados JSON. Embora o WordPress não tenha suporte nativo para tipos JSON, você pode armazenar strings JSON em campos TEXT e usar funções JSON do MySQL para consultas avançadas.

global $wpdb;
$query = $wpdb->prepare(
    "SELECT post_id, meta_value FROM {$wpdb->prefix}postmeta WHERE JSON_EXTRACT(meta_value, '$.status') = %s",
    'ativo'
);
$results = $wpdb->get_results($query);
foreach ($results as $item) {
    echo "Post ID: {$item->post_id} - Meta JSON: {$item->meta_value}<br>";
}

Exemplo de Backup e Restauração via WP-CLI

Além de executar consultas, o WP-CLI permite realizar backups e restaurações do banco de dados, facilitando a manutenção:

# Backup do banco de dados
wp db export backup.sql

# Restauração do banco de dados
wp db import backup.sql

Exemplo de Uso do $wpdb para Inserção com Retorno do ID

Após inserir um registro, você pode obter o ID gerado automaticamente para uso posterior:

global $wpdb;
$wpdb->insert(
    "{$wpdb->prefix}posts",
    [
        'post_title' => 'Novo Post',
        'post_content' => 'Conteúdo do post',
        'post_status' => 'publish'
    ],
    ['%s', '%s', '%s']
);

$insert_id = $wpdb->insert_id;
echo "ID do post inserido: " . $insert_id;

Melhores Práticas para Uso de Índices em Consultas Personalizadas

Além de criar índices, é importante analisar as consultas frequentes para identificar quais colunas devem ser indexadas. Utilize o comando EXPLAIN para entender o plano de execução das queries:

EXPLAIN SELECT p.ID, p.post_title
FROM wp_posts p
INNER JOIN wp_postmeta pm ON p.ID = pm.post_id
WHERE pm.meta_key = 'preco' AND pm.meta_value > 100;

Com base no resultado, crie índices para colunas usadas em filtros e junções.

Exemplo de Consulta com UNION para Combinar Resultados

O operador UNION permite combinar resultados de múltiplas consultas. Exemplo para listar títulos de posts e páginas:

global $wpdb;
$query = "(
    SELECT ID, post_title, 'post' AS tipo FROM {$wpdb->prefix}posts WHERE post_type = 'post' AND post_status = 'publish'
) UNION (
    SELECT ID, post_title, 'page' AS tipo FROM {$wpdb->prefix}posts WHERE post_type = 'page' AND post_status = 'publish'
) ORDER BY post_title ASC";

$results = $wpdb->get_results($query);
foreach ($results as $item) {
    echo "[{$item->tipo}] ID: {$item->ID} - Título: {$item->post_title}<br>";
}

Considerações sobre Charset e Collation para Sites Multilíngues

Para sites que suportam múltiplos idiomas, incluindo caracteres especiais e acentuações, é fundamental usar utf8mb4_unicode_ci como collation. Isso garante ordenação correta e suporte a todos os caracteres Unicode, incluindo emojis.

Para alterar o charset e collation de uma tabela:

ALTER TABLE wp_posts CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

Ferramentas para Análise de Performance SQL

MySQL Slow Query Log: Habilita o registro de consultas lentas para análise.
New Relic: Serviço de monitoramento de performance que inclui análise de queries SQL.
Percona Toolkit: Conjunto de ferramentas para análise e otimização de bancos MySQL.

Exemplo de Uso do $wpdb para Deleção Segura de Dados

Ao deletar dados, utilize sempre o método delete() para garantir segurança e evitar SQL Injection:

global $wpdb;
$post_id = 123;
$deleted = $wpdb->delete(
    "{$wpdb->prefix}posts",
    ['ID' => $post_id],
    ['%d']
);
if ($deleted) {
    echo "Post deletado com sucesso.";
} else {
    echo "Falha ao deletar post.";
}