Création d'une source à l'aide du composant Script

En principe, une composant source utilise un gestionnaire de connexions existant pour se connecter à la source de données à partir de laquelle il charge des données dans le flux de données. Dans la page Gestionnaires de connexions de l'Éditeur de transformation de script, cliquez sur Ajouter pour ajouter le gestionnaire de connexions approprié.

Toutefois, un gestionnaire de connexions n'est qu'une unité pratique qui permet d'encapsuler et de stocker les informations dont il doit disposer pour se connecter à une source de données d'un type particulier. Vous devez écrire votre propre code personnalisé pour charger ou enregistrer vos données et éventuellement ouvrir et fermer la connexion à la source de données.

Pour des informations générales sur l'utilisation des gestionnaires de connexions avec le composant Script, consultez Connexion aux sources de données dans le composant Script.

Pour plus d'informations sur la page Gestionnaires de connexions de l'Éditeur de transformation de script, consultez Éditeur de transformation de script (Page Gestionnaire de connexions).

Un composant source ne possède pas d'entrée et prend en charge une ou plusieurs sorties. La page Entrées et sorties de l'Éditeur de transformation de script, montre qu'une seule sortie a été créée par défaut, mais qu'aucune colonne de sortie n'a été créée. Dans cette page de l'éditeur, vous pouvez avoir besoin ou envie de configurer les éléments suivants.

• Vous devez ajouter et configurer manuellement des colonnes de sortie pour chaque sortie. Sélectionnez le dossier Colonnes de sortie pour chaque sortie, puis utilisez les boutons Ajouter une colonne et Supprimer une colonne pour gérer les colonnes de sortie de chaque sortie du composant source. Vous ferez ultérieurement référence aux colonnes de sortie dans le script par le nom que vous leur assignez dans cette page, à l'aide des propriétés d'accesseur typées, créées dans le code généré automatiquement.

• Vous pouvez créer une ou plusieurs sorties supplémentaires, telles qu'une sortie d'erreur simulée pour les lignes qui contiennent des valeurs inattendues. Utilisez les boutons Ajouter une sortie et Supprimer une sortie pour gérer les sorties du composant source. Toutes les lignes d'entrée sont dirigées vers toutes les sorties disponibles, sauf si vous attribuez une valeur identique non nulle à la propriété ExclusionGroup de ces sorties, auquel cas vous pourrez diriger chaque ligne vers une seule de ces sorties partageant la même valeur ExclusionGroup. La valeur entière particulière sélectionnée pour identifier ExclusionGroup n'a pas d'importance.

  [!REMARQUE]

  Vous pouvez également utiliser une valeur de propriété ExclusionGroup non nulle avec une sortie unique lorsque vous ne souhaitez pas générer des sorties pour toutes les lignes. Toutefois, dans ce cas, vous devez appeler explicitement la méthode DirectRowTo<outputbuffer> pour chaque ligne que vous souhaitez envoyer à la sortie.

• Vous pouvez assigner un nom convivial aux sorties. Vous ferez ultérieurement référence aux sorties par leur nom dans le script, à l'aide des propriétés d'accesseur typées, créées dans le code généré automatiquement.

• Normalement, plusieurs sorties dans le même ExclusionGroup possèdent les mêmes colonnes de sortie. Toutefois, si vous créez une sortie d'erreur simulée, vous pouvez ajouter des colonnes supplémentaires pour stocker les informations d'erreur. Pour plus d'informations sur la manière dont le moteur de flux de données traite les lignes d'erreur, consultez Utilisation de sorties d'erreur dans un composant de flux de données. Dans le composant Script, vous devez cependant écrire votre propre code pour remplir les colonnes supplémentaires avec les informations d'erreur appropriées. Pour plus d'informations, consultez Simulation d'une sortie d'erreur pour le composant Script.

Pour plus d'informations sur la page Entrées et sorties de l'Éditeur de transformation de script, consultez Éditeur de transformation de script (page Entrées et sorties).

S'il existe des variables dont vous souhaitez utiliser les valeurs dans votre script, vous pouvez les ajouter dans les champs de propriété ReadOnlyVariables et ReadWriteVariables dans la page Script de l'Éditeur de transformation de script.

Lorsque vous entrez plusieurs variables dans les champs de propriété, séparez les noms de variables par des virgules. Vous pouvez également entrer plusieurs variables en cliquant sur le bouton de sélection (…) en regard des champs de propriété ReadOnlyVariables et ReadWriteVariables, puis en sélectionnant les variables dans la boîte de dialogue Sélectionner des variables.

Pour obtenir des informations générales sur l'utilisation de variables avec le composant Script, consultez Utilisation de variables dans le composant Script.

Pour plus d'informations sur la page Script de l'Éditeur de transformation de script, consultez Éditeur de transformation de script (page Script).

Lorsque vous ouvrez l'environnement de développement intégré VSTA après avoir créé et configuré un composant source, la classe ScriptMain modifiable apparaît dans l'éditeur de code. Vous pouvez écrire votre code personnalisé dans la classe ScriptMain.

La classe ScriptMain inclut un stub pour la méthode CreateNewOutputRows. CreateNewOutputRows est la méthode la plus importante d'un composant source.

Si vous ouvrez la fenêtre Explorateur de projets dans VSTA, vous constatez que le composant Script a également généré des éléments de projet BufferWrapper et ComponentWrapper en lecture seule. La classe ScriptMain hérite de la classe UserComponent dans l'élément de projet ComponentWrapper.

Au moment de l'exécution, le moteur de flux de données appelle la méthode PrimeOutput dans la classe UserComponent, qui substitue la méthode PrimeOutput de la classe parente ScriptComponent. La méthode PrimeOutput appelle à son tour les méthodes suivantes :

1. La méthode CreateNewOutputRows, que vous substituez dans ScriptMain pour ajouter des lignes de la source de données aux mémoires tampons de sortie, initialement vides.

2. La méthode FinishOutputs, vide par défaut. Substituez cette méthode dans ScriptMain pour effectuer les traitements requis pour terminer l'opération de sortie.

3. La méthode MarkOutputsAsFinished privée, qui appelle la méthode SetEndOfRowset de la classe parente ScriptBuffer pour indiquer au moteur de flux de données que l'opération de sortie est terminée. Vous n'avez pas besoin d'appeler SetEndOfRowset de manière explicite dans votre propre code.

Pour achever la création d'un composant source personnalisé, vous pouvez écrire le script dans les méthodes suivantes disponibles dans la classe ScriptMain.

1. Substituez la méthode AcquireConnections pour vous connecter à la source de données externe. Extrayez l'objet de connexion, ou les informations de connexion requises, du gestionnaire de connexions.

2. Substituez la méthode PreExecute pour charger des données, si vous pouvez charger toutes les donnée sources en même temps. Par exemple, vous pouvez exécuter SqlCommand sur une connexion ADO.NET à une base de données SQL Server et charger en même temps toutes les données sources dans SqlDataReader. Si vous devez charger les données sources une ligne à la fois, (par exemple, lors de la lecture d'un fichier texte) vous pouvez charger les données pendant que vous parcourez les lignes dans CreateNewOutputRows.

3. Utilisez la méthode CreateNewOutputRows substituée pour ajouter de nouvelles lignes aux mémoires tampons de sortie vides et remplir les valeurs de chaque colonne dans les nouvelles lignes de sortie. Utilisez la méthode AddRow de chaque mémoire tampon de sortie pour ajouter une nouvelle ligne vide, puis définissez les valeurs de chaque colonne. En général, vous pouvez copier les valeurs des colonnes chargées à partir de la source externe.

4. Substituez la méthode PostExecute pour terminer le traitement des données. Par exemple, vous pouvez fermer SqlDataReader qui vous a permis de charger des données.

5. Substituez la méthode ReleaseConnections pour vous déconnecter de la source de données externe, le cas échéant.

Cet exemple montre un composant source qui utilise un gestionnaire de connexions ADO.NET existant pour charger les données d'une table SQL Server dans le flux de données.

Si vous souhaitez exécuter cet exemple de code, vous devez configurer le package et le composant comme suit :

1. Créez un gestionnaire de connexions ADO.NET qui utilise le fournisseur SqlClient pour se connecter à la base de données AdventureWorks.

2. Ajoutez un nouveau composant Script à l'aire du concepteur de flux de données et configurez-le en tant que source.

3. Ouvrez l'Éditeur de transformation de script. Dans la page Entrées et sorties, renommez la sortie par défaut avec un nom plus descriptif, tel que MyAddressOutput, puis ajoutez et configurez les deux colonnes de sortie, AddressID et City.

4. Dans la page Gestionnaires de connexions, ajoutez ou créez le gestionnaire de connexions ADO.NET et attribuez-lui un nom, par exemple MyADONETConnection.

5. Dans la page Script, cliquez sur Modifier le script, puis entrez le script suivant. Ensuite, fermez l'environnement de développement de script et l'Éditeur de transformation de script.

6. Créez et configurez un composant de destination, tel qu'une destination SQL Server, ou l'exemple de composant de destination présenté dans Création d'une destination à l'aide du composant Script, qui attend les colonnes AddressID et City. Puis, connectez le composant source à la destination. (Vous pouvez connecter directement une source à une destination sans transformation.) Vous pouvez créer une table de destination en exécutant la commande Transact-SQL suivante dans la base de données AdventureWorks :

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

7. Exécutez l'exemple.

   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);
   
       }
   
   }
   

Cet exemple montre un composant source qui utilise un gestionnaire de connexions de fichiers plats existant pour charger les données d'un fichier plat dans le flux de données. Vous pouvez créer des données sources de fichier plat en les exportant de SQL Server.

Si vous souhaitez exécuter cet exemple de code, vous devez configurer le package et le composant comme suit :

1. Utilisez l'Assistant Importation et Exportation SQL Server pour exporter la table Person.Address de l'exemple de base de données AdventureWorks vers un fichier plat délimité par des virgules. Cet exemple utilise le nom de fichier ExportedAddresses.txt.

2. Créez un gestionnaire de connexions de fichiers plats qui se connecte au fichier de données exporté.

3. Ajoutez un nouveau composant Script à l'aire du concepteur de flux de données et configurez-le en tant que source.

4. Ouvrez l'Éditeur de transformation de script. Dans la page Entrées et sorties, renommez la sortie par défaut avec un nom plus descriptif, tel que MyAddressOutput. Ajoutez et configurez les deux colonnes de sortie, AddressID et City.

5. Dans la page Gestionnaires de connexions, ajoutez ou créez le gestionnaire de connexions de fichiers plats, en lui attribuant un nom descriptif, tel que MyFlatFileSrcConnectionManager.

6. Dans la page Script, cliquez sur Modifier le script, puis entrez le script suivant. Ensuite, fermez l'environnement de développement de script et l'Éditeur de transformation de script.

7. Créez et configurez un composant de destination, tel qu'une destination SQL Server, ou l'exemple de composant de destination présenté dans Création d'une destination à l'aide du composant Script. Puis, connectez le composant source à la destination. (Vous pouvez connecter directement une source à une destination sans transformation.) Vous pouvez créer une table de destination en exécutant la commande Transact-SQL suivante dans la base de données AdventureWorks :

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

8. Exécutez l'exemple.

   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();
   
       }
   
   }