Skip to content

Commit

Permalink
feat: update test structure
Browse files Browse the repository at this point in the history 
Signed-off-by: Otavio Santana <otaviopolianasantana@gmail.com>
  • Loading branch information
@otaviojava
otaviojava committed Mar 2, 2024
1 parent 8314049 commit d65bef3
Show file tree
Hide file tree
Showing 57 changed files with 1,194 additions and 1,856 deletions.
64 changes: 32 additions & 32 deletions ...tured/src/main/java/org/eclipse/jnosql/mapping/semistructured/AbstractColumnTemplate.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,13 +18,13 @@
import jakarta.data.exceptions.NonUniqueResultException;
import jakarta.nosql.PreparedStatement;
import jakarta.nosql.QueryMapper;
import jakarta.nosql.column.ColumnTemplate;
import org.eclipse.jnosql.communication.column.ColumnDeleteQuery;
import org.eclipse.jnosql.communication.column.ColumnEntity;
import org.eclipse.jnosql.communication.column.ColumnManager;
import org.eclipse.jnosql.communication.column.ColumnObserverParser;
import org.eclipse.jnosql.communication.column.ColumnQuery;
import org.eclipse.jnosql.communication.column.ColumnQueryParser;

import org.eclipse.jnosql.communication.semistructured.CommunicationEntity;
import org.eclipse.jnosql.communication.semistructured.CommunicationObserverParser;
import org.eclipse.jnosql.communication.semistructured.DatabaseManager;
import org.eclipse.jnosql.communication.semistructured.DeleteQuery;
import org.eclipse.jnosql.communication.semistructured.QueryParser;
import org.eclipse.jnosql.communication.semistructured.SelectQuery;
import org.eclipse.jnosql.mapping.core.Converters;
import org.eclipse.jnosql.mapping.IdNotFoundException;
import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata;
Expand All @@ -47,32 +47,32 @@
import static java.util.Objects.requireNonNull;

/**
* The template method to {@link ColumnTemplate}
* The template method to {@link SemistructuredTemplate}
*/
public abstract class AbstractColumnTemplate implements JNoSQLColumnTemplate {
public abstract class AbstractColumnTemplate implements SemistructuredTemplate {

private static final ColumnQueryParser PARSER = new ColumnQueryParser();
private static final QueryParser PARSER = new QueryParser();

protected abstract ColumnEntityConverter getConverter();

protected abstract ColumnManager getManager();
protected abstract DatabaseManager getManager();

protected abstract ColumnEventPersistManager getEventManager();

protected abstract EntitiesMetadata getEntities();

protected abstract Converters getConverters();

private final UnaryOperator<ColumnEntity> insert = e -> getManager().insert(e);
private final UnaryOperator<CommunicationEntity> insert = e -> getManager().insert(e);

private final UnaryOperator<ColumnEntity> update = e -> getManager().update(e);
private final UnaryOperator<CommunicationEntity> update = e -> getManager().update(e);

private ColumnObserverParser observer;
private CommunicationObserverParser observer;


private ColumnObserverParser getObserver() {
private CommunicationObserverParser getObserver() {
if (Objects.isNull(observer)) {
observer = new ColumnMapperObserver(getEntities());
observer = new MapperObserver(getEntities());
}
return observer;
}
Expand Down Expand Up @@ -122,30 +122,30 @@ public <T> Iterable<T> insert(Iterable<T> entities, Duration ttl) {
}

@Override
public void delete(ColumnDeleteQuery query) {
public void delete(DeleteQuery query) {
requireNonNull(query, "query is required");
getManager().delete(query);
}


@Override
public <T> Stream<T> select(ColumnQuery query) {
public <T> Stream<T> select(SelectQuery query) {
requireNonNull(query, "query is required");
return executeQuery(query);
}

@Override
public long count(ColumnQuery query) {
public long count(SelectQuery query) {
return getManager().count(query);
}

@Override
public boolean exists(ColumnQuery query) {
public boolean exists(SelectQuery query) {
return getManager().exists(query);
}

@Override
public <T> Optional<T> singleResult(ColumnQuery query) {
public <T> Optional<T> singleResult(SelectQuery query) {
requireNonNull(query, "query is required");
final Stream<T> select = select(query);

Expand All @@ -171,7 +171,7 @@ public <T, K> Optional<T> find(Class<T> type, K id) {
.orElseThrow(() -> IdNotFoundException.newInstance(type));

Object value = ConverterUtil.getValue(id, entityMetadata, idField.fieldName(), getConverters());
ColumnQuery query = ColumnQuery.select().from(entityMetadata.name())
SelectQuery query = SelectQuery.select().from(entityMetadata.name())
.where(idField.name()).eq(value).build();

return singleResult(query);
Expand All @@ -187,7 +187,7 @@ public <T, K> void delete(Class<T> type, K id) {
.orElseThrow(() -> IdNotFoundException.newInstance(type));
Object value = ConverterUtil.getValue(id, entityMetadata, idField.fieldName(), getConverters());

ColumnDeleteQuery query = ColumnDeleteQuery.delete().from(entityMetadata.name())
DeleteQuery query = DeleteQuery.delete().from(entityMetadata.name())
.where(idField.name()).eq(value).build();
getManager().delete(query);
}
Expand Down Expand Up @@ -232,10 +232,10 @@ public <T> long count(Class<T> type) {
return getManager().count(findAllQuery(type));
}

private <T> Stream<T> executeQuery(ColumnQuery query) {
private <T> Stream<T> executeQuery(SelectQuery query) {
requireNonNull(query, "query is required");
Stream<ColumnEntity> entities = getManager().select(query);
Function<ColumnEntity, T> function = e -> getConverter().toEntity(e);
Stream<CommunicationEntity> entities = getManager().select(query);
Function<CommunicationEntity, T> function = e -> getConverter().toEntity(e);
return entities.map(function).peek(getEventManager()::firePostEntity);
}

Expand Down Expand Up @@ -266,16 +266,16 @@ public <T> void deleteAll(Class<T> type) {
if(metadata.inheritance().isPresent()){
InheritanceMetadata inheritanceMetadata = metadata.inheritance().orElseThrow();
if(!inheritanceMetadata.parent().equals(metadata.type())){
getManager().delete(ColumnDeleteQuery.delete().from(metadata.name())
getManager().delete(DeleteQuery.delete().from(metadata.name())
.where(inheritanceMetadata.discriminatorColumn())
.eq(inheritanceMetadata.discriminatorValue()).build());
return;
}
}
getManager().delete(ColumnDeleteQuery.delete().from(metadata.name()).build());
getManager().delete(DeleteQuery.delete().from(metadata.name()).build());
}

protected <T> T persist(T entity, UnaryOperator<ColumnEntity> persistAction) {
protected <T> T persist(T entity, UnaryOperator<CommunicationEntity> persistAction) {
return Stream.of(entity)
.map(toUnary(getEventManager()::firePreEntity))
.map(getConverter()::toColumn)
Expand All @@ -293,16 +293,16 @@ private <T> UnaryOperator<T> toUnary(Consumer<T> consumer) {
};
}

private <T> ColumnQuery findAllQuery(Class<T> type){
private <T> SelectQuery findAllQuery(Class<T> type){
EntityMetadata metadata = getEntities().get(type);

if(metadata.inheritance().isPresent()){
InheritanceMetadata inheritanceMetadata = metadata.inheritance().orElseThrow();
if(!inheritanceMetadata.parent().equals(metadata.type())){
return ColumnQuery.select().from(metadata.name())
return SelectQuery.select().from(metadata.name())
.where(inheritanceMetadata.discriminatorColumn()).eq(inheritanceMetadata.discriminatorValue()).build();
}
}
return ColumnQuery.select().from(metadata.name()).build();
return SelectQuery.select().from(metadata.name()).build();
}
}
54 changes: 27 additions & 27 deletions ...ructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/AbstractMapperQuery.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,8 +14,8 @@
*/
package org.eclipse.jnosql.mapping.semistructured;

import org.eclipse.jnosql.communication.column.Column;
import org.eclipse.jnosql.communication.column.ColumnCondition;
import org.eclipse.jnosql.communication.semistructured.CriteriaCondition;
import org.eclipse.jnosql.communication.semistructured.Element;
import org.eclipse.jnosql.mapping.core.Converters;
import org.eclipse.jnosql.mapping.metadata.EntityMetadata;
import org.eclipse.jnosql.mapping.core.util.ConverterUtil;
Expand All @@ -30,11 +30,11 @@

abstract class AbstractMapperQuery {

protected final String columnFamily;
protected final String entity;

protected boolean negate;

protected ColumnCondition condition;
protected CriteriaCondition condition;

protected boolean and;

Expand All @@ -44,28 +44,28 @@ abstract class AbstractMapperQuery {

protected transient final Converters converters;

protected transient final JNoSQLColumnTemplate template;
protected transient final SemistructuredTemplate template;

protected long start;

protected long limit;


AbstractMapperQuery(EntityMetadata mapping, Converters converters, JNoSQLColumnTemplate template) {
AbstractMapperQuery(EntityMetadata mapping, Converters converters, SemistructuredTemplate template) {
this.mapping = mapping;
this.converters = converters;
this.columnFamily = mapping.name();
this.entity = mapping.name();
this.template = template;
mapping.inheritance().ifPresent(i -> {
if(!i.parent().equals(mapping.type())){
this.condition = ColumnCondition.eq(Column.of(i.discriminatorColumn(), i.discriminatorValue()));
this.condition = CriteriaCondition.eq(Element.of(i.discriminatorColumn(), i.discriminatorValue()));
this.and = true;
}
});
}

protected void appendCondition(ColumnCondition incomingCondition) {
ColumnCondition columnCondition = getColumnCondition(incomingCondition);
protected void appendCondition(CriteriaCondition incomingCondition) {
CriteriaCondition columnCondition = getCondition(incomingCondition);

if (nonNull(condition)) {
this.condition = and ? this.condition.and(columnCondition) : this.condition.or(columnCondition);
Expand All @@ -80,8 +80,8 @@ protected void appendCondition(ColumnCondition incomingCondition) {
protected <T> void betweenImpl(T valueA, T valueB) {
requireNonNull(valueA, "valueA is required");
requireNonNull(valueB, "valueB is required");
ColumnCondition newCondition = ColumnCondition
.between(Column.of(mapping.columnField(name), asList(getValue(valueA), getValue(valueB))));
CriteriaCondition newCondition = CriteriaCondition
.between(Element.of(mapping.columnField(name), asList(getValue(valueA), getValue(valueB))));
appendCondition(newCondition);
}

Expand All @@ -91,59 +91,59 @@ protected <T> void inImpl(Iterable<T> values) {
requireNonNull(values, "values is required");
List<Object> convertedValues = StreamSupport.stream(values.spliterator(), false)
.map(this::getValue).collect(toList());
ColumnCondition newCondition = ColumnCondition
.in(Column.of(mapping.columnField(name), convertedValues));
CriteriaCondition newCondition = CriteriaCondition
.in(Element.of(mapping.columnField(name), convertedValues));
appendCondition(newCondition);
}

protected <T> void eqImpl(T value) {
requireNonNull(value, "value is required");

ColumnCondition newCondition = ColumnCondition
.eq(Column.of(mapping.columnField(name), getValue(value)));
CriteriaCondition newCondition = CriteriaCondition
.eq(Element.of(mapping.columnField(name), getValue(value)));
appendCondition(newCondition);
}

protected void likeImpl(String value) {
requireNonNull(value, "value is required");
ColumnCondition newCondition = ColumnCondition
.like(Column.of(mapping.columnField(name), getValue(value)));
CriteriaCondition newCondition = CriteriaCondition
.like(Element.of(mapping.columnField(name), getValue(value)));
appendCondition(newCondition);
}

protected <T> void gteImpl(T value) {
requireNonNull(value, "value is required");
ColumnCondition newCondition = ColumnCondition
.gte(Column.of(mapping.columnField(name), getValue(value)));
CriteriaCondition newCondition = CriteriaCondition
.gte(Element.of(mapping.columnField(name), getValue(value)));
appendCondition(newCondition);
}

protected <T> void gtImpl(T value) {
requireNonNull(value, "value is required");
ColumnCondition newCondition = ColumnCondition
.gt(Column.of(mapping.columnField(name), getValue(value)));
CriteriaCondition newCondition = CriteriaCondition
.gt(Element.of(mapping.columnField(name), getValue(value)));
appendCondition(newCondition);
}

protected <T> void ltImpl(T value) {
requireNonNull(value, "value is required");
ColumnCondition newCondition = ColumnCondition
.lt(Column.of(mapping.columnField(name), getValue(value)));
CriteriaCondition newCondition = CriteriaCondition
.lt(Element.of(mapping.columnField(name), getValue(value)));
appendCondition(newCondition);
}

protected <T> void lteImpl(T value) {
requireNonNull(value, "value is required");
ColumnCondition newCondition = ColumnCondition
.lte(Column.of(mapping.columnField(name), getValue(value)));
CriteriaCondition newCondition = CriteriaCondition
.lte(Element.of(mapping.columnField(name), getValue(value)));
appendCondition(newCondition);
}

protected Object getValue(Object value) {
return ConverterUtil.getValue(value, mapping, name, converters);
}

private ColumnCondition getColumnCondition(ColumnCondition newCondition) {
private CriteriaCondition getCondition(CriteriaCondition newCondition) {
if (negate) {
return newCondition.negate();
} else {
Expand Down
Loading

0 comments on commit d65bef3

Please sign in to comment.