Dolan Antenucci's questions

Estou usando o MS-SQL Server 2012 Standard, rodando no Windows Server 2012 RTM. Usei o SSMS para criar uma Sessão de Evento Estendida, onde usei o modelo interno "Rastreamento de consultas em lote" e salvei o resultado em um arquivo.

Eu tenho um banco de dados chamado "mydb" com uma tabela "dbo.mytable" nele. A certa altura, testei isso em uma caixa diferente e, seguindo as etapas acima, as consultas seriam registradas no rastreamento de eventos estendidos, mas nessa nova caixa (usando a mesma AWS AMI, um dia depois), qualquer consulta em "dbo .mytable" não estão sendo gravados.

Por padrão, o modelo Batch Query Tracking tem um filtro em batch_sql_completed (is_system=0 e dbid>4). Eu removi esses e outros logs de consultas do sistema. Verifiquei que a Sessão de Evento Estendida está em execução. Eu também tentei o modelo "Detailed Query Tracking", para ter certeza de que não era aquele modelo que eu usei antes.

Meu objetivo é simplesmente auditar todas as consultas executadas no banco de dados. As consultas de teste que executei foram inserções simples em "mytable" e select-all's. Estou executando as consultas através do SSMS.

Alguma idéia de por que essas consultas não seriam registradas? Deixe-me saber que outras informações posso fornecer. Obrigado!

Mais detalhes sobre meus testes

Criando a Sessão de Evento Estendido:

• Vá para "Nova sessão .." opção de menu do botão direito do mouse no SSMS (em Gerenciamento -> Eventos estendidos)
• Insira as seguintes informações:
  • Nome da sessão: consultas de log
  • Modelo: acompanhamento de lote de consulta
  • Agenda: Iniciar a sessão do evento na inicialização do servidor; Iniciar imediatamente após a criação
  • Rastreamento de causalidade: acompanhe como os eventos se relacionam.
  • Armazenamento de dados: event_file, C:\logs\log-queries.xel
• Verifique se está em execução:
  • selecione * de sys.dm_xe_sessions;
  • Verificado: vejo na lista

Sobre meu banco de dados de teste:

• Banco de dados: mydb
• Tabela: dbo.mytable (cid nchar(10), cname nchar(10), cidade nchar(10))
  • ("dbo" é o esquema; uma das opções padrão quando criei)
• Consulta: SELECT TOP 1000 [cid], [cname], [city] FROM [mydb].[dbo].[mytable]

Verificando se o log está funcionando:

• Seguindo este tutorial , extraia as instruções do arquivo de log, e procuro minha consulta no resultado:

IF OBJECT_ID('tempdb..#ExEvent') IS NOT NULL DROP TABLE #ExEvent

SELECT IDENTITY(INT,1,1) AS RowId, object_name AS event_name, CONVERT(XML,event_data) AS event_data
    INTO #ExEvent
FROM sys.fn_xe_file_target_read_file(N'C:\logs\*.xel', null, null, null);


SELECT ISNULL(t_action.RowId, t_data.RowId) AS RowId
        , ISNULL(t_action.event_name, t_data.event_name) AS event_name
        , t_action.[client_hostname], t_action.[collect_system_time], t_action.[database_name], t_action.[query_plan_hash], t_action.[server_principal_name], t_action.[session_id]
        , t_data.[collect_statement], t_data.[connection_reset_option], t_data.[cpu_time], t_data.[data_stream], t_data.[duration], t_data.[last_row_count], t_data.[line_number], t_data.[logical_reads], t_data.[object_name], t_data.[offset], t_data.[offset_end], t_data.[output_parameters], t_data.[parameterized_plan_handle], t_data.[physical_reads], t_data.[result], t_data.[row_count], t_data.[statement], t_data.[writes]
    FROM (
            SELECT RowId, event_name, [client_hostname], [collect_system_time], [database_name], [query_plan_hash], [server_principal_name], [session_id]                  
                FROM (
                        SELECT RowId
                                , event_name
                                , T2.Loc.query('.').value('(/action/@name)[1]', 'varchar(max)')AS att_name
                                , T2.Loc.query('.').value('(/action/value)[1]', 'varchar(max)')AS att_value
                        FROM   #ExEvent
                        CROSS APPLY event_data.nodes('/event/action') as T2(Loc)
                        WHERE T2.Loc.query('.').value('(/action/@name)[1]', 'varchar(max)')
                            IN ('client_hostname', 'collect_system_time', 'database_name', 'query_plan_hash', 'server_principal_name', 'session_id')
                    ) AS SourceTable
                        PIVOT(
                            MAX(att_value)
                            FOR att_name IN ([client_hostname], [collect_system_time], [database_name], [query_plan_hash], [server_principal_name], [session_id])
                    ) AS PivotTable
            ) AS t_action

        -- Full outer because it might be no events selected only the payload
        FULL OUTER JOIN (
            SELECT RowId, event_name, [collect_statement], [connection_reset_option], [cpu_time], [data_stream], [duration], [last_row_count], [line_number], [logical_reads], [object_name], [offset], [offset_end], [output_parameters], [parameterized_plan_handle], [physical_reads], [result], [row_count], [statement], [writes]
                FROM (
                        SELECT RowId
                                , event_name
                                , T3.Loc.query('.').value('(/data/@name)[1]', 'varchar(max)') AS att_name
                                , T3.Loc.query('.').value('(/data/value)[1]', 'varchar(max)') AS att_value

                            FROM   #ExEvent
                            CROSS APPLY event_data.nodes('/event/data') as T3(Loc)
                            WHERE T3.Loc.query('.').value('(/data/@name)[1]', 'varchar(max)')
                                IN ('collect_statement', 'connection_reset_option', 'cpu_time', 'data_stream', 'duration', 'last_row_count', 'line_number', 'logical_reads', 'object_name', 'offset', 'offset_end', 'output_parameters', 'parameterized_plan_handle', 'physical_reads', 'result', 'row_count', 'statement', 'writes')
                        ) AS SourceTable
                            PIVOT (
                            MAX(att_value)
                                FOR att_name IN ([collect_statement], [connection_reset_option], [cpu_time], [data_stream], [duration], [last_row_count], [line_number], [logical_reads], [object_name], [offset], [offset_end], [output_parameters], [parameterized_plan_handle], [physical_reads], [result], [row_count], [statement], [writes])
                        ) AS PivotTable

            ) AS t_data
            ON t_data.RowId = t_action.RowId

Isso é semelhante a outro post meu , mas agora tenho uma estrutura de tabela diferente e ainda não está claro quais parâmetros do MySQL devem ser alterados para aproveitar a memória RAM extra que minha máquina possui --- portanto, se parecer uma duplicata, deixe saber a melhor forma de reformular o que estou perguntando.

Tenho a seguinte tabela: create table mytable (id1 int, id2 int, score float) engine MyISAM,com 50 bilhões de registros.

Pretendo adicionar um índice na primeira coluna ( alter table mytable add index myindex (id1)), e gostaria de saber quais parâmetros do MySQL poderiam ser alterados para aproveitar essa memória extra (por exemplo, buffers?)?

Observação: o tipo de mecanismo não precisa ser MyISAM se isso fizer diferença.

Eu tenho um servidor rodando Ubuntu 10.04 com Mysql 5.1x instalado via pacote. O sistema tem 128 GB de RAM, 8 núcleos e 4 TB de espaço livre onde Mysql e Mysql tmp são armazenados.

Eu tenho um MyISAM assim:

CREATE TABLE `data_store` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `uniqname` varchar(150) NOT NULL,
  `data` blob,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM CHARSET=latin1;

Eu inseri 800mil registros (cerca de 350gb de dados antes de inserir), então tentei adicionar o seguinte índice:

ALTER TABLE data_store DISABLE KEYS;
ALTER TABLE data_store ADD INDEX uniqname_index (uniqname);
ALTER TABLE data_store ENABLE KEYS;

(Em relação ao DISABLE KEYScomando, vi que sugerido em outro lugar para usar ANTES de inserir dados e, como o comando nunca chegou a ENABLE KEYS, presumo que não esteja servindo a nenhum propósito para mim. Acabei de incluir principalmente para ser completo em minha descrição do que estou estou fazendo.)

Quando inicio o trabalho de indexação, o primeiro status que aparece SHOW PROCESSLISTé "copiando para a tabela tmp".

Depois de algumas horas, volto a verificar e o status permanece na mensagem "Reparar com Keycache" mesmo após 24 horas. Tentei executar o trabalho em um servidor um pouco mais antigo e, após 3 dias, ele ainda permanece com o status "Reparar com cache de chave". Por causa disso, cancelei o comando create-index nesta máquina mais nova.

Eu li que o "Reparar com Keycache" pode ser muito lento e "Reparar por classificação" é o preferido em muitos casos.

Com base em alguns Stack Exchange e postagens aleatórias online, adicionei as seguintes configurações ao meu servidor Mysql:

myisam_sort_buffer_size = 80G
bulk_insert_buffer_size = 80G
myisam_repair_threads   = 8
max_heap_table_size     = 20G
myisam_max_sort_file_size = 500G
tmp_table_size          = 20G
key_buffer_size         = 20G
sort_buffer_size        = 20G
join_buffer_size        = 20G

Reiniciei o trabalho e o mesmo processo aconteceu novamente (copie para o arquivo tmp e repare por meio do cache de chaves).

Depois de matar o trabalho, notei que em mysql/error.log havia uma mensagem, "myisam_sort_buffer_size é muito pequeno". Isso aconteceu no início do dia e não exatamente quando eu matei o trabalho.

perguntas

• Estou indo pelo caminho errado? Eu só quero poder pesquisar meus dados rapidamente por alguma chave (uniqname).

• Existe algum benefício em começar de novo com minha tabela, adicionar o índice desde o início, usar o DISABLE KEYScomando, inserir meus registros de 800mil e depois ENABLE KEYS? Eu li em outro lugar que isso pode impedir a cópia da tabela tmp (o que pode me poupar apenas algumas horas?)

• Eu quero este 'Reparar por triagem'?

Esta é uma continuação de Como armazenar melhor os ngrams do Google em um banco de dados? , que aborda como armazenar os dados do Google Ngram Book .

Estou procurando armazenar os dados da Web do Google NGram , que têm um formato ligeiramente diferente (sem informações de página/ano; apenas conta):

...
ceramics collectables collectibles 55
ceramics collectables fine 130
...
serve as the incoming 92
serve as the incubator 99

Como essa é uma estrutura de dados muito simples, qual é um bom método para armazenar esses dados que são razoavelmente rápidos para importar e rápidos para recuperar a contagem por um ngram específico?

Eu gosto da ideia de um banco de dados relacional, simplesmente por causa dos métodos comuns para acessá-lo, mas acho que a maioria desses outros bancos de dados não relacionais (por exemplo, tokyo hashtable) também têm métodos bastante comuns.

Atualizar

Exemplos de consultas:

# primary query
> SELECT ngram_count FROM ngram_table WHERE ngram = 'ceramics collectables fine';

ceramics collectables collectibles 55
ceramics collectables fine 130

# secondary query (not needed, but nice if have option)
SELECT ngram_count FROM ngram_table WHERE ngram LIKE '%collectables%';

ceramics collectables collectibles 55