All perguntas(dba)

É fácil demonstrar que muitos formatos de data/hora diferentes dos dois seguintes são vulneráveis ​​a interpretações errôneas devido a SET LANGUAGE, SET DATEFORMAT ou ao idioma padrão de um login:

yyyyMMdd                 -- unseparated, date only
yyyy-MM-ddThh:mm:ss.fff  -- date dash separated, date/time separated by T 

Mesmo este formato, sem o T, pode parecer um formato ISO 8601 válido, mas falha em vários idiomas:

DECLARE @d varchar(32) = '2017-03-13 23:22:21.020';

SET LANGUAGE Deutsch;
SELECT CONVERT(datetime, @d);

SET LANGUAGE Français;
SELECT CONVERT(datetime, @d);

Resultados:

Die Spracheneinstellung wurde auf Deutsch geändert.

Msg 242, Level 16, State 3
Bei der Konvertierung eines varchar-Datentyps in einen datetime-Datentyp liegt der Wert außerhalb des gültigen Bereichs.

Le paramètre de langue est passé à Français.

Msg 242, Nível 16, Estado 3
La convert d'un type de données varchar en type de données datetime a créé une valeur hors limites.

Agora, estes falham como se, em inglês, eu tivesse transposto o mês e o dia, para formular um componente de data de yyyy-dd-mm:

DECLARE @d varchar(32) = '2017-13-03 23:22:21.020';

SET LANGUAGE us_english;
SELECT CONVERT(datetime, @d);

Resultado:

Msg 242, Level 16, State 3
A conversão de um tipo de dados varchar em um tipo de dados datetime resultou em um valor fora do intervalo.

(Este não é o Microsoft Access, que é "legal" para você e corrige a transposição para você. Além disso, erros semelhantes podem acontecer em alguns casos com SET DATEFORMAT ydm;- não é apenas uma coisa de idioma, esse é apenas o cenário mais comum em que esses quebras acontecem - e nem sempre são notadas porque às vezes não são erros, só que 7 de agosto virou 8 de julho e ninguém percebeu.)

Então, a pergunta:

Agora que sei que existem vários formatos inseguros, existem outros formatos que serão seguros, considerando qualquer combinação de idioma e formato de data?

Listar trabalhos, agendamentos e próximas datas de execução agendadas

Estou tentando listar Jobs, Schedules e Next Scheduled Run Datetimes. No entanto, não pareço estar conseguindo.

sysjobactivitytem next_scheduled_run_date, que é o que eu preciso, mas não consigo descobrir como conectá-lo ao Job e ao Schedule.

Se houver outra maneira que não seja sysjobactivity, por favor me guie até lá.

SELECT
sj.name AS jobName
, ss.name AS scheduleName
, sja.next_scheduled_run_date
FROM msdb.dbo.sysjobs sj
INNER JOIN msdb.dbo.sysjobactivity sja ON sja.job_id = sj.job_id
INNER JOIN msdb.dbo.sysjobschedules sjs ON sjs.job_id = sja.job_id
INNER JOIN msdb.dbo.sysschedules ss ON ss.schedule_id = sjs.schedule_id
WHERE (sj.name LIKE 'xray%')
AND (sja.next_scheduled_run_date > GETDATE())

Existe uma maneira de ver o andamento de uma pg_dumpoperação em um banco de dados grande (ou seja, > 1 GB)? adicionar a -vopção apenas despeja o texto na tela, mas não me fornece muitas informações de rastreamento significativas.

Simples: gostaria de contar o número de linhas da subconsulta. Observe que o status é se o host está online ou não.

Código incorreto

SELECT COUNT(ip_address) FROM `ports` (
    SELECT DISTINCT ip_address FROM `ports` WHERE status IS TRUE
)

Explicado

A primeira consulta, quando executada por conta própria, retorna isso:

SELECT DISTINCT ip_address FROM `ports` WHERE status IS TRUE

ip_address  
192.168.1.1
192.168.1.2
192.168.1.248
192.168.1.251
192.168.1.254

A segunda consulta executada por conta própria retorna isso:

SELECT COUNT(ip_address) FROM `ports`

17

Pergunta

Gostaria de saber como contar essa lista de 5 endereços IP.

Eu tenho procurado on-line possíveis soluções para esse problema simples e estou ficando frustrado, então pensei em perguntar aos especialistas.

Tenho várias centenas (atualmente 466, mas sempre crescendo) tabelas que preciso copiar de um servidor para outro.

Eu nunca tive que fazer isso antes, então não tenho certeza de como abordá-lo. Todas as tabelas estão no mesmo formato:Cart<Eight character customer number>

Isso faz parte de um projeto maior do qual estou fundindo todas essas Cart<Number>tabelas em uma única Cartstabela, mas essa é uma questão totalmente diferente.

Alguém tem um método de prática recomendada que eu possa usar para copiar todas essas tabelas? Os nomes dos bancos de dados em ambos os servidores são os mesmos, se isso ajudar. E como eu disse anteriormente, eu tenho a saconta para que eu possa fazer o que for necessário para obter os dados de A para B. Ambos os servidores também estão no mesmo farm de servidores.

Algumas tabelas INNODB em nosso banco de dados de produção estão prestes a atingir o limite INT AUTO_INCREMENT de 2147483647 e precisamos alterá-las para BIGINT, caso contrário as gravações começarão a falhar.

As tabelas estão em um banco de dados MySQL 5.6.19a de produção em execução no Amazon RDS.

Como podemos fazer um ALTER assim sem atrapalhar as leituras e inserções de produção que estão acontecendo o tempo todo?

ALTER TABLE MYTABLECHANGE id idBIGINT NOT NULL AUTO_INCREMENT;

Aqui está o DDL para a tabela:

CREATE TABLE `MYTABLE` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `siteId` int(11) NOT NULL,
  `filter` varchar(10) NOT NULL DEFAULT 'ALL',
  `date` varchar(10) NOT NULL,
  `cards` varchar(250) NOT NULL,
  `apples` varchar(45) NOT NULL,
  `carrots` varchar(45) NOT NULL,
  `corn` varchar(45) NOT NULL,
  `peas` varchar(45) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `unique` (`siteId`,`filter`,`date`,`cards`),
  KEY `date_k` (`date`),
  KEY `cards_k` (`cards`),
  KEY `apples_k` (`apples`),
  KEY `siteId_k` (`siteId`)
) ENGINE=InnoDB AUTO_INCREMENT=1748961482 DEFAULT CHARSET=utf8

Eu tenho uma pergunta sobre XTP_CHECKPOINT.

Estou usando o SQL Server 2014. Tenho um banco de dados que está no modo de modelo de recuperação SIMPLES. Também está sendo replicado.

Não há transações abertas. Já rodei DBCC OPENTRANe retorna:

"Nenhuma transação aberta ativa."

Mas continuo recebendo esta mensagem sempre que tento criar ou descartar uma tabela ou excluir dados:
(substituí meu nome real do banco de dados pela palavra database_name)

"O log de transações do banco de dados 'database_name' está cheio devido a 'XTP_CHECKPOINT'"

Alguém sabe por que isso pode estar acontecendo e, mais importante, como posso fazer isso parar?

E sim, o banco de dados realmente está no modo de modelo de recuperação SIMPLES. ou seja, o log de transações deve truncar automaticamente.

Aliás, outro banco que tenho em full recovery mode fez a mesma coisa, começou a retornar o mesmo erro:

O log de transações do banco de dados 'database_name' está cheio devido a 'XTP_CHECKPOINT'

Tentei alterar as configurações de crescimento do log para crescimento ilimitado, mas não permitia, retornando o mesmo erro.

Posso reproduzir o problema sem nenhum material XTP, exceto apenas o grupo de arquivos. Veja como: http://pastebin.com/jWSiEU9U

Existe um método mais eficiente de obter uma lista de números de 1 a 49 com uma coluna contendo as palavras FIZZquando o número pode ser dividido igualmente por 3, BUZZquando o número pode ser dividido igualmente por 5 e FIZZBUZZquando o número pode ser dividido igualmente por 3 e 5?

Minhas tentativas são (CUIDADO, isso irá esvaziar seu cache de procedimento, então NÃO EXECUTAR EM UMA CAIXA DE PRODUÇÃO):

DBCC FREEPROCCACHE
GO
/*VARIANT1*/
;WITH t AS (
    SELECT RowNum = ROW_NUMBER() OVER (ORDER BY o.object_id)
    FROM sys.objects o
)
SELECT t.RowNum
    , CASE WHEN ((t.RowNum % 3) + (t.RowNum % 5)) = 0  THEN 'FIZZBUZZ' 
    ELSE 
        CASE WHEN t.RowNum % 3 = 0 THEN 'FIZZ' 
        ELSE 
            CASE WHEN t.RowNum % 5 = 0 THEN 'BUZZ' 
            ELSE '' 
            END 
        END 
    END
FROM t
WHERE t.RowNum < 50;
GO 100

/*VARIANT2*/
DECLARE @t TABLE
(
    Num INT NOT NULL PRIMARY KEY CLUSTERED
);
INSERT INTO @t (Num)
SELECT ROW_NUMBER() OVER (ORDER BY o.object_id)
FROM sys.objects o;

SELECT t.Num
    , CASE WHEN ((t.Num % 3) + (t.Num % 5)) = 0  THEN 'FIZZBUZZ' 
    ELSE 
        CASE WHEN t.Num % 3 = 0 THEN 'FIZZ' 
        ELSE 
            CASE WHEN t.Num % 5 = 0 THEN 'BUZZ' 
            ELSE '' 
            END 
        END 
    END
FROM @t t
WHERE t.Num < 50;
GO 100

SELECT CASE WHEN dest.text LIKE '%/*VARIANT1*/%' THEN 'VARIANT1' ELSE 'VARIANT2' END
    , MAX(deqs.execution_count)
    , SUM(deqs.total_worker_time)
    , AvgWorkerTime = SUM(deqs.total_worker_time) / MAX(deqs.execution_count)
FROM sys.dm_exec_query_stats deqs
CROSS APPLY sys.dm_exec_sql_text(deqs.sql_handle) dest
WHERE (dest.text LIKE '%/*VARIANT1*/%'
    OR dest.text LIKE '%/*VARIANT2*/%')
    AND dest.text NOT LIKE '%/*NOT_ME!*/%'
GROUP BY CASE WHEN dest.text LIKE '%/*VARIANT1*/%' THEN 'VARIANT1' ELSE 'VARIANT2' END
ORDER BY CASE WHEN dest.text LIKE '%/*VARIANT1*/%' THEN 'VARIANT1' ELSE 'VARIANT2' END
/*NOT_ME!*/;

Modifiquei minhas tentativas de executar cada conjunto de instruções 100 vezes cada e, em seguida, mostrar os tempos registrados pelo SQL Server por meio de sys.dm_exec_query_stats.

Os resultados:

            Runs    total_time      average time
VARIANT1    100     42533           425
VARIANT2    100     138677          1386

Atualização 2014-12-18

Com a resposta esmagadora à pergunta principal sendo "Não", as respostas mais interessantes se concentraram na parte 2, como resolver o quebra-cabeça de desempenho com um ORDER BY. Embora eu já tenha marcado uma resposta, não ficaria surpreso se houvesse uma solução com desempenho ainda melhor.

Original

Essa dúvida surgiu porque a única solução extremamente rápida que consegui encontrar para um determinado problema só funciona sem uma ORDER BYcláusula. Abaixo está o T-SQL completo necessário para produzir o problema, junto com minha solução proposta (estou usando o SQL Server 2008 R2, se isso for importante).

--Create Orders table
IF OBJECT_ID('tempdb..#Orders') IS NOT NULL DROP TABLE #Orders
CREATE TABLE #Orders
(  
       OrderID    INT NOT NULL IDENTITY(1,1)
     , CustID     INT NOT NULL
     , StoreID    INT NOT NULL       
     , Amount     FLOAT NOT NULL
)
CREATE CLUSTERED INDEX IX ON #Orders (StoreID, Amount DESC, CustID)

--Add 1 million rows w/ 100K Customers each of whom had 10 orders
;WITH  
    Cte0 AS (SELECT 1 AS C UNION ALL SELECT 1), --2 rows  
    Cte1 AS (SELECT 1 AS C FROM Cte0 AS A, Cte0 AS B),--4 rows  
    Cte2 AS (SELECT 1 AS C FROM Cte1 AS A ,Cte1 AS B),--16 rows 
    Cte3 AS (SELECT 1 AS C FROM Cte2 AS A ,Cte2 AS B),--256 rows 
    Cte4 AS (SELECT 1 AS C FROM Cte3 AS A ,Cte3 AS B),--65536 rows 
    Cte5 AS (SELECT 1 AS C FROM Cte4 AS A ,Cte2 AS B),--1048576 rows 
    FinalCte AS (SELECT  ROW_NUMBER() OVER (ORDER BY C) AS Number FROM   Cte5)
INSERT INTO #Orders (CustID, StoreID, Amount)
SELECT CustID = Number / 10
     , StoreID    = Number % 4
     , Amount     = 1000 * RAND(Number)
FROM  FinalCte
WHERE Number <= 1000000

SET STATISTICS IO ON
SET STATISTICS TIME ON

--For StoreID = 1, find the top 500 customers ordered by their most expensive purchase (Amount)

--Solution A: Without ORDER BY
DECLARE @Top INT = 500
SELECT DISTINCT TOP (@Top) CustID
FROM #Orders WITH(FORCESEEK)
WHERE StoreID = 1
OPTION(OPTIMIZE FOR (@Top = 1), FAST 1);
--9 logical reads, CPU Time = 0 ms, elapsed time = 1 ms
GO
--Solution B: With ORDER BY
DECLARE @Top INT = 500
SELECT TOP (@Top) CustID
FROM #Orders
WHERE StoreID = 1
GROUP BY CustID
ORDER BY MAX(Amount) DESC
OPTION(MAXDOP 1)
--745 logical reads, CPU Time = 141 ms, elapsed time = 145 ms
--Uses Sort operator

GO

Aqui estão os planos de execução para a Solução A e B, respectivamente:

A solução A fornece o desempenho de que preciso, mas não consegui fazê-la funcionar com o mesmo desempenho ao adicionar qualquer tipo de cláusula ORDER BY (por exemplo, consulte a Solução B). E certamente parece que a Solução A teria que entregar seus resultados em ordem, já que 1) a tabela tem apenas um índice nela, 2) uma busca é forçada, eliminando assim a possibilidade de usar uma varredura de ordem de alocação baseada em páginas IAM .

Então minhas perguntas são:

1. Estou certo de que garantirá o pedido neste caso sem uma cláusula de pedido?

2. Caso contrário, existe outro método para forçar um plano que seja tão rápido quanto a Solução A, preferencialmente um que evite classificações? Observe que ele teria que resolver exatamente o mesmo problema (para StoreID = 1, encontre os 500 principais clientes solicitados pelo valor de compra mais caro). Também teria que usar a #Orderstabela, mas diferentes esquemas de indexação seriam OK.

Um dos INSERT INTOscripts é escrito da seguinte forma.

INSERT INTO tableName (Column1, Column2,....) VALUES (value1, Value2,...), (value1, Value2,...),....

A seguir está o erro que estamos enfrentando ao analisar acima da instrução de inserção

Msg 10738, Level 15, State 1, Line 1007 O número de expressões de valor de linha na instrução INSERT excede o número máximo permitido de 1.000 valores de linha.

Minha pergunta simples é que, podemos alterar o limite de 1000 valores?