Trabalhar com tipos definidos pelo usuário –Manipular dados UDT

Aplica-se a: simSQL Server (todas as versões compatíveis)

O Transact-SQL não fornece uma sintaxe especializada para instruções INSERT, UPDATE ou DELETE ao modificar dados nas colunas UDTs (tipos definidos pelo usuário). As funções Transact-SQL CAST ou CONVERT são usadas para converter tipos de dados nativos no tipo UDT.

Inserindo dados em uma coluna UDT

As instruções Transact-SQL a seguir inserão três linhas de dados de exemplo na tabela Pontos. O tipo de dados Point consiste em valores inteiros X e Y expostos como propriedades do UDT. Você deve usar a função CAST ou CONVERT para converter os valores X e Y delimitados por vírgula para o tipo Point. As duas primeiras instruções usam a função CONVERT para converter um valor de cadeia de caracteres no tipo Point e a terceira instrução usa a função CAST:

INSERT INTO dbo.Points (PointValue) VALUES (CONVERT(Point, '3,4'));  
INSERT INTO dbo.Points (PointValue) VALUES (CONVERT(Point, '1,5'));  
INSERT INTO dbo.Points (PointValue) VALUES (CAST ('1,99' AS Point));  

Selecionando dados

A instrução SELECT a seguir seleciona o valor binário do UDT.

SELECT ID, PointValue FROM dbo.Points  

Para ver a saída exibida em um formato acessível, chame o método ToString do UDT de Ponto, que converte o valor em sua representação de cadeia de caracteres.

SELECT ID, PointValue.ToString() AS PointValue   
FROM dbo.Points;  

Isso gera os resultados a seguir.

ID PointValue  
-- ----------  
 1 3,4  
 2 1,5  
 3 1,99  

Você também pode usar as funções Transact-SQL CAST e CONVERT para obter os mesmos resultados.

SELECT ID, CAST(PointValue AS varchar)   
FROM dbo.Points;  
  
SELECT ID, CONVERT(varchar, PointValue)   
FROM dbo.Points;  

O UDT de Ponto expõe suas coordenadas X e Y como propriedades, que você pode selecionar individualmente. A seguinte instrução Transact-SQL seleciona as coordenadas X e Y separadamente:

SELECT ID, PointValue.X AS xVal, PointValue.Y AS yVal   
FROM dbo.Points;  

As propriedades X e Y retornam um valor inteiro, que é exibido no conjunto de resultados.

ID xVal yVal  
-- ---- ----  
 1    3    4  
 2    1    5  
 3    1   99  

Trabalhando com variáveis

Você pode trabalhar com variáveis usam a instrução DECLARE para atribuir uma variável a um tipo UDT. As instruções a seguir atribuem um valor usando a instrução SET e exibem os resultados chamando o método Transact-SQL ToString do UDT na variável:

DECLARE @PointValue Point;  
SET @PointValue = (SELECT PointValue FROM dbo.Points  
    WHERE ID = 2);  
SELECT @PointValue.ToString() AS PointValue;  

O conjunto de resultados exibe o valor da variável:

PointValue  
----------  
-1,5  

As seguintes instruções Transact-SQL obtêm o mesmo resultado que usar SELECT em vez de SET para a atribuição de variável:

DECLARE @PointValue Point;  
SELECT @PointValue = PointValue FROM dbo.Points  
    WHERE ID = 2;  
SELECT @PointValue.ToString() AS PointValue;  

A diferença entre usar SELECT e SET para a atribuição de variável é que SELECT permite atribuir muitas variáveis a uma única instrução SELECT, ao passo que a sintaxe SET exige que cada atribuição de variável tenha sua própria instrução SET.

Comparando dados

Você pode usar operadores de comparação para comparar valores em seu UDT se tiver definido a propriedade IsByteOrdered como true ao definir a classe . Para obter mais informações, consulte Criando um User-Defined tipo.

SELECT ID, PointValue.ToString() AS Points   
FROM dbo.Points  
WHERE PointValue > CONVERT(Point, '2,2');  

Você pode comparar valores internos do UDT independentemente da configuração IsByteOrdered se os próprios valores são comparáveis. A seguinte instrução Transact-SQL seleciona linhas onde X é maior que Y:

SELECT ID, PointValue.ToString() AS PointValue   
FROM dbo.Points  
WHERE PointValue.X < PointValue.Y;  

Você também pode usar operadores de comparação com variáveis, como mostrado nesta consulta que procura um PointValue compatível.

DECLARE @ComparePoint Point;  
SET @ComparePoint = CONVERT(Point, '3,4');  
SELECT ID, PointValue.ToString() AS MatchingPoint   
FROM dbo.Points  
WHERE PointValue = @ComparePoint;  

Invocando métodos UDT

Você também pode invocar métodos definidos em seu UDT no Transact-SQL. A classe Point contém três métodos, Distance, DistanceFrom e DistanceFromXY. Para as listagem de código que definem esses três métodos, consulte Codificando User-Defined tipos.

A Transact-SQL instrução a seguir chama o método PointValue.Distance:

SELECT ID, PointValue.X AS [Point.X],   
    PointValue.Y AS [Point.Y],  
    PointValue.Distance() AS DistanceFromZero   
FROM dbo.Points;  

Os resultados são exibidos na coluna Distância:

ID X  Y  Distance  
-- -- -- ----------------  
 1  3  4                5  
 2  1  5 5.09901951359278  
 3  1 99 99.0050503762308  

O método DistanceFrom recebe um argumento do tipo de dados Point e exibe a distância do ponto especificado para o PointValue:

SELECT ID, PointValue.ToString() AS Pnt,  
   PointValue.DistanceFrom(CONVERT(Point, '1,99')) AS DistanceFromPoint  
FROM dbo.Points;  

Os resultados exibem os resultados do método DistanceFrom para cada linha na tabela:

ID Pnt DistanceFromPoint  
-- --- -----------------  
 1 3,4  95.0210502993942  
 2 1,5                94  
 3 1,9                90  

O método DistanceFromXY assume os pontos individualmente como argumentos:

SELECT ID, PointValue.X as X, PointValue.Y as Y,   
PointValue.DistanceFromXY(1, 99) AS DistanceFromXY   
FROM dbo.Points  

O conjunto de resultados é o mesmo que o método DistanceFrom.

Atualizando dados em uma coluna UDT

Para atualizar dados em uma coluna UDT, use a instrução Transact-SQL UPDATE. Você também pode usar um método do UDT para atualizar o estado do objeto. A seguinte instrução Transact-SQL atualiza uma única linha na tabela:

UPDATE dbo.Points  
SET PointValue = CAST('1,88' AS Point)  
WHERE ID = 3  

Você também pode atualizar elementos UDT separadamente. A seguinte instrução Transact-SQL atualiza somente a coordenada Y:

UPDATE dbo.Points  
SET PointValue.Y = 99  
WHERE ID = 3  

Se o UDT tiver sido definido com ordenação de byte definida como true, poderá avaliar Transact-SQL a coluna UDT em uma cláusula WHERE.

UPDATE dbo.Points  
SET PointValue = '4,5'  
WHERE PointValue = '3,4';  

Atualizando limitações

Você não pode atualizar várias propriedades de uma ver usando Transact-SQL. Por exemplo, a instrução UPDATE a seguir falha com um erro porque você não pode usar o mesmo nome de coluna duas vezes em uma instrução UPDATE.

UPDATE dbo.Points  
SET PointValue.X = 5, PointValue.Y = 99  
WHERE ID = 3  

Para atualizar cada ponto individualmente, você precisaria criar um método modificador no assembly UDT Point. Você pode invocar o método modificador para atualizar o objeto em uma instrução Transact-SQL UPDATE, da seguinte maneira:

UPDATE dbo.Points  
SET PointValue.SetXY(5, 99)  
WHERE ID = 3  

Excluindo dados em uma coluna UDT

Para excluir dados em um UDT, use a instrução Transact-SQL DELETE. A instrução a seguir exclui todas as linhas da tabela que correspondem aos critérios especificadas na cláusula WHERE. Se você omitir a cláusula WHERE em uma instrução DELETE, todas as linhas da tabela serão excluídas.

DELETE FROM dbo.Points  
WHERE PointValue = CAST('1,99' AS Point)  

Use a instrução UPDATE se quiser remover os valores em uma coluna UDT e deixar os valores de outras linhas intactos. Este exemplo define PointValue como nulo.

UPDATE dbo.Points  
SET PointValue = null  
WHERE ID = 2  

Consulte Também

Trabalhando com tipos de dados definidos pelo usuário no SQL Server