Java NumberExpression类代码示例

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
@Override
public Expression<?> visit(Add node) {
    List<de.fraunhofer.iosb.ilt.sta.query.expression.Expression> params = node.getParameters();
    Expression<?> p1 = params.get(0).accept(this);
    Expression<?> p2 = params.get(1).accept(this);
    if (p1 instanceof TimeExpression) {
        TimeExpression ti1 = (TimeExpression) p1;
        return ti1.add(p2);
    }
    if (p2 instanceof TimeExpression) {
        TimeExpression ti2 = (TimeExpression) p2;
        return ti2.add(p1);
    }
    NumberExpression n1 = getSingleOfType(NumberExpression.class, p1);
    NumberExpression n2 = getSingleOfType(NumberExpression.class, p2);
    return n1.add(n2);
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
private List<HuntingClubAreaChangedExcelView.ExcelRow> fetchChanged(final @Nonnull GISZone zoneEntity) {
    final SQZonePalsta zonePalsta = new SQZonePalsta("zp");
    final SQPalstaalue pa1 = new SQPalstaalue("pa1"); // Current
    final SQPalstaalue pa2 = new SQPalstaalue("pa2"); // New

    final NumberPath<Integer> pathPalstaId = zonePalsta.palstaId;
    final NumberPath<Integer> pathPalstaIdNew = zonePalsta.newPalstaId;

    final NumberPath<Long> pathPalstaTunnus = zonePalsta.palstaTunnus;
    final NumberPath<Long> pathPalstaTunnusNew = zonePalsta.newPalstaTunnus;

    final NumberPath<Double> pathAreaDiff = zonePalsta.diffArea;
    final NumberExpression<Double> pathAreaSize = zonePalsta.geom.asMultiPolygon().area();

    return sqlQueryFactory
            .from(zonePalsta)
            .leftJoin(pa1).on(pa1.id.eq(pathPalstaId))
            .leftJoin(pa2).on(pa2.id.eq(pathPalstaIdNew))
            .where(zonePalsta.zoneId.eq(zoneEntity.getId())
                    .and(zonePalsta.isChanged.isTrue()))
            .select(Projections.constructor(HuntingClubAreaChangedExcelView.ExcelRow.class,
                    pathPalstaTunnus, pathPalstaTunnusNew,
                    pathAreaSize, pathAreaDiff))
            .orderBy(pathPalstaTunnus.asc(), pathPalstaId.asc())
            .fetch();
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
private Map<Long, Float> findAmendmentAmountsByOriginalPermitId(final List<HarvestPermit> originalPermits,
                                                                final int speciesCode,
                                                                final int huntingYear) {

    final QHarvestPermitSpeciesAmount speciesAmount = QHarvestPermitSpeciesAmount.harvestPermitSpeciesAmount;
    final QGameSpecies species = QGameSpecies.gameSpecies;
    final QHarvestPermit amendmentPermit = new QHarvestPermit("amendmentPermit");

    final NumberPath<Long> originalPermitId = amendmentPermit.originalPermit.id;
    final NumberExpression<Float> sumOfAmendmentPermitAmounts = speciesAmount.amount.sum();

    return jpqlQueryFactory.select(originalPermitId, sumOfAmendmentPermitAmounts)
            .from(speciesAmount)
            .join(speciesAmount.gameSpecies, species)
            .join(speciesAmount.harvestPermit, amendmentPermit)
            .where(amendmentPermit.originalPermit.in(originalPermits),
                    species.officialCode.eq(speciesCode),
                    speciesAmount.validOnHuntingYear(huntingYear))
            .groupBy(originalPermitId)
            .transform(groupBy(originalPermitId).as(sumOfAmendmentPermitAmounts));
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
/**
 * Filter criteria includes:
 * - If harvest is linked to groups hunting day, it is included always
 * Otherwise:
 * - Person must have occupation in given club
 * - Occupation must be valid on the day of harvest
 * - If harvest.harvest_report_required=true then harvest must have accepted harvest report
 * - Harvest species must not be any the given mooselikes (those are included by hunting days)
 * - Harvest location must intersect with active area for club
 */
@Override
@Transactional(readOnly = true)
public Map<Long, Integer> countClubHarvestAmountGroupByGameSpeciesId(final HuntingClub huntingClub,
                                                                     final int huntingYear,
                                                                     final Interval interval,
                                                                     final Set<Integer> mooselike) {
    final SQHarvest harvest = SQHarvest.harvest;
    final BooleanExpression predicate1 = harvest.groupHuntingDayId.isNull()
            .and(harvest.harvestId.in(harvestOfClubMemberInsideClubHuntingArea(
                    huntingClub.getId(), interval, huntingYear, mooselike)));

    final BooleanExpression predicate2 = harvest.groupHuntingDayId.isNotNull()
            .and(harvest.groupHuntingDayId.in(harvestLinkedToClubHuntingDay(huntingClub.getId(), huntingYear)));

    final NumberPath<Long> keyPath = harvest.gameSpeciesId;
    final NumberExpression<Integer> valuePath = harvest.amount.sum();

    return sqlQueryFactory.from(harvest)
            .select(keyPath, valuePath)
            .where(predicate1.or(predicate2))
            .groupBy(keyPath)
            .transform(GroupBy.groupBy(keyPath).as(valuePath));
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
/**
 * Adds a global contains text filter on the provided attributes.
 * WARNING: this creates a very inefficient query. If you have many entity
 * instances to query, use instead an indexed text search solution for better
 * performance.
 * @param text the text to look for
 * @param query
 * @param globalSearchAttributes the list of attributes to perform the
 *        filter on
 * @return the updated query
 */
protected JPQLQuery<T> applyGlobalSearch(String text, JPQLQuery<T> query,
    Path<?>... globalSearchAttributes) {
  if (text != null && !StringUtils.isEmpty(text) && globalSearchAttributes.length > 0) {
    BooleanBuilder searchCondition = new BooleanBuilder();
    for (int i = 0; i < globalSearchAttributes.length; i++) {
      Path<?> path = globalSearchAttributes[i];
      if (path instanceof StringPath) {
        StringPath stringPath = (StringPath) path;
        searchCondition.or(stringPath.containsIgnoreCase(text));
      } else if (path instanceof NumberExpression) {
        searchCondition.or(((NumberExpression<?>) path).like("%".concat(text).concat("%")));
      }
    }
    return query.where(searchCondition);
  }
  return query;
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
/**
 * The (json) type of the other expression.
 *
 * @param e
 * @return
 */
private CompareType getOtherType(Expression<?> e) {
    if (e instanceof NumberExpression) {
        return CompareType.NUMBER;
    }
    if (e instanceof BooleanExpression) {
        return CompareType.BOOLEAN;
    }
    return CompareType.STRING;
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
private List<Integer> resolvePublicHolidayYears(final long schemeId) {
  return querydslSupport.execute((connection, configuration) -> {
    QPublicHoliday qPublicHoliday = QPublicHoliday.publicHoliday;
    NumberExpression<Integer> yearExpression =
        qPublicHoliday.date.year().as("public_holiday_year");
    return new SQLQuery<Integer>(connection, configuration)
        .select(yearExpression)
        .from(qPublicHoliday)
        .groupBy(yearExpression)
        .orderBy(yearExpression.asc())
        .where(qPublicHoliday.holidaySchemeId.eq(schemeId))
        .fetch();
  });
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
private static Expression<Long> weekdaySumForReplacementDay(final NumberPath<Long> workSchemeId,
    final NumberExpression<Integer> dayOfWeek) {
  QWeekdayWork qWeekdayWork = new QWeekdayWork("exp_work_repl_wdw");
  SQLQuery<Long> query = new SQLQuery<>();
  query.select(qWeekdayWork.duration.sum())
      .from(qWeekdayWork)
      .where(qWeekdayWork.workSchemeId.eq(workSchemeId)
          .and(
              Expressions.path(Integer.class, qWeekdayWork.weekday.getMetadata()).eq(dayOfWeek)));
  return query;
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
@Override
    default public void customize(QuerydslBindings bindings, QCustomer cust) {

//        bindings.bind(cust.firstName).first(StringExpression::containsIgnoreCase);

        bindings
                .bind(String.class)
                .first((SingleValueBinding<StringPath, String>) StringExpression::containsIgnoreCase);

        bindings
                .bind(Long.class)
                .first((SingleValueBinding<NumberPath<Long>, Long>) NumberExpression::goe);

//        bindings.excluding(cust.lastName);
    }
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
public static <T> NumberExpression<Integer> countIf(BooleanExpression condition) {
	/**
	 * We use Expressions.* rather than constants, in order to avoid introducing request parameters.
	 * Otherwise, Hibernate would freak out because it can't guess the CASE expression data type
	 * (which seems legitimate).
	 */
	return new CaseBuilder().when(condition).then(Expressions.ONE).otherwise(Expressions.ZERO).sum();
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
public static <T> NumberExpression<Integer> sumIf(NumberExpression<Integer> expression, BooleanExpression condition) {
	if (condition == null) {
		return expression.sum();
	} else {
		/**
		 * We use Expressions.* rather than constants, in order to avoid introducing request parameters.
		 * Otherwise, Hibernate would freak out because it can't guess the CASE expression data type
		 * (which seems legitimate).
		 */
		return new CaseBuilder().when(condition).then(expression).otherwise(Expressions.ZERO).sum();
	}
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
@Test
public void testAppendGoeTwoArguments() {
    SingleIntegerArgument argument = SingleIntegerArgument.of(200);
    BooleanBuilder builder = new BooleanBuilder();
    argument.append(builder, NumberExpression::goe, QPerson.person.oneInteger, QPerson.person.anotherInteger);
    Person result = new JPAQuery<Void>(entityManager).select(QPerson.person).from(QPerson.person).where(builder).fetchOne();
    assertThat(result.getAnotherInteger()).isEqualTo(321);
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
@Test
public void testAppendGoeTwoArgumentsWithNoResult() {
    SingleIntegerArgument argument = SingleIntegerArgument.of(400);
    BooleanBuilder builder = new BooleanBuilder();
    argument.append(builder, NumberExpression::goe, QPerson.person.oneInteger, QPerson.person.anotherInteger);
    Person result = new JPAQuery<Void>(entityManager).select(QPerson.person).from(QPerson.person).where(builder).fetchOne();
    assertThat(result).isNull();
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
@Test
public void testAppendLoeCustomNumberTypeAndInteger() {
    SingleIntegerArgument argument = SingleIntegerArgument.of(250);
    BooleanBuilder builder = new BooleanBuilder();
    argument.append(builder, NumberExpression::loe, QPerson.person.oneCustomNumberType.intValue(), QPerson.person.anotherInteger);
    Person result = new JPAQuery<Void>(entityManager).select(QPerson.person).from(QPerson.person).where(builder).fetchOne();
    Assertions.assertThat(result.getOneCustomNumberType()).isEqualTo(CustomNumberType.of(new BigDecimal("222")));
}
 

import com.querydsl.core.types.dsl.NumberExpression; //导入依赖的package包/类
@Test
public void testAppendGoeTwoArguments() {
    SingleBigDecimalArgument argument = SingleBigDecimalArgument.of(new BigDecimal("200"));
    BooleanBuilder builder = new BooleanBuilder();
    argument.append(builder, NumberExpression::goe, QPerson.person.oneBigDecimal, QPerson.person.anotherBigDecimal);
    Person result = new JPAQuery<Void>(entityManager).select(QPerson.person).from(QPerson.person).where(builder).fetchOne();
    assertThat(result.getAnotherBigDecimal()).isEqualTo(new BigDecimal("321"));
}