Quale ORM supporta questo

Question

Ho una parte facoltativa di query che deve essere eseguita su una determinata condizione. Ecco il codice di esempio:

int cat = 1; 
int UserID = 12; 
string qry = "select * from articles"; 
if(cat > 0) 
    qry += " where categoryID = " + cat; 
if(UserID > 0) 
    qry += " AND userid = " + UserID; //The AND may be a WHERE if first condition is false 

Come si può vedere, ho un'istruzione if nella query. Attualmente sto usando Entity Framework e non supporta questo tipo di scenario. C'è un ORM là fuori che supporta questo?

Modifica Ho cercato di nascondere la query. Ma ho circa 20 dichiarazioni "IF" e le querys sono molto lunghe.

I ORM stavo guardando erano:

• NHibernate
• LLBLGen
• Subsonic

Sono aperto a qualsiasi ORM. Grazie

Answer 1

Probabilmente si può fare questo con qualsiasi provider LINQ, ma so che la LightSpeed ORM lo sostiene:

var query = UnitOfWork.Articles; 
if (cat > 0) 
    query = query.Where(a => a.CategoryId == cat); 

Answer 2

faccio questo genere di cose in NHibernate per tutto il tempo.

(Ho fatto cose simili in Rails. Sono un po 'sorpreso che ci sono ORM che non farlo supporto questo.)

Answer 3

questo può essere fatto utilizzando LINQ to SQL ...

IQueryable<Article> query = yourDataContext.Articles; 

if (catId > 0) 
    query = query.Where(x => x.CategoryId == catId); 

return query.ToList(); 

Answer 4

È possibile creare facilmente query in questo modo utilizzando HQL di NHibernate (linguaggio di interrogazione Hibernate). Sarebbe un'implementazione quasi identica, ma personalmente utilizzerei i parametri.

public List<Article> GetCat(int cat) 

    { 
     string qry = "select ap from Article a"; 
     if(cat > 0) 
      qry += " where a.categoryID = :cat"; 

     IQuery query = session.CreateQuery(qry).SetInt32("cat",cat); 

     return query.List<Article>(); 
    } 

Questo restituisce un oggetto <> di oggetti Articolo pronto per l'uso.

Answer 5

NHibernate supporta questa utilizzando l'API Criteri:

ICriteria criteria = session.CreateCriteria<Article>(); 

if (cat > 0) 
    criteria.Add(Expression.Eq("categoryID", cat)); 

Answer 6

È possibile utilizzare il predicato Builder e LINQ to NHibernate per generare domanda di dinamica come questa:

//using Predicate Builder 
     public List<Location> FindAllMatching(string[] filters) 
     { 
      var db = Session.Linq<Location>(); 
      var expr = PredicateBuilder.False<Location>(); //-OR- 
      foreach (var filter in filters) 
      { 
       string temp = filter; 
       expr = expr.Or(p => p.Name.Contains(temp)); 
      } 

      return db.Where(expr).ToList(); 
     } 

Si ottiene il vantaggio di Tipo file Query e controllo del compilatore.

È inoltre possibile utilizzare lo stesso approccio del generatore di predicati con Linq su Sql e Entity Framework.

MODIFICA: Aggiunto esempio. Potrebbe essere qualcosa come ottenere tutte le posizioni corrispondenti a N regioni del mondo, dove l'utente seleziona le regioni che vuole vedere, non sappiamo quanti l'utente selezionerà, dobbiamo costruire l'espressione (OR) sul volare, si può fare qualcosa di simile:

public ActionResult Action(string[] filters) 
{ 
    /*This values are provided by the user, maybe its better to use 
    an ID instead of the name, but for the example is OK. 
    filters will be something like : string[] filters = {"America", "Europe", "Africa"}; 
    */ 
    List<Location> LocationList = FindAllMatchingRegions(filters); 
    return View(LocationList); 
} 

public List<Location> FindAllMatchingRegions(string[] filters) 
     { 
      var db = Session.Linq<Location>(); 
      var expr = PredicateBuilder.False<Location>(); //-OR- 
      foreach (var filter in filters) 
      { 
       string temp = filter; 
       expr = expr.Or(p => p.Region.Name == filter); 
      } 

      return db.Where(expr).ToList(); 
     } 

potete predicati Nest per scenari complessi come questo:

Se si vuole fare qualcosa di simile

p => p.Price > 99 && 
    p.Price < 999 && 
    (p.Description.Contains ("foo") || p.Description.Contains ("far")) 

si può costruire:

var inner = PredicateBuilder.False<Product>(); 
inner = inner.Or (p => p.Description.Contains ("foo")); 
inner = inner.Or (p => p.Description.Contains ("far")); 

var outer = PredicateBuilder.True<Product>(); 
outer = outer.And (p => p.Price > 99); 
outer = outer.And (p => p.Price < 999); 
outer = outer.And (inner); 

e usarlo come:

var pr = db.Products.Where(outer).ToList(); 

il predicato Builder Fonte e gli esempi sono disponibili presso http://www.albahari.com/nutshell/predicatebuilder.aspx

Answer 7

Nessun amore per LLBLGen? Beh, può farlo anche tu.

Utilizzando lo stile 'adattatore':

RelationPredicateBucket filters = new RelationPredicateBucket(); 
if (cat > 0) 
    filters.Predicate.Add(Article.Fields.CategoryID == cat); 
if (userId > 0) 
    filters.Predicate.Add(Article.Fields.UserID == userId); 
// And so on. 

var adapter = new DataAccessAdapter(); 
var results = new EntityCollection<Article>(new ArticleFactory()); 
adapter.FetchEntityCollection(results, filters); 

ho il sospetto maggior parte ORM dovrebbero essere in grado di farlo abbastanza facilmente.

Answer 8

Come già menzionato qui, LINQ consente di estendere qualsiasi query aggiungendo semplicemente più criteri ad esso.

var query = 
    from x in xs 
    where x==1 
    select x; 

if (mustAddCriteria1) 
    query = 
    from x in query 
    where ... // criteria 1 
    select x; 

if (mustAddCriteria2) 
    query = 
    from x in query 
    where ... // criteria 2 
    select x; 

E così via. Questo approccio funziona perfettamente. Ma probabilmente, sai che la compilazione di query LINQ è piuttosto costosa: ad es. Entity Framework può compilare solo circa 500 query relativamente semplici al secondo (vedere ad esempio ORMBattle.NET).

D'altra parte, molti strumenti ORM supporta le query compilate:

• si passa un'istanza IQueryable a qualche metodo Compile, e ottenere un delegato che consente di eseguire molto più veloce più tardi, perché non ricompilazione avverrebbe in questo caso.

Ma se vorremmo provare a utilizzare questo approccio qui, notiamo subito che la nostra query è in realtà dinamica: IQueryable eseguiamo ogni volta che potrebbe differire da quella precedente. La presenza di parti di query è determinata dai valori dei parametri esterni.

Così possiamo eseguire tali query come compilate senza ad es. memorizzazione nella cache esplicita?

DataObjects.Net 4 supporta la cosiddetta funzione "boolean branching". Esso implica che qualsiasi espressione booleana costante viene valutata durante la compilazione della query e il suo valore effettivo viene iniettato nella query SQL come costante booleana vera (cioè non come valore del parametro o come espressione che utilizza parametri).

Questa funzione consente di generare diversi piani di query in base ai valori di tali espressioni booleane con facilità. Per esempio.questo codice:

int all = new Random().Next(2); 
    var query = 
    from c in Query<Customer>.All 
    where all!=0 || c.Id=="ALFKI" 
    select c; 

sarà eseguito utilizzando due diversi query SQL, e quindi - due diversi piani di query:

• Query piano basato su Index Seek (abbastanza veloce), se tutto == 0
• piano di query sulla base di indice di scansione (piuttosto lento), se tutto = 0

caso quando tutto == null, query SQL:

SELECT 
    [a].[CustomerId], 
    111 AS [TypeId] , 
    [a].[CompanyName] 
FROM 
    [dbo].[Customers] [a] 
WHERE((CAST(0 AS bit) <> 0) OR([a].[CustomerId] = 'ALFKI')); 

caso quando tutto == null, piano di query:

|--Compute Scalar(DEFINE:([Expr1002]=(111))) 
    |--Clustered Index Seek(OBJECT:([DO40-Tests].[dbo].[Customers].[PK_Customer] AS [a]), SEEK:([a].[CustomerId]=N'ALFKI') ORDERED FORWARD) 

secondo caso (quando tutto! = Null), query SQL: (! Quando tutti = null)

SELECT 
    [a].[CustomerId], 
    111 AS [TypeId] , 
    [a].[CompanyName] 
FROM 
    [dbo].[Customers] [a] 
WHERE((CAST(1 AS bit) <> 0) OR([a].[CustomerId] = 'ALFKI')); 
-- Notice the^value is changed! 

Secondo caso , piano di query:

|--Compute Scalar(DEFINE:([Expr1002]=(111))) 
    |--Clustered Index Scan(OBJECT:([DO40-Tests].[dbo].[Customers].[PK_Customer] AS [a])) 
-- There is index scan instead of index seek! 

Nota che quasi ogni altro ORM sarebbe compilare questo a una query utilizzando parametro intero:

SELECT 
    [a].[CustomerId], 
    111 AS [TypeId] , 
    [a].[CompanyName] 
FROM 
    [dbo].[Customers] [a] 
WHERE((@p <> 0) OR ([a].[CustomerId] = 'ALFKI')); 
--  ^^ parameter is used here 

Dal momento che SQL Server (così come la maggior parte delle basi di dati) genera una singola versione di piano di query per una determinata query, è l'unica opzione in questo caso - generare un piano con indice di scansione:

|--Compute Scalar(DEFINE:([Expr1002]=(111))) 
    |--Clustered Index Scan(OBJECT:([DO40-Tests].[dbo].[Customers].[PK_Customer] AS [a]), WHERE:(CONVERT(bit,[@p],0)<>(0) OR [DO40-Tests].[dbo].[Customers].[CustomerId] as [a].[CustomerId]=N'ALFKI')) 

Ok, questa era una spiegazione "rapida" dell'utilità di questa funzione. Torniamo al tuo caso ora.

ramificazione booleano consente di implementare in modo molto semplice:

var categoryId = 1; 
var userId = 1; 

var query = 
    from product in Query<Product>.All 
    let skipCategoryCriteria = !(categoryId > 0) 
    let skipUserCriteria = !(userId > 0) 
    where skipCategoryCriteria ? true : product.Category.Id==categoryId 
    where skipUserCriteria ? true : 
    (
    from order in Query<Order>.All 
    from detail in order.OrderDetails 
    where detail.Product==product 
    select true 
).Any() 
    select product; 

L'esempio differisce dalla vostra, ma illustra l'idea. Ho usato un modello diverso principalmente per essere in grado di testarlo (il mio esempio si basa sul modello om Northwind).

Questa domanda è:

Non
• una query dinamica, in modo da poter tranquillamente passarlo a Query.Execute(...) metodo per ottenerlo eseguito come query compilata.
• Ciononostante, ciascuna esecuzione porterà allo stesso risultato come se ciò avvenisse con "accodamento" a IQueryable.