Warren P's questions

Acabei de descobrir que a palavra-chave DML ROWGUIDCOLestá obsoleta, a substituição é $rowguid; e essa palavra-chave DML IDENTITYCOLestá obsoleta, o novo nome é $identity.

Não entendo por que um DML não variável (sem símbolo de cifrão) pode ser substituído pelo que é essencialmente um alias, que, se eu o entendo, às vezes será avaliado de volta ROWGUIDCOLe às vezes para outra coisa? Alguém pode explicar o que está acontecendo aqui? O que significa essa depreciação?

Na amostra AdventureWorks, por exemplo, não acho que isso signifique que devo fazer isso:

CREATE TABLE [Sales].[Customer]
(
    [CustomerID] [int] IDENTITY(1,1) NOT FOR REPLICATION NOT NULL,
    ...
    [rowguid] [uniqueidentifier] $rowguid  NOT NULL,
    ...
);
GO

O acima não funciona, obviamente. Então, o que está dizendo é obsoleto? Claramente não é a palavra-chave ROWGUIDCOLacima?

Eu pensei que quando algo está obsoleto, uma nova sintaxe já deve existir e isso me daria tempo para fazer a transição para um formulário que não será interrompido no "SQL 2017+".

Origem:

Recursos obsoletos do mecanismo de banco de dados no SQL Server 2016

Atualmente, o SQL Server 2016 CTP 3 e versões posteriores oferecem suporte a campos NVARCHAR(max) com conteúdo JSON. No entanto, como o tipo NVARCHAR(max) é totalmente de forma livre, não há restrição nesses campos.

Posso declarar uma restrição que impeça a inserção de um valor não nulo que não seja um JSON válido?

Durante a instalação do MS SQL Server 2016, em um PC cliente de estação de trabalho desenvolvedor/DBA que está associado a um domínio, a instalação usando todos os logon e outros padrões do instalador é concluída com falhas e uma mensagem muito genérica que significa apenas que o banco de dados SQL principal O serviço do mecanismo (MSSQLSERVER) não foi iniciado. Ao iniciá-lo manualmente a partir de services.msc, vê-se este erro igualmente genérico:

Windows could not start the SQL Server (MSSQLSERVER) on Local Computer. 
For more information, review the System Event Log. If this is a 
non-Microsoft service, contact the service vendor, and refer 
to service-specific error code -2146885628.

No visualizador de eventos do sistema (eventvwr.msc) existem várias falhas:

#1. (1500) User Profile Service error for user NT SERVICE\MSSQLSERVER: Windows 
cannot log you on because your profile cannot be loaded. Check that 
you are connected to the network, and that your network is 
functioning correctly. 

#2. (17826) Could not start the network library because of an internal error in 
the network library. To determine the cause, review the errors 
immediately preceding this one in the error log.

#3. (17182) TDSSNIClient initialization failed with error 0x80092004, 
 status code 0x1. Reason: Initialization failed with an infrastructure 
 error. Check for previous errors. Cannot find object or property. 


#4. (17182)  TDSSNIClient initialization failed with error 0x80092004, status 
code 0x80. Reason: Unable to initialize SSL support. Cannot find 
object or property. 

#5. (17190) Initializing the FallBack certificate failed with error 
code: 1, state: 20, error number: 0.

Existem centenas de kilobytes de arquivos de log, mas nenhuma saída clara em nenhum deles para indicar uma causa raiz.

Isso parece ser uma variante do caso de falha de inicialização SSL-init-failure, mas tive o mesmo erro com o CTP 2.3 e esperava que o instalador do SQL Server me ajudasse a descobrir por que nenhum dos PCs com Windows 10 em meu local O domínio do escritório aceitará e executará o MS SQL 2016 (ou MS SQL 2014) sem atingir alguma variação desses erros de SQL.

SystemConfigurationCheck_Report.htm não contém erros, tudo é marcas de seleção verdes e nenhum erro foi relatado durante a instalação real. Não havia outros serviços/instâncias do MS SQL na máquina anteriormente, mas há um Visual Studio 2015 e MS SQL localdb.

Isso é um erro de SQL, algum erro de perfil local ou algo mais? Eu tentei isso no SQL 2016 CTP 2.3 e 2.4 e tive o mesmo problema. Resolvi esperar até o SQL 2016 CTP 3, que já saiu, mas estou com o mesmo problema.

Parece-me que no windows 10, com o serviço sql logado, NT SERVICE\MSSQLSERVERtudo DEVE funcionar. Mas isso não acontece.

Essa questão realmente se resume a "Por que o MS SQL escolhe uma conta de login de serviço nomeada NT SERVICE\MSSQLSERVERe depois falha em garantir que essa conta seja válida e possa funcionar com SSL, ou tenha um perfil local válido ou qualquer outra coisa que sqlsrvr.exeprecise ser executada? ", e dado que o comportamento padrão do instalador é inadequado mesmo para um DBA ou para a própria estação de trabalho privada do desenvolvedor SQL (um ambiente que não seja de produção), o que se deve fazer?

Baixei e instalei o SQL Server 2016 Community Technology Preview 2.3, que, se bem entendi, deve conter uma função interna chamada JSON_VALUE. (Atualização: o CTP 2.4 foi enviado e nenhuma menção é feita aos novos recursos JSON ainda)

Começando com os recursos JSON que já funcionam, o " ... FOR JSON AUTO" pode ser especificado na minha SELECTdeclaração, assim:

SELECT [ID], [DATA] FROM [dbo].[JSONDEMO] FOR JSON AUTO

O resultado da minha consulta de demonstração acima será um conjunto de resultados com uma coluna, com algum nome gerado automaticamente JSON_F123123123e o valor no formato JSON, algo como:

[{"ID":"IDVALUE", "DATA":"{ {name:'ramsoft', id:1234}, ... }", ... }] 

Até aí tudo bem, mas se DATAcontivesse dados JSON, você receberia um documento JSON contendo um literal de string de dados, mesmo que esse literal de string fosse um JSON válido. O que você provavelmente queria, ou melhor, o que eu queria, é:

 [{"ID":"IDVALUE", "DATA":{ {name:'ramsoft', id:1234}, ... }, ... }] 

De acordo com algumas postagens do MS Blog, para obter o valor JSON como um valor JSON em vez de uma VARCHAR(n)string, você deve escrever:

SELECT [ID], JSON_VALUE(D.DATA,'$') DATA   
FROM [dbo].[JSONDEMO] D FOR JSON AUTO

Isso não funciona, recebo um erro:

'JSON_VALUE' is not a recognized built-in function name.

Algum tipo de extração de valor JSON está disponível no CTP 2.3 ou não existirá até o CTP 3?

Eu tenho uma instância do SQL Server 2012 rodando como um serviço no meu computador, e de acordo com a página do serviço ele faz logon como conta "NT Service\MSSQLSERVER". No entanto, não consigo ver esse nome de conta em nenhum outro lugar, incluindo na área "Usuários e grupos locais" na tela de gerenciamento do computador, porque, como diz o link abaixo, isso não é uma conta de usuário, é um nome de serviço, nessa caixa que A Microsoft tão útil rotulou "conta". Neste ponto, posso ver muitas pessoas confusas.

A tarefa que estou tentando realizar é restaurar arquivos usando a caixa de diálogo "Localizar arquivo de backup" do SSMS, que usa uma caixa de diálogo completamente diferente de qualquer uma das caixas de diálogo padrão de abertura de arquivos do Windows, provavelmente porque está fazendo um trabalho "remoto" e operando a partir do contexto de segurança do servidor SQL, outra fonte rica de confusão do usuário final, que espero que esta pergunta possa ajudar a esclarecer.

Até agora, se eu quiser restaurar um arquivo .mdf/.bak de backup que tenho em uma de minhas pastas, tenho que definir essa pasta como legível por todos ou não consigo entrar lá com o SQL Server "Localizar backup Arquivo" janela. Acho essa ideia de que você está usando uma GUI conversando com um serviço que tem contas de usuário e direitos diferentes de você, que ninguém na Microsoft se importou em deixar claro para você, muito confusa mesmo quando tenho anos de experiência com administração de sistemas windows .

Espero ter perdido algumas páginas de documentação do SQL Server que informam, depois de instalar uma nova instância do SQL Server, como você pode configurar a segurança.

Posts de fórum como este têm até funcionários da Microsoft dizendo "isso é complicado" e que "mudou de novo" no Denali. Como isso funciona agora no SQL Server 2012 e como posso adicionar permissão para ler arquivos pertencentes a usuários ao mecanismo de segurança do banco de dados SQL SID.

Usando o SQL Server Profiler (estou no SQL Server 2012), estou tentando gerar um rastreamento útil que mostre os valores dos parâmetros, não apenas o SQL com nomes de variáveis. O procedimento armazenado percorre uma quantidade bruta de dados de inventário para gerar alguns resultados extremamente valiosos, e estou tentando documentar o comportamento existente, para que eu possa testá-lo, defini-lo exatamente e, em seguida, refatorá-lo em algo sensato.

Eu tenho um procedimento armazenado que executa um subprocedimento de 54 parâmetros, dentro de um loop onde o procedimento armazenado cria um cursor e faz um loop while. Aqui está uma visão simplificada:

CREATE PROCEDURE 
   [dbo].[OuterProcedure]       
   (  @ProductCode varchar(8),          
     -- 41 more parameters omitted
   )
AS            
  SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED   
  SET NOCOUNT ON           
 DECLARE @AboutFourHundredLocalvariables -- omit about 400 local variable declarations.
 -- OMIT ABOUT 10 temporary table declarations.
 DECLARE  aCursor CURSOR FAST_FORWARD FOR         
   SELECT [ID],bkno,  -- about 40 fields omitted.
              FROM vwVeryComplexViewThatDoesALotOfVeryBrutalJoins         
              WHERE  (about_80_boolean_expressions AND omitted_here)
        ORDER BY some,keys,like,this

OPEN aCursor          
FETCH NEXT FROM aCursor /* Get First Record */         
    INTO @ID, @about_40_fields,.... 
WHILE (@@FETCH_STATUS = 0) AND         
          ( @About80MoreBooleanExpressionsHere)  
BEGIN   /* 1 */            
     -- about 700 lines of logic, math and if-parameter-this-then-that
     -- stuff omitted
            EXEC  @ConsiderItem = 
                      InnerProcedureCallWithinLoop
                                            @from_locn,        
                        @About53PARAMSOMITTED,
                                                ...

    FETCH NEXT FROM CurInventory /* Get Next Record */       
       INTO @ID,@MoreStuff,...    
END                   
CLOSE CurInventory          
DEALLOCATE CurInventory        

Como eu obteria um rastreamento para me mostrar todos os valores de parâmetro passados InnerProcedureCallWithinLoop? Existem 54 parâmetros. Tenho que escrever essencialmente "54 linhas de debug-printfs" dentro do meu SQL ou posso despejar todos os valores de parâmetro de uma chamada de procedimento enquanto faço um rastreamento SQL de alguma forma?

Quando recebo um rastreamento agora, recebo esta saída:

EXEC  @ConsiderItem = InnerProcedureCallWithinLoop  @from_locn,        
                        @About53ParmsOmitted

O que eu gostaria de saber é que @from_locn = 1e @About53ParmsOmitted = 'hello world'assim por diante.

Isso não me diz o valor real do parâmetro @from_locn. No caso desse primeiro parâmetro, ele é passado para meu procedimento armazenado de nível superior, então sei que é 0 ou 1, conforme o caso. No entanto, cerca de 40 dos 43 parâmetros nesse procedimento interno vêm da FETCH NEXT FROM aCursoroperação dentro de um WHILEloop.

No momento, o rastreamento me diz quantas vezes InnerProcedureCallWithinLoopé chamado e quanto tempo cada um levou, mas não quais eram os valores dos parâmetros para essa chamada. Se eu pudesse, de alguma forma, obter "scripts SQL autônomos executáveis" que replicam alguns casos de canto que encontro em meu código, enquanto rastreio esses scripts, configurando essas funções grosseiras (eu sei, 54 parâmetros, isso é realmente grosseiro, mas não escrevi eles!) poderia me levar uma hora digitando apenas para criar um script SQL que me permite invocar esse caso de canto sozinho, fora desse grande emaranhado gigantesco de procedimentos armazenados do SQL Server.

Tudo isso faz parte de um esforço para detalhar uma expressão SQL e criar scripts que possam sondar esses procedimentos armazenados complexos.

Atualização Encontrei uma opção de gravação RPC "Output Param", mas não uma opção de gravação "RPC IN PARAM".

Eu tenho um procedimento armazenado que leva cerca de 3 a 5 segundos que estou tentando entender, então quero um plano de execução para ele. Quando eu o executo no SQL Server Management Studio com o Plano de Execução ativado, leva mais de 15 minutos e, em seguida, recebo uma guia que diz "Plano de Execução", mas a guia está vazia. Qualquer outra tentativa de executar qualquer SQL (mesmo select * from foo) não funcionará mais. Eu tenho um aplicativo de estúdio de gerenciamento do servidor SQL quebrado, devo desligá-lo e tentar novamente. Eu fiz isso três vezes e perdi 45 minutos, e agora estou pronto para aprender sobre algumas alternativas.

Primeiro, existe uma maneira confiável de linha de comando para gerar um SQLPLANarquivo para um script sql específico, talvez a partir da linha de comando, e então eu poderia investigar o uso de alguma outra ferramenta além do SSMS para gerar meus planos.

Em segundo lugar, se não houver uma maneira de linha de comando confiável integrada para gerar e armazenar um plano de execução SQL como texto ou XML, gostaria de saber se existem outras ferramentas de terceiros que fariam um bom trabalho em SQLPlans muito grandes, em particular não engasgando e morrendo quando as partes de desenho da GUI ficam sobrecarregadas.

O que você faz quando o SSMS não gera e mostra um plano de execução? Estou usando o SQL 2008 R2 Standard e sua versão SSMS incluída e não tenho nenhum plug-in extra.

Atualização Estou invocando um procedimento armazenado que cria um cursor, que faz subconsultas e faz muito mal, em um loop, gerando mais de 10 mil instruções de subconsultas individuais. Parece que eu realmente preciso refatorar isso para gerar menos uma tempestade de saída.

Update2 Realmente se parece com o rastreamento do lado do servidor (para zerar as áreas problemáticas) e, em seguida, um retorno à criação de perfil e, em seguida, um retorno aos planos de consulta pode ser necessário. Estou ampliando muito o zoom em uma imagem grande e preciso diminuir um pouco o zoom.

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?

Minha pergunta inicial era : como alguém determina se é uma boa ideia indexar uma exibição? .

Atualização: Minha suposição subjacente era que as exibições de indexação as aceleram. Aparentemente, isso não é sensato, pois as visualizações apenas executam consultas, como apontam os comentários abaixo.

O que estou fazendo agora é muito semelhante ao que esse cara está fazendo: estou encontrando exibições que selecionam cerca de 2 mil linhas de 2 milhões de linhas, demoram muito para buscar linhas e pensei que um limite de esquema exibição indexada pode ajudar.

A operação que eu estava tentando otimizar é:

select * from vwSample where TYPE_CODE = 'X';

TYPE_CODETYPE_CODEé uma string de 10 caracteres, há cerca de 2 mil valores exclusivos em vwSample, e cerca de 2 a 5 milhões de linhas em vwSample, e há entre 2 mil e 10 mil linhas para cada valor exclusivo de TYPE_CODE. Não postei meu plano de execução porque estava tentando fazer uma pergunta de "prática geral".

Atualização: parece que minha pergunta está errada, devo apenas escrever e otimizar as consultas e ignorar o fato de que há uma exibição, talvez até mesmo escrevê-la como uma consulta regular e ignorar essa exibição. E não há "botões turbo" disponíveis nas visualizações, que possam tornar minha visualização mais rápida, por mágica, como sugere a resposta aceita. Minha pergunta parece se resumir a "Sou um SQL Server n00be não sei nada sobre como otimizar exibições, como faço para acelerar select * from vwSomething where KEY=Xonde vwSomethingestá uma exibição?".

Espero que esta seja uma pergunta com uma resposta mais curta do que "Leia um livro de 1000 páginas", mas, se essa for a situação real, então me bata com ela.

Não sou um DBA de verdade, sou um desenvolvedor de software que está percebendo que precisamos de um DBA e, no entanto, a loja em que trabalho não tem DBAs. No entanto, nosso design de banco de dados MS SQL, incluindo vários procedimentos armazenados principais, é uma bagunça gigante. Os procedimentos armazenados são lentos, suspeitamos que eles tenham bugs, mas nem sabemos como eles devem funcionar, então não sabemos como corrigi-los.

Para começar, decidi que documentaremos como tudo deve funcionar, depois iniciaremos o teste de unidade e criaremos um conjunto de testes de unidade que ajudam a provar que os procedimentos armazenados realmente funcionam. A lógica que eles executam é uma parte fundamental de nosso aplicativo, pode-se dizer, são as "jóias da coroa" do principal produto de nossa empresa, e o modo como ele funciona é completamente não documentado.

Estou procurando a documentação técnica específica que um DBA profissional pode esperar que exista, ou que possa escrever a si mesmo, se necessário, para entender uma rede gigante de procedimentos armazenados que chamam uns aos outros.

1. Qual é o formato usual para documentar um grande procedimento armazenado? Descrição dos valores esperados para cada parâmetro In (ou seja, "pré-condições", "pós-condições", ou seja, para parâmetros booleanos, o que muda quando você liga ou desliga, etc?)

2. Como alguém costuma documentá-lo? Somente comentários SQL? Ferramentas externas que são específicas para o propósito? "Documentação" externa? Não temos ferramentas SQL, além do MS SQL Management studio, mas estamos nos perguntando se existe uma ferramenta que torne melhor a compreensão, a documentação e o teste de nosso ambiente. Talvez seja uma maneira melhor de fazer minha pergunta; Que ferramenta eu preciso para resolver nossa bagunça?

Nosso objetivo é ser capaz de:

R. Use a documentação que geramos, ou quaisquer ferramentas que adicionamos ao nosso ambiente, para ajudar a entender como os procedimentos devem funcionar, para que possamos criar cobertura de teste de unidade para os procedimentos armazenados.

B. Mostre aos desenvolvedores de aplicativos cliente como chamar corretamente cada um desses procedimentos armazenados complexos.

C. Teste de unidade nossos procedimentos armazenados.