MrVimes's questions

Recentemente, troquei os servidores de banco de dados (bancos de dados restaurados do antigo para o novo e depois troquei os IPs) ...

Antigo: Sql Server 2005, Windows Server 2003 Novo: Sql Server 2008, Windows Server 2012

Todos os processos que se conectam ao servidor (site dot net, PHP, vbscript, mssql) de uma VPN geograficamente próxima funcionam bem no novo servidor.

Mas temos uma VPN entre o servidor (UK) e um escritório satélite (KY USA) e um aplicativo de banco de dados em execução no Microsoft Access, e esse aplicativo está gerando um erro ao realizar consultas no novo servidor. O erro é....

Erro: ODBC--falha na chamada.

[Microsoft][ODBC SQL Server Driver][DBNETLIB]ConnectionRead (recv()). (#10054) [Microsoft][ODBC SQL Server Driver][DBNETLIB]Erro geral de rede. Verifique a documentação da sua rede. (#11)

Se eu tiver temporariamente esse aplicativo consultando o servidor antigo (alterando o arquivo hosts local) o erro não ocorre e tudo funciona.

Para ajudar na solução de problemas, criei um pequeno script ...

'ConString="Provider=SQLOLEDB;Data Source=172.17.201.11,1433;" & _
'   "OLE DB Services=-2;Initial Catalog=Perf;Network=DBMSSOCN;User Id=*;Password=*"

ConString="Provider=SQLOLEDB;Data Source=172.17.201.11,1433;" & _
    "Initial Catalog=Perf;Network=DBMSSOCN;User Id=*;Password=*"
    set conn = CreateObject("ADODB.Connection") 
    
Conn.connectiontimeout=500
Conn.commandtimeout=500
conn.open ConString

SCRIPTTIMEOUT = 1000

'sqlstring="SELECT top 100 ClientID FROM Clients"
sqlstring="SELECT top 1000 ClientID FROM Clients"
'sqlstring="SELECT ClientID FROM Clients"

'succeeds with top 100
'fails with top 1000 or no limit


set Rcount = Conn.Execute(sqlstring)

msgbox Rcount(0)

Rcount.Close
set Rcount = Nothing

set sqlstring = Nothing
Conn.Close
set Conn = Nothing

O script funciona se eu consultar 100 linhas. Se eu tentar 1000, ele falha todas as vezes (eu não tentei quantidades intermediárias, mas não vejo muito sentido em reduzi-lo)

O script funciona se eu mudar o endereço IP para o servidor antigo (todo o resto é o mesmo - mesma vpn, mesmo cliente, mesmo script)

O script e o aplicativo de acesso funcionam bem em todos os sentidos em uma VPN diferente (também no Reino Unido)

• Eu vasculhei todas as configurações que posso encontrar em cada servidor (no MS SQL Studio, Configuration Manager, Network Settings) para tentar corresponder e experimentar configurações diferentes.
• Eu parei e iniciei serviços
• Eu pesquisei isso e tentei todas as sugestões que pude encontrar (perdi o controle, mas tentei adicionar OLE DB Services=-2. Tentei Encrypt=on(e desativei). Tentei Trusted_connection=on(e desativei). Tentei Pooling=on(e desativei). tentei especificar o nome da instância após o IP.

Ambos os servidores estão no mesmo rack físico, na mesma rede/sub-rede, conectados ao mesmo switch físico.

Antes de seguir o caminho de mexer nas configurações da VPN, trocar os fios (exigindo acesso ao DC), há algo que eu possa/deveria fazer/olhar no novo servidor para ajudar?

Edit: Se eu adicionar Packet Size=1024;à minha string de conexão, funciona! O problema é que ambos os servidores têm definido como 4096 por padrão, e o servidor antigo funciona bem com isso.

Editar 2 O acima funcionou para o meu script de teste, mas não para o aplicativo de acesso.

Espero encontrar uma solução alternativa que não exija uma alteração da cadeia de conexão porque isso será um aborrecimento (envolvendo o desenvolvedor do aplicativo de acesso)

Eu preciso ser capaz de ingressar em uma linha 'padrão' em uma tabela (tabela direita) somente quando não houver registro correspondente para ambos os campos na tabela esquerda. Abaixo está o conteúdo bruto das tabelas

#lefttable
--------------------
value  program  race
100    gold     1
100    gold     4
100    gold     5


#righttable
-------------------------
commission  program  race
14          GOLD     1
23          GOLD     NULL

Neste exemplo, onde a corrida é 1, preciso escolher a primeira linha (comissão = 14), mas se a corrida for diferente de 1, preciso escolher a linha NULL que corresponde ao outro campo (comissão = 23)

O problema que estou tendo é que minha consulta escolhe o registro nulo e o registro correspondente ao ingressar, resultando em duplicação ...

SELECT #lefttable.race,
       totalvalue = SUM(value),
       commission = SUM(value * (commission * 0.01))
  FROM #lefttable
  LEFT JOIN #righttable  ON #lefttable.program = #righttable.program
                        AND #lefttable.race = ISNULL(#righttable.race, #lefttable.race)
 GROUP BY #lefttable.race;

Isso resulta no abaixo

--------------------
race  totalvalue  commission
1     200         37.00
3     100         23.00
4     100         23.00

O valor total é o dobro do que deveria ser (e comissão incorreta) porque a junção criou duas linhas para a corrida 1 (uma para cada linha na tabela direita)

Idealmente, eu quero ser capaz de resolver esse problema inteiramente dentro da cláusula join, em vez de ter que adicionar cluds confusos à cláusula select, ou junções adicionais, ou visualizações, ou modificar righttable para criar uma linha para cada corrida, independentemente.

Eu tentei diferentes maneiras de construir a cláusula join, mas não consigo entender como dizer "Dê-me a linha com a corrida nula somente se não houver nenhuma linha que corresponda à corrida na tabela esquerda" usando uma junção sql.

Isso é possível?

Eu tenho tentado escrever uma função para verificar se uma string contém um número sem que esse número faça parte de um número maior (em outras palavras, se o número pesquisado for '6' e a string for '7+16+2' deve retornar false, porque o '6' nesta string faz parte do número '16')

Eu escrevi a função abaixo (é longa, mas eu ia testá-la antes de refatorá-la)

Ao testar, encontrei um bug pelo qual ele executa apenas a primeira instância de um número encontrado através da lógica. Portanto, executar esta função com '6' contra '16+7+9+6' retornaria false porque determina que o primeiro '6' faz parte de um número maior e interrompe o processamento.

Achei que para contornar isso eu tenho que implementar um loop para encurtar a string 'haystack' (para que, usando o exemplo '16+7+9+6' a função continue verificando '+7+9+6' após eliminar o primeiro '6'), mas antes de gastar tempo para fazer uma função já complicada ainda mais complicada eu queria verificar se existe uma maneira mais simples de atingir o mesmo objetivo?

drop function dbo.runners_contain_runner
go
create function dbo.runners_contain_runner(@runner varchar(max), @runners varchar(max))
returns int
as 
begin

    /*
    eliminate the plus sign from @runners so that the 
    'isnumeric' function doesn't return false positives (it returns 1 for '+') 
    */
    set @runners = replace(@runners,'+','_' ) 


    declare @ret int;
    set @ret = 0;

    -- if the runner is the only runner return 1
    if @runners = @runner 
        set @ret = 1
    else
    begin
        declare @charindex int;
        set @charindex = charindex(@runner,@runners)
        if @charindex > 0
        begin

            -- if it is at the beginning then check the char after it 
            if @charindex = 1 
            begin
                if isnumeric(substring(@runners,@charindex + len(@runner),1)) = 0
                    set @ret = @charindex
            end

            -- if it is at the end then check the char before it
            else if @charindex = len(@runners) - (len(@runner) - 1) 
            begin
                if isnumeric(substring(@runners,@charindex - 1,1)) = 0
                    set @ret = @charindex
            end

            -- if it is in the middle check the chars either side of it
            else
            begin
                if isnumeric(substring(@runners,@charindex - 1,1)) + 
                isnumeric(substring(@runners,@charindex + len(@runner),1)) = 0
                    set @ret = @charindex 
            end
        end
    end
    return @ret
end

Percebo que isso pode estar marcado como duplicado, mas estou perguntando especificamente em relação ao SQL Server 2005

Eu li conselhos conflitantes na internet, então estou perguntando aqui. Especificamente no SQL Server 2005, um NULL em uma coluna varchar ocupa o mesmo espaço que uma string vazia?

Eu construí uma tabela 'holding' em outra unidade e a preenchi com os dados da tabela de origem e, onde quer que os campos estivessem em branco, eu costumava nullif([field],'')inserir nulos no lugar dos espaços em branco.

Então eu construí uma nova tabela com exatamente a mesma estrutura da tabela de espera, mas em vez de substituir espaços em branco por nulo eu apenas inseri os espaços em branco, e até agora parece estar ocupando mais espaço (ainda não terminei de preenchê-lo e Não posso ter certeza de que está consumindo mais dados ainda)

Portanto, antes de preenchê-lo ainda mais e acabar com uma tabela maior do que pensei que seria, é melhor inserir nulos ou espaços em branco?

Editar:

Depois de migrar os dados da tabela de retenção para a nova tabela, a nova tabela é aproximadamente 4 GB maior.

Existem apenas duas pequenas diferenças no design da tabela - O campo 'serial_number' é char(15) na tabela de retenção, mas varchar(15) na tabela de destino. (O comprimento máximo de um número de série é 14 e há muitos valores vazios - acho que cerca de 30 milhões, se bem me lembro), e o índice clusterizado para a tabela de retenção tem uma coluna extra - program_name ..

Mesa de espera

USE [Temp_holding_EWS]
GO
/****** Object:  Table [dbo].[AmtoteAccountActivity_holding]    
 Script Date: 02/17/2017 20:41:32 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[AmtoteAccountActivity_holding](
    [_Date] [char](8) NULL,[Community] [varchar](10) NULL,
    [AccountNumber] [varchar](50) NULL,
    [Branch] [varchar](10) NULL,
    [Window] [varchar](3) NULL,
    [Time] [char](8) NULL,[Balance_Forward] [varchar](10) NULL,
    [Transaction_Type] [varchar](10) NULL,
    [Program_Name] [varchar](10) NULL,
    [Race] [varchar](10) NULL,[Pool_Type] [varchar](10) NULL,
    [Amount] [money] NULL,[Runners] [varchar](60) NULL,
    [Total_Bet_Amount] [varchar](10) NULL,
    [Debit_Amount] [varchar](10) NULL,
    [Credit_Amount] [varchar](10) NULL,
    [Tx_Date] [char](8) NULL,
    [Check_Clear_Date] [varchar](10) NULL,
    [Refund_Amt] [varchar](10) NULL,
    [Bet_Pool_Modifier] [varchar](5) NULL,
    [RecordID] [int] IDENTITY(1,1) NOT NULL,
    [serial_number] [char](15) NULL,
    [handle]  AS 
       (CONVERT([money],[total_bet_amount],(0))-CONVERT([money],[refund_amt],(0))),
    [txdatetime]  AS (CONVERT([datetime],([tx_date]+' ')+[time],(11))),
    [dbdate]  AS (CONVERT([datetime],[_date],(11))),
    [Audit_Trail] [varchar](20) NULL,
 CONSTRAINT [PK_AmtoteAccountActivity_holding] PRIMARY KEY NONCLUSTERED 
(
    [RecordID] 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
SET ANSI_PADDING OFF

(Índice agrupado)

USE [Temp_holding_EWS]
GO
/****** Object:  Index [IX_AmtoteAccountActivity_holding] 
    Script Date: 02/17/2017 21:08:44 ******/
CREATE CLUSTERED INDEX [IX_AmtoteAccountActivity_holding] ON 
    [dbo].[AmtoteAccountActivity_holding] 
(
    [AccountNumber] ASC,
    [_Date] ASC,
    [Program_Name] ASC
)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]

Tabela de destino

USE [EWS]
GO
/****** Object:  Table [dbo].[AmtoteAccountActivity]    
Script Date: 02/17/2017 20:48:16 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[AmtoteAccountActivity](
    [_Date] [char](8) NULL,     [Community] [varchar](10) NULL,
    [AccountNumber] [varchar](50) NULL,
    [Branch] [varchar](10) NULL,[Window] [varchar](3) NULL,
    [Time] [char](8) NULL,  [Balance_Forward] [varchar](10) NULL,
    [Transaction_Type] [varchar](10) NULL,
    [Program_Name] [varchar](10) NULL,
    [Race] [varchar](10) NULL,
    [Pool_Type] [varchar](10) NULL,
    [Amount] [money] NULL,[Runners] [varchar](60) NULL,
    [Total_Bet_Amount] [varchar](10) NULL,
    [Debit_Amount] [varchar](10) NULL,
    [Credit_Amount] [varchar](10) NULL,
    [Tx_Date] [char](8) NULL,
    [Check_Clear_Date] [varchar](10) NULL,
    [Refund_Amt] [varchar](10) NULL,
    [Bet_Pool_Modifier] [varchar](5) NULL,
    [RecordID] [int] IDENTITY(1,1) NOT NULL,
    [serial_number] [varchar](15) NULL,
    [handle]  AS 
       (CONVERT([money],[total_bet_amount],(0))-CONVERT([money],[refund_amt],(0))),
    [txdatetime]  AS (CONVERT([datetime],([tx_date]+' ')+[time],(11))),
    [dbdate]  AS (CONVERT([datetime],[_date],(11))),
    [Audit_Trail] [varchar](20) NULL,
 CONSTRAINT [PK_AmtoteAccountActivity2] PRIMARY KEY NONCLUSTERED 
(
    [RecordID] 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
SET ANSI_PADDING OFF

(Índice agrupado)

USE [EWS]
GO
/****** Object:  Index [IX_AmtoteAccountActivity2]  Script Date: 02/17/2017 21:06:29 ******/
CREATE CLUSTERED INDEX [IX_AmtoteAccountActivity2] ON [dbo].[AmtoteAccountActivity] 
(
    [AccountNumber] ASC,
    [_Date] ASC
)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]

( Nota: Para quem se pergunta por que aparentemente tem valores financeiros e numéricos armazenados em campos de caracteres: Esse foi o design original da tabela há 17 anos (não por mim) e agora existem centenas de consultas sql que são executadas neste banco de dados, é menos trabalhe para mantê-los como varchar e as consultas mantenham sua conversão, do que alterá-las para money,int ou decimal e alterar centenas de consultas)

Estou tentando cortar tudo depois de um determinado caractere (neste caso '&') e se não houver ocorrência desse caractere, pegue a string inteira.

select left(@str,isnull(nullif(charindex('&',@str) - 1,-1),len(@str)))

Esta parece ser uma maneira desnecessariamente complicada de fazê-lo. Existe uma maneira melhor/mais curta?

Aqui está um caso de teste completo para indicar o que estou fazendo ...

declare @str as varchar(255) 
set @str = 'abc&def&ghi'

select left(@str,isnull(nullif(charindex('&',@str) - 1,-1),len(@str)))

-- Returns 'abc'

set @str = 'abc'

select left(@str,isnull(nullif(charindex('&',@str) - 1,-1),len(@str)))

-- Returns 'abc'

Em uma tentativa amplamente experimental de reduzir o uso do espaço de tabela, alterei uma char(10)coluna para char(3) (O conteúdo da coluna nunca tem mais de três caracteres)

Etapas (não realizadas em um único lote)

use thedatabase;
alter table thetable
alter column thecolumn char(3) null

DBCC CLEANTABLE (thedatabase,'thetable', 500000); 
/* Apparently not needed for fixed length column but just in case*/

DBCC SHRINKFILE (1);

A operação foi concluída com êxito, mas a tabela aumentou de tamanho. Eu sei que isso pode acontecer devido à maneira como o mecanismo sql modifica uma coluna (cria uma cópia ao lado e depois copia o conteúdo da coluna), então corri dbcc cleantablena tabela e depois dbcc shrinkfileno arquivo do banco de dados. Nenhuma dessas operações fez qualquer diferença no tamanho da tabela.

A tabela não tem índice, portanto não é possível executar uma operação de reconstrução de índice.

Então, minha pergunta é: por que a tabela cresceu, mesmo após comandos para reduzi-la?

Descartei uma coluna char(10) de uma tabela que tem cerca de 111 milhões de linhas (dados de 30 GB, índice de 11 GB)

Em seguida, executei uma reconstrução de índice no índice clusterizado. Isso consumiu todo o espaço na unidade que contém o banco de dados.

Então corri dbcc cleantablee recuperei todo o espaço, além de mais alguns shows.

Existe uma maneira de recuperar espaço da coluna descartada quando não há espaço suficiente para a reconstrução do índice?

Ou a cleantableoperação realmente recuperou o espaço? (Eu sei que recuperou espaço, mas acho que é possível que recuperou espaço por um motivo diferente, já que cleantable não é sugerido como a maneira de recuperar espaço depois de descartar uma coluna)

Eu tenho uma tabela enorme no SQL Server 2005. (A tabela tem cerca de 40 GB) Estou procurando a maneira mais segura e descomplicada de liberar espaço ou atrasar seu crescimento.

A tabela tem três colunas de comprimento fixo ( char(10)) que são a) totalmente desnecessárias e b) quase totalmente preenchidas com NULL.

Se eu descartar essas colunas, o SQL Server começará a usar o espaço liberado no arquivo de dados quando novos registros forem importados? Ou sua natureza fragmentada (presumo) por estar espalhada por muitos registros significa que o SQL Server ignorará o espaço por motivos de desempenho?

Se eu derrubá-los, posso executar o banco de dados reduzido para liberar espaço?

Sou o único desenvolvedor que utiliza esse banco de dados e sei que essas colunas são excedentes aos requisitos. Eles foram adicionados junto com todas as outras colunas em um arquivo simples 15 anos atrás, quando diferentes desenvolvedores preguiçosos criaram esse banco de dados.

Em uma tabela com muitos milhões de linhas e dois índices existentes (um clusterizado e um índice de chave primária não clusterizado), criei um terceiro índice não exclusivo não clusterizado. Antes de criar esse índice, nas propriedades da tabela, o espaço do índice mostrava cerca de 4,9 GB. Após a criação, ele mostrou aproximadamente 9,9 gb

Verifiquei o espaço livre em disco no sistema operacional de cada disco antes de fazer isso. Eu verifiquei novamente depois e não há praticamente nenhuma mudança significativa (certamente não na ordem de 5 GB) em nenhum dos discos. Eu verifiquei novamente horas depois e ainda sem alterações.

Estou suspeitando/presumindo que algum arquivo de dados tinha muito espaço livre dentro dele, e o novo índice simplesmente ocupou aquele espaço já alocado. É provável que isso seja o que aconteceu?

Devo me preocupar?

Até hoje eu achava que tinha o jeito de otimizar consultas com junções em subconsultas. Mas venho tentando otimizar uma consulta e por capricho tentei um método antigo que achava que não precisava mais usar - usei tabelas temporárias.

Consulta lenta (leva 5 minutos)...

select (columns) from big_transactions_table t inner join 

  (select (columns) from small_info_table where (conditions)) q1

on q1.key = t.key
group by (columns)

Consulta rápida usando uma tabela temporária...

select (columns) from small_info_table into #q1 where (conditions)

go

select (columns) from big_transactions_table t inner join #q1
on #q1.key = t.key
group by (columns)

Demorou 14 segundos!

Fiquei com a impressão de que, quando você tem uma subconsulta em uma junção como essa, o mecanismo SQL obtém os dados primeiro antes de uni-los à consulta externa. Agora não tenho tanta certeza. Alguém pode me dizer porque há uma grande diferença no tempo de execução e se existe uma maneira simples de acelerar a consulta sem usar uma tabela temporária?

Eu tentei entender exemplos não dinâmicos na web, mas eles não resultam exatamente no que estou tentando fazer, que é ter linhas específicas transformadas em colunas e colunas transformadas em linhas. Para tentar ilustrar o que quero dizer, incluí uma foto...

Eu acredito que os dados em uma determinada coluna precisam ser do mesmo tipo, então se for esse o caso, tudo bem ter todas as colunas como varchar. Os dados na tabela de origem não precisarão fazer parte de nenhuma soma, apenas exibidos como estão. Estou apenas tentando 'girar' isso para exibir os dados de forma vertical para consumo do usuário final.

Desejo criar um usercom acesso mínimo necessário a dois bancos de dados em um servidor. O usuário será utilizado por alguém de terceiros integrando uma ferramenta de Business Intelligence em nosso banco de dados. Eles especificaram que precisarão apenas criar exibições.

Portanto, criei um novo usuário no servidor e usei as propriedades do banco de dados em cada banco de dados para conceder a eles os privilégios SELECTe CREATE VIEWnesse banco de dados.

Em seguida, loguei no SSMS usando esse usuário e tentei criar uma exibição, mas recebi uma mensagem dizendo que

'dbo' não existe ou não tenho permissão para usá-lo.

Tentei descobrir esse problema sozinho por tentativa e erro, mas simplesmente não entendo as permissões de usuário no servidor SQL. O que estou fazendo de errado e quais etapas extras/diferentes preciso executar?

Lembre-se, não quero que eles tenham mais controle do que o mínimo necessário.

Estou tentando retornar uma lista de clientes e a soma de suas transações na última semana, mas a consulta retorna clientes que não apostaram nada. Estou tentando fazer isso com uma junção à esquerda, mas a consulta só retorna uma linha se um cliente apostou, o que não é como espero que a junção à esquerda funcione. O que posso fazer para que isso funcione do jeito que eu quero?

select i.accountnumber, i.firstname, i.lastname, sum(a.amount)
from accountinformaton i 
left join accountactivity a 
    on i.accountnumber = a.accountnumber
where a.transactiontype = 'Bet' 
  and a.transactiondate >='2015-07-31'
group by i.accountnumber, i.firstname, i.lastname

a tabela 'accountinformation' tem milhares de linhas, a consulta acima retorna algumas centenas. Eu esperava poder retornar todas as linhas de 'informações da conta' e ter a soma nula nas contas que não apostaram.

Eu tenho uma tabela em um banco de dados no servidor Microsoft SQL Server 2005 com 16 GB de tamanho e 58 milhões de linhas.

Tem uma coluna chamada 'balance_forward' que é char(10) (Escolha incomum para uma coluna numérica, mas não projetei a tabela) Preciso aumentar seu tamanho para acomodar saldos com mais de dez caracteres (xxxxxxxxx. xx)

Tentei alterá-lo para char(12) (arriscado, não dou desculpas), mas acho que* isso fez com que o arquivo de log do banco de dados crescesse muitos gigabytes (e enchesse a unidade de log) e a operação falhou de qualquer maneira (o tipo de dados ainda é char(10))

Mais tarde, percebi que faria mais sentido mudar para pelo menos varchar(12), dessa forma a coluna não ocuparia mais espaço à força, mas teria mais espaço para acomodar dados maiores.

Minha pergunta é - isso também fará com que o arquivo de log cresça novamente (consegui liberar algum espaço movendo outros arquivos para fora da unidade de log)

E estou correto ao supor que usar varchar em vez de char impedirá que os dados existentes ocupem mais espaço?

(Idealmente, o tipo de dados deve ser alterado para o tipo mais apropriado para saldos financeiros, mas acho que será uma mudança mais drástica em 58 milhões de linhas)

* Não tenho certeza. Eu pensei ter visto muito espaço na unidade de log antes da operação, mas posso ter visto 'mb' e confundido com 'gb'. Então pode ser que o log já tenha preenchido o drive. Aparentemente, os logs podem crescer até preencherem a unidade/espaço alocado

Eu tenho lido sobre isso, mas a documentação online é um pouco difícil de entender e parece estranhamente escrita. Por exemplo, o INIT, NOINIT. Um diz que tentará sobrescrever tudo. O outro diz que será anexado independentemente.

Eu quero algo no meio disso. Desejo que os conjuntos de mídia expirados não estejam mais no arquivo, mas que novas tarefas de backup sejam anexadas ao arquivo ao lado de quaisquer conjuntos que ainda não tenham expirado.

O SQL abaixo realizará o backup desejado?

BACKUP DATABASE [mydb] 
TO  DISK = N'c:\Backups\mydb.bak' 
WITH NOFORMAT, NOINIT,  NAME = N'mydb-Full Database Backup', NOSKIP, 
NOREWIND, NOUNLOAD,  STATS = 10, RETAINDAYS = 60
GO

Se eu executar o procedimento acima e houver um conjunto de backup com mais de 60 dias, ele será removido do arquivo?

Editar:

Em resposta à sugestão de RichardTheKiwi, reescrevi o código para criar um novo arquivo a cada vez. Em seguida, escreverei um script do Windows para excluir arquivos anteriores a uma determinada data

declare @filename varchar(max)
set @filename = 'c:\sqlbackups\pptd_' +  replace(replace(convert(varchar, getdate(), 120),':','_'),' ','_') + '.bak'
BACKUP DATABASE [Peter's pointless test database] 
TO  DISK = @filename
WITH FORMAT, INIT,  NAME = N'pptd-Full Database Backup', 
NOREWIND, NOUNLOAD,  STATS = 10
GO

Perdoe-me se este é o site de troca errado para esta pergunta. Parece o certo.

Há muito tempo sou fã de escrever consultas manualmente, mas recentemente adquiri o hábito de usar o designer de consultas no Management Studio por um motivo - ele permite a edição de dados no local. (Provavelmente existe uma maneira de fazer isso na janela de consulta manual, mas ainda não descobri)

De qualquer forma, hoje eu queria criar uma nova instância dela para uma tabela e preservar a que já tinha aberta. Não me deixaria. Quando cliquei em 'abrir tabela' no explorador de objetos, ele apenas me levou para a janela que já estava aberta. Isso significava que, se eu quisesse consultar os dados de uma maneira diferente, teria que abandonar a consulta que havia configurado.

Existe uma maneira de obter uma segunda (ou mais) janela do designer de consulta para a mesma tabela?

Ocorre-me que posso apenas abrir uma segunda instância de todo o aplicativo (SSMS), mas isso parece um exagero para o que deve ser uma necessidade simples/comum.