Trabalhar com tipos definidos pelo usuário –Manipular dados UDT
Aplica-se a:
SQL Server
O Transact-SQL não fornece sintaxe especializada para instruções INSERT, UPDATE ou DELETE ao modificar dados em colunas de tipo definido pelo usuário (UDT). As funções TRANSact-SQL CAST ou CONVERT são usadas para converter tipos de dados nativos para o tipo UDT.
Inserindo dados em uma coluna UDT
As instruções Transact-SQL a seguir inserem 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írgulas para o tipo Point . As duas primeiras instruções usam a função CONVERT para converter um valor de cadeia de caracteres para o 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 legível, chame o método ToString do Point UDT, 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;
A 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 Transact-SQL e exibem os resultados chamando o método 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 usando 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 comotrue ao definir a classe . Para obter mais informações, consulte Criando um tipo de User-Defined.
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 forem comparáveis. A seguinte instrução Transact-SQL seleciona linhas em que 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 obter as listagens de código que definem esses três métodos, consulte Codificação User-Defined Tipos.
A seguinte instrução Transact-SQL 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 usa um argumento do tipo de dados Point e exibe a distância do ponto especificado até 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 usa 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 apenas a coordenada Y:
UPDATE dbo.Points
SET PointValue.Y = 99
WHERE ID = 3
Se o UDT tiver sido definido com a ordenação de bytes definida como true, o Transact-SQL poderá avaliar a coluna UDT em uma cláusula WHERE.
UPDATE dbo.Points
SET PointValue = '4,5'
WHERE PointValue = '3,4';
Atualizando limitações
Não é possível atualizar várias propriedades ao mesmo tempo usando o 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. Em seguida, você pode invocar o método mutador para atualizar o objeto em uma instrução Transact-SQL UPDATE, como no seguinte:
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
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de