Matthew Verstraete's questions

Estou executando um script de reconstrução de índice:

DECLARE @TableName varchar(255)

DECLARE TableCursor CURSOR FOR
SELECT table_name FROM information_schema.tables
WHERE table_type = 'base table'

OPEN TableCursor
FETCH NEXT FROM TableCursor INTO @TableName
WHILE @@FETCH_STATUS = 0

BEGIN

    DBCC DBREINDEX(@TableName,' ',90)

    FETCH NEXT FROM TableCursor INTO @TableName

END

CLOSE TableCursor;
DEALLOCATE TableCursor;

mas falha com o erro "Mensagem 2501, Nível 16, Estado 45, Linha 13 Não é possível localizar uma tabela ou objeto com o nome "ServiceDeploymentsTable". Verifique o catálogo do sistema."

O script é de https://gallery.technet.microsoft.com/scriptcenter/Script-for-rebuilding-all-8d079754

Tenho a sensação de que a tabela pode pertencer a um objeto diferente (como dbo ou outra coisa), mas não sei como confirmar isso ou modificar o script para lidar com isso. Ou talvez eu esteja completamente fora da base.

Como posso lidar melhor com esse erro e reconstruir todos os índices no banco de dados?

Fiz um backup de nosso banco de dados de produção e o restaurei para os ambientes de teste e desenvolvimento ontem à noite, mas esta manhã um único usuário não conseguiu fazer login nos bancos de dados de teste/desenvolvimento. Posso entrar no SSMS e conectar-me ao SQL Server com o usuário, mas quando tento conectar-me aos bancos de dados específicos, recebo um erro de falha de login 4064. As credenciais devem estar corretas, pois posso me virar e fazer login na produção e executar consultas sem problemas. Comparei os dois conjuntos de permissões e não vi nenhuma diferença entre prod e dev/test. Ambos têm permissão de "conectar" ao esquema do banco de dados e fazem parte dos grupos "db_reader" e "db_executor". O que posso estar procurando no sistema de teste/desenvolvimento que está impedindo esse usuário de se conectar ao banco de dados?

Eu tenho uma função nomeada db_executore preciso descobrir quais permissões ela possui em quais objetos. Encontrei Listar todas as permissões para uma determinada função? mas a única solução que funciona remotamente é:

SELECT DB_NAME() AS 'DBName'
      ,p.[name] AS 'PrincipalName'
      ,p.[type_desc] AS 'PrincipalType'
      ,p2.[name] AS 'GrantedBy'
      ,dbp.[permission_name]
      ,dbp.[state_desc]
      ,so.[Name] AS 'ObjectName'
      ,so.[type_desc] AS 'ObjectType'
  FROM [sys].[database_permissions] dbp LEFT JOIN [sys].[objects] so
    ON dbp.[major_id] = so.[object_id] LEFT JOIN [sys].[database_principals] p
    ON dbp.[grantee_principal_id] = p.[principal_id] LEFT JOIN [sys].[database_principals] p2
    ON dbp.[grantor_principal_id] = p2.[principal_id]

WHERE p.[name] = 'db_executor'

O problema é que o ObjectNamee ObjectTypeé NULL. Portanto, embora eu saiba que ele só tem EXECUTEpermissão em um estado de GRANTnão sei a que objeto (s) isso se aplica. Existe uma maneira melhor de obter essa lista ou como posso modificar esse código para listar o (s) objeto (s)?

Ao tentar descobrir as permissões exatas que preciso dar a um usuário para executar todos os procedimentos armazenados, corri várias páginas dizendo para criar uma função de "db_executer" e dar GRANT EXECUTEpermissão a essa função e, em seguida, atribuir usuários a essa função. Quando fui ao meu servidor para fazer essa função, descobri que ela já existe. Desde que herdei este servidor, não tenho certeza se foi feito pelo último administrador, um programa ou se está embutido. Pesquisando no Google, não estou encontrando nenhum acesso relevante mais recente que 2010 e todos falam sobre como fazer a função. Alguém pode me dizer se esta é uma função padrão em 2012 ou se alguém/coisa a fez?

Recebi a tarefa de mover relatórios do SSRS para nosso aplicativo ASP.Net interno e isso me envolveu reescrever algumas funções e um procedimento armazenado para melhorar o desempenho, torná-los saída em formulários melhor consumidos pelo aplicativo e tornar quaisquer adições solicitadas aos relatórios.

O que eu também preciso fazer é remover as funções e procedimentos antigos do sistema à medida que vou, antes de fazer isso, embora eu queira ter certeza de que não quebrará mais nada. Existe uma maneira que eu possa passar por todas as precedências e funções para ver se alguma delas contém referências às que estarei removendo?

Existem milhares deles para ir embora e eu preferiria não ter que abrir cada um de cada vez no SSMS para olhar. Então, se houver alguma tabela que eu possa consultar ou mesmo se houver um arquivo .sql que o SQL Server está escondendo que eu possa cavar, isso seria ótimo.

Eu quero fazer uma alteração de permissão para alguém no nível superior do SQL Server Reporting Service e fazer com que ela seja transferida para cada pasta e relatório, isso é automático se essa pasta/relatório estiver definido para herdar, mas se estiver definido para substituir, será não. Temos centenas de relatórios para os quais esta 1 permissão deve ser alterada e não quero reverter as permissões do cliente nos relatórios. Como posso enviar essa alteração de permissão para todas as pastas e relatórios?

Eu preciso reconstruir os índices em dois bancos de dados muito grandes (quase 750 tabelas), mas quero impedir que os usuários acessem o banco de dados enquanto isso acontece. Existe um estado em que posso colocar o banco de dados que impeça que os usuários o acessem, mas ainda permita que eu reconstrua os índices? Para referência, planejo o script fornecido em http://instadba.com/quick-script-to-defragment-your-sql-server-indexes/ para fazer a reconstrução.

Eu estava olhando para um procedimento armazenado antigo hoje e notei que estava usando quotenameos parâmetros de entrada. Depois de fazer algumas pesquisas para descobrir o que isso faz exatamente, me deparei com este site . Agora entendo o que ele faz e como usá-lo, mas o site diz que é usado como uma mitigação de ataques de SQL Injection. Quando eu costumava desenvolver aplicativos que consultavam diretamente um banco de dados, usando asp.net, eu usava os parâmetros ADO.Net para passar a entrada do usuário como um valor literal e nunca me preocupava em protegê-lo em meus procedimentos armazenados.

Agora estou escrevendo um procedimento armazenado que será usado por aplicativos que não escrevo, então preciso tentar me proteger de ataques de injeção no nível do procedimento, é quotenamea melhor maneira de fazer isso ou existe uma função mais nova/melhor método?

Código que me levou a esse padrão de pensamento ( @parm1é um parâmetro de entrada do usuário):

'SELECT project [Project], project_desc [Description], 
        customer [Customer], cpnyid [Company]
FROM PJPROJ (nolock)
where project like ' + quotename(@parm1,'''') + '

Eu fiz algumas pesquisas sobre o que a OPTION (FAST XXX)dica de consulta faz dentro de uma SELECTinstrução e ainda estou confuso sobre isso. De acordo com o MSDN:

Especifica que a consulta é otimizada para recuperação rápida das primeiras number_rows. Este é um número inteiro não negativo. Depois que as primeiras number_rows são retornadas, a consulta continua a execução e produz seu conjunto de resultados completo.

Para mim isso não faz muito sentido, mas basicamente a consulta pode obter as primeiras linhas XXX muito rápido e o restante na velocidade normal?

A consulta do Microsoft Dynamics que me fez pensar nisso é:

select pjproj.project,pjproj.project_desc,pjproj.customer,pjproj.cpnyid
from pjproj WITH (NOLOCK)
where project like  '%'
order by project OPTION(FAST 500)

Alguém pode explicar exatamente o que essa dica de consulta está fazendo e sua vantagem sobre não usá-la?

Estou tentando executar um script que faz algum trabalho, incluindo remover os dois caracteres iniciais da string dentro de cada linha de uma coluna. Para fazer isso, estou usando RIGHT()e funciona bem quando uso em um, SELECT..FROMmas quando uso esse mesmo código dentro de um UPDATE, ele falha com

Parâmetro de comprimento inválido passado para a função DIREITA

por que está falhando no, UPDATEmas não no SELECT...FROM?

USE JobSight;

DROP TABLE #ReleaseTemp;


SELECT  A.MajRelease,  
        A.MinRelease,
        A.Build,
        Split.a.value('.', 'VARCHAR(MAX)') AS ReleaseNotes
INTO #ReleaseTemp
FROM  
        (
            SELECT  MajRelease,
                    MinRelease,
                    Build,  
                    CAST ('<M>' + REPLACE(RelNotes, ';;', '</M><M>') + '</M>' AS XML) AS ReleaseNotes
            FROM JobsDB.dbo.ReleaseData
        ) AS A 
    CROSS APPLY ReleaseNotes.nodes ('/M') AS Split(a);

UPDATE #ReleaseTemp
SET ReleaseNotes = RIGHT(ReleaseNotes, LEN(ReleaseNotes) - 2);

UPDATE #ReleaseTemp
SET ReleaseNotes = LTRIM(#ReleaseTemp.ReleaseNotes);

SELECT  MajRelease,
        MinRelease,
        Build,
        RIGHT(ReleaseNotes, LEN(ReleaseNotes) - 2) AS ReleaseNots
FROM #ReleaseTemp
WHERE #ReleaseTemp.ReleaseNotes <> '';

Eu tenho duas colunas em minha tabela, uma varchar(8)intitulada Trans_Timeque contém dados em um XX:XX:XXformato de hora e uma DateTimecoluna chamada Trand_Dateque contém apenas um componente de data no XX-XX-XXXXformato.

Estou tentando combinar as duas colunas para obter uma data e hora completas (ou seja, se Trans_Timefor 08:10:14e Trand_Datefor 04-04-2007, a saída deve ser 04-04-2007 08:10:14).

Meu problema é que algumas vezes o Trans_Timeé nulo e isso produz uma saída nula.

Existe alguma maneira de tratar null como 00:00:00?

Estou migrando dados de um sistema antigo para um novo sistema que estou construindo e descobri que alguém está fazendo uma prática ruim de adicionar um ponto ao início dos nomes de algumas pessoas para fazê-los aparecer primeiro em algumas listas suspensas. Estou tentando descobrir como posso remover esses pontos quando eles são o primeiro caractere da coluna sem remover pontos posteriores no nome (como para iniciais do meio). Esta mudança está sendo feita durante e INSERT INTO SELECTcomando.

Eu tenho um procedimento que leva, entre outras coisas, parâmetros de data inicial e final. Esses dois parâmetros são entradas opcionais e o padrão é NULL. O que eu gostaria de fazer é modificar uma das SELECTdeclarações atuais para que, se as datas de início e término forem fornecidas, ela retorne apenas os resultados entre essas duas datas. Eu considerei apenas jogar um CASE WHEN...na WHEREdeclaração, mas isso é confuso e não parece certo. Essa é a maneira apropriada de lidar com isso ou há algo mais eficiente?

SELECTCláusula existente :

SELECT  do.OrdrNmbr AS 'Order Number',
        mb.BOLNmbr AS 'BOL Number',
        do.DlvryDt  AS 'Deliver Date',
        mh.Text3 AS 'Truck',
        do.DlvrdQntty AS 'Gallons Delivered',
        ba.BANme AS 'Carier Business Associate'
FROM dbo.DeliveryOrder AS do WITH (NOLOCK)
INNER JOIN dbo.ManifestBOL AS mb WITH (NOLOCK)
    ON do.OrdrNmbr = mb.OrdrNmbr
INNER JOIN dbo.BusinessAssociate AS ba WITH (NOLOCK)
    ON do.CrrrBAID = ba.BAID
INNER JOIN SRA.dbo.MovementDocument as md WITH (NOLOCK)
    ON md.MvtDcmntExtrnlDcmntNbr = 'DOD' + CONVERT(VARCHAR, mb.OrdrNmbr)
INNER JOIN SRA.dbo.MovementHeader AS mh WITH (NOLOCK)
   ON mh.MvtHdrMvtDcmntID = md.MvtDcmntID
WHERE mb.OrdrNmbr = @OrderNumber;

e as datas de início/término seriam executadas em do.DlvryDt.

PS Eu sei que os nomes das tabelas/colunas são horríveis, mas este é um aplicativo de terceiros no qual a consulta está sendo executada.

Recebi uma instrução SELECT que está sendo executada em um Crystal Report para investigar um problema de dados, mas quando tento executá-lo no banco de dados, recebo o erro:

ORA-01861: literal não corresponde à string de formato 01861. 00000 - "literal não corresponde à string de formato" *Causa: Os literais na entrada devem ter o mesmo comprimento que os literais na string de formato (com exceção do espaço em branco inicial). Se o modificador "FX" foi ativado, o literal deve corresponder exatamente, sem espaço em branco extra. *Ação: Corrija a string de formato para corresponder ao literal.

Eu acho que tem a ver com as comparações de datas, mas não tenho certeza do que está errado. Eu não sei nada sobre oracle e, como a mensagem de erro não especifica a linha em que o erro está, estou apenas supondo qual pode ser o problema. Alguém pode me indicar o que está causando esse problema?

   SELECT ACTDET.GROSS_VOLUME, 
          ACTDET.NET_VOLUME,
          ACTIVITY.SHIPPER_ID,
          ACTIVITY.ACTIVITY_START_DATE,
          SHIPPER.NAME_1,
          TANK.TANK_PRODUCT_CODE,
          PRODUCT.DESCRIPTION_2,
          SITE.NAME_1,
          SITE.NAME_2
   FROM   G3USER.ACTIVITY ACTIVITY,
          G3USER.ACTDET ACTDET,
          G3USER.SHIPPER SHIPPER,
          G3USER.TANK TANK,
          G3USER.SITE SITE,
          G3USER.PRODUCT PRODUCT
   WHERE ((ACTIVITY.TERMINAL_ID=ACTDET.TERMINAL_ID) AND (ACTIVITY.BOL_NUMBER=ACTDET.BOL_NUMBER))
   AND ((ACTIVITY.TERMINAL_ID=SHIPPER.TERMINAL_ID) AND (ACTIVITY.SHIPPER_ID=SHIPPER.SHIPPER_ID))
   AND ((ACTDET.TERMINAL_ID=TANK.TERMINAL_ID) AND (ACTDET.TANK_ID=TANK.TANK_ID))
   AND (ACTDET.TERMINAL_ID=SITE.TERMINAL_ID)
   AND ((TANK.TERMINAL_ID=PRODUCT.TERMINAL_ID AND (TANK.TANK_PRODUCT_CODE=PRODUCT.PRODUCT_CODE))
   AND (ACTIVITY.ACTIVITY_START_DATE >= '2014-02-05 00:00:00') AND (ACTIVITY.ACTIVITY_START_DATE < '2014-02-06 00:00:00'));

Estou projetando um novo banco de dados SQL para meu aplicativo da Web ASP.net e posso prever que algumas das colunas de ID ficarão muito grandes na necessidade de recursos INT, BIGINTmas isso não acontecerá por alguns anos. Com o Entity Framework no ASP.net, é bastante fácil alterar os tipos de dados da coluna. Então, eu queria saber, do ponto de vista do design e do ponto de desempenho, é melhor começar usando os tipos de colunas menores, como TINYINTe SMALLINTe crescer, INTe BIGINTquando finalmente chegar a hora?

Pela leitura na net, parece que o uso de cursores é desaprovado, mas ninguém parecia dar uma alternativa a eles. No meu caso, preciso definir linha por linha os resultados de uma instrução select e passar algumas colunas de cada linha para outro procedimento armazenado para processamento. A única maneira que vejo de fazer isso é criar um cursor e executar um loop while para usar o cursor para pegar cada linha para que os dados possam ser processados. Então, usar um cursor para percorrer cada linha de uma instrução select para processamento é a melhor maneira de fazer isso ou existe outra maneira? No meu caso, tenho que garantir que cada linha seja processada.

Sei que é uma boa prática e um aumento de desempenho no SQL Server prefixar o nome da tabela com o esquema ( dbo.TableName) na FROMcláusula de uma SELECTinstrução, mas você também deve usá-lo em outras cláusulas como o WHEREou ON? Você também deve especificar o TABLEnome columnsna cláusula where se o nome da coluna for exclusivo?

Considere dois cenários:

SELECT Col1, Col2, Col3
FROM dbo.Table
WHERE Col1 = Value;

e

SELECT Col1, Col2, Col3,
FROM dbo.Table
INNER JOIN dbo.Table2
ON Col1 = Col5
WHERE Col6 = Value;

No primeiro cenário, devo adicionar dbo.Tablea cada nome de coluna?

No segundo cenário, se eu adicionasse um alias a cada tabela, isso incluiria automaticamente os dados do esquema também ou ainda precisaria pré-fixar os nomes das colunas com o esquema.

E em ambos os cenários eu PRECISO prefixar as colunas com dados de esquema ou isso é inútil e não aumenta o desempenho?