All perguntas(dba)

Eu tenho um modelo de multilocação

tenant_template (
    tenant_id int,
    sub_org_id int, 
    code text, 
    active bool,
    ......
)

com chave de partição -> (tenant_id, sub_org_id) e chave de cluster ->code

temos que buscar todas as configurações ativas com a API de administração,

a linha ativa máxima pode ser de até 1000 (o tamanho da linha única seria em torno de 11 KB).

1. é bom buscar todos os dados do banco de dados?
2. qualquer prática recomendada para o número de linhas deve ser partição única

Apesar da instalação/configuração correta (na minha opinião) a consulta ...

SELECT DISTINCT [net_transport]
    , [protocol_type]
    , [encrypt_option]
    , [auth_scheme]
  FROM [master].[sys].[dm_exec_connections];

... retorna FALSE na coluna [encrypt_option] para o tipo de protocolo "Database Mirroring":

Eu consegui com sucesso...

• instalou e configurou 2 instâncias do SQL Server (SQL Server 2019 Enterprise Edition),
• configurou "Force Encryption" como "Yes" nas propriedades do protocolo (SQL Server Configuration Manager),
• configure os endpoints necessários com a ENCRYPTION = REQUIRED ALGORITHM AESopção e
• configurar um grupo de disponibilidade.

A instância usa um certificado autogerado criado durante a inicialização. No entanto, tenho a mesma imagem em outro cluster onde são usados ​​​​certificados gerados explicitamente (AD).

O que eu possivelmente perdi?

Encontrei uma pergunta semelhante, mas ainda sem resposta aqui: https://www.sqlservercentral.com/forums/topic/unencrypted-connections-in-availability-group

Existe uma maneira de verificar se existe um índice em outro banco de dados?

AFAIK, as formas usuais ( sys.indexese INDEXPROPERTY) são executadas apenas no contexto do banco de dados atual .

Eu tenho uma tabela de banco de dados SQL Server que contém valores separados por vírgulas em muitas colunas. Por exemplo:

Quero dividir todas as colunas em linhas e a saída deve ser esta:

Acabei de dar a ideia de como convertê-las em linhas, mas minhas colunas reais têm mais de 30 e precisam ser separadas por vírgula.

Eu gostaria de criar uma transação que irá:

1. DESATIVAR o rastreamento de alterações SE existir.
2. Partição TRUNCATE para tabela.
3. MUDE A PARTIÇÃO de uma tabela diferente para a tabela principal.
4. ATIVAR o rastreamento de alterações SE foi desativado antes.

Gostaria de criar um script com parâmetros, então usarei SQL dinâmico. Ideia:

/* OPS parameters */
DECLARE @schemaName sysname = 'dbo';
DECLARE @tableName sysname = 'TABLE';
DECLARE @partition INT = 90;  

/* DEV parameters */
DECLARE @tableNameSRP sysname = CONCAT(@tableName, '_SRP');
DECLARE @tableNameWithSchema sysname = CONCAT(QUOTENAME(@schemaName), '.', QUOTENAME(@tableName));
DECLARE @tableNameWithSchemaSRP sysname = CONCAT(QUOTENAME(@schemaName), '.', QUOTENAME(@tableNameSRP));
DECLARE @isCtReEnabled BIT = 0;
DECLARE @isDebug BIT = 1;


SET TRAN ISOLATION LEVEL READ UNCOMMITTED;
SET XACT_ABORT ON;
BEGIN TRAN;
BEGIN TRY
    IF EXISTS (
        SELECT
            1
        FROM sys.change_tracking_tables
        WHERE object_id = OBJECT_ID(@tableNameWithSchema)
    )
    BEGIN

        SET @statement = N'ALTER TABLE ' + @tableNameWithSchema + N' DISABLE CHANGE_TRACKING;';
        IF (@isDebug = 0)
        BEGIN
            EXEC sp_executesql @stmt = @statement;
        END;
        IF (@isDebug = 1)
        BEGIN
            RAISERROR('[INFO] SQL: %s', 0, 1, @statement) WITH NOWAIT;
        END;
        SET @isCtReEnabled = 1;
    END;

    SET @statement
        = N'TRUNCATE TABLE ' + @tableNameWithSchema + N' WITH (PARTITIONS (' + CAST(@partition AS NVARCHAR(5)) + N')) 
ALTER TABLE '        + @tableNameWithSchemaSRP + N' SWITCH PARTITION ' + CAST(@partition AS NVARCHAR(5)) + N' TO ' + @tableNameWithSchema + N' PARTITION '
          + CAST(@partition AS NVARCHAR(5));
    IF (@isDebug = 0)
    BEGIN
        EXEC sp_executesql @stmt = @statement;
    END;
    IF (@isDebug = 1)
    BEGIN
        RAISERROR('[INFO] SQL: %s', 0, 1, @statement) WITH NOWAIT;
    END;

    IF (@isCtReEnabled = 1)
    BEGIN
        SET @statement = N'ALTER TABLE ' + @tableNameWithSchema + N' ENABLE CHANGE_TRACKING;';
        IF (@isDebug = 0)
        BEGIN
            EXEC sp_executesql @stmt = @statement;
        END;
        IF (@isDebug = 1)
        BEGIN
            RAISERROR('[INFO] SQL: %s', 0, 1, @statement) WITH NOWAIT;
        END;
    END;
    COMMIT;

END TRY
BEGIN CATCH
    SET @errorMessage = ERROR_MESSAGE();
    RAISERROR('ERROR MESSAGE: %s', 0, 1, @errorMessage) WITH NOWAIT;
    IF @@TRANCOUNT > 0
        ROLLBACK TRANSACTION;
END CATCH;

Minhas perguntas:

1. Operações como ENABLE/DISABLE change tracking, TRUNCATE e PARTITION SWITCH funcionarão em uma transação? (quer executar tudo ou nada)
2. O SQL dinâmico é um problema neste caso?

Acabei de atualizar o servidor MariaDB de 10.6.10 para 10.6.15 em minha máquina de desenvolvimento e a tentativa de restaurar um dump SQL anteriormente funcional agora falha.

Aqui está um exemplo de consulta com falha:

CREATE TABLE `lin_98_41_strumenti_categorie` (
  `id_categoria` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `id_azienda` int(10) unsigned NOT NULL DEFAULT 1,
  `id_sede` int(10) unsigned NOT NULL DEFAULT 1,
  `revisione_documento` int(10) unsigned NOT NULL DEFAULT 0,
  `id_macchina` int(10) unsigned DEFAULT NULL,
  `id_attrezzo` int(10) unsigned DEFAULT NULL,
  `id_impianto` int(10) unsigned DEFAULT NULL,
  `id_opera_provvisionale` int(10) unsigned DEFAULT NULL,
  `tipo_strumento` char(1) GENERATED ALWAYS AS (concat_ws('',if(`id_macchina` is not null,'M',NULL),if(`id_attrezzo` is not null,'A',NULL),if(`id_impianto` is not null,'I',NULL),if(`id_opera_provvisionale` is not null,'O',NULL))) VIRTUAL,
  PRIMARY KEY (`id_categoria`,`id_azienda`,`id_sede`,`revisione_documento`),
  UNIQUE KEY `unique_id_macchina_lin_98_41_strumenti_categorie` (`id_macchina`,`id_azienda`,`id_sede`,`revisione_documento`),
  UNIQUE KEY `unique_id_attrezzo_lin_98_41_strumenti_categorie` (`id_attrezzo`,`id_azienda`,`id_sede`,`revisione_documento`),
  UNIQUE KEY `unique_id_impianto_lin_98_41_strumenti_categorie` (`id_impianto`,`id_azienda`,`id_sede`,`revisione_documento`),
  UNIQUE KEY `unique_id_opera_provvisionale_lin_98_41_strumenti_categorie` (`id_opera_provvisionale`,`id_azienda`,`id_sede`,`revisione_documento`),
  KEY `fk_main_lin_98_41_strumenti_categorie` (`id_azienda`,`id_sede`,`revisione_documento`),
  CONSTRAINT `fk_id_attrezzo_lin_98_41_strumenti_categorie` FOREIGN KEY (`id_attrezzo`) REFERENCES `agews_attrezzi` (`id_attrezzo`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `fk_id_impianto_lin_98_41_strumenti_categorie` FOREIGN KEY (`id_impianto`) REFERENCES `agews_impianti` (`id_impianto`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `fk_id_macchina_lin_98_41_strumenti_categorie` FOREIGN KEY (`id_macchina`) REFERENCES `agews_macchine` (`id_macchina`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `fk_id_opera_provvisionale_lin_98_41_strumenti_categorie` FOREIGN KEY (`id_opera_provvisionale`) REFERENCES `agews_opere_provvisionali` (`id_opera_provvisionale`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `fk_main_lin_98_41_strumenti_categorie` FOREIGN KEY (`id_azienda`, `id_sede`, `revisione_documento`) REFERENCES `lin_98_41` (`id_azienda`, `id_sede`, `revisione_documento`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_general_ci;

O erro está no último GENERATED ALWAYScampo marcado como STORED, se eu alterar manualmente o tipo para VIRTUALfuncionar.

O erro apenas diz:

ERRO 1901 (HY000) na linha 420329: A função ou expressão 'id_macchina' não pode ser usada na cláusula GENERATED ALWAYS AS detipo_strumento

mas não dá nenhuma indicação útil sobre por que não pode ser usado agora.

No entanto, este dump SQL funcionou sem modificações com a versão 10.6.10. É possível que tenha havido uma alteração tão incompatível com versões anteriores na versão 10.6 mais recente? Eu olhei as notas de lançamento, mas não encontrei nada que justificasse essa mudança significativa.

Eu tenho uma consulta fácil que pode me mostrar os 10 principais tempos decorridos por query_plan_hash e query_hash :

PRINT '-- top 10 elapsed time  by query_plan_hash and query_hash --'

SELECT TOP 10 query_plan_hash
    ,query_hash
    ,sum(execution_count) AS 'execution_count'
    ,sum(total_worker_time) AS 'total_worker_time'
    ,SUM(total_elapsed_time) AS 'total_elapsed_time'
    ,SUM(total_logical_reads) AS 'total_logical_reads'
    ,max(REPLACE(REPLACE(REPLACE(SUBSTRING(CONVERT(NVARCHAR(4000), st.[text]), qs.statement_start_offset / 2 + 1, CASE 
                            WHEN qs.statement_end_offset = - 1
                                THEN LEN(st.[text])
                            ELSE qs.statement_end_offset / 2 - qs.statement_start_offset / 2 + 1
                            END), CHAR(13), ' '), CHAR(10), ' '), CHAR(09), ' ')) AS sample_statement_text
FROM sys.dm_exec_query_stats AS qs
CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) AS st
GROUP BY query_plan_hash
    ,query_hash
ORDER BY sum(total_elapsed_time) DESC;
GO

Como posso calcular:

• total_worker_time
• total_tempo_decorrido
• leituras_lógicas_totais

em minutos em vez de milissegundos?

Dadas as duas tabelas a seguir:

CREATE TABLE SalesLedger (
  Id int PRIMARY KEY IDENTITY,
  Date date NOT NULL,
  Total decimal(38,18),
  INDEX IX (Date, Total)
);

CREATE TABLE Purchases (
  Id int PRIMARY KEY IDENTITY,
  Date date NOT NULL,
  Total decimal(38,18),
  INDEX IX (Date, Total)
);

E a seguinte visão

CREATE VIEW ViewMetrics
AS

Select
  Date,
  'Sale' as Metric,
  Total as Value
From SalesLedger

UNION ALL

Select
  Date,
  'Purchase' as Metric,
  Total as Value
From Purchases;

A consulta a seguir usa um Concatenation Sortpar:

Select SUM(Value) as Sales, Date
from ViewMetrics
Group By Date;

Colar o plano

Considerando que uma pequena reescrita dá obviamente mais desempenhoMerge Concatenation

SELECT SUM(Sales), Date
FROM (
  Select SUM(Value) as Sales, Date
  from ViewMetrics
  Group By Metric, Date
) t
GROUP BY Date;

Colar o plano

O compilador pode ver claramente que a visualização está particionada por Metric, como mostra esta consulta, não Sorté necessário:

Select SUM(Value) as Sales, Date
from ViewMetrics
where Metric = 'Sale'
Group By Date;

A questão é: por que a primeira consulta força a Sort, enquanto a segunda pode usar uma mais eficiente Merge Concatenation, visto que a Metriccoluna não possui WHEREpredicado em nenhum dos casos?

O compilador não deveria ser capaz de ver que a Mergefuncionaria, visto que os índices já estão classificados Datee o particionamento está ativado Metric? Ou se não consegue ver isso, por que GROUP BY Metric, Datede repente lhe dá essa habilidade?

banco de dados<> violino

Ainda mais estranho, como descobriu @MartinSmith, se não houver dados, o compilador usará o plano melhor, embora sem uma agregação intermediária em Metric, Date. db<>fiddle Por outro lado, a mesclagem sem agregação parcial é provavelmente mais lenta do que a classificação após a agregação parcial, porque há mais linhas para mesclar. A questão é por que não é possível fazer agregação parcial e mesclar ao mesmo tempo por padrão?

Suponho que haja alguma otimização específica para uma visualização particionada quando a agregação inclui o particionamento, porque nesse caso ela usa uma concatenação e quando uma ordem é necessária, ela usa a concatenação de mesclagem, consulte db<> fiddle . Isso ajuda quando você deseja agregar ainda mais, pois os dados agora já estão classificados na ordem correta. Mas se você não fizer a agregação intermediária não tem lógica que a aplique.

Eu vi alguém trocando o código abaixo:

SELECT
    PK1
    , PK2
    , PK3
    , PK4
    , C
    , B
    , SUM(NUMERIC_1)
    , SUM(NUMERIC_2)
    , MAX(NUMERIC_3)
    , SUM(NUMERIC_4)
FROM MATDOC_EXTRACT
WHERE A = ''
      AND (
          (
              (
              B = ''
              OR B = 'K'
          )
              AND (
                  C = '01'
                  OR C = '02'
                  OR C = '07'
                  OR C = '08'
              )
          )
          OR (
              B = ''
              AND (
                  C = '03'
                  OR C = '04'
              )
          )
      )
GROUP BY PK1
         , PK2
         , PK3
         , PK4
         , C
         , B;

para este

SELECT
    PK1
    , PK2
    , PK3
    , PK4
    , C
    , B
    , SUM(NUMERIC_1)
    , SUM(NUMERIC_2)
    , MAX(NUMERIC_3)
    , SUM(NUMERIC_4)
FROM sap.MATDOC_EXTRACT
WHERE A = N''
      AND B = N''
      AND C IN (N'01', N'02', N'07', N'08', N'03', N'04')
GROUP BY PK1
         , PK2
         , PK3
         , PK4
         , C
         , B
UNION ALL
SELECT
    PK1
    , PK2
    , PK3
    , PK4
    , C
    , B
    , SUM(NUMERIC_1)
    , SUM(NUMERIC_2)
    , MAX(NUMERIC_3)
    , SUM(NUMERIC_4)
FROM sap.MATDOC_EXTRACT
WHERE A = N''
      AND B = N'K'
      AND C IN (N'01', N'02', N'07', N'08')
GROUP BY PK1
         , PK2
         , PK3
         , PK4
         , C
         , B;

eles são iguais?

Fiz uma View bastante complexa no meu banco de dados MySQL e percebi que algumas consultas são lentas. Minha primeira ideia foi adicionar índices, mas não é possível fazer isso em uma visualização, então estou perdido em como melhorar o desempenho da minha consulta.

Compartilharei aqui minha consulta de visualização e farei o possível para explicá-la, depois compartilharei minha estrutura de banco de dados (reduzida ao que é necessário apenas para a visualização).

CREATE VIEW conversations_search AS (
    SELECT a.id, a.organization_id, a.status, a.way, a.agent_id, a.subject, a.snooze_until, a.channel_id, a.source, a.contact_id, a.name, a.email, a.created, a.message, a.category, a.is_personal, a.is_customer, a.last_update,
        CONCAT(DATE_FORMAT(a.last_update, '%Y%m%d'), a.is_customer, DATE_FORMAT(a.last_update, '%H%i%S'), RIGHT(LPAD(a.id, 6, '0'), 6)) AS priority_sort,
        CONCAT(DATE_FORMAT(a.last_update, '%Y%m%d%H%i%S'), RIGHT(LPAD(a.id, 6, '0'), 6)) AS date_sort,
        CONCAT(RIGHT(LPAD(CAST((UTC_TIMESTAMP() - a.last_update) AS UNSIGNED) * 100, 12, '0'), 12), RIGHT(LPAD(a.id, 6, '0'), 6)) AS longest_sort
    FROM (
        SELECT c.id, c.organization_id, c.status, e.way, c.agent_id, c.subject AS subject, c.snooze_until, c.channel_id, c.source, c.contact_id, cn.name, cn.email, e.created, e.message, e.category, c.is_personal,
            IF(pc.customer_id IS NULL, 0, 1) AS is_customer,
            (
                IFNULL(
                    (SELECT created FROM messages WHERE conversation_id = c.id AND way = 'IN' ORDER BY created DESC LIMIT 1),
                    IFNULL(
                        (SELECT created FROM messages WHERE conversation_id = c.id AND way = 'OUT' ORDER BY created DESC LIMIT 1),
                        (SELECT created FROM message_drafts WHERE conversation_id = c.id)
                    )
                )
            ) AS last_update
        FROM (
            SELECT m.way, m.created, m.message, m.conversation_id, 'MESSAGE' AS category FROM messages m WHERE `status` != 'DRAFT'
            UNION
            SELECT NULL AS way, n.created AS created, n.message, n.conversation_id, 'NOTE' AS category FROM conversation_notes n WHERE `status` != 'DRAFT'
        ) AS e LEFT JOIN conversations c ON c.id = e.conversation_id LEFT JOIN contacts cn ON cn.id = c.contact_id
            LEFT JOIN processor_customers pc ON pc.contact_id = c.contact_id
    ) AS a
);

Explicação : Esta visualização carrega algumas colunas relacionadas a tickets, incluindo:

• o ID do bilhete
• o Organization_id ao qual o ticket é afetado
• O status (fechado, aberto, etc.)
• a forma como a última mensagem foi enviada (recebida ou enviada)
• O ID do agente atribuído
• O sujeito
• O tempo de soneca (se houver)
• o ID do canal (como [email protegido] )
• o ID do contato (do e-mail)
• O nome do contato
• O e-mail do contato
• A data de criação do ticket
• o conteúdo da última mensagem
• a categoria (se a última entrada for uma mensagem ou nota)
• Se a mensagem recebida for pessoal (o canal para onde o email foi enviado é pessoal, como [email protegido] , ou aberto a qualquer pessoa da equipe, como suporte@..)
• Se o contato for um cliente
• A última vez que o ticket foi atualizado
• Uma coluna usada para classificar por prioridade
• Uma coluna para classificar por data
• Uma coluna para classificar aguardando mais

Definitivamente, não sou um especialista em banco de dados, então talvez já existam muitas melhorias disponíveis nessa consulta, mas o que percebi é que, na produção, uma consulta simples como:

SELECT COUNT(id) FROM Conversations_search WHERE Organization_id = X; Leva cerca de 2,5 segundos para ser executado. Tentei com alguns IDs diferentes e o resultado está entre 900 e 18.000, mas ainda leva cerca de 2,5 segundos.

Claramente, estão faltando algumas otimizações ...

Aqui está minha estrutura de banco de dados (removi algumas colunas inúteis para simplificar aqui):

CREATE TABLE `contacts` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(250) DEFAULT NULL,
  `email` varchar(250) NOT NULL,
  `created` datetime NOT NULL,
  `organization_id` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `email` (`email`,`organization_id`),
  KEY `organization_id` (`organization_id`),
  CONSTRAINT `contacts_ibfk_2` FOREIGN KEY (`organization_id`) REFERENCES `organizations` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=11181 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

CREATE TABLE `conversations` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `subject` varchar(250) DEFAULT NULL,
  `status` varchar(15) NOT NULL,
  `source` varchar(15) NOT NULL,
  `created` datetime(6) NOT NULL,
  `snooze_until` datetime DEFAULT NULL,
  `channel_id` bigint(20) unsigned DEFAULT NULL,
  `organization_id` int(11) NOT NULL,
  `contact_id` bigint(20) unsigned NOT NULL,
  `agent_id` bigint(20) unsigned DEFAULT NULL,
  `is_personal` tinyint(1) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `agent_id` (`agent_id`),
  KEY `channel_id` (`channel_id`),
  KEY `contact_id` (`contact_id`),
  KEY `organization_id` (`organization_id`),
  CONSTRAINT `conversations_ibfk_1` FOREIGN KEY (`agent_id`) REFERENCES `agents` (`id`),
  CONSTRAINT `conversations_ibfk_2` FOREIGN KEY (`channel_id`) REFERENCES `channels` (`id`),
  CONSTRAINT `conversations_ibfk_3` FOREIGN KEY (`contact_id`) REFERENCES `contacts` (`id`),
  CONSTRAINT `conversations_ibfk_4` FOREIGN KEY (`organization_id`) REFERENCES `organizations` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=17502 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

CREATE TABLE `messages` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `message` mediumtext DEFAULT NULL,
  `way` varchar(3) NOT NULL,
  `created` datetime(6) NOT NULL,
  `last_update` datetime NOT NULL,
  `status` varchar(20) NOT NULL,
  `conversation_id` bigint(20) unsigned NOT NULL,
  `contact_id` bigint(20) unsigned DEFAULT NULL,
  `agent_id` bigint(20) unsigned DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `agent_id` (`agent_id`),
  KEY `contact_id` (`contact_id`),
  KEY `conversation_id` (`conversation_id`),
  CONSTRAINT `messages_ibfk_1` FOREIGN KEY (`agent_id`) REFERENCES `agents` (`id`),
  CONSTRAINT `messages_ibfk_2` FOREIGN KEY (`contact_id`) REFERENCES `contacts` (`id`),
  CONSTRAINT `messages_ibfk_3` FOREIGN KEY (`conversation_id`) REFERENCES `conversations` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=27845 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

CREATE TABLE `conversation_notes` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `agent_id` bigint(20) unsigned DEFAULT NULL,
  `message` mediumtext DEFAULT NULL,
  `status` varchar(20) NOT NULL,
  `created` datetime(6) NOT NULL,
  `conversation_id` bigint(20) unsigned NOT NULL,
  PRIMARY KEY (`id`),
  KEY `agent_id` (`agent_id`),
  KEY `conversation_id` (`conversation_id`),
  CONSTRAINT `conversation_notes_ibfk_1` FOREIGN KEY (`agent_id`) REFERENCES `agents` (`id`),
  CONSTRAINT `conversation_notes_ibfk_2` FOREIGN KEY (`conversation_id`) REFERENCES `conversations` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1452 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

CREATE TABLE `message_drafts` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `content` mediumtext DEFAULT NULL,
  `created` datetime(6) NOT NULL,
  `last_updated` datetime NOT NULL,
  `conversation_id` bigint(20) unsigned NOT NULL,
  `agent_id` bigint(20) unsigned NOT NULL,
  PRIMARY KEY (`id`),
  KEY `agent_id` (`agent_id`),
  KEY `conversation_id` (`conversation_id`),
  CONSTRAINT `message_drafts_ibfk_1` FOREIGN KEY (`agent_id`) REFERENCES `agents` (`id`),
  CONSTRAINT `message_drafts_ibfk_2` FOREIGN KEY (`conversation_id`) REFERENCES `conversations` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=653 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

CREATE TABLE `agents` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(250) DEFAULT NULL,
  `email` varchar(250) NOT NULL,
  `organization_id` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ix_agents_email` (`email`),
  UNIQUE KEY `email` (`email`,`organization_id`),
  KEY `organization_id` (`organization_id`),
  CONSTRAINT `agents_ibfk_1` FOREIGN KEY (`organization_id`) REFERENCES `organizations` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=679 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

CREATE TABLE `organizations` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(250) NOT NULL,
  `slug` varchar(250) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ix_organizations_slug` (`slug`),
) ENGINE=InnoDB AUTO_INCREMENT=647 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

Como posso melhorar a consulta acima? (A visualização contém esses valores porque posso pesquisar por nome de contato ou e-mail, por status, por agente, por caminho (entrada/saída), por canal, etc. Todas as colunas podem ser usadas na pesquisa.

Obrigado pela ajuda!