Java Expressions类代码示例

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
private SQLQuery<Long> moderatedGroups(final Collection<Long> includedGameSpeciesIds, final int huntingYear) {
    final SQBasicClubHuntingSummary bchs = new SQBasicClubHuntingSummary("bchs");
    final SQHarvestPermitSpeciesAmount hpsa = new SQHarvestPermitSpeciesAmount("hpsa");
    final SQOrganisation group = new SQOrganisation("group");

    return SQLExpressions
            .select(group.organisationId)
            .from(bchs)
            .join(hpsa).on(hpsa.harvestPermitSpeciesAmountId.eq(bchs.speciesAmountId))
            .join(group).on(
                    group.parentOrganisationId.eq(bchs.clubId),
                    group.organisationType.eq(Expressions.asString(OrganisationType.CLUBGROUP.name())),
                    group.gameSpeciesId.eq(hpsa.gameSpeciesId),
                    group.harvestPermitId.eq(hpsa.harvestPermitId))
            .where(hpsa.gameSpeciesId.in(includedGameSpeciesIds),
                    bchs.moderatorOverride.isTrue(),
                    bchs.huntingFinished.isTrue(),
                    sqlDateInsideHuntingYear(bchs.huntingEndDate, huntingYear),
                    group.huntingYear.eq(huntingYear));
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
@Transactional(readOnly = true)
public boolean isClubNameDuplicate(Long clubId, String name) {
    final SQOrganisation club = SQOrganisation.organisation;

    final StringTemplate candidate = replaceAll(name.toLowerCase(), "\\W", "");
    final StringTemplate nameFi = replaceAll(club.nameFinnish.lower(), "\\W", "");
    final StringTemplate nameSv = replaceAll(club.nameSwedish.lower(), "\\W", "");
    final Boolean b = createNativeQuery()
            .select(Expressions.constant(true))
            .from(club)
            .where(club.organisationType.eq(OrganisationType.CLUB.name()),
                    clubId != null ? club.organisationId.ne(clubId) : null,
                    candidate.eq(nameFi).or(candidate.eq(nameSv)))
            .fetchOne();
    return Boolean.TRUE.equals(b);
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
private Map<Long, Boolean> getPermitIdToMooseHarvestReportExistsMapping(final List<HarvestPermit> permits,
                                                                        final int speciesCode,
                                                                        final int huntingYear) {
    final QHarvestPermitSpeciesAmount speciesAmount = QHarvestPermitSpeciesAmount.harvestPermitSpeciesAmount;
    final QMooseHarvestReport report = QMooseHarvestReport.mooseHarvestReport;
    final QGameSpecies species = QGameSpecies.gameSpecies;

    final JPQLQuery<Object> mooseHarvestReportQuery = jpqlQueryFactory.select(Expressions.nullExpression())
            .from(report)
            .where(report.speciesAmount.eq(speciesAmount));

    final Expression<Boolean> mooseHarvestReportExists = new CaseBuilder()
            .when(mooseHarvestReportQuery.exists()).then(Expressions.constant(true))
            .otherwise(Expressions.constant(false));

    return jpqlQueryFactory.select(speciesAmount.harvestPermit.id, mooseHarvestReportExists)
            .from(speciesAmount)
            .join(speciesAmount.gameSpecies, species)
            .where(speciesAmount.harvestPermit.in(permits),
                    species.officialCode.eq(speciesCode),
                    speciesAmount.validOnHuntingYear(huntingYear))
            .transform(groupBy(speciesAmount.harvestPermit.id).as(mooseHarvestReportExists));
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
private Object synchronizeDateSequenceIfNecessary(final Connection connection,
    final Configuration configuration) {

  QDateSequence qDateSequence = QDateSequence.dateSequence;
  long dateSequenceCount = new SQLQuery<>(connection, configuration)
      .select(Expressions.ONE.count()).from(qDateSequence).fetchOne();

  if (dateSequenceCount == 0) {
    QDateRange qDateRange = QDateRange.dateRange;
    long dateRangeCount = new SQLQuery<>(connection, configuration)
        .select(Expressions.ONE.count()).from(qDateRange).fetchOne();
    if (dateRangeCount != 0) {
      fillDateSequenceFromDateRanges(connection, configuration, dateRangeCount);
    }
  }
  return null;
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
/**
 * Getting the expected work amount for a date period. The calculation for each day in the range
 * is done in the following order:
 * <ol>
 * <li>if there is an exact work day specified for a specific date, that is used. Otherwise</li>
 * <li>if there is a replacement day of a public holiday and there is a weekday specified for the
 * replaced holiday, that is used. Otherwise</li>
 * <li>If there is a non holiday weekday, that is used. Otherwise</li>
 * <li>zero is used.</li>
 * </ol>
 *
 * @param userId
 *          The id of the user who should have done the work.
 * @param startDate
 *          The date when we start calculating the work that should be done from.
 * @param endDateExcluded
 *          The date until we calculate the work that should be done (excluded).
 * @return The amount of work that should be done by the specified user in the specific time
 *         period.
 */
public static SQLQuery<Long> expectedWorkAmount(final Expression<Long> userId,
    final Expression<Date> startDate, final Expression<Date> endDateExcluded) {

  QDateSequence qDates = new QDateSequence("exp_work_dates");
  QDateRange qDateRange = new QDateRange("exp_work_date_range");
  QUserWorkScheme qUserWorkScheme = new QUserWorkScheme("exp_work_user_work_scheme");

  SQLQuery<Long> query = new SQLQuery<>();
  query.select(
      new Coalesce<Long>(Long.class,
          exactWorkSubSelect(qUserWorkScheme.workSchemeId, qDates.date),
          replacementWeekdaySubSelect(qUserWorkScheme.workSchemeId, userId, qDates.date),
          nonHolidayWeekdaySubSelect(qUserWorkScheme.workSchemeId, userId, qDates.date),
          Expressions.ZERO)
              .asNumber().sum());
  query
      .from(qDates)
      .innerJoin(qDateRange)
      .on(qDateRange.startDate.loe(qDates.date).and(qDateRange.endDateExcluded.gt(qDates.date)))
      .innerJoin(qUserWorkScheme).on(qUserWorkScheme.dateRangeId.eq(qDateRange.dateRangeId))
      .where(qDates.date.goe(startDate).and(qDates.date.lt(endDateExcluded))
          .and(qUserWorkScheme.userId.eq(userId)));

  return query;
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
/**
 * Creates an {@link Expression} for the given {@link Order} property.
 *
 * @param order must not be {@literal null}.
 * @param builder must not be {@literal null}.
 * @return
 */
private static Expression<?> buildOrderPropertyPathFrom(Order order, PathBuilder<?> builder) {

	Assert.notNull(order, "Order must not be null!");
	Assert.notNull(builder, "Builder must not be null!");

	PropertyPath path = PropertyPath.from(order.getProperty(), builder.getType());
	Expression<?> sortPropertyExpression = builder;

	while (path != null) {

		if (!path.hasNext() && order.isIgnoreCase()) {
			// if order is ignore-case we have to treat the last path segment as a String.
			sortPropertyExpression = Expressions.stringPath((Path<?>) sortPropertyExpression, path.getSegment()).lower();
		} else {
			sortPropertyExpression = Expressions.path(path.getType(), (Path<?>) sortPropertyExpression, path.getSegment());
		}

		path = path.next();
	}

	return sortPropertyExpression;
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
@Override
public Expression<?> visit(Time node) {
    de.fraunhofer.iosb.ilt.sta.query.expression.Expression param = node.getParameters().get(0);
    Expression<?> input = param.accept(this);
    DateTimeExpression inExp = getSingleOfType(DateTimeExpression.class, input);
    if (inExp instanceof ConstantDateTimeExpression) {
        ConstantDateTimeExpression constant = (ConstantDateTimeExpression) inExp;
        if (!constant.isUtc()) {
            throw new IllegalArgumentException("Constants passed to the time() function have to be in UTC.");
        }
    }
    TimeTemplate<java.sql.Time> time = Expressions.timeTemplate(java.sql.Time.class, "pg_catalog.time({0})", inExp);
    return time;
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
@Override
public TimeExpression subi(Expression<?> other) {
    if (other instanceof DateTimeExpression) {
        // We calculate with the start time and return a duration.
        DateTimeExpression dtStart = PgExpressionHandler.checkType(DateTimeExpression.class, start, false);
        String template = "({0}::timestamp - {1}::timestamp)";
        return new ConstantDurationExpression(Expressions.stringTemplate(template, other, dtStart));
    }
    throw new UnsupportedOperationException("Can not subtract TimeInterval from anything.");
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
@Override
public TimeExpression sub(Expression<?> other) {
    if (other instanceof DateTimeExpression) {
        // We calculate with the start time and return a duration.
        DateTimeExpression dtStart = PgExpressionHandler.checkType(DateTimeExpression.class, start, false);
        String template = "({0}::timestamp - {1}::timestamp)";
        return new ConstantDurationExpression(Expressions.stringTemplate(template, dtStart, other));
    }
    return simpleOp("-", other);
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
private TimeIntervalExpression simpleOp(String op, Expression<?> other) {
    if (other instanceof ConstantDurationExpression) {
        ConstantDurationExpression cd = (ConstantDurationExpression) other;
        DateTimeExpression dtEnd = PgExpressionHandler.checkType(DateTimeExpression.class, end, false);
        DateTimeExpression dtStart = PgExpressionHandler.checkType(DateTimeExpression.class, start, false);
        String template = "({0}::timestamp " + op + " {1}::interval)";
        DateTimeTemplate<Timestamp> newStart = Expressions.dateTimeTemplate(Timestamp.class, template, dtStart, cd.duration);
        DateTimeTemplate<Timestamp> newEnd = Expressions.dateTimeTemplate(Timestamp.class, template, dtEnd, cd.duration);
        return new TimeIntervalExpression(newStart, newEnd);
    }
    throw new UnsupportedOperationException("Can not add TimeInterval and " + other.getClass().getName());
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
/**
 * Find the common type that should be used to compare the given two
 * expressions.
 *
 * @param other The type of the other that we should enforce on the json
 * type.
 * @return the extra predicate to enforce the type with.
 */
private Predicate createTypePredicate(CompareType other) {
    switch (other) {
        case NUMBER:
            return Expressions.stringTemplate("jsonb_typeof({0})", jsonExpression).eq("number");
        case BOOLEAN:
            return Expressions.stringTemplate("jsonb_typeof({0})", jsonExpression).eq("boolean");
        default:
            return null;
    }
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
public Expression<?> build() {
    StringBuilder templateCore = new StringBuilder();
    boolean firstDone = false;
    for (String key : path) {
        if (firstDone) {
            templateCore.append(",");
        } else {
            firstDone = true;
        }
        templateCore.append(key);
    }
    String templateCoreString = templateCore.toString();
    String templateJsonb = "{0}::jsonb#>'{ " + templateCoreString + " }'";
    String templateString = "{0}::jsonb#>>'{ " + templateCoreString + " }'";
    String templateNumber = "safe_cast_to_numeric({0}::jsonb#>'{ " + templateCoreString + " }')";
    String templateBoolean = "safe_cast_to_boolean({0}::jsonb#>'{ " + templateCoreString + " }')";

    Map<String, Expression<?>> expressions = new HashMap<>();
    Map<String, Expression<?>> expressionsForOrder = new HashMap<>();
    StringTemplate stringTemplate = Expressions.stringTemplate(templateString, jsonField);
    // TODO: Review if this should change to the jsonb field.
    expressionsForOrder.put("s", stringTemplate);
    expressions.put(KEY_STRING, stringTemplate);
    expressions.put(KEY_NUMBER, Expressions.numberTemplate(Double.class, templateNumber, jsonField));
    expressions.put(KEY_BOOLEAN, Expressions.booleanTemplate(templateBoolean, jsonField));
    ComparableTemplate<String> jsonExpression = Expressions.comparableTemplate(String.class, templateJsonb, jsonField);
    expressions.put(KEY_JSONB, jsonExpression);

    ListExpression listExpression = new ListExpressionJson(expressions, expressionsForOrder, jsonExpression);

    return listExpression;
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
private BooleanExpression simpleOpBool(String op, Expression<?> other) {
    if (other instanceof ConstantDurationExpression) {
        ConstantDurationExpression cd = (ConstantDurationExpression) other;
        String template = "({0}::interval " + op + " {1}::interval)";
        return Expressions.booleanTemplate(template, this.duration, cd.duration);
    }
    throw new UnsupportedOperationException("Can not compare between Duration and " + other.getClass().getName());
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的package包/类
private static Expression<Long> nonHolidayWeekdaySubSelect(final NumberPath<Long> workSchemeId,
    final Expression<Long> userId, final DatePath<Date> date) {

  QWeekdayWork qWeekdayWork = new QWeekdayWork("exp_work_nh_wdw");

  SQLQuery<Long> query = new SQLQuery<>();
  query.select(qWeekdayWork.duration.sum()).from(qWeekdayWork)
      .where(qWeekdayWork.workSchemeId.eq(workSchemeId)
          .and(date.dayOfWeek()
              .eq(Expressions.path(Integer.class, qWeekdayWork.weekday.getMetadata())))
          .and(noHolidayExistsSubSelect(userId, date)));
  return query;
}
 

import com.querydsl.core.types.dsl.Expressions; //导入依赖的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;
}