Arquivo da tag: Split

Short Scripts – Setembro 2018


Buenos dias, bom dia, comunidade….

E ai como passaram os últimos meses?

Pergunto isso, devido ao post anterior desta sessão ter sido publicado no mês de maio, posso imaginar que neste intervalo de tempo nossas vidas apresentaram inúmeras situações, espero que todas possam ter sido dentro do possível boas, assim como a minha, e se caso venha a existir algo mais espinhoso, que você possa ter superado.

Seguindo em frente, que alegria poder te encontrar em mais um post da sessão Short Scripts, uma das sessões mais recentes do meu blog que esta alçando a marca de 34 posts publicados trimestralmente.

Mantendo a tradição estou retornando com mais um conjunto de “pequenos” scripts catalogados e armazenados em minha biblioteca pessoal de códigos relacionados ao Microsoft SQL Server e sua fantástica linguagem de desenvolvimento Transact-SQL.

Como promessa é dívida e deve ser cumprida “ou melhor” compartilhada, estou compartilhando a minha feita a alguns meses no final do último post desta sessão, publicando mais um conjunto de scripts adicionados atualmente na minha biblioteca particular de códigos e exemplos.

O post de hoje

Normalmente compartilhado os principais scripts armazenados nos últimos meses, no post de hoje vou fazer um pouco diferente, recentemente tive a necessidade de realizar alguns atividades relacionadas as Split de dados e Collation, sendo assim, decide então compartilhar alguns códigos que estejam envolvidos com estes assuntos e que também se vinculem com outros, dentre os quais destaco:

  • Collate Column,
  • Collate,
  • Collation,
  • Database Collate,
  • Database Collation,
  • Instâncias Microsoft SQL Server,
  • Junção de Tabelas,
  • Page Split,
  • Server Collation,
  • Servidores Microsoft SQL Server,
  • String Split,
  • User Defined Function, e
  • Valores separados por vírgulas.

Chegou a hora, mãos nos teclados, a seguir apresento os códigos e exemplos selecionados para o Short Script – Setembro 2018 . Vale ressaltar que todos os scripts publicados nesta sessão foram devidamente testados, mas isso não significa que você pode fazer uso dos mesmo em seu ambiente de produção, vale sim todo cuidado possível para evitar maiores problemas.

Fique a vontade para compartilhar, comentar e melhorar cada um destes códigos.

Short Scripts

— Short Script 1  – Identificando Page Split – Método 1  —
SELECT cntr_value
FROM sys.sysperfinfo
WHERE counter_name =’Page Splits/sec’ AND
OBJECT_NAME LIKE’%Access methods%’
Go

— Short Script 2  – Identificando Page Split – Método 2  —
SELECT object_name,
counter_name,
instance_name,
cntr_value, cntr_type

FROM sys.dm_os_performance_counters
WHERE counter_name =’Page Splits/sec’ AND
OBJECT_NAME LIKE’%Access methods%’
Go

— Short Script 3  – Criando um User Defined Function para separação de Strings por vírgula  – Método 1 —
CREATE FUNCTION dbo.UFN_SEPARATES_COLUMNS(@TEXT1 varchar(8000), @COLUMN tinyint, @SEPARATOR char(1))
RETURNS varchar(8000)
AS
BEGIN
DECLARE @POS_START int = 1
DECLARE @POS_END int = CHARINDEX(@SEPARATOR, @TEXT, @POS_START)

WHILE (@COLUMN >1 AND @POS_END> 0)
BEGIN
SET @POS_START = @POS_END + 1
SET @POS_END = CHARINDEX(@SEPARATOR, @TEXT, @POS_START)
SET @COLUMN = @COLUMN – 1
END

IF @COLUMN > 1 SET @POS_START = LEN(@TEXT) + 1
IF @POS_END = 0 SET @POS_END = LEN(@TEXT) + 1

RETURN SUBSTRING (@TEXT, @POS_START, @POS_END – @POS_START)
END
Go

SELECT
dbo.UFN_SEPARATES_COLUMNS(@ISBN, 1, ‘-‘) AS PREFIX,
dbo.UFN_SEPARATES_COLUMNS(@ISBN, 2, ‘-‘) AS REGISTRATION_GROUP,
dbo.UFN_SEPARATES_COLUMNS(@ISBN, 3, ‘-‘) AS REGISTRANT,
dbo.UFN_SEPARATES_COLUMNS(@ISBN, 4, ‘-‘) AS PUBLICATION,
dbo.UFN_SEPARATES_COLUMNS(@ISBN, 5, ‘-‘) AS [CHECK]
Go

— Short Script 4  – Criando um User Defined Function para separação de Strings por vírgula – Método 2  —

Create FUNCTION [dbo].[fnSplitString]
(
@string NVARCHAR(MAX),
@delimiter CHAR(1)
)
RETURNS @output TABLE(splitdata NVARCHAR(MAX)
)
BEGIN
DECLARE @start INT, @end INT
SELECT @start = 1, @end = CHARINDEX(@delimiter, @string)
WHILE @start < LEN(@string) + 1 BEGIN
IF @end = 0
SET @end = LEN(@string) + 1

INSERT INTO @output (splitdata)
VALUES(SUBSTRING(@string, @start, @end – @start))
SET @start = @end + 1
SET @end = CHARINDEX(@delimiter, @string, @start)

END
RETURN
END

Select * from dbo.fnSplitString(‘Querying SQL Server’,”)
Go

— Short Script 5  – Informando o Collate de uma coluna na cláusula Where  —
S
elect campo
From tabela
Where campo collate Latin_General_CI_AS like ‘%á%’
Go

— Short Script 6  – Informando o Collate na declaração de uma coluna e na cláusula Where  —
Select Campo collate Latin_General_CI_AS
From tabela
Where Campo collate Latin_General_CI_AS like ‘%á%’
Go

— Short Script 7  – Alterando o Collate de um Banco de Dados  —
Alter Database MosaicoClient
Collate SQL_Latin1_General_CP1_CI_AI
Go

— Short Script 8  – Alterando o Collate de uma Coluna  —
Alter Table Users
Alter Column [Password] Varchar(12) Collate SQL_Latin1_General_CP1_CS_AS
Go

— Short Script 9  – Identificando o Server Collation  – Método 1 —
Select SERVERPROPERTY (‘collation’)
Go

— Short Script 10 – Identificando o Server Collation  – Método 2 —
Exec sp_helpsort
Go

— Short Script 11 – Identificando o Database Collation —
Select DatabasePropertyEx(‘MRP’,’collation’)
Go

— Short Script 12 – Identificando o Column Collation – Método 1 —
Exec sp_help ‘Produtos’
Go

— Short Script 13 – Identificando o Column Collation – Método 2 —
Select * from Sys.columns
Where Name = ‘Produtos’
Go

— Short Script 14 – Identificando o Column Collation – Método 3 —
Select * from Information_schema.columns
Where Table_Name = ‘Produtos’
Go

Muito bem, missão mais que cumprida! Uma nova relação de short scripts acaba de ser compartilhada, mesmo sendo denominados short entre aspas “pequenos”, posso garantir que todos estes exemplos são de grande importância, apresentam um valor e conhecimento do mais alto nível.


Chegamos ao final de mais um Short Scripts, espero que este material possa lhe ajudar, ilustrando o uso de alguns recursos e funcionalidades do Microsoft SQL Server.

Acredito que você tenha observado que estes códigos são conhecidos em meu blog, todos estão relacionados aos posts dedicados ao Microsoft SQL Server publicados no decorrer dos últimos anos.

Boa parte deste material é fruto de um trabalho dedicado exclusivamente a colaboração com a comunidade, visando sempre encontrar algo que possa ser a solução de um determinado problema, bem como, a demonstração de como se pode fazer uso de um determinado recurso.

Links

Caso você queira acessar os últimos posts desta sessão, não perca tempo acesse os links listados abaixo:

https://pedrogalvaojunior.wordpress.com/2018/05/10/short-scripts-maio-2018/

https://pedrogalvaojunior.wordpress.com/2018/02/19/short-scripts-fevereiro-2018-transaction-log/

https://pedrogalvaojunior.wordpress.com/2017/12/09/short-scripts-dezembro-2017/

https://pedrogalvaojunior.wordpress.com/2017/09/16/short-scripts-setembro-2017/

Agradecimento

Obrigado mais uma vez por sua visita, fico honrado com sua ilustre presença ao meu blog, desejo e espero que você possa ter encontrado algo que lhe ajudou.

Volte sempre, nos encontraremos mais uma vez na sessão Short Scripts no post do mês de novembro de 2018.

Abraços…

Anúncios

Transformando um Conjunto de Números Inteiros separados por Vírgulas em Linhas no SQL Server


Pessoal, boa tarde.

Tudo bem? Aproveitando a aproximação do Natal, quero desejar a todos os meus amigos, visitantes, seguidores, enfim á todos que por algum motivo consumam visitar o meu Blog.

UM FELIZ 2012, com muito Amor, Esperança, Paz e principalmente Harmonia.

_______________________________________________________________________

Bom como todos devem estar em clima de festa, não vou ser muito chato e querer compartilhar com vocês algo que possa consumir muito do seu tempo preciso, sendo assim, escolhi um tema bastante prático e que normalmente é muito procurado e questionado nos Fóruns MSDN e TechNet.

Estou me referindo à possibilidade de Separar, Dividir, Desagrupar ou simplesmente Fatiar um conjunto de Números Inteiros separados por Vírgulas no SQL Server. Este conjunto de números pode ser reconhecido ou definido como um Array Simples, Uma coleção de números, enfim, podemos empregar diversas terminologias, que todas poderão ser bem compreendidas para esta situação.


Vamos lá!

Uma das maiores dificuldades para qualquer Programador, Desenvolver, Analista e até mesmo DBA esta relacionada à forma de tratamento de todo e qualquer dado que se pretende armazenar em uma estrutura de dados do tipo tabela, ou até mesmo a manipulação deste dado.

Quando trabalhamos como uma série de valores numéricos temos diversas possibilidades de utilização de recursos específicos para estes valores, como por exemplo:

  • Realização de Cálculos;
  • Utilização de Mecanismos de Pesquisa e Ordenação de Valores;
  • Métodos para organização e diferenciação de dados; entre outros.

Até ai tudo bem, trabalhar diretamente com valores inteiros, números, fórmulas é algo que já realizamos há muito tempo. Agora se por acaso em um dos nossos Aplicativos, Sistemas ou até mesmo Algoritmos nos deparamos com um conjunto de 5, 10, 20, 100, 500 números armazenados em uma estrutura de dados de forma seqüência ou não, mas todos os números separados por vírgula. Então o que fazer ou como fazer para trabalhar de forma individual este conjunto?

É justamente esta pergunta que eu pretender responder para você. Como podemos manipular um conjunto de números inteiros, contidas nesta estrutura, reconhecendo cada número de forma individual e posteriormente separando este conjunto em valores independentes.

Para tentar responder este questionamento, bem como, demonstrar as possibilidades, vou começar a explicar cada uma das partes do Código 1, apresentado abaixo:

— Código 1 —

Declare @Resultado Table (Numero Int)

Declare @ListaValores VarChar(50), @PosicaoAtual Int            

Set @ListaValores=’25,3545,45,6015,2569,14535,2544,4878,15′

While CharIndex(‘,’,@ListaValores,0) <> 0

 Begin

  Set @PosicaoAtual = SubString(@ListaValores,1,CharIndex(‘,’,@ListaValores,0)-1)

  Set @ListaValores = SubString(@ListaValores,CharIndex(‘,’,@ListaValores,0)+1,Len(@ListaValores))

  If Len(@PosicaoAtual) > 0

    Insert Into @Resultado Values (Convert(Int, @PosicaoAtual))   

 End

  If Len(@ListaValores) > 0

    Insert Into @Resultado Values (Convert(Int,@ListaValores))

Select * from @Resultado

Começamos a análise e entendimento do Código 1, com base nas linhas 1,2 e 3 definida como Código 1 – Parte 1, apresentada a seguir:

— Código 1 – Parte 1 —

1. Declare @Resultado Table (Numero Int)

2. Declare @ListaValores VarChar(50), @PosicaoAtual Int            

3. Set @ListaValores=’25,3545,45,6015,2569,14535,2544,4878,15′

Na linha de número 1, estou fazendo a declaração de uma estrutura de armazenamento de valores, sendo esta estrutura denominada @Resultado, o que representa uma variável do Tipo Tabela, existente somente durante a execução completa do Código 1.

A linha de número 2, estou declarando duas variáveis denominadas:

  • @ListaValores: Utilizada como Array ou Container para armazenamento do conjunto de valores numéricos; e
  • @PosicaoAtual: Utilizada para armazenar durante a execução do Código 1, o primeiro valor existente dentro do Array.

Para a linha de número 3, estou atribuindo para a variável @ListaValores este conjunto de números: ‘25,3545,45,6015,2569,14535,2544,4878,15’. Observe que todos os valores estão sendo separados por vírgulas.

Agora que já conhecemos a Parte 1 do nosso Código 1, vou destacar a Parte 2 que representa as seguintes linhas:

— Codigo 1 – Parte 2 —

4. While CharIndex(‘,’,@ListaValores,0) <> 0

5. Begin

6.  Set @PosicaoAtual = SubString(@ListaValores,1,CharIndex(‘,’,@ListaValores,0)-1)

7.  Set @ListaValores = SubString(@ListaValores,CharIndex(‘,’,@ListaValores,0)+1,Len(@ListaValores))

8.  If Len(@PosicaoAtual) > 0

9.   Insert Into @Resultado Values (Convert(Int, @PosicaoAtual))   

10. End

A linha de número 4, apresenta o comando While utilizado para criar e manter a estrutura de repetição enquanto a condição CharIndex(‘,’,@ListaValores,0) for diferente de Zero.

As linhas de número 5 e 10, são de conhecimento de todos, responsáveis em iniciar e encerrar o bloco de código do comando While.

Um dos segredos do Código 1, encontra-se nas linhas de número 6 e 7, onde estamos fazendo as seguintes operações:

  • Na linha 6: É realizado um tratamento para obter o primeiro valor númerico dentro deste conjunto, através da função Substring() dividida em 3 parâmetros:
    • Parâmetro 1 – Informamos a String que contem os valores que queremos obter uma determinada posição, neste caso, utilizamos a variável @ListaValores;
    • Parâmetro 2 – Neste parâmetro devemos informar a posição e número Inteiro que o SQL Server deve começar se posicionar para capturar a porção de dados desejada.

Como nossos números estão armazenados na mesma estrutura o que dificulta em muito a identificação dos valores, é necessário utilizar a função string CharIndex, responsável em encontrar um determinado caracter do tipo String dentro de uma String definida pelo usuário, que neste caso será a Vírgula(‘,’) dentro da variável @ListaValores. 

    • Parâmetro 3 – Neste parâmetro devemos informar o tamanho da porção ou parte de dados string que queremos copiar. Neste parâmetro esta sendo passado um valor fixo -1, pois como o segundo parâmetro vai retornar a posição do dado a ser copia incluíndo a vírgula, temos que desconsiderar justamente a vírgula na cópia.
  • Após a realização deste tratamento o resultado é armazenado dentro da variável @PosicaoAtual.

A linha de número 7, apresenta o outro segredo do Código 1, realizando um tratamento similar a linha de número 6, mas com algumas diferenças.

Ao invês de armazenarmos o resultado do tramanento de valores na variável @PosicaoAtual, estamos na verdade, substituíndo o conteúdo da variável @ListaValores, removendo sempre valor contido da variável @PosicaoAtual, conforme o bloco While vai se executado.

A Figura 1 apresentada a seguir ilustra como o SQL Server vai realizando o armazenamento dos dados na variável @PosicaoInicial, removendo este mesmo valor da variável @ListaValores.

Figura 1, Valores armazenados nas variáveis @PosicaoAtual e @ListaValores.

Além disso, temos outras duas diferença nos parâmetros de número 2 e 3 da função Substring(), onde: 

    • Parâmetro 2 – Ao invês de realizarmos a diminuição de uma posição conforme apresentado na linha 6, estamos fazendo justamento o contrário, acrescentando mais linha posição no valor retornado pelo CharIndex, incluíndo então a posição da Vírgula.
    • Parâmetro 3 – Neste parâmetro estamos passando o tamanho total da nossa variável @ListaValores.

Após os tratamentos realizados nas linhas 6 e 7, é realizado uma análise condicional na linha 8, responsável em verificar se a variável @PosicaoAtual possui algum valor, caso esta condição seja verdadeiro o valor contido nesta variável é armazenada na variável table @Resultado, através do comando Insert.

Para finalizar vou apresentar a parte final do Código 1, com base nas seguintes linhas:

— Codigo 1 – Parte Final —

11. If Len(@ListaValores) > 0

12. Insert Into @Resultado Values (Convert(Int,@ListaValores))

13. Select * from @Resultado

Na linha de número 11, estamos realizando uma nova análise condicional, responsável em verificar se a variável @ListaValores, possui algum valor, sendo este valor o último valor existente dentro do conjunto de valores declarados, posteriormente armazenado na tabela @Resultado, conforme a apresenta a linha de número 12.

A linha de número 13, tem como finalidade apresentar o resultado da seperação deste conjunto de valores numéricos, conforme apresenta a Figura 2.

Figura 2 – Conjunto de números separados em linhas.

Galera, é isso ai, vou chegando ao final de mais uma dica, espero que todos possam ter gostado, que as informações apresentadas aqui possam ajudar no seu dia-á-dia.

Nos encontramos em breve.

Até mais.

Simulando Array e Separação de elementos String no SQL Server 2008


Salve galera, boa tarde.

Hoje vou postar algo diferente em minhas dicas, mas tenho certeza que muita gente vai gostar.

__________________________________________________________________________________________

Você já ouvi falar de Estruturas de Dados?

• Na Ciência da computação, uma estrutura de dados é um modo particular de armazenamento e organização de dados em um computador. Seu objetivo é possibilitar a utilização deste mesmo dado, de forma eficiente.

• Diferentes tipos de estrutura de dados são adequadas a diferentes tipos de aplicação, algumas são altamente especializadas, destinando-se a tarefas específicas.

• Por exemplo, as B-trees(Árvores binárias) são particularmente indicadas para a implementação de bases de dados, devido a sua forma de ordenação e armazenamento dos dados, considerada de grande eficiência durante os processos de busca e pesquisa de informações.

• As Estruturas de dados são consideradas temas fundamentais na ciência da computação, sendo utilizadas nas mais diversas áreas do conhecimento e com os mais diferentes propósitos de aplicação.

• Quando estes dados estão organizados (dispostos) de forma coerente, caracterizam uma forma, denominada estrutura de dados.

• A organização e os métodos para manipular essa estrutura é que lhe conferem singularidade, específicos para cada estrutruda de dados, bem como, os tipos de dados armazenados nesta estrutura.

• As estruturas de dados são chamadas tipos de dados compostos que dividem-se em homogêneos (vetores e matrizes) e  heterogêneos (registros).
• As estruturas homogêneas são conjuntos de dados formados pelo mesmo tipo de dado primitivo. Ao contrário as estruturas heterogêneas são conjuntos de dados formados por tipos de dados primitivos diferentes (campos do registro) em uma mesma estrutura.
• A escolha de uma estrutura de dados apropriada pode se tornar um problema complicado em uma solução relativamente simples, caso seja definida uma estrutura inadequada ou incompatível.
Matrizes e Vetores (Arrays)
• Em programação de computadores, um array, também é conhecido como vetor (para arrays uni-dimensionais) ou matriz (para arrays bi-dimensionais), considerado uma das mais simples estruturas de dados. Os arrays mantêm uma série de elementos de dados, geralmente do mesmo tamanho e tipo de dados.
• Estes elementos individuais são acessados por sua posição no array. A posição é dada por um índice, também chamado de subscrição.
• O índice geralmente utiliza uma seqüência de números inteiros, (ao contrário de um array associativo) mas o índice pode ter qualquer valor ordinal. Alguns arrays podem ser definidos como multi-dimensionais, significando que eles são indexados por
um número fixo de números inteiros. A matriz pode ser definida como uma coleção de variáveis de mesmo tipo, acessíveis com um único nome e armazenados contiguamente na memória.
• Por exemplo, uma sequência (ou sucessão) finita de quatro números inteiros, geralmente, arrays uni- e bi-dimensionais são os mais comuns.
• Consideradas como estruturas de dados simples, vetores e matrizes possuem a vantagem de que os seus elementos são acessíveis de forma rápida, mas apresentam uma notável limitação: São definidos por um tamanho fixo.
• Esta suposta limitação pode ser contornada, através do uso de algoritmos, que possibilitam a declaração de um vetor com tamanho indefinido, mais conhecido como Vetor ou Array Dinâmico.
• A ordem de armazenamento aos dados, ocorre com base na ordenação das posições definição em cada índice, sendo este índice numerado de forma sequencial. O conjunto de valores armazenados em um vetor ou matriz, podem estar organizados de forma: aleatórias, sequencial ou mista(contendo partes  organizadas sequencialmente misturada com partes aleatórias).
• A forma de acesso aos elementos de um vetor ou matriz é direta, ao contrário das listas. Isto quer dizer que o elemento desejado obtêm-se a partir do seu índice e não é preciso procurá-lo elemento por elemento.
Após esta introdução sobre Estrutura de Dados, Matrizes, Vetores e Arrys, podemos dizer que temos um conhecimento prévio para se entender a forma de organização e utilização de Arrays.
Muito bem, mas em Bancos de Dados Relacionais, ou melhor dizendo no SQL Server como podemos simular e até mesmo colocar em prática este tipo de estrutura de dados?
É justamente a resposta para este pergunta que pretendo demonstrar para vocês!!! Bom vamos então construir nosso ambiente de trabalho, para isso duas novas tabelas serão criadas, sendo elas:
  • dbo.Numeracao –> Tabela auxiliar responsável em armazenar uma sequência de números inteiros;
  • dbo.Arrays –> Tabela principal, utilizada para armazenar os elementos que compõem no Array.

A Listagem 1 apresentada a abaixo, ilustra o código de criação e população de dados para as tabelas dbo.Numeracao e dbo.Arrays,

— Listagem 1 – Criando as tabelas dbo.Numeracao e dbo.Arrays —

Use TEMPDB;

Go

If OBJECT_ID(‘dbo.Numeracao’,’U’) Is Not Null

Drop Table dbo.Numeracao;

— Criação da tabela dbo.Numeracao — 

Create Table dbo.Numeracao

(Numero Int Not Null Primary Key) ;

Go

Declare @ValorMaximo Int,

@Contador Int;

Set @ValorMaximo=1000000;

Set @Contador=1;

Insert Into dbo.Numeracao Values(1)

— Loop de inserção de dados —

While @Contador * 2 <= @ValorMaximo

 Begin

   Insert Into dbo.Numeracao

   Select Numero+@Contador from dbo.Numeracao;

   Set @Contador *= 2;       

 End

— Inserção de dados complementares da tabela dbo.Numeracao —

Insert Into dbo.Numeracao

 Select Numero + @Contador from dbo.Numeracao

 Where Numero + @Contador <= @ValorMaximo

Go

IF OBJECT_ID(‘dbo.Arrays’) Is Not Null

Drop Table dbo.Arrays;

— Criando a tabela dbo.Arrays —

Create Table dbo.Arrays

(Idx Varchar(10) Not Null Primary Key,

Elementos Varchar(8000) Not Null)

Go

— Inserção de dados na tabela dbo.Arrays —

Insert Into Arrays(Idx, Elementos)

Values

 (‘A’,‘20,223,2544,25567,14’),

(‘B’,’30,-23433,28′),

(‘C’,‘12,10,8099,12,1200,13,12,14,10,9’),

(‘D’,‘-4,-6,-45678,-2’)
GO

Nossas tabelas foram criadas e seus respectivos dados armazenados em suas estruturas, vale ressaltar que a tabela dbo.Numeracao possui uma massa de 1 milhão de linhas de registros. Para confirmar podemos observar a Figura 1, apresentada a seguir:

Figura 1 – Dados armazenados nas tabelas dbo.Numeracao e dbo.Arrays.

Agora com nosso ambiente pronto e abastecido de informações, o próximo passo é montar o Array, tarefa que será dividida em algumas fases.

A Listagem 2, apresenta a Primeira Fase para construção do nosso Array, onde inicialmente vamos realizar um Select fazendo a junção entre a tabela dbo.Numeracao e dbo.Array. O objetivo deste select é obter o Número armazenado na tabela dbo.Numeracao correspondente ao tamanho dos elementos envolvidos em cada linha da tabela dbo.Arrays.

Neste código utilizo a função DataLength(): Retorna o número de bytes usado para representar qualquer expressão, outro detalhe importante esta relacionado com a função SubString(): Retorna parte de uma expressão de caractere, binária, de texto ou de imagem, através desta função, vamos retornar a vírgula utilizada como separador de caracteres armazenados na coluna Elementos existente na tabela Arrays.

— Listagem 2 – Primeira fase para construção do Array —

Select A.Idx, A.Elementos,

N.Numero

from dbo.Arrays A Join dbo.Numeracao N

On N.Numero <= DATALENGTH(A.Elementos)

                                 And SUBSTRING(Elementos, Numero, 1) = ‘,’ 

Após executarmos a Listagem 2, temos o seguinte resultado, conforme apresenta a Figura 2:

Figura 2 — Resultado da execução da Listagem 2.

Vamos para o próximo passo, evoluir nossa estrutura o mais próximo de um Array, neste caso, transformar nosso elementos que estão agrupados em uma única linha correspondente ao linha registro em linhas separadas, para isso, vou utilizar neste segunda fase da função CharIndex: Utilizada para pesquisar valores em declarados em uma expressão que possam existir na expressão de origem, retornando a posição desta expressão.

Pois bem, vamos utilizar então a CharIndex para pesquisar dentro da coluna Elementos, a vírgula utilizada como separador de caracteres, com isso, teremos a posição de cada vírgula existente entre os valores declarados. Esta linha de código será o ponto chave para a montar do nosso Array, conforme a Listagem 3 apresentada a seguir, bem como, a Figura 4 que ilustra nosso Array.

Select

A.Idx,

Substring(A.Elementos, N.Numero,

CHARINDEX(‘,’, A.Elementos + ‘,’, N.Numero)-N.Numero) As Elementos

from

dbo.Arrays A Join dbo.Numeracao N

On N.Numero <= DATALENGTH(A.Elementos) + 1

And SUBSTRING(‘,’ + A.Elementos, Numero, 1) = ‘,’

— Listagem 3 – Segunda fase para construção do Array —

Select A.Idx,

Substring(A.Elementos, N.Numero, CHARINDEX(‘,’, A.Elementos + ‘,’, N.Numero)-N.Numero) As Elementos

from dbo.Arrays A Join dbo.Numeracao N

                                  On N.Numero <= DATALENGTH(A.Elementos) + 1

                                  And SUBSTRING(‘,’ + A.Elementos, Numero, 1) = ‘,’

Figura 3 – Elementos separados através da utilização da função SubString em conjunto com a função CharIndex.

Então os elementos foram separados, nosso Array esta quase pronto, o que falta agora é estabelecer a posição de cada elemento, o que representa a fase final da construção do nosso Array, conforme apresenta a Listagem 4 e demonstrado na Figura 4.

— Listagem 4 — Fase Final – Construção do Array —

Create Table dbo.ArrayCompleto

(Idx Int Identity Primary Key,

Identificador Char(1) Not Null,

Elementos Varchar(10))

Go

— Inserindo os dados na Tabela ArrayCompleto —  

Insert Into ArrayCompleto(Identificador, Elementos)

Select A.Idx,

Substring(A.Elementos, N.Numero, CHARINDEX(‘,’, A.Elementos + ‘,’, N.Numero)-N.Numero) As Elementos

from dbo.Arrays A Join dbo.Numeracao N

On N.Numero <= DATALENGTH(A.Elementos) + 1

And SUBSTRING(‘,’ + A.Elementos, Numero, 1) = ‘,’

Go;

Figura 4 – Estrutura Completa do Array.

Com base no resultado apresentado na Figura 4, temos a comprovação que nosso Array esta pronto, nossa estrutura criada anteriormente contendo os elementos agrupados por Identficadores foram distribuídos em cada linha, nossa sua estrutura de Array esta completa, contendo a coluna Índice, a coluna Identificador que representava um campo de identifação dos Elementos e a coluna Elementos com cada valor disposto em linhas distintas.

Sendo assim, acredito que esta dica se encerra aqui, nosso Array esta montando e pronto para ser utilizado!!!

Espero que você tenha gostado e entendido como podemos construir um simples Array no SQL Server, fazendo uso de funções Strings, separadores de caracteres e decomposição de elementos.

Agradeço a sua visita, nos encontramos nos próximos artigos.

Até mais.