All perguntas(dba)

Sei que esse tipo de pergunta surge muito, mas ainda não li nenhum argumento convincente para me ajudar a tomar essa decisão. Por favor, tenha paciência comigo!

Eu tenho um banco de dados enorme - ele cresce cerca de 10.000.000 de registros por dia. Os dados são relacionais e, por motivos de desempenho, carrego a tabela com BULK COPY. Por esse motivo, preciso gerar chaves para as linhas e não posso contar com uma coluna IDENTITY.

Um inteiro de 64 bits - um bigint - é grande o suficiente para eu usar, mas para garantir a exclusividade, preciso de um gerador centralizado para criar meus IDs para mim. Atualmente, tenho um serviço de gerador que permite que um serviço reserve X números de sequência e garanta a ausência de colisões. No entanto, uma consequência disso é que todos os serviços que tenho dependem desse gerador centralizado e, portanto, estou limitado em como posso distribuir meu sistema e não estou satisfeito com as outras dependências (como exigir acesso à rede) impostas por este projeto. Isso tem sido um problema na ocasião.

Agora estou pensando em usar GUIDs sequenciais como minhas chaves primárias (geradas externamente para SQL). Pelo que pude verificar em meus próprios testes, a única desvantagem disso é a sobrecarga de espaço em disco de um tipo de dados mais amplo (que é exacerbado por seu uso em índices). Não testemunhei nenhuma desaceleração perceptível no desempenho da consulta, em comparação com a alternativa bigint. Carregar a tabela com BULK COPY é um pouco mais lento, mas não muito. Meus índices baseados em GUID não estão se tornando fragmentados graças à minha implementação de GUID sequencial.

Basicamente, o que eu quero saber é se há alguma outra consideração que eu possa ter esquecido. No momento, estou inclinado a dar o salto e começar a usar GUIDs. Eu não sou um especialista em banco de dados, então eu realmente aprecio qualquer orientação.

Eu sou o administrador e simplesmente executo o comando:

 sqllocaldb start v11.0

Resultado:

 Start of LocalDB instance "v11.0" failed because of the following error:
 Error occurred during LocalDB instance startup: SQL Server process failed to sta
 rt.

Log do visualizador de eventos ID do evento: 528

A chamada de API do Windows WaitForMultipleObjects retornou o código de erro: 575. A mensagem de erro do sistema Windows é: {Application Error} O aplicativo não pôde ser iniciado corretamente (0x%lx). Clique em OK para fechar o aplicativo. Relatado na linha: 3621.

Eu tentei outras contas (usuário e administrador), não houve problemas com elas.

Eu desinstalei e reinstalei a versão 2012 do SQLLocalDB.msi, mas não tive sorte. Você tem alguma idéia e correção?

O novo OFFSET ... FETCHmodelo introduzido com o SQL Server 2012 oferece paginação simples e mais rápida. Por que existem diferenças considerando que as duas formas são semanticamente idênticas e muito comuns?

Alguém poderia supor que o otimizador reconhece ambos e os otimiza (trivialmente) ao máximo.

Aqui está um caso muito simples onde OFFSET ... FETCHé ~2x mais rápido de acordo com a estimativa de custo.

SELECT * INTO #objects FROM sys.objects

SELECT *
FROM (
    SELECT *, ROW_NUMBER() OVER (ORDER BY object_id) r
    FROM #objects
) x
WHERE r >= 30 AND r < (30 + 10)
    ORDER BY object_id

SELECT *
FROM #objects
ORDER BY object_id
OFFSET 30 ROWS FETCH NEXT 10 ROWS ONLY

Pode-se variar este caso de teste criando um IC object_idou adicionando filtros, mas é impossível remover todas as diferenças de plano. OFFSET ... FETCHé sempre mais rápido porque faz menos trabalho em tempo de execução.

Quais são as diferenças entre CREATE INDEXe CREATE STATISTICSe quando devo usar cada um?

Eu tenho uma tabela com 7,2 milhões de tuplas que se parece com isso:

                               table public.methods
 column |          type         |                      attributes
--------+-----------------------+----------------------------------------------------
 id     | integer               | not null DEFAULT nextval('methodkey'::regclass)
 hash   | character varying(32) | not null
 string | character varying     | not null
 method | character varying     | not null
 file   | character varying     | not null
 type   | character varying     | not null
Indexes:
    "methods_pkey" PRIMARY KEY, btree (id)
    "methodhash" btree (hash)

Agora quero selecionar alguns valores, mas a consulta é incrivelmente lenta:

db=# explain 
    select hash, string, count(method) 
    from methods 
    where hash not in 
          (select hash from nostring) 
    group by hash, string 
    order by count(method) desc;
                                            QUERY PLAN
----------------------------------------------------------------------------------------
 Sort  (cost=160245190041.10..160245190962.07 rows=368391 width=182)
   Sort Key: (count(methods.method))
   ->  GroupAggregate  (cost=160245017241.77..160245057764.73 rows=368391 width=182)
       ->  Sort  (cost=160245017241.77..160245026451.53 rows=3683905 width=182)
             Sort Key: methods.hash, methods.string
             ->  Seq Scan on methods  (cost=0.00..160243305942.27 rows=3683905 width=182)
                   Filter: (NOT (SubPlan 1))
                   SubPlan 1
                   ->  Materialize  (cost=0.00..41071.54 rows=970636 width=33)
                     ->  Seq Scan on nostring  (cost=0.00..28634.36 rows=970636 width=33)

A hashcoluna é o hash md5 stringe tem um índice. Então, acho que meu problema é que a tabela inteira é classificada por id e não por hash, então demora um pouco para classificá-la primeiro e depois agrupá-la?

A tabela nostringcontém apenas uma lista de hashes que não quero ter. Mas eu preciso que ambas as tabelas tenham todos os valores. Portanto, não é uma opção para excluí-los.

informações adicionais: nenhuma das colunas pode ser nula (corrigido isso na definição da tabela) e estou usando o postgresql 9.2.

O procedimento armazenado do sistema sp_dboption não está mais disponível no SQL Server 2012. Como poderia ser substituído?

Vamos considerar o seguinte exemplo (do início de um script psql):

\c :db_to_run_on

TRUNCATE the_most_important_table;
-- tried to avoid similarities to anything that exists out there

Agora, se for executado pelo comando

psql [connection details] -v db_to_run_on=\'dev_database\'

então ele simplesmente roda e o usuário fica feliz. Mas e se ele decidir especificar -v db_to_run_on=production_database? (Vamos supor que isso possa acontecer, assim como as pessoas executam rm -rf / # don't try this at home!!!ocasionalmente.) Espero que haja um novo backup dessa tabela ...

Então surge a pergunta: como verificar as variáveis ​​passadas para um script e interromper o processamento posterior com base em seu valor?

Os clientes se conectam ao nosso banco de dados PostgreSQL 8.3, mas deixam as conexões abertas. É possível configurar o PostgreSQL para fechar essas conexões após uma certa inatividade?

Um de nossos produtos suporta Oracle e SQL Server como back-end de banco de dados. Temos um cliente que deseja mudar de um back-end Oracle para o Microsoft SQL Server, o que não é uma transição típica para nós.

Qual é a maneira mais fácil de obter todos os dados de todo o Oracle Schema no banco de dados do SQL Server?

O esquema contém apenas tabelas antigas e nada extravagantes. Pode haver um ou dois procedimentos armazenados que não teremos problemas para migrar manualmente.

Eu poderia usar o SQLDeveloper da Oracle para exportar os dados da tabela como CREATEe INSERTinstruções, mas eles não corresponderão à sintaxe usada no SQL Server e não estou ansioso para corrigir manualmente os erros de sintaxe.

Eu conto registros com consultas como

SELECT COUNT(col1) FROM table1 WHERE col1 LIKE '%something%'
SELECT COUNT(col1) FROM table1 WHERE col1 LIKE '%another%'
SELECT COUNT(col1) FROM table1 WHERE col1 LIKE '%word%'

Para cada contagem, o mysql precisa percorrer a tabela, e isso é um grande problema se tiver uma tabela longa e várias consultas.

Gostaria de saber se existe uma maneira de fazer todas as contagens em uma consulta. Nesse caso, quando o mysql percorre cada linha, ele processará todas as contagens e não será necessário varrer a tabela inteira repetidamente.