Acho que estou trabalhando com a versão mais recente do Sqlite e C++. Tenho uma tabela com dados, e preciso retornar esses dados na ordem que os inseri.
Tenho alguma garantia de que as colunas sempre serão devolvidas nesta ordem?
Talvez eu deva adicionar outra coluna para definir a ordem e usar ORDER BY:
Estou usando o SQL Server 13.0.5102.14.
Eu tenho essas três tabelas:
CREATE TABLE [dbo].[ProductionOrder]
(
[ProductionOrderId] INT NOT NULL IDENTITY (1, 1),
[ProductId] INT NOT NULL,
[Name] NVARCHAR(50) NOT NULL,
CONSTRAINT [PK_ProductionOrder] PRIMARY KEY CLUSTERED
(
[ProductionOrderId] ASC
))
)
CREATE TABLE [dbo].[Code]
(
[CodeId] int NOT NULL IDENTITY(1, 1),
[Serial] [varchar](38) not null,
[ProductionOrderId] int NOT NULL,
[AggregationLevel] [tinyint] NOT NULL,
CONSTRAINT [PK_Code] PRIMARY KEY CLUSTERED
(
[CodeId] ASC
),
CONSTRAINT [UC_Code_Serial] UNIQUE ([Serial]),
CONSTRAINT [FK_Code_ProductionOrder_ProductionOrderId] FOREIGN KEY ([ProductionOrderId]) REFERENCES [dbo].[ProductionOrder] ([ProductionOrderId]))
)
CREATE TABLE [dbo].[VariableData]
(
[ProductionOrderId] INT NOT NULL,
[AggregationLevelConfigurationId] TINYINT NOT NULL,
[VariableDataId] VARCHAR(4) NOT NULL,
[Value] NVARCHAR(200) NOT NULL,
CONSTRAINT [PK_VariableData] PRIMARY KEY CLUSTERED
(
[AggregationLevelConfigurationId] ASC,
[ProductionOrderId] ASC,
[VariableDataId] ASC
),
CONSTRAINT [FK_VariableData_AggregationLevelConfiguration_AggregationLevelConfigurationId] FOREIGN KEY ([AggregationLevelConfigurationId], [ProductionOrderId]) REFERENCES [dbo].[AggregationLevelConfiguration] ([AggregationLevelConfigurationId], [ProductionOrderId]) ON DELETE CASCADE,
CONSTRAINT [FK_VariableData_ProductionOrder_ProductionOrderId] FOREIGN KEY ([ProductionOrderId]) REFERENCES [dbo].[ProductionOrder] ([ProductionOrderId]),
CONSTRAINT [CK_VariableData_VariableDataId] CHECK (([VariableDataId]<>N''))
)
CREATE TABLE [dbo].[Product]
(
[ProductId] INT NOT NULL IDENTITY (1, 1),
[ProductCode] VARCHAR(14) not null,
[Description] NVARCHAR(50) NULL,
[LawId] TINYINT NOT NULL,
[Name] NVARCHAR(100) NOT NULL,
[Comment] NVARCHAR(100) NULL,
CONSTRAINT [PK_Product] PRIMARY KEY CLUSTERED
(
[ProductId] ASC
),
CONSTRAINT [CK_Product_ProductCode] CHECK (([ProductCode]<>N'')),
CONSTRAINT [CK_Product_Name] CHECK (([Name]<>N''))
)
CREATE TABLE [dbo].[AggregationChildren]
(
[AggregationChildrenId] INT NOT NULL,
[AggregationId] INT NOT NULL,
[Position] [int] NOT NULL,
CONSTRAINT [PK_AggregationChildren] PRIMARY KEY CLUSTERED
(
[AggregationChildrenId] ASC
),
CONSTRAINT [FK_AggregationChildren_Aggregation_AggregationId] FOREIGN KEY ([AggregationId]) REFERENCES [Aggregation]([AggregationId]) ON DELETE CASCADE,
CONSTRAINT [FK_AggregationChildren_Code_AggregationChildrenId] FOREIGN KEY ([AggregationChildrenId]) REFERENCES [Code]([CodeId])
)
CREATE TABLE [dbo].[Aggregation]
(
[AggregationId] INT NOT NULL,
[Created] varchar(34) NULL,
CONSTRAINT [PK_Aggregation] PRIMARY KEY CLUSTERED
(
[AggregationId] ASC
),
CONSTRAINT [FK_Aggregation_Code_AggregationId] FOREIGN KEY ([AggregationId]) REFERENCES [dbo].[Code] ([CodeId])
)
Eu tenho essas três consultas de trabalho :
declare @prodID int = 1;
declare @lotAI varchar(4) = '10';
select cod.Serial as ItemNO
, varData.Value as Lot
, pro.ProductCode as Product
from dbo.VariableData varData
JOIN dbo.Code cod ON varData.ProductionOrderId = cod.ProductionOrderId
JOIN dbo.ProductionOrder proOrd ON varData.ProductionOrderId = proOrd.ProductionOrderId
JOIN dbo.Product pro on proOrd.ProductId = pro.ProductId
where varData.ProductionOrderId = @prodID and
varData.VariableDataId = @lotAI and
varData.AggregationLevelConfigurationId = 1 and
cod.AggregationLevel = 1
select cod.Serial as Box
from dbo.Code cod
LEFT JOIN dbo.AggregationChildren agg on agg.AggregationId = cod.CodeId
where cod.ProductionOrderId = @prodID and
cod.AggregationLevel = 2
select cod.Serial as Pallet
from dbo.Code cod
JOIN dbo.Aggregation agg on agg.AggregationId = cod.CodeId
where cod.ProductionOrderId = @prodID and
cod.AggregationLevel = 3
Eu quero juntar todos eles em uma consulta. Meu problema para fazer isso é que estou usando dbo.Codepara obter três valores diferentes:
select cod.Serial as ItemNOselect cod.Serial as Boxselect cod.Serial as PalletComo posso juntar essas três consultas em uma?
Estou desenvolvendo um procedimento armazenado do SQL Server 2016 e quero obter os últimos caracteres de uma varchar(38)coluna.
Eu sei que sempre haverá pelo menos 18 caracteres e não sei o comprimento exato da coluna, porque é variável.
Acho que posso obter o comprimento da coluna e fazer uma subtração para usar SUBSTRING, mas não posso fazer isso porque estou fazendo isso:
set @externalCodes = (
select Serial, AggregationLevel
from ExternalCode where ProductionOrderId = @productionOrderId
for json path
Estou gerando um JSON e não sei como pegar o comprimento de cada Serialcoluna dentro de um select.
Minha pergunta é: como posso obter uma substring de uma string sem os primeiros 18 caracteres sem saber seu comprimento?
Uma solução poderia ser:
SUBSTRING(Serial, 18, 38)
E sempre retorna a substring de 18 até o final da string, mesmo que a string não tenha um comprimento de 38.
Continuando com a pergunta Obtenha todas as linhas envolvidas entre as relações de tabelas , agora tenho que excluir todas as linhas desses códigos. Explico:
tenho um SQL Server 2016 com as seguintes tabelas:
CREATE TABLE [dbo].[Code] (
[CodeId] INT IDENTITY (1, 1) NOT NULL,
[Serial] VARCHAR(20) NOT NULL,
[AggregationLevelId] TINYINT NOT NULL,
[CommissioningFlag] TINYINT NOT NULL,
[ ... ]
CONSTRAINT [PK_CODE] PRIMARY KEY CLUSTERED ([CodeId] ASC),
CONSTRAINT [UC_CODE_SERIAL] UNIQUE NONCLUSTERED ([Serial] ASC),
CONSTRAINT [FK_Code_AggregationLevelConfiguration]
FOREIGN KEY ([AggregationLevelId])
REFERENCES [dbo].[AggregationLevelConfiguration] ([AggregationLevelConfigurationId])
)
CREATE TABLE [dbo].[Aggregation] (
[AggregationId] INT NOT NULL,
CONSTRAINT [PK_AGGREGATIONS] PRIMARY KEY CLUSTERED ([AggregationId] ASC),
CONSTRAINT [FK_Aggregation_Code]
FOREIGN KEY ([AggregationId])
REFERENCES [dbo].[Code] ([CodeId])
)
CREATE TABLE [dbo].[AggregationChildren] (
[AggregationChildrenId] INT NOT NULL,
[AggregationId] INT NOT NULL,
[Position] INT NOT NULL,
CONSTRAINT [PK_AGGREGATION_CHILDS] PRIMARY KEY CLUSTERED ([AggregationChildrenId] ASC),
CONSTRAINT [FK_AggregationChildren_Code]
FOREIGN KEY ([AggregationChildrenId])
REFERENCES [dbo].[Code] ([CodeId]),
CONSTRAINT [FK_AggregationChildren_Aggregation]
FOREIGN KEY ([AggregationId])
REFERENCES [dbo].[Aggregation] ([AggregationId]) ON DELETE CASCADE
)
Aggregatione AggregationChildrenrepresentam as relações entre as linhas na tabela Code.
Uma agregação terá 1 ou mais filhos de agregação. E também, um código em filhos de agregação pode ter 0 ou mais filhos de agregação.
É algo assim:
Code1
|___________________
| |
Code2 Code3
|________ |________________
| | | | |
Code4 Code5 Code6 Code7 Code8
Todos os itens acima são Code.Serialvalores.
Todos os Code.CodeIdvalores para esses seriais estão na Aggregationtabela para Code1, Code2e Code3.
E, para esses seriados, Code2, Code3, Code4, Code5, Code6, Code7, e Code8estão na AggregationChildrentabela.
Eu preciso excluir as linhas desses seriais Aggregatione AggregationChildrentabelas.
Usando a resposta da pergunta anterior, tentei fazer isso:
DECLARE @Serial VARCHAR(20) = 'Code1';
;WITH rc AS
(
SELECT AggregationId Id
FROM dbo.Aggregation
WHERE AggregationId = (SELECT CodeId FROM dbo.Code WHERE Serial = @Serial)
UNION ALL
SELECT ac.AggregationChildrenId Id
FROM dbo.AggregationChildren ac
JOIN rc
ON ac.AggregationId = rc.Id
)
UPDATE c
SET CommissioningFlag = 130
FROM dbo.Code c
JOIN rc
ON c.CodeId = rc.Id;
GO
Delete ag from dbo.Aggregation ag
inner join rc
on ag.AggregationId = rc.Id;
Mas eu não sei como usar o DELETE FROMcom a rcdeclaração. Mas acho que só preciso dos Codesque estão em Aggregatione AggregationChildren. Talvez eu precise modificar a Withinstrução para obter primeiro as linhas na Aggregationtabela porque tenho uma tabela ON DELETE CASCADEem AggregationChildren.
Como posso obter todos os códigos para excluir da Aggregationtabela?
Tenho um SQL Server 2016 com as seguintes tabelas:
CREATE TABLE [dbo].[Code] (
[CodeId] INT IDENTITY (1, 1) NOT NULL,
[Serial] VARCHAR(20) NOT NULL,
[AggregationLevelId] TINYINT NOT NULL,
[CommissioningFlag] TINYINT NOT NULL,
[ ... ]
CONSTRAINT [PK_CODE] PRIMARY KEY CLUSTERED ([CodeId] ASC),
CONSTRAINT [UC_CODE_SERIAL] UNIQUE NONCLUSTERED ([Serial] ASC),
CONSTRAINT [FK_Code_AggregationLevelConfiguration]
FOREIGN KEY ([AggregationLevelId])
REFERENCES [dbo].[AggregationLevelConfiguration] ([AggregationLevelConfigurationId])
)
CREATE TABLE [dbo].[Aggregation] (
[AggregationId] INT NOT NULL,
CONSTRAINT [PK_AGGREGATIONS] PRIMARY KEY CLUSTERED ([AggregationId] ASC),
CONSTRAINT [FK_Aggregation_Code]
FOREIGN KEY ([AggregationId])
REFERENCES [dbo].[Code] ([CodeId])
)
CREATE TABLE [dbo].[AggregationChildren] (
[AggregationChildrenId] INT NOT NULL,
[AggregationId] INT NOT NULL,
[Position] INT NOT NULL,
CONSTRAINT [PK_AGGREGATION_CHILDS] PRIMARY KEY CLUSTERED ([AggregationChildrenId] ASC),
CONSTRAINT [FK_AggregationChildren_Code]
FOREIGN KEY ([AggregationChildrenId])
REFERENCES [dbo].[Code] ([CodeId]),
CONSTRAINT [FK_AggregationChildren_Aggregation]
FOREIGN KEY ([AggregationId])
REFERENCES [dbo].[Aggregation] ([AggregationId]) ON DELETE CASCADE
)
Aggregatione AggregationChildrenrepresentam as relações entre as linhas na tabela Code.
Uma agregação terá 1 ou mais filhos de agregação. E também, um código em filhos de agregação pode ter 0 ou mais filhos de agregação.
É algo assim:
Code1
|___________________
| |
Code2 Code3
|________ |________________
| | | | |
Code4 Code5 Code6 Code7 Code8
Todos os itens acima são Code.Serialvalores.
Todos os Code.CodeIdvalores para esses seriais estão na Aggregationtabela para Code1, Code2e Code3.
E, para esses seriados, Code2, Code3, Code4, Code5, Code6, Code7, e Code8estão na AggregationChildrentabela.
Eu preciso atualizar Code.CommissioningFlagpara todos esses seriados.
Eu criei um procedimento armazenado para chamado recursivamente. Eu passo Code1como argumento e ele fará uma chamada recursiva para Code2e Code3.
Esse método funciona bem com alguns códigos, mas agora preciso atualizar 3.000 códigos e ele bloqueia o SQL Server.
Eu pensei em navegar, lançar a 'árvore' e obter uma tabela temporária com todos os códigos, e fazer e atualizar para todos eles, mas não sei como 'navegar na árvore' no SQL.
Como posso obter todos os códigos para atualizar todos de uma vez?
Estou trabalhando com o SQL Server 2016 e preciso permitir que um usuário MyDatabaseexecute xp_cmdshell. Eu faço o seguinte:
USE [MyDatabase]
GO
GRANT EXECUTE ON xp_cmdshell TO myUser
GO
myUseré um usuário de MyDatabasee quando executo o código acima, logado como sa, recebo o seguinte erro:
As permissões em exibições de catálogo no escopo do servidor ou procedimentos armazenados do sistema ou procedimentos armazenados estendidos podem ser concedidas somente quando o banco de dados atual for mestre.
Preciso adicionar o usuário ao masterbanco de dados? Não acho seguro.
Eu preciso disso porque quero escrever um arquivo de texto de um procedimento armazenado. Encontrei o seguinte artigo, http://www.nigelrivett.net/WriteTextFile.html , dizendo que posso escrever um arquivo de texto usando:
You will need to create the data to be output as in dynamic sql statements
The first command here creates or overwrites the file - the rest append to the file.
exec master..xp_cmdshell 'echo hello > c:\file.txt'
exec master..xp_cmdshell 'echo appended data >> c:\file.txt'
exec master..xp_cmdshell 'echo more data >> c:\file.txt'
Pergunto isso porque meu procedimento armazenado gerará uma string grande (nvarchar(max)) json e quando tento anotá-la com C# não recebo nada: nem o arquivo nem uma exceção. Eu pensei em escrever a string json dentro do procedimento armazenado (se eu puder).
O procedimento armazenado termina corretamente, verifiquei no depurador que recebo algo no parâmetro de saída json (eu sei porque o Visual Studio define que não há memória suficiente para mostrar seu conteúdo), o File.WriteAllTexté executado porque tenho um ponto de interrupção em isso, e também, o caminho é absoluto. Mas talvez haja algo que eu ignore e eu tenha que verificar tudo novamente.
Acabei de começar a usar OPENJSONcom o SQL Server 2016 SP1.
Eu tenho esta frase:
select c.Serial as Parent,
(Select co.Serial, agc.Position
from AggregationChildren agc, Aggregation ag, Code co
where agc.AggregationId = a.AggregationId
and co.CodeId = agc.AggregationChildrenId for json path) as children
from Aggregation a, Code c
where c.CodeId = a.AggregationId for json path
Para gerar este JSON:
{"Parent":"4244287599479491","Children":
[{"Serial":"8915753733724633","Position":"1"},
{"Serial":"1247782815710855","Position":"2"},
...]}
Mas é muito muito lento.
Meu problema é com o Childrenarray porque não sei como obtê-lo.
Existe uma maneira de fazer isso mais rápido?
Estas são as tabelas:
CREATE TABLE [dbo].[Code] (
[CodeId] INT IDENTITY (1, 1) NOT NULL,
[Serial] NVARCHAR (20) NOT NULL,
[ ... ],
CONSTRAINT [PK_CODE] PRIMARY KEY CLUSTERED ([CodeId] ASC),
[ ... ]
)
CREATE TABLE [dbo].[Aggregation] (
[AggregationId] INT NOT NULL,
[ ... ],
CONSTRAINT [PK_AGGREGATIONS] PRIMARY KEY CLUSTERED ([AggregationId] ASC),
CONSTRAINT [FK_Aggregation_Code]
FOREIGN KEY ([AggregationId])
REFERENCES [dbo].[Code] ([CodeId])
)
CREATE TABLE [dbo].[AggregationChildren] (
[AggregationChildrenId] INT NOT NULL,
[AggregationId] INT NOT NULL,
[Position] INT NOT NULL,
CONSTRAINT [PK_AGGREGATION_CHILDS] PRIMARY KEY CLUSTERED ([AggregationChildrenId] ASC),
CONSTRAINT [FK_AggregationChildren_Code]
FOREIGN KEY ([AggregationChildrenId])
REFERENCES [dbo].[Code] ([CodeId]),
CONSTRAINT [FK_AggregationChildren_Aggregation]
FOREIGN KEY ([AggregationId])
REFERENCES [dbo].[Aggregation] ([AggregationId]) ON DELETE CASCADE
)
A Serialcoluna é uma, nvarchar(20)pois os valores podem ser qualquer combinação de alfanuméricos, embora meu exemplo mostre apenas números.
Estou desenvolvendo um procedimento armazenado para SQL Server 2016.
Eu tenho que fazer isso (a seguinte instrução sql não funciona):
Insert into AggregationChildren (AggregationId, AggregationChildrenId, Position)
SELECT Parent, Serial, Position
FROM
OPENJSON (@json, '$.Aggregations')
WITH ( Parent nvarchar(20) '$.Parent',
Children nvarchar(max) AS JSON )
CROSS APPLY
OPENJSON (Children)
WITH ( Serial nvarchar(20), Position int)
Meu problema é que AggregationIde AggregationChildrenIdsão inteiros e Parente Serialsão nvarchar(20).
Existe uma relação entre Parente AggregationId, e entre Seriale AggregationChildrenId. Eu posso obtê-lo usando a Codetabela.
Eu sei como posso fazer isso quando tenho que inserir valores para uma coluna:
Insert into AggregationChildren (AggregationId)
Select CodeId from Code Where Serial = (SELECT Parent
FROM
OPENJSON (@json, '$.Aggregations')
WITH ( Parent nvarchar(20) '$.Parent',
Children nvarchar(max) AS JSON )
CROSS APPLY
OPENJSON (Children)
WITH ( Serial nvarchar(20), Position int))
Os dados que estou tentando inserir são:
{
...,
"Aggregations": [{
"Parent": "88962730000000004051",
"Children": [{
"Serial": "81861400000000020227",
"Position": "1"
}, {
"Serial": "81861400000000033191",
"Position": "2"
}, {
"Serial": "81861400000000046051",
"Position": "3"
},
...
]
}, {
"Parent": "88962730000000016653",
"Children": [{
"Serial": "81861400000001825849",
"Position": "1"
}, {
"Serial": "81861400000001832643",
"Position": "2"
}, {
"Serial": "81861400000001841911",
"Position": "3"
}, {
"Serial": "81861400000001850803",
"Position": "4"
}, {
"Serial": "81861400000001862474",
"Position": "5"
}, {
"Serial": "81861400000001874774",
"Position": "6"
}, {
"Serial": "81861400000001884159",
"Position": "7"
}, {
"Serial": "81861400000001898352",
"Position": "8"
}, {
"Serial": "81861400000001904764",
"Position": "9"
},
...
]
}]
}
Mas, como posso fazer isso se tiver que usar dois Select CodeId from Code Where Serial = (SELECT ...?
Acho que tenho que fazer algo assim mas sem fazer o mesmo select três vezes:
Insert into AggregationChildren (AggregationId, AggregationChildrenId, Position)
Select CodeId from Code Where Serial = (SELECT Parent
FROM
OPENJSON (@json, '$.Aggregations')
WITH ( Parent nvarchar(20) '$.Parent',
Children nvarchar(max) AS JSON )
CROSS APPLY
OPENJSON (Children)
WITH ( Serial nvarchar(20), Position int)),
Select CodeId from Code Where Serial = (SELECT Serial
FROM
OPENJSON (@json, '$.Aggregations')
WITH ( Parent nvarchar(20) '$.Parent',
Children nvarchar(max) AS JSON )
CROSS APPLY
OPENJSON (Children)
WITH ( Serial nvarchar(20), Position int)),
SELECT Position
FROM
OPENJSON (@json, '$.Aggregations')
WITH ( Parent nvarchar(20) '$.Parent',
Children nvarchar(max) AS JSON )
CROSS APPLY
OPENJSON (Children)
WITH ( Serial nvarchar(20), Position int)
Tenho um banco de dados no SQL Server 2012 SP3 com esta tabela:
CREATE TABLE [dbo].[Code] (
[CodeId] INT IDENTITY (1, 1) NOT NULL,
[Serial] NVARCHAR (20) NOT NULL,
[AggregationLevelId] TINYINT NOT NULL,
[...],
CONSTRAINT [PK_CODE] PRIMARY KEY CLUSTERED ([CodeId] ASC),
CONSTRAINT [UC_CODE_SERIAL] UNIQUE NONCLUSTERED ([Serial] ASC)
)
Usando o Sql Server Management Studio Activity Monitor, vi que a seleção a seguir tem uma duração média de 32 ms.
set @maxCode = (select max(Serial) from Code where AggregationLevelId = @codeLevel);
Existe alguma maneira de melhorá-lo? Eu perguntei isso porque não sei se posso adicionar um novo índice a uma coluna que tenha uma restrição exclusiva.
ATUALIZAR:
Codetabela também tem este índice:
CREATE NONCLUSTERED INDEX [ix255] ON [dbo].[Code]
(
[AggregationLevelId] ASC
)
INCLUDE ( [Serial],
[CodeId])
WHERE ([CommissioningFlag]=(255))
Eu tenho um banco de dados SQL Server com uma frase de atualização executada com muita frequência. Eu vi no Activity Monitor que esta frase de atualização dispara 27ms e quero melhorá-la.
Eu verifiquei o plano de execução e vi que a frase de atualização atualiza os índices da exibição:
a consulta de atualização é esta:
UPDATE Code
SET CommissioningFlag = @newCommFlagValue
, Source = @source
, UserName = @username
, LastChange = CAST(SYSDATETIMEOFFSET() as nvarchar(50))
, SentToNextLevel = 0
, HelperCodeId = @helperCodeId
WHERE CodeId = @codeId
E o script realçado da exibição é:
CREATE VIEW dbo.PrintedCodesStatistics
WITH SCHEMABINDING
AS
SELECT AggregationLevelId, COUNT_BIG(*) as CodesPrinted
FROM dbo.Code
WHERE (CommissioningFlag != 255)
GROUP BY AggregationLevelId
GO
CREATE UNIQUE CLUSTERED INDEX [IX_Printed_Statistics]
ON [dbo].[PrintedCodesStatistics]([AggregationLevelId] ASC);
E, finalmente, Codescript de tabela:
CREATE TABLE [dbo].[Code] (
[CodeId] INT IDENTITY (1, 1) NOT NULL,
[Serial] NVARCHAR (20) NOT NULL,
[AggregationLevelId] TINYINT NOT NULL,
[CommissioningFlag] TINYINT NOT NULL,
[... ]
CONSTRAINT [PK_CODE] PRIMARY KEY CLUSTERED ([CodeId] ASC),
CONSTRAINT [UC_CODE_SERIAL] UNIQUE NONCLUSTERED ([Serial] ASC)
As exibições retardam a consulta de atualização?
Estou otimizando meu banco de dados SQL Server usando o SQL Server Management Studio Activity Monitor.
As duas sentenças SQL mais caras são:
set @codesToPrintCount =
(select count(CodeId)
from Code
where CommissioningFlag = 255
and AggregationLevelId = @codeLevel);
SET @code = (SELECT TOP 1 Serial
FROM Code
WHERE CommissioningFlag = 255
and AggregationLevelId = @codeLevel);
Este é Codeo script sql da tabela:
CREATE TABLE [dbo].[Code] (
[CodeId] INT IDENTITY (1, 1) NOT NULL,
[Serial] NVARCHAR (20) NOT NULL,
[AggregationLevelId] TINYINT NOT NULL,
[CommissioningFlag] TINYINT NOT NULL,
[ ... ]
CONSTRAINT [PK_CODE] PRIMARY KEY CLUSTERED ([CodeId] ASC),
CONSTRAINT [UC_CODE_SERIAL] UNIQUE NONCLUSTERED ([Serial] ASC),
CONSTRAINT [FK_Code_AggregationLevelConfiguration]
FOREIGN KEY ([AggregationLevelId])
REFERENCES [dbo].[AggregationLevelConfiguration] ([AggregationLevelConfigurationId])
)
Não sei como posso acelerar essas frases.
Há mais linhas Codenessa tabela com o mesmo valor na AggregationLevelIdcoluna do que colunas com o valor 255 em CommissioningFlag. Ou seja, na Codetabela existem 1.050.000 linhas com valor AggregationLevelIdigual a @codeLevele 32 linhas ou menos com valor 255 na CommissioningFlagcoluna.
É uma boa ideia adicionar dois índices nesta tabela? Um para CommissioningFlage outro para AggregationLevelId.
Neste momento, existem 1.100.000 linhas na Codetabela e elas levam 23ms e 78ms, respectivamente, para serem executadas.
A propósito, essas duas frases estão em um procedimento armazenado.
Eu tenho um procedimento armazenado do SQL Server 2012 com uma junção interna que leva 7.387ms para executar (vi no Activity Monitor):
[...]
declare @childrenIds as dbo.CodeIdList;
[...]
Update
dbo.Code
set
dbo.Code.CommissioningFlag = 21
From
dbo.Code
INNER JOIN
@childrenIds c
ON
dbo.Code.CodeId = c.CodeId
CodeIdListé:
CREATE TYPE [dbo].[CodeIdList] AS TABLE (
[CodeId] INT NULL
);
Existe uma maneira mais rápida de atualizar a tabela Code do que usar um INNER JOIN?
Não sou dba, então não sei se você precisa de mais detalhes sobre minha pergunta. Se você precisar deles, por favor, pergunte.
Eu executei sp_helpindexna tabela de códigos com estes resultados:
index_name | índice_descrição PK_CODE | chave primária agrupada, exclusiva, localizada em PRIMARY | CodeId UC_CODE_SERIAL | chave exclusiva, não clusterizada e exclusiva localizada em PRIMARY | Serial
Codescript de criação de tabela:
CREATE TABLE [dbo].[Code] (
[CodeId] INT IDENTITY (1, 1) NOT NULL,
[Serial] NVARCHAR (20) NOT NULL,
[ ...]
CONSTRAINT [PK_CODE] PRIMARY KEY CLUSTERED ([CodeId] ASC),
CONSTRAINT [UC_CODE_SERIAL] UNIQUE NONCLUSTERED ([Serial] ASC)
)
Neste momento existem 1.006.896 linhas na tabela Code.
Plano de execução:
Versão XML em http://pastebin.com/9yXsRfva
Informações da versão do SQL Server:
Microsoft SQL Server Management Studio 11.0.6020.0 Herramientas cliente de Microsoft Analysis Services 11.0.6020.0 Microsoft Data Access Components (MDAC) 6.1.7601.17514 MSXML 3.0 4.0 6.0 Microsoft Internet Explorer 9.11.9600.18314 Microsoft .NET Framework 4.0.30319.42000 Sistema operativo 6.1.7601
Select @@VERSION:
Microsoft SQL Server 2012 (SP3) (KB3072779) - 11.0.6020.0 (X64) 20 de outubro de 2015 15:36:27 Copyright (c) Microsoft Corporation Enterprise Edition (64 bits) em Windows NT 6.1 (Compilação 7601: Service Pack 1)
Estou trabalhando com o SQL Server 2012. Quero verificar se existe um usuário antes de adicioná-lo a um banco de dados.
Isto é o que eu testei:
USE [MyDatabase]
GO
IF NOT EXISTS (SELECT name
FROM [sys].[server_principals]
WHERE name = N'IIS APPPOOL\MyWebApi AppPool')
Begin
CREATE USER [IIS APPPOOL\MyWebApi AppPool]
FOR LOGIN [IIS APPPOOL\MyWebApi AppPool] WITH DEFAULT_SCHEMA=[dbo]
end
ALTER ROLE [db_owner] ADD MEMBER [IIS APPPOOL\MyWebApi AppPool]
GO
Mas esse código SELECT name FROM [sys].[server_principals]não retorna se esse usuário existir no MyDatabase.
Como posso verificar se um usuário existe em MyDatabase?
Estou desenvolvendo um banco de dados SQL Server 2012 e tenho uma pergunta sobre um relacionamento um para zero ou um.
Eu tenho duas tabelas, Codese HelperCodes. Um código pode ter zero ou um código auxiliar. Este é o script sql para criar essas duas tabelas e seus relacionamentos:
CREATE TABLE [dbo].[Code]
(
[Id] NVARCHAR(20) NOT NULL,
[Level] TINYINT NOT NULL,
[CommissioningFlag] TINYINT NOT NULL,
[SentToRanger] BIT NOT NULL DEFAULT 0,
[LastChange] NVARCHAR(50) NOT NULL,
[UserName] NVARCHAR(50) NOT NULL,
[Source] NVARCHAR(50) NOT NULL,
[Reason] NVARCHAR(200) NULL,
[HelperCodeId] NVARCHAR(20) NULL,
CONSTRAINT [PK_Code] PRIMARY KEY CLUSTERED
(
[Id] ASC
),
CONSTRAINT [FK_Code_LevelConfiguration]
FOREIGN KEY ([Level])
REFERENCES [dbo].[LevelConfiguration] ([Level]),
CONSTRAINT [FK_Code_HelperCode]
FOREIGN KEY ([HelperCodeId])
REFERENCES [dbo].[HelperCode] ([HelperCodeId])
)
CREATE TABLE [dbo].[HelperCode]
(
[HelperCodeId] NVARCHAR(20) NOT NULL,
[Level] TINYINT NOT NULL,
[CommissioningFlag] TINYINT NOT NULL,
[LastChange] NVARCHAR(50) NOT NULL,
CONSTRAINT [PK_HelperCode] PRIMARY KEY CLUSTERED
(
[HelperCodeId] ASC
),
CONSTRAINT [FK_HelperCode_LevelConfiguration]
FOREIGN KEY ([Level])
REFERENCES [dbo].[LevelConfiguration] ([Level])
)
Isso é correto?
Um Code e um HelperCode são entidades diferentes. Um HelperCode pode ser usado (nenhum código faz referência a ele) ou usado (apenas um código faz referência a ele).
Talvez Code.HelperCodeId deve fazer parte da chave primária da tabela de códigos. Mas não tenho certeza se uma coluna nula pode fazer parte de uma primária. Fazendo isso, quero evitar que dois ou mais Codes façam referência ao mesmo HelperCode.
Executando um procedimento armazenado CLR do SQL Server 2012 com este código:
const string executeLog = "EXEC master..xp_logevent @errorNumber, @message, informational";
using (SqlCommand cmd = new SqlCommand(executeLog, connection))
{
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue("@errorNumber", 60001);
cmd.Parameters.AddWithValue("@message", url);
cmd.ExecuteScalar();
}
Eu recebo este erro:
System.Data.SqlClient.SqlException: A permissão EXECUTE foi negada no objeto 'xp_logevent', banco de dados 'mssqlsystemresource', esquema 'sys'.
Eu tentei fazer isso como sausuário:
grant execute on xp_logevent to sa
Mas recebo outro erro:
Você não pode encontrar o usuário 'sa' que não existe ou o usuário não tem permissão.
Como posso conceder permissões de execução ao usuário sa?
Estou trabalhando com a edição SQL Server 2014 Express e quero carregar alguns dados do OpenStreetMaps.
Os dados são um XML de 172 Mb e carregam bem. O problema está neste script:
UPDATE ways
SET geog4326 = 'LINESTRING(' + STUFF((
SELECT ',' + CAST(CAST(n.Longitude AS decimal(18,9)) AS varchar(32)) + ' ' + CAST(CAST(n.Latitude AS decimal(18,9)) AS varchar(32)) AS [text()]
FROM
ways w JOIN waynodes wn ON w.wayid = wn.wayid
JOIN nodes n ON wn.nodeid = n.nodeid
WHERE wn.wayid = w.wayid
ORDER BY w.wayid, orderid
FOR XML PATH(''), TYPE
).value('/', 'NVARCHAR(MAX)'),1,1,'') +')'
Recebo uma estrutura .NET sem memória no SQL Server Management Studio e também o executo no SQLCMD.
waystabela tem 101.393 linhas e waynodestem 1.018.575 linhas.
Você sabe como posso melhorar esse script?
By the way, eu recebo este script deste tutorial .
Não tenho índice e nem execução de plano. Estou apenas seguindo o tutorial e recebo um erro de falta de memória.
Estou trabalhando com o SQL Server 2012 Enterprise Edition SP2 em um Windows 7 32 bits.
Eu tenho esse código dentro de um procedimento armazenado.
Begin try
-- EXEC CLR Stored Procedure
exec dbo.MyStoredProcedureCLR @baseUrl, @orderNumber
end try
begin catch
Declare @message nvarchar(max);
set @message = ERROR_MESSAGE()
EXEC master..xp_logevent 60000, @message, informational
end catch
MyStoredProcedureCLRé um SQL CLR Stored Procedure que faz um PUT para um serviço web RESTful.
Às vezes, recebo uma 404 Not Foundexceção e quero capturá-la e registrá-la. Esta é a mensagem que recebo:
A .NET Framework error occurred during execution of user-defined routine or aggregate "GetNewCodesICODECLR":
System.Net.WebException: Error en el servidor remoto: (404) No se encontró.
System.Net.WebException:
en System.Net.HttpWebRequest.GetResponse()
en StoredProcedures.GetNewCodesICODECLR(SqlString baseUrl, SqlString orderNumber, SqlString lineCode, Int64 quantity, Int64 codesPrinted, Int64 codesCleared)
Mas, quando recebo essa exceção, recebo outra exceção em xp_logevent:
'Erro ao executar o procedimento armazenado estendido: tipo de parâmetro inválido'
Como posso saber se ERROR_MESSAGE()é um parâmetro válido? OU o que está acontecendo?
A propósito, estou executando um procedimento armazenado SQL CLR dentro de uma fila do Service Broker.
Estou tentando representar isso:
O design do meu banco de dados está correto?
Estou lendo este tutorial e tenho uma dúvida sobre isso.
Olhe para essa foto:
'Lendo' a relação lógica, li que a Projectdeve ter um ou mais Employee. Mas a implementação física tem que um Projeto pode ter zero ou mais ProjectEmployee.
Ou talvez eu esteja errado e a implementação física esteja correta.
O que você acha?
Estou projetando um banco de dados e quero representar o relacionamento entre usuários e grupos:
Um usuário pode estar em zero ou mais grupos. Um grupo pode ter um ou mais usuários.
Usando o Microsoft Visio 2013, desenhei este diagrama:
Está correto?