NHibernate - CreateCriteria vs CreateAlias

En supposant que le scénario suivant:

class Project{
   public Job Job;
}

class Job{
   public Name;
}

En supposant que je veux utiliser l'API des Critères de recherche pour tous les projets dont le Travail porte le nom "sumthing".

Je pouvais utiliser le CreateAlias pour créer un alias pour l'Emploi et l'utiliser pour accéder Nom, ou je pourrais créer un nouveau critère pour le bien de l'Emploi et de la recherche par Nom.

Performance sage, est-il une différence?

InformationsquelleAutor Megacan | 2009-05-22

compte tenu de ces exigences, il n'y aurait pas de différence, le SQL généré est le même:
pour mappages:

    <?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
    <class name="Project" table="Project">
        <id name="Id" type="Int32" unsaved-value="0">
            <column name="Id" sql-type="int" not-null="true" unique="true"/>
            <generator class="native" />
        </id>
        <many-to-one name="Job" column="FK_JobId" cascade="save-update" not-null="true" />
    </class>
</hibernate-mapping>
<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
    <class name="Job" table="Job">
        <id name="Id" type="Int32" unsaved-value="0">
            <column name="Id" sql-type="int" not-null="true" unique="true"/>
            <generator class="native" />
        </id>
        <property name="Name" type="String">
            <column name="Name" sql-type="nvarchar" length="50" not-null="true"/>
        </property>
    </class>
</hibernate-mapping>

et les classes

public class Project
    {
        public Project() { }

        public virtual int Id { get; set; }

        public virtual Job Job { get; set; }
    }
public class Job
    {
        public Job() { }

        public virtual int Id { get; set; }

        public virtual String Name { get; set; }
    }

ces définitions des critères de

ICriteria criteriacrit = session
  .CreateCriteria(typeof (Project))
  .CreateCriteria("Job", "job")
  .Add(Restrictions.Eq("job.Name", "sometextA"));

ICriteria aliascrit = session
  .CreateCriteria(typeof (Project))
  .CreateAlias("Job", "job")
  .Add(Restrictions.Eq("job.Name", "sometextB"));

générer le SQL

SELECT 
  this_.Id as Id2_1_, 
  this_.FK_JobId as FK2_2_1_, 
  job1_.Id as Id1_0_, 
  job1_.Name as Name1_0_ 
FROM 
  Project this_ 
  inner join Job job1_ 
    on this_.FK_JobId=job1_.Id 
WHERE job1_.Name = @p0; @p0 = 'sometextA'

SELECT 
  this_.Id as Id2_1_, 
  this_.FK_JobId as FK2_2_1_, 
  job1_.Id as Id1_0_, 
  job1_.Name as Name1_0_ 
FROM
  Project this_ 
  inner join Job job1_ 
    on this_.FK_JobId=job1_.Id 
WHERE job1_.Name = @p0; @p0 = 'sometextB'

noter cependant que la CreateAlias s'appuie sur les mappages de générer des associations alors que la CreateCriteria appel permet de spécifier JoinType.

donc, ces appels

ICriteria criteriacrit = session
  .CreateCriteria(typeof(Project))
  .CreateCriteria("Job",JoinType.LeftOuterJoin)
  .Add(Restrictions.Eq("Name", "sometextA"));

ICriteria aliascrit = session
  .CreateCriteria(typeof (Project))
  .CreateAlias("Job", "job")
  .Add(Restrictions.Eq("job.Name", "sometextB"));

générer ces instructions SQL

SELECT 
  this_.Id as Id2_1_, 
  this_.FK_JobId as FK2_2_1_, 
  job1_.Id as Id1_0_, 
  job1_.Name as Name1_0_ 
FROM 
  Project this_ 
  **left outer** join Job job1_
    on this_.FK_JobId=job1_.Id 
WHERE job1_.Name = @p0; @p0 = 'sometextA'

SELECT 
  this_.Id as Id2_1_, 
  this_.FK_JobId as FK2_2_1_, 
  job1_.Id as Id1_0_, 
  job1_.Name as Name1_0_ 
FROM Project this_ 
  **inner join** Job job1_ 
    on this_.FK_JobId=job1_.Id 
WHERE job1_.Name = @p0; @p0 = 'sometextB'

Mais vous pouvez spécifier le type de jointure dans la CreateAlias surcharge? CreateAlias semble toujours par défaut à la jointure interne pour moi...même quand le many-to-one permet à null.
Oui avec NH2++ le CreateAlias permet également de spécifier un JoinType substitution de la mappés à des associations. Je suppose que depuis le CreateCriteria retourne un ICriteria objet ("racine" à l'entité associée), il peut être possible de générer différents (avancé) les requêtes depuis le générés ICriteria peuvent être manipulés dans de multiples façons.

InformationsquelleAutor Jaguar

Pour expliquer la différence entre CreateCriteria et CreateAlias dans NHibernate 2.0 + permet de voir le domaine suivant modèle.

public class Product
{
    public virtual int Id { get; private set; }
    public virtual string Name { get; set; }
    public virtual decimal Price { get; set; }
    public virtual Category Category { get; set; }
    public virtual IList<ProductStock> ProductStocks { get; set; }
}

public class Category
{
    public virtual int Id { get; private set; }
    public virtual string Name { get; set; }
    public virtual IList<Product> Products { get; set; }
}

public class ProductStock
{
    public virtual int Id { get; private set; }
    public virtual Product Product { get; set; }
    public virtual string WarehouseName { get; set; }
    public virtual int Stock { get; set; }
}

Maintenant, si vous écrivez des critères suivants pour jointure interne de ces entités

var criteria = DetachedCriteria.For<Product>()
                .CreateCriteria("Category", JoinType.InnerJoin)
                .CreateCriteria("ProductStocks", "ps", JoinType.InnerJoin)
                .Add(Restrictions.Le("ps.Stock",10));

Les critères ci-dessus ne fonctionnent pas, parce que lors de la première CreateCriteria exécute retour "Catégorie" de l'entité, par conséquent, lors de la deuxième CreateCriteria exécuter il l'habitude de trouver des biens ProductStocks dans la "Catégorie" de l'entité et la requête échoue.

Donc la bonne façon d'écrire ce critère est

var criteria = DetachedCriteria.For<Product>()
                .CreateAlias("Category", "c", JoinType.InnerJoin)
                .CreateCriteria("ProductStocks", "ps", JoinType.InnerJoin)
                .Add(Restrictions.Le("ps.Stock",10));

Lors de la première CreateAlias exécute retour "Produit" de l'entité, lors de la deuxième CreateCriteria exécuter trouverez propriété ProductStocks dans le "Produit" de l'entité.

Donc le TSQL sera comme ceci.

SELECT this_.ProductID     as ProductID8_2_,
       this_.Name          as Name8_2_,
       this_.Price         as Price8_2_,
       this_.CategoryID    as CategoryID8_2_,
       ps2_.ProductStockID as ProductS1_9_0_,
       ps2_.Stock          as Stock9_0_,
       ps2_.ProductID      as ProductID9_0_,
       ps2_.WarehouseID    as Warehous4_9_0_,
       c1_.CategoryID      as CategoryID0_1_,
       c1_.Name            as Name0_1_
FROM   [Product] this_
       inner join [ProductStock] ps2_ on this_.ProductID = ps2_.ProductID
       inner join [Category] c1_ on this_.CategoryID = c1_.CategoryID
WHERE  ps2_.Stock <= 10

J'espère que cela aidera.

Cela fait beaucoup de sens et de réponses à la question d'origine.

InformationsquelleAutor Shafaat Hussain

7

createAlias() renvoie des critères d'origine comme c'est le résultat
createCriteria() renvoie nouveaux critères construit avec createCriteria

différence sera quand le chaînage de méthodes par exemple

cr.createAlias().ajouter(Restrictions.ilike (le"code","abc")) va ajouter une restriction de l'entité
cr.createCriteria (la"société mère","p").ajouter(Restrictions.ilike (le"code","abc")) va ajouter une restriction à son parent

InformationsquelleAutor Ahim

Vous devez vous connecter pour publier un commentaire.