Java SQLUpdateClause类代码示例

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
private void update(final Long userHolidayAmountId, final Long userId,
    final Date startSqlDate, final Date endSqlDateExcluded,
    final long amountInSeconds, final String description) {

  transactionTemplate.execute(() -> querydslSupport.execute((connection, configuration) -> {
    QUserHolidayAmount qUserHolidayAmount = QUserHolidayAmount.userHolidayAmount;

    Long dateRangeId =
        getDateRangeId(userHolidayAmountId, connection, configuration);

    new DateRangeUtil(connection, configuration).modifyDateRange(dateRangeId, startSqlDate,
        endSqlDateExcluded);

    new SQLUpdateClause(connection, configuration, qUserHolidayAmount)
        .set(qUserHolidayAmount.userId, userId)
        .set(qUserHolidayAmount.amount, amountInSeconds)
        .set(qUserHolidayAmount.description, description)
        .where(qUserHolidayAmount.userHolidayAmountId.eq(userHolidayAmountId))
        .execute();

    return null;
  }));
}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
private void update(final long recordId, final long schemeId, final long userId,
    final Date startDate, final Date endDateExcluded) {
  transactionTemplate.execute(() -> querydslSupport.execute((connection, configuration) -> {

    Long dateRangeId = new SQLQuery<Long>(connection, configuration)
        .select(qUserSchemeEntityParameter.dateRangeId)
        .from(qUserSchemeEntityParameter.userSchemeEntityPath)
        .where(qUserSchemeEntityParameter.userSchemeId.eq(recordId)).fetchOne();

    new DateRangeUtil(connection, configuration).modifyDateRange(dateRangeId, startDate,
        endDateExcluded);

    new SQLUpdateClause(connection, configuration,
        qUserSchemeEntityParameter.userSchemeEntityPath)
            .set(qUserSchemeEntityParameter.userId, userId)
            .where(qUserSchemeEntityParameter.userSchemeId.eq(recordId));
    return null;
  }));

}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
private void updatePublicHoliday(final long publicHolidayId, final Date date,
    final Date replacementDate,
    final String description) {

  querydslSupport.execute((connection, configuration) -> {
    QPublicHoliday qPublicHoliday = QPublicHoliday.publicHoliday;
    SQLUpdateClause update = new SQLUpdateClause(connection, configuration, qPublicHoliday)
        .set(qPublicHoliday.date, date);

    if (replacementDate != null) {
      update.set(qPublicHoliday.replacementDate, replacementDate);
    } else {
      update.setNull(qPublicHoliday.replacementDate);
    }

    if (description != null) {
      update.set(qPublicHoliday.description, description);
    } else {
      update.setNull(qPublicHoliday.description);
    }

    update.where(qPublicHoliday.publicHolidayId.eq(publicHolidayId)).execute();
    return null;
  });
}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
private void updateScheme(final SchemeDTO scheme) {
  querydslSupport.execute((connection, configuration) -> {
    QWorkScheme qWorkScheme = QWorkScheme.workScheme;
    return new SQLUpdateClause(connection, configuration, qWorkScheme)
        .set(qWorkScheme.name, scheme.name)
        .where(qWorkScheme.workSchemeId.eq(scheme.schemeId))
        .execute();
  });
}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
private void updateScheme(final SchemeDTO scheme) {
  querydslSupport.execute((connection, configuration) -> {
    QHolidayScheme qHolidayScheme = QHolidayScheme.holidayScheme;
    return new SQLUpdateClause(connection, configuration, qHolidayScheme)
        .set(qHolidayScheme.name, scheme.name)
        .where(qHolidayScheme.holidaySchemeId.eq(scheme.schemeId))
        .execute();
  });
}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
public void modifyDateRange(final long dateRangeId, final Date startDate,
    final Date endDateExcluded) {

  QDateRange dateRange = QDateRange.dateRange;
  new SQLUpdateClause(connection, configuration, dateRange)
      .set(dateRange.startDate, startDate)
      .set(dateRange.endDateExcluded, endDateExcluded)
      .where(dateRange.dateRangeId.eq(dateRangeId)).execute();

  vacuumDates();
  fillDateSequenceFromRange(startDate, endDateExcluded);

}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
private void updatePorts(long facilityId, Map<Integer, Port> updatedPorts) {
    if (updatedPorts != null && !updatedPorts.isEmpty()) {
        SQLUpdateClause update = queryFactory.update(qPort);
        for (Entry<Integer, Port> entry : updatedPorts.entrySet()) {
            Integer portIndex = entry.getKey();
            populate(facilityId, portIndex, entry.getValue(), update);
            update.where(qPort.facilityId.eq(facilityId), qPort.portIndex.eq(portIndex));
            update.addBatch();
        }
        update.execute();
    }
}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
@Override
@TransactionalWrite
public void updateContact(long contactId, Contact contact) {
    SQLUpdateClause update = queryFactory.update(qContact).where(qContact.id.eq(contactId));
    populate(contact, update);
    if (update.execute() != 1) {
        notFound(contactId);
    }
}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
private <T> void updateBatch(Collection<T> batch, RelationalPath<?> expression, BiConsumer<SQLUpdateClause, T> processor) {
    if (batch.isEmpty()) {
        return;
    }
    final SQLUpdateClause update = queryFactory.update(expression);
    batch.forEach(item -> {
        processor.accept(update, item);
        update.addBatch();
    });
    update.execute();
}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
private long maybeUpdatePredictionLookupTable(UtilizationKey utilizationKey, DateTime start, List<Prediction> predictions) {
    SQLUpdateClause update = queryFactory.update(qPrediction)
            .where(qPrediction.facilityId.eq(utilizationKey.facilityId),
                    qPrediction.capacityType.eq(utilizationKey.capacityType),
                    qPrediction.usage.eq(utilizationKey.usage))
            .set(qPrediction.start, start);
    predictions.forEach(p -> update.set(spacesAvailableAt(p.timestamp), p.spacesAvailable));

    return update.execute();
}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
@TransactionalWrite
@Override
public void updateOperator(long operatorId, Operator operator) {
    SQLUpdateClause update = queryFactory.update(qOperator);
    update.where(qOperator.id.eq(operatorId));
    nameMapping.populate(operator.name, update);
    if (update.execute() != 1) {
        notFound(operatorId);
    }
}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
@Override
@TransactionalWrite
public void updateHub(long hubId, Hub hub) {
    SQLUpdateClause update = queryFactory.update(qHub);
    update.where(qHub.id.eq(hubId));
    populate(hub, update);
    if (update.execute() != 1) {
        throw new HubNotFoundException(hubId);
    }

    deleteHubFacilities(hubId);
    insertHubFacilities(hubId, hub.facilityIds);
}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
protected Multimap<Id, Revision> doPublish() {
    Map<Revision, Id> uncommittedRevisions = getUnpublishedRevisionsForUpdate();
    long lastOrdinal = getMaxOrdinal();

    log.debug("publish({})", uncommittedRevisions.size());
    if (uncommittedRevisions.isEmpty()) {
        return ImmutableMultimap.of();
    }

    Multimap<Id, Revision> publishedDocs = ArrayListMultimap.create();

    SQLUpdateClause versionUpdateBatch = options.queryFactory.update(options.version);

    for (Map.Entry<Revision, Id> entry : uncommittedRevisions.entrySet()) {
        Revision revision = entry.getKey();
        Id docId = entry.getValue();
        publishedDocs.put(docId, revision);
        setOrdinal(versionUpdateBatch, ++lastOrdinal)
                .where(options.version.revision.eq(revision))
                .addBatch();
    }

    versionUpdateBatch.execute();

    afterPublish(publishedDocs);
    return publishedDocs;
}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
public boolean updateHistoricalLocation(HistoricalLocation hl, UUID id) {
    SQLQueryFactory qFactory = pm.createQueryFactory();
    QHistLocations qhl = QHistLocations.histLocations;
    SQLUpdateClause update = qFactory.update(qhl);
    if (hl.isSetThing()) {
        if (!entityExists(hl.getThing())) {
            throw new IncompleteEntityException("Thing can not be null.");
        }
        update.set(qhl.thingId, (UUID) hl.getThing().getId().getValue());
    }
    if (hl.isSetTime()) {
        if (hl.getTime() == null) {
            throw new IncompleteEntityException("time can not be null.");
        }
        insertTimeInstant(update, qhl.time, hl.getTime());
    }
    update.where(qhl.id.eq(id));
    long count = 0;
    if (!update.isEmpty()) {
        count = update.execute();
    }
    if (count > 1) {
        LOGGER.error("Updating Location {} caused {} rows to change!", id, count);
        throw new IllegalStateException("Update changed multiple rows.");
    }
    LOGGER.debug("Updated Location {}", id);

    // Link existing locations to the HistoricalLocation.
    for (Location l : hl.getLocations()) {
        if (!entityExists(l)) {
            throw new IllegalArgumentException("Unknown Location or Location with no id.");
        }
        UUID lId = (UUID) l.getId().getValue();

        QLocationsHistLocations qlhl = QLocationsHistLocations.locationsHistLocations;
        SQLInsertClause insert = qFactory.insert(qlhl);
        insert.set(qlhl.histLocationId, id);
        insert.set(qlhl.locationId, lId);
        insert.execute();
        LOGGER.debug("Linked Location {} to HistoricalLocation {}.", lId, id);
    }
    return true;
}
 

import com.querydsl.sql.dml.SQLUpdateClause; //导入依赖的package包/类
public boolean updateObservedProperty(ObservedProperty op, UUID opId) throws NoSuchEntityException {
    SQLQueryFactory qFactory = pm.createQueryFactory();
    QObsProperties qop = QObsProperties.obsProperties;
    SQLUpdateClause update = qFactory.update(qop);
    if (op.isSetDefinition()) {
        if (op.getDefinition() == null) {
            throw new IncompleteEntityException("definition can not be null.");
        }
        update.set(qop.definition, op.getDefinition());
    }
    if (op.isSetDescription()) {
        if (op.getDescription() == null) {
            throw new IncompleteEntityException("description can not be null.");
        }
        update.set(qop.description, op.getDescription());
    }
    if (op.isSetName()) {
        if (op.getName() == null) {
            throw new IncompleteEntityException("name can not be null.");
        }
        update.set(qop.name, op.getName());
    }
    if (op.isSetProperties()) {
        update.set(qop.properties, objectToJson(op.getProperties()));
    }

    update.where(qop.id.eq(opId));
    long count = 0;
    if (!update.isEmpty()) {
        count = update.execute();
    }
    if (count > 1) {
        LOGGER.error("Updating ObservedProperty {} caused {} rows to change!", opId, count);
        throw new IllegalStateException("Update changed multiple rows.");
    }

    // Link existing Datastreams to the observedProperty.
    for (Datastream ds : op.getDatastreams()) {
        if (ds.getId() == null || !entityExists(ds)) {
            throw new NoSuchEntityException("ObservedProperty with no id or non existing.");
        }
        UUID dsId = (UUID) ds.getId().getValue();
        QDatastreams qds = QDatastreams.datastreams;
        long dsCount = qFactory.update(qds)
                .set(qds.obsPropertyId, opId)
                .where(qds.id.eq(dsId))
                .execute();
        if (dsCount > 0) {
            LOGGER.info("Assigned datastream {} to ObservedProperty {}.", dsId, opId);
        }
    }

    if (!op.getMultiDatastreams().isEmpty()) {
        throw new IllegalArgumentException("Can not add MultiDatastreams to an ObservedProperty.");
    }

    LOGGER.debug("Updated ObservedProperty {}", opId);
    return true;
}