import com.mysema.query.types.Ops; //导入依赖的package包/类
@Test
@Ignore
  public void everyPagePredicate() {
      int pageSize = 25;
      int totalPages = N / 25;
      Stopwatch sw = new Stopwatch();
      for (int pageNumber = 0; pageNumber < N / pageSize; pageNumber++) {
          sw.start();
          Page<PagingAndSortingEntity> page = repository.findAll(
              BooleanOperation.create(
                  Ops.EQ,
                  new ConstantImpl<String>("foo"),
                  new ConstantImpl<String>("foo")),
              new PageableImpl(pageNumber, 25, 0, null));
          Assert.assertEquals(pageNumber, page.getNumber());
          Assert.assertEquals(pageSize, page.getSize());
          Assert.assertEquals(totalPages, page.getTotalPages());
          LOGGER.info("Fetched page {} in {}ms...", pageNumber, sw.elapsed(TimeUnit.MILLISECONDS));
          sw.reset();
      }
  }
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get a day of month expression (range 1-31)
 *
 * @return
 */
public NumberExpression<Integer> dayOfMonth(){
    if (dayOfMonth == null) {
        dayOfMonth = NumberOperation.create(Integer.class, Ops.DateTimeOps.DAY_OF_MONTH, this);
    }
    return dayOfMonth;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get a day of week expression (range 1-7 / SUN-SAT)
 * <p>NOT supported in JDOQL and not in Derby</p>
 *
 * @return
 */
public NumberExpression<Integer> dayOfWeek() {
    if (dayOfWeek == null) {
        dayOfWeek = NumberOperation.create(Integer.class, Ops.DateTimeOps.DAY_OF_WEEK, this);
    }
    return dayOfWeek;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get a day of year expression (range 1-356)
 * <p>NOT supported in JDOQL and not in Derby</p>
 *
 * @return
 */
public NumberExpression<Integer> dayOfYear() {
    if (dayOfYear == null){
        dayOfYear = NumberOperation.create(Integer.class, Ops.DateTimeOps.DAY_OF_YEAR, this);
    }
    return dayOfYear;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get a hours expression (range 0-23)
 *
 * @return
 */
public NumberExpression<Integer> hour(){
    if (hour == null) {
        hour = NumberOperation.create(Integer.class, Ops.DateTimeOps.HOUR, this);
    }
    return hour;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get the maximum value of this expression (aggregation)
 *
 * @return max(this)
 */
public DateTimeExpression<T> max(){
    if (max == null) {
        max = DateTimeOperation.<T>create((Class<T>)getType(), Ops.AggOps.MAX_AGG, this);
    }
    return max;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get a milliseconds expression (range 0-999)
 * <p>Is always 0 in HQL and JDOQL modules</p>
 *
 * @return
 */
public NumberExpression<Integer> milliSecond(){
    if (milliSecond == null) {
        milliSecond = NumberOperation.create(Integer.class, Ops.DateTimeOps.MILLISECOND, this);
    }
    return milliSecond;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get the minimum value of this expression (aggregation)
 *
 * @return min(this)
 */
public DateTimeExpression<T> min(){
    if (min == null) {
        min = DateTimeOperation.<T>create((Class<T>)getType(), Ops.AggOps.MIN_AGG, this);
    }
    return min;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get a minutes expression (range 0-59)
 *
 * @return
 */
public NumberExpression<Integer> minute(){
    if (minute == null) {
        minute = NumberOperation.create(Integer.class, Ops.DateTimeOps.MINUTE, this);
    }
    return minute;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get a month expression (range 1-12 / JAN-DEC)
 *
 * @return
 */
public NumberExpression<Integer> month(){
    if (month == null) {
        month = NumberOperation.create(Integer.class, Ops.DateTimeOps.MONTH, this);
    }
    return month;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get a seconds expression (range 0-59)
 *
 * @return
 */
public NumberExpression<Integer> second(){
    if (second == null) {
        second = NumberOperation.create(Integer.class, Ops.DateTimeOps.SECOND, this);
    }
    return second;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get a week expression
 *
 * @return
 */
public NumberExpression<Integer> week() {
    if (week == null) {
        week = NumberOperation.create(Integer.class, Ops.DateTimeOps.WEEK,  this);
    }
    return week;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get a year expression
 *
 * @return
 */
public NumberExpression<Integer> year(){
    if (year == null) {
        year = NumberOperation.create(Integer.class, Ops.DateTimeOps.YEAR, this);
    }
    return year;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * Get a year / month expression
 *
 * @return
 */
public NumberExpression<Integer> yearMonth(){
    if (yearMonth == null) {
        yearMonth = NumberOperation.create(Integer.class, Ops.DateTimeOps.YEAR_MONTH, this);
    }
    return yearMonth;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
@Bean
public SQLTemplates templates() {
    return new PostgresTemplates() {{
        // https://github.com/mysema/querydsl/pull/280
        setPrintSchema(false);
        add(Ops.DateTimeOps.CURRENT_TIMESTAMP, "current_timestamp");
        add(Ops.DateTimeOps.CURRENT_TIME, "current_time");
        add(Ops.DateTimeOps.CURRENT_DATE, "current_date");
    }};
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
/**
 * カラムメタデータに基づいて当該カラムの表記名を取得する。<br />
 * 「AS」で別名が指定された場合は別名、そうでなければ、元のカラム名が得られる。カラム名を特定できない場合はnullが返却される。
 * 
 * @param expression 対象の式。
 * @return 表記名。
 */
public static String getExpressionLabel(Expression<?> expression) {
	if (expression instanceof Operation) {
		Operation<?> op = (Operation<?>) expression;
		if (op.getOperator() == Ops.ALIAS) {
			return ((Path<?>) op.getArg(1)).getMetadata().getName();
		}
	}
	if (expression instanceof Path) {
		return getColumnMetadata((Path<?>) expression).getName();
	}
	return null;
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
private BooleanExpression isConfidential () {
	final QLeafLayer leafLayer = new QLeafLayer ("leaf_layer2");
	
	return new SQLSubQuery ()
		.from (groupStructure)
		.join (leafLayer).on (groupStructure.childLayerId.eq (leafLayer.genericLayerId))
		.join (dataset).on (leafLayer.datasetId.eq (dataset.id))
		.join (sourceDataset).on (dataset.sourceDatasetId.eq (sourceDataset.id))
		.where (groupStructure.groupLayerIdentification.eq (genericLayer.identification))
		.where (Expressions.booleanOperation (Ops.EQ, Expressions.constant (true), new SQLSubQuery ().from (sourceDatasetVersion).where (sourceDatasetVersion.sourceDatasetId.eq (sourceDataset.id)).orderBy (sourceDatasetVersion.createTime.desc ()).limit (1).list (sourceDatasetVersion.confidential)))
		.exists ();
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
private BooleanExpression isWmsOnly () {
	final QLeafLayer leafLayer = new QLeafLayer ("leaf_layer2");
	
	return new SQLSubQuery ()
		.from (groupStructure)
		.join (leafLayer).on (groupStructure.childLayerId.eq (leafLayer.genericLayerId))
		.join (dataset).on (leafLayer.datasetId.eq (dataset.id))
		.join (sourceDataset).on (dataset.sourceDatasetId.eq (sourceDataset.id))
		.where (groupStructure.groupLayerIdentification.eq (genericLayer.identification))
		.where (Expressions.booleanOperation (Ops.EQ, Expressions.constant (true), new SQLSubQuery ().from (sourceDatasetVersion).where (sourceDatasetVersion.sourceDatasetId.eq (sourceDataset.id)).orderBy (sourceDatasetVersion.createTime.desc ()).limit (1).list (sourceDatasetVersion.wmsOnly)))
		.exists ();
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
private BooleanExpression isConfidential () {
	return new SQLSubQuery ()
		.from (serviceStructure)
		.join (leafLayer).on (serviceStructure.childLayerId.eq (leafLayer.genericLayerId))
		.join (dataset).on (leafLayer.datasetId.eq (dataset.id))
		.join (sourceDataset).on (dataset.sourceDatasetId.eq (sourceDataset.id))
		.where (serviceStructure.serviceIdentification.eq (genericLayer.identification))
		.where (Expressions.booleanOperation (Ops.EQ, Expressions.constant (true), new SQLSubQuery ().from (sourceDatasetVersion).where (sourceDatasetVersion.sourceDatasetId.eq (sourceDataset.id)).orderBy (sourceDatasetVersion.createTime.desc ()).limit (1).list (sourceDatasetVersion.confidential)))
		.exists ();
}
 

import com.mysema.query.types.Ops; //导入依赖的package包/类
private BooleanExpression isWmsOnly () {
	return new SQLSubQuery ()
		.from (serviceStructure)
		.join (leafLayer).on (serviceStructure.childLayerId.eq (leafLayer.genericLayerId))
		.join (dataset).on (leafLayer.datasetId.eq (dataset.id))
		.join (sourceDataset).on (dataset.sourceDatasetId.eq (sourceDataset.id))
		.where (serviceStructure.serviceIdentification.eq (genericLayer.identification))
		.where (Expressions.booleanOperation (Ops.EQ, Expressions.constant (true), new SQLSubQuery ().from (sourceDatasetVersion).where (sourceDatasetVersion.sourceDatasetId.eq (sourceDataset.id)).orderBy (sourceDatasetVersion.createTime.desc ()).limit (1).list (sourceDatasetVersion.wmsOnly)))
		.exists ();
}