@Override
public <E extends T, K> E findByKey(Class<E> type, K key) {
Type<E> entityType = entityModel.typeOf(type);
if (entityType.isCacheable() && entityCache != null) {
E entity = entityCache.get(type, key);
if (entity != null) {
return entity;
}
}
Set<Attribute<E, ?>> keys = entityType.getKeyAttributes();
if (keys.isEmpty()) {
throw new MissingKeyException();
}
Selection<? extends Result<E>> selection = select(type);
if (keys.size() == 1) {
QueryAttribute<E, Object> attribute = Attributes.query(keys.iterator().next());
selection.where(attribute.equal(key));
} else {
if (key instanceof CompositeKey) {
CompositeKey compositeKey = (CompositeKey) key;
for (Attribute<E, ?> attribute : keys) {
QueryAttribute<E, Object> keyAttribute = Attributes.query(attribute);
Object value = compositeKey.get(keyAttribute);
selection.where(keyAttribute.equal(value));
}
} else {
throw new IllegalArgumentException("CompositeKey required");
}
}
return selection.get().firstOrNull();
}
@Override
public <E extends T> Insertion<? extends Result<Tuple>> insert(Class<E> type) {
checkClosed();
Type<E> entityType = context.getModel().typeOf(type);
Set<Expression<?>> keySelection = new LinkedHashSet<>();
for (Attribute<E, ?> attribute : entityType.getKeyAttributes()) {
keySelection.add((Expression<?>) attribute);
}
InsertReturningOperation operation = new InsertReturningOperation(context, keySelection);
return new QueryElement<>(INSERT, entityModel, operation).from(type);
}