public static void Batch(long id)
        {
            using (var session = ConfigurationNHiberante.CreateSession())
            {
                //Prepara a query
                var query = session.CreateQuery("from Pessoa p where p.Id = :id")
                            .SetParameter("id", id)
                            .Future <Pessoa>();

                // Eager load na primeira lista
                session.CreateQuery(@"
                    from Pessoa p 
                    left join fetch p.Enderecos e 
                    where p.Id = :id")
                .SetParameter("id", id)
                .Future <Pessoa>();

                // Eager load na segunda lista
                session.CreateQuery(@"
                    from Pessoa p 
                    left join fetch p.Telefones t
                    left join fetch t.TipoTelefone tt
                    where p.Id = :id")
                .SetParameter("id", id)
                .Future <Pessoa>();

                Console.WriteLine(query.ToList().First());
            }
        }
 public static void SessionGet(long id)
 {
     using (var session = ConfigurationNHiberante.CreateSession())
     {
         var query = session.Get <Pessoa>(id);
         Console.WriteLine(query);
     }
 }
 public static void LazyLoad(long id)
 {
     using (var session = ConfigurationNHiberante.CreateSession())
     {
         var query = session.Query <Pessoa>()
                     .Where(pessoa => pessoa.Id == id);
         Console.WriteLine(query.ToList().First());
     }
 }
示例#4
0
 public static void LazyLoad(long id)
 {
     using (var session = ConfigurationNHiberante.CreateSession())
     {
         var query = session.CreateCriteria <Pessoa>()
                     .Add(Restrictions.Eq("Id", id));
         Console.WriteLine(query.List().First());
     }
 }
        public static void LazyLoad(long id)
        {
            using (var session = ConfigurationNHiberante.CreateSession())
            {
                //Prepara a query
                var query = session.CreateQuery("from Pessoa p where p.Id = :id")
                            .SetParameter("id", id);

                Console.WriteLine(query.List().First());
            }
        }
        public static void PessoaWithManyToManySet(long id)
        {
            using (var session = ConfigurationNHiberante.CreateSession())
            {
                var query = session.Query <Pessoa>()
                            .Where(p => p.Id == id)
                            .ProjectTo <PessoaWithManyToManySetDto>();

                Console.WriteLine(query.ToList().First());
            }
        }
示例#7
0
        public static void EagerLoad(long id)
        {
            using (var session = ConfigurationNHiberante.CreateSession())
            {
                var query = session.CreateCriteria <Pessoa>("p")
                            .Add(Restrictions.Eq("Id", id))
                            .CreateCriteria("p.Enderecos", JoinType.LeftOuterJoin)
                            .CreateCriteria("p.Telefones", "t", JoinType.LeftOuterJoin)
                            .CreateCriteria("t.TipoTelefone", "tt", JoinType.LeftOuterJoin);

                Console.WriteLine(query.List().First());
            }
        }
        public static void EagerLoad(long id)
        {
            using (var session = ConfigurationNHiberante.CreateSession())
            {
                var query = session.Query <Pessoa>()
                            .FetchMany(pessoa => pessoa.Enderecos)
                            .FetchMany(pessoa => pessoa.Telefones)
                            .ThenFetch(telefone => telefone.TipoTelefone)
                            .FetchMany(pessoa => pessoa.Carros)
                            .ThenFetchMany(carro => carro.Pessoas)
                            .Where(pessoa => pessoa.Id == id)
                            .ToList().First();

                Console.WriteLine(query);
            }
        }
        public static void EagerLoad(long id)
        {
            using (var session = ConfigurationNHiberante.CreateSession())
            {
                var query = session.CreateQuery(@"
                    from Pessoa p
                    left join fetch p.Enderecos e
                    left join fetch p.Telefones t
                    left join fetch t.TipoTelefone tt
                    where p.Id = :id")
                            .SetParameter("id", id)
                            .List <Pessoa>().First();

                Console.WriteLine(query);
            }
        }
        public static void EagerLoad(long id)
        {
            using (var session = ConfigurationNHiberante.CreateSession())
            {
                Telefone     telefoneAlias     = null;
                TipoTelefone tipoTelefoneAlias = null;

                var query = session.QueryOver <Pessoa>()
                            .Fetch(pessoa => pessoa.Enderecos).Eager
                            .Left.JoinAlias(pessoa => pessoa.Telefones, () => telefoneAlias)
                            .Left.JoinAlias(() => telefoneAlias.TipoTelefone, () => tipoTelefoneAlias)
                            .Where(pessoa => pessoa.Id == id)
                            .TransformUsing(Transformers.DistinctRootEntity)
                            .List().First();

                Console.WriteLine(query);
            }
        }
        public static void PaginationWithLinqWithCollectionEagerFetch()
        {
            using (var session = ConfigurationNHiberante.CreateSession())
            {
                var numberItens = 3;
                var pageNumber  = 2 * numberItens;

                var pageSubQuery = session.Query <Pessoa>()
                                   .OrderBy(p => p.Id)
                                   .Select(p => p.Id)
                                   .Skip(pageNumber)   // Número da página
                                   .Take(numberItens); // Quantidade de Itens por página

                var items = session.Query <Pessoa>()
                            .Where(w => pageSubQuery.Contains(w.Id))
                            .OrderBy(p => p.Id) // Importante ter a mesma ordenação da subquery
                            .FetchMany(p => p.Enderecos)
                            .ToFuture();

                /*
                 * Obs.: Qualquer filtro terá que ser repetida na subquery do count
                 *  e na na subquery da paginação!
                 */
                // Quantidade de pessoas totais
                var count = session.Query <Pessoa>()
                            .Select(p => p.Id)
                            .Distinct()
                            .ToFuture()
                            .Count();

                Console.WriteLine($"\nQuantidade de pessoas totais : {count}\n");

                foreach (var pessoa in items.ToList())
                {
                    Console.WriteLine($"Pessoa: {pessoa.Nome}");
                    Console.WriteLine($"Quantidade endreço: {pessoa.Enderecos.Count}");
                }
            }
        }
        public static void PaginationWithQueryOverWithCollectionEagerFetch()
        {
            using (var session = ConfigurationNHiberante.CreateSession())
            {
                // Garante a sintaxe para execução da subquery
                var subQuery = QueryOver.Of <Pessoa>();

                var numberItens = 3;
                var pageNumber  = 2 * numberItens;

                var pageSubQuery = subQuery.Clone()
                                   .OrderBy(p => p.Id).Asc
                                   .Select(p => p.Id)
                                   .Skip(pageNumber)   // Número da página
                                   .Take(numberItens); // Quantidade de Itens por página

                var items = session.QueryOver <Pessoa>()
                            .WithSubquery.WhereProperty(p => p.Id).In(pageSubQuery)
                            .OrderBy(p => p.Id).Asc // Importante ter a mesma ordenação da subquery
                            .Fetch(p => p.Enderecos).Eager
                            .TransformUsing(new DistinctRootEntityResultTransformer())
                            .Future();

                // Quantidade de pessoas totais
                var count = subQuery.GetExecutableQueryOver(session)
                            .Select(Projections.CountDistinct <Pessoa>(p => p.Id))
                            .FutureValue <int>();

                Console.WriteLine($"\nQuantidade de pessoas totais : {count.Value}\n");

                foreach (var pessoa in items.ToList())
                {
                    Console.WriteLine($"Pessoa: {pessoa.Nome}");
                    Console.WriteLine($"Quantidade endreço: {pessoa.Enderecos.Count}");
                }
            }
        }
        public static void Batch(long id)
        {
            using (var session = ConfigurationNHiberante.CreateSession())
            {
                Telefone     telefoneAlias     = null;
                TipoTelefone tipoTelefoneAlias = null;

                var query = session.QueryOver <Pessoa>()
                            .Where(pessoa => pessoa.Id == id)
                            .Future();

                session.QueryOver <Pessoa>()
                .Fetch(pessoa => pessoa.Enderecos).Eager
                .Future();

                session.QueryOver <Pessoa>()
                .Left.JoinAlias(pessoa => pessoa.Telefones, () => telefoneAlias)
                .Left.JoinAlias(() => telefoneAlias.TipoTelefone, () => tipoTelefoneAlias)
                .Future();


                Console.WriteLine(query.ToList().First());
            }
        }