DaoStream.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2020 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.turro.jpa.stream;
 
import java.util.function.Consumer;
import java.util.stream.Stream;
import org.hibernate.query.Query;
import org.turro.elephant.db.WhereClause;
import org.turro.jpa.Dao;
import org.turro.jpa.DaoManager;
import org.turro.jpa.query.AbstractJpaQuery;
import org.turro.sql.SqlClause;
import org.turro.util.AtomicCounter;
 
public class DaoStream<T> {
 
  private final Dao dao;
  private final WhereClause wc;
  private final SqlClause sc;
  private final AbstractJpaQuery<T> query;
  private DaoManager manager;
//  private ScrollableResults results;
  
  public DaoStream(Dao dao, String query) {
    this(dao, new WhereClause());
    wc.addClause(query);
  }
 
  public DaoStream(Dao dao, WhereClause wc) {
    this.dao = dao;
    this.wc = wc;
    this.sc = null;
    this.query = null;
  }
 
  public DaoStream(Dao dao, SqlClause sc) {
    this.dao = dao;
    this.wc = null;
    this.sc = sc;
    this.query = null;
  }
 
  public DaoStream(Dao dao, AbstractJpaQuery<T> query) {
    this.dao = dao;
    this.wc = null;
    this.sc = null;
    this.query = query;
  }
 
  public <T> void forEach(Consumer<T> action) {
    try(Stream stream = stream()) {
      stream.forEach(action);
    }
  }
  
  public Stream<T> stream() {
    return stream(100);
  }
 
  public Stream<T> stream(int batchSize) {
    manager = new DaoManager(dao);
    Query q = null;
    if(query != null) {
      q = (Query) manager.createQuery(query.query());
    } else if(wc != null) {
      q = (Query) manager.createQuery(wc.getClause());
      wc.setNamedParameters(q);
    } else if(sc != null) {
      q = (Query) manager.createQuery(sc.clause());
      manager.setNamedParameters(q, sc.getNamedValues());
    }
    if(q != null) {
      //q.setReadOnly(true);
      //q.setLockMode(LockModeType.NONE);
      //q.setFetchSize(batchSize);
      openStreams.increment();
      return (Stream<T>) q.<T>stream().onClose(() -> {
        manager.close();
        openStreams.decrement();
      });
    }
    return null;
//    results = q.scroll(ScrollMode.FORWARD_ONLY);
//    return Stream
//            .generate(() -> next(batchSize))
//            .takeWhile(Predicate.not(List::isEmpty))
//            .flatMap(List::stream)
//            .onClose(() -> {
//              results.close();
//              manager.close();
//              openStreams.decrement();
//            });
  }
 
//  private List<T> next(int batchSize) {
//    List<T> result = new ArrayList<>();
//    int count = 0;
//    while (count++ < batchSize) {
//      if(results.next()) {
//        Object[] row = results.get();
//        if(row.length > 1) {
//          result.add((T) row);
//        } else {
//          result.add((T) row[0]);
//        }
//      } else {
//        break;
//      }
//    }
//    return result;
//  }
 
  /* Debug */
  
  private static final AtomicCounter openStreams = new AtomicCounter();
 
  public static AtomicCounter getCounter() {
    return openStreams;
  }
  
}