C # SQL Server - Passer une liste à une procédure stockée

J'appelle une procédure stockée SQL Server à partir de mon code C #:

using (SqlConnection conn = new SqlConnection(connstring))
{
   conn.Open();
   using (SqlCommand cmd = new SqlCommand("InsertQuerySPROC", conn))
   {
      cmd.CommandType = CommandType.StoredProcedure;

      var STableParameter = cmd.Parameters.AddWithValue("@QueryTable", QueryTable);
      var NDistanceParameter = cmd.Parameters.AddWithValue("@NDistanceThreshold", NDistanceThreshold);
      var RDistanceParameter = cmd.Parameters.AddWithValue(@"RDistanceThreshold", RDistanceThreshold);

      STableParameter .SqlDbType = SqlDbType.Structured;
      NDistanceParameter.SqlDbType = SqlDbType.Int;
      RDistanceParameter.SqlDbType = SqlDbType.Int;

      // Execute the query
      SqlDataReader QueryReader = cmd.ExecuteReader();

Mon proc stocké est assez standard mais fait une jointure avec QueryTable(d'où la nécessité d'utiliser un proc stocké).

Maintenant: je veux ajouter une liste de chaînes List<string>,, au jeu de paramètres. Par exemple, ma requête proc stockée ressemble à ceci:

SELECT feature 
FROM table1 t1 
INNER JOIN @QueryTable t2 ON t1.fid = t2.fid 
WHERE title IN <LIST_OF_STRINGS_GOES_HERE>

Cependant, la liste des chaînes est dynamique et longue de quelques centaines.

Existe-t-il un moyen de passer une liste de chaînes List<string>au proc stocké ??? Ou y a-t-il une meilleure façon de faire cela?

Merci beaucoup, Brett

Si vous utilisez SQL Server 2008, il existe une nouvelle fonctionnalité appelée un type de table défini par l'utilisateur. Voici un exemple de son utilisation:

Créez votre type de table défini par l'utilisateur:

CREATE TYPE [dbo].[StringList] AS TABLE(
    [Item] [NVARCHAR](MAX) NULL
);

Ensuite, vous devez l'utiliser correctement dans votre procédure stockée:

CREATE PROCEDURE [dbo].[sp_UseStringList]
    @list StringList READONLY
AS
BEGIN
    -- Just return the items we passed in
    SELECT l.Item FROM @list l;
END

Enfin, voici quelques sql pour l'utiliser en c #:

using (var con = new SqlConnection(connstring))
{
    con.Open();

    using (SqlCommand cmd = new SqlCommand("exec sp_UseStringList @list", con))
    {
        using (var table = new DataTable()) {
          table.Columns.Add("Item", typeof(string));

          for (int i = 0; i < 10; i++)
            table.Rows.Add("Item " + i.ToString());

          var pList = new SqlParameter("@list", SqlDbType.Structured);
          pList.TypeName = "dbo.StringList";
          pList.Value = table;

          cmd.Parameters.Add(pList);

          using (var dr = cmd.ExecuteReader())
          {
            while (dr.Read())
                Console.WriteLine(dr["Item"].ToString());
          }
         }
    }
}

Pour l'exécuter à partir de SSMS

DECLARE @list AS StringList

INSERT INTO @list VALUES ('Apple')
INSERT INTO @list VALUES ('Banana')
INSERT INTO @list VALUES ('Orange')

-- Alternatively, you can populate @list with an INSERT-SELECT
INSERT INTO @list
   SELECT Name FROM Fruits

EXEC sp_UseStringList @list

Le modèle typique dans cette situation est de transmettre les éléments dans une liste délimitée par des virgules, puis en SQL de les diviser en une table que vous pouvez utiliser. La plupart des gens créent généralement une fonction spécifiée pour faire cela comme:

 INSERT INTO <SomeTempTable>
 SELECT item FROM dbo.SplitCommaString(@myParameter)

Et puis vous pouvez l'utiliser dans d'autres requêtes.

Non, les tableaux / listes ne peuvent pas être transmis directement à SQL Server.

Les options suivantes sont disponibles:

1. Passer une liste délimitée par des virgules, puis avoir une fonction en SQL, diviser la liste. La liste délimitée par des virgules sera très probablement passée sous la forme d'un Nvarchar ()
2. Transmettez xml et demandez à une fonction dans SQL Server d'analyser le XML pour chaque valeur de la liste
3. Utiliser le nouveau type de table défini par l'utilisateur (SQL 2008)
4. Construisez dynamiquement le SQL et transmettez la liste brute en tant que "1,2,3,4" et créez l'instruction SQL. Ceci est sujet aux attaques par injection SQL, mais cela fonctionnera.

Oui, définissez le paramètre proc stocké sur VARCHAR(...) Et puis passez les valeurs séparées par des virgules à une procédure stockée.

Si vous utilisez Sql Server 2008, vous pouvez tirer parti de TVP ( paramètres de valeur de table ): SQL 2008 TVP et LINQ si la structure de QueryTable est plus complexe que le tableau de chaînes, sinon ce serait excessif car le type de table doit être créé dans SQl Server

Créez un datatable avec une colonne au lieu de List et ajoutez des chaînes à la table. Vous pouvez passer ce datatable en tant que type structuré et effectuer une autre jointure avec le champ title de votre table.

Si vous préférez fractionner une liste CSV en SQL, il existe une manière différente de le faire à l'aide d' expressions de table communes (CTE). Voir moyen efficace de split chaîne en utilisant CTE .

Le seul moyen dont je suis conscient est de créer une liste CSV, puis de la passer sous forme de chaîne. Ensuite, du côté SP, divisez-le et faites tout ce dont vous avez besoin.

CREATE TYPE [dbo].[StringList1] AS TABLE(
[Item] [NVARCHAR](MAX) NULL,
[counts][nvarchar](20) NULL);

créer un TYPE comme table et le nommer "StringList1"

create PROCEDURE [dbo].[sp_UseStringList1]
@list StringList1 READONLY
AS
BEGIN
    -- Just return the items we passed in
    SELECT l.item,l.counts FROM @list l;
    SELECT l.item,l.counts into tempTable FROM @list l;
 End

Créez une procédure comme ci-dessus et nommez-la comme "UserStringList1" s

String strConnection = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString.ToString();
            SqlConnection con = new SqlConnection(strConnection);
            con.Open();
            var table = new DataTable();

            table.Columns.Add("Item", typeof(string));
            table.Columns.Add("count", typeof(string));

            for (int i = 0; i < 10; i++)
            {
                table.Rows.Add(i.ToString(), (i+i).ToString());

            }
                SqlCommand cmd = new SqlCommand("exec sp_UseStringList1 @list", con);


                    var pList = new SqlParameter("@list", SqlDbType.Structured);
                    pList.TypeName = "dbo.StringList1";
                    pList.Value = table;

                    cmd.Parameters.Add(pList);
                    string result = string.Empty;
                    string counts = string.Empty;
                    var dr = cmd.ExecuteReader();

                    while (dr.Read())
                    {
                        result += dr["Item"].ToString();
                        counts += dr["counts"].ToString();
                    }

dans le c #, essayez ceci