Wie erzielt man mit nHibernate und QueryOver API ein eindeutiges Ergebnis?

Ich habe das Repository-Methode

    public IList<Message> ListMessagesBy(string text, IList<Tag> tags, int pageIndex, out int count, out int pageSize)
    {
        pageSize = 10;
        var likeString = string.Format("%{0}%", text);
        var query = session.QueryOver<Message>()
            .Where(Restrictions.On<Message>(m => m.Text).IsLike(likeString) || 
            Restrictions.On<Message>(m => m.Fullname).IsLike(likeString));

        if (tags.Count > 0)
        {
            var tagIds = tags.Select(t => t.Id).ToList();
            query
                .JoinQueryOver<Tag>(m => m.Tags)
                .WhereRestrictionOn(t => t.Id).IsInG(tagIds);
        }            

        count = 0;
        if(pageIndex < 0)
        {
            count = query.ToRowCountQuery().FutureValue<int>().Value;
            pageIndex = 0;
        }
        return query.OrderBy(m => m.Created).Desc.Skip(pageIndex * pageSize).Take(pageSize).List();
    }

Liefern Sie einen freien text search-string und eine Liste von Tags.
Das problem ist, dass wenn eine Nachricht mehr als einen tag, es ist mal dupliziert.
Ich möchte ein bestimmtes Ergebnis auf der Grundlage der Message-Entität. Ich habe

Projections.Distinct

Aber es erfordert eine Liste der Eigenschaften, um auf die deutliche Frage auf. Diese Meldung ist meiner Entität root gibt es die meisten ein Weg, um dieses Verhalten ohne die Bereitstellung alle von der Entität Eigenschaften?

Vielen Dank im Voraus, Anders

InformationsquelleAutor der Frage Anders | 2011-01-06

c#nhibernate queryover

61

Wenn Sie mit der ICriteria-API, die Sie benötigen:
```
.SetResultTransformer(new DistinctEntityRootTransformer())
```
Wenn Sie mit der QueryOver-API, die Sie benötigen:
```
.TransformUsing(Transformers.DistinctRootEntity)
```
Aber Vorsicht, dies alles geschieht auf der client-Seite, also alle doppelten Zeilen sind immer noch gezogen.

InformationsquelleAutor der Antwort Sly

Probieren Sie etwas wie dieses

public IPagedList<Client> Find(int pageIndex, int pageSize)
{
    Client clientAlias = null;

    var query = Session.QueryOver<Client>(() => clientAlias)

        .Select(
            Projections.Distinct(
                Projections.ProjectionList()
                    .Add(Projections.Property<Client>(x => x.Id).As("Id"))
                    .Add(Projections.Property<Client>(x => x.Name).As("Name"))
                    .Add(Projections.Property<Client>(x => x.Surname).As("Surname"))
                    .Add(Projections.Property<Client>(x => x.GivenName).As("GivenName"))
                    .Add(Projections.Property<Client>(x => x.EmailAddress).As("EmailAddress"))
                    .Add(Projections.Property<Client>(x => x.MobilePhone).As("MobilePhone"))
            )
        )
        .TransformUsing(Transformers.AliasToBean<Client>())

        .OrderBy(() => clientAlias.Surname).Asc
        .ThenBy(() => clientAlias.GivenName).Asc;

    var count = query
        .ToRowCountQuery()
        .FutureValue<int>();

    return query
        .Take(pageSize)
        .Skip(Pagination.FirstResult(pageIndex, pageSize))
        .List<Client>()
        .ToPagedList(pageIndex, pageSize, count.Value);
}

InformationsquelleAutor der Antwort Craig

11

Können Sie SelectList und GroupBy, e.g:
```
tags.SelectList(t => t.SelectGroup(x => x.Id))
```
Sollte funktionieren und produzieren die gleiche query plan als deutlich.

Wenn Sie mehrere Elemente in der Gruppe, etwas zu tun:
```
tags.SelectList(t => t.SelectGroup(x => x.Id)
                      .SelectGroup(x => x.Name)
               )
```
InformationsquelleAutor der Antwort Chris Haines

Ich habe vor kurzem eine Methode zur Anwendung select distinct basiert auf einem zugeordneten Objekt-Typ.
Es gilt diese zu einem IQueryOver-Objekt (Eigenschaft der Klasse). Methode hat auch Zugriff auf die nhibernate-Konfiguration. Man könnte hinzufügen, werden diese als Parameter der Methode. Braucht Arbeit für die Produktion, aber die Methode funktioniert wunderbar in dev, nur verwendet es für eine Person so weit.

Dieser Methode erstellt wurde, weil ich versucht bin, auf der Seite meine Daten auf der server-Ebene und eine ausgeprägte Ergebnis-Transformator nicht funktionieren würde.

Nachdem Sie Ihrem Objekt-Sammlung (Abfrage.Liste ()), die Sie haben können, um neu zu laden der Objekte zum Auffüllen einer zu viele untergeordnete Objekte enthalten sind. Viele zu eins-Zuordnungen werden Proxy für faule Lasten.

 public void DistinctRootProjectionList<E>()
    {
        var classMapping = Context.Config.GetClassMapping(typeof(E));
        var propertyIterator = classMapping.UnjoinedPropertyIterator;
        List<IProjection> projections = new List<IProjection>();
        ProjectionList list = Projections.ProjectionList();

        list.Add(Projections.Property(classMapping.IdentifierProperty.Name), classMapping.IdentifierProperty.Name);

        foreach (var item in propertyIterator)
        {
            if (item.Value.IsSimpleValue || item.Value.Type.IsEntityType)
            {
                list.Add(Projections.Property(item.Name), item.Name);
            }
        }
        query.UnderlyingCriteria.SetProjection(Projections.Distinct(list));
        query.TransformUsing(Transformers.AliasToBean<E>());
    }

Code, den ich verwendet, um die Last auf viele Beziehungen... T ist der entity-Typ.

for (int i = 0; i < resp.Data.Count; i++)
        {
            resp.Data[i] = session.Load<T>(GetInstanceIdValue(resp.Data[i]));
        }

InformationsquelleAutor der Antwort longday

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.