GWR's questions

Eu tenho um procedimento armazenado que retorna vários conjuntos de registros para uso em um aplicativo. Às vezes, alguns desses conjuntos de registros estão vazios.

Eu gostaria de reduzir a sobrecarga e retornar apenas aqueles que têm 1 ou mais linhas.

Minha pergunta é - Como posso retornar apenas os conjuntos de registros que possuem linhas?

O aplicativo simplesmente espera 0 ou mais conjuntos de registros, faz um loop em cada um e os imprime.

Eu sei que posso ignorá-los no código do aplicativo, mas estou tentando impedir que eles sejam retornados, se estiverem vazios.

O procedimento é tão simples quanto isto:

CREATE PROCEDURE bfsp_PROC_NM
AS 

    BEGIN

        SELECT * FROM TABLE_1

        SELECT * FROM TABLE_2

        SELECT * FROM TABLE_3

        RETURN  

    END
GO

No procedimento real, algumas das consultas são caras, então eu não quero ter que testar a consulta, então se ela retornar uma linha ou mais, execute-a novamente... pois seria muito caro.

Eu tenho duas tabelas, ambas com tipos de dados idênticos, conjuntos de caracteres e agrupamento explicitamente especificados.

CLERK CHAR(3) CHARACTER SET latin1 COLLATE latin1_bin NULL

Para uma junção que diferencia maiúsculas de minúsculas no CLERKcampo, preciso especificar a ordenação na cláusula de junção também ou o fato de ela ser especificada no nível DDL significa que ela não é necessária na junção?

FROM
    CUSTOMER S JOIN 
    CLERK C ON S.CLERK = C.CLERK COLLATE latin1_bin

Estou trabalhando com dados que têm um valor de id de sessão que é reciclado ao longo do tempo (ids de sessão asp do IIS para ser exato).

Estou tentando dar a eles uma sequência para que cada instância de um ASP_SESSION_ID não seja agrupada.

Por exemplo, os dados ficariam assim. Mesma ID de sessão, usada em agosto de 2016 e novamente em março de 2017.

DTTM                        SESSION_ID
2016-08-29 14:24:28.450     297692378
2017-04-13 23:54:53.760     297692378
2017-04-13 23:59:53.477     297692378
2017-04-14 00:04:52.897     297692378
2017-04-14 00:04:53.790     297692378

A princípio, pensei em agrupar apenas na data (no nível DAY), mas para o exemplo acima, observe como a segunda instância do ID da sessão abrange a meia-noite. Isso causaria um 3º grupo, quando na verdade é a mesma sessão.

Então, se eu pudesse classificá-los corretamente, seria:

DTTM                        SESSION_ID      RANK
2016-08-29 14:24:28.450     297692378       1
2017-04-13 23:54:53.760     297692378       2
2017-04-13 23:59:53.477     297692378       2
2017-04-14 00:04:52.897     297692378       2
2017-04-14 00:04:53.790     297692378       2

Aqui, ASP_SESSION_ID deve ser considerado uma nova instância de uma sessão quando > 20 minutos se passaram desde a última solicitação.

Então, como posso agrupar ou classificar o mesmo ASP_SESSION_ID de maneira diferente à medida que eles são reutilizados ao longo do tempo? por exemplo, se a próxima solicitação desse ASP_SESSION_ID for > 20 minutos da última, agrupe-a/classifique-a de forma diferente?

Só não sei como atacar o problema.

Aqui estão algumas declarações para gerar os dados acima:

CREATE TABLE #TEST
(
DTTM DATETIME, 
SESSION_ID INT
)

INSERT INTO #TEST (DTTM, SESSION_ID)
select '2016-08-29 14:24:28.450', 297692378 union
select '2017-04-13 23:54:53.760', 297692378 union
select '2017-04-13 23:59:53.477', 297692378 union
select '2017-04-14 00:04:52.897', 297692378 union
select '2017-04-14 00:04:53.790', 297692378 

Qual seria o melhor tipo de dados para armazenar os resultados do HASHBYTES('MD5', ...)?

Ele produz 16 bytes de binário da seguinte forma: por exemplo

0x5CFCD77F9FF836189D2F647EBCEA183E

Eu poderia armazená-lo nos seguintes tipos de dados:

• char(34)
• binary(16)(Eu acho - eu li aqui ( https://stackoverflow.com/questions/14722305/what-kind-of-datatype-should-one-use-to-store-hashes#16680423 ) que usar o mesmo algo deve retornar o mesmo número de bytes todas as vezes, independentemente da string de entrada)
• outro?

Cada linha terá um valor (sem nulos) e a coluna será usada para comparação com uma coluna semelhante em outra tabela.

Qual é o melhor tipo de dados para armazenar a HASHBYTESsaída para uso conforme descrito acima?

Eu estava pensando que, como os tipos de dados de comprimento fixo às vezes podem ser mais eficientes em junções, etc. binary(16)vs varbinary(8000)(a saída padrão de HASHBYTES) parece melhor, e binary(16)vs a varchar(34)é melhor, pois usaria menos espaço de armazenamento.

Eu tenho uma coluna que tem informações de data, hora e fuso horário como esta:

Sat, 20 Aug 2016 03:50:04 CDT
Sun, 17 Sep 2017 16:51:46 CEST
Mon, 09 Oct 2017 06:43:27 CET
Thu, 28 Sep 2017 14:05:23 IST
Thu, 05 Oct 2017 08:59:01 IDT
Wed, 28 Jun 2017 17:10:22 CEST
Mon, 18 Sep 2017 18:32:52 GMT
Sat, 27 Aug 2016 07:06:22 MEST
Sat, 06 Aug 2016 13:17:09 UTC
Sat, 16 Jul 2016 23:53:02 PDT

Eu quero normalizar tudo isso para UTC.

Eu posso remover os 5 caracteres principais e a string de fuso horário à direita, e eles convertem para datetime muito bem ... mas minha pergunta é:

O SQL Server tem alguma função embutida onde eu possa passar a data e hora, a string de fuso horário de origem, por exemplo PDT, e uma string de fuso horário de destino, por exemplo UTC, e ele lidará com a conversão?

Estou pensando em algo semelhante ao que a Oracle tem:

FROM_TZ(YOUR_TIMESTAMP, 'UTC') AT TIME ZONE 'America/Dawson_Creek'

Espero poder fazer isso sem ter que manter uma tabela de deslocamentos de fuso horário para mapear os valores de string para um deslocamento. Eu também não quero codificar os deslocamentos em alguma declaração de maiúsculas e minúsculas.

Estou no sql server 2014, então não posso usar o novo select * from sys.time_zone_infopara informações de fuso horário que vem em 2016.

Alguma ideia?

Eu tenho uma varcharcoluna em uma tabela no SQL Server que contém uma string de texto codificada em base64 que eu gostaria de decodificar em seu equivalente de texto simples

O SQL Server tem alguma funcionalidade nativa para lidar com esse tipo de coisa?

Uma string base64 de amostra:

cm9sZToxIHByb2R1Y2VyOjEyIHRpbWVzdGFtcDoxNDY4NjQwMjIyNTcxMDAwIGxhdGxuZ3tsYXRpdHVkZV9lNzo0MTY5ODkzOTQgbG9uZ2l0dWRlX2U3Oi03Mzg5NjYyMTB9IHJhZGl1czoxOTc2NA==

Que decodifica para:

role:1 producer:12 timestamp:1468640222571000 latlng{latitude_e7:416989394 longitude_e7:-738966210} radius:19764

Digamos que temos uma tabela onde cada linha é um dia, e é ordenada por esta coluna de dia. Em seguida, deixamos um conjunto de dados de associação que mostra em que dia os membros estavam ativos (e não).

Digamos que nosso conjunto de dados atual seja assim... A associação estava ativa do dia 3 ao 5, inativa do dia 5 ao 8 e ativa do dia 9 em diante, etc.

DAY     DATE        MEMBER  ACTIVE
 1      2017-01-01  123     null
 2      2017-01-02  123     null
 3      2017-01-03  123     2017-01-03
 4      2017-01-04  123     2017-01-04
 5      2017-01-05  123     2017-01-05
 6      2017-01-06  123     null
 7      2017-01-07  123     null
 8      2017-01-08  123     null
 9      2017-01-09  123     2017-01-09
10      2017-01-10  123     2017-01-10

...então ACTIVE=nullsignifica que a associação não estava ativa naqueles dias.

Com esta estrutura de dados, gostaria de chegar a um conjunto "recolhido", mostrando "spans" de tempo inativo/ativo:

MEMBER  MIN(DATE)   MAX(DATE)   STATUS
123,    2017-01-01, 2017-01-02  INACTIVE
123,    2017-01-03, 2017-01-05  ACTIVE
123,    2017-01-06, 2017-01-08  INACTIVE
123,    2017-01-09, 2017-01-10  ACTIVE

Eu tentei usar row_number() para de alguma forma particionar os subconjuntos de um determinado status, mas neste caso, usando min()/ max()sobre as linhas em que ACTIVE é nulo, trata-as como um único grupo, quando na realidade existem vários intervalos distintos de "associação inativa".

Como posso distinguir os períodos de associação inativa uns dos outros para fins de agrupamento? Que técnica posso usar para obter essa saída acima?

Aqui está o script para gerar os dados de origem fictícios:

CREATE TABLE ##SRC (ID INT, D DATE, MEMBER INT, ACTIVE DATE);

INSERT INTO ##SRC (ID, D, MEMBER, ACTIVE)
SELECT 1, '2017-01-01', 123, NULL UNION 
SELECT 2, '2017-01-02', 123, NULL UNION 
SELECT 3, '2017-01-03', 123, '2017-01-03' UNION 
SELECT 4, '2017-01-04', 123, '2017-01-04' UNION 
SELECT 5, '2017-01-05', 123, '2017-01-05' UNION 
SELECT 6, '2017-01-06', 123, NULL UNION 
SELECT 7, '2017-01-07', 123, NULL UNION 
SELECT 8, '2017-01-08', 123, NULL UNION 
SELECT 9, '2017-01-09', 123, '2017-01-09' UNION 
SELECT 10, '2017-01-10',    123, '2017-01-10' 
;

A documentação do BOL diz que a permissão sysadmin é necessária para executar o depurador.

Tenho 90% de certeza de que não há solução alternativa para esse requisito, mas pensei em perguntar caso alguém encontrasse uma maneira de conceder permissão ao Debugger sem conceder permissão ao administrador do sistema.

O que as pessoas fazem quando você tem uma equipe de desenvolvedores precisando passar por um loop de cursor complicado com variáveis, etc., para depurar algum aspecto disso?

A maioria das lojas não permite que os desenvolvedores tenham permissão sysadmin mesmo em servidores de desenvolvimento, e muitos não permitem que os desenvolvedores mantenham uma cópia dos dados corporativos em sua máquina local com sua própria edição do servidor sql do desenvolvedor, por exemplo, devido a PII e razões de segurança de dados.

Não tenho certeza por que o depurador seria configurado dessa maneira.

Então, estou curioso para saber como outras pessoas lidam com as solicitações de permissão do Debugger em um cenário semelhante.

O que você faz no seu ambiente?

Ao aprender como obter a data de um dia da semana da semana anterior (por exemplo, a data de segunda-feira da semana anterior), encontrei as duas expressões a seguir geralmente, onde você altera o último número (por exemplo, 0 = segunda-feira) dependendo do dia que você deseja:

SELECT DATEADD(wk, DATEDIFF(wk, 6, GETDATE()), 0)

SELECT DATEADD(wk, DATEDIFF(wk, 7, GETDATE()), 0)

Ambos parecem retornar a data correta 2017-05-29quando eu o executo hoje (2017-06-17).

Minha pergunta é - como isso funciona? Parece estar contando semanas desde 6ou 7semanas depois 1900-01-01? E por que funciona com a 6e 7?

Além disso, existem casos extremos que você precisaria estar ciente de onde pode não fornecer os resultados esperados?

Qual é a melhor maneira de indexar uma coluna para uma pesquisa eficiente com base em uma comparação bit a bit na cláusula WHERE, por exemplo

SELECT ID, FLAGS, NAME FROM TABLE WHERE FLAGS & 4 = 4

Estou em um ambiente SQL Server 2012.

Entendo que um índice na coluna FLAGS não será usado neste tipo de consulta.

Sei que a outra opção é dividir a coluna FLAGS em colunas individuais, mas queria evitar isso porque, em alguns casos, isso significaria mais de 25 novas colunas, cada uma das quais precisaria de uma combinação de índices para dar suporte às consultas comuns.

Existem maneiras de indexar a coluna única para que as consultas bit a bit sejam mais eficientes?

Tentei usar uma coluna computada com um índice conforme sugerido pelo dudu abaixo, mas quando usei em uma tabela que possui um índice clusterizado e comecei a selecionar colunas (ao invés de apenas selecionar count(*) ele não usa mais o índice naquela nova coluna calculada.

SELECT 
* 
INTO 
    MYTABLE
FROM 
(
    SELECT 'A' COL_A, 'A' COL_B, CAST(129 AS INT) FLAGS UNION
    SELECT 'B' COL_A, 'D' COL_B, CAST(129 AS INT) FLAGS UNION
    SELECT 'C' COL_A, 'S' COL_B, CAST(129 AS INT) FLAGS UNION
    SELECT 'D' COL_A, 'F' COL_B, CAST(129 AS INT) FLAGS UNION
    SELECT 'E' COL_A, 'T' COL_B, CAST(128 AS INT) FLAGS UNION
    SELECT 'F' COL_A, 'D' COL_B, CAST(128 AS INT) FLAGS UNION
    SELECT 'G' COL_A, 'D' COL_B, CAST(128 AS INT) FLAGS UNION
    SELECT 'H' COL_A, 'X' COL_B, CAST(128 AS INT) FLAGS 
) SRC

CREATE CLUSTERED INDEX IX_CLU_A ON MYTABLE(COL_A)



ALTER TABLE MYTABLE ADD FLAG_BIT_1 AS (CAST ((FLAGS & 1) AS BIT))
CREATE INDEX MYTABLE_IX_FLAG_BIT_1 ON MYTABLE (FLAG_BIT_1)

SELECT * FROM MYTABLE WHERE FLAGS & 1 = 1
SELECT * FROM MYTABLE WHERE FLAG_BIT_1 = 1

SELECT COUNT(*) FROM MYTABLE WHERE FLAGS & 1 = 1
SELECT COUNT(*) FROM MYTABLE WHERE FLAG_BIT_1 = 1

Estou em um ambiente SQL Server 2008.

Estou tentando usar a correspondência de padrões na WHEREcláusula para localizar linhas em que o valor de uma determinada coluna contém caracteres que não são alfanuméricos, sublinhado, traço, ponto ou espaço.

Este é o meu código e dados de amostra, mas não estou obtendo os resultados esperados.

Nos dados de exemplo, quero retornar as linhas 7, 8, 9 e 12, mas estou obtendo as linhas 5 e 6.

Se esta não for a melhor maneira de atingir o objetivo, estou aberto a ouvir outros métodos.

Não estou em um ambiente em que possa implementar regex, portanto, minha solução está limitada à funcionalidade pronta para uso.

CREATE TABLE PATTERN_TEST
(
ID INT NOT NULL,
STRING NVARCHAR(40) NOT NULL
)

INSERT INTO PATTERN_TEST
SELECT 1, 'string' UNION 
SELECT 2, 'STRING' UNION 
SELECT 3, 'string space' UNION 
SELECT 4, 'STRING SPACE' UNION 
SELECT 5, 'string-dash' UNION 
SELECT 6, 'string-dash space' UNION 
SELECT 7, 'string "otherchar"' UNION 
SELECT 8, 'string "other char"' UNION 
SELECT 9, '"string"' UNION 
SELECT 10, 'string_underscore' UNION 
SELECT 11, 'string_underscore space' UNION
SELECT 12, '"'
;

SELECT * FROM PATTERN_TEST WHERE STRING LIKE '%[^a-zA-Z0-9_ -.]%';

Estou tentando encontrar uma maneira de converter uma data de string rfc822 (com fuso horário) em um valor GMT do tipo de dados DATETIME ou um registro de data e hora unix do tipo de dados INT. Por exemplo:

Mon, 15 Aug 2016 11:36:36 UTC
Mon, 29 Aug 2016 04:37:10 GMT
Wed, 27 Jul 2016 14:41:05 UTC

Acredito que as porções "UTC" e "GMT" realmente significam a mesma coisa e, para meu caso de uso específico, acredito que esses são os únicos dois valores de fuso horário que verei.

Estou trabalhando em um ambiente SQL Server 2008r2.

A única coisa que estou encontrando para fazer isso é a função abaixo, mas quero evitar isso por alguns motivos:

• Ele usa deslocamentos codificados
• Ele precisa de acesso de leitura de registro (que acho que não terei com meu provedor de hospedagem)
• Espero não ter uma dependência de uma função definida pelo usuário

Existem maneiras mais simples e fáceis de realizar essa conversão? Melhor ainda seria algo que eu pudesse usar nativamente no T-SQL em vez de criar uma dependência de função.

CREATE FUNCTION udf_ConvertTime (
    @TimeToConvert  varchar(80),
    @TimeZoneTo     varchar(8)
)
RETURNS DateTime
AS
BEGIN
    DECLARE @dtOutput       datetime,
            @nAdjust        smallint,
            @hh             smallint,
            @Loc            smallint,
            @FromDate       datetime,
            @mm             smallint,
            @Ndx            tinyint,
            @TimeZoneFrom   varchar(80),
            @WkTime         varchar(80)

    SET @TimeZoneTo = ISNULL(@TimeZoneTo, 'LOCAL')

    /* ------------------------------------------------------------------------ */
    /*  Important: If you want to convert to your local time, the following is  */
    /*  necessary to handle daylight savings time. Your SQLServer installation  */
    /*  must allow this function to execute xp_regread.                         */
    /* ------------------------------------------------------------------------ */

    SET @Loc = CONVERT(smallint, DATEDIFF(hh, GETUTCDATE(), GETDATE()) * 60)
    IF @TimeZoneTo = 'LOCAL'
    BEGIN
        DECLARE @root VARCHAR(32),
                @key  VARCHAR(128),
                @StandardBias VARBINARY(8),
                @DaylightBias VARBINARY(8)
        SET @root = 'HKEY_LOCAL_MACHINE'
        SET @key  = 'SYSTEM\CurrentControlSet\Control\TimeZoneInformation'
        EXEC master..xp_regread @root, @key, 'StandardBias', @StandardBias OUTPUT
        EXEC master..xp_regread @root, @key, 'DaylightBias', @DaylightBias OUTPUT
        IF @StandardBias <> @DayLightBias
            SET @Loc = @Loc - 60
    END

    /* ------------------------------------------------------------------------ */
    /*  Build a temporary table of timezone conversions.                        */
    /* ------------------------------------------------------------------------ */

    DECLARE @Temp TABLE (
        TimeZone varchar(8),
        nOffset  smallint )

    INSERT INTO @Temp
    SELECT 'A',     60  UNION ALL
    SELECT 'ACDT', 630  UNION ALL
    SELECT 'ACST', 570  UNION ALL
    SELECT 'ADT', -180  UNION ALL
    SELECT 'AEDT', 660  UNION ALL
    SELECT 'AEST', 600  UNION ALL
    SELECT 'AKDT',-480  UNION ALL
    SELECT 'AKST',-540  UNION ALL
    SELECT 'AST', -240  UNION ALL
    SELECT 'AWDT', 540  UNION ALL
    SELECT 'AWST', 480  UNION ALL
    SELECT 'B',    120  UNION ALL
    SELECT 'BST',   60  UNION ALL
    SELECT 'C',    180  UNION ALL
    SELECT 'CDT', -300  UNION ALL
    SELECT 'CEDT', 120  UNION ALL
    SELECT 'CEST', 120  UNION ALL
    SELECT 'CET',   60  UNION ALL
    SELECT 'CST', -360  UNION ALL
    SELECT 'CXT',  420  UNION ALL
    SELECT 'D',    240  UNION ALL
    SELECT 'E',    300  UNION ALL
    SELECT 'EDT', -240  UNION ALL
    SELECT 'EEDT', 180  UNION ALL
    SELECT 'EEST', 180  UNION ALL
    SELECT 'EET',  120  UNION ALL
    SELECT 'EST', -300  UNION ALL
    SELECT 'F',    360  UNION ALL
    SELECT 'G',    420  UNION ALL
    SELECT 'GMT',    0  UNION ALL
    SELECT 'H',    480  UNION ALL
    SELECT 'HAA', -180  UNION ALL
    SELECT 'HAC', -300  UNION ALL
    SELECT 'HADT',-540  UNION ALL
    SELECT 'HAE', -240  UNION ALL
    SELECT 'HAP', -420  UNION ALL
    SELECT 'HAR', -360  UNION ALL
    SELECT 'HAST',-600  UNION ALL
    SELECT 'HAT', -150  UNION ALL
    SELECT 'HAY', -480  UNION ALL
    SELECT 'HNA', -240  UNION ALL
    SELECT 'HNC', -360  UNION ALL
    SELECT 'HNE', -300  UNION ALL
    SELECT 'HNP', -480  UNION ALL
    SELECT 'HNR', -420  UNION ALL
    SELECT 'HNT', -210  UNION ALL
    SELECT 'HNY', -540  UNION ALL
    SELECT 'I',    540  UNION ALL
    SELECT 'IST',   60  UNION ALL
    SELECT 'K',    600  UNION ALL
    SELECT 'L',    660  UNION ALL
    SELECT 'LOC',  @Loc UNION ALL
    SELECT 'LOCAL',@Loc UNION ALL
    SELECT 'M',    720  UNION ALL
    SELECT 'MDT', -360  UNION ALL
    SELECT 'MESZ', 120  UNION ALL
    SELECT 'MEZ',   60  UNION ALL
    SELECT 'MST', -420  UNION ALL
    SELECT 'N',    -60  UNION ALL
    SELECT 'NDT', -150  UNION ALL
    SELECT 'NFT',  690  UNION ALL
    SELECT 'NST', -210  UNION ALL
    SELECT 'O',   -120  UNION ALL
    SELECT 'P',   -180  UNION ALL
    SELECT 'PDT', -420  UNION ALL
    SELECT 'PST', -480  UNION ALL
    SELECT 'Q',   -240  UNION ALL
    SELECT 'R',   -300  UNION ALL
    SELECT 'S',   -360  UNION ALL
    SELECT 'T',   -420  UNION ALL
    SELECT 'U',   -480  UNION ALL
    SELECT 'UTC',    0  UNION ALL
    SELECT 'V',   -540  UNION ALL
    SELECT 'W',   -600  UNION ALL
    SELECT 'WEDT',  60  UNION ALL
    SELECT 'WEST',  60  UNION ALL
    SELECT 'WET',    0  UNION ALL
    SELECT 'WST',  540  UNION ALL
    SELECT 'WST',  480  UNION ALL
    SELECT 'X',   -660  UNION ALL
    SELECT 'Y',   -720  UNION ALL
    SELECT 'Z',      0

    /* ------------------------------------------------------------------------ */
    /*  If timezone is embedded within @TimeToConvert, separate it out. If we   */
    /*  can at all convert this date with SQL, do it.                           */
    /* ------------------------------------------------------------------------ */

    SET @Ndx = CHARINDEX(' ', REVERSE(@TimeToConvert))
    IF @Ndx > 0
    BEGIN
        SET @TimeZoneFrom = RIGHT(@TimeToConvert, @Ndx - 1)

        IF 'TRUE' = CASE
                        WHEN @TimeZoneFrom LIKE '[0-9][0-9][0-9][0-9]' THEN 'TRUE'
                        WHEN @TimeZoneFrom LIKE '[+][0-9][0-9][0-9][0-9]' THEN 'TRUE'
                        WHEN @TimeZoneFrom LIKE '[-][0-9][0-9][0-9][0-9]' THEN 'TRUE'
                        ELSE 'FALSE'
                    END
        BEGIN   -- This has already converted offset hhmm
            SET @hh = CONVERT(smallint, LEFT(@TimeZoneFrom, LEN(@TimeZoneFrom) - 2))
            SET @mm = CONVERT(smallint, RIGHT(@TimeZoneFrom, 2))
            SET @nAdjust = (@hh * 60) + @mm
            SET @TimeToConvert = LEFT(@TimeToConvert, LEN(@TimeToConvert) - @Ndx)
        END
        ELSE
        IF EXISTS (SELECT 1 FROM @Temp
                   WHERE  TimeZone = @TimeZoneFrom)
            SET @TimeToConvert = LEFT(@TimeToConvert, LEN(@TimeToConvert) - @Ndx)
        ELSE
            SET @TimeZoneFrom = NULL
    END

    IF ISDATE(@TimeToConvert) = 1
        SET @FromDate = CONVERT(datetime, @TimeToConvert)

    SET @TimeZoneFrom = ISNULL(@TimeZoneFrom, 'LOCAL')

    /* ------------------------------------------------------------------------ */
    /*  We are providing a varchar(80) date field to facilitate RFC822 dates.   */
    /* ------------------------------------------------------------------------ */

    IF @FromDate IS NULL
    BEGIN
        SET @Ndx  = 1

        SET @WkTime = REPLACE(@TimeToConvert, ',', '')
        SET @WkTime = REVERSE(
                        SUBSTRING(
                            REVERSE(
                                SUBSTRING(@WkTime, 5, LEN(@WkTime))
                                   ), @Ndx, LEN(@WkTime)))

        IF CHARINDEX(' ', @WkTime)     = 4  AND
           CHARINDEX(' ', @WkTime, 5)  = 7  AND
           CHARINDEX(':', @WkTime, 8)  = 10 AND
           CHARINDEX(':', @WkTime, 11) = 13 -- Means we have no year
            SET @WkTime = LEFT(@WkTime, 7) + CONVERT(varchar(5), YEAR(GETDATE())) + SUBSTRING(@WkTime, 7, 40)

        IF ISDATE(@WkTime) = 1
            SET @FromDate = CONVERT(datetime, @WkTime)
    END

    IF @FromDate IS NULL
        RETURN @FromDate

    /* ------------------------------------------------------------------------ */
    /*  If the from and to are the same, we need go no further.                 */
    /* ------------------------------------------------------------------------ */

    IF ISNULL(@TimeZoneFrom, '') IN (ISNULL(@TimeZoneTo, ''), ISNULL(@TimeZoneTo, 'LOCAL'))
        RETURN @FromDate

    /* ------------------------------------------------------------------------ */
    /*  Return the difference between the from/to timezones.                    */
    /* ------------------------------------------------------------------------ */

    IF @nAdjust IS NULL
    BEGIN
        SELECT @nAdjust = nOffset
        FROM   @Temp
        WHERE  timeZone = @TimeZoneFrom

        IF EXISTS (SELECT 1 FROM @Temp
                   WHERE  timeZone = @TimeZoneTo)
            SELECT @nAdjust = nOffset - @nAdjust
            FROM   @Temp
            WHERE  timeZone = @TimeZoneTo
    END

    SET @dtOutput = DATEADD(n, ISNULL(@nAdjust, 0), @FromDate)
    RETURN @dtOutput
END

No SQL Server 2008, por que isso retorna a linha, mesmo quando adiciono um espaço em branco, ou dois, ou mais, ao final da cláusula where? registros zero não deveriam ser encontrados no exemplo a seguir?

WITH SRC AS (SELECT cast('12345' as varchar) DEMO)
SELECT * FROM SRC WHERE DEMO='12345  '

E se alguém precisar consultar para encontrar, '1234 'mas não'1234'

Eu tenho três colunas, CITY, STATE, COUNTRY. Uma, duas ou todas as colunas podem ser NULL.

Com a seguinte lógica, uma única string é feita usando o SQL abaixo. É confuso e estou me perguntando se existe uma maneira mais simples de obter a saída? Eu considerei CONCAT (), mas não acho que posso usar isso e ainda colocar os separadores lá.

• se CITY e STATE tiverem um valor, use-o, separado por ', '. Excluir PAÍS.
• se existir apenas um de CIDADE ou ESTADO, E existir um País, use o de CIDADE/ESTADO que existe, mais o separador e o PAÍS.
• se não houver CIDADE nem ESTADO, use apenas o país sem separador
• se apenas um dos três existir, use-o como está, sem separador
• Se nenhum existir, a saída deve ser NULL (não '')

Acrescentarei que, se existir um valor CITY e/ou STATE, COUNTRY nunca será NULL.

Aqui está o código até agora. É confuso, mas acredito que atende aos requisitos de saída listados acima.

Estou trabalhando no SQL Server 2008.

CASE WHEN 
    CASE WHEN ISNULL(M.CITY, '') = '' THEN  '' ELSE ISNULL(M.CITY, '') + ', ' END + CASE WHEN ISNULL(M.PROVINCE, '') = '' THEN  '' ELSE ISNULL(M.PROVINCE, '') END

     = '' THEN CASE WHEN COUNTRY IS NOT NULL THEN COUNTRY ELSE NULL END ELSE 

     CASE WHEN ISNULL(M.CITY, '') = '' THEN  '' ELSE ISNULL(M.CITY, '') + ', ' END + CASE WHEN ISNULL(M.PROVINCE, '') = '' THEN  '' ELSE ISNULL(M.PROVINCE, '') END 
END 
+ 
CASE
    WHEN (M.CITY IS NULL AND M.PROVINCE IS NOT NULL) OR (M.CITY IS NOT NULL AND M.PROVINCE IS NULL) THEN 
        CASE WHEN PROVINCE IS NOT NULL AND CITY IS NULL THEN ', ' ELSE '' END + COUNTRY
    ELSE '' 
END 
LOCATION 

Estou trabalhando com o SQL Server 2008 e estou procurando uma função como ltrime rtrimque também remova guias iniciais e finais, espaços duplos, retornos de carro, alimentações de linha, etc.

Existem várias funções por aí, mas todas as que encontrei têm limitações, por exemplo, truncar a string para 8.000 caracteres. por exemplo (de acordo com alguns dos comentários):

SQL SERVER – 2008 – Função TRIM() aprimorada – Remover espaços à direita, espaços iniciais, espaço em branco, tabulações, retornos de carro, feeds de linha

Um dos comentários propôs uma solução melhor, mas - 1causa um incorrect syntaxerro e não sei por quê.

CREATE FUNCTION dbo.SuperTrimLeft(@str varchar(MAX)) RETURNS varchar(MAX)
    AS
    BEGIN
    IF (ASCII(LEFT(@str, 1)) < 33) BEGIN
        SET @str = STUFF(@str, 1, PATINDEX('%[^'+CHAR(0)+'-'+CHAR(32)+']%', @str) – 1, ' ');
    END;

    RETURN @str;
END;

Então, minha pergunta é: qual é a melhor abordagem para realizar a tarefa acima?

No SQL Server (2008), tenho uma coluna que é varchar(max).

Desejo consultar todas as linhas em que a sinopse contém uma lista com letras:

Some sentence is here

a. foo
b. bar
c. baz

Some more text later

Posso fazer isso facilmente em expressões regulares, mas não tenho acesso para adicionar recursos de regex à minha instância.

Então, como posso pesquisar usando LIKE para encontrar algo assim? Presumivelmente, eu precisaria descobrir onde o primeiro caractere da linha (em uma sinopse de várias linhas) é um caractere e o segundo é um ponto.

Sou novo na tecnologia Oracle (principalmente versado em SQL Server) e estou tendo problemas com o desempenho de uma UDF.

O objetivo da UDF é obter algumas entradas para um "evento" e procurar um "tempo esperado para a ocorrência do evento b". A função retorna um único DATEvalor.

A primeira coisa que ocorre é SELECT ... INTO [variable] FROM DUAL;uma variável. Por fim, ocorre uma pesquisa em uma tabela de referência (apenas ~ 30k linhas) e é armazenada na variável de retorno.

Demorou 8 horas para processar em 800 mil linhas. Posso selecionar todas as colunas sem usar a função em menos de 40 segundos.

Minha principal dúvida é: O uso do DUAL está me custando caro?

Estamos em um Oracle 11g RAC.

Estou exportando uma tabela para um arquivo TSV usando sqlcmd e estou tendo problemas. A tabela tem mais de 16 milhões de linhas e cerca de 55 colunas.

O problema é que ele não exporta a tabela completa, mas parece parar aleatoriamente em vários pontos (suponho que seja um tempo limite?) Cada vez que um número diferente de linhas é exportado e cada vez que o arquivo tem um tamanho ligeiramente diferente (indicando que não estou atingindo nenhum limite de linha ou tamanho).

Não estou usando nenhuma chave de tempo limite (o que significa que o padrão "o tempo que for necessário" é usado).

Aqui está o meu comando (com a maioria das colunas removidas para fins de simplificação e ilustração):

sqlcmd -U myUsername -P myPassword -S SERVERNAME -d "DBNAME" -Q "SELECT ROW_KEY, ISNULL(CARRIER_ID, ''),ISNULL(CONVERT(VARCHAR(19),ORDER_DATETIME,120),''),ISNULL(HEIGHT, ''),ISNULL(RESIDENTIAL_CHARGE, '') FROM MYTABLE" -o "OUTPUT_FILE.txt" -h-1 -s"|" -W

Gostaria de saber se poderia ter algo a ver com tempos limite ou o uso de ISNULL () em todas as colunas (embora quando executo a consulta no sql server management studio recebo o número correto de linhas retornadas, por exemplo, 16 milhões +)?

Mais uma vez, recebo cerca de 4 a 8 milhões de linhas de cada vez, mas nunca o valor total. Estou em um sql server 2k5 db e executando o sqlcmd de uma máquina remota com sql server 2k8.

Eu tenho uma consulta que atinge várias tabelas em um banco de dados Oracle (11g). Não tenho acesso ao próprio servidor. Eu uso o SQL Developer ou SQL*Plus para conectar.

Existem cerca de 31 milhões de linhas e 7 colunas, e quero despejá-las em um arquivo CSV.

Como posso conseguir isso?

Gostaria de saber se existe uma solução igualmente elegante para Oracle para o problema postado e respondido aqui:

Comparando colunas que podem conter NULLS - existe uma maneira mais elegante?

Não consigo fazer com que esta solução (a que foi aceita) funcione em ambiente Oracle.