Hi Carlos.
El left join funciona exacto como el left join de la base de datos. Es
decir, trae tantos registros como asociaciones alla con la tabla en la
derecha del join, y en caso de que no haya ningun registro asociado trae uno
solo con nulos en las columnas correspondientes en este caso a tickets.

En este caso project 3 no tiene asociacion asi que te trae solo los campos
de project 3 y nulo en tickets, project 1 y 2 traen 2 y 3 filas
respectivamente con todos los datos de los tickets llenos.

from P en este caso lo que hace es devuelver un arreglo de objetos ya que no
pusiste nada en el select. en la primer parte del arreglo de objetos tenes P
y en la segunda T.

Aca tenes un ejemplo de la documentacion de NHibernate para solucionar lo
que vos buscas


IEnumerable foosAndBars = sess.Enumerable(
    "select foo, bar from Foo foo, Bar bar " +
    "where bar.Date = foo.Date"
);
foreach (object[] tuple in foosAndBars)
{
    Foo foo = tuple[0]; Bar bar = tuple[1];
    ....
}

es decir haces el join y luego obtenes en una recorrida lo que corresponde a
p y a t de las tuplas.

Abrazo.

Tavo.

On Wed, Jun 25, 2008 at 8:43 PM, Carlos Peix <[EMAIL PROTECTED]> wrote:

>  Gustavo,
>
> Perdoname pero no entiendo bien los dos primeros parrafos. El ultimo lo
> entiendo y es tal como decis, yo quiero hacer el join fetch solo en algunos
> casos.
>
> Volviendo a mi caso, esta bien que me devuelva una lista con 6 proyectos
> (en realidad referencias repetdas) si tengo tres solamente en la base de
> datos? No deberia NH darse cuenta de que esta haciendo un join como
> optimizacion y que no tiene que repetir los proyectos?
>
> Carlos Peix
>
>  ------------------------------
>  *De:* [email protected] [mailto:
> [EMAIL PROTECTED] *En nombre de *Gustavo Ringel
> *Enviado el:* Miércoles, 25 de Junio de 2008 03:36 p.m.
>
> *Para:* [email protected]
> *Asunto:* [NHibernate-Hispano] Re: Asociaciones y joins (caso 1)
>
>   Carlos, lo que se te ocurrio es correcto si no haces fetch NHibernate
> podria ir luego y obtener los tickets con selects.
>
> Pero el resultado final del query va a ser 6 o con n+1 selects o segun tu
> estrategia actual 1 sola. A mi la estrategia me parece correcta, siempre y
> cuando sea lo que estas buscando.
>
> Por supuesto que ya se que lo sabes, pero si siempre quisieras hacer join y
> no solo para esta consulta lo podes poner en el mapping. Es decir, todo
> depede de si tenes consultas que usan los ticket y consultas que no.
>
> Gustavo.
> On Wed, Jun 25, 2008 at 8:31 PM, Carlos Peix <[EMAIL PROTECTED]>
> wrote:
>
>>  Gracias Gustavo,
>>
>> Lo que quiero es obtener todos los proyectos con sus tickets pero que use
>> un solo query a la base de datos (por cuestiones de optimizacion).
>>
>> Se me ocurrio que "from Project as p left join fetch p.Tickets order by
>> p.Code" deberia hacer justo eso.
>>
>> Por supuesto, esta prueba que estamos haciendo es una simplificacion de
>> una caso real mucho mas complejo.
>>
>> Gracias por tu tiempo.
>>
>> Carlos Peix
>>
>>  ------------------------------
>> *De:* [email protected] [mailto:
>> [EMAIL PROTECTED] *En nombre de *Gustavo Ringel
>> *Enviado el:* Miércoles, 25 de Junio de 2008 03:26 p.m.
>> *Para:* [email protected]
>> *Asunto:* [NHibernate-Hispano] Re: Asociaciones y joins (caso 1)
>>
>>   Hi Carlos, el query que estas haciendo ahi es algo como select P.*, T.*
>> FROM Project P LEFT JOIN Ticket T
>>
>> El cual trae todos los P y los T en una query y tantas filas como matches
>> alla en T y para el caso del projecto sin T trae nulos en T
>>
>> es decir tiene que traer 6...
>>
>> No tengo claro que esperas que devuelva la consulta...a mi gusto tiene que
>> devolver 6 exactamente como esta devolviendo.
>>
>> Gustavo.
>>
>>
>> On Wed, Jun 25, 2008 at 8:10 PM, Carlos Peix <[EMAIL PROTECTED]>
>> wrote:
>>
>>>
>>> Nhibernate 1.2.1.4000, .NET 1.1
>>>
>>> Tengo el siguiente caso, dos clases:
>>>
>>> // Clase Project
>>> public class Project
>>> {
>>>        //...
>>>        private string code;
>>>
>>>        private IList tickets = new ArrayList();
>>>        public IList Tickets
>>>        {
>>>                get { return ArrayList.ReadOnly(tickets); }
>>>        }
>>>
>>>        public Ticket AddTicket( string ticketText )
>>>        {
>>>                Ticket ticket = new Ticket(this, ticketText);
>>>                tickets.Add( ticket );
>>>                return ticket;
>>>        }
>>> }
>>>
>>> // y clase ticket
>>> public class Ticket
>>> {
>>>        public Ticket(Project project, string text)
>>>        {
>>>                this.project = project;
>>>                this.text = text;
>>>        }
>>>
>>>        //...
>>>
>>>        private Project project;
>>>        public Project Project
>>>        {
>>>                get { return project; }
>>>        }
>>>
>>>        //...
>>> }
>>>
>>> Mapeados asi:
>>>
>>>        <class name="Project" table="Projects">
>>>
>>>                <id name="Id"  column="Id">
>>>                        <generator class="guid"/>
>>>                </id>
>>>
>>>                <property name="Code" />
>>>                <property name="Description" />
>>>                <bag name="Tickets" inverse="true"
>>> cascade="all-delete-orphan" lazy="true">
>>>                        <key column="IdProject" />
>>>                        <one-to-many class="Ticket" />
>>>                </bag>
>>>
>>>        </class>
>>> Y
>>>        <class name="Ticket" table="Tickets">
>>>
>>>                <id name="Id"  column="Id">
>>>                        <generator class="guid"/>
>>>                </id>
>>>
>>>                <property name="Text" />
>>>                <many-to-one name="Project" column="IdProject"
>>> class="Project" />
>>>
>>>        </class>
>>>
>>> Luego creo tres proyectos en la base de datos:
>>>
>>>        Project project1 = new Project("1", "Project 1");
>>>        project1.AddTicket( "Ticket 1" );
>>>        project1.AddTicket( "Ticket 2" );
>>>
>>>        Project project2 = new Project("2", "Project 2");
>>>        project2.AddTicket( "Ticket 1" );
>>>        project2.AddTicket( "Ticket 2" );
>>>        project2.AddTicket( "Ticket 3" );
>>>
>>>        Project project3 = new Project("3", "Project 3");
>>>
>>> Ahora veamos el problema:
>>>
>>>        IQuery query = s.CreateQuery( "from Project as p left join fetch
>>> p.Tickets order by p.Code" );
>>>        IList list = query.List();
>>>        Assert.AreEqual( 3, list.Count );
>>>
>>> Este test falla, list.Count es igual a 6!, que es igual a la cantidad
>>> filas
>>> que devuelve el join. Dentro del IList tengo dos entradas a la misma
>>> instancia del projecto 1, tres a la del proyecto 2 y 1 del proyecto 3.
>>> Quiero usar el join fetch para que me cargue todos proyectos y tickets en
>>> un
>>> solo query.
>>>
>>> Por que? Hicimos algo mal?
>>>
>>> Si alguno esta interesado, tengo un proyecto con tests que demuestran
>>> esto y
>>> generan automaticamente la BD.
>>>
>>> Carlos Peix
>>>
>>>
>>>
>>
> >
>

--~--~---------~--~----~------------~-------~--~----~
Para escribir al Grupo, hágalo a esta dirección: 
[email protected]
Para más, visite: http://groups.google.com/group/NHibernate-Hispano
-~----------~----~----~----~------~----~------~--~---

Responder a