Trabajar con tipos definidos por el usuario: manipular datos UDT
Se aplica a:
SQL Server
Transact-SQL no proporciona ninguna sintaxis especializada para las instrucciones INSERT, UPDATE o DELETE al modificar datos en columnas de tipo definido por el usuario (UDT). Las funciones CAST o CONVERT de Transact-SQL se usan para convertir tipos de datos nativos al tipo UDT.
Insertar datos en una columna UDT
Las siguientes instrucciones Transact-SQL insertan tres filas de datos de ejemplo en la tabla Points . El tipo de datos Point consta de valores enteros X e Y que se exponen como propiedades del UDT. Debe usar la función CAST o CONVERT para convertir los valores X e Y delimitados por comas al tipo Point . Las dos primeras instrucciones usan la función CONVERT para convertir un valor de cadena al tipo Point y la tercera instrucción usa la función 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));
Seleccionar datos
La siguiente instrucción SELECT selecciona el valor binario del UDT.
SELECT ID, PointValue FROM dbo.Points
Para ver la salida mostrada en un formato legible, llame al método ToString del UDT point , que convierte el valor en su representación de cadena.
SELECT ID, PointValue.ToString() AS PointValue
FROM dbo.Points;
Esto produce el siguiente resultado.
ID PointValue
-- ----------
1 3,4
2 1,5
3 1,99
También puede usar las funciones CAST y CONVERT de Transact-SQL para lograr los mismos resultados.
SELECT ID, CAST(PointValue AS varchar)
FROM dbo.Points;
SELECT ID, CONVERT(varchar, PointValue)
FROM dbo.Points;
El UDT point expone sus coordenadas X e Y como propiedades, que puede seleccionar individualmente. La siguiente instrucción Transact-SQL selecciona las coordenadas X e Y por separado:
SELECT ID, PointValue.X AS xVal, PointValue.Y AS yVal
FROM dbo.Points;
Las propiedades X e Y devuelven un valor entero, que se muestra en el conjunto de resultados.
ID xVal yVal
-- ---- ----
1 3 4
2 1 5
3 1 99
Trabajar con variables
Puede trabajar con variables si utiliza la instrucción DECLARE para asignar una variable a un tipo UDT. Las instrucciones siguientes asignan un valor mediante la instrucción SET de Transact-SQL y muestran los resultados llamando al método ToString del UDT en la variable :
DECLARE @PointValue Point;
SET @PointValue = (SELECT PointValue FROM dbo.Points
WHERE ID = 2);
SELECT @PointValue.ToString() AS PointValue;
El conjunto de resultados muestra el valor variable:
PointValue
----------
-1,5
Las siguientes instrucciones Transact-SQL logran el mismo resultado mediante SELECT en lugar de SET para la asignación de variables:
DECLARE @PointValue Point;
SELECT @PointValue = PointValue FROM dbo.Points
WHERE ID = 2;
SELECT @PointValue.ToString() AS PointValue;
La diferencia entre el uso de SELECT y SET para la asignación de variable es que SELECT permite asignar varias variables en una instrucción SELECT, mientras que la sintaxis de SET exige que cada asignación de variable tenga su propia instrucción SET.
Comparar datos
Puede usar operadores de comparación para comparar valores en el UDT si ha establecido la propiedad IsByteOrdered en true al definir la clase . Para obtener más información, vea Crear un tipo de User-Defined.
SELECT ID, PointValue.ToString() AS Points
FROM dbo.Points
WHERE PointValue > CONVERT(Point, '2,2');
Puede comparar los valores internos del UDT independientemente del valor IsByteOrdered si los propios valores son comparables. La siguiente instrucción Transact-SQL selecciona filas donde X es mayor que Y:
SELECT ID, PointValue.ToString() AS PointValue
FROM dbo.Points
WHERE PointValue.X < PointValue.Y;
También puede utilizar operadores de comparación con variables, tal como se muestra en esta consulta que busca un PointValue correspondiente.
DECLARE @ComparePoint Point;
SET @ComparePoint = CONVERT(Point, '3,4');
SELECT ID, PointValue.ToString() AS MatchingPoint
FROM dbo.Points
WHERE PointValue = @ComparePoint;
Invocar métodos del UDT
También puede invocar métodos definidos en el UDT en Transact-SQL. La clase Point contiene tres métodos, Distance, DistanceFrom y DistanceFromXY. Para ver los listados de código que definen estos tres métodos, vea Codificación de tipos User-Defined.
La siguiente instrucción Transact-SQL llama al método PointValue.Distance :
SELECT ID, PointValue.X AS [Point.X],
PointValue.Y AS [Point.Y],
PointValue.Distance() AS DistanceFromZero
FROM dbo.Points;
Los resultados se muestran en la columna Distancia :
ID X Y Distance
-- -- -- ----------------
1 3 4 5
2 1 5 5.09901951359278
3 1 99 99.0050503762308
El método DistanceFrom toma un argumento del tipo de datos Point y muestra la distancia desde el punto especificado hasta PointValue:
SELECT ID, PointValue.ToString() AS Pnt,
PointValue.DistanceFrom(CONVERT(Point, '1,99')) AS DistanceFromPoint
FROM dbo.Points;
Los resultados muestran los resultados del método DistanceFrom para cada fila de la tabla:
ID Pnt DistanceFromPoint
-- --- -----------------
1 3,4 95.0210502993942
2 1,5 94
3 1,9 90
El método DistanceFromXY toma los puntos individualmente como argumentos:
SELECT ID, PointValue.X as X, PointValue.Y as Y,
PointValue.DistanceFromXY(1, 99) AS DistanceFromXY
FROM dbo.Points
El conjunto de resultados es el mismo que el método DistanceFrom .
Actualizar datos en una columna UDT
Para actualizar datos en una columna UDT, use la instrucción UPDATE de Transact-SQL. También puede utilizar un método del UDT para actualizar el estado del objeto. La siguiente instrucción Transact-SQL actualiza una sola fila de la tabla:
UPDATE dbo.Points
SET PointValue = CAST('1,88' AS Point)
WHERE ID = 3
También puede actualizar los elementos UDT por separado. La siguiente instrucción transact-SQL actualiza solo la coordenada Y:
UPDATE dbo.Points
SET PointValue.Y = 99
WHERE ID = 3
Si el UDT se ha definido con el orden de bytes establecido en true, Transact-SQL puede evaluar la columna UDT en una cláusula WHERE.
UPDATE dbo.Points
SET PointValue = '4,5'
WHERE PointValue = '3,4';
Limitaciones de la actualización
No se pueden actualizar varias propiedades a la vez mediante Transact-SQL. Por ejemplo, se produce un error en la siguiente instrucción UPDATE porque no se puede usar el mismo nombre de columna dos veces en una instrucción UPDATE.
UPDATE dbo.Points
SET PointValue.X = 5, PointValue.Y = 99
WHERE ID = 3
Para actualizar individualmente cada punto, debe crear un método mutador en el ensamblado UDT de Point. A continuación, puede invocar el método mutador para actualizar el objeto en una instrucción UPDATE de Transact-SQL, como se muestra a continuación:
UPDATE dbo.Points
SET PointValue.SetXY(5, 99)
WHERE ID = 3
Eliminar datos en una columna UDT
Para eliminar datos en un UDT, use la instrucción DELETE de Transact-SQL. La siguiente instrucción elimina todas las filas de la tabla que coinciden con los criterios especificadas en la cláusula WHERE. Si omite la cláusula WHERE de una instrucción DELETE, se eliminarán todas las filas de la tabla.
DELETE FROM dbo.Points
WHERE PointValue = CAST('1,99' AS Point)
Utilice la instrucción UPDATE si desea quitar los valores de una columna UDT y conservar los valores de otra fila intactos. En este ejemplo se establece PointValue en NULL.
UPDATE dbo.Points
SET PointValue = null
WHERE ID = 2
Consulte también
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de