All perguntas(dba)

Eu tenho uma tabela que atualmente tem valores duplicados em uma coluna.

Não posso remover essas duplicatas errôneas, mas gostaria de impedir que valores não exclusivos adicionais sejam adicionados.

Posso criar um UNIQUEque não verifique a conformidade existente?

Já tentei usar NOCHECKmas não obtive sucesso.

Nesse caso, tenho uma tabela que vincula as informações de licenciamento a "CompanyName"

EDIT: Ter várias linhas com o mesmo "CompanyName" é um dado incorreto, mas não podemos remover ou atualizar essas duplicatas neste momento. Uma abordagem é fazer com que os INSERTs usem um procedimento armazenado que falhará para duplicatas... Se fosse possível que o SQL verificasse a exclusividade por conta própria, seria preferível.

Esses dados são consultados pelo nome da empresa. Para as poucas duplicatas existentes, isso significará que várias linhas serão retornadas e exibidas... Embora isso esteja errado, é aceitável em nosso caso de uso. O objetivo é evitar isso no futuro. Parece-me pelos comentários que tenho que fazer essa lógica nos procedimentos armazenados.

Pergunta conceitual: As consultas individuais são mais rápidas do que as junções ou: Devo tentar espremer todas as informações que desejo no lado do cliente em uma instrução SELECT ou apenas usar quantas parecer conveniente?

TL;DR : Se minha consulta associada demorar mais do que a execução de consultas individuais, isso é minha culpa ou isso é esperado?

Em primeiro lugar, não sou muito experiente em banco de dados, então pode ser apenas eu, mas notei que quando tenho que obter informações de várias tabelas, é "muitas vezes" mais rápido obter essas informações por meio de várias consultas em tabelas individuais (talvez contendo uma junção interna simples) e remendar os dados no lado do cliente para tentar escrever uma consulta unida (complexa) onde posso obter todos os dados em uma consulta.

Eu tentei colocar um exemplo extremamente simples juntos:

SQL Fiddle

Configuração do esquema :

CREATE TABLE MASTER 
( ID INT NOT NULL
, NAME VARCHAR2(42 CHAR) NOT NULL
, CONSTRAINT PK_MASTER PRIMARY KEY (ID)
);

CREATE TABLE DATA
( ID INT NOT NULL
, MASTER_ID INT NOT NULL
, VALUE NUMBER
, CONSTRAINT PK_DATA PRIMARY KEY (ID)
, CONSTRAINT FK_DATA_MASTER FOREIGN KEY (MASTER_ID) REFERENCES MASTER (ID)
);

INSERT INTO MASTER values (1, 'One');
INSERT INTO MASTER values (2, 'Two');
INSERT INTO MASTER values (3, 'Three');

CREATE SEQUENCE SEQ_DATA_ID;

INSERT INTO DATA values (SEQ_DATA_ID.NEXTVAL, 1, 1.3);
INSERT INTO DATA values (SEQ_DATA_ID.NEXTVAL, 1, 1.5);
INSERT INTO DATA values (SEQ_DATA_ID.NEXTVAL, 1, 1.7);
INSERT INTO DATA values (SEQ_DATA_ID.NEXTVAL, 2, 2.3);
INSERT INTO DATA values (SEQ_DATA_ID.NEXTVAL, 3, 3.14);
INSERT INTO DATA values (SEQ_DATA_ID.NEXTVAL, 3, 3.7);

Consulta A :

select NAME from MASTER
where ID = 1

Resultados :

| NAME |
--------
|  One |

Pergunta B :

select ID, VALUE from DATA
where MASTER_ID = 1

Resultados :

| ID | VALUE |
--------------
|  1 |   1.3 |
|  2 |   1.5 |
|  3 |   1.7 |

Consulta C :

select M.NAME, D.ID, D.VALUE 
from MASTER M INNER JOIN DATA D ON M.ID=D.MASTER_ID
where M.ID = 1

Resultados :

| NAME | ID | VALUE |
---------------------
|  One |  1 |   1.3 |
|  One |  2 |   1.5 |
|  One |  3 |   1.7 |

Claro, não medi nenhum desempenho com estes, mas pode-se observar:

• A consulta A+B retorna a mesma quantidade de informações utilizáveis ​​que a consulta C.
• A+B tem que retornar 1+2x3==7 "Células de Dados" para o cliente
• C tem que retornar 3x3==9 "Células de Dados" para o cliente, porque com a junção eu naturalmente incluo alguma redundância no conjunto de resultados.

Generalizando a partir disso (por mais improvável que seja):

Uma consulta combinada sempre deve retornar mais dados do que as consultas individuais que recebem a mesma quantidade de informações. Como o banco de dados precisa juntar os dados, para grandes conjuntos de dados , pode-se supor que o banco de dados precisa fazer mais trabalho em uma única consulta unida do que nas consultas individuais, pois (pelo menos) precisa retornar mais dados ao cliente.

A partir disso, quando observo que dividir uma consulta do lado do cliente em várias consultas produz um desempenho melhor, esse é apenas o caminho a seguir ou significaria que estraguei a consulta unida?

O problema:

Temos um site social onde os membros podem avaliar uns aos outros para compatibilidade ou correspondência. Esta user_match_ratingstabela contém mais de 220 milhões de linhas (9 giga de dados ou quase 20 giga em índices). As consultas nesta tabela aparecem rotineiramente em slow.log (limiar > 2 segundos) e é a consulta lenta mais frequentemente registrada no sistema:

Query_time: 3  Lock_time: 0  Rows_sent: 3  Rows_examined: 1051
"select rating, count(*) as tally from user_match_ratings where rated_user_id = 395357 group by rating;"

Query_time: 4  Lock_time: 0  Rows_sent: 3  Rows_examined: 1294
"select rating, count(*) as tally from user_match_ratings where rated_user_id = 4182969 group by rating;"

Query_time: 3  Lock_time: 0  Rows_sent: 3  Rows_examined: 446
"select rating, count(*) as tally from user_match_ratings where rated_user_id = 630148 group by rating;"

Query_time: 5  Lock_time: 0  Rows_sent: 3  Rows_examined: 3788
"select rating, count(*) as tally from user_match_ratings where rated_user_id = 1835698 group by rating;"

Query_time: 17  Lock_time: 0  Rows_sent: 3  Rows_examined: 4311
"select rating, count(*) as tally from user_match_ratings where rated_user_id = 1269322 group by rating;"

Versão do MySQL:

• versão do protocolo: 10
• versão: 5.0.77-log
• versão bdb: Sleepycat Software: Berkeley DB 4.1.24: (29 de janeiro de 2009)
• máquina de compilação de versão: x86_64 version_compile_os:redhat-linux-gnu

Informações da tabela:

SHOW COLUMNS FROM user_match_ratings;

Dá:

╔═══════════════╦════════════╦════╦═════╦════════╦════════════════╗
║ id            ║ int(11)    ║ NO ║ PRI ║ NULL   ║ auto_increment ║
║ rater_user_id ║ int(11)    ║ NO ║ MUL ║ NULL   ║                ║
║ rated_user_id ║ int(11)    ║ NO ║ MUL ║ NULL   ║                ║
║ rating        ║ varchar(1) ║ NO ║     ║ NULL   ║                ║
║ created_at    ║ datetime   ║ NO ║     ║ NULL   ║                ║
╚═══════════════╩════════════╩════╩═════╩════════╩════════════════╝

Exemplo de consulta:

select * from mutual_match_ratings where id=221673540;

dá:

╔═══════════╦═══════════════╦═══════════════╦════════╦══════════════════════╗
║ id        ║ rater_user_id ║ rated_user_id ║ rating ║ created_at           ║
╠═══════════╬═══════════════╬═══════════════╬════════╬══════════════════════╣
║ 221673540 ║ 5699713       ║ 3890950       ║ N      ║ 2013-04-09 13:00:38  ║
╚═══════════╩═══════════════╩═══════════════╩════════╩══════════════════════╝

Índices

A tabela tem 3 índices configurados:

1. índice único emrated_user_id
2. índice composto em rater_user_idecreated_at
3. índice composto em rated_user_iderater_user_id

mostre o índice de user_match_ratings;

dá:

╔════════════════════╦════════════╦═══════════════════════════╦══════════════╦═══════════════╦═══════════╦═════════════╦══════════╦════════╦═════════════════════════╦════════════╦══════════════════╗
║ Table              ║ Non_unique ║ Key_name                  ║ Seq_in_index ║ Column_name   ║ Collation ║ Cardinality ║ Sub_part ║ Packed ║ Null                    ║ Index_type ║ Comment          ║
╠════════════════════╬════════════╬═══════════════════════════╬══════════════╬═══════════════╬═══════════╬═════════════╬══════════╬════════╬═════════════════════════╬════════════╬══════════════════╣
║ user_match_ratings ║ 0          ║ PRIMARY                   ║ 1            ║ id            ║ A         ║ 220781193   ║ NULL     ║ NULL   ║ BTREE                   ║            ║                  ║
║ user_match_ratings ║ 1          ║ user_match_ratings_index1 ║ 1            ║ rater_user_id ║ A         ║ 11039059    ║ NULL     ║ NULL   ║ BTREE                   ║            ║                  ║
║ user_match_ratings ║ 1          ║ user_match_ratings_index1 ║ 2            ║ created_at    ║ A         ║ 220781193   ║ NULL     ║ NULL   ║ BTREE                   ║            ║                  ║
║ user_match_ratings ║ 1          ║ user_match_ratings_index2 ║ 1            ║ rated_user_id ║ A         ║ 4014203     ║ NULL     ║ NULL   ║ BTREE                   ║            ║                  ║
║ user_match_ratings ║ 1          ║ user_match_ratings_index2 ║ 2            ║ rater_user_id ║ A         ║ 220781193   ║ NULL     ║ NULL   ║ BTREE                   ║            ║                  ║
║ user_match_ratings ║ 1          ║ user_match_ratings_index3 ║ 1            ║ rated_user_id ║ A         ║ 2480687     ║ NULL     ║ NULL   ║ BTREE                   ║            ║                  ║
╚════════════════════╩════════════╩═══════════════════════════╩══════════════╩═══════════════╩═══════════╩═════════════╩══════════╩════════╩═════════════════════════╩════════════╩══════════════════╝

Mesmo com os índices essas consultas são lentas.

Minha pergunta:

Separar essa tabela/dados para outro banco de dados em um servidor que tenha ram suficiente para armazenar esses dados na memória, isso aceleraria essas consultas? Existe alguma coisa que as tabelas/índices estão configuradas que podemos melhorar para tornar essas consultas mais rápidas?

Atualmente temos 16GB de memória; no entanto, estamos pensando em atualizar a máquina existente para 32 GB ou adicionar uma nova máquina com pelo menos isso, talvez unidades de estado sólido também.

Temos um procedimento armazenado que os usuários podem executar manualmente para obter alguns números atualizados para um relatório que é usado constantemente ao longo do dia.

Eu tenho um segundo procedimento armazenado que deve ser executado após a execução do primeiro procedimento armazenado, pois é baseado nos números obtidos desse primeiro procedimento armazenado, no entanto, leva mais tempo para ser executado e é para um processo separado, portanto, não quero faça o usuário esperar enquanto este segundo procedimento armazenado é executado.

Existe uma maneira de fazer com que um procedimento armazenado inicie um segundo procedimento armazenado e retorne imediatamente sem esperar pelos resultados?

Estou usando o SQL Server 2005.

Eu encontrei este script sql-server-2005-reaching-table-row-size-limit que parece retornar o tamanho da linha por comprimentos de tipo de dados definidos. Eu preciso de um script que me dê todas as linhas em uma tabela que seu tamanho máximo de dados está acima do recomendado 8024 (o que o MS recomenda)

Como faço para definir uma coluna de carimbo de data/hora cujo valor padrão é a hora UTC atual?

MySQL usa UTC_TIMESTAMP()função para timestamp UTC:

mysql> SELECT UTC_TIMESTAMP();
+---------------------+
| UTC_TIMESTAMP()     |
+---------------------+
| 2012-07-01 11:36:35 |
+---------------------+
1 row in set (0.00 sec)

Então eu tentei:

CREATE TABLE `blah` (
`creation_time` TIMESTAMP DEFAULT UTC_TIMESTAMP,
...

E outras variações, como UTC_TIMESTAMP(), mas sem sucesso.

Normalmente, quando crio um procedimento armazenado, uso o seguinte como modelo de classificação

Create procedure <procedurename>
<@param1 <type>, @param2 <type>, etc..> 
as begin

 <procedure>

end

Existe uma maneira de incluir a concessão de permissão de execução apenas nesse procedimento armazenado enquanto estou nisso?
Por exemplo como...

Grant execute [User_Execute] 

... mas apenas para este procedimento armazenado?

Eu vi algumas outras perguntas semelhantes, mas elas parecem se referir a TODOS os procedimentos armazenados e não apenas a um, nem vi um em que você possa especificar permissões dentro do create procedurescript. Até mesmo respostas sobre como posso definir permissões sem a GUI para procedimentos armazenados específicos seriam bem-vindas.

Editar A resposta principal certamente me apontou na direção certa, isso é essencialmente o que eu estava procurando, não pensei em agrupar os comandos, o que acabei fazendo, agrupando o comando junto com meu procedimento armazenado. De qualquer forma, eu acho que é bem maneiro.

Create procedure <procedurename>
<@param1 <type>, @param2 <type>, etc..> 
as begin

<procedure>

end
GO
GRANT EXECUTE ON <procedurename> to <username>
GO

Estou tentando excluir um principal do banco de dados, mas não consigo porque ele possui um esquema. Quando vou editar o usuário, porém, a caixa para desmarcar esquemas fica azul e irremovível. Como posso remover o principal desses esquemas?

Eu herdei um Planos de Manutenção que faz o seguinte:

• Limpar dados antigos
• Verifica a integridade do banco de dados
• Executa backups de banco de dados e log de transações
• Reorganiza nossos índices
• Estatísticas de atualizações
• Excluir backups antigos e arquivos do Plano de Manutenção

Do plano de manutenção de 23 minutos, a atualização das estatísticas leva impressionantes 13 minutos. Durante esse período de 13 minutos, o acesso ao banco de dados é bloqueado (ou pelo menos, a replicação desse banco de dados para os outros é pausada).

Minha pergunta é:

Quando devemos atualizar as estatísticas e por quê?

Este parece ser o tipo de coisa que devemos fazer com menos frequência do que todos os dias. Estou tentando nos tirar da mentalidade "só porque" de fazer manutenção desnecessária.

Eu sei que o psiquiatra é o diabo: ele inverte a ordem das páginas e é responsável pelo câncer de pele, fragmentação de dados e aquecimento global. A lista continua... Dito isto, digamos que eu tenha um banco de dados de 100 GB e exclua 50 GB de dados -- não em uma tabela, mas uma poda geral de dados antigos em um nível de banco de dados amplo, cobrindo 90% do tabelas - isso constitui um caso de uso apropriado para reduzir o banco de dados?

Se não, quais são as etapas apropriadas para limpar a casa depois de remover uma porcentagem tão alta de dados de um banco de dados? Posso pensar em dois: Reconstruir Índices e Atualizar Estatísticas. O que mais?