Java Modifying类代码示例

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
/**
   * Delete all messages that do not involve users other than the one specified (no other users as sender o recipient)
   * @param userProfile the receiver/sender of the message
   */
  @Modifying
  @Transactional(readOnly = false) 
  public void deleteBelongingTo(YadaUserProfile userProfile) {
  	// Messages that have the user as sender or recipient, and nobody else involved, or
  	// where the user is both sender and recipient
  	List <YadaUserMessage> toDelete = YadaSql.instance().selectFrom("select yum from YadaUserMessage yum")
  	    .where("(sender=:userProfile and recipient=null)").or()
  	    .where("(sender=null and recipient=:userProfile)").or()
  	    .where("(sender=:userProfile and recipient=:userProfile)")
   	.setParameter("userProfile", userProfile)
   	.query(em, YadaUserMessage.class).getResultList();
  	// Need to fetch them all then delete them, in order to cascade deletes to "created" and "attachment"
  	for (YadaUserMessage yadaUserMessage : toDelete) {
	em.remove(yadaUserMessage);
}
  }
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
/**
 * Updates counts of test run.
 * @param id Test run id.
 * @param totalCases Total test case count.
 * @param failedCases Total failed test cases count.
 */
@Modifying
@Transactional
@Query("UPDATE TestRun tr SET tr.exampleCount = COALESCE(tr.exampleCount, 0) + :totalCases, " +
		"tr.failureCount = COALESCE(tr.failureCount, 0) + :failedCases, " +
		"tr.duration = COALESCE(tr.duration, 0) + :duration " +
		"WHERE tr.id = :id")
void updateCounts(@Param("id")  Long id, @Param("totalCases") int totalCases, @Param("failedCases") int failedCases,
				  @Param("duration") double duration);
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
@Modifying
@Query(QueryProperties.updateStaffProfileByEmpId)
int updateStaffProfile(@Param("employeeFirstName") String employeeFirstName,
                       @Param("employeeLastName") String employeeLastName,
                       @Param("employeeTitle") String employeeTitle,
                       @Param("employeePhone") String employeePhone,
                       @Param("employeeId") long employeeId);
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
/**
 * Opens a new ticket
 * @param type
 * @param title
 * @param messageText initial ticket message
 * @param sender User opening the ticket
 * @param severity
 * @return the newly created ticket
 */
   @Modifying
   @Transactional(readOnly = false) 
   public YadaTicket addTicket(YadaLocalEnum<?> type, String title, String messageText, YadaUserProfile sender, int severity) {
   	List<YadaTicketMessage> yadaTicketMessages = new ArrayList<>();
	YadaTicket yadaTicket = new YadaTicket();
	yadaTicket.setStatus(YadaTicketStatus.OPEN);
	yadaTicket.setPriority(severity);
	yadaTicket.setType(type);
	yadaTicket.setOwner(sender);
	yadaTicket.setTitle(title);

	YadaTicketMessage yadaTicketMessage = new YadaTicketMessage();	
	yadaTicketMessage.setTitle(title);
	yadaTicketMessage.setMessage(messageText);
	yadaTicketMessage.setSender(sender);
	// When a ticket is added, no recipient has been chosen yet for the message
	// yadaTicketMessage.setRecipient();
	yadaTicketMessage.setStackable(false); // Same-content messages will never be stacked
	yadaTicketMessage.setPriority(severity); // message priority is the same as ticket priority

	yadaTicket.setMessages(yadaTicketMessages);
	yadaTicketMessage.setYadaTicket(yadaTicket);
	yadaTicketMessages.add(yadaTicketMessage);
	
	em.persist(yadaTicket); // Cascade save
	return yadaTicket;
}
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
/**
   * Send a reply to a ticket.
   * @param yadaTicket
   * @param messageText
   * @param replySender the user replying to the previous message, could be either the support staff or the original user
   * @param supportStaffReply true if this reply is an answer to the user who opened the ticket, false if it is the user answer to the support staff
   * @param closeTicket true if the replyer has closed the ticket on this reply
   * @return the new message added to the ticket
   */
  @Modifying
  @Transactional(readOnly = false) 
  public YadaTicketMessage replyTicket(Long yadaTicketId, String messageText, YadaUserProfile replySender, boolean supportStaffReply, boolean closeTicket) {
  	YadaTicket yadaTicket = em.find(YadaTicket.class, yadaTicketId); 
  	// Altrimenti si prende "could not initialize proxy - no Session" alla getMessages()
YadaTicketMessage yadaTicketMessage = new YadaTicketMessage();	
yadaTicket.getMessages().add(yadaTicketMessage);
yadaTicketMessage.setYadaTicket(yadaTicket);
yadaTicketMessage.setMessage(messageText);
yadaTicketMessage.setTitle(yadaTicket.getTitle());
yadaTicketMessage.setSender(replySender);
if (supportStaffReply) {
	yadaTicketMessage.setRecipient(yadaTicket.getOwner());
} else {
	yadaTicketMessage.setRecipient(yadaTicket.getAssigned()); // Could be null, but it's ok
}
yadaTicketMessage.setStackable(false); // Same-content messages will never be stacked
yadaTicketMessage.setPriority(yadaTicket.getPriority()); // message priority is the same as ticket priority
if (closeTicket) {
	yadaTicket.setStatus(YadaTicketStatus.CLOSED);
} else {
	// When the owner replies without closing, the ticket becomes OPEN
	// When the staff replies an open ticket, the status becomes ANSWERED
	yadaTicket.setStatus(supportStaffReply && yadaTicket.isOpen() ? YadaTicketStatus.ANSWERED : YadaTicketStatus.OPEN);
}
return yadaTicketMessage;
  }
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
@Modifying
   @Transactional(readOnly = false)
@Query("delete from #{#entityName} e where e.expiration is not null and e.expiration < NOW()")
void deleteExpired();
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
@Modifying
@Transactional
@Query("delete from BotCamera bc where bc.timeTaken < ?1")
void deleteOlderThan(Date timeTaken);
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
@Modifying
@Query(value = "delete from user where id = ?", nativeQuery = true)
public void deleteUserById(String id);
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
@Modifying
@Query("update Notification n set n.isRead = true where n.touser = ?1")
void updateByIsRead(User user);
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
@Modifying(clearAutomatically = true)
@Transactional
@Query(nativeQuery = true, value = "DELETE FROM ARTICLE_CATE_LABEL WHERE ARTICLE_ID=:articleId")
int deleteArticleCateLabel(@Param("articleId") Long articleId);
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
@Modifying(clearAutomatically = true)
@Transactional
@Query(nativeQuery = true, value = "UPDATE MEMO_REMIND SET STATUS=:status WHERE ID =:id")
int updateStatus(@Param("id") Long id, @Param("status") Integer status);
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
@Modifying
@Transactional
@Query(value="DELETE FROM cms_page WHERE bo_type_id = :boTypeId", nativeQuery=true)
void deleteByBoTypeId(@Param(value="boTypeId") long boTypeId);
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
@Modifying
@Query("delete from InstanceConfig  where ConfigAppId=?1 and ConfigClusterName=?2 and ConfigNamespaceName = ?3")
int batchDelete(String appId, String clusterName, String namespaceName);
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
@Modifying
   @Transactional(readOnly = false)
@Query("delete from #{#entityName} e where e.yadaUserCredentials = :userCredentials and e.type = :facebookType")
void deleteByYadaUserCredentialsAndType(@Param("userCredentials") YadaUserCredentials userCredentials, @Param("facebookType") int facebookType);
 

import org.springframework.data.jpa.repository.Modifying; //导入依赖的package包/类
@Modifying
@Query("select p.time,p.psJVM from TomcatResultEntity p where p.tomcatId=(?1) order by p.time asc ")
List<TomcatResultEntity> seletctJvmByTomcatId(String id);