Transact SQL proporciona una variedad bastante amplia de funciones para llevar a cabo tal tarea. Algunas de las operaciones que podemos realizar son concatenación, obtención de subcadenas, pasar a mayúsculas o minúsculas, eliminar espacios en blanco… incluso detectar la similitud entre expresiones.

A continuación veremos algunas de ellos y aplicaremos algunos ejemplos:

LOWER y UPPER

Devuelven un VARCHAR o un NVARCHAR con la expresión pasada como parámetro en minúsculas y en mayúsculas, respectivamente.

SELECT LOWER(Nombre) AS Minusculas FROM Usuario
SELECT UPPER(Nombre) AS Mayusculas FROM Usuario

LEN

Devuelve la longitud en caracteres de una cadena.

SELECT LEN(Nombre) AS NumCaracteres, Nombre FROM Usuario

SUBSTRING

Recupera una subcadena de la expresión dada, indicando la posición inicial (empezando por la posición 0) y el número de caracteres a “leer”.
Es útil en combinación con LEN para mostrar secciones de texto. Por ejemplo, para eliminar los dos últimos caracteres de un nombre, escribiríamos lo que sigue:

SELECT SUBSTRING(Nombre, 0, LEN(Nombre)-2) AS SubCadena FROM Usuario

LEFT y RIGHT

Parecido a SUBSTRING. LEFT devuelve los N primeros caracteres de la cadena dada, mientras que RIGHT devolverá los N últimos.

SELECT LEFT(Nombre, LEN(Nombre)-2) AS [Left] FROM Usuario
SELECT RIGHT(Nombre, LEN(Nombre)-2) AS [Right] FROM Usuario

LTRIM y RTRIM

Eliminan todos los espacios de la izquierda y de la derecha, respectivamente, de la expresión dada.

-- Elimina los espacios a la izquierda
SELECT LTRIM('     PRUEBA       ') AS [LTRIM];

-- Elimina los espacios a la derecha
SELECT RTRIM('     PRUEBA       ') AS [RTRIM];

-- Elimina los espacios a la derecha y a la izquierda
SELECT(LTRIM(RTRIM('     PRUEBA       '))) AS [LTRIM + RTRIM];

DIFFERENCE

Establece un rango de similitud entre dos expresiones, que varía entre 0 (ninguna similitud) y 4 (mucha similitud).

-- Mucha similitud, rango 4
SELECT DIFFERENCE('García', 'Gracia') AS Rango

-- Cierta similitud, rango 2
SELECT DIFFERENCE('López', 'Pérez') AS Rango

-- Ninguna similitud, rango 0
SELECT DIFFERENCE('New York City', 'Barcelona') AS Rango

REVERSE

Invierte una cadena.

SELECT REVERSE(Nombre) AS erbmoN FROM Usuario

CHARINDEX

Busca la primera expresión en la segunda y devuelve la posición en la que se encuentra su primera aparición, comenzando desde la posición 0.

SELECT CHARINDEX('prueba', 'Esto es una prueba prueba') AS [CharIndex]

PATINDEX

Busca el patrón indicado en la primera expresión en la segunda y devuelve la posición en la que se encuentra su primera aparición, comenzando desde la posición 0. La diferencia con CHARINDEX es la posibilidad de utilizar patrones en lugar de expresiones.

SELECT Nombre, 'ua' AS Patron, PATINDEX('%ua%', Nombre) AS Posicion FROM Usuario

REPLICATE

Repite la expresión dada como primer argumento un número de veces igual al indicado por el segundo argumento.

SELECT REPLICATE(Nombre + ' ', 2) AS Replica FROM Usuario

Para una información más detallada, no obstante, aconsejo acudir a la MSDN.

Vimos previamente que nuestra clase  ClasePrueba tenía una función llamada sumarUno(). Vamos a intentar, mediante Reflection, invocar a la función sin necesidad de “conocer” el objeto. En realidad, y para simplificar el ejemplo, utilizaremos el nombre del método directamente, pero sería posible, a partir de una estructura MethodInfo, obtener nombre y parámetros de cada uno de los métodos y ejecutarlos de forma dinámica.

Partiendo del código del artículo anterior, añadiríamos lo siguiente para invocar el método:

 // Ejecutamos un método mediante Reflection. En primer lugar obtenemos una referencia al método
 MethodInfo Metodo = tipoObjeto.GetMethod("sumarUno");

 // A continuación, llamamos al método Invoke del tipo, pasándole como primer parámetro
 //el objeto cuyo método queremos ejecutar, y como segundo parámetro, un array de objetos con
 //los parámetros que espera el método o función.
 int dato;
 object[] parametros = new object[1] { 2 };
 dato = (int)Metodo.Invoke(objeto, parametros);

 Console.WriteLine("El resultado de la invocación ha sido: " + dato.ToString());

Recordemos que el objeto ‘objeto‘ era una instancia de ClasePrueba.

Como puntilla mostraremos otra forma de invocar un método mediante Reflection: utilizando Activator para obtener una instancia de la clase ClasePrueba y ejecutando el método Type.InvokeMember().

 // Utilizamos la clase Activator para ejecutar el método de otro objeto
 object objeto2 = Activator.CreateInstance(tipoObjeto);
 dato = (int)tipoObjeto.InvokeMember("sumarUno", BindingFlags.InvokeMethod, null, objeto2, parametros);

 Console.WriteLine("El resultado de la invocación (mediante Activator) ha sido: " + dato.ToString());

El resultado sería el siguiente:

A modo didáctico, veremos las posibilidades de exploración e invocación de reflection. Para comenzar, crearemos una clase con dos atributos, dos propiedades, dos métodos y cuatro constructores, a la que llamaremos ClasePrueba:

using System;
using System.Collections.Generic;
using System.Text;

namespace Simple.Test
{
 /// <summary>
 /// Clase de prueba, cuyo objetivo es demostrar la utilización del espacio de nombres Reflection
 /// </summary>
 /// <changelog>
 /// Daniel Garcia (contacto at danigarcia punto o erre ge)
 /// 26/05/2009    Creacion
 /// </changelog>
 public class ClasePrueba
 {
    #region Atributos y Propiedades

    private int variableEntera;
    private string variableCadena;

    public int PropiedadEntero
    {
       get { return variableEntera;}
       set { variableEntera = value;}
    }

    public string PropiedadCadena
    {
       get { return variableCadena; }
       set { variableCadena = value; }
    }

 #endregion

 #region Constructores

    public ClasePrueba()
    {
       variableCadena = "";
       variableEntera = 0;
    }

    public ClasePrueba(int entero)
    {
       variableCadena = "";
       variableEntera = entero;
    }

    public ClasePrueba(string cadena)
    {
       variableCadena = cadena;
       variableEntera = 0;
    }

   public ClasePrueba(int entero, string cadena)
    {
       variableCadena = cadena;
       variableEntera = entero;
    }

 #endregion

 #region Funciones

    public int sumarUno(int dato)
    {
       PropiedadEntero = dato + 1;
       return PropiedadEntero;
    }

    public string insertarLetra(char caracter)
    {
       PropiedadCadena += caracter;
       return PropiedadCadena;
    }

 #endregion

    }
}

Creada nuestra clase, es hora de comenzar a “reflexionar” sobre el tema. Como punto de inicio, instanciaremos un objeto de la clase ClasePrueba y declararemos una referencia Type a la asignaremos el tipo de nuestro objeto, mediante la función GetType().

 // Instanciamos el objeto
 ClasePrueba objeto = new ClasePrueba();

 // Obtenemos su tipo
 Type tipoObjeto = objeto.GetType();

A continuación, “exprimimos” el contenido de nuestro tipo, obteniendo información variada como métodos, constructores, propiedades o miembros en general.

 // Obtenemos información sobre miembros, constructores y métodos
 ConstructorInfo[] Constructores = tipoObjeto.GetConstructors();
 MemberInfo[] Miembros = tipoObjeto.GetMembers();
 PropertyInfo[] Propiedades = tipoObjeto.GetProperties();
 MethodInfo[] Metodos = tipoObjeto.GetMethods();

Finalmente, mostrar la información por pantalla será tarea sencilla recorriendo los arrays con distintas informaciones.

 Console.WriteLine("Constructores:");
 Console.WriteLine("-------------------------------------------------------------");
 foreach (ConstructorInfo info in Constructores)
     Console.WriteLine(info.ToString());

 Console.WriteLine("Miembros:");
 Console.WriteLine("-------------------------------------------------------------");
 foreach (MemberInfo info in Miembros)
     Console.WriteLine(info.ToString());

 Console.WriteLine("Propiedades:");
 Console.WriteLine("-------------------------------------------------------------");
 foreach (PropertyInfo info in Propiedades)
     Console.WriteLine(info.ToString());

 Console.WriteLine("Metodos:");
 Console.WriteLine("-------------------------------------------------------------");
 foreach (MethodInfo info in Metodos)
     Console.WriteLine(info.ToString());

El resultado es fascinante: toda la información sobre la clase al alcance de un click.

Posteriormente comprobaremos otra tarea sencilla con Reflection: invocar métodos de un objeto.

Una forma simple de ahorrarnos dolores de cabeza sería almacenar la fecha sin hora. Para ello haremos uso de los distintos formatos de fecha que nos permite promocionar SQL Server y escribiríamos algo así:

 UPDATE NombreTabla SET CampoFecha = convert(datetime, convert(varchar(10), CampoFecha, 103))  

Con lo cual, almacenaremos nuestra fecha en formato DD:MM:AAAA 00:00:00.

Hablando en llano, una interfaz no es más que una estructura de datos que muestra únicamente las firmas de los métodos de una clase. A partir de ahí, una clase que herede de la interfaz estará obligada a “rellenar” la implementación de dichos métodos. De forma simple, una interfaz sería algo así:

Interfaz Motor
    Arrancar();
    Detener();

Esta interfaz únicamente dice QUÉ acciones se van a realizar, pero no CÓMO se realizarán. Para saber cómo realizarlas, crearemos clases que implementen esta interfaz, obligando a “rellenar” el contenido de los métodos que declaramos previamente.

Por poner un ejemplo:

Clase Gasolina : Motor
    Arrancar()
        InyectarAire();
        IniciarCarburacion();
        EncenderMezcla(Bujía);
    Detener()
        DetenerCarburacion();

Clase Diesel : Motor
    Arrancar()
        InyectarCombustible();
        InyectarAire();
        Comprimir();
    Detener()
        DetenerInyeccion();

Ahora imaginemos que tenemos una clase “Coche” que necesite un “Motor”. Esta clase debe ignorar el funcionamiento interno del motor, únicamente debe saber cómo arrancarlo y cómo pararlo.

Clase Vehiculo
    Motor m;

Para ello hará uso de los métodos Arrancar() y Parar(). Esta interfaz será donde se “conecte” el motor, independientemente de si es un Gasolina o un Diesel. Por ello, si quisiéramos utilizar un motor Diesel, haríamos lo siguiente:

m = new Diesel();
    m.Arrancar();

Como podemos observar, para un motor gasolina sería igual, salvo que declararíamos una instancia de la clase Gasolina.

Implementando una interfaz en C#

Como ejemplo de implementación y utilización de interfaces en C#, crearemos una interfaz ITest que implemente dos métodos: HolaMundo y DevolverCadena. Esta interfaz será implementada por dos clases: Minusculas y Mayusculas. La primera devolverá cadenas en minúsculas, mientras que la segunda, lo hará en mayúsculas.
Para comenzar, crearemos tres clases: ITest, Minusculas y Mayusculas. Estableceremos el cuerpo de ITest de la siguiente forma:

using System;
using System.Collections.Generic;
using System.Text;

namespace Simple.Interface
{
    public interface ITest
    {
        string HolaMundo();
        string DevolverCadena(string s);
    }
}

Así de simple. Establecemos los nombres de las funciones junto a sus parámetros (sin establecer niveles de visibilidad, como public, protected o private). Hecho esto, tenemos declarada una interfaz.

El segundo paso será crear nuestras clases que la implementen. Comenzaremos por “Minusculas“. Lo único que deberemos hacer será añadir dos puntos tras el nombre de la clase, y a continuación, el nombre de la clase o interfaz de la que hereda, en nuestro caso, ITest.

using System;
using System.Collections.Generic;
using System.Text;

namespace Simple.Interface
{
    public class Minusculas : ITest
    {

    }
}

Acto seguido, haremos click derecho sobre “ITest” y seleccionaremos la opción “Implementar interfaz”.

Con esto se añadirán automáticamente a nuestro código aquellos elementos que necesiten ser implementados.

#region Miembros de ITest

public string HolaMundo()
{
    throw new Exception("The method or operation is not implemented.");
}

public string DevolverCadena(string s)
{
    throw new Exception("The method or operation is not implemented.");
}

#endregion

Por último, sustituiremos las sentencias throw por nuestro propio código, que será el siguiente:

#region Miembros de ITest

public string HolaMundo()
{
    return ("hola, mundo");
}

public string DevolverCadena(string s)
{
    return s.ToLower();
}

#endregion

Con la clase Mayusculas realizaremos la misma operación, solo que la implementación será la siguiente:

#region Miembros de ITest

public string HolaMundo()
{
    return ("HOLA, MUNDO");
}

public string DevolverCadena(string s)
{
    return s.ToUpper();
}

#endregion

Ahora deberemos probar nuestro código. En un proyecto de aplicación de consola, declararemos una referencia a nuestra interfaz (lo que equivaldría una referencia al Motor en el primer ejemplo).

Hecho esto, le asociamos una instancia de cualquiera de las clases que la implementen:

ITest minusculas = new Minusculas();
ITest mayusculas = new Mayusculas();

Console.WriteLine(minusculas.HolaMundo());
Console.WriteLine(mayusculas.HolaMundo());

Console.WriteLine("------------------------------------------------");

Console.WriteLine(minusculas.DevolverCadena("Esto es una Prueba de INTERFACES"));
Console.WriteLine(mayusculas.DevolverCadena("Esto es una Prueba de INTERFACES"));

Como observaremos a continuación, nuestra interfaz ITest conoce los métodos que tiene, pero no cómo ejecutarlos. Es por ello que, al asociarle una instancia que implemente la interfaz, nuestra referencia se comportará de una forma u otra.

Imaginemos la potencia de la utilización de interfaces a la hora de crear, por ejemplo, conexiones a bases de datos. Este será un tema que veremos con posterioridad.

Como vemos, lo normal suele ser utilizar campos enlazados a la consulta (BoundFields), así como campos-plantilla (TemplateFields) con los que se suele interactuar con el listado (ver detalles, edición, etc.).

Si sabemos de antemano qué datos vamos a obtener, es sencillo “maquetar” nuestro GridView de forma sencilla. El problema radica en el momento en el que el número de columnas que nuestro GridView mostrará sea variable. En este caso, el atributo AutoGenerateColumns deberá ser puesto a True, con lo que perderemos el control del orden de los TemplateFields.

Veamos el siguiente caso: queremos un campo plantilla que muestre un LinkButton que nos permita editar el registro, y otro que nos permita visualizar los detalles del mismo. Queremos uno de estos campos en la primera columna (el de edición) y otro en la última (visualización). Si utilizamos TemplateFields con el atributo AutoGenerateColumns=”True”, lo que lograremos será que ambos botones se sitúen juntos en las dos primeras columnas de nuestro GridView. ¿Cómo hacer que uno de ellos se coloque al final? Añadiéndolo de forma dinámica.

Para comenzar, añadiremos un GridView con un TemplateField conteniendo un LinkButton, colocando el atributo AutogenerateColumns=”True”.

El templatefield contendría un LinkButton:

El resultado sería este:

Seguidamente, acudiremos a nuestro código, listos para editar el evento RowDataBound. En él haremos lo siguiente:

• Declararemos una celda y un LinkButton.
• Daremos formato al LinkButton (nombre, clase, etc.)
• Asignaremos al LinkButton un CommandArgument igual al Identificador (DataKey) de esa fila del GridView
• Añadiremos el LinkButton a la celda, y la celda a la fila

Para ello utilizaremos el siguiente código:

Protected Sub GridView1_RowDataBound(ByVal sender As Object, ByVal e As System.Web.UI.WebControls.GridViewRowEventArgs) Handles GridView1.RowDataBound
Try

    ' Si se trata de una fila de datos...
    If e.Row.RowType = DataControlRowType.DataRow Then
        Dim celda As New TableCell()
        Dim boton As New LinkButton()

        boton.Text = "Detalles"
        If e.Row.Cells.Count > 1 Then
            boton.CommandArgument = GridView1.DataKeys(e.Row.RowIndex).Value.ToString()
        End If

        ' Añadimos el LinkButton a la celda, y la celda a la fila
        celda.Controls.Add(boton)
        e.Row.Controls.Add(celda)
    End If
Catch ex As Exception
    Throw ex
End Try
End Sub

Con esto lograremos el buscado esquema [Botón] [CAMPOS] [Botón].

BEGIN TRAN
 -- Ejecución de sentencias
COMMIT TRAN

Como imaginaremos, la primera sentencia “arranca” la transacción, mientras que la última la compromete. Pero ¿y si ocurre un error en alguna de las sentencias? ¿Cómo lo detectamos?
En el siguiente ejemplo, utilizaremos variables enteras para trazar los fallos y realizar un ROLLBACK en el caso de que la transacción falle.

Se declarará una variable de tipo INT por cada sentencia a ejecutar, y se inician a 0. Se comprueba, después de cada sentencia ejecutada, la variable @@Error, y se almacena en las variables anteriormente creadas. Si es distinta de 0, hay un error, por lo que se añade información al mensaje de error.
Al final de la transacción, si todas las variables son 0, se hace el COMMIT. Si una de ellas es distinta de cero, significará que existe un error y se hace el Rollback, mostrando el mensaje de error.

DECLARE @CadenaError varchar(1000);
 DECLARE @CodigosError varchar(1000);
 DECLARE @ErrorSentencia1 int;
 DECLARE @ErrorSentencia2 int;
 DECLARE @ErrorSentencia3 int;

 SET @ErrorSentencia1 = 0;
 SET @ErrorSentencia2 = 0;
 SET @ErrorSentencia3 = 0;

 SET @CadenaError = 'Error al realizar actualización: ';
 SET @CodigosError = 'Códigos de error: ';

 -- Inicio de la transacción
 BEGIN TRAN

 -- Primera actualización
 UPDATE Usuario SET Nombre = 'Elena' WHERE Nombre = "Helena";

 -- Almacenamos el posible código de error
 SET @ErrorSentencia1 = @@Error;
 IF (@ErrorSentencia1 <> 0)
 BEGIN
     SET @CadenaError = @CadenaError + 'Actualización 1; '
     SET @CodigosError = @CodigosError + CAST(@ErrorSentencia1 AS VARCHAR(10)) + '; ';
 END

 -- Segunda actualización
 UPDATE Perfil SET Nombre = 'Administrador' WHERE Nombre = "Admin";

 -- Almacenamos el posible código de error
 SET @ErrorSentencia2 = @@Error;
 IF (@ErrorSentencia2 <> 0)
 BEGIN
     SET @CadenaError = @CadenaError + 'Actualización 2; '
     SET @CodigosError = @CodigosError + CAST(@ErrorSentencia2 AS VARCHAR(10)) + '; ';
 END

 -- Tercera actualización
 UPDATE UsuarioPerfil SET CodigoUsuario = 1 WHERE CodigoPerfil < 3;

 -- Almacenamos el posible código de error
 SET @ErrorSentencia3 = @@Error;
 IF (@ErrorSentencia3 <> 0)
 BEGIN
     SET @CadenaError = @CadenaError + 'Actualización 3; '
     SET @CodigosError = @CodigosError + CAST(@ErrorSentencia3 AS VARCHAR(10)) + '; ';
 END

 -- En ausencia de errores, comprometemos la transacción
 IF (@ErrorSentencia1 = 0) AND (@ErrorSentencia2 = 0) AND (@ErrorSentencia3 = 0)

BEGIN
     COMMIT TRAN;
     PRINT('Transacción realizada con éxito');
 END
 ELSE
 BEGIN
     ROLLBACK TRAN;
     PRINT('Transacción abortada');
     PRINT(@CadenaError);
     PRINT(@CodigosError);
 END

Con todo esto, obtendremos suficiente información (esperemos) como para detectar donde está el fallo.

SELECT Nombre + ' ' + Apellido1 + ' ' + Apellido2 AS NombreCompleto FROM Usuario

Es decir: concatenar varios campos y devolverlo como uno solo. Ante esto existe un problema bastante común: ¿Qué ocurre cuando uno de estos campos es NULL?
Si uno de estos campos es NULL, por defecto el registro devolverá NULL. Esto es, si tenemos un usuario llamado Santiago, cuyo primer apellido es López y su segundo apellido no consta en la base de datos, el resultado de concatenar Santiago + López + NULL será NULL.

Una posible solución a este problema es utilizar condicionales dentro de la propia sentencia T-SQL, haciendo algo así:

SELECT U.IdUsuario, U.Nombre + ' ' + CASE 
     WHEN U.Apellido1 is NULL THEN '' 
     ELSE U.Apellido1 END + ' ' + CASE 
     WHEN U.Apellido2 is NULL THEN ' ' 
     ELSE U.Apellido2 END AS NombreCompleto
FROM Usuario U

Esto nos devolverá una columna “NombreCompleto” con los campos concatenados correctamente, sin temor a que éstos sean NULL.

La razón es la siguiente: hemos visto previamente, cuando hablábamos del patrón DAO, que la necesidad de crear entidades DTO para cada tabla de la base de datos era una realidad.

Bien, hasta aquí todo claro. Pero… ¿y si fuese posible crear estos ficheros de forma automática? ¿Cómo? Preguntándole a la base de datos qué tablas y campos posee, y generando a partir de ellos el código necesario para implementar un DTO. Y todo ello sin despeinarnos.
Este artículo trata de hacer un breve inciso en el principio en el que se basa dicha generación de código. Únicamente veremos el mecanismo por el cual preguntar a la base de datos por estos parámetros. Hecho esto, podremos crear un fichero fuente con facilidad.

Para comenzar, declararemos un método que, a partir de una conexión de tipo Sql Server, devuelva un DataSet con una colección de tablas, cuyo nombre sea el propio nombre de la tabla y sus campos sean los datos de dichas tablas que queramos obtener.

      public DataSet ObtenerEsquemaBD(SqlConnection Conexion)
        {

Lo primero que haremos será abrir la conexión, con su correspondiente comprobación de nulos (es decir, si la conexión existe o no).

            try
            {
                if (!(Conexion == null))
                {
                    // Abrimos la conexión
                    if (!(Conexion.State == ConnectionState.Open))
                    {
                        Conexion.Open();
                    }

Seguidamente, crearemos un DataTable para almacenar los nombres de las tablas de la base de datos, así como un DataSet y un DataAdapter para almacenar los datos de las consultas. Utilizaremos una cadena de texto para almacenar las sentencias de las consultas.

                    // Creamos un DataTable para almacenar los nombres de las tablas de la base de datos
                    DataTable dtTablas = new DataTable();

                    // Creamos un DataSet y un DataAdapter para obtener los datos
                    DataSet ds = new DataSet();
                    SqlDataAdapter da = new SqlDataAdapter();

                    // Declaramos una cadena para la consulta
                    string sSQL;

Indicaremos que queremos obtener las tablas de la Base de Datos, y lo almacenamos en el DataTable destinado a ello mediante el DataAdapter

                    sSQL = "SELECT TABLE_NAME as Tabla FROM Information_Schema.Tables";
                    da.SelectCommand = new SqlCommand(sSQL, Conexion);
                    da.Fill(dtTablas);

Ahora recorreremos la tabla que contiene los nombres de cada tabla, realizando una consulta por cada una de ellas. En esta consulta obtendremos datos como el nombre de columna, si admite nulos o no, el tipo de dato…

                    foreach (DataRow dr in dtTablas.Rows)
                    {
                        if(!dr.IsNull("Tabla"))
                        {
                            DataTable dt = new DataTable();
                            sSQL = ("SELECT TABLE_CATALOG as Db, TABLE_NAME as Tabla, ORDINAL_POSITION as Posicion, COLUMN_NAME as Columna" +
                            ", IS_NULLABLE as AdmiteNulos, DATA_TYPE as TipoDatos, CHARACTER_MAXIMUM_LENGTH as MaxChar FROM Infor" +
                            "mation_Schema.Columns WHERE TABLE_NAME = \'"
                                        + (dr["Tabla"].ToString() + "\'"));
                            da.SelectCommand = new SqlCommand(sSQL, Conexion);
                            da.Fill(dt);

                            // Hecha la consulta, añadimos la tabla obtenida por este procedimiento a nuestro DataSet
                            dt.TableName = dr["Tabla"].ToString();
                            ds.Tables.Add(dt);
                        }
                    }

Finalmente, cerramos la conexión y devolvemos el DataSet

                    Conexion.Close();
                    return ds;
                }
                else
                {
                    Conexion.Close();
                    return null;
                }
            }
            catch (Exception ex)
            {
                throw(ex);
            }
        }

El resultado aparecerá en el DataSet, almacenando, por lo tanto, un esquema por cada tabla.