All perguntas(dba)

Estou tentando acessar o servidor "localdb\MSSQLLocalDB" no meu computador por meio do PowerShell com o utilitário SQLCMD. Estou usando o PowerShell v5, .NET v5.0 e o nome do servidor é (localdb)\MSSQLLocalDBquando me conecto a ele no Microsoft SQL Server Management Studio 2014.

PS C:\> sqlcmd -S localdb\MSSQLLocalDBe PS C:\> sqlcmd -S .\localdb\MSSQLLocalDBresultar neste erro:

Sqlcmd: Erro: Microsoft ODBC Driver 11 para SQL Server: Interfaces de rede do SQL Server: Erro ao localizar servidor/instância especificada [xFFFFFFFF].

Consultei o nome do servidor no Management Studio com SELECT @@ServerNamee usei-o após o -Scomando acima e obtive o mesmo erro.

PS C:\> sqlcmd -S localdbdá esse erro:

Sqlcmd: Erro: Microsoft ODBC Driver 11 para SQL Server: Provedor de pipes nomeados: não foi possível abrir uma conexão com o SQL Server [53]

Outras observações: consigo me conectar ao servidor e trabalhar com um banco de dados chamado testdb01 em um aplicativo de console C# usando System.Data.SqlClientesta string de conexão:

"Data Source=(localdb)\\mssqllocaldb;Initial Catalog=testdb01;Integrated Security=SSPI;"

Preciso determinar as datas que são a "3ª sexta-feira de cada mês" para um intervalo de datas de "1.1.1996 - 30.8.2014" no SQL Server.

Espero que eu deva usar uma combinação de DENSE_RANK()e PARTITION BY()para definir "rank = 3". No entanto, sou novo no SQL e não consigo encontrar o código correto.

No MySQL Workbench, pode-se usar o atalho de teclado Ctrl+ ENTERpara executar a instrução no cursor (delineada com ponto e vírgula).

Existe um atalho semelhante no pgAdmin?

Para consultas SQL que abrangem apenas uma linha, uso um comando de voz no Dragon NaturallySpeaking:

Sub Main
    SendKeys "{End}"
    Wait(0.3)
    SendKeys "+{Home}"
    Wait(0.3)
    SendKeys "{F5}"
End Sub

mas não tenho nenhuma solução para consultas SQL que abrangem mais de uma linha.

Eu queria saber qual das duas abordagens a seguir é mais rápida:

1) Três COUNT:

 SELECT Approved = (SELECT COUNT(*) FROM dbo.Claims d
                  WHERE d.Status = 'Approved'),
        Valid    = (SELECT COUNT(*) FROM dbo.Claims d
                    WHERE d.Status = 'Valid'),
        Reject   = (SELECT COUNT(*) FROM dbo.Claims d
                    WHERE d.Status = 'Reject')

2) SUMcom FROMcláusula -:

SELECT  Approved = SUM(CASE WHEN Status = 'Approved' THEN 1 ELSE 0 END),
        Valid    = SUM(CASE WHEN Status = 'Valid'    THEN 1 ELSE 0 END),
        Reject   = SUM(CASE WHEN Status = 'Reject'   THEN 1 ELSE 0 END)
FROM dbo.Claims c;

Fiquei surpreso que a diferença é tão grande. A primeira consulta com três subconsultas retorna o resultado imediatamente, enquanto a segunda SUMabordagem precisa de 18 segundos.

Claimsé uma exibição que seleciona de uma tabela contendo aproximadamente 18 milhões de linhas. Há um índice na coluna FK para a ClaimStatustabela que contém o nome do status.

Por que faz uma diferença tão grande se eu uso COUNTou SUM?

Planos de execução:

• COUNT
• SUM

Existem 12 status no total. Esses três status pertencem a 7% de todas as linhas.

Esta é a visão real, não tenho certeza se é relevante:

CREATE VIEW [dbo].[Claims]
AS
SELECT 
   mu.Marketunitname AS MarketUnit, 
   c.Countryname     AS Country, 
   gsp.Gspname       AS GSP, 
   gsp.Wcmskeynumber AS GspNumber, 
   sl.Slname         AS SL, 
   sl.Wcmskeynumber  AS SlNumber, 
   m.Modelname       AS Model, 
   m.Salesname       AS [Model-Salesname], 
   s.Claimstatusname AS [Status], 
   d.Work_order      AS [Work Order], 
   d.Ssn_number      AS IMEI, 
   d.Ssn_out, 
   Remarks, 
   d.Claimnumber     AS [Claim-Number], 
   d.Rma_number      AS [RMA-Number], 
   dbo.ToShortDateString(d.Received_Date, 1) AS [Received Date], 
   Iddata, 
   Fisl, 
   Fimodel, 
   Ficlaimstatus 
FROM Tabdata AS d 
   INNER JOIN Locsl AS sl 
           ON d.Fisl = sl.Idsl 
   INNER JOIN Locgsp AS gsp 
           ON sl.Figsp = gsp.Idgsp 
   INNER JOIN Loccountry AS c 
           ON gsp.Ficountry = c.Idcountry 
   INNER JOIN Locmarketunit AS mu 
           ON c.Fimarketunit = mu.Idmarketunit 
   INNER JOIN Modmodel AS m 
           ON d.Fimodel = m.Idmodel 
   INNER JOIN Dimclaimstatus AS s 
           ON d.Ficlaimstatus = s.Idclaimstatus 
   INNER JOIN Tdefproducttype 
           ON d.Fiproducttype = Tdefproducttype.Idproducttype 
   LEFT OUTER JOIN Tdefservicelevel 
                ON d.Fimaxservicelevel = Tdefservicelevel.Idservicelevel 
   LEFT OUTER JOIN Tdefactioncode AS ac 
                ON d.Fimaxactioncode = ac.Idactioncode 

Eu vi esta pergunta SSIS 2012 - Como consultar pacotes atualmente em execução no T-SQL?

Ele me dá o seguinte script:

SELECT
    E.execution_id
,   E.folder_name
,   E.project_name
,   E.package_name
,   E.reference_id
,   E.reference_type
,   E.environment_folder_name
,   E.environment_name
,   E.project_lsn
,   E.executed_as_sid
,   E.executed_as_name
,   E.use32bitruntime
,   E.operation_type
,   E.created_time
,   E.object_type
,   E.object_id
,   E.status
,   E.start_time
,   E.end_time
,   E.caller_sid
,   E.caller_name
,   E.process_id
,   E.stopped_by_sid
,   E.stopped_by_name
,   E.dump_id
,   E.server_name
,   E.machine_name
,   E.total_physical_memory_kb
,   E.available_physical_memory_kb
,   E.total_page_file_kb
,   E.available_page_file_kb
,   E.cpu_count
,   F.folder_id
,   F.name
,   F.description
,   F.created_by_sid
,   F.created_by_name
,   F.created_time
,   P.project_id
,   P.folder_id
,   P.name
,   P.description
,   P.project_format_version
,   P.deployed_by_sid
,   P.deployed_by_name
,   P.last_deployed_time
,   P.created_time
,   P.object_version_lsn
,   P.validation_status
,   P.last_validation_time
,   PKG.package_id
,   PKG.name
,   PKG.package_guid
,   PKG.description
,   PKG.package_format_version
,   PKG.version_major
,   PKG.version_minor
,   PKG.version_build
,   PKG.version_comments
,   PKG.version_guid
,   PKG.project_id
,   PKG.entry_point
,   PKG.validation_status
,   PKG.last_validation_time
FROM
    SSISDB.catalog.executions AS E
INNER JOIN
    ssisdb.catalog.folders AS F ON F.name = E.folder_name
INNER JOIN 
    SSISDB.catalog.projects AS P ON P.folder_id = F.folder_id
                                 AND P.name = E.project_name
INNER JOIN
    SSISDB.catalog.packages AS PKG ON PKG.project_id = P.project_id
                                   AND PKG.name = E.package_name;

Mas não responde à minha busca. Estou investigando as razões pelas quais os pacotes falham e preciso obter as mensagens de erro.

Onde posso encontrá-lo?

Eu gostaria de usar o T-SQL para consultar a mensagem de erro.

Eu também tenho este script abaixo, que me aproxima, mas não exatamente:

SELECT 
    q.*
FROM
    (SELECT em.*
     FROM SSISDB.catalog.event_messages em
     WHERE em.operation_id = (SELECT MAX(execution_id) 
                              FROM SSISDB.catalog.executions)
       AND event_name NOT LIKE '%Validate%') q
/* Put in whatever WHERE predicates you might like*/
--WHERE event_name = 'OnError'
WHERE package_name = 'InfoGroup Feed.dtsx'
--WHERE execution_path LIKE '%<some executable>%'
ORDER BY message_time DESC

Este é o e-mail que eu gostaria de abordar, como eles chegaram a essa mensagem de erro:

Qualquer informação sobre como solucionar erros do SSIS é bem-vinda.

Preciso criar alguns dados de teste que envolvam uma hierarquia. Eu poderia facilitar e fazer alguns CROSS JOINs, mas isso me daria uma estrutura completamente uniforme / sem nenhuma variação. Isso não apenas parece monótono, mas a falta de variação nos dados de teste às vezes mascara problemas que, de outra forma, seriam encontrados. Então, estou querendo gerar uma hierarquia não uniforme que siga estas regras:

• 3 níveis de profundidade
  • O nível 1 é aleatório de 5 a 20 nós
  • O nível 2 é de 1 a 10 nós, aleatório por cada nó do nível 1
  • O nível 3 é de 1 a 5 nós, aleatório por cada nó do nível 2
• Todas as ramificações terão 3 níveis de profundidade. A uniformidade em profundidade está ok neste ponto.
• Pode haver sobreposição de nomes de nós filhos em qualquer nível (ou seja, nomes de nós filhos não precisam ser exclusivos em todos os nós do mesmo nível).
• O termo "aleatório" é definido aqui como sendo pseudo-aleatório, não exclusivamente aleatório. Isso precisa ser mencionado, pois o termo "aleatório" é frequentemente usado para significar "ordenação aleatória de um determinado conjunto que não produz duplicatas". Eu aceito que aleatório = aleatório e se o número de filhos por cada nó do Nível 1 for apenas 4, 7 e 8, mesmo em 20 nós no Nível 1 que tenha uma dispersão potencial de 1 a 10 filhos por cada um desses nós, então tudo bem, porque é isso que é aleatório.
• Mesmo que isso possa ser feito facilmente com WHILEloops aninhados, a preferência é encontrar uma abordagem baseada em conjunto. De um modo geral, a geração de dados de teste não tem os requisitos de eficiência que o código de produção teria, mas buscar uma abordagem baseada em conjunto provavelmente será mais educacional e ajudará no futuro a encontrar abordagens baseadas em conjunto para problemas. Portanto WHILE, os loops não são descartados, mas só podem ser usados ​​se nenhuma abordagem baseada em conjunto for possível.
• Baseada em conjunto = idealmente uma única consulta, independentemente de CTEs, APPLYs, etc. Portanto, usar uma tabela de números inline ou existente é bom. Usar uma abordagem WHILE / CURSOR / procedural não funcionará. Suponho que preparar partes dos dados em tabelas temporárias ou variáveis ​​de tabela seja bom, desde que as operações sejam todas baseadas em conjunto, sem loops. No entanto, dito isso, uma abordagem de consulta única provavelmente será preferida em relação a várias consultas, a menos que possa ser demonstrado que a abordagem de várias consultas é realmente melhor. Lembre-se também de que o que constitui "melhor" geralmente é subjetivo ;-). Lembre-se também de que o uso de "tipicamente" na frase anterior também é subjetivo.
• Qualquer versão e edição do SQL Server (2005 e mais recente, suponho) serve.
• Somente T-SQL puro: nada daquelas bobagens de SQLCLR!! Pelo menos em termos de geração de dados. A criação dos diretórios e arquivos será feita usando SQLCLR. Mas aqui estou apenas focando em gerar os valores do que criar.
• T-SQL Multi-statement TVF são considerados procedurais, não baseados em conjunto, embora por fora eles mascarem a abordagem procedimental em um conjunto. Há momentos em que isso é absolutamente apropriado. Este não é um daqueles momentos. Nessa mesma linha, as funções T-SQL Scalar também não são permitidas, não apenas porque também são processuais, mas o Query Optimizer às vezes armazena em cache seu valor e o repete de forma que a saída não seja a esperada.
• T-SQL Inline TVFs (também conhecidos como iTVFs) são okey-dokey, pois são baseados em conjunto e efetivamente o mesmo que usar [ CROSS | OUTER ] APPLY, que foi declarado acima como ok.
• Execuções repetidas da(s) consulta(s) devem produzir resultados principalmente diferentes da execução anterior.
• Atualização de esclarecimento 1: o conjunto de resultados final deve ser expresso como tendo uma linha para cada nó distinto do Level3, tendo o caminho completo começando no Level1. Isso significa que os valores Level1 e Level2 serão necessariamente repetidos em uma ou mais linhas, exceto nos casos de haver apenas um único nó Level2 contendo apenas um único nó Level3.
• Atualização de esclarecimento 2: há uma preferência muito forte para que cada nó tenha um nome ou rótulo, e não apenas um número. Isso permitirá que os dados de teste resultantes sejam mais significativos e realistas.

Não tenho certeza se essas informações adicionais são importantes, mas apenas no caso de ajudar a ter algum contexto, os dados do teste estão relacionados à minha resposta a esta pergunta:

Importar arquivos XML para o SQL Server 2012

Embora não seja relevante neste ponto, o objetivo final de gerar essa hierarquia é criar uma estrutura de diretório para testar métodos recursivos do sistema de arquivos. Os níveis 1 e 2 serão diretórios e o nível 3 acabará sendo o nome do arquivo. Eu pesquisei (tanto aqui quanto nos Googles) e encontrei apenas uma referência para gerar uma hierarquia aleatória:

Linux: criar diretório aleatório/hierarquia de arquivos

Essa pergunta (no StackOverflow) é realmente muito próxima em termos de resultado desejado, pois também visa criar uma estrutura de diretório para teste. Mas essa pergunta (e as respostas) estão focadas em scripts de shell Linux/Unix e não tanto no mundo baseado em conjuntos em que vivemos.

Agora, sei gerar dados aleatórios, e já estou fazendo isso para criar o conteúdo dos arquivos para que eles também apresentem variações. A parte complicada aqui é que o número de elementos dentro de cada conjunto é aleatório, não um campo específico. E , o número de elementos dentro de cada nó precisa ser aleatório de outros nós nos mesmos níveis.

Exemplo de Hierarquia

     Level 1
              Level 3
|---- A
|     |-- 1
|     |   |--- I
|     |
|     |-- 2
|         |--- III
|         |--- VI
|         |--- VII
|         |--- IX
|
|---- B
|     |-- 87
|         |--- AAA
|         |--- DDD
|
|---- C
      |-- ASDF
      |   |--- 11
      |   |--- 22
      |   |--- 33
      |
      |-- QWERTY
      |   |--- beft
      |
      |-- ROYGBP
          |--- Poi
          |--- Moi
          |--- Soy
          |--- Joy
          |--- Roy

Conjunto de resultados de exemplo descrevendo a hierarquia acima

Level 1    Level 2    Level 3
A          1          I
A          2          III
A          2          VI
A          2          VII
A          2          IX
B          87         AAA
B          87         DDD
C          ASDF       11
C          ASDF       22
C          ASDF       33
C          QWERTY     beft
C          ROYGBP     Poi
C          ROYGBP     Moi
C          ROYGBP     Soy
C          ROYGBP     Joy
C          ROYGBP     Roy

Eu tenho uma consulta que une algumas tabelas e tem um desempenho muito ruim - as estimativas de linha estão muito (1000 vezes) erradas e a junção de loops aninhados é escolhida, resultando em várias varreduras de tabela. A forma da consulta é bastante simples, parecendo algo assim:

SELECT t1.id
FROM t1
INNER JOIN t2 ON t1.id = t2.t1_id
LEFT OUTER JOIN t3 ON t2.id = t3.t2_id
LEFT OUTER JOIN t4 ON t3.t4_id = t4.id 
WHERE t4.id = some_GUID

Brincando com a consulta, notei que, quando sugiro usar uma junção de mesclagem para uma das junções, ela é executada muito mais rápido. Isso eu posso entender - Merge join é uma opção melhor para os dados que são unidos, mas o SQL Server simplesmente não estima corretamente escolhendo os Nested Loops.

O que não entendo completamente é por que essa dica de junção altera todas as estimativas para todas as operadoras de planos? Ao ler diferentes artigos e livros, presumi que as estimativas de cardinalidade são executadas antes de o plano ser criado, portanto, usar uma dica não alteraria as estimativas, mas diria explicitamente ao SQL Server para usar uma implementação de junção física específica.

O que vejo, no entanto, é que a sugestão de mesclagem faz com que todas as estimativas se tornem praticamente perfeitas. Por que isso acontece e existem técnicas comuns para fazer o otimizador de consulta fazer uma estimativa melhor sem uma dica - considerando que as estatísticas obviamente permitem isso?

UPD: planos de execução anônimos podem ser encontrados aqui: https://www.dropbox.com/s/hchfuru35qqj89s/merge_join.sqlplan?dl=0 https://www.dropbox.com/s/38sjtv0t7vjjfdp/no_hints_join.sqlplan?dl =0

Eu verifiquei as estatísticas usadas por ambas as consultas usando TF 3604, 9292 e 9204, e elas são idênticas. No entanto, os índices que são verificados/buscados diferem entre as consultas.

Além disso, tentei executar a consulta com OPTION (FORCE ORDER)- ela é ainda mais rápida do que usar merge join, escolhendo HASH MATCH para cada junção.

Recentemente, restaurei um banco de dados para a mesma instância da qual foi feito o backup (SQL Server 2008 R2 Enterprise) e descobri que não conseguia acessar as propriedades do banco de dados.

Eu tenho feito o seguinte:

• Verificado se o proprietário do banco de dados foi definido corretamente usando sp_helpdb.
• Alterado o proprietário do banco de dados para sa. Não é uma correção.
• Mudou o proprietário do banco de dados de volta para o meu sysadminusuário. Não é uma correção.
• Emitido DBCC updateusageem relação ao banco de dados afetado. Não é uma correção.
• Execute DBCC CheckDBem uma cópia restaurada para outra instância. Nenhuma corrupção encontrada. A cópia restaurada (do mesmo arquivo de backup) não gerou nenhum erro ao acessar a janela de propriedades do banco de dados.

Alguém pode ajudar?

A mensagem de erro que recebo ao tentar visualizar as propriedades é:

Não é possível mostrar a caixa de diálogo solicitada. (SqlMgmt)
O tamanho da propriedade não está disponível para o banco de dados '[DBNAME]'.
Esta propriedade pode não existir para este objeto ou pode não ser recuperável devido a direitos de acesso insuficientes. (Microsoft.SqlServer.Smo)

Eu sou um sysadminnesta instância.

Atualização: Como sugerido, criei um novo usuário, tornei-o sysadmin e alterei o proprietário do banco de dados para ele. Não é uma correção infelizmente. Vou ver se um rastreamento de profiler produz algo útil.

Atualização: Aaron - o banco de dados original foi renomeado e colocado offline, mas ainda está nessa instância. O backup desse banco de dados foi então restaurado usando o nome original. Os nomes de arquivo dos novos arquivos de banco de dados são diferentes do original, pois estão na mesma pasta que o mdf/ldf original. O banco de dados restaurado está conduzindo nossos aplicativos críticos normalmente.

Tenho um select no SQL SERVER que trava toda a tabela.

Aqui está o script de configuração (certifique-se de não sobrescrever nada)

USE [master]
GO

IF EXISTS(SELECT 1 FROM sys.databases d WHERE d.name = 'LockingTestDB')
DROP DATABASE LockingTestDB
GO

CREATE DATABASE LockingTestDB
GO

USE [LockingTestDB]
GO
IF EXISTS(SELECT 1 FROM sys.tables t WHERE t.name = 'LockingTestTable')
  DROP TABLE LockingTestTable
GO

CREATE TABLE LockingTestTable (
  Id int IDENTITY(1, 1),
  Name varchar(100),
  PRIMARY KEY CLUSTERED (Id)
)
GO

INSERT INTO LockingTestTable(Name) VALUES ('1')
INSERT INTO LockingTestTable(Name) VALUES ('2')
GO

Abra uma nova janela de consulta e execute a seguinte transação (que contém uma espera):

USE [LockingTestDB]
GO

BEGIN TRANSACTION
  SELECT * FROM LockingTestTable t WITH (UPDLOCK, ROWLOCK) WHERE t.Name = '1'
  WAITFOR DELAY '00:01:00'

COMMIT TRANSACTION
--ROLLBACK
GO

USE [master]
GO

E outro que será executado (certifique-se de que sejam executados ao mesmo tempo):

USE [LockingTestDB]
GO

SELECT * FROM LockingTestTable t WITH (UPDLOCK, ROWLOCK) WHERE t.Name = '2'

USE [master]
GO

Você notará que a segunda consulta será bloqueada pela primeira. Pare a primeira consulta e execute o ROLLBACK e a segunda será concluída.

Por que isso está acontecendo?

PS: Adicionar um índice não clusterizado (com cobertura total) sobre o nome corrigirá isso:

USE [LockingTestDB]
GO

CREATE NONCLUSTERED INDEX [IX_Name] ON [dbo].[LockingTestTable] 
(
  [Name] ASC
)
INCLUDE ( [Id]) WITH (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]
GO

Novamente por quê?

Eu criei a tabela donorno esquema referenceconforme:

CREATE TABLE reference.donor (
    donor_code smallint PRIMARY KEY,
    donor_name character varying NOT NULL,
    donor_type smallint REFERENCES reference.donor_type (type_id),
    alpha_2_code char(2) REFERENCES reference.iso_3166_1 (alpha_2_code)
);

Eu preenchi a tabela conforme:

INSERT INTO reference.donor (donor_code, donor_name, donor_type, alpha_2_code)
SELECT donor_code, donor_name, donor_type, alpha_2_code
FROM reference.donor_template;

Quando eu corro:

\dt+ reference.*

dentro do psql eu vejo a reference.donortabela:

                          List of relations
  Schema   |      Name      | Type  |  Owner   | Size  | Description 
-----------+----------------+-------+----------+-------+-------------
 reference | donor          | table | postgres | 16 kB | 
 reference | donor_template | table | postgres | 16 kB | 
 reference | donor_type     | table | postgres | 16 kB | 
 reference | iso_3166_1     | table | postgres | 48 kB | 
(4 rows)

Mas quando executo \dt+ donor*(ou \dt(+)) não vejo a reference.donortabela:

                          List of relations
  Schema   |      Name      | Type  |  Owner   | Size  | Description 
-----------+----------------+-------+----------+-------+-------------
 oecd_cl   | donor          | table | postgres | 16 kB | 
 reference | donor_template | table | postgres | 16 kB | 
 reference | donor_type     | table | postgres | 16 kB | 
(3 rows)

Por que só consigo ver a reference.donortabela se eu executar \dt+ reference.*ou \dt+ *.donor?
Eu estava esperando \dt(ou \dt+) exibi-lo, mas isso não acontece.

My search_pathinclui o esquema referencee o usuário postgrestem todas as permissões no esquema referencee todas as tabelas no esquema conforme:

GRANT ALL ON ALL TABLES IN SCHEMA reference TO postgres;

Só para esclarecer, tenho duas donortabelas, mas elas estão em dois esquemas diferentes, ou seja, oecd.donor& reference.donor. (Posso ver oecd.donorsem problemas quando uso \dt(+)dentro do psql).