SELECT * FROM X WHERE id IN (…) avec Dapper ORM

Quelle est la meilleure façon d'écrire une requête avec la clause IN à l'aide de Dapper ORM lorsque la liste des valeurs de la clause IN provient de la logique métier? Par exemple, disons que j'ai une requête:

SELECT * 
  FROM SomeTable 
 WHERE id IN (commaSeparatedListOfIDs)

Le commaSeparatedListOfIDsest transmis à partir de la logique métier et il peut s'agir de n'importe quel type de IEnumerable(of Integer). Comment pourrais-je construire une requête dans ce cas? Dois-je faire ce que j'ai fait jusqu'à présent, qui est essentiellement une concaténation de chaînes ou existe-t-il une sorte de technique avancée de mappage de paramètres que je ne connais pas?

Dapper le prend en charge directement. Par exemple...

string sql = "SELECT * FROM SomeTable WHERE id IN @ids"
var results = conn.Query(sql, new { ids = new[] { 1, 2, 3, 4, 5 }});

Directement depuis la page d'accueil du projet GitHub :

Dapper vous permet de passer IEnumerable et paramètrera automatiquement votre requête.

connection.Query<int>(
    @"select * 
      from (select 1 as Id union all select 2 union all select 3) as X 
      where Id in @Ids", 
    new { Ids = new int[] { 1, 2, 3 });

Sera traduit en:

select * 
from (select 1 as Id union all select 2 union all select 3) as X 
where Id in (@Ids1, @Ids2, @Ids3)

// @Ids1 = 1 , @Ids2 = 2 , @Ids2 = 3

Si votre INclause est trop volumineuse pour être traitée par MSSQL, vous pouvez utiliser un TableValueParameter avec Dapper assez facilement.

1. Créez votre type TVP dans MSSQL:

   CREATE TYPE [dbo].[MyTVP] AS TABLE([ProviderId] [int] NOT NULL)

2. Créez un DataTableavec la même colonne (s) que le TVP et remplissez-le avec des valeurs

   var tvpTable = new DataTable();
   tvpTable.Columns.Add(new DataColumn("ProviderId", typeof(int)));
   // fill the data table however you wish

3. Modifiez votre requête Dapper pour faire une INNER JOINsur la table TVP:

   var query = @"SELECT * FROM Providers P
       INNER JOIN @tvp t ON p.ProviderId = t.ProviderId";

4. Passer le DataTable dans votre appel de requête Dapper

   sqlConn.Query(query, new {tvp = tvpTable.AsTableValuedParameter("dbo.MyTVP")});

Cela fonctionne également de manière fantastique lorsque vous souhaitez effectuer une mise à jour en masse de plusieurs colonnes - créez simplement un TVP et effectuez une UPDATEavec une jointure interne au TVP.

Voici probablement le moyen le plus rapide d'interroger un grand nombre de lignes avec Dapper à l'aide d'une liste d'ID. Je vous promets que c'est plus rapide que presque toutes les autres façons auxquelles vous pouvez penser (à l'exception possible de l'utilisation d'un TVP comme indiqué dans une autre réponse, et que je n'ai pas testé, mais je soupçonne qu'il peut être plus lent car vous devez encore remplir le TVP). Il s'agit de planètes plus rapides que Dapper utilisant la INsyntaxe et les univers plus rapidement que Entity Framework ligne par ligne. Et c'est même des continents plus rapides que de passer dans une liste de VALUESou des UNION ALL SELECTéléments. Il peut facilement être étendu pour utiliser une clé multi-colonnes, il suffit d'ajouter les colonnes supplémentaires à la DataTable, la table temporaire et les conditions de jointure.

public IReadOnlyCollection<Item> GetItemsByItemIds(IEnumerable<int> items) {
   var itemList = new HashSet(items);
   if (itemList.Count == 0) { return Enumerable.Empty<Item>().ToList().AsReadOnly(); }

   var itemDataTable = new DataTable();
   itemDataTable.Columns.Add("ItemId", typeof(int));
   itemList.ForEach(itemid => itemDataTable.Rows.Add(itemid));

   using (SqlConnection conn = GetConnection()) // however you get a connection
   using (var transaction = conn.BeginTransaction()) {
      conn.Execute(
         "CREATE TABLE #Items (ItemId int NOT NULL PRIMARY KEY CLUSTERED);",
         transaction: transaction
      );

      new SqlBulkCopy(conn, SqlBulkCopyOptions.Default, transaction) {
         DestinationTableName = "#Items",
         BulkCopyTimeout = 3600 // ridiculously large
      }
         .WriteToServer(itemDataTable);
      var result = conn
         .Query<Item>(@"
            SELECT i.ItemId, i.ItemName
            FROM #Items x INNER JOIN dbo.Items i ON x.ItemId = i.ItemId
            DROP TABLE #Items;",
            transaction: transaction,
            commandTimeout: 3600
         )
         .ToList()
         .AsReadOnly();
      transaction.Rollback(); // Or commit if you like
      return result;
   }
}

Sachez que vous devez en apprendre un peu plus sur les inserts en vrac. Il existe des options concernant le déclenchement des déclencheurs (la valeur par défaut est no), le respect des contraintes, le verrouillage de la table, l'autorisation des insertions simultanées, etc.

Assurez-vous également de ne pas placer de parenthèses autour de votre chaîne de requête comme ceci:

SELECT Name from [USER] WHERE [UserId] in (@ids)

J'ai eu cette cause une erreur de syntaxe SQL en utilisant Dapper 1.50.2, corrigée en supprimant les parenthèses

SELECT Name from [USER] WHERE [UserId] in @ids

Il n'est pas nécessaire d'ajouter ()la clause WHERE comme nous le faisons dans un SQL standard. Parce que Dapper le fait automatiquement pour nous. Voici le syntax: -

const string SQL = "SELECT IntegerColumn, StringColumn FROM SomeTable WHERE IntegerColumn IN @listOfIntegers";

var conditions = new { listOfIntegers };

var results = connection.Query(SQL, conditions);

Exemple pour postgres:

string sql = "SELECT * FROM SomeTable WHERE id = ANY(@ids)"
var results = conn.Query(sql, new { ids = new[] { 1, 2, 3, 4, 5 }});

Dans mon cas, j'ai utilisé ceci:

var query = "select * from table where Id IN @Ids";
var result = conn.Query<MyEntity>(query, new { Ids = ids });

ma variable "ids" dans la deuxième ligne est un IEnumerable de chaînes, elles peuvent aussi être des entiers je suppose.

D'après mon expérience, la façon la plus conviviale de gérer cela est d'avoir une fonction qui convertit une chaîne en une table de valeurs.

Il existe de nombreuses fonctions de séparation disponibles sur le Web, vous en trouverez facilement une pour votre goût de SQL.

Vous pouvez alors faire ...

SELECT * FROM table WHERE id IN (SELECT id FROM split(@list_of_ids))

Ou

SELECT * FROM table INNER JOIN (SELECT id FROM split(@list_of_ids)) AS list ON list.id = table.id

(Ou similaire)