import com.querydsl.core.Tuple; //导入依赖的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.core.Tuple; //导入依赖的package包/类
@Override
public void visit(EntityPathElement element) {
    sqlQuery.limit(2);
    List<Tuple> results = sqlQuery.fetch();
    if (results.size() > 1) {
        throw new IllegalStateException("Expecting an element, yet more than 1 result. Got " + results.size() + " results.");
    }
    if (results.isEmpty()) {
        return;
    }

    PropertyHelper.entityFromTupleFactory<? extends Entity> factory = PropertyHelper.getFactoryFor(element.getEntityType().getImplementingClass());
    Entity entity = factory.create(results.get(0), query, new DataSize());

    if (entity == null) {
        throw new IllegalStateException("Failed to create an entity from result set.");
    }
    expandEntity(entity, query);
    resultObject = entity;
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
public static <T extends Entity> EntitySet<T> createSetFromTuples(entityFromTupleFactory<T> factory, CloseableIterator<Tuple> tuples, Query query, long maxDataSize) {
    EntitySet<T> entitySet = new EntitySetImpl<>(factory.getEntityType());
    int count = 0;
    DataSize size = new DataSize();
    int top = query.getTopOrDefault();
    while (tuples.hasNext()) {
        Tuple tuple = tuples.next();
        entitySet.add(factory.create(tuple, query, size));
        count++;
        if (count >= top) {
            return entitySet;
        }
        if (size.getDataSize() > maxDataSize) {
            LOGGER.debug("Size limit reached: {} > {}.", size.getDataSize(), maxDataSize);
            return entitySet;
        }
    }
    return entitySet;
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
@Override
public Thing create(Tuple tuple, Query query, DataSize dataSize) {
    Set<Property> select = query == null ? Collections.emptySet() : query.getSelect();

    Thing entity = new Thing();
    entity.setName(tuple.get(qInstance.name));
    entity.setDescription(tuple.get(qInstance.description));

    UUID id = tuple.get(qInstance.id);
    if (id != null) {
        entity.setId(new UuidId(tuple.get(qInstance.id)));
    }

    if (select.isEmpty() || select.contains(EntityProperty.Properties)) {
        String props = tuple.get(qInstance.properties);
        dataSize.increase(props == null ? 0 : props.length());
        entity.setProperties(jsonToObject(props, Map.class));
    }

    return entity;
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
@Override
public Thing create(Tuple tuple, Query query, DataSize dataSize) {
    Set<Property> select = query == null ? Collections.emptySet() : query.getSelect();

    Thing entity = new Thing();
    entity.setName(tuple.get(qInstance.name));
    entity.setDescription(tuple.get(qInstance.description));

    Long id = tuple.get(qInstance.id);
    if (id != null) {
        entity.setId(new LongId(tuple.get(qInstance.id)));
    }

    if (select.isEmpty() || select.contains(EntityProperty.Properties)) {
        String props = tuple.get(qInstance.properties);
        dataSize.increase(props == null ? 0 : props.length());
        entity.setProperties(jsonToObject(props, Map.class));
    }

    return entity;
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
public void addOrderbyToQuery(OrderBy orderBy, SQLQuery<Tuple> sqlQuery) {
    Expression<?> resultExpression = orderBy.getExpression().accept(this);
    if (resultExpression instanceof TimeIntervalExpression) {
        TimeIntervalExpression ti = (TimeIntervalExpression) resultExpression;
        addToQuery(orderBy, ti.getStart(), sqlQuery);
        addToQuery(orderBy, ti.getEnd(), sqlQuery);
    }
    if (resultExpression instanceof ConstantDurationExpression) {
        ConstantDurationExpression duration = (ConstantDurationExpression) resultExpression;
        addToQuery(orderBy, duration.getDuration(), sqlQuery);
    }
    if (resultExpression instanceof ListExpression) {
        for (Expression<?> sqlExpression : ((ListExpression) resultExpression).getExpressionsForOrder().values()) {
            addToQuery(orderBy, sqlExpression, sqlQuery);
        }
    } else {
        addToQuery(orderBy, resultExpression, sqlQuery);
    }
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
@Override
public Thing create(Tuple tuple, Query query, DataSize dataSize) {
    Set<Property> select = query == null ? Collections.emptySet() : query.getSelect();

    Thing entity = new Thing();
    entity.setName(tuple.get(qInstance.name));
    entity.setDescription(tuple.get(qInstance.description));

    String id = tuple.get(qInstance.id);
    if (id != null) {
        entity.setId(new StringId(tuple.get(qInstance.id)));
    }

    if (select.isEmpty() || select.contains(EntityProperty.Properties)) {
        String props = tuple.get(qInstance.properties);
        dataSize.increase(props == null ? 0 : props.length());
        entity.setProperties(jsonToObject(props, Map.class));
    }

    return entity;
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
private Map<String, Long> resolveProjectKeyIdMap(final Set<String> projectKeys) {
  Map<String, Long> result = querydslSupport.execute((connection, configuration) -> {
    List<Tuple> resultSet = new SQLQuery<>(connection, configuration)
        .select(QProject.project.pkey, QProject.project.id)
        .from(QProject.project)
        .where(QProject.project.pkey.in(projectKeys)).fetch();

    Map<String, Long> localResult = new HashMap<>();
    for (Tuple tuple : resultSet) {
      localResult.put(tuple.get(QProject.project.pkey), tuple.get(QProject.project.id));
    }
    return localResult;
  });

  checkNoProjectKeyMissing(projectKeys, result.keySet());
  return result;
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
@Override
protected Facility map(Tuple row) {
    Facility facility = mapFacility(row, new Facility());
    facility.contacts = new FacilityContacts(
            row.get(qFacility.emergencyContactId),
            row.get(qFacility.operatorContactId),
            row.get(qFacility.serviceContactId)
    );
    facility.paymentInfo.detail = paymentInfoDetailMapping.map(row);
    facility.paymentInfo.url = paymentInfoUrlMapping.map(row);

    facility.openingHours.info = openingHoursInfoMapping.map(row);
    facility.openingHours.url = openingHoursUrlMapping.map(row);

    return facility;
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
@Override
protected Contact map(Tuple row) {
    Long id = row.get(qContact.id);
    if (id == null) {
        return null;
    }
    Contact contact = new Contact();
    contact.id = id;
    contact.operatorId = row.get(qContact.operatorId);
    contact.email = row.get(qContact.email);
    contact.phone = row.get(qContact.phone);
    contact.name = nameMapping.map(row);
    contact.address = addressMapping.map(row);
    contact.openingHours = openingHoursMapping.map(row);
    contact.info = infoMapping.map(row);
    return contact;
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
private void setEndDateForPreviousStateHistoryEntry(long facilityId, DateTime currentDate) {
    final Tuple lastHistoryEntry = queryFactory.query()
            .select(qFacilityStatusHistory.id, qFacilityStatusHistory.startTs)
            .from(qFacilityStatusHistory)
            .where(qFacilityStatusHistory.facilityId.eq(facilityId))
            .orderBy(qFacilityStatusHistory.endTs.desc().nullsFirst())
            .fetchFirst();

    if (lastHistoryEntry != null) {
        Long lastHistoryEntryId = lastHistoryEntry.get(qFacilityStatusHistory.id);
        final DateTime lastEntryStartTs = lastHistoryEntry.get(qFacilityStatusHistory.startTs);
        validateTimestamp(facilityId, currentDate, lastEntryStartTs, lastHistoryEntryId);
        queryFactory.update(qFacilityStatusHistory)
                .set(qFacilityStatusHistory.endTs, currentDate)
                .where(qFacilityStatusHistory.id.eq(lastHistoryEntryId))
                .execute();
    }
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
private void setEndDateForPreviousCapacityHistoryEntry(long facilityId, DateTime currentDate) {
    final Tuple lastHistoryEntry = queryFactory.query()
            .select(qFacilityCapacityHistory.id, qFacilityCapacityHistory.startTs)
            .from(qFacilityCapacityHistory)
            .where(qFacilityCapacityHistory.facilityId.eq(facilityId))
            .orderBy(qFacilityCapacityHistory.endTs.desc().nullsFirst())
            .fetchFirst();

    if (lastHistoryEntry != null) {
        Long lastHistoryEntryId = lastHistoryEntry.get(qFacilityCapacityHistory.id);
        final DateTime lastEntryStartTs = lastHistoryEntry.get(qFacilityCapacityHistory.startTs);
        validateTimestamp(facilityId, currentDate, lastEntryStartTs, lastHistoryEntryId);
        queryFactory.update(qFacilityCapacityHistory)
                .set(qFacilityCapacityHistory.endTs, currentDate)
                .where(qFacilityCapacityHistory.id.eq(lastHistoryEntryId))
                .execute();
    }
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
private static MappingProjection<PredictionBatch> predictionMapping(DateTime timeWithFullPrecision) {
    DateTime time = toPredictionResolution(timeWithFullPrecision);
    Path<Integer> spacesAvailableColumn = spacesAvailableAt(time);
    return new MappingProjection<PredictionBatch>(PredictionBatch.class,
            qPrediction.facilityId,
            qPrediction.capacityType,
            qPrediction.usage,
            qPrediction.start,
            spacesAvailableColumn) {
        @Override
        protected PredictionBatch map(Tuple row) {
            PredictionBatch pb = new PredictionBatch();
            pb.utilizationKey = new UtilizationKey(
                    row.get(qPrediction.facilityId),
                    row.get(qPrediction.capacityType),
                    row.get(qPrediction.usage)
            );
            pb.sourceTimestamp = row.get(qPrediction.start);
            Integer spacesAvailable = row.get(spacesAvailableColumn);
            if (spacesAvailable != null) {
                pb.predictions.add(new Prediction(time, spacesAvailable));
            }
            return pb;
        }
    };
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
protected FetchResults<Id, M> fetch(List<Group> versionsAndParents, boolean optimized, BooleanExpression predicate) {
    if (versionsAndParents.isEmpty()) {
        return noResults;
    }

    Map<Revision, List<Tuple>> properties = fetchProperties(optimized, predicate);
    ListMultimap<Id, ObjectVersion<M>> results = ArrayListMultimap.create();
    Revision latestRevision = null;

    for (Group versionAndParents : versionsAndParents) {
        Id id = versionAndParents.getOne(options.version.docId);
        latestRevision = versionAndParents.getOne(options.version.revision);
        Map<PropertyPath, Object> changeset = toChangeSet(properties.get(latestRevision));

        results.put(id, buildVersion(latestRevision, versionAndParents, changeset));
    }
    return new FetchResults<>(results, latestRevision);
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
protected Map<Revision, List<Tuple>> fetchProperties(boolean optimized, BooleanExpression predicate) {
    SQLQuery<?> qry = options.queryFactory
            .from(options.property)
            .where(predicate);

    if (optimized) {
        qry.innerJoin(options.version).on(
                options.version.revision.eq(options.property.revision),
                options.version.status.goe(ACTIVE));
        qry.where(options.property.status.goe(ACTIVE));
    } else {
        qry.innerJoin(options.version).on(options.version.revision.eq(options.property.revision));
        qry.where(options.property.status.loe(ACTIVE));
    }
    return qry.transform(properties);
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
@SuppressWarnings("unused")
protected Object getPropertyValue(PropertyPath path, Tuple tuple) {
    String type = firstNonNull(tuple.get(options.property.type), "N");
    String str = tuple.get(options.property.str);
    Long nbr = tuple.get(options.property.nbr);

    switch (type.charAt(0)) {
        case 'O': return Persistent.object(str);
        case 'A': return Persistent.array();
        case 's': return str;
        case 'b': return nbr != null ? nbr != 0 : null;
        case 'l': return nbr;
        case 'd': return nbr != null ? Double.longBitsToDouble(nbr) : null;
        case 'D': return !isNullOrEmpty(str) ? new BigDecimal(str) : null;
        case 'N': return Persistent.NULL;
        case 'n': return null;
        default:
            throw new IllegalArgumentException("Unsupported type: " + type);
    }
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
/**
 * Change the projection of this query
 * @param exprs new projection
 * @return the current object
 */
@Override
public JpaQuery<Tuple> select(Expression<?>... exprs) {
	queryMixin.setProjection(exprs);
	@SuppressWarnings("unchecked") // This is the new type
	JpaQuery<Tuple> newType = (JpaQuery<Tuple>) this;
	return newType;
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
@Override
public List<QuerydslTuple> getResultTuples() {
	List<?> results = executeQuery();

	List<QuerydslTuple> tuples = new ArrayList<>();
	for (Object result : results) {
		if (result instanceof Tuple) {
			tuples.add(new QuerydslTupleImpl((Tuple) result, selectionBindings));
		} else {
			tuples.add(new QuerydslObjectArrayTupleImpl(result, selectionBindings));
		}
	}
	return tuples;
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
@Before
public void setup() {

	expression = Mockito.mock(Expression.class);
	Tuple tuple = Mockito.mock(Tuple.class);
	Mockito.when(tuple.size()).thenReturn(2);
	Mockito.when(tuple.get(expression)).thenReturn("test");
	Mockito.when(tuple.toArray()).thenReturn(new Object[]{"0", "1"});
	Mockito.when(tuple.get(0, String.class)).thenReturn("0");
	Mockito.when(tuple.get(1, String.class)).thenReturn("1");

	Mockito.when(tuple.size()).thenReturn(2);
	Map<String, Integer> selectionBindings = new HashMap<>();
	impl = new QuerydslTupleImpl(tuple, selectionBindings);
}
 

import com.querydsl.core.Tuple; //导入依赖的package包/类
@Override
public Object get(ResourcePath path, Query query) {
    ResourcePathElement lastElement = path.getLastElement();
    if (!(lastElement instanceof EntityPathElement) && !(lastElement instanceof EntitySetPathElement)) {
        if (!query.getExpand().isEmpty()) {
            LOGGER.warn("Expand only allowed on Entities or EntitySets. Not on {}!", lastElement.getClass());
            query.getExpand().clear();
        }
        if (!query.getSelect().isEmpty()) {
            LOGGER.warn("Select only allowed on Entities or EntitySets. Not on {}!", lastElement.getClass());
            query.getSelect().clear();
        }
    }

    SQLQueryFactory qf = createQueryFactory();
    PathSqlBuilder psb = new PathSqlBuilderUuid();
    SQLQuery<Tuple> sqlQuery = psb.buildFor(path, query, qf, settings.getPersistenceSettings());

    if (LOGGER.isTraceEnabled()) {
        LOGGER.trace("Generated SQL:\n{}", sqlQuery.getSQL().getSQL());
    }

    EntityCreator entityCreator = new EntityCreator(this, path, query, sqlQuery);
    lastElement.visit(entityCreator);
    Object entity = entityCreator.getEntity();

    if (path.isValue() && entity instanceof Map) {
        Map map = (Map) entity;
        entity = map.get(entityCreator.getEntityName());
    }

    return entity;
}