Manipular datos de tipo definido por el usuario (UDT)
Se aplica a:
SQL Server
Transact-SQL no proporciona ninguna sintaxis especializada para las instrucciones INSERT, UPDATEo DELETE al modificar datos en columnas de tipo definido por el usuario (UDT). Las funciones Transact-SQL CAST o CONVERT 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 de Point. Las dos primeras instrucciones usan la función CONVERT para convertir un valor de cadena en el 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));
Selección de 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 Point UDT, que convierte el valor en su representación de cadena.
SELECT ID, PointValue.ToString() AS PointValue
FROM dbo.Points;
Este es el conjunto de resultados.
ID PointValue
-- ----------
1 3,4
2 1,5
3 1,99
También puede usar las funciones Transact-SQL CAST y CONVERT para lograr los mismos resultados.
SELECT ID, CAST (PointValue AS VARCHAR)
FROM dbo.Points;
SELECT ID, CONVERT (VARCHAR, PointValue)
FROM dbo.Points;
El Point UDT 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 mediante la instrucción DECLARE para asignar una variable a un tipo UDT. Las instrucciones siguientes asignan un valor mediante la instrucción Transact-SQL SET y muestran los resultados llamando al método ToString del UDT en la variable :
DECLARE @PointValue AS 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 AS Point;
SELECT @PointValue = PointValue
FROM dbo.Points
WHERE ID = 2;
SELECT @PointValue.ToString() AS PointValue;
La diferencia entre usar SELECT y SET para la asignación de variables es que SELECT permite asignar varias variables en una instrucción SELECT, mientras que la sintaxis SET requiere que cada asignación de variables tenga su propia instrucción SET.
Comparación de datos
Puede usar operadores de comparación para comparar valores en el UDT si establece la propiedad IsByteOrdered en true al definir la clase . Para obtener más información, consulte Creación de tipos definidos por el usuario.
SELECT ID, PointValue.ToString() AS Points
FROM dbo.Points
WHERE PointValue > CONVERT (Point, '2,2');
Puede comparar los valores internos del UDT independientemente de la configuración de 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 usar operadores de comparación con variables, como se muestra en esta consulta que busca una PointValuecoincidente.
DECLARE @ComparePoint AS Point;
SET @ComparePoint = CONVERT (Point, '3,4');
SELECT ID, PointValue.ToString() AS MatchingPoint
FROM dbo.Points
WHERE PointValue = @ComparePoint;
Invocar métodos UDT
También puede invocar métodos definidos en el UDT en Transact-SQL. La clase Point contiene tres métodos, Distance, DistanceFromy DistanceFromXY. Para ver las listas de código que definen estos tres métodos, consulte Creación de tipos definidos por el usuario con ADO.NET.
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 Distance:
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 de Point tipo de datos y muestra la distancia desde el punto especificado hasta el 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 los datos de una columna UDT, use la instrucción Transact-SQL UPDATE. 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 solo actualiza la coordenada Y:
UPDATE dbo.Points
SET PointValue.Y = 99
WHERE ID = 3;
Si el UDT se define 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 actualización
No se pueden actualizar varias propiedades a la vez mediante Transact-SQL. Por ejemplo, la siguiente instrucción UPDATE produce un error 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 cada punto individualmente, tendría que 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 Transact-SQL UPDATE, como en el ejemplo siguiente:
UPDATE dbo.Points
SET PointValue.SetXY(5, 99)
WHERE ID = 3;
Eliminación de datos en una columna UDT
Para eliminar datos en un UDT, use la instrucción Transact-SQL DELETE. La siguiente instrucción elimina todas las filas de la tabla que coinciden con los criterios especificados en la cláusula WHERE. Si omite la cláusula WHERE en una instrucción DELETE, se eliminan todas las filas de la tabla.
DELETE dbo.Points
WHERE PointValue = CAST ('1,99' AS Point);
Use la instrucción UPDATE si desea quitar los valores de una columna UDT mientras deja intactos otros valores de fila. En este ejemplo se establece el PointValue en NULL.
UPDATE dbo.Points
SET PointValue = NULL
WHERE ID = 2;