Examples of siena.core.options.QueryOptionPage

siena.core.options.QueryOptionPage

  }
  
  protected <T> void preFetch(Query<T> query, int limit, int offset, boolean recursing){
    QueryOptionSdbContext sdbCtx = (QueryOptionSdbContext)query.option(QueryOptionSdbContext.ID);
    QueryOptionState state = (QueryOptionState)query.option(QueryOptionState.ID);
    QueryOptionPage pag = (QueryOptionPage)query.option(QueryOptionPage.ID);
    QueryOptionOffset off = (QueryOptionOffset)query.option(QueryOptionOffset.ID);


    if(sdbCtx==null){
      sdbCtx = new QueryOptionSdbContext();
      query.customize(sdbCtx);
    }
    
    if(!pag.isPaginating()){
      if(state.isStateless()){
        // if not empty, it means we are recursing on tokens
        sdbCtx.reset(recursing);        
      }
      // no pagination but pageOption active
      if(pag.isActive()){        
        // if local limit is set, it overrides the pageOption.pageSize
        if(limit!=Integer.MAX_VALUE){
          sdbCtx.realPageSize = limit;        
          // DONT DO THAT BECAUSE IT PREVENTS GOING TO NEXT TOKENS USING PAGE SIZE
          // pageOption is passivated to be sure it is not reused
          //pag.passivate();
        }
        // using pageOption.pageSize
        else {
          sdbCtx.realPageSize = pag.pageSize;
          // DONT DO THAT BECAUSE IT PREVENTS GOING TO NEXT TOKENS USING PAGE SIZE
          // passivates the pageOption in stateless mode not to keep anything between 2 requests
          //if(state.isStateless()){
          //  pag.passivate();
          //}            
        }
      }
      else {
        if(limit != Integer.MAX_VALUE){
          sdbCtx.realPageSize = limit;
          // activates paging (but not pagination)
          pag.activate();
        }else {
          sdbCtx.realPageSize = 0;
        }
      }
    }else {

View Full Code Here

  
  public static Map<Integer, QueryOption> defaultOptions() {
    return new HashMap<Integer, QueryOption>() {
      private static final long serialVersionUID = -7438657296637379900L;
      {
        put(QueryOptionPage.ID, new QueryOptionPage(0));
        put(QueryOptionOffset.ID, new QueryOptionOffset(0));
        put(QueryOptionState.ID, new QueryOptionState());
        //the fetch type is activated by default and set to NORMAL
        put(QueryOptionFetchType.ID, (new QueryOptionFetchType()).activate());
      }};

View Full Code Here

    ownees.add(0, new QueryOwned(owner, field));
  }
  
  protected void optionPaginate(int pageSize) {
    // sets the pagination
    QueryOptionPage opt = (QueryOptionPage)(options.get(QueryOptionPage.ID));
    QueryOptionOffset offOpt = (QueryOptionOffset)options.get(QueryOptionOffset.ID);
    //QueryOptionState stateOpt = (QueryOptionState)(options.get(QueryOptionState.ID)).activate();
    // can't change pagination after it has been initialized because it breaks all the cursor mechanism
    
    /*if(opt.isActive() && opt.isPaginating()){
      throw new SienaException("Can't change pagination after it has been initialized...");
    }*/
    
    opt.activate();
    opt.pageSize=pageSize;
    opt.pageType = QueryOptionPage.PageType.PAGINATING;
    
    // resets offset to be sure nothing changes the pagination mechanism
    offOpt.offsetType = QueryOptionOffset.OffsetType.PAGINATING;

View Full Code Here

    }*/
  }
  
  protected void optionLimit(int limit) {
    // sets the pagination
    QueryOptionPage pagOpt = (QueryOptionPage)(options.get(QueryOptionPage.ID));
    //QueryOptionOffset offOpt = (QueryOptionOffset)options.get(QueryOptionOffset.ID);
    //QueryOptionState stateOpt = (QueryOptionState)(options.get(QueryOptionState.ID));
    
    pagOpt.activate();
    pagOpt.pageSize = limit;
    pagOpt.pageType = QueryOptionPage.PageType.MANUAL;
    
    // in stateless mode, we must reset the offset as we don't want it to be stateful
    //if(stateOpt.isStateless() && !offOpt.isManual()){

View Full Code Here

    //  offOpt.offset = 0;
    //}
  }
  
  protected void optionOffset(int offset) {
    QueryOptionPage pagOpt = (QueryOptionPage)(options.get(QueryOptionPage.ID));
    QueryOptionOffset offOpt = (QueryOptionOffset)options.get(QueryOptionOffset.ID);
    //QueryOptionState stateOpt = (QueryOptionState)(options.get(QueryOptionState.ID));
    
    offOpt.activate();
    offOpt.offsetType = QueryOptionOffset.OffsetType.MANUAL;

View Full Code Here

    
    QueryOptionState state = (QueryOptionState)query.option(QueryOptionState.ID);
    QueryOptionFetchType fetchType = (QueryOptionFetchType)query.option(QueryOptionFetchType.ID);
    FetchOptions fetchOptions = FetchOptions.Builder.withDefaults();


    QueryOptionPage pag = (QueryOptionPage)query.option(QueryOptionPage.ID);
    if(!pag.isPaginating()){
      // no pagination but pageOption active
      if(pag.isActive()){
        // if local limit is set, it overrides the pageOption.pageSize
        if(limit!=Integer.MAX_VALUE){
          gaeCtx.realPageSize = limit;
          fetchOptions.limit(gaeCtx.realPageSize);
          // pageOption is passivated to be sure it is not reused
          pag.passivate();
        }
        // using pageOption.pageSize
        else {
          gaeCtx.realPageSize = pag.pageSize;
          fetchOptions.limit(gaeCtx.realPageSize);
          // passivates the pageOption in stateless mode not to keep anything between 2 requests
          if(state.isStateless()){
            pag.passivate();
          }            
        }
      }
      else {
        if(limit != Integer.MAX_VALUE){
          gaeCtx.realPageSize = limit;
          fetchOptions.limit(gaeCtx.realPageSize);
        }
      }
    }else {
      // paginating so use the pagesize and don't passivate pageOption
      // local limit is not taken into account
      gaeCtx.realPageSize = pag.pageSize;
      fetchOptions.limit(gaeCtx.realPageSize);
    }


    QueryOptionOffset off = (QueryOptionOffset)query.option(QueryOptionOffset.ID);
    // if local offset has been set, uses it
    if(offset!=0){
      off.activate();
      off.offset = offset;
    }
            
    // if previousPage has detected there is no more data, simply returns an empty list
    if(gaeCtx.noMoreDataBefore){
      return new ArrayList<T>();
    }
            
    if(state.isStateless()) {
      if(pag.isPaginating()){
        if(off.isActive()){
          gaeCtx.realOffset+=off.offset;
          fetchOptions.offset(gaeCtx.realOffset);
          off.passivate();
        }else {
          fetchOptions.offset(gaeCtx.realOffset);
        }
      }else {
        // if stateless and not paginating, resets the realoffset to 0
        gaeCtx.realOffset = 0;
        if(off.isActive()){
          gaeCtx.realOffset=off.offset;
          fetchOptions.offset(gaeCtx.realOffset);
          off.passivate();
        }
      }
      
      switch(fetchType.fetchType){
      case KEYS_ONLY:
        {
          // uses iterable as it is the only async request for prepared query for the time being
          List<Entity> entities = prepareKeysOnly(query).asList(fetchOptions);
          // if paginating and 0 results then no more data else resets noMoreDataAfter
          if(pag.isPaginating()){
            if(entities.size() == 0){
              gaeCtx.noMoreDataAfter = true;
            }
            else {
              gaeCtx.noMoreDataAfter = false;
            }
          }
          return mapKeysOnly(query, entities);
        }
      case NORMAL:
      default:
        {
          // uses iterable as it is the only async request for prepared query for the time being
          List<Entity> entities = prepare(query).asList(fetchOptions);
          // if paginating and 0 results then no more data else resets noMoreDataAfter
          if(pag.isPaginating()){
            if(entities.size() == 0){
              gaeCtx.noMoreDataAfter = true;
            }
            else {
              gaeCtx.noMoreDataAfter = false;
            }
          }
          return map(query, entities);
        }
      }


    }else {
      if(off.isActive()){
        // by default, we add the offset but it can be added with the realoffset 
        // in case of cursor desactivated
        fetchOptions.offset(off.offset);
        gaeCtx.realOffset+=off.offset;
        off.passivate();
      }
      
      // manages cursor limitations for IN and != operators with offsets
      if(!gaeCtx.isActive()){
        // cursor not yet created
        switch(fetchType.fetchType){
        case KEYS_ONLY:
          {
            PreparedQuery pq = prepareKeysOnly(query);
            if(!gaeCtx.useCursor){
              // then uses offset (in case of IN or != operators)
              //if(offset.isActive()){
              //  fetchOptions.offset(gaeCtx.realOffset);
              //}            
              fetchOptions.offset(gaeCtx.realOffset);
            }
            
            // we can't use real asynchronous function with cursors
            // so the page is extracted at once and wrapped into a SienaFuture
            QueryResultList<Entity> entities = pq.asQueryResultList(fetchOptions);


            // activates the GaeCtx now that it is initialised
            gaeCtx.activate();
            // sets the current cursor (in stateful mode, cursor is always kept for further use)
            if(pag.isPaginating()){
              Cursor cursor = entities.getCursor();
              if(cursor!=null){
                gaeCtx.addCursor(cursor.toWebSafeString());
              }
              
              // if paginating and 0 results then no more data else resets noMoreDataAfter
              if(entities.size()==0){
                gaeCtx.noMoreDataAfter = true;
              } else {
                gaeCtx.noMoreDataAfter = false;
              }
            }else{
              Cursor cursor = entities.getCursor();
              if(cursor!=null){
                gaeCtx.addAndMoveCursor(entities.getCursor().toWebSafeString());
              }
              // keeps track of the offset anyway if not paginating
              gaeCtx.realOffset+=entities.size();
            }                      
            
            return mapKeysOnly(query, entities);
          }
        case NORMAL:
        default:
          {
            PreparedQuery pq = prepare(query);
            if(!gaeCtx.useCursor){
              // then uses offset (in case of IN or != operators)
              //if(offset.isActive()){
              //  fetchOptions.offset(gaeCtx.realOffset);
              //}
              fetchOptions.offset(gaeCtx.realOffset);
            }
            // we can't use real asynchronous function with cursors
            // so the page is extracted at once and wrapped into a SienaFuture
            QueryResultList<Entity> entities = pq.asQueryResultList(fetchOptions);
            
            // activates the GaeCtx now that it is initialised
            gaeCtx.activate();
            // sets the current cursor (in stateful mode, cursor is always kept for further use)
            if(pag.isPaginating()){
              Cursor cursor = entities.getCursor();
              if(cursor!=null){
                gaeCtx.addCursor(cursor.toWebSafeString());
              }
              // if paginating and 0 results then no more data else resets noMoreDataAfter
              if(entities.size()==0){
                gaeCtx.noMoreDataAfter = true;
              } else {
                gaeCtx.noMoreDataAfter = false;
              }
            }else{
              Cursor cursor = entities.getCursor();
              if(cursor!=null){
                gaeCtx.addAndMoveCursor(entities.getCursor().toWebSafeString());
              }
              // keeps track of the offset anyway if not paginating
              gaeCtx.realOffset+=entities.size();
            }
            
            return map(query, entities);
          }
        }
        
      }else {
        switch(fetchType.fetchType){
        case KEYS_ONLY:
          {
            // we prepare the query each time
            PreparedQuery pq = prepareKeysOnly(query);
            QueryResultList<Entity> entities;
            if(!gaeCtx.useCursor){
              // then uses offset (in case of IN or != operators)
              //if(offset.isActive()){
              //  fetchOptions.offset(gaeCtx.realOffset);
              //}
              fetchOptions.offset(gaeCtx.realOffset);
              // we can't use real asynchronous function with cursors
              // so the page is extracted at once and wrapped into a SienaFuture
              entities = pq.asQueryResultList(fetchOptions);
            }else {
              // we can't use real asynchronous function with cursors
              // so the page is extracted at once and wrapped into a SienaFuture
              String cursor = gaeCtx.currentCursor();
              if(cursor!=null){
                entities = pq.asQueryResultList(
                  fetchOptions.startCursor(Cursor.fromWebSafeString(cursor)));
              }
              else {
                entities = pq.asQueryResultList(fetchOptions);
              }
            }
            
            // sets the current cursor (in stateful mode, cursor is always kept for further use)
            if(pag.isPaginating()){
              Cursor cursor = entities.getCursor();
              if(cursor!=null){
                gaeCtx.addCursor(cursor.toWebSafeString());
              }
              // if paginating and 0 results then no more data else resets noMoreDataAfter
              if(entities.size()==0){
                gaeCtx.noMoreDataAfter = true;
              } else {
                gaeCtx.noMoreDataAfter = false;
              }
            }else{
              Cursor cursor = entities.getCursor();
              if(cursor!=null){
                gaeCtx.addAndMoveCursor(entities.getCursor().toWebSafeString());
              }
              // keeps track of the offset anyway if not paginating
              gaeCtx.realOffset+=entities.size();
            }
            //}
            
            return mapKeysOnly(query, entities);
          }
        case NORMAL:
        default:
          {
            PreparedQuery pq = prepare(query);
            QueryResultList<Entity> entities;
            if(!gaeCtx.useCursor){
              // then uses offset (in case of IN or != operators)
              //if(offset.isActive()){
              //  fetchOptions.offset(gaeCtx.realOffset);
              //}
              
              fetchOptions.offset(gaeCtx.realOffset);
              // we can't use real asynchronous function with cursors
              // so the page is extracted at once and wrapped into a SienaFuture
              entities = pq.asQueryResultList(fetchOptions);
            }else {
              // we can't use real asynchronous function with cursors
              // so the page is extracted at once and wrapped into a SienaFuture
              String cursor = gaeCtx.currentCursor();
              if(cursor!=null){
                entities = pq.asQueryResultList(
                  fetchOptions.startCursor(Cursor.fromWebSafeString(gaeCtx.currentCursor())));
              }else {
                entities = pq.asQueryResultList(fetchOptions);
              }
            }
            
            // sets the current cursor (in stateful mode, cursor is always kept for further use)
            if(pag.isPaginating()){
              Cursor cursor = entities.getCursor();
              if(cursor!=null){
                gaeCtx.addCursor(cursor.toWebSafeString());
              }
              // if paginating and 0 results then no more data else resets noMoreDataAfter

View Full Code Here

      query.customize(gaeCtx);
    }


    FetchOptions fetchOptions = FetchOptions.Builder.withDefaults();


    QueryOptionPage pag = (QueryOptionPage)query.option(QueryOptionPage.ID);
    if(!pag.isPaginating()){
      // no pagination but pageOption active
      if(pag.isActive()){
        // if local limit is set, it overrides the pageOption.pageSize
        if(limit!=Integer.MAX_VALUE){
          gaeCtx.realPageSize = limit;
          fetchOptions.limit(gaeCtx.realPageSize);
          // pageOption is passivated to be sure it is not reused
          pag.passivate();
        }
        // using pageOption.pageSize
        else {
          gaeCtx.realPageSize = pag.pageSize;
          fetchOptions.limit(gaeCtx.realPageSize);
          // passivates the pageOption in stateless mode not to keep anything between 2 requests
          if(state.isStateless()){
            pag.passivate();
          }            
        }
      }
      else {
        if(limit != Integer.MAX_VALUE){
          gaeCtx.realPageSize = limit;
          fetchOptions.limit(gaeCtx.realPageSize);
        }
      }
    }else {
      // paginating so use the pagesize and don't passivate pageOption
      // local limit is not taken into account
      gaeCtx.realPageSize = pag.pageSize;
      fetchOptions.limit(gaeCtx.realPageSize);
    }


    QueryOptionOffset off = (QueryOptionOffset)query.option(QueryOptionOffset.ID);
    // if local offset has been set, uses it
    if(offset!=0){
      off.activate();
      off.offset = offset;
    }
    
    // if previousPage has detected there is no more data, simply returns an empty list
    if(gaeCtx.noMoreDataBefore){
      return new ArrayList<T>();
    }
            
    if(state.isStateless()) {
      if(pag.isPaginating()){      
        if(off.isActive()){
          gaeCtx.realOffset+=off.offset;
          fetchOptions.offset(gaeCtx.realOffset);
          off.passivate();
        }else {
          fetchOptions.offset(gaeCtx.realOffset);
        }
      }else {
                
        // if stateless and not paginating, resets the realoffset to 0
        gaeCtx.realOffset = off.offset;
        if(off.isActive()){
          fetchOptions.offset(gaeCtx.realOffset);
          off.passivate();
        }
      }
      
      switch(fetchType.fetchType){
      case ITER:
      default:
        {
          // uses iterable as it is the only async request for prepared query for the time being
          Iterable<Entity> entities = prepare(query).asIterable(fetchOptions);
          return new GaeSienaIterable<T>(this, entities, query);
        }
      }
      
    }else {      
      if(off.isActive()){
        // by default, we add the offset but it can be added with the realoffset 
        // in case of cursor desactivated
        fetchOptions.offset(off.offset);
        gaeCtx.realOffset+=off.offset;
        off.passivate();
      }
      // manages cursor limitations for IN and != operators    
      if(!gaeCtx.isActive()){
        // cursor not yet created
        switch(fetchType.fetchType){
        case ITER:
        default:
          {
            PreparedQuery pq = prepare(query);
            
            if(pag.isPaginating()){
              // in case of pagination, we need to allow asynchronous calls such as:
              // QueryAsync<MyClass> query = pm.createQuery(MyClass).paginate(5).stateful().order("name");
              // SienaFuture<Iterable<MyClass>> future1 = query.iter();
              // SienaFuture<Iterable<MyClass>> future2 = query.nextPage().iter();
              // Iterable<MyClass> it = future1.get().iterator();
              // while(it.hasNext()) { // do it }
              // it = future2.get().iterator();
              // while(it.hasNext()) { // do it }
              
              // so we can't use the asQueryResultIterable as the cursor is not moved to the end of the current page
              // but moved at each call of iterable.iterator().next()
              // thus we use the List in this case to be able to move directly to the next page with cursors
              QueryResultList<Entity> entities = pq.asQueryResultList(fetchOptions);


              // activates the GaeCtx now that it is initialised
              gaeCtx.activate();
              // sets the current cursor (in stateful mode, cursor is always kept for further use)
              //if(gaeCtx.useCursor){
              Cursor cursor = entities.getCursor();
              if(cursor!=null){
                gaeCtx.addCursor(cursor.toWebSafeString());
              }
              //}
              return new GaeSienaIterable<T>(this, entities, query);
            }else {
              // if not paginating, we simply use the queryresultiterable and moves the current cursor
              // while iterating
              QueryResultIterable<Entity> entities = pq.asQueryResultIterable(fetchOptions);
              // activates the GaeCtx now that it is initialised
              gaeCtx.activate();
              return new GaeSienaIterableWithCursor<T>(this, entities, query);
            }
            
          }
        }
        
      }else {
        switch(fetchType.fetchType){
        case ITER:
        default:
          {
            PreparedQuery pq = prepare(query);
            if(pag.isPaginating()){
              // in case of pagination, we need to allow asynchronous calls such as:
              // QueryAsync<MyClass> query = pm.createQuery(MyClass).paginate(5).stateful().order("name");
              // SienaFuture<Iterable<MyClass>> future1 = query.iter();
              // SienaFuture<Iterable<MyClass>> future2 = query.nextPage().iter();
              // Iterable<MyClass> it = future1.get().iterator();

View Full Code Here

      this.query = query;
      this.id = ClassInfo.getIdField(query.getQueriedClass());
      this.gaeIterator = gaeIterable.iterator();
      
      // if paginating and 0 results then no more data else resets noMoreDataAfter
      QueryOptionPage pag = (QueryOptionPage)query.option(QueryOptionPage.ID);
      QueryOptionGaeContext gaeCtx = (QueryOptionGaeContext)query.option(QueryOptionGaeContext.ID);
      if(pag.isPaginating()){
        if(!gaeIterator.hasNext()){
          gaeCtx.noMoreDataAfter = true;
        }else {
          gaeCtx.noMoreDataAfter = false;
        }

View Full Code Here

    default:
      results = pm.map(query, entities);
      break;
    }
    // if paginating and 0 results then no more data else resets noMoreDataAfter
    QueryOptionPage pag = (QueryOptionPage)query.option(QueryOptionPage.ID);
    QueryOptionGaeContext gaeCtx = (QueryOptionGaeContext)query.option(QueryOptionGaeContext.ID);
    if(pag.isPaginating()){
      if(results.size() == 0){
        gaeCtx.noMoreDataAfter = true;
      }else {
        gaeCtx.noMoreDataAfter = false;
      }

View Full Code Here

      gaeCtx.realOffset = 0;
    }
  }
  
  public static <T> void nextPage(QueryData<T> query) {
    QueryOptionPage pag = (QueryOptionPage)query.option(QueryOptionPage.ID);
    QueryOptionState state = (QueryOptionState)query.option(QueryOptionState.ID);
    QueryOptionGaeContext gaeCtx = (QueryOptionGaeContext)query.option(QueryOptionGaeContext.ID);
    if(gaeCtx==null){
      gaeCtx = new QueryOptionGaeContext();
      query.options().put(gaeCtx.type, gaeCtx);
    }
    
    // if no more data after, doesn't try to go after
    if(gaeCtx.noMoreDataAfter){
      return;
    }
    
    // if no more data before, removes flag to be able and stay there
    if(gaeCtx.noMoreDataBefore){
      gaeCtx.noMoreDataBefore = false;
      return;
    }
    
    if(pag.isPaginating()){
      gaeCtx.realPageSize = pag.pageSize;
      if(state.isStateless()) {
        //QueryOptionOffset offset = (QueryOptionOffset)query.option(QueryOptionOffset.ID);
        //if(offset.isActive()){
        gaeCtx.realOffset+=pag.pageSize;

View Full Code Here

0 1 2

TOP

Related Classes of siena.core.options.QueryOptionPage

siena.BaseQueryData

siena.gae.GaePersistenceManager

siena.gae.GaePersistenceManagerAsync

siena.gae.GaeQueryUtils

siena.gae.GaeSienaFutureListMapper

siena.gae.GaeSienaIterable$SienaGaeIterator

siena.gae.GaeSienaIterableAsync$SienaGaeIteratorAsync

siena.gae.GaeSienaIterableAsyncWithCursor$SienaGaeIteratorAsyncWithCursor

siena.gae.GaeSienaIterableWithCursor$SienaGaeIteratorWithCursor

siena.jdbc.JdbcPersistenceManager

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.