All perguntas(dba)

Tenho uma tabela com muitos inserts, definindo um dos campos ( uploaded_at) para NULL. Em seguida, uma tarefa periódica seleciona todas as tuplas WHERE uploaded_at IS NULL, as processa e atualiza, definindo uploaded_ata data atual.

Como devo indexar a tabela?

Entendo que devo usar um índice parcial como:

CREATE INDEX foo ON table (uploaded_at) WHERE uploaded_at IS NULL

Ou algo assim. Estou um pouco confuso, porém, se é correto indexar em um campo que é sempre NULL. Ou se é correto usar um índice de árvore b. O hash parece uma ideia melhor, mas é obsoleto e não é replicado por meio de replicação de espera ativa por streaming. Qualquer conselho seria muito apreciado.

Eu experimentei um pouco com os seguintes índices:

"foo_part" btree (uploaded_at) WHERE uploaded_at IS NULL
"foo_part_id" btree (id) WHERE uploaded_at IS NULL

e o planejador de consulta parece sempre escolher o foo_partíndice. explain analysetambém produz um resultado um pouco melhor para o foo_partíndice:

Index Scan using foo_part on t1  (cost=0.28..297.25 rows=4433 width=16) (actual time=0.025..3.649 rows=4351 loops=1)
   Index Cond: (uploaded_at IS NULL)
 Total runtime: 4.060 ms

vs

Bitmap Heap Scan on t1  (cost=79.15..6722.83 rows=4433 width=16) (actual time=1.032..4.717 rows=4351 loops=1)
   Recheck Cond: (uploaded_at IS NULL)
   ->  Bitmap Index Scan on foo_part_id  (cost=0.00..78.04 rows=4433 width=0) (actual time=0.649..0.649 rows=4351 loops=1)
 Total runtime: 5.131 ms

Eu tenho executado um tipo de esquema intensivo, descartando e criando em um servidor PostgreSQL, mas agora reclama ..:

WARNING:  out of shared memory
ERROR:  out of shared memory
HINT:  You might need to increase max_locks_per_transaction.

Mas o problema permanece se o PostgreSQL for reiniciado com service postgresql restart, suspeito que max_locks_per_transaction não ajustará nada.

Estou um pouco estranho porque as listas de solução de problemas para esse erro não estão funcionando para mim.

MAIS INFO 1409291350: Faltam alguns detalhes mas mantenho o resultado do SQL principal.

postgres=# SELECT version();
PostgreSQL 9.3.5 on x86_64-unknown-linux-gnu, compiled by gcc (Ubuntu 4.8.2-19ubuntu1) 4.8.2,
 64-bit

E:

$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 14.04.1 LTS
Release:        14.04
Codename:       trusty

Estou investigando os benefícios de atualizar do MS SQL 2012 para 2014. Um dos grandes pontos de venda do SQL 2014 são as tabelas com otimização de memória, que aparentemente tornam as consultas super rápidas.

Descobri que existem algumas limitações em tabelas com otimização de memória, como:

• Nenhum (max)campo dimensionado
• Máximo ~1 KB por linha
• Nenhum timestampcampo
• Nenhuma coluna computada
• Sem UNIQUErestrições

Todos eles se qualificam como incômodos, mas se eu realmente quiser contorná-los para obter os benefícios de desempenho, posso fazer um plano.

O verdadeiro problema é o fato de que você não pode executar uma ALTER TABLEinstrução e precisa passar por essa ladainha toda vez que adicionar um campo à INCLUDElista de um índice. Além disso, parece que você precisa excluir os usuários do sistema para fazer alterações de esquema nas tabelas MO no banco de dados ativo.

Acho isso totalmente ultrajante, na medida em que realmente não consigo acreditar que a Microsoft possa ter investido tanto capital de desenvolvimento nesse recurso e deixado sua manutenção tão impraticável. Isso me leva à conclusão de que devo ter entendido errado; Devo ter entendido mal algo sobre tabelas com otimização de memória que me levou a acreditar que é muito mais difícil mantê-las do que realmente é.

Então, o que eu entendi errado? Você já usou tabelas MO? Existe algum tipo de interruptor ou processo secreto que os torna práticos de usar e manter?

Estamos usando AlwaysOn Availability Groupo recurso do SQL Server 2012. Backups de banco de dados completos regulares e backups de log de transações são feitos todos os dias no banco de dados secundário.

Eu li aqui fazer o backup do log de transações na réplica primária ou na réplica secundária marcará os logs de transações das duas réplicas como reutilizáveis. De qualquer forma, o tamanho do backup do log de transações é grande e pode ser reduzido usando o arquivo de redução:

Eu restaurei o banco de dados localmente e executei a operação de redução. O tamanho do arquivo de log foi reduzido para 160 MB.

Minha pergunta é em qual banco de dados devo realizar uma operação de redução no arquivo de log de transações (primário, secundário ou ambos)?

Eu acho que no passado por vários anos nenhum backup do arquivo de log é feito, então ele se tornou tão grande. Executando DBCC SQLPERF (LOGSPACE), posso ver que apenas 0.06%o arquivo é usado - não há sentido em manter um tamanho tão grande do arquivo de log. Em [sys].[database_files]eu verifico se max_sizeestá definido para com, -1então acho que quando precisar de mais espaço, ele terá. De qualquer forma, posso reduzi-lo para 5%, por exemplo, para evitar um crescimento futuro. Estou tentando encontrar alguma confirmação de que não é má ideia fazê-lo.growth65536

Na verdade, os backups (no banco de dados e nos arquivos de log) são executados apenas nos bancos de dados secundários, portanto, será mais fácil realizar a redução do arquivo neles, mas o tamanho do arquivo de log principal também será reduzido?

Recentemente descobri que o MySQL tem um offsetrecurso. Tenho tentado encontrar documentação sobre os resultados do deslocamento ou a diferença entre o deslocamento e a variante de limite, mas não consigo encontrar o que estou procurando.

Digamos que eu tenha 10.000 linhas em uma tabela e quero 25 resultados, da linha 1.000. Tanto quanto eu cheguei até agora, eu poderia fazer as duas coisas para obter o mesmo resultado:

SELECT id,name,description FROM tablename LIMIT 1000,25
SELECT id,name,description FROM tablename LIMIT 25 OFFSET 1000

O que eu gostaria de saber é a diferença entre os dois.

• Isso realmente faz o mesmo ou meu entendimento está errado?
• É um mais lento/rápido em tabelas maiores
• O resultado do deslocamento muda quando eu faço WHERE column=1(digamos que a coluna tenha> 100 valores diferentes)
• O resultado do deslocamento muda quando eu faço ORDER BY column ASC(supondo que tenha valores aleatórios)

Tenho a sensação de que o deslocamento pula as primeiras linhas X encontradas no banco de dados, desconsiderando a classificação e o local.

Por que algo assim não funciona?

SELECT
CASE 
WHEN NULLIF(COL_LENGTH('Customers', 'Somecol'), '') IS NULL THEN NULL
ELSE Somecol
END AS MyTest
FROM Customers;

Estou apenas verificando se a coluna existe, porém, o SQL Server reclama de Somecolnão existir. Existe uma alternativa para isso em uma única declaração?

Eu tenho um banco de dados PostgreSQL rodando em um servidor que tem seu fuso horário definido para o fuso horário da Índia (ou seja, UTC +5:30)

Eu tenho alguns dados em uma tabela que é criada assim:

CREATE TABLE "CLOUDDATA"
(
  "CD_Tm_Obs" timestamp without time zone,
  "CD_Avg_Cloud" double precision
)

Eu quero consultar os dados e obter os valores para um tempo específico. Minha entrada será um carimbo de data/hora Unix (ou seja, segundos de 1 a janeiro de 1970)

A única maneira de converter a hora unix para Timestamp que encontrei é esta: select to_timestamp(TRUNC(CAST(1395036000 AS bigint))). Mas isso cria um timestamp com timezone. Meus dados estão em timestamp without time zone, então não obtenho nenhum resultado.

Como converter uma hora unix para o Timstamp do PostgreSQL sem timezome?

Eu tenho uma tabela que é criada assim:

--
-- Table: #__content
--
CREATE TABLE "jos_content" (
  "id" serial NOT NULL,
  "asset_id" bigint DEFAULT 0 NOT NULL,
   ...
  "xreference" varchar(50) DEFAULT '' NOT NULL,
  PRIMARY KEY ("id")
);

Mais tarde, algumas linhas são inseridas especificando o id:

INSERT INTO "jos_content" VALUES (1,36,'About',...)

Posteriormente alguns registros são inseridos sem id e falham com o erro: Error: duplicate key value violates unique constraint.

Aparentemente, o id foi definido como uma sequência:

Cada inserção com falha aumenta o ponteiro na sequência até que ele seja incrementado para um valor que não existe mais e as consultas sejam bem-sucedidas.

SELECT nextval('jos_content_id_seq'::regclass)

O que há de errado com a definição da tabela? Qual é a maneira inteligente de corrigir isso?

Parece que me lembro que, em 2008, você poderia restaurar um backup para uma nova cópia de um banco de dados, alterando o nome no campo "Banco de dados de destino" do assistente de restauração. Isso criaria um novo banco de dados, que é uma cópia do banco de dados original restaurado no momento desejado. Eu ainda não descobri como fazer o SQL 2012 fazer isso.

Agora, eu entendo (graças a Aaron Bertrand) que isso realmente não mudou, e que 2012 está realmente tornando mais óbvio para mim que essa estratégia foi uma má ideia em primeiro lugar!

Então, o que eu preciso fazer é o seguinte: Criar um novo banco de dados, 'MyDB_Copy', a partir de um banco de dados existente, 'MyDB', usando seus arquivos de backup. Temos backups completos noturnos (.bak) e TLogs a cada 15 minutos (.trn). Eu não quero que o 'MyDB' existente seja afetado/tocado, porque está "ao vivo".

Depois que o MyDB_Copy é criado a partir do arquivo de backup completo principal, preciso restaurar algumas dúzias de backups TLog para chegar a um determinado ponto no tempo.

Estamos migrando do SQL 2005 [instância e banco de dados com agrupamento de SQL_Latin1_General_CP1_CI_AS] para SQL 2008 [cujo padrão é Latin1_General_CI_AS].

Concluí uma instalação do SQL 2008 R2 e usei o Latin1_General_CI_ASagrupamento padrão, com a restauração do banco de dados ainda em SQL_Latin1_General_CP1_CI_AS. Ocorreram os problemas de exceção - as tabelas #temp foram inseridas Latin1_General_CI_ASenquanto o banco de dados estava SQL_Latin1_General_CP1_CI_ASe é aqui que estou agora - preciso de conselhos sobre as armadilhas agora, por favor.

Na instalação do SQL 2008 R2, tenho a opção de instalação 'SQL Collation, used for backwards compatibility'onde tenho a opção de selecionar o mesmo agrupamento do banco de dados 2005: SQL_Latin1_General_CP1_CI_AS.

1. Isso me permitirá não ter problemas com tabelas #temp, mas existem armadilhas?

2. Eu perderia alguma funcionalidade ou recurso de qualquer tipo por não usar um agrupamento "atual" do SQL 2008?

3. E quando passarmos (por exemplo, em 2 anos) de 2008 para o SQL 2012? Terei problemas então?

4. Em algum momento eu seria forçado a ir Latin1_General_CI_AS?

5. Eu li que alguns scripts de DBA completam as linhas de bancos de dados completos e, em seguida, executam o script de inserção no banco de dados com o novo agrupamento - estou com muito medo e cauteloso com isso - você recomendaria fazer isso?