All perguntas(dba)

Estou tendo problemas para recriar um banco de dados com um relacionamento um-para-muitos (1:M) entre Users e Items .

Isso é bastante direto, sim; no entanto, cada Item pertence a uma determinada Categoria (por exemplo, um Carro , um Barco ou um Avião ), e cada Categoria possui um determinado número de atributos, por exemplo:

Carestrutura:

+----+--------------+--------------+
| PK | Attribute #1 | Attribute #2 |
+----+--------------+--------------+

Boatestrutura:

+----+--------------+--------------+--------------+
| PK | Attribute #1 | Attribute #2 | Attribute #3 |
+----+--------------+--------------+--------------+

Planeestrutura:

+----+--------------+--------------+--------------+--------------+
| PK | Attribute #1 | Attribute #2 | Attribute #3 | Attribute #4 |
+----+--------------+--------------+--------------+--------------+

Devido a essa diversidade na quantidade de atributos (colunas), inicialmente pensei que seria uma boa ideia criar uma tabela separada para cada Category , assim evitaria vários NULLs e assim aproveitaria melhor a indexação.

Embora parecesse ótimo no começo, não consegui encontrar uma maneira de criar o relacionamento entre os itens e as categorias através do banco de dados porque, pelo menos em minha modesta experiência como administrador de banco de dados, ao criar chaves estrangeiras, informo explicitamente um banco de dados o nome da tabela e a coluna.

No final, gostaria de uma estrutura sólida para armazenar todos os dados, mas com todos os meios para listar todos os atributos de todos os itens que um usuário possa ter com uma consulta.

Eu poderia codificar consultas dinâmicas com a linguagem do lado do servidor , mas acho que isso está errado e não é o ideal.

Informação adicional

Estas são minhas respostas aos comentários do MDCCL:

1. Quantas categorias de itens de interesse existem em seu contexto de negócios, três (ou seja, carros , barcos e aviões ) ou mais?

Na verdade, é muito simples: existem apenas cinco categorias no total.

2. O mesmo Item pertencerá sempre ao mesmo Utilizador (ou seja, uma vez que um determinado Item tenha sido “atribuído” a um determinado Utilizador não pode ser alterado)?

Não, eles podem mudar. No cenário fictício da pergunta, seria como se o usuário A vendesse o item nº 1 para o usuário B , portanto, a propriedade deve ser refletida.

3. Existem atributos compartilhados por algumas ou todas as categorias ?

Não compartilhado, mas, de memória, posso dizer que pelo menos três atributos estão presentes em todas as Categorias .

4. Existe uma chance de que a cardinalidade do relacionamento entre Usuário e Item seja muitos-para-muitos (M:N) em vez de um-para-muitos (1:M)? Por exemplo, no caso das seguintes regras de negócios: A User owns zero-one-or-many ItemseAn Item is owned by one-to-many Users

Não, porque Itens descreveriam um objeto físico. Os usuários terão uma cópia virtual deles, cada um identificado por um GUID v4 exclusivo

5. Em relação à sua seguinte resposta a um dos comentários da pergunta:

“No cenário fictício da pergunta, seria como se o usuário A vendesse o item nº 1 para o usuário B , então a propriedade deve ser refletida.”

Parece que você está planejando acompanhar a evolução da propriedade do item , por assim dizer. Desta forma, quais atributos você gostaria de armazenar sobre tal fenômeno? Apenas a modificação do atributo que indica o Usuário específico que é o Dono de um Item específico ?

Não, na verdade não. A propriedade pode mudar, mas não preciso acompanhar o proprietário anterior .

Considere estas duas funções:

ROW_NUMBER() OVER (PARTITION BY A,B ORDER BY C)

ROW_NUMBER() OVER (PARTITION BY B,A ORDER BY C)

Tanto quanto eu entendo, eles produzem exatamente o mesmo resultado. Em outras palavras, a ordem em que você lista as colunas na PARTITION BYcláusula não importa.

Se houver um índice, (A,B,C)eu esperava que o otimizador usasse esse índice em ambas as variantes.

Mas, surpreendentemente, o otimizador decidiu fazer uma classificação extra explícita na segunda variante.

Eu vi isso no SQL Server 2008 Standard e no SQL Server 2014 Express.

Aqui está um script completo que usei para reproduzi-lo.

Tentei no Microsoft SQL Server 2014 - 12.0.2000.8 (X64) 20 de fevereiro de 2014 20:04:26 Copyright (c) Microsoft Corporation Express Edition (64 bits) no Windows NT 6.1 (Build 7601: Service Pack 1)

e Microsoft SQL Server 2014 (SP1-CU7) (KB3162659) - 12.0.4459.0 (X64) 27 de maio de 2016 15:33:17 Copyright (c) Microsoft Corporation Express Edition (64 bits) no Windows NT 6.1 (Build 7601: Service Pacote 1)

com o estimador de cardinalidade antigo e novo usando OPTION (QUERYTRACEON 9481)e OPTION (QUERYTRACEON 2312).

Configurar tabela, índice, dados de amostra

CREATE TABLE [dbo].[T](
    [ID] [int] IDENTITY(1,1) NOT NULL,
    [A] [int] NOT NULL,
    [B] [int] NOT NULL,
    [C] [int] NOT NULL,
    CONSTRAINT [PK_T] PRIMARY KEY CLUSTERED 
(
    [ID] ASC
)WITH (PAD_INDEX = OFF, 
STATISTICS_NORECOMPUTE = OFF, 
IGNORE_DUP_KEY = OFF, 
ALLOW_ROW_LOCKS = ON, 
ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO

CREATE NONCLUSTERED INDEX [IX_ABC] ON [dbo].[T]
(
    [A] ASC,
    [B] ASC,
    [C] ASC
)WITH (PAD_INDEX = OFF, 
STATISTICS_NORECOMPUTE = OFF, 
SORT_IN_TEMPDB = OFF, 
DROP_EXISTING = OFF, 
ONLINE = OFF, 
ALLOW_ROW_LOCKS = ON, 
ALLOW_PAGE_LOCKS = ON)
GO

INSERT INTO [dbo].[T] ([A],[B],[C]) VALUES
(10, 20, 30),
(10, 21, 31),
(10, 21, 32),
(10, 21, 33),
(11, 20, 34),
(11, 21, 35),
(11, 21, 36),
(12, 20, 37),
(12, 21, 38),
(13, 21, 39);

Consultas

SELECT -- AB
    ID,A,B,C
    ,ROW_NUMBER() OVER (PARTITION BY A,B ORDER BY C) AS rnAB
FROM T
ORDER BY C
OPTION(RECOMPILE);

SELECT -- BA
    ID,A,B,C
    ,ROW_NUMBER() OVER (PARTITION BY B,A ORDER BY C) AS rnBA
FROM T
ORDER BY C
OPTION(RECOMPILE);

SELECT -- both
    ID,A,B,C
    ,ROW_NUMBER() OVER (PARTITION BY A,B ORDER BY C) AS rnAB
    ,ROW_NUMBER() OVER (PARTITION BY B,A ORDER BY C) AS rnBA
FROM T
ORDER BY C
OPTION(RECOMPILE);

Planos de execução

PARTIÇÃO POR A,B

PARTIÇÃO POR B,A

Ambos

Como você pode ver, o segundo plano tem um Sort extra. Ordena por B,A,C. O otimizador, aparentemente, não é inteligente o suficiente para perceber que PARTITION BY B,Aé o mesmo PARTITION BY A,Be reclassificar os dados.

Curiosamente, a terceira consulta contém ambas as variantes ROW_NUMBERe não há classificação extra! O plano é o mesmo da primeira consulta. (O Projeto de Sequência tem expressão extra na Lista de Saída para a coluna extra, mas não Ordenação extra). Portanto, neste caso mais complicado, o otimizador parecia ser inteligente o suficiente para perceber que PARTITION BY B,Aé o mesmo que PARTITION BY A,B.

Na primeira e terceira consultas o operador Index Scan tem a propriedade Ordered:True, na segunda consulta é False.

Ainda mais interessante, se eu reescrever a terceira consulta assim (troque duas colunas):

SELECT -- both
    ID,A,B,C
    ,ROW_NUMBER() OVER (PARTITION BY B,A ORDER BY C) AS rnBA
    ,ROW_NUMBER() OVER (PARTITION BY A,B ORDER BY C) AS rnAB
FROM T
ORDER BY C
OPTION(RECOMPILE);

então o Sort extra aparece novamente!

Alguém poderia dar uma luz? O que está acontecendo no otimizador aqui?

Então hoje um professor nos disse que quando o banco de dados tem que fazer uma atualização, internamente (em baixo nível) ele faz um delete e depois um insert com os campos atualizados. Ele então disse que isso é algo feito em todos os bancos de dados e então comecei uma discussão dizendo que achava que não fazia sentido, mas não tinha recursos suficientes para sustentar minha posição. Ele parece saber muito, mas não consigo entender por que dbs faria isso.

Quer dizer, eu sei que se você atualizar um campo e precisar de mais espaço para aquela linha, ele pode excluir a linha fisicamente e colocá-la no final com os novos dados. Mas se, por exemplo, você reduzir o espaço usado, por que excluir e inserir novamente no final?

Isso é mesmo verdade? Quais são os benefícios?

Estou tentando atribuir SELECTprivilégios a um grupo no Redshift. Então eu criei um grupo e um usuário nesse grupo:

CREATE GROUP data_viewers;
CREATE USER <user> PASSWORD '<password>' IN GROUP data_viewers;

Agora eu gostaria de permitir que este grupo pudesse ler dados de qualquer tabela:

GRANT SELECT ON ALL TABLES IN SCHEMA PUBLIC TO GROUP data_viewers;

O comando retorna GRANT. Agora, quando me conecto ao Redshift como meu usuário e problema recém-criados SELECT * FROM something.something;, recebo:

permissão negada para esquema algo

Eu tentei conceder permissões para algo: GRANT SELECT ON ALL TABLES IN SCHEMA something TO GROUP data_viewers;mas isso não mudou nada.

Como posso permitir que usuários do meu grupo acessem SELECTdados de qualquer tabela no esquema?

O código a seguir foi adicionado por um de nossos desenvolvedores para excluir registros duplicados da tabela:

DELETE  SubQuery

FROM
(
    SELECT  ID
            ,FK1
            ,FK2
            ,CreatedDateTime
            ,ROW_NUMBER() OVER(PARTITION BY FK1, FK2 ORDER BY CreatedDateTime) AS RowNumber

    FROM    Table
)
AS SubQuery

WHERE   RowNumber > 1

Ao revisar o código, presumi que não funcionaria, no entanto, testá-lo em nosso ambiente de teste (SQL 2014) mostra que sim!

Como o SQL sabe resolver a subconsulta e excluir os registros table?

Estou trabalhando na otimização de algumas consultas.

Para a consulta abaixo,

SET STATISTICS IO ON;
DECLARE @OrderStartDate DATETIME2 = '27 feb 2016';
DECLARE @OrderEndDate  DATETIME2 = '28 feb 2016';

SELECT  o.strBxOrderNo
        , o.sintOrderStatusID
        , o.sintOrderChannelID
        , o.sintOrderTypeID
        , o.sdtmOrdCreated
        , o.sintMarketID
        , o.strOrderKey
        , o.strOfferCode
        , o.strCurrencyCode
        , o.decBCShipFullPrice
        , o.decBCShipFinal
        , o.decBCShipTax
        , o.decBCTotalAmount
        , o.decWrittenTotalAmount
        , o.decBCWrittenTotalAmount
        , o.decBCShipOfferDisc
        , o.decBCShipOverride
        , o.decTotalAmount
        , o.decShipTax
        , o.decShipFinal
        , o.decShipOverride
        , o.decShipOfferDisc
        , o.decShipFullPrice
        , o.lngAccountParticipantID
        , CONVERT(DATE, o.sdtmOrdCreated, 120) as OrderCreatedDateConverted
FROM    tablebackups.dbo.tblBOrder o
WHERE   o.sdtmOrdCreated >= @OrderStartDate
        AND o.sdtmOrdCreated < @OrderEndDate
        AND EXISTS  (
            SELECT  *
            FROM    tablebackups.dbo.tblBOrderItem oi 
            WHERE   oi.strBxOrderNo = o.strBxOrderNo
            AND     oi.decCatItemPrice > 0
        )
OPTION (RECOMPILE);

Eu criei o seguinte índice FILTERED:

-- table dbo.tblBorderItem
CREATE NONCLUSTERED INDEX IX_tblBOrderItem_decCatItemPrice_INCL 
ON dbo.tblBorderItem 
( 
     strBxOrderNo ASC
    , sintOrderSeqNo ASC
    , decCatItemPrice   
)   
INCLUDE 
(
    blnChargeShipping
    , decBCCatItemPrice
    , decBCCostPrice
    , decBCFinalPrice
    , decBCOfferDiscount
    , decBCOverrideDiscount
    , decBCTaxAmount
    , decCostPrice
    , decFinalPrice
    , decOfferDiscount
    , decOverrideDiscount
    , decTaxAmount
    , decWasPrice
    , dtmOrdItemCreated
    , sintOrderItemStatusId
    , sintOrderItemType
    , sintQuantity
    , strItemNo
)  
WHERE decCatItemPrice > 0 
WITH (DROP_EXISTING = ON, FILLFACTOR = 95);

Este índice não é utilizado apenas para esta consulta em particular, existem outras consultas que utilizam este mesmo índice, por isso as colunas INCLUÍDAS.

Para esta consulta em particular, quero apenas verificar (EXISTS) se um pedido possui algum item onde decCatItemPrice > 0.

O SQL Server está fazendo uma varredura de índice, como você pode ver nas imagens abaixo.

• As estatísticas acabaram de ser atualizadas.
• A tabela de itens tem 41.208 linhas em teste.

Observe que não seleciono nenhuma coluna da tabela de itens.

Esta tabela de itens tem 164.309.397 ao vivo. Eu gostaria de evitar uma varredura lá.

perguntas:

Por que o SQL Server não está fazendo uma busca de índice?

Existem outros fatores/coisas que devo considerar para melhorar esta consulta?

(4537 row(s) affected) Table 'tblBorder'. Scan count 1, logical reads
116, physical reads 0, read-ahead reads 0, lob logical reads 0, lob
physical reads 0, lob read-ahead reads 0. Table 'tblBorderItem'. Scan
count 1, logical reads 689, physical reads 0, read-ahead reads 0, lob
logical reads 0, lob physical reads 0, lob read-ahead reads 0.

(1 row(s) affected)

esta é a definição e índices na tabela tblBorderItem

    IF OBJECT_ID('[dbo].[tblBorderItem]') IS NOT NULL 
    DROP TABLE [dbo].[tblBorderItem] 
    GO
    CREATE TABLE [dbo].[tblBorderItem] ( 
    [strBxOrderNo]                VARCHAR(20)                      NOT NULL,
    [sintOrderSeqNo]              SMALLINT                         NOT NULL,
    [sintOrderItemStatusId]       SMALLINT                         NOT NULL,
    [sintNameStructureID]         SMALLINT                         NOT NULL,
    [strItemNo]                   VARCHAR(20)                      NOT NULL,
    [sintQuantity]                SMALLINT                         NOT NULL,
    [strCurrencyCode]             VARCHAR(3)                       NOT NULL,
    [decCostPrice]                DECIMAL(18,4)                    NOT NULL,
    [decCatItemPrice]             DECIMAL(18,2)                    NOT NULL,
    [decOfferDiscount]            DECIMAL(18,2)                    NOT NULL,
    [decOverrideDiscount]         DECIMAL(18,2)                    NOT NULL,
    [decFinalPrice]               DECIMAL(18,2)                    NOT NULL,
    [decTaxAmount]                DECIMAL(18,2)                    NOT NULL,
    [strBCCurrencyCode]           VARCHAR(3)                       NOT NULL,
    [decBCCostPrice]              DECIMAL(18,4)                    NOT NULL,
    [decBCCatItemPrice]           DECIMAL(18,4)                    NOT NULL,
    [decBCOfferDiscount]          DECIMAL(18,4)                    NOT NULL,
    [decBCOverrideDiscount]       DECIMAL(18,4)                    NOT NULL,
    [decBCFinalPrice]             DECIMAL(18,4)                    NOT NULL,
    [decBCTaxAmount]              DECIMAL(18,4)                    NOT NULL,
    [dtmOrdItemCreated]           DATETIME                         NOT NULL,
    [blnChargeShipping]           BIT                              NOT NULL,
    [lngTimeOfOrderQtyOnHand]     INT                                  NULL,
    [sdtmTimeOfOrderDueDate]      SMALLDATETIME                        NULL,
    [lngProdSetSeqNo]             INT                                  NULL,
    [lngProdRelationId]           INT                                  NULL,
    [lngProdRelationMemberId]     INT                                  NULL,
    [decWasPrice]                 DECIMAL(18,2)                        NULL,
    [sintOrderItemType]           SMALLINT                             NULL,
    [tsRowVersion]                TIMESTAMP                            NULL,
    [sdtmOrderItemStatusUpdated]  SMALLDATETIME                        NULL,
    CONSTRAINT   [PK_tblBOrderItem]  
PRIMARY KEY CLUSTERED    
([strBxOrderNo] asc, [sintOrderSeqNo] asc) 
WITH FILLFACTOR = 100)

    GO

    CREATE NONCLUSTERED INDEX 
    [IX_tblBOrderItem__dtmOrdItemCreated] 
       ON [dbo].[tblBorderItem] ([dtmOrdItemCreated] asc)
       WITH FILLFACTOR = 100


    CREATE NONCLUSTERED INDEX [IX_tblBOrderItem__sintOrderItemStatusId] 
       ON [dbo].[tblBorderItem] ([sintOrderItemStatusId] asc)
       INCLUDE ([sdtmOrderItemStatusUpdated], 
    [sintOrderSeqNo], [strBxOrderNo], [strItemNo])
       WITH FILLFACTOR = 100

CREATE NONCLUSTERED INDEX [IX_tblBOrderItem__
sintOrderItemStatusId_decFinalPrice_
sdtmOrderItemStatusUpdated_
include_strBxOrderNo] 
   ON [dbo].[tblBorderItem] 
([sintOrderItemStatusId] asc, 
 [decFinalPrice] asc, 
 [sdtmOrderItemStatusUpdated] asc)
   INCLUDE ([strBxOrderNo])
   WITH FILLFACTOR = 100

CREATE NONCLUSTERED INDEX [IX_tblBOrderItem__strBxOrderNo] 
   ON [dbo].[tblBorderItem] 
([strBxOrderNo] asc)
   WITH FILLFACTOR = 100


CREATE NONCLUSTERED INDEX [IX_tblBOrderItem__strItemNo] 
   ON [dbo].[tblBorderItem] ([strItemNo] asc)
   WITH FILLFACTOR = 100

CREATE NONCLUSTERED INDEX 
[IX_tblBOrderItem_decCatItemPrice_INCL] 
   ON [dbo].[tblBorderItem] 
([strBxOrderNo] asc, [sintOrderSeqNo] asc, [decCatItemPrice] asc)
   INCLUDE ([blnChargeShipping], 
[decBCCatItemPrice], [decBCCostPrice], [decBCFinalPrice], 
[decBCOfferDiscount], [decBCOverrideDiscount], 
[decBCTaxAmount], [decCostPrice], [decFinalPrice], 
[decOfferDiscount], [decOverrideDiscount], 
[decTaxAmount], [decWasPrice], [dtmOrdItemCreated], 
[sintOrderItemStatusId], [sintOrderItemType], 
[sintQuantity], [strItemNo])
   WHERE ([decCatItemPrice]>(0))
   WITH FILLFACTOR = 95

esta é a definição e índices na tabela tblBorder

IF OBJECT_ID('[dbo].[tblBorder]') IS NOT NULL 
DROP TABLE [dbo].[tblBorder] 
GO
CREATE TABLE [dbo].[tblBorder] ( 
[strBxOrderNo]                VARCHAR(20)                      NOT NULL,
[uidOrderUniqueID]            UNIQUEIDENTIFIER                 NOT NULL,
[sintOrderStatusID]           SMALLINT                         NOT NULL,
[sintOrderChannelID]          SMALLINT                         NOT NULL,
[sintOrderTypeID]             SMALLINT                         NOT NULL,
[blnIsBasket]                 BIT                              NOT NULL,
[sdtmOrdCreated]              SMALLDATETIME                    NOT NULL,
[sintMarketID]                SMALLINT                         NOT NULL,
[strOrderKey]                 VARCHAR(20)                      NOT NULL,
[strOfferCode]                VARCHAR(20)                      NOT NULL,
[lngShippedToParticipantID]   INT                              NOT NULL,
[lngOrderedByParticipantID]   INT                              NOT NULL,
[lngShipToAddressID]          INT                              NOT NULL,
[lngAccountAddressID]         INT                              NOT NULL,
[lngAccountParticipantID]     INT                              NOT NULL,
[lngOrderedByAddressID]       INT                              NOT NULL,
[lngOrderTakenBy]             INT                              NOT NULL,
[strCurrencyCode]             VARCHAR(3)                       NOT NULL,
[decShipFullPrice]            DECIMAL(18,2)                    NOT NULL,
[decShipOfferDisc]            DECIMAL(18,2)                    NOT NULL,
[decShipOverride]             DECIMAL(18,2)                    NOT NULL,
[decShipFinal]                DECIMAL(18,2)                    NOT NULL,
[decShipTax]                  DECIMAL(18,2)                    NOT NULL,
[strBCCurrencyCode]           VARCHAR(3)                       NOT NULL,
[decBCShipFullPrice]          DECIMAL(18,4)                    NOT NULL,
[decBCShipOfferDisc]          DECIMAL(18,4)                    NOT NULL,
[decBCShipOverride]           DECIMAL(18,4)                    NOT NULL,
[decBCShipFinal]              DECIMAL(18,4)                    NOT NULL,
[decBCShipTax]                DECIMAL(18,4)                    NOT NULL,
[decTotalAmount]              DECIMAL(18,2)                    NOT NULL,
[decBCTotalAmount]            DECIMAL(18,4)                    NOT NULL,
[decWrittenTotalAmount]       DECIMAL(18,2)                        NULL,
[decBCWrittenTotalAmount]     DECIMAL(18,4)                        NULL,
[blnProRataShipping]          BIT                              NOT NULL,
[blnChargeWithFirstShipment]  BIT                              NOT NULL,
[sintShippingServiceLevelID]  SMALLINT                         NOT NULL,
[sintShippingMethodID]        SMALLINT                         NOT NULL,
[sdtmDoNotShipUntil]          SMALLDATETIME                        NULL,
[blnHoldUntilComplete]        BIT                              NOT NULL,
[tsRowVersion]                TIMESTAMP                            NULL,
CONSTRAINT   [PK_tblBOrder]  
PRIMARY KEY CLUSTERED    
([strBxOrderNo] asc) WITH FILLFACTOR = 100)

GO

CREATE NONCLUSTERED INDEX 
[IX_tblBOrder__lngAccountAddressID] 
   ON [dbo].[tblBorder] 
   ([lngAccountAddressID] asc, [sintOrderStatusID] asc)
   WITH FILLFACTOR = 100

CREATE NONCLUSTERED INDEX 
[IX_tblBOrder__lngAccountParticipantID] 
   ON [dbo].[tblBorder] 
   ([lngAccountParticipantID] asc)
   WITH FILLFACTOR = 100

CREATE NONCLUSTERED INDEX 
[IX_tblBOrder__lngOrderedByAddressID] 
   ON [dbo].[tblBorder] 
   ([lngOrderedByAddressID] asc, [sintOrderStatusID] asc)
   WITH FILLFACTOR = 100

CREATE NONCLUSTERED INDEX 
[IX_tblBOrder__lngOrderedByParticipantID] 
   ON [dbo].[tblBorder] ([lngOrderedByParticipantID] asc)
   WITH FILLFACTOR = 100

CREATE NONCLUSTERED INDEX 
[IX_tblBOrder__lngShippedToParticipantID] 
   ON [dbo].[tblBorder] 
   ([lngShippedToParticipantID] asc)
   WITH FILLFACTOR = 100

CREATE NONCLUSTERED INDEX 
[IX_tblBOrder__lngShipToAddressID] 
   ON [dbo].[tblBorder] 
   ([lngShipToAddressID] asc, [sintOrderStatusID] asc)
   WITH FILLFACTOR = 100

CREATE NONCLUSTERED INDEX 
[IX_tblBOrder__sdtmOrdCreated_sintMarketID__include_strBxOrderNo] 
   ON [dbo].[tblBorder] 
   ([sdtmOrdCreated] asc, [sintMarketID] asc)
   INCLUDE ([strBxOrderNo])
   WITH FILLFACTOR = 100

CREATE NONCLUSTERED INDEX 
[IX_tblBOrder_sdtmOrdCreated_INCL] 
   ON [dbo].[tblBorder] 
   ([sdtmOrdCreated] asc)
   INCLUDE ([decBCShipFinal], [decBCShipFullPrice], 
            [decBCShipOfferDisc], [decBCShipOverride], 
            [decBCShipTax], [decBCTotalAmount], [decBCWrittenTotalAmount], 
            [decShipFinal], [decShipFullPrice], [decShipOfferDisc], 
            [decShipOverride], [decShipTax], [decTotalAmount], 
            [decWrittenTotalAmount], [lngAccountParticipantID], 
            [lngOrderedByParticipantID], [sintMarketID], 
            [sintOrderChannelID], [sintOrderStatusID], 
            [sintOrderTypeID], [strBxOrderNo], [strCurrencyCode], 
            [strOfferCode], [strOrderKey])
   WITH FILLFACTOR = 100

CREATE NONCLUSTERED 
INDEX [IX_tblBOrder_sintMarketID_sdtmOrdCreated] 
   ON [dbo].[tblBorder] 
   ([sintMarketID] asc, [sdtmOrdCreated] asc)
   INCLUDE ([sintOrderChannelID], [strBxOrderNo])
   WITH FILLFACTOR = 100

CREATE NONCLUSTERED 
INDEX [IX_tblBOrder__sintOrderChannelID_sdtmOrdCreated_INCL] 
   ON [dbo].[tblBorder] 
   ([sintOrderChannelID] asc, [sdtmOrdCreated] asc)
   INCLUDE ([decBCShipFinal], [decBCShipFullPrice], 
   [decBCShipTax], [decShipFinal], [decShipFullPrice], 
   [decShipTax], [lngAccountParticipantID], [sintMarketID], 
   [sintOrderTypeID], [strBxOrderNo], 
   [strCurrencyCode], [strOrderKey])
   WITH FILLFACTOR = 100

CREATE NONCLUSTERED INDEX [IX_tblBOrder_strBxOrderNo_sdtmOrdCreated_incl] 
   ON [dbo].[tblBorder] ([strBxOrderNo] asc, 
   [sdtmOrdCreated] asc)
   INCLUDE ([sintOrderChannelID], [sintOrderTypeID], [sintMarketID], 
   [strOrderKey], [lngAccountParticipantID], [strCurrencyCode], 
   [decShipFullPrice], [decShipFinal], [decShipTax], 
   [decBCShipFullPrice], [decBCShipFinal], 
   [decBCShipTax])

Conclusão

Apliquei meu índice no sistema LIVE e atualizei meu procedimento armazenado para usar SMALLDATETIME, a fim de corresponder os tipos de dados no banco de dados para as colunas envolvidas.

Após isso, ao olhar o plano de consulta vejo a imagem abaixo:

era exatamente como eu queria que fosse.

Acho que o otimizador de consulta, neste caso , fez um bom trabalho para obter o melhor plano de consulta em ambos os ambientes e estou feliz por não ter adicionado nenhuma dica de consulta.

Aprendi com as 3 respostas postadas. obrigado a Max Vernon , Paul White e Daniel Hutmacher por suas respostas.

Se você executar uma consulta com 'Incluir plano de execução real', o plano também sugerirá índices que estão faltando. Os detalhes do índice estão dentro MissingIndexesda tag no XML. Existe uma situação em que o plano inclui várias sugestões de índice? Tentei diferentes consultas SQL, mas não consegui encontrar nenhuma consulta que gerasse dois ou mais índices ausentes.

Eu cavei algumas horas em relação à minha pergunta e não obtive resposta satisfatória. Ainda tenho dúvida. Eu encontrei o seguinte sobre o índice clusterizado:

1. Os dados são armazenados na ordem do índice clusterizado.
2. Apenas um índice clusterizado por tabela.
3. Quando uma chave primária é criada, um índice clusterizado também é criado automaticamente.

Eu tenho esses pontos, mas minhas perguntas são:

1. O índice clusterizado existe no banco de dados Oracle? pois li em alguns blogs "Oracle não tem um conceito de índice clusterizado."
2. Se sim, por favor, deixe-me saber a instrução sql para criar um índice clusterizado .
3. Como dito acima, o índice clusterizado é criado automaticamente quando a chave primária é definida em uma coluna de uma tabela, como posso verificar o tipo de índice se ele é criado ou não?

Por favor, encontre minha arquitetura de tabela:

Deixe-me saber se mais alguma coisa é necessária para obter respostas para essas perguntas.

Nosso arquiteto de banco de dados disse a um cliente nosso que o SQL Server 2014 é uma escolha ruim em relação a 2012 porque não possui as vantagens de desempenho e estabilidade que 2012 possui. Tudo o que li contradiz isso. Aaron Bertrand diz exatamente o oposto e todos os white papers que li da MS também concordam - 2014 foi aprimorado e resolve alguns dos problemas de AG que as pessoas tiveram com 2012.

Existe alguma grande desvantagem em escolher 2014 em vez de 2012 que estou perdendo?

Acontece que estamos usando o SQL Server 2012 Standard Edition. Também uso os scripts de Ola Hallengren para fornecer uma estrutura fácil e mais flexível para fazer backups e manutenção.

Esta pergunta não é tanto sobre os scripts de Ola, mas sim sobre uma prática recomendada. Sei que a resposta final é "depende dos requisitos da sua empresa". Mas estou tentando buscar o conselho da comunidade sobre a melhor forma de cumprir o que entendo dos requisitos de nossa empresa.

Desejo configurar backups de log de transações a cada 15 minutos. Dessa forma, esperamos não perder mais de 15 minutos de dados. Devo configurar um trabalho que usa ALL_DATABASES? ou é melhor configurar um trabalho para cada banco de dados e iniciá-los todos em paralelo? Pergunto, porque tenho a sensação, com base em como vejo o script de Ola funcionando, de que os backups são iniciados em série. A desvantagem do serial seria que cada backup sucessivo espera até que o outro seja concluído. Isso pode aumentar potencialmente a quantidade de tempo entre os backups (ou seja, mais de 15 minutos). Além disso, minha preocupação seria que uma falha em um backup impedisse que os outros acontecessem, e eu não gostaria que fosse esse o caso. Eu gostaria que os outros continuassem recuando.

Então é verdade que os scripts do Ola são executados em série e também uma falha interrompe os backups sucessivos?

E é melhor ter um trabalho para cada banco de dados? ou um único trabalho que faz tudo? Minha inclinação é para trabalhos separados, mas desejo entender o que os DBAs do SQL Server em geral tendem a fazer.