Jérôme Verstrynge's questions

Estou tentando entender o failover automático versus sempre em grupos de disponibilidade em situações híbridas e de região geográfica do Azure:

1. É possível ter bancos de dados SQL locais, bancos de dados SQL de VM e bancos de dados do Azure no mesmo grupo de disponibilidade? Ou é preciso separar os bancos de dados locais dos bancos de dados na nuvem em grupos de disponibilidade sempre ativos separados?

2. O failover automático não é possível em situações híbridas, ele deve ser forçado manualmente. Mas, o failover automático pode ser implementado entre regiões na nuvem ou precisa acontecer na mesma região?

Para ilustrar minha pergunta, segue uma consulta detectando o id do pedido que não foi inserido em um data warehouse e os insere:

With NewOrders 
As
(   
    Select OrderID From Orders
    Except
    Select OrderID From FactOrders
)
Insert Into FactOrders(OrderID, OrderDate, CustomerId)
    Select OrderID, OrderDate, CustomerId From Orders
    Where OrderID in (Select OrderID from NewOrders);

Digamos que a consulta seja executada pela primeira vez e Orderscontenha 400 milhões de linhas ou mais:

O SQL Server pode lidar com esse número de linhas em uma única INSERTinstrução?

Se não, como devo proceder? Devo limitar o número de linhas buscadas na INSERTinstrução? Quantas linhas o mecanismo pode manipular em uma única INSERTinstrução?

Alguns meses atrás, descobri em um banco de dados (não tão bem mantido) uma tabela totalmente inútil contendo 430 milhões de linhas não indexadas, crescendo cerca de 80.000 linhas por dia.

Foi um dos principais candidatos à remoção. No entanto, nunca tive a oportunidade de conseguir isso (também conhecido como prioridade). Eu nem tive a oportunidade de tentar excluí-lo em um banco de dados dev atualizado semanalmente.

Eu queria saber se um simples TRUNCATE ou DROP poderia ser muito demorado? Quero dizer, essa operação poderia bloquear um ambiente de produção por vários minutos, como DELETEs podem quando não são bem escritos. Ou essas operações são seguras?

Digamos que eu tenha uma tabela definida da seguinte forma:

CREATE TABLE my_tbl (
    id  bigint,
    a1  bigint[],
    a2  bigint[]
);

Gostaria de criar um procedimento armazenado para acrescentar valores a a1e a2. Esta é a maneira correta de proceder ou existe uma maneira mais simples?

CREATE OR REPLACE FUNCTION append(
        iid  bigint,
        next_a1  bigint,
        next_a2  bigint)
DECLARE
    r       "my_tbl";
    tmp_a1  bigint[]; 
    tmp_a2  bigint[]; 
BEGIN
    FOR r IN SELECT * FROM "my_tbl"
              WHERE r."id" = iid
                FOR UPDATE
        LOOP
            tmp_a1 := r.a1 || next_a1;
            tmp_a2 := r.a2 || next_a2;
            UPDATE my_tbl SET ( "a1", "a2" ) = ( tmp_a1, tmp_a2 )
             WHERE "id" = iid;
        END LOOP;
END; $$
LANGUAGE plpgsql;

Estou no Postgresql 9.2.

Na seguinte função armazenada PgSql:

CREATE OR REPLACE FUNCTION get_offer_from_id(
        offer_id     bigint)
RETURNS json AS $$
DECLARE
    res "entity_data_result";
    r   "get_offer_data";
BEGIN
    FOR r IN SELECT * FROM "get_offer_data"
              WHERE "id" = offer_id
              LIMIT 1
              FOR SHARE
        LOOP
            res.found := true;
            res.data := row_to_json(r);
        END LOOP;
    RETURN row_to_json(res);
END; $$
LANGUAGE plpgsql;

existe um benefício real em usar FOR SHARE ou pode-se removê-lo da consulta?

No postgresql.confarquivo, pode-se configurar valores autorizados para ssl_cipher. No entanto, não consegui encontrar documentação explicando a que correspondem os valores ALL, ADH, LOW, EXP, MD5 e STRENGTH.

MD5 refere-se ao algoritmo MD5 correspondente, eu acho, mas e os outros valores? Acredito que LOW não deve ser usado em um ambiente de produção.

Eu tenho uma tabela em um banco de dados PostGreSql definido da seguinte forma:

CREATE TABLE public."MATCH"(
    "ITEM_A_ID" bigint DEFAULT 0,
    "ITEM_B_ID" bigint DEFAULT 0,
    "OWNER_A_ID" bigint DEFAULT 0,
    "OWNER_B_ID" bigint DEFAULT 0,
    "OTHER_DATA" varchar(100) NOT NULL DEFAULT ''
    CONSTRAINT "MATCH_PK" PRIMARY KEY ("ITEM_A_ID","ITEM_B_ID")
);

Ele conterá muitas linhas. Haverá muitas consultas como as seguintes realizadas nesta tabela:

SELECT * FROM "MATCH" WHERE "OWNER_A_ID" = owner_a_id;
SELECT * FROM "MATCH" WHERE "OWNER_B_ID" = owner_b_id;

Eu estava pensando em criar índices em OWNER_A_IDe OWNER_B_ID, já que essas colunas não são chaves. Esta é uma boa ideia e, se sim, como devo criá-los? Devo criar um índice com ambas as colunas? Devo criar dois índices? Devo incluir outras colunas?

Tenho lido a documentação do Postgres sobre timestamps, mas ainda estou um pouco confuso.

Preciso armazenar momentos em tempos, medidos em milissegundos, entre a hora atual e a meia-noite de 1º de janeiro de 1970 UTC (como aqueles definidos em Java , mas não estou usando Java).

Se eu ler a documentação corretamente, acredito que devo usar CURRENT_TIMESTAMP, porque inclui o fuso horário. Correto?

Alguém pode explicar como criar um procedimento armazenado que irá converter este carimbo de data/hora nos milissegundos que eu quero (e a função reversa também)?

Motivação : Entendo que alguém poderia usar algo como EXTRACTon CURRENT_TIMESTAMPao selecionar linhas, mas essa conversão seria mais cara do que armazenar o tempo em milissegundos. Estou pronto para armazenar meus momentos em um arquivo bigint. Seria mais rápido comparar momentos ou calcular diferenças de tempo.

Eu tenho uma tabela MySql com três colunas:

CU VARCHAR(3)
DA DATETIME
VA DOUBLE

Eu preciso executar várias REPLACE into mytable (CU, DA, VA) values("ABC", mydate, myval)instruções de Java. mydateé um Datee myvalé um double.

Minha pergunta é, supondo que eu tenha uma conexão com meu banco de dados, como faço para formatar e incluir mydatecorretamente myvalnesta instrução de string?

Estou usando um banco de dados MySQL e realizo vários selects como estes:

SELECT MyField FROM MyTable WHERE MyKey = 'some_value';

O objetivo é recuperar um valor de campo se a linha correspondente existir. MyKeyé a única chave na tabela e é indexada.

Minha pergunta é: há algum benefício ou desvantagem em adicionar LIMIT 0,1à minha declaração?

Tenho uma situação fora de controle em relação a um número cada vez maior de pequenos arquivos estáticos que preciso acessar aleatoriamente em uma grande estrutura de diretórios. DEVO reduzir drasticamente o número desses arquivos muito em breve. Estou investigando soluções rápidas para liberar a pressão.

Uma opção é mover o conteúdo do arquivo (texto UTF8) para um banco de dados e executar SELECTs para substituir a pesquisa do arquivo (por nome). As instruções selecionadas seriam as seguintes:

SELECT TOP(1) MyContent FROM MyTable WHERE MyContentName LIKE 'criteria%';
SELECT TOP(1) MyContent FROM MyTable WHERE MyContentName LIKE '%othercriteria';
SELECT TOP(1) MyContent FROM MyTable WHERE MyContentName LIKE '%andanothercriteria%';

Estamos falando de um total de 200 mil solicitações por dia em uma tabela de 800 mil linhas (que eu poderia facilmente dividir em duas se ajudar). MyContentNamefaz parte da chave e será indexado. Existe uma entrada que corresponde aos critérios na tabela ou nenhuma.

Não sou especialista em administrador de banco de dados. Isso é algo que uma instância do MySQL em um servidor compartilhado pode suportar ou minhas expectativas são muito altas?

Eu sei que a resposta típica é: eu deveria testar. Infelizmente, por causa da emergência, não tenho tempo para fazer exames. Preciso encontrar uma solução rápida, mesmo que temporária, mesmo que prejudique um pouco a demora na resposta do serviço.

Estou procurando a opinião de um administrador de banco de dados experiente sobre essa estratégia. Dicas e sugestões também são bem vindas.

Seguindo uma sugestão feita para outra pergunta para armazenar grandes quantidades de texto: pode-se usar um CLOB como campo de chave primária (ou seja, da implementação DataNucleus de JDO do Java)?

Sei que provavelmente é uma péssima ideia usar um CLOB como chave, mas preciso usar um texto grande como chave em uma operação única.

Não sou DBA. Eu tenho uma situação com um banco de dados MySQL (5.0.51a) em que desejo remover um prefixo 'dr_' de todas as tabelas com esse prefixo (cerca de 110 tabelas). Eu poderia renomeá-los um por um, é claro, mas queria saber se havia um comando SQL para executar isso de uma só vez?

Para deixar claro, uma tabela chamada dr_hjkdteria que ser renomeada hjkd. Uma tabela chamada rfefdmanteria o mesmo nome. Obrigado.

Instalei o PostgreSQL 9.1 no meu PC (Win 7). Eu tenho um pequeno aplicativo Java conectando-se com sucesso a ele com login=sae password="". A conexão funciona.

No entanto, é recusado pelo próprio PgAdmin III. Eu recebo:

Error connecting to the server: fe_sendauth: no password supplied

Como me conecto ao meu banco de dados do PgAdmin III com uma senha vazia?

EDITAR

Este é apenas um teste, não um código de produção.

H2 é um banco de dados de thread único com boa reputação em relação ao desempenho. Outros bancos de dados são multi-thread.

Minha pergunta é: quando um banco de dados multi-thread se torna mais interessante do que um banco de dados de thread único? Quantos usuários? Quantos processos? Qual é o gatilho? Alguém tem experiência para compartilhar?

Resumo

• O gargalo usual é o acesso ao disco
• Os SSDs são rápidos, mas frágeis (o procedimento de falha é obrigatório)
• Uma longa consulta em um único sistema de thread bloqueará todas as outras
• Configurar o sistema multi-threading pode ser complicado
• Bancos de dados multithread são benéficos mesmo em sistemas de núcleo único