All perguntas(dba)

Aqui está uma pergunta para os sys ops por aí (ou para aqueles que passaram por essa experiência antes).

Minha empresa deseja alocar espaço em disco adicional em caixas existentes do SQL Server em produção. Estamos nos perguntando se a extensão de um volume ("Estender Volume..." no Gerenciamento de Disco) pode ser feita ONLINE ou se o SQL Server Service precisa ser desligado.

Algum motivo pelo qual o SQL Server Service deve ser interrompido para fazer isso ou não há problema em apenas executar essa operação durante o dia?

Apenas no caso de as especificações do sistema serem relevantes. Esta é uma caixa real (sem virtualização) executando o Windows 2012 R2 e o SQL Server 2008 R2.

Obrigado!

Dada uma função de banco de dados, user1, uma função something()definida como um procedimento armazenado e uma exibição criada como:

CREATE VIEW view1 AS select * from something()

E, dadas essas permissões:

REVOKE ALL ON FUNCTION something FROM user1
REVOKE SELECT ON view1 FROM user1

Quando executo SELECT * FROM view1, recebo um erro permission denied for function something().

Minha pergunta é, se eu revogar as permissões de seleção na exibição, por que a função é chamada? Esperava receber algo como:

permission denied for relation view1

Obrigada!

para minha empresa, criei uma visão que é usada para exportação. Talvez haja um problema com a consulta que é usada para criar esta tabela.

Então aqui está a minha pergunta:

É possível obter a consulta que usei para criar a referida tabela de visualização?

Eu tenho uma situação que acho que pode ser resolvida usando a função de janela, mas não tenho certeza.

Imagine a seguinte tabela

CREATE TABLE tmp (
  date timestamp
, id_type integer
) ;

INSERT INTO tmp (date, id_type)
VALUES
    ( '2017-01-10 07:19:21.0', 3 ),
    ( '2017-01-10 07:19:22.0', 3 ),
    ( '2017-01-10 07:19:23.1', 3 ),
    ( '2017-01-10 07:19:24.1', 3 ),
    ( '2017-01-10 07:19:25.0', 3 ),
    ( '2017-01-10 07:19:26.0', 5 ),
    ( '2017-01-10 07:19:27.1', 3 ),
    ( '2017-01-10 07:19:28.0', 5 ),
    ( '2017-01-10 07:19:29.0', 5 ),
    ( '2017-01-10 07:19:30.1', 3 ),
    ( '2017-01-10 07:19:31.0', 5 ),
    ( '2017-01-10 07:19:32.0', 3 ),
    ( '2017-01-10 07:19:33.1', 5 ),
    ( '2017-01-10 07:19:35.0', 5 ),
    ( '2017-01-10 07:19:36.1', 5 ),
    ( '2017-01-10 07:19:37.1', 5 );

Eu gostaria de ter um novo grupo a cada mudança de valor na coluna id_type. EG 1º grupo das 7:19:21 às 7:19:25, 2º largada e chegada às 7:19:26, e assim sucessivamente.

Neste momento, usando a consulta abaixo ...

SELECT distinct 
    min(min(date)) over w as begin, 
    max(max(date)) over w as end,   
    id_type
FROM tmp
GROUP BY id_type
WINDOW w AS (PARTITION BY id_type)
ORDER BY begin;

Obtenho o seguinte resultado:

begin                   end                     id_type
2017-01-10 07:19:21.0   2017-01-10 07:19:32.0   3
2017-01-10 07:19:26.0   2017-01-10 07:19:37.1   5

Enquanto eu gostaria:

begin                   end                     id_type
2017-01-10 07:19:21.0   2017-01-10 07:19:25.0   3
2017-01-10 07:19:26.0   2017-01-10 07:19:26.0   5
2017-01-10 07:19:27.1   2017-01-10 07:19:27.1   3
2017-01-10 07:19:28.0   2017-01-10 07:19:29.0   5
2017-01-10 07:19:30.1   2017-01-10 07:19:30.1   3
2017-01-10 07:19:31.0   2017-01-10 07:19:31.0   5
2017-01-10 07:19:32.0   2017-01-10 07:19:32.0   3
2017-01-10 07:19:33.1   2017-01-10 07:19:37.1   5

Quando isso funcionar, quero incluir mais critérios para definir grupos, e esses outros serão anuláveis.

Versão do Postgres: 8.4. Temos Postgres com PostGis, então não é fácil atualizar. As funções do PostGis mudam de nome e há outros problemas, mas já estamos reescrevendo tudo e a nova versão usará uma versão mais recente 9.X com PostGis 2.x.

Eu gerei um arquivo de rastreamento no SQL Server 2012, não tenho certeza sobre a unidade de duração, ela é medida em milissegundos?

Tabela #01 Status:

StatusID    Status
-----------------------
 1          Opened
 2          Closed
 3          ReOpened
 4          Pending

Tabela #02 Claims:

ClaimID     CompanyName StatusID
--------------------------------------
1               ABC     1
2               ABC     1
3               ABC     2
4               ABC     4
5               XYZ     1
6               XYZ     1

Resultado esperado:

CompanyName TotalOpenClaims TotalClosedClaims TotalReOpenedClaims TotalPendingClaims
--------------------------------------------------------------------------------
ABC                 2           1                      0               1
XYZ                 2           0                      0               0

Como eu preciso escrever a consulta para que eu possa obter o resultado conforme o esperado?

Eu tenho uma tabela com uma coluna de identidade que também é uma chave primária. Atualmente, possui 50 milhões de linhas, com o valor mais alto da coluna de identidade em 148.921.803. A mesa tem muitos DELETEse INSERTSrealizados nela, daí o alto valor.

Queremos alterar o tipo de dados de INTpara BIGINTpara preparar a adição de mais linhas. Observe que não há referências à coluna PK.

Qual é a melhor maneira de fazer isso, com o mínimo de tempo de inatividade? Eu tenho duas opções.

1. Solte o PK e altere a coluna; ou
2. O método copy-drop-rename, conforme descrito aqui :

Aqui está o resumo: estou fazendo uma consulta de seleção. Todas as colunas nas cláusulas WHEREe ORDER BYestão em um único índice não clusterizado IX_MachineryId_DateRecorded, como parte da chave ou como INCLUDEcolunas. Estou selecionando todas as colunas, para que isso resulte em uma pesquisa de favoritos, mas estou apenas usando TOP (1), então certamente o servidor pode dizer que a pesquisa só precisa ser feita uma vez, no final.

Mais importante, quando forço a consulta a usar index IX_MachineryId_DateRecorded, ela é executada em menos de um segundo. Se eu deixar o servidor decidir qual índice usar, ele escolherá IX_MachineryIde levará até um minuto. Isso realmente sugere para mim que fiz o índice certo e o servidor está apenas tomando uma decisão ruim. Por quê?

CREATE TABLE [dbo].[MachineryReading] (
    [Id]                 INT              IDENTITY (1, 1) NOT NULL,
    [Location]           [sys].[geometry] NULL,
    [Latitude]           FLOAT (53)       NOT NULL,
    [Longitude]          FLOAT (53)       NOT NULL,
    [Altitude]           FLOAT (53)       NULL,
    [Odometer]           INT              NULL,
    [Speed]              FLOAT (53)       NULL,
    [BatteryLevel]       INT              NULL,
    [PinFlags]           BIGINT           NOT NULL,
    [DateRecorded]       DATETIME         NOT NULL,
    [DateReceived]       DATETIME         NOT NULL,
    [Satellites]         INT              NOT NULL,
    [HDOP]               FLOAT (53)       NOT NULL,
    [MachineryId]        INT              NOT NULL,
    [TrackerId]          INT              NOT NULL,
    [ReportType]         NVARCHAR (1)     NULL,
    [FixStatus]          INT              DEFAULT ((0)) NOT NULL,
    [AlarmStatus]        INT              DEFAULT ((0)) NOT NULL,
    [OperationalSeconds] INT              DEFAULT ((0)) NOT NULL,
    CONSTRAINT [PK_dbo.MachineryReading] PRIMARY KEY CLUSTERED ([Id] ASC),
    CONSTRAINT [FK_dbo.MachineryReading_dbo.Machinery_MachineryId] FOREIGN KEY ([MachineryId]) REFERENCES [dbo].[Machinery] ([Id]) ON DELETE CASCADE,
    CONSTRAINT [FK_dbo.MachineryReading_dbo.Tracker_TrackerId] FOREIGN KEY ([TrackerId]) REFERENCES [dbo].[Tracker] ([Id]) ON DELETE CASCADE
);

GO
CREATE NONCLUSTERED INDEX [IX_MachineryId]
    ON [dbo].[MachineryReading]([MachineryId] ASC);

GO
CREATE NONCLUSTERED INDEX [IX_TrackerId]
    ON [dbo].[MachineryReading]([TrackerId] ASC);

GO
CREATE NONCLUSTERED INDEX [IX_MachineryId_DateRecorded]
    ON [dbo].[MachineryReading]([MachineryId] ASC, [DateRecorded] ASC)
    INCLUDE([OperationalSeconds], [FixStatus]);

A tabela é particionada em intervalos de meses (embora eu ainda não entenda realmente o que está acontecendo lá).

ALTER PARTITION SCHEME PartitionSchemeMonthRange NEXT USED [Primary]
ALTER PARTITION FUNCTION [PartitionFunctionMonthRange]() SPLIT RANGE(N'2016-01-01T00:00:00.000') 

ALTER PARTITION SCHEME PartitionSchemeMonthRange NEXT USED [Primary]
ALTER PARTITION FUNCTION [PartitionFunctionMonthRange]() SPLIT RANGE(N'2016-02-01T00:00:00.000') 
...

CREATE UNIQUE CLUSTERED INDEX [PK_dbo.MachineryReadingPs] ON MachineryReading(DateRecorded, Id) ON PartitionSchemeMonthRange(DateRecorded)

A consulta que eu normalmente executaria:

SELECT TOP (1) [Id], [Location], [Latitude], [Longitude], [Altitude], [Odometer], [ReportType], [FixStatus], [AlarmStatus], [Speed], [BatteryLevel], [PinFlags], [DateRecorded], [DateReceived], [Satellites], [HDOP], [OperationalSeconds], [MachineryId], [TrackerId]
    FROM [dbo].[MachineryReading]
    --WITH(INDEX(IX_MachineryId_DateRecorded)) --This makes all the difference
    WHERE ([MachineryId] = @p__linq__0) AND ([DateRecorded] >= @p__linq__1) AND ([DateRecorded] < @p__linq__2) AND ([OperationalSeconds] > 0)
    ORDER BY [DateRecorded] ASC

Plano de consulta: https://www.brentozar.com/pastetheplan/?id=r1c-RpxNx

Plano de consulta com índice forçado: https://www.brentozar.com/pastetheplan/?id=SywwTagVe

Os planos incluídos são os planos de execução reais, mas no banco de dados de preparação (cerca de 1/100 do tamanho do ao vivo). Estou hesitante em mexer no banco de dados ativo porque comecei nesta empresa há apenas um mês.

Tenho a sensação de que é por causa do particionamento, e minha consulta normalmente abrange todas as partições (por exemplo, quando desejo obter o primeiro ou o último OperationalSecondsregistrado para uma máquina). No entanto, as consultas que tenho escrito à mão estão sendo executadas de 10 a 100 vezes mais rápido do que o EntityFramework gerou, então vou apenas criar um procedimento armazenado.

id value
1   50
2   60
3   55

select max(value) from tablename;

Geralmente sabemos que teremos 60, mas preciso do próximo valor 55.

Como obtenho o valor 55 usando SQL?

Postgres novato aqui.

Eu estou querendo saber se esta consulta é otimizada ou não? Tentei JOIN ON apenas os valores que são 100% necessários e deixando todas as condições dinâmicas na cláusula WHERE. Veja abaixo.

SELECT *
    FROM
      myapp_employees
    JOIN myapp_users ON
      myapp_users.user_id=myapp_employees.user_id
    JOIN myapp_contacts_assoc ON
      myapp_contacts_assoc.user_id=myapp_users.user_id
    JOIN myapp_contacts ON
      myapp_contacts.contact_id=myapp_contacts_assoc.contact_id
    WHERE
      myapp_contacts.value='[email protected]' AND
      myapp_contacts.type=(1)::INT2 AND
      myapp_contacts.is_primary=(1)::INT2 AND
      myapp_contacts.expired_at IS NULL AND
      myapp_employees.status=(1)::INT2 AND
      myapp_users.status=(1)::INT2
    LIMIT 1;

Nota: Por contexto, este proc está verificando se um usuário também é um funcionário (privs elevados/tipo de usuário diferente).

De qualquer forma, este é o caminho certo a seguir? O JOIN ON deve conter mais instruções como verificar expired_at IS NULL, por exemplo? Por que ou por que isso não faz sentido?