Java SQLQuery.select方法代码示例

import com.querydsl.sql.SQLQuery; //导入方法依赖的package包/类
public void addToQuery(OrderBy orderBy, Expression<?> sqlExpression, SQLQuery<Tuple> sqlQuery) {
    if (sqlExpression instanceof ComparableExpressionBase) {
        ComparableExpressionBase comparable = (ComparableExpressionBase) sqlExpression;
        Expression<?> projection = sqlQuery.getMetadata().getProjection();
        if (projection instanceof QTuple) {
            QTuple qTuple = (QTuple) projection;
            List<Expression<?>> args = new ArrayList<>(qTuple.getArgs());
            args.add(comparable);
            sqlQuery.select(args.toArray(new Expression[args.size()]));
        }

        if (orderBy.getType() == OrderBy.OrderType.Ascending) {
            sqlQuery.orderBy(comparable.asc());
        } else {
            sqlQuery.orderBy(comparable.desc());
        }
    }
}
 

import com.querydsl.sql.SQLQuery; //导入方法依赖的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.sql.SQLQuery; //导入方法依赖的package包/类
@Override
public void visit(EntitySetPathElement element) {

    int top = query.getTopOrDefault();
    sqlQuery.limit(top + 1);

    int skip = 0;
    if (query.getSkip().isPresent()) {
        skip = query.getSkip().get();
        sqlQuery.offset(skip);
    }
    long start = System.currentTimeMillis();
    if (LOGGER.isTraceEnabled()) {
        LOGGER.trace("Query: {}", sqlQuery.getSQL().getSQL());
    }
    CloseableIterator<Tuple> results = sqlQuery.iterate(); //fetch();
    if (LOGGER.isDebugEnabled()) {
        long end = System.currentTimeMillis();
        LOGGER.debug("Query executed in {} ms.", end - start);
    }

    PropertyHelper.entityFromTupleFactory<? extends Entity> factory = PropertyHelper.getFactoryFor(element.getEntityType().getImplementingClass());
    EntitySet<? extends Entity> entitySet = PropertyHelper.createSetFromTuples(factory, results, query, pm.getCoreSettings().getDataSizeMax());

    if (entitySet == null) {
        throw new IllegalStateException("Empty set!");
    }

    if (query.isCountOrDefault()) {
        SQLQuery<Tuple> countQuery = sqlQuery.clone();
        countQuery.select(factory.getPrimaryKey());
        int count = (int) countQuery.fetchCount();
        entitySet.setCount(count);
    }

    int entityCount = entitySet.size();
    boolean hasMore = results.hasNext();
    if (entityCount < top && hasMore) {
        // The loading was aborted, probably due to size constraints.
        query.setTop(entityCount);
    }
    if (hasMore) {
        entitySet.setNextLink(UrlHelper.generateNextLink(path, query));
    }
    for (Entity e : entitySet) {
        expandEntity(e, query);
    }
    resultObject = entitySet;
}