SELEZIONA * DA X DOVE ID IN (...) con Dapper ORM

Qual è il modo migliore per scrivere una query con la clausola IN utilizzando Dapper ORM quando l'elenco di valori per la clausola IN proviene dalla logica aziendale? Ad esempio diciamo che ho una query:

SELECT * 
  FROM SomeTable 
 WHERE id IN (commaSeparatedListOfIDs)

Il commaSeparatedListOfIDsviene passato dalla logica di business e può essere qualsiasi tipo di IEnumerable(of Integer). Come costruirò una query in questo caso? Devo fare quello che ho fatto finora, che è fondamentalmente la concatenazione di stringhe o esiste una sorta di tecnica avanzata di mappatura dei parametri di cui non sono a conoscenza?

Dapper lo supporta direttamente. Per esempio...

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

Direttamente dalla homepage del progetto GitHub :

Dapper ti consente di passare a IEnumerable e parametrizza automaticamente la tua query.

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

Sarà tradotto in:

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

Se la tua INclausola è troppo grande per essere gestita da MSSQL, puoi usare un TableValueParameter con Dapper abbastanza facilmente.

1. Crea il tuo tipo TVP in MSSQL:

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

2. Crea un DataTablecon le stesse colonne del TVP e popolalo con i valori

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

3. Modifica la tua query Dapper per eseguire un'operazione INNER JOINsulla tabella TVP:

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

4. Passa la DataTable nella tua chiamata di query Dapper

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

Questo funziona anche in modo fantastico quando si desidera eseguire un aggiornamento di massa di più colonne: è sufficiente creare un TVP e farlo UPDATEcon un collegamento interno al TVP.

Ecco forse il modo più veloce per interrogare un gran numero di righe con Dapper usando un elenco di ID. Ti prometto che questo è più veloce di quasi tutti gli altri modi a cui riesci a pensare (con la possibile eccezione dell'uso di un TVP come indicato in un'altra risposta e che non ho testato, ma sospetto che potrebbe essere più lento perché devi ancora popolare il TVP). È i pianeti più veloce di Dapper usando la INsintassi e gli universi più velocemente di Entity Framework riga per riga. Ed è anche i continenti più veloce del passaggio in un elenco di VALUESo UNION ALL SELECTelementi. Può essere facilmente esteso per usare una chiave multi-colonna, basta aggiungere le colonne extra alla DataTable, la tabella temporanea e le condizioni di join.

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

Tieni presente che devi imparare qualcosa sugli inserti in serie. Esistono opzioni sull'attivazione dei trigger (il valore predefinito è no), il rispetto dei vincoli, il blocco della tabella, la possibilità di inserimenti simultanei e così via.

Assicurati inoltre di non avvolgere le parentesi attorno alla stringa della query in questo modo:

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

Ho avuto questo causa un errore di sintassi SQL utilizzando Dapper 1.50.2, risolto rimuovendo le parentesi

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

Non è necessario aggiungere ()la clausola WHERE come facciamo in un normale SQL. Perché Dapper lo fa automaticamente per noi. Ecco il syntax: -

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

var conditions = new { listOfIntegers };

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

Esempio per Postgres:

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

Nel mio caso ho usato questo:

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

la mia variabile "ids" nella seconda riga è un IEnumerable di stringhe, anche loro possono essere numeri interi.

Nella mia esperienza, il modo più amichevole di gestirlo è avere una funzione che converte una stringa in una tabella di valori.

Ci sono molte funzioni splitter disponibili sul web, ne troverai facilmente una per qualunque sia il tuo sapore di SQL.

Puoi quindi fare ...

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

O

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

(O simili)