All perguntas(dba)

Eu descobri recentemente que nossos servidores web de produção que executam o MySQL não estão sendo copiados regularmente (ou de forma alguma). Estou acostumado a fazer backup de bancos de dados SQL Server, mas não tenho muita experiência com bancos de dados MySQL. Alguma prática recomendada para usar 'mysqldump' ou qualquer outra ferramenta de backup de banco de dados?

Provavelmente vou fazer o cron job do cronograma para que seja feito todas as noites e depois fazer backup dos arquivos com meu sistema de backup.

Obrigado.

Recentemente, comecei a usar o Management Studio 2012. Ao usar o MySQL Workbench, um recurso útil era que eu podia ficar tudo em letras minúsculas e qualquer palavra reservada (como SELECT, INSERT) seria convertida em maiúsculas automaticamente. Como faço para replicar esse comportamento no SSMS?

Eu tenho uma tabela existente com dados:

dbo.Test (col1,col2,col3....) ON [PRIMARY]

Eu preciso mudar essa tabela para ser particionada assim:

dbo.Test(col1,col2,col3....) ON Ps_Date(Col2)

Como posso conseguir isso sem descartar e recriar a tabela?

Estou projetando um banco de dados que armazenará dados em diferentes idiomas (usando UTF-8), então acho que a melhor maneira de exibir os resultados da consulta é ordenando-os de acordo com o idioma do usuário durante a própria consulta ( porque há mais de um maneiras corretas de fazer isso ), como segue:

SELECT a < b COLLATE "de_DE" FROM test1;

Supondo que esta seja a maneira correta de trabalhar com dados internacionais, qual é o melhor agrupamento para o próprio banco de dados? A documentação do PostgreSQL diz :

Os agrupamentos C e POSIX especificam o comportamento "C tradicional", no qual apenas as letras ASCII "A" a "Z" são tratadas como letras e a classificação é feita estritamente por valores de byte de código de caractere.

Acho que esta é a melhor escolha neste caso, ou estou errado?

(Pergunta bônus: é muito lento selecionar o agrupamento na própria consulta?).

Eu tenho uma tabela que tem um ID, um valor e uma data. Há muitos IDs, Valores e datas nesta tabela.

Os registros são inseridos nesta tabela periodicamente. O ID permanecerá sempre o mesmo, mas ocasionalmente o valor mudará.

Como posso escrever uma consulta que me dará o ID mais a hora mais recente em que o valor foi alterado? Nota: o valor sempre aumentará.

A partir destes dados de exemplo:

  Create Table Taco
 (  Taco_ID int,
    Taco_value int,
    Taco_date datetime)

Insert INTO Taco 
Values (1, 1, '2012-07-01 00:00:01'),
        (1, 1, '2012-07-01 00:00:02'),
        (1, 1, '2012-07-01 00:00:03'),
        (1, 1, '2012-07-01 00:00:04'),
        (1, 2, '2012-07-01 00:00:05'),
        (1, 2, '2012-07-01 00:00:06'),
        (1, 2, '2012-07-01 00:00:07'),
        (1, 2, '2012-07-01 00:00:08')

O resultado deve ser:

Taco_ID      Taco_date
1            2012-07-01 00:00:05

(Porque 00:05 foi a última vez que Taco_Valuemudou.)

Temos 40 bancos de dados em nosso servidor.

Queremos fazer backup de 36 bancos de dados usando mysqldump. Como posso ignorar os 4 bancos de dados restantes no comando mysqldump? Existe alguma opção para o mysqldump ignorar bancos de dados para backup no MySQL?

Eu conheço o comando geral mysqldump, mas é muito longo. Eu quero ignorar apenas 4 bancos de dados e preciso fazer backup de dbs restantes.

Quero ter um relacionamento um-para-muitos em que, para cada pai, um ou zero dos filhos seja marcado como "favorito". No entanto, nem todos os pais terão um filho. (Pense nos pais como perguntas neste site, filhos como respostas e favoritos como a resposta aceita.) Por exemplo,

TableA
    Id            INT PRIMARY KEY

TableB
    Id            INT PRIMARY KEY
    Parent        INT NOT NULL FOREIGN KEY REFERENCES TableA.Id

A meu ver, posso adicionar a seguinte coluna à TabelaA:

    FavoriteChild INT NULL FOREIGN KEY REFERENCES TableB.Id

ou a seguinte coluna para TableB:

    IsFavorite    BIT NOT NULL

O problema com a primeira abordagem é que ela introduz uma chave estrangeira anulável, que, pelo que entendi, não está na forma normalizada. O problema com a segunda abordagem é que mais trabalho precisa ser feito para garantir que no máximo um filho seja o favorito.

Que tipo de critério devo usar para determinar qual abordagem usar? Ou existem outras abordagens que não estou considerando?

Estou usando o SQLServer 2012.

De acordo com a documentação, desde que eu não esteja conectado a um banco de dados, posso excluir um banco de dados no console usando:

DROP DATABASE dbname;

Ou posso soltá-lo usando a ferramenta wrapper dropdb.

Ambos me dão um erro dizendo que o banco de dados não existe, mas quando no console e digito o comando \l, recebo uma lista de bancos de dados incluindo o que quero excluir.

                                          List of databases
           Name            |   Owner   | Encoding |   Collate   |    Ctype    |   Access privileges   
---------------------------+-----------+----------+-------------+-------------+-----------------------
 Blog_development          | myusername | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 Blog_test                 | myusername | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 

O nome do banco de dados é Blog_development (e o que está abaixo dele). Eu estava brincando com trilhos e tentando aprender com a documentação online. Eu queria começar de novo e apagar tudo.

Ao tentar excluí-lo, no entanto, ele diz que não existe. Eu sou novo no PostgreSQL, então estou um pouco perdido, nada na documentação sobre esse erro além de aparecer quando ele não existe. Claro que existe, está bem ali.

Eu tenho uma visão muito importante, muito lenta, que inclui algumas condições realmente feias como esta em sua cláusula where. Também estou ciente de que as junções são brutas e lentas em varchar(13)vez de campos de identidade de número inteiro, mas gostaria de melhorar a consulta simples abaixo que usa essa exibição:

CREATE VIEW [dbo].[vwReallySlowView]  AS  
AS  
SELECT     
  I.booking_no_v32 AS bkno, 
  I.trans_type_v41 AS trantype, 
  B.Assigned_to_v61 AS Assignbk, 
  B.order_date AS dateo, B.HourBooked AS HBooked,   
  B.MinBooked AS MBooked, B.SecBooked AS SBooked, 
  I.prep_on AS Pon, I.From_locn AS Flocn, 
  I.Trans_to_locn AS TTlocn,   
                      (CASE I.prep_on WHEN 'Y' THEN I.PDate ELSE I.FirstDate END) AS PrDate, I.PTimeH AS PrTimeH, I.PTimeM AS PrTimeM,   
                      (CASE WHEN I.RetnDate < I.FirstDate THEN I.FirstDate ELSE I.RetnDate END) AS RDatev, I.bit_field_v41 AS bitField, I.FirstDate AS FDatev, I.BookDate AS DBooked,   
                      I.TimeBookedH AS TBookH, I.TimeBookedM AS TBookM, I.TimeBookedS AS TBookS, I.del_time_hour AS dth, I.del_time_min AS dtm, I.return_to_locn AS rtlocn,   
                      I.return_time_hour AS rth, I.return_time_min AS rtm, (CASE WHEN I.Trans_type_v41 IN (6, 7) AND (I.Trans_qty < I.QtyCheckedOut)   
                      THEN 0 WHEN I.Trans_type_v41 IN (6, 7) AND (I.Trans_qty >= I.QtyCheckedOut) THEN I.Trans_Qty - I.QtyCheckedOut ELSE I.trans_qty END) AS trqty,   
                      (CASE WHEN I.Trans_type_v41 IN (6, 7) THEN 0 ELSE I.QtyCheckedOut END) AS MyQtycheckedout, (CASE WHEN I.Trans_type_v41 IN (6, 7)   
                      THEN 0 ELSE I.QtyReturned END) AS retqty, I.ID, B.BookingProgressStatus AS bkProg, I.product_code_v42, I.return_to_locn, I.AssignTo, I.AssignType,   
                      I.QtyReserved, B.DeprepOn,  
        (CASE  B.DeprepOn       
        WHEN 1 THEN  B.DeprepDateTime     
        ELSE   I.RetnDate  
           END)  AS DeprepDateTime, I.InRack 
FROM         dbo.tblItemtran AS I 

INNER JOIN  -- booking_no = varchar(13)
         dbo.tblbookings AS B ON B.booking_no = I.booking_no_v32  --  string inner-join

INNER JOIN  -- product_code = varchar(13) 
        dbo.tblInvmas AS M ON I.product_code_v42 = M.product_code  --  string inner-join

WHERE     (I.trans_type_v41 NOT IN (2, 3, 7, 18, 19, 20, 21, 12, 13, 22)) AND (I.trans_type_v41 NOT IN (6, 7)) AND (I.bit_field_v41 & 4 = 0) OR  
                      (I.trans_type_v41 NOT IN (6, 7)) AND (I.bit_field_v41 & 4 = 0) AND (B.BookingProgressStatus = 1) OR  
                      (I.trans_type_v41 IN (6, 7)) AND (I.bit_field_v41 & 4 = 0) AND (I.QtyCheckedOut = 0) OR  
                      (I.trans_type_v41 IN (6, 7)) AND (I.bit_field_v41 & 4 = 0) AND (I.QtyCheckedOut > 0) AND (I.trans_qty - (I.QtyCheckedOut - I.QtyReturned) > 0)  

Essa visão geralmente é usada assim:

select * from vwReallySlowView
where product_code_v42  = 'LIGHTBULB100W'  -- find "100 watt lightbulb" rows

Quando eu o executo, recebo esse item do plano de execução custando de 20 a 80% do custo total do lote, com predicado CONVERT_IMPLICIT( .... &(4))mostrando que parece ser muito lento em fazer bitwise boolean testscoisas como (I.ibitfield & 4 = 0).

Não sou um especialista em MS SQL ou em trabalhos do tipo DBA em geral, pois sou um desenvolvedor de software não SQL na maioria das vezes. Mas eu suspeito que essas combinações bit a bit são uma má ideia e que teria sido melhor ter campos booleanos discretos.

Eu poderia de alguma forma melhorar esse índice que tenho, para lidar melhor com essa visão sem alterar o esquema (que já está em produção em milhares de locais) ou devo alterar a tabela subjacente que possui vários valores booleanos compactados em um número inteiro bit_field_v41, para corrigir esse problema ?

Aqui está meu índice agrupado no tblItemtranqual está sendo verificado neste plano de execução:

-- goal:  speed up  select * from vwReallySlowView where productcode  = 'X'
CREATE CLUSTERED INDEX [idxtblItemTranProductCodeAndTransType] ON [dbo].[tblItemtran] 
(
    [product_code_v42] ASC,  -- varchar(13)
    [trans_type_v41] ASC     -- int
)WITH ( PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, 
        IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, 
        ALLOW_PAGE_LOCKS  = ON) 
ON [PRIMARY]

Aqui está o plano de execução, para um dos outros produtos que resulta em um custo de 27% neste CONVERT_IMPLICITpredicado. atualização Observe que, neste caso, meu pior nó agora é "correspondência de hash" em um inner join, que está custando 34% Acredito que esse seja um custo que não posso evitar, a menos que possa evitar fazer junções em strings que não posso atualmente livrar-se de. Ambas as INNER JOINoperações na exibição acima estão em varchar(13)campos.

Ampliado no canto inferior direito:

Todo o plano de execução como .sqlplan está disponível no skydrive. Esta imagem é apenas uma visão geral visual. Clique aqui para ver a imagem por si só.

A atualização postou todo o plano de execução. Não consigo descobrir qual product_codevalor era patologicamente ruim, mas uma maneira de fazer isso é, em select count(*) from viewvez de fazer um único produto. Mas produtos que são usados ​​em apenas 5% dos registros na tabela subjacente ou menos parecem apresentar custos muito menores na CONVERT_IMPLICIT operação. Se eu fosse consertar o SQL aqui, acho que pegaria a WHEREcláusula bruta na exibição, calcularia e armazenaria o resultado dessa condição gigante da cláusula where como um campo de bits "IncludeMeInTheView", na tabela subjacente . Presto, problema resolvido, certo?

Quando tento executar pg_restore.exeum arquivo de despejo de um banco de dados, ele lança dezenas de erros, todos iguais:

ERROR: insert or update on table "someTable" violates foreign key constraint "aConstraintName"

Isso se deve obviamente ao fato de que eu esvaziei o banco de dados antes de restaurá-lo do arquivo de despejo (este arquivo vem de um banco de dados de produção) ... ...

Existe uma maneira de desabilitar as restrições e todas as chaves estrangeiras, para todas as tabelas, antes de chamar pg_restore.exee, depois, reativar as restrições e chaves estrangeiras.

No SO eu encontrei algo interessante: adiar a verificação de restrição para confirmar o tempo . Mas acho que não posso ligar pg_restore.exede dentro psql.exedepois de adiar as restrições.

Há também este post , que data de 10 anos atrás, sugerindo a retirada e a adição das restrições. Ou alterar o valor de pg_class reltriggers para 0 e isso também seria possível para restrições ... mas temo que seja mais hacking do que uma boa prática ...

O que você aconselha, qual é a melhor prática neste caso? O uso pg_dump.exe com o -cleansinalizador cria um dump que ignora as restrições de verificação ao restaurar o banco de dados?