All perguntas(dba)

Sempre que preciso verificar a existência de alguma linha em uma tabela, costumo escrever sempre uma condição como:

SELECT a, b, c
  FROM a_table
 WHERE EXISTS
       (SELECT *  -- This is what I normally write
          FROM another_table
         WHERE another_table.b = a_table.b
       )

Algumas outras pessoas escrevem assim:

SELECT a, b, c
  FROM a_table
 WHERE EXISTS
       (SELECT 1   --- This nice '1' is what I have seen other people use
          FROM another_table
         WHERE another_table.b = a_table.b
       )

Quando a condição é NOT EXISTSem vez de EXISTS: Em algumas ocasiões, posso escrevê-la com a LEFT JOINe uma condição extra (às vezes chamada de antijoin ):

SELECT a, b, c
  FROM a_table
       LEFT JOIN another_table ON another_table.b = a_table.b
 WHERE another_table.primary_key IS NULL

Eu tento evitá-lo porque acho que o significado é menos claro, especialmente quando o que é seu primary_keynão é tão óbvio, ou quando sua chave primária ou sua condição de junção é multi-coluna (e você pode facilmente esquecer uma das colunas). No entanto, às vezes você mantém o código escrito por outra pessoa... e ele está lá.

1. Existe alguma diferença (além do estilo) para usar SELECT 1em vez de SELECT *?
   Existe algum caso de canto em que não se comporte da mesma maneira?

2. Embora o que escrevi seja o SQL padrão (AFAIK): Existe essa diferença para diferentes bancos de dados / versões mais antigas?

3. Existe alguma vantagem em escrever explicitamente um antijoin?
   Os planejadores/otimizadores contemporâneos a tratam de forma diferente da NOT EXISTScláusula?

Eu tenho feito backups dos meus bancos de dados SQL Server 2014 Express para importação para outros servidores e notei uma diferença no tamanho do arquivo entre .bacpace .bak.

Por que um .bacpacarquivo é tão pequeno comparado a um .bakarquivo do mesmo banco de dados?

Obrigado por quaisquer insights!

Eu estava lendo este artigo na BBC. Ele conta a história de uma pessoa chamada Jenifer Null e como ela enfrenta problemas do dia a dia ao usar bancos de dados online como reserva de passagens aéreas, net banking etc.

Não sou muito versado em bancos de dados e não os uso com muita frequência. Quando criei um site para aprendizado, a validação do formulário do lado do servidor usava expressões regulares. Pelo que me lembro, aceitaria alegremente o nome "Null". Eu não tentei embora.

Alguém poderia explicar os detalhes técnicos quando essa situação ocorreria? A validação do formulário está apenas fazendo um string == NULLou algo assim? Mesmo assim não acho NULL is same as "NULL".

Ocasionalmente, movo um banco de dados (SQL Express 2012) de uma máquina de desenvolvimento para um servidor, ou vice-versa, usando backup e restauração de banco de dados no SQL Server Management Studio.

Sempre que faço isso, os aplicativos na máquina de destino não podem acessar o banco de dados até que eu exclua o usuário que eles usam, "george", dos usuários do banco de dados (Banco de dados, Segurança, Usuários no SQL Server Management Studio) e o adicione novamente como proprietário em Segurança, Logins, george/propriedades, mapeamento de usuários.

Existe uma maneira melhor de fazer isso? Parece um pouco complicado.

No PostgreSQL 9.2.3 estou tentando criar esta tabela simplificada:

CREATE TABLE test (
    user_id INTEGER,
    startend TSTZRANGE,
    EXCLUDE USING gist (user_id WITH =, startend WITH &&)
);

Mas recebo este erro:

ERROR:  data type integer has no default operator class for access method "gist"
HINT:  You must specify an operator class for the index or define
       a default operator class for the data type.

Os documentos do PostgreSQL usam este exemplo que não funciona para mim:

CREATE TABLE room_reservation (
    room text,
    during tsrange,
    EXCLUDE USING gist (room WITH =, during WITH &&)
);

Mesma mensagem de erro.

E este , que também não funciona para mim:

CREATE TABLE zoo (
    cage   INTEGER,
    animal TEXT,
    EXCLUDE USING gist (cage WITH =, animal WITH <>)
);

Mesma mensagem de erro.

Eu sou capaz de criar isso sem nenhum problema:

CREATE TABLE test (
    user_id INTEGER,
    startend TSTZRANGE,
    EXCLUDE USING gist (startend WITH &&)
);

e isto:

CREATE TABLE test (
    user_id INTEGER,
    startend TSTZRANGE,
    EXCLUDE USING btree (user_id WITH =)
);

Passei um bom tempo procurando dicas sobre como fazer isso funcionar, ou descobrir por que não funcionaria. Alguma ideia?

Eu entendo que um endereço de e-mail de 254 caracteres é válido, mas as implementações que pesquisei tendem a usar um varchar(60) para varchar(80) ou equivalente. Por exemplo: esta recomendação do SQL Server usa varchar(80) ou este exemplo do Oracle

Existe uma razão para não usar o máximo de 254 caracteres? Um varchar, por definição, não usa apenas o armazenamento necessário para armazenar os dados?

Existem implicações/compensações significativas de desempenho que fazem com que tantas implementações usem menos do que os 254 caracteres possíveis?

Hoje, enquanto solucionava um problema do agente de serviços, descobri que o proprietário do banco de dados era o login do Windows de um funcionário que havia deixado a empresa. Seu login foi removido e, portanto, as notificações de consulta estavam falhando.

Supostamente, a melhor prática para lidar com isso é tornar 'sa' o proprietário do banco de dados. Nós mudamos e isso limpou a fila.

Minha pergunta (muito elementar): qual é o proprietário do banco de dados e qual é o seu propósito?

Nova instalação do CentOS.

Eu estava executando uma importação de um banco de dados grande (arquivo sql de 2 GB) e tive um problema. O cliente SSH parecia perder a conexão e a importação parecia congelar. Eu usei outra janela para fazer login no mysql e a importação parecia estar morta, presa em uma tabela de linhas de 3M específica.

Então eu tentei

DROP DATABASE huge_db;

15-20 minutos depois, nada. Em outra janela, fiz:

/etc/init.d/mysqld restart

A janela DROP DB apresentou a mensagem: SERVER SHUTDOWN. Então eu realmente reiniciei o servidor físico.

Logado novamente no mysql, verificado e o db ainda estava lá, executei

DROP DATABASE huge_db;

novamente, e novamente estou esperando já cerca de 5 minutos.

Mais uma vez, é uma nova instalação. O huge_dbé o único db (diferente do dbs do sistema). Eu juro que deixei cair db's tão grandes antes e rapidamente, mas talvez eu esteja errado.

Eu derrubei com sucesso o banco de dados. Demorou algo como 30 minutos. Observe também que acho que me enganei quando pensei que a importação do mysqldump estava morta. A conexão do terminal foi perdida, mas acho que o processo ainda estava em execução. Eu provavelmente matei a tabela intermediária de importação (a tabela de linhas de 3M) e provavelmente 3/4 do caminho através de todo o banco de dados. Era enganoso que "top" mostrasse o mysql usando apenas 3% da memória, quando parecia que deveria estar usando mais.

Soltar o banco de dados acabou levando 30 minutos, então, novamente, talvez eu não tivesse que reiniciar o servidor e possivelmente poderia ter esperado o DROP terminar, mas não sei como o mysql reagiria ao obter uma consulta DROP para o mesmo db que está importando via mysqldump.

Ainda assim, a pergunta permanece, por que leva mais de 30 minutos para DROP um banco de dados de 2 GB quando tudo o que deveria fazer é excluir todos os arquivos db e remover todas as referências ao banco de dados de information_schema? Qual é o problema?

Como você faz alterações de esquema em um banco de dados ativo sem tempo de inatividade?

Por exemplo, digamos que eu tenha um banco de dados PostgreSQL com uma tabela incluindo vários dados de usuário, como endereços de e-mail, etc., todos associados a usuários específicos. Se eu quisesse mover os endereços de e-mail para uma nova tabela dedicada, teria que alterar o esquema e migrar os dados de e-mail para a nova tabela. Como isso poderia ser feito sem interromper as gravações na tabela original? Certamente, enquanto os dados são gravados da tabela antiga para a nova, os novos dados continuariam a ser gravados na tabela antiga e seriam perdidos, certo?

Acho que esse problema surge com bastante frequência, mas não consigo encontrar nenhuma solução padrão para lidar com isso.

Este artigo trata do problema, mas eu realmente não entendi a etapa 3. Ele diz para gravar nas duas tabelas e depois migrar os dados antigos da primeira tabela para a nova. Como você garante que está migrando apenas dados antigos?

(Eu uso PostgreSQL no Heroku .)

No PostreSQL 8.3, estou tentando criar uma visão que se pareça com uma tabela existente, mas com nomes de colunas diferentes.

Isso funciona

CREATE OR REPLACE VIEW gfam.nice_builds AS 
 SELECT (family_tree.family_tree_id) as x,
        family_tree.family_tree_name, family_tree.family_tree_description
   FROM gfam.family_tree;

O acima faz uma duplicata da tabela family_tree, mas a tentativa a seguir falha:

CREATE OR REPLACE VIEW gfam.nice_builds AS 
 SELECT (family_tree.family_tree_id) as x,
        family_tree.family_tree_name, family_tree.family_tree_description
   FROM gfam.family_tree;

• ERRO: não é possível alterar o nome da coluna de visualização "family_tree_id"

Como posso renomear colunas?