Crear un origen con el componente de script

Normalmente, un componente de origen utiliza un administrador de conexión existente para conectarse al origen de datos del que carga los datos en el flujo de datos. En la página Administradores de conexión del Editor de transformación Script, haga clic en Agregar para agregar el administrador de conexión adecuado.

Sin embargo, un administrador de conexión solo es una unidad práctica que encapsula y almacena la información necesaria para conectarse a un origen de datos de un tipo determinado. Debe escribir su propio código personalizado para cargar o guardar los datos y posiblemente también para abrir y cerrar la conexión al origen de datos.

Para obtener información general sobre cómo utilizar los administradores de conexión con el componente de script, vea Conectarse a orígenes de datos del componente de script.

Para obtener más información acerca de la página Administradores de conexión del Editor de transformación Script, vea Editor de transformación Scripts (página Administradores de conexión).

Un componente de origen no tiene ninguna entrada y admite una o más salidas. En la página Entradas y salidas del Editor de transformación Script, se ha creado una única salida de forma predeterminada, pero no se ha creado ninguna columna de salida. En esta página del editor, quizá necesite o desee configurar los elementos siguientes.

• Debe agregar y configurar manualmente las columnas de salida para cada salida. Seleccione la carpeta Columnas de salida para cada salida y, a continuación, utilice los botones Agregar columna y Quitar columna para administrar las columnas de salida de cada salida del componente de origen. Después, hará referencia a las columnas de salida en el script por los nombres que asigna aquí, mediante las propiedades de descriptor de acceso con tipo creadas en el código generado automáticamente.

• Puede crear una o varias salidas adicionales, como una salida de error simulada para las filas que contienen valores inesperados. Utilice los botones Agregar salida y Quitar salida para administrar las salidas del componente de origen. Todas las filas de entrada se dirigen a todas las salidas disponibles a menos que también especifique un valor distinto de cero idéntico para la propiedad ExclusionGroup de las salidas si desea dirigir cada fila a sólo una de las salidas que comparten el mismo valor de ExclusionGroup. El valor entero determinado seleccionado para identificar el elemento ExclusionGroup no es significativo.

  [!NOTA]

  También puede utilizar un valor de la propiedad ExclusionGroup distinto de cero con una salida única si no desea generar la salida de todas las filas. Sin embargo, en este caso, debe llamar explícitamente al método DirectRowTo<outputbuffer> para cada fila que desea enviar a la salida.

• Puede asignar un nombre descriptivo a las salidas. Después, hará referencia a las salidas en el script por sus nombres, mediante las propiedades de descriptor de acceso con tipo creadas en el código generado automáticamente.

• Normalmente, varias salidas del mismo ExclusionGroup tienen las mismas columnas de salida. Sin embargo, si crea una salida de error simulada, quizá desee agregar más columnas que almacenen información de error. Para obtener información acerca de cómo el motor de flujo de datos procesa las filas de errores, vea Usar las salidas de error en un componente de flujo de datos. En el componente de script, sin embargo, debe escribir su propio código para llenar las columnas adicionales con la información de error adecuada. Para obtener más información, vea Simular una salida de error para el componente de script.

Para obtener más información acerca de la página Entradas y salidas del Editor de transformación Script, vea Editor de transformación Script (página Entradas y salidas).

Si desea usar en su script valores de variables ya existentes, puede agregar estas variables a los campos de propiedades de ReadOnlyVariables y ReadWriteVariables en la página Script del Editor de transformación Script.

Al introducir diversas variables en los campos de propiedades, separe los nombres de éstas por comas. Para introducir múltiples variables, también puede hacer clic en el botón de puntos suspensivos (…) situado junto a los campos de propiedades ReadOnlyVariables y ReadWriteVariables, y seleccionar a continuación las variables en el cuadro de diálogo Seleccionar variables.

Para obtener información general acerca de la forma de usar variables con el componente de script, vea Utilizar variables en el componente de script.

Para obtener más información acerca de la página Script del Editor de transformación Script, vea Editor de transformación Script (página Script).

Al abrir el IDE de VSTA después de crear y configurar un componente de origen, la clase ScriptMain modificable aparece en el editor de código. El código personalizado se escribe en la clase ScriptMain.

La clase ScriptMain incluye un código auxiliar para el método CreateNewOutputRows. CreateNewOutputRows es el método más importante en un componente de origen.

Si abre la ventana Explorador de proyectos de VSTA, puede ver que el componente de script también ha generado elementos de proyecto BufferWrapper y ComponentWrapper de sólo lectura. La clase ScriptMain hereda de la clase UserComponent en el elemento de proyecto ComponentWrapper.

En tiempo de ejecución, el motor de flujo de datos invoca el método PrimeOutput de la clase UserComponent, lo que invalida el método PrimeOutput de la clase primaria ScriptComponent. El método PrimeOutput a su vez llama a los métodos siguientes:

1. El método CreateNewOutputRows, que se invalida en ScriptMain para agregar filas del origen de datos a los búferes de salida, que al principio están vacíos.

2. El método FinishOutputs, que está vacío de forma predeterminada. Invalide este método en ScriptMain para realizar cualquier procesamiento que se exija para completar la salida.

3. El método privado MarkOutputsAsFinished, que llama al método SetEndOfRowset de la clase primaria ScriptBuffer para indicar al motor de flujo de datos que la salida ha finalizado. No tiene que llamar explícitamente a SetEndOfRowset en su propio código.

Para terminar de crear un componente de origen personalizado, puede escribir un script en los siguientes métodos disponibles en la clase ScriptMain.

1. Invalide el método AcquireConnections para conectarse al origen de datos externo. Extraiga el objeto de conexión, o la información de conexión necesaria, del administrador de conexión.

2. Invalide el método PreExecute para cargar datos, si puede cargar al mismo tiempo todos los datos de origen. Por ejemplo, puede ejecutar SqlCommand en una conexión ADO.NET a una base de datos SQL Server y cargar al mismo tiempo todos los datos de origen en SqlDataReader. Si debe cargar los datos de origen una fila a la vez (por ejemplo, al leer un archivo de texto), puede cargar los datos mientras recorre las filas en bucle en CreateNewOutputRows.

3. Utilice el método CreateNewOutputRows invalidado para agregar nuevas filas a los búferes de salida vacíos y rellenar los valores de cada columna en las nuevas filas de salida. Utilice el método AddRow de cada búfer de salida para agregar una nueva fila vacía y, a continuación, establezca los valores de cada columna. Normalmente copia los valores de las columnas cargadas del origen externo.

4. Invalide el método PostExecute para finalizar el procesamiento de los datos. Por ejemplo, puede cerrar la clase SqlDataReader que utilizó para cargar datos.

5. Invalide el método ReleaseConnections para desconectarse del origen de datos externo, si se requiere.

En este ejemplo se muestra un componente de origen que utiliza un administrador de conexión de ADO.NET existente para cargar datos de una tabla de SQL Server en el flujo de datos.

Si desea ejecutar este código de ejemplo, debe configurar el paquete y el componente de la siguiente forma:

1. Cree un administrador de conexión de ADO.NET que utilice el proveedor SqlClient para conectarse a la base de datos AdventureWorks.

2. Agregue un nuevo componente de script a la superficie del diseñador de flujo de datos y configúrelo como origen.

3. Abra el Editor de transformación Script. En la página Entradas y salidas, cambie el nombre de la salida predeterminada por un nombre más descriptivo como MyAddressOutput y agregue y configure las dos columnas de salida, AddressID y City.

4. En la página Administradores de conexión, agregue o cree el administrador de conexión de ADO.NET y déle un nombre como MyADONETConnection.

5. En la página Script, haga clic en Editar script y escriba el script que se indica a continuación. A continuación, cierre el entorno de desarrollo de scripts y el Editor de transformación Script.

6. Cree y configure un componente de destino, como un destino de SQL Server o el componente de destino de ejemplo que se muestra en Crear un destino con el componente de script, que espere las columnas AddressID y City. A continuación, conecte el componente de origen al destino. (Puede conectar directamente un origen a un destino sin ninguna transformación.) Puede crear una tabla de destino ejecutando el comando Transact-SQL siguiente en la base de datos AdventureWorks:

   CREATE TABLE [Person].[Address2](
       [AddressID] [int] NOT NULL,
       [City] [nvarchar](30) NOT NULL
   )
   

7. Ejecute el ejemplo.

   Imports System.Data.SqlClient
   ...
   Public Class ScriptMain
       Inherits UserComponent
   
       Dim connMgr As IDTSConnectionManager100
       Dim sqlConn As SqlConnection
       Dim sqlReader As SqlDataReader
   
       Public Overrides Sub AcquireConnections(ByVal Transaction As Object)
   
           connMgr = Me.Connections.MyADONETConnection
           sqlConn = CType(connMgr.AcquireConnection(Nothing), SqlConnection)
   
       End Sub
   
       Public Overrides Sub PreExecute()
   
           Dim cmd As New SqlCommand("SELECT AddressID, City, StateProvinceID FROM Person.Address", sqlConn)
           sqlReader = cmd.ExecuteReader
   
       End Sub
   
       Public Overrides Sub CreateNewOutputRows()
   
           Do While sqlReader.Read
               With MyAddressOutputBuffer
                   .AddRow()
                   .AddressID = sqlReader.GetInt32(0)
                   .City = sqlReader.GetString(1)
               End With
           Loop
   
       End Sub
   
       Public Overrides Sub PostExecute()
   
           sqlReader.Close()
   
       End Sub
   
       Public Overrides Sub ReleaseConnections()
   
           connMgr.ReleaseConnection(sqlConn)
   
       End Sub
   
   End Class
   

   using System.Data.SqlClient;
   public class ScriptMain:
       UserComponent
   
   {
       IDTSConnectionManager100 connMgr;
       SqlConnection sqlConn;
       SqlDataReader sqlReader;
   
       public override void AcquireConnections(object Transaction)
       {
           connMgr = this.Connections.MyADONETConnectionManager;
           sqlConn = (SqlConnection)connMgr.AcquireConnection(null);
   
       }
   
       public override void PreExecute()
       {
   
           SqlCommand cmd = new SqlCommand("SELECT AddressID, City, StateProvinceID FROM Person.Address", sqlConn);
           sqlReader = cmd.ExecuteReader();
   
       }
   
       public override void CreateNewOutputRows()
       {
   
           while (sqlReader.Read())
           {
               {
                   MyAddressOutputBuffer.AddRow();
                   MyAddressOutputBuffer.AddressID = sqlReader.GetInt32(0);
                   MyAddressOutputBuffer.City = sqlReader.GetString(1);
               }
           }
   
       }
   
       public override void PostExecute()
       {
   
           sqlReader.Close();
   
       }
   
       public override void ReleaseConnections()
       {
   
           connMgr.ReleaseConnection(sqlConn);
   
       }
   
   }
   

En este ejemplo se muestra un componente de origen que utiliza un administrador de conexión de archivos planos existente para cargar datos de un archivo plano en el flujo de datos. Los datos de origen del archivo plano se crean mediante su exportación desde SQL Server.

Si desea ejecutar este código de ejemplo, debe configurar el paquete y el componente de la siguiente forma:

1. Utilice el Asistente para importación y exportación de SQL Server para exportar la tabla Person.Address de la base de datos de ejemplo AdventureWorks a un archivo plano separado por comas. En este ejemplo se utiliza el nombre de archivo ExportedAddresses.txt.

2. Cree un administrador de conexión de archivos planos que se conecte al archivo de datos exportado.

3. Agregue un nuevo componente de script a la superficie del diseñador de flujo de datos y configúrelo como origen.

4. Abra el Editor de transformación Script. En la página Entradas y salidas, cambie el nombre de la salida predeterminada por un nombre más descriptivo, como MyAddressOutput. Agregue y configure las dos columnas de salida, AddressID y City.

5. En la página Administradores de conexión, agregue o cree el administrador de conexión de archivos planos utilizando un nombre descriptivo como MyFlatFileSrcConnectionManager.

6. En la página Script, haga clic en Editar script y escriba el script que se indica a continuación. A continuación, cierre el entorno de desarrollo de scripts y el Editor de transformación Script.

7. Cree y configure un componente de destino, como un destino de SQL Server o el componente de destino de ejemplo que se muestra en Crear un destino con el componente de script. A continuación, conecte el componente de origen al destino. (Puede conectar directamente un origen a un destino sin ninguna transformación.) Puede crear una tabla de destino ejecutando el comando Transact-SQL siguiente en la base de datos AdventureWorks:

   CREATE TABLE [Person].[Address2](
       [AddressID] [int] NOT NULL,
       [City] [nvarchar](30) NOT NULL
   )
   

8. Ejecute el ejemplo.

   Imports System.IO
   ...
   Public Class ScriptMain
       Inherits UserComponent
   
       Private textReader As StreamReader
       Private exportedAddressFile As String
   
       Public Overrides Sub AcquireConnections(ByVal Transaction As Object)
   
           Dim connMgr As IDTSConnectionManager100 = _
               Me.Connections.MyFlatFileSrcConnectionManager
           exportedAddressFile = _
               CType(connMgr.AcquireConnection(Nothing), String)
   
       End Sub
   
       Public Overrides Sub PreExecute()
           MyBase.PreExecute()
           textReader = New StreamReader(exportedAddressFile)
       End Sub
   
       Public Overrides Sub CreateNewOutputRows()
   
           Dim nextLine As String
           Dim columns As String()
   
           Dim delimiters As Char()
           delimiters = ",".ToCharArray
   
           nextLine = textReader.ReadLine
           Do While nextLine IsNot Nothing
               columns = nextLine.Split(delimiters)
               With MyAddressOutputBuffer
                   .AddRow()
                   .AddressID = columns(0)
                   .City = columns(3)
               End With
               nextLine = textReader.ReadLine
           Loop
   
       End Sub
   
       Public Overrides Sub PostExecute()
           MyBase.PostExecute()
           textReader.Close()
   
       End Sub
   
   End Class
   

   using System.IO;
   public class ScriptMain:
       UserComponent
   
   {
       private StreamReader textReader;
       private string exportedAddressFile;
   
       public override void AcquireConnections(object Transaction)
       {
   
           IDTSConnectionManager100 connMgr = this.Connections.MyFlatFileSrcConnectionManager;
           exportedAddressFile = (string)connMgr.AcquireConnection(null);
   
       }
   
       public override void PreExecute()
       {
           base.PreExecute();
           textReader = new StreamReader(exportedAddressFile);
       }
   
       public override void CreateNewOutputRows()
       {
   
           string nextLine;
           string[] columns;
   
           char[] delimiters;
           delimiters = ",".ToCharArray();
   
           nextLine = textReader.ReadLine();
           while (nextLine != null)
           {
               columns = nextLine.Split(delimiters);
               {
                   MyAddressOutputBuffer.AddRow();
                   MyAddressOutputBuffer.AddressID = columns[0];
                   MyAddressOutputBuffer.City = columns[3];
               }
               nextLine = textReader.ReadLine();
           }
   
       }
   
       public override void PostExecute()
       {
   
           base.PostExecute();
           textReader.Close();
   
       }
   
   }