import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
public PerformInsert(RelationalPath<?> entity, List<PerformInsertBatch> batches, Optional<Path<?>> key) {
	Objects.requireNonNull(entity);
	
	if(batches.isEmpty()) {
		throw new IllegalArgumentException("batches list is empty");
	}
	
	this.entity = entity;
	this.batches = batches;
	this.key = key.orElse(null);
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
public SQLUpdateClause getUpdateClause(RelationalPath path) {
    return new SQLUpdateClause(connection, MySQLTemplates.DEFAULT, path);
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
public SQLInsertClause getInsertClause(RelationalPath path) {
    return new SQLInsertClause(connection, MySQLTemplates.DEFAULT, path);
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
public SQLDeleteClause getDeleteCluase(RelationalPath path) {
    return new SQLDeleteClause(connection, MySQLTemplates.DEFAULT, path);
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
public void notifyDelete(RelationalPath<?> entity, QueryMetadata md) {
	// 何もしない
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
public void notifyDeletes(RelationalPath<?> entity, List<QueryMetadata> batches) {
	// 何もしない
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
public void notifyMerge(RelationalPath<?> entity, QueryMetadata md, List<Path<?>> keys, List<Path<?>> columns,
		List<Expression<?>> values, SubQueryExpression<?> subQuery) {
	// 何もしない
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
public void notifyMerges(RelationalPath<?> entity, QueryMetadata md, List<SQLMergeBatch> batches) {
	// 何もしない
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
public void notifyInsert(RelationalPath<?> entity, QueryMetadata md, List<Path<?>> columns,
		List<Expression<?>> values, SubQueryExpression<?> subQuery) {
	// 何もしない
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
public void notifyInserts(RelationalPath<?> entity, QueryMetadata md, List<SQLInsertBatch> batches) {
	// 何もしない
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
public void notifyUpdate(RelationalPath<?> entity, QueryMetadata md, List<Pair<Path<?>, Expression<?>>> updates) {
	// 何もしない
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
public void notifyUpdates(RelationalPath<?> entity, List<SQLUpdateBatch> batches) {
	// 何もしない
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
@WithBridgeMethods(value=AbstractAsyncSQLQuery.class, castRequired=true)
public <E> Q fullJoin(ForeignKey<E> key, RelationalPath<E> entity) {
    return queryMixin.fullJoin(entity).on(key.on(entity));
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
@WithBridgeMethods(value=AbstractAsyncSQLQuery.class, castRequired=true)
public <E> Q innerJoin(ForeignKey<E> key, RelationalPath<E> entity) {
    return queryMixin.innerJoin(entity).on(key.on(entity));
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
@WithBridgeMethods(value=AbstractAsyncSQLQuery.class, castRequired=true)
public <E> Q join(ForeignKey<E> key, RelationalPath<E>  entity) {
    return queryMixin.join(entity).on(key.on(entity));
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
@WithBridgeMethods(value=AbstractAsyncSQLQuery.class, castRequired=true)
public <E> Q leftJoin(ForeignKey<E> key, RelationalPath<E>  entity) {
    return queryMixin.leftJoin(entity).on(key.on(entity));
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
@Override
@WithBridgeMethods(value=AbstractAsyncSQLQuery.class, castRequired=true)
public <E> Q rightJoin(ForeignKey<E> key, RelationalPath<E>  entity) {
    return queryMixin.rightJoin(entity).on(key.on(entity));
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
public PerformDelete(RelationalPath<?> entity, DefaultQueryMetadata metadata) {
	this.entity = entity;
	this.metadata = metadata;
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
public RelationalPath<?> getEntity() {
	return entity;
}
 

import com.mysema.query.sql.RelationalPath; //导入依赖的package包/类
public PerformUpdate(RelationalPath<?> entity, List<Path<?>> columns, List<Expression<?>> values, QueryMetadata metadata) {
	this.entity = entity;
	this.columns = columns;
	this.values = values;
	this.metadata = metadata;		
}