From b673ab0c66bcfd95f5360c0bd68a15de0a115835 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 06:20:54 +0000 Subject: [PATCH 01/47] chore: update validation at return Signed-off-by: Otavio Santana --- .../jnosql/mapping/core/query/AnnotationOperation.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperation.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperation.java index 94c1439f5..e13fd9720 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperation.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperation.java @@ -43,8 +43,8 @@ public Object invoke(Operation operation) { Iterable result = operation.repository.insertAll(Arrays.asList((Object[]) param)); return returnType.isVoid() ? Void.TYPE : result; } else { - Object result = operation.repository.insert(param); - return returnType.isVoid() ? Void.TYPE : param; + var result = operation.repository.insert(param); + return returnType.isVoid() ? Void.TYPE : result; } } }, From 7360c95e2cda564f8f57a81f0be06606431c3fa8 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 17:37:00 +0000 Subject: [PATCH 02/47] feat: create implementation to column paramter based query Signed-off-by: Otavio Santana --- .../query/ColumnParameterBasedQuery.java | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java diff --git a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java new file mode 100644 index 000000000..cf0ea1674 --- /dev/null +++ b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2023 Contributors to the Eclipse Foundation + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * and Apache License v2.0 which accompanies this distribution. + * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html + * and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php. + * + * You may elect to redistribute this code under either of these licenses. + * + * Contributors: + * + * Otavio Santana + */ +package org.eclipse.jnosql.mapping.column.query; + +import jakarta.data.Sort; +import jakarta.data.page.Pageable; +import jakarta.enterprise.inject.spi.CDI; +import org.eclipse.jnosql.communication.column.ColumnCondition; +import org.eclipse.jnosql.communication.column.ColumnQuery; +import org.eclipse.jnosql.mapping.column.MappingColumnQuery; +import org.eclipse.jnosql.mapping.core.Converters; +import org.eclipse.jnosql.mapping.core.NoSQLPage; +import org.eclipse.jnosql.mapping.metadata.EntityMetadata; +import org.eclipse.jnosql.mapping.metadata.FieldMetadata; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import static org.eclipse.jnosql.mapping.core.util.ConverterUtil.getValue; + +/** + * The implementation of Parameter-based Conditions determine the implementation of the method to Column query + */ +public class ColumnParameterBasedQuery { + + private static final ColumnCondition[] CONDITIONS = new ColumnCondition[0]; + + public ColumnQuery toQuery(Map params, Pageable pageable, EntityMetadata entityMetadata) { + var convert = CDI.current().select(Converters.class).get(); + var conditions = new ArrayList<>(); + for (Map.Entry entry : params.entrySet()) { + conditions.add(getCondition(convert, entityMetadata, entry)); + } + + var columnCondition = ColumnCondition.and(conditions.toArray(CONDITIONS)); + var sorts = pageable.sorts(); + long limit = pageable.size(); + long skip = NoSQLPage.skip(pageable); + var columnFamily = entityMetadata.name(); + return new MappingColumnQuery(sorts, limit, skip, columnCondition, columnFamily); + } + + private ColumnCondition getCondition(Converters convert, EntityMetadata entityMetadata, Map.Entry entry) { + var name = entityMetadata.fieldMapping(entry.getKey()) + .map(FieldMetadata::name) + .orElse(entry.getKey()); + var value = getValue(entry.getValue(), entityMetadata, entry.getKey(), convert); + return ColumnCondition.eq(name, value); + } +} From 932f8fbdc3e40dbddd0214ec18870ae44305803a Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 17:41:46 +0000 Subject: [PATCH 03/47] docs: create documentation at column parameter based query Signed-off-by: Otavio Santana --- .../query/ColumnParameterBasedQuery.java | 25 ++++++++++++++----- 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java index cf0ea1674..6b72ea56c 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java @@ -14,7 +14,6 @@ */ package org.eclipse.jnosql.mapping.column.query; -import jakarta.data.Sort; import jakarta.data.page.Pageable; import jakarta.enterprise.inject.spi.CDI; import org.eclipse.jnosql.communication.column.ColumnCondition; @@ -26,18 +25,32 @@ import org.eclipse.jnosql.mapping.metadata.FieldMetadata; import java.util.ArrayList; -import java.util.List; import java.util.Map; +import java.util.function.IntFunction; import static org.eclipse.jnosql.mapping.core.util.ConverterUtil.getValue; /** - * The implementation of Parameter-based Conditions determine the implementation of the method to Column query + * The ColumnParameterBasedQuery class is responsible for generating Column queries based on a set of parameters. + * It leverages the provided parameters, pageable information, and entity metadata to construct a ColumnQuery object + * tailored for querying a specific entity's columns. */ -public class ColumnParameterBasedQuery { +public final class ColumnParameterBasedQuery { - private static final ColumnCondition[] CONDITIONS = new ColumnCondition[0]; + private static final IntFunction TO_ARRAY = ColumnCondition[]::new; + + private ColumnParameterBasedQuery() { + } + + /** + * Constructs a ColumnQuery based on the provided parameters, pageable information, and entity metadata. + * + * @param params The map of parameters used for filtering columns. + * @param pageable The Pageable object containing sorting and pagination information. + * @param entityMetadata Metadata describing the structure of the entity. + * @return A ColumnQuery instance tailored for the specified entity. + */ public ColumnQuery toQuery(Map params, Pageable pageable, EntityMetadata entityMetadata) { var convert = CDI.current().select(Converters.class).get(); var conditions = new ArrayList<>(); @@ -45,7 +58,7 @@ public ColumnQuery toQuery(Map params, Pageable pageable, Entity conditions.add(getCondition(convert, entityMetadata, entry)); } - var columnCondition = ColumnCondition.and(conditions.toArray(CONDITIONS)); + var columnCondition = ColumnCondition.and(conditions.toArray(TO_ARRAY)); var sorts = pageable.sorts(); long limit = pageable.size(); long skip = NoSQLPage.skip(pageable); From 63624381617def32f0419228b042003980a34627 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 17:43:01 +0000 Subject: [PATCH 04/47] feat: convert to singleton the column parater based Signed-off-by: Otavio Santana --- .../mapping/column/query/ColumnParameterBasedQuery.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java index 6b72ea56c..ef53be441 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java @@ -51,7 +51,7 @@ private ColumnParameterBasedQuery() { * @param entityMetadata Metadata describing the structure of the entity. * @return A ColumnQuery instance tailored for the specified entity. */ - public ColumnQuery toQuery(Map params, Pageable pageable, EntityMetadata entityMetadata) { + public static ColumnQuery toQuery(Map params, Pageable pageable, EntityMetadata entityMetadata) { var convert = CDI.current().select(Converters.class).get(); var conditions = new ArrayList<>(); for (Map.Entry entry : params.entrySet()) { @@ -66,7 +66,7 @@ public ColumnQuery toQuery(Map params, Pageable pageable, Entity return new MappingColumnQuery(sorts, limit, skip, columnCondition, columnFamily); } - private ColumnCondition getCondition(Converters convert, EntityMetadata entityMetadata, Map.Entry entry) { + private static ColumnCondition getCondition(Converters convert, EntityMetadata entityMetadata, Map.Entry entry) { var name = entityMetadata.fieldMapping(entry.getKey()) .map(FieldMetadata::name) .orElse(entry.getKey()); From 6cd5373f16e657e75b190ccb9a96a79b26f4ccd2 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 17:43:38 +0000 Subject: [PATCH 05/47] feat: convert the column parater to enum Signed-off-by: Otavio Santana --- .../column/query/ColumnParameterBasedQuery.java | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java index ef53be441..43386c288 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java @@ -35,14 +35,12 @@ * It leverages the provided parameters, pageable information, and entity metadata to construct a ColumnQuery object * tailored for querying a specific entity's columns. */ -public final class ColumnParameterBasedQuery { +public enum ColumnParameterBasedQuery { + INSTANCE; private static final IntFunction TO_ARRAY = ColumnCondition[]::new; - private ColumnParameterBasedQuery() { - } - /** * Constructs a ColumnQuery based on the provided parameters, pageable information, and entity metadata. * @@ -51,7 +49,7 @@ private ColumnParameterBasedQuery() { * @param entityMetadata Metadata describing the structure of the entity. * @return A ColumnQuery instance tailored for the specified entity. */ - public static ColumnQuery toQuery(Map params, Pageable pageable, EntityMetadata entityMetadata) { + public ColumnQuery toQuery(Map params, Pageable pageable, EntityMetadata entityMetadata) { var convert = CDI.current().select(Converters.class).get(); var conditions = new ArrayList<>(); for (Map.Entry entry : params.entrySet()) { @@ -66,7 +64,7 @@ public static ColumnQuery toQuery(Map params, Pageable pageable, return new MappingColumnQuery(sorts, limit, skip, columnCondition, columnFamily); } - private static ColumnCondition getCondition(Converters convert, EntityMetadata entityMetadata, Map.Entry entry) { + private ColumnCondition getCondition(Converters convert, EntityMetadata entityMetadata, Map.Entry entry) { var name = entityMetadata.fieldMapping(entry.getKey()) .map(FieldMetadata::name) .orElse(entry.getKey()); From 56afe497e038acb0f11b27bafeafbcb97d82c380 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 17:46:14 +0000 Subject: [PATCH 06/47] test: create column paramter based query Signed-off-by: Otavio Santana --- .../query/ColumnParameterBasedQueryTest.java | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java diff --git a/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java new file mode 100644 index 000000000..1bfcbdbe2 --- /dev/null +++ b/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2023 Contributors to the Eclipse Foundation + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * and Apache License v2.0 which accompanies this distribution. + * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html + * and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php. + * + * You may elect to redistribute this code under either of these licenses. + * + * Contributors: + * + * Otavio Santana + */ +package org.eclipse.jnosql.mapping.column.query; + +import org.eclipse.jnosql.mapping.column.ColumnEntityConverter; +import org.eclipse.jnosql.mapping.column.MockProducer; +import org.eclipse.jnosql.mapping.column.spi.ColumnExtension; +import org.eclipse.jnosql.mapping.core.Converters; +import org.eclipse.jnosql.mapping.core.spi.EntityMetadataExtension; +import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.jboss.weld.junit5.auto.AddExtensions; +import org.jboss.weld.junit5.auto.AddPackages; +import org.jboss.weld.junit5.auto.EnableAutoWeld; + +import static org.junit.jupiter.api.Assertions.*; + +@EnableAutoWeld +@AddPackages(value = {Converters.class, ColumnEntityConverter.class}) +@AddPackages(MockProducer.class) +@AddPackages(Reflections.class) +@AddExtensions({EntityMetadataExtension.class, ColumnExtension.class}) +class ColumnParameterBasedQueryTest { + +} \ No newline at end of file From 210c564d1d4885c18a0caa9f2733bd376159583c Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 17:56:47 +0000 Subject: [PATCH 07/47] feat: create null condition Signed-off-by: Otavio Santana --- .../column/query/ColumnParameterBasedQuery.java | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java index 43386c288..869f2fb32 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java @@ -25,7 +25,9 @@ import org.eclipse.jnosql.mapping.metadata.FieldMetadata; import java.util.ArrayList; +import java.util.Collections; import java.util.Map; +import java.util.Optional; import java.util.function.IntFunction; import static org.eclipse.jnosql.mapping.core.util.ConverterUtil.getValue; @@ -56,10 +58,11 @@ public ColumnQuery toQuery(Map params, Pageable pageable, Entity conditions.add(getCondition(convert, entityMetadata, entry)); } - var columnCondition = ColumnCondition.and(conditions.toArray(TO_ARRAY)); - var sorts = pageable.sorts(); - long limit = pageable.size(); - long skip = NoSQLPage.skip(pageable); + var columnCondition = conditions.isEmpty()? null: ColumnCondition.and(conditions.toArray(TO_ARRAY)); + var optional = Optional.ofNullable(pageable); + var sorts = optional.map(Pageable::sorts).orElse(Collections.emptyList()); + long limit = optional.map(Pageable::size).orElse(0); + long skip = optional.map(p -> NoSQLPage.skip(pageable)).orElse(0L); var columnFamily = entityMetadata.name(); return new MappingColumnQuery(sorts, limit, skip, columnCondition, columnFamily); } From 74dd87daec3bd71ba1274720592eff48e34bafe9 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:11:01 +0000 Subject: [PATCH 08/47] feat: create implementation to column paramter based Signed-off-by: Otavio Santana --- .../query/ColumnParameterBasedQuery.java | 15 +++- .../query/ColumnParameterBasedQueryTest.java | 74 +++++++++++++++++++ 2 files changed, 87 insertions(+), 2 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java index 869f2fb32..2416a55de 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java @@ -26,6 +26,7 @@ import java.util.ArrayList; import java.util.Collections; +import java.util.List; import java.util.Map; import java.util.Optional; import java.util.function.IntFunction; @@ -53,12 +54,12 @@ public enum ColumnParameterBasedQuery { */ public ColumnQuery toQuery(Map params, Pageable pageable, EntityMetadata entityMetadata) { var convert = CDI.current().select(Converters.class).get(); - var conditions = new ArrayList<>(); + List conditions = new ArrayList<>(); for (Map.Entry entry : params.entrySet()) { conditions.add(getCondition(convert, entityMetadata, entry)); } - var columnCondition = conditions.isEmpty()? null: ColumnCondition.and(conditions.toArray(TO_ARRAY)); + var columnCondition = columnCondition(conditions); var optional = Optional.ofNullable(pageable); var sorts = optional.map(Pageable::sorts).orElse(Collections.emptyList()); long limit = optional.map(Pageable::size).orElse(0); @@ -67,6 +68,16 @@ public ColumnQuery toQuery(Map params, Pageable pageable, Entity return new MappingColumnQuery(sorts, limit, skip, columnCondition, columnFamily); } + private ColumnCondition columnCondition(List conditions) { + if(conditions.isEmpty()){ + return null; + } + else if(conditions.size() == 1){ + return conditions.get(0); + } + return ColumnCondition.and(conditions.toArray(TO_ARRAY)); + } + private ColumnCondition getCondition(Converters convert, EntityMetadata entityMetadata, Map.Entry entry) { var name = entityMetadata.fieldMapping(entry.getKey()) .map(FieldMetadata::name) diff --git a/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java index 1bfcbdbe2..7ee49504c 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java @@ -14,15 +14,31 @@ */ package org.eclipse.jnosql.mapping.column.query; +import jakarta.inject.Inject; +import org.assertj.core.api.SoftAssertions; +import org.eclipse.jnosql.communication.Condition; +import org.eclipse.jnosql.communication.TypeReference; +import org.eclipse.jnosql.communication.column.Column; +import org.eclipse.jnosql.communication.column.ColumnCondition; +import org.eclipse.jnosql.communication.column.ColumnQuery; import org.eclipse.jnosql.mapping.column.ColumnEntityConverter; import org.eclipse.jnosql.mapping.column.MockProducer; +import org.eclipse.jnosql.mapping.column.entities.Person; import org.eclipse.jnosql.mapping.column.spi.ColumnExtension; import org.eclipse.jnosql.mapping.core.Converters; import org.eclipse.jnosql.mapping.core.spi.EntityMetadataExtension; +import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; +import org.eclipse.jnosql.mapping.metadata.EntityMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.List; +import java.util.Map; import static org.junit.jupiter.api.Assertions.*; @@ -33,4 +49,62 @@ @AddExtensions({EntityMetadataExtension.class, ColumnExtension.class}) class ColumnParameterBasedQueryTest { + @Inject + private EntitiesMetadata entitiesMetadata; + + private EntityMetadata metadata; + @BeforeEach + void setUp(){ + this.metadata = entitiesMetadata.get(Person.class); + } + + @Test + void shouldCreateQuerySingleParameter(){ + Map params = Map.of("name", "Ada"); + ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, null, metadata); + + SoftAssertions.assertSoftly(soft ->{ + soft.assertThat(query.limit()).isEqualTo(0L); + soft.assertThat(query.skip()).isEqualTo(0L); + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.sorts()).isEmpty(); + soft.assertThat(query.condition()).isNotEmpty(); + soft.assertThat(query.condition()).get().isEqualTo(ColumnCondition.eq(Column.of("name", "Ada"))); + }); + } + + @Test + void shouldCreateQueryMultipleParams(){ + Map params = Map.of("name", "Ada", "age", 10); + ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, null, metadata); + + SoftAssertions.assertSoftly(soft ->{ + soft.assertThat(query.limit()).isEqualTo(0L); + soft.assertThat(query.skip()).isEqualTo(0L); + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.sorts()).isEmpty(); + soft.assertThat(query.condition()).isNotEmpty(); + var condition = query.condition().orElseThrow(); + soft.assertThat(condition.condition()).isEqualTo(Condition.AND); + soft.assertThat(condition.column().get(new TypeReference>() { + })).contains(ColumnCondition.eq(Column.of("name", "Ada")), + ColumnCondition.eq(Column.of("age", 10))); + }); + + } + + @Test + void shouldCreateQueryEmptyParams(){ + Map params = Collections.emptyMap(); + ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, null, metadata); + + SoftAssertions.assertSoftly(soft ->{ + soft.assertThat(query.limit()).isEqualTo(0L); + soft.assertThat(query.skip()).isEqualTo(0L); + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.sorts()).isEmpty(); + soft.assertThat(query.condition()).isEmpty(); + }); + } + } \ No newline at end of file From f8c5b0210164c77f22c966633b5fa0018dcbc798 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:14:32 +0000 Subject: [PATCH 09/47] test: create scenarios to column parameter based query Signed-off-by: Otavio Santana --- .../query/ColumnParameterBasedQueryTest.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java index 7ee49504c..23fc49cc6 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java @@ -14,6 +14,8 @@ */ package org.eclipse.jnosql.mapping.column.query; +import jakarta.data.Sort; +import jakarta.data.page.Pageable; import jakarta.inject.Inject; import org.assertj.core.api.SoftAssertions; import org.eclipse.jnosql.communication.Condition; @@ -107,4 +109,20 @@ void shouldCreateQueryEmptyParams(){ }); } + @Test + void shouldCreateQueryPageable(){ + Map params = Map.of("name", "Ada"); + var pageable = Pageable.ofPage(2).size(10).sortBy(Sort.asc("name")); + ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, pageable, metadata); + + SoftAssertions.assertSoftly(soft ->{ + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.condition()).isNotEmpty(); + soft.assertThat(query.condition()).get().isEqualTo(ColumnCondition.eq(Column.of("name", "Ada"))); + soft.assertThat(query.limit()).isEqualTo(10L); + soft.assertThat(query.skip()).isEqualTo(10L); + soft.assertThat(query.sorts()).hasSize(1).contains(Sort.asc("name")); + }); + } + } \ No newline at end of file From 0d27eff9b181c472e5bb93451ec006ce42f85b72 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:18:52 +0000 Subject: [PATCH 10/47] feat: create document parameter based query Signed-off-by: Otavio Santana --- .../query/DocumentParameterBasedQuery.java | 88 +++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java diff --git a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java new file mode 100644 index 000000000..379263bbb --- /dev/null +++ b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2023 Contributors to the Eclipse Foundation + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * and Apache License v2.0 which accompanies this distribution. + * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html + * and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php. + * + * You may elect to redistribute this code under either of these licenses. + * + * Contributors: + * + * Otavio Santana + */ +package org.eclipse.jnosql.mapping.document.query; + +import jakarta.data.page.Pageable; +import jakarta.enterprise.inject.spi.CDI; +import org.eclipse.jnosql.communication.document.DocumentCondition; +import org.eclipse.jnosql.communication.document.DocumentQuery; +import org.eclipse.jnosql.mapping.core.Converters; +import org.eclipse.jnosql.mapping.core.NoSQLPage; +import org.eclipse.jnosql.mapping.document.MappingDocumentQuery; +import org.eclipse.jnosql.mapping.metadata.EntityMetadata; +import org.eclipse.jnosql.mapping.metadata.FieldMetadata; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.IntFunction; + +import static org.eclipse.jnosql.mapping.core.util.ConverterUtil.getValue; + +/** + * The DocumentParameterBasedQuery enum provides a singleton instance for generating Document queries based on + * a set of parameters. It utilizes the provided parameters, pageable information, and entity metadata to construct + * a DocumentQuery object tailored for querying a specific entity's documents. + */ +public enum DocumentParameterBasedQuery { + + + INSTANCE; + private static final IntFunction TO_ARRAY = DocumentCondition[]::new; + + /** + * Constructs a DocumentQuery based on the provided parameters, pageable information, and entity metadata. + * + * @param params The map of parameters used for filtering documents. + * @param pageable The Pageable object containing sorting and pagination information. + * @param entityMetadata Metadata describing the structure of the entity. + * @return A DocumentQuery instance tailored for the specified entity. + */ + public DocumentQuery toQuery(Map params, Pageable pageable, EntityMetadata entityMetadata) { + var convert = CDI.current().select(Converters.class).get(); + List conditions = new ArrayList<>(); + for (Map.Entry entry : params.entrySet()) { + conditions.add(getCondition(convert, entityMetadata, entry)); + } + + var columnCondition = columnCondition(conditions); + var optional = Optional.ofNullable(pageable); + var sorts = optional.map(Pageable::sorts).orElse(Collections.emptyList()); + long limit = optional.map(Pageable::size).orElse(0); + long skip = optional.map(p -> NoSQLPage.skip(pageable)).orElse(0L); + var columnFamily = entityMetadata.name(); + return new MappingDocumentQuery(sorts, limit, skip, columnCondition, columnFamily); + } + + private DocumentCondition columnCondition(List conditions) { + if(conditions.isEmpty()){ + return null; + } + else if(conditions.size() == 1){ + return conditions.get(0); + } + return DocumentCondition.and(conditions.toArray(TO_ARRAY)); + } + + private DocumentCondition getCondition(Converters convert, EntityMetadata entityMetadata, Map.Entry entry) { + var name = entityMetadata.fieldMapping(entry.getKey()) + .map(FieldMetadata::name) + .orElse(entry.getKey()); + var value = getValue(entry.getValue(), entityMetadata, entry.getKey(), convert); + return DocumentCondition.eq(name, value); + } +} From 97c64bc2f88cb0147e4d28350e244b624fabf54e Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:20:36 +0000 Subject: [PATCH 11/47] style: organize imports Signed-off-by: Otavio Santana --- .../mapping/column/query/ColumnParameterBasedQueryTest.java | 1 - .../document/query/DocumentParameterBasedQueryTest.java | 4 ++++ 2 files changed, 4 insertions(+), 1 deletion(-) create mode 100644 jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java diff --git a/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java index 23fc49cc6..8e6d2fe19 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java @@ -42,7 +42,6 @@ import java.util.List; import java.util.Map; -import static org.junit.jupiter.api.Assertions.*; @EnableAutoWeld @AddPackages(value = {Converters.class, ColumnEntityConverter.class}) diff --git a/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java new file mode 100644 index 000000000..bf5dea75e --- /dev/null +++ b/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java @@ -0,0 +1,4 @@ +import static org.junit.jupiter.api.Assertions.*; +class DocumentParameterBasedQueryTest { + +} \ No newline at end of file From 3d48166e1ffdfb12fe0419bcfc9c9154ea2fc065 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:20:51 +0000 Subject: [PATCH 12/47] test: create initial structure of document Signed-off-by: Otavio Santana --- .../DocumentParameterBasedQueryTest.java | 34 ++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java index bf5dea75e..aa73a5f8d 100644 --- a/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java @@ -1,4 +1,36 @@ +/* + * Copyright (c) 2023 Contributors to the Eclipse Foundation + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * and Apache License v2.0 which accompanies this distribution. + * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html + * and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php. + * + * You may elect to redistribute this code under either of these licenses. + * + * Contributors: + * + * Otavio Santana + */ +package org.eclipse.jnosql.mapping.document.query; + +import org.eclipse.jnosql.mapping.core.Converters; +import org.eclipse.jnosql.mapping.core.spi.EntityMetadataExtension; +import org.eclipse.jnosql.mapping.document.DocumentEntityConverter; +import org.eclipse.jnosql.mapping.document.MockProducer; +import org.eclipse.jnosql.mapping.document.spi.DocumentExtension; +import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.jboss.weld.junit5.auto.AddExtensions; +import org.jboss.weld.junit5.auto.AddPackages; +import org.jboss.weld.junit5.auto.EnableAutoWeld; + import static org.junit.jupiter.api.Assertions.*; + +@EnableAutoWeld +@AddPackages(value = {Converters.class, DocumentEntityConverter.class}) +@AddPackages(MockProducer.class) +@AddPackages(Reflections.class) +@AddExtensions({EntityMetadataExtension.class, DocumentExtension.class}) class DocumentParameterBasedQueryTest { - + } \ No newline at end of file From 4782a52ea37866e7c1156ad409813a01153cdc1e Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:23:31 +0000 Subject: [PATCH 13/47] test: create document paramter query based Signed-off-by: Otavio Santana --- .../DocumentParameterBasedQueryTest.java | 92 +++++++++++++++++++ 1 file changed, 92 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java index aa73a5f8d..4f046c6e0 100644 --- a/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java @@ -14,15 +14,33 @@ */ package org.eclipse.jnosql.mapping.document.query; +import jakarta.data.Sort; +import jakarta.data.page.Pageable; +import jakarta.inject.Inject; +import org.assertj.core.api.SoftAssertions; +import org.eclipse.jnosql.communication.Condition; +import org.eclipse.jnosql.communication.TypeReference; +import org.eclipse.jnosql.communication.document.Document; +import org.eclipse.jnosql.communication.document.DocumentCondition; +import org.eclipse.jnosql.communication.document.DocumentQuery; import org.eclipse.jnosql.mapping.core.Converters; import org.eclipse.jnosql.mapping.core.spi.EntityMetadataExtension; import org.eclipse.jnosql.mapping.document.DocumentEntityConverter; import org.eclipse.jnosql.mapping.document.MockProducer; +import org.eclipse.jnosql.mapping.document.entities.Person; import org.eclipse.jnosql.mapping.document.spi.DocumentExtension; +import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; +import org.eclipse.jnosql.mapping.metadata.EntityMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.List; +import java.util.Map; import static org.junit.jupiter.api.Assertions.*; @@ -33,4 +51,78 @@ @AddExtensions({EntityMetadataExtension.class, DocumentExtension.class}) class DocumentParameterBasedQueryTest { + + @Inject + private EntitiesMetadata entitiesMetadata; + + private EntityMetadata metadata; + @BeforeEach + void setUp(){ + this.metadata = entitiesMetadata.get(Person.class); + } + + @Test + void shouldCreateQuerySingleParameter(){ + Map params = Map.of("name", "Ada"); + var query = DocumentParameterBasedQuery.INSTANCE.toQuery(params, null, metadata); + + SoftAssertions.assertSoftly(soft ->{ + soft.assertThat(query.limit()).isEqualTo(0L); + soft.assertThat(query.skip()).isEqualTo(0L); + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.sorts()).isEmpty(); + soft.assertThat(query.condition()).isNotEmpty(); + soft.assertThat(query.condition()).get().isEqualTo(DocumentCondition.eq(Document.of("name", "Ada"))); + }); + } + + @Test + void shouldCreateQueryMultipleParams(){ + Map params = Map.of("name", "Ada", "age", 10); + var query = DocumentParameterBasedQuery.INSTANCE.toQuery(params, null, metadata); + + SoftAssertions.assertSoftly(soft ->{ + soft.assertThat(query.limit()).isEqualTo(0L); + soft.assertThat(query.skip()).isEqualTo(0L); + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.sorts()).isEmpty(); + soft.assertThat(query.condition()).isNotEmpty(); + var condition = query.condition().orElseThrow(); + soft.assertThat(condition.condition()).isEqualTo(Condition.AND); + soft.assertThat(condition.document().get(new TypeReference>() { + })).contains(DocumentCondition.eq(Document.of("name", "Ada")), + DocumentCondition.eq(Document.of("age", 10))); + }); + + } + + @Test + void shouldCreateQueryEmptyParams(){ + Map params = Collections.emptyMap(); + var query = DocumentParameterBasedQuery.INSTANCE.toQuery(params, null, metadata); + + SoftAssertions.assertSoftly(soft ->{ + soft.assertThat(query.limit()).isEqualTo(0L); + soft.assertThat(query.skip()).isEqualTo(0L); + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.sorts()).isEmpty(); + soft.assertThat(query.condition()).isEmpty(); + }); + } + + @Test + void shouldCreateQueryPageable(){ + Map params = Map.of("name", "Ada"); + var pageable = Pageable.ofPage(2).size(10).sortBy(Sort.asc("name")); + var query = DocumentParameterBasedQuery.INSTANCE.toQuery(params, pageable, metadata); + + SoftAssertions.assertSoftly(soft ->{ + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.condition()).isNotEmpty(); + soft.assertThat(query.condition()).get().isEqualTo(DocumentCondition.eq(Document.of("name", "Ada"))); + soft.assertThat(query.limit()).isEqualTo(10L); + soft.assertThat(query.skip()).isEqualTo(10L); + soft.assertThat(query.sorts()).hasSize(1).contains(Sort.asc("name")); + }); + } } \ No newline at end of file From d61ea6dc88887fb7905c36f048206640d1452527 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:30:36 +0000 Subject: [PATCH 14/47] feat: implement repository type using paramter based Signed-off-by: Otavio Santana --- .../eclipse/jnosql/mapping/core/query/RepositoryType.java | 8 ++++++-- .../jnosql/mapping/core/query/RepositoryTypeTest.java | 4 ++-- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/RepositoryType.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/RepositoryType.java index dde6fa731..0d85ff38a 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/RepositoryType.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/RepositoryType.java @@ -61,7 +61,11 @@ public enum RepositoryType { * Exists projection, returning typically a boolean result. It starts with "existsBy" keyword */ EXISTS_BY("existsBy"), - UNKNOWN(""), + + /** + * The last condition is parameter based. That will match the parameter in a simple query. + */ + PARAMETER_BASED(""), /** * Methods from {@link Object} */ @@ -158,7 +162,7 @@ public static RepositoryType of(Method method, Class repositoryType) { } return KEY_WORLD_METHODS.stream() .filter(k -> methodName.startsWith(k.keyword)) - .findFirst().orElse(UNKNOWN); + .findFirst().orElse(PARAMETER_BASED); } private static boolean isCustomRepository(Class type) { diff --git a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/RepositoryTypeTest.java b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/RepositoryTypeTest.java index 02249437c..53adb69cf 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/RepositoryTypeTest.java +++ b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/RepositoryTypeTest.java @@ -115,8 +115,8 @@ void shouldReturnJNoSQLQuery() throws NoSuchMethodException { } @Test - void shouldReturnUnknown() throws NoSuchMethodException { - Assertions.assertEquals(RepositoryType.UNKNOWN, RepositoryType.of(getMethod(DevRepository.class, "nope"), CrudRepository.class)); + void shouldReturnParameterBased() throws NoSuchMethodException { + Assertions.assertEquals(RepositoryType.PARAMETER_BASED, RepositoryType.of(getMethod(DevRepository.class, "nope"), CrudRepository.class)); } @Test From fa54bec5bfcf37b6d2dc1b6f41e38242fc7af4a7 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:33:32 +0000 Subject: [PATCH 15/47] chore: update abstract repository proxy Signed-off-by: Otavio Santana --- .../core/query/AbstractRepositoryProxy.java | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryProxy.java index dd02865c0..a9c9195ce 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryProxy.java @@ -118,6 +118,8 @@ public abstract class AbstractRepositoryProxy implements InvocationHandler */ protected abstract Object executeFindByQuery(Object instance, Method method, Object[] params); + protected abstract Object executeParameterBased(Object instance, Method method, Object[] params); + @Override public Object invoke(Object instance, Method method, Object[] params) throws Throwable { @@ -128,22 +130,22 @@ public Object invoke(Object instance, Method method, Object[] params) throws Thr return unwrapInvocationTargetException(() -> method.invoke(repository(), params)); } case FIND_BY -> { - return executeFindByQuery(instance, method, params); + return unwrapInvocationTargetException(() -> executeFindByQuery(instance, method, params)); } case COUNT_BY -> { - return executeCountByQuery(instance, method, params); + return unwrapInvocationTargetException(() -> executeCountByQuery(instance, method, params)); } case EXISTS_BY -> { - return executeExistByQuery(instance, method, params); + return unwrapInvocationTargetException(() -> executeExistByQuery(instance, method, params)); } case FIND_ALL -> { - return executeFindAll(instance, method, params); + return unwrapInvocationTargetException(() -> executeFindAll(instance, method, params)); } case DELETE_BY -> { - return executeDeleteByAll(instance, method, params); + return unwrapInvocationTargetException(() -> executeDeleteByAll(instance, method, params)); } case OBJECT_METHOD -> { - return unwrapInvocationTargetException(() -> method.invoke(this, params)); + return unwrapInvocationTargetException(() -> unwrapInvocationTargetException(() -> method.invoke(this, params))); } case DEFAULT_METHOD -> { return unwrapInvocationTargetException(() -> InvocationHandler.invokeDefault(instance, method, params)); @@ -151,7 +153,10 @@ public Object invoke(Object instance, Method method, Object[] params) throws Thr case ORDER_BY -> throw new MappingException("Eclipse JNoSQL has not support for method that has OrderBy annotation"); case QUERY -> { - return executeQuery(instance, method, params); + return unwrapInvocationTargetException(() -> executeQuery(instance, method, params)); + } + case PARAMETER_BASED -> { + return unwrapInvocationTargetException(() -> executeParameterBased(instance, method, params)); } case CUSTOM_REPOSITORY -> { Object customRepository = CDI.current().select(method.getDeclaringClass()).get(); From 2a61fa6ac627f2da53d48c67099c4f136409ee30 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:35:01 +0000 Subject: [PATCH 16/47] docs: create documentation to Abstract repository proxy Signed-off-by: Otavio Santana --- .../mapping/core/query/AbstractRepositoryProxy.java | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryProxy.java index a9c9195ce..063662ea9 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryProxy.java @@ -118,6 +118,15 @@ public abstract class AbstractRepositoryProxy implements InvocationHandler */ protected abstract Object executeFindByQuery(Object instance, Method method, Object[] params); + /** + * Executes a custom operation based on the method and parameters, allowing for parameter-based queries. + * This method is meant to handle repository methods that involve custom parameter-based logic. + * + * @param instance The instance on which the method was invoked. + * @param method The method being invoked, representing the custom parameter-based operation. + * @param params The parameters of the method, providing input for the parameter-based operation. + * @return The result of the custom parameter-based operation. + */ protected abstract Object executeParameterBased(Object instance, Method method, Object[] params); @Override From d43fe4bb59a4bfd33764035e5a8663301310fcdf Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:38:38 +0000 Subject: [PATCH 17/47] test: create scenarios to test when this is long Signed-off-by: Otavio Santana --- .../jnosql/mapping/core/query/AnnotationOperationTest.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperationTest.java b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperationTest.java index dca7a2ab6..21d4fc726 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperationTest.java +++ b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperationTest.java @@ -400,6 +400,8 @@ interface PersonRepository extends DataRepository{ int sameInt(Person person); + long sameLong(Person person); + Person[] array(Person[] people); boolean arrayBoolean(Person[] people); @@ -408,6 +410,8 @@ interface PersonRepository extends DataRepository{ int arrayInt(Person[] people); + long arrayLong(Person[] people); + List iterable(List people); void iterableVoid(List people); @@ -415,5 +419,7 @@ interface PersonRepository extends DataRepository{ boolean iterableBoolean(List people); int iterableInt(List people); + + long iterableLong(List people); } } \ No newline at end of file From e4d5446a6c20d12698ebb32ec0feecc78833bf9d Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:41:45 +0000 Subject: [PATCH 18/47] test: create long scenario to all operations Signed-off-by: Otavio Santana --- .../core/query/AnnotationOperationTest.java | 64 ++++++++++++++++++- 1 file changed, 63 insertions(+), 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperationTest.java b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperationTest.java index 21d4fc726..236e01c99 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperationTest.java +++ b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperationTest.java @@ -30,7 +30,6 @@ import static org.eclipse.jnosql.mapping.core.query.AnnotationOperation.INSERT; import static org.eclipse.jnosql.mapping.core.query.AnnotationOperation.SAVE; import static org.eclipse.jnosql.mapping.core.query.AnnotationOperation.UPDATE; -import static org.junit.jupiter.api.Assertions.*; @ExtendWith(MockitoExtension.class) class AnnotationOperationTest { @@ -120,6 +119,16 @@ void shouldUpdateSingleParameterInt() throws Throwable { Assertions.assertThat(invoked).isEqualTo(1); } + @Test + void shouldUpdateSingleParameterLong() throws Throwable { + Method method = PersonRepository.class.getDeclaredMethod("sameLong", Person.class); + Person person = Person.builder().build(); + Mockito.when(repository.update(person)).thenReturn(true); + Object invoked = UPDATE.invoke(new AnnotationOperation.Operation(method, new Object[]{person}, repository)); + Mockito.verify(repository).update(person); + Assertions.assertThat(invoked).isEqualTo(1L); + } + @Test void shouldUpdateIterableParameter() throws Throwable { Method method = PersonRepository.class.getDeclaredMethod("iterable", List.class); @@ -150,6 +159,17 @@ void shouldUpdateIterableParameterInt() throws Throwable { Assertions.assertThat(invoked).isEqualTo(1); } + + @Test + void shouldUpdateIterableParameterLong() throws Throwable { + Method method = PersonRepository.class.getDeclaredMethod("iterableLong", List.class); + Person person = Person.builder().build(); + Mockito.when(repository.updateAll(List.of(person))).thenReturn(1); + Object invoked = UPDATE.invoke(new AnnotationOperation.Operation(method, new Object[]{List.of(person)}, repository)); + Mockito.verify(repository).updateAll(List.of(person)); + Assertions.assertThat(invoked).isEqualTo(1L); + } + @Test void shouldUpdateIterableParameterBoolean() throws Throwable { Method method = PersonRepository.class.getDeclaredMethod("iterableBoolean", List.class); @@ -193,6 +213,19 @@ void shouldUpdateArrayParameterInt() throws Throwable { Assertions.assertThat(invoked).isEqualTo(1); } + + @Test + void shouldUpdateArrayParameterLong() throws Throwable { + Method method = PersonRepository.class.getDeclaredMethod("arrayInt", Person[].class); + Person person = Person.builder().build(); + Mockito.when(repository.updateAll(List.of(person))).thenReturn(1); + Object invoked = UPDATE.invoke(new AnnotationOperation.Operation(method, new Object[]{new Person[]{person}}, + repository)); + Mockito.verify(repository).updateAll(List.of(person)); + Assertions.assertThat(invoked).isEqualTo(1L); + } + + @Test void shouldUpdateArrayParameterVoid() throws Throwable { Method method = PersonRepository.class.getDeclaredMethod("arrayVoid", Person[].class); @@ -240,6 +273,16 @@ void shouldDeleteSingleParameterInt() throws Throwable { Assertions.assertThat(invoked).isEqualTo(1); } + @Test + void shouldDeleteSingleParameterLong() throws Throwable { + Method method = PersonRepository.class.getDeclaredMethod("sameLong", Person.class); + Person person = Person.builder().build(); + Object invoked = DELETE.invoke(new AnnotationOperation.Operation(method, new Object[]{person}, repository)); + Mockito.verify(repository).delete(person); + Assertions.assertThat(invoked).isEqualTo(1L); + } + + @Test void shouldDeleteIterableParameter() throws Throwable { Method method = PersonRepository.class.getDeclaredMethod("iterable", List.class); @@ -267,6 +310,15 @@ void shouldDeleteIterableParameterInt() throws Throwable { Assertions.assertThat(invoked).isEqualTo(1); } + @Test + void shouldDeleteIterableParameterLong() throws Throwable { + Method method = PersonRepository.class.getDeclaredMethod("iterableLong", List.class); + Person person = Person.builder().build(); + Object invoked = DELETE.invoke(new AnnotationOperation.Operation(method, new Object[]{List.of(person)}, repository)); + Mockito.verify(repository).deleteAll(List.of(person)); + Assertions.assertThat(invoked).isEqualTo(1L); + } + @Test void shouldDeleteIterableParameterBoolean() throws Throwable { Method method = PersonRepository.class.getDeclaredMethod("iterableBoolean", List.class); @@ -306,6 +358,16 @@ void shouldDeleteArrayParameterInt() throws Throwable { Assertions.assertThat(invoked).isEqualTo(1); } + @Test + void shouldDeleteArrayParameterLong() throws Throwable { + Method method = PersonRepository.class.getDeclaredMethod("arrayLong", Person[].class); + Person person = Person.builder().build(); + Object invoked = DELETE.invoke(new AnnotationOperation.Operation(method, new Object[]{new Person[]{person}}, + repository)); + Mockito.verify(repository).deleteAll(List.of(person)); + Assertions.assertThat(invoked).isEqualTo(1L); + } + @Test void shouldDeleteArrayParameterVoid() throws Throwable { Method method = PersonRepository.class.getDeclaredMethod("arrayVoid", Person[].class); From 9c44a9451c208b5c0eda6fc0d5a098c6f528344b Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:47:34 +0000 Subject: [PATCH 19/47] feat: add long condition at the return Signed-off-by: Otavio Santana --- .../core/query/AnnotationOperation.java | 33 ++++++++++++++++--- 1 file changed, 29 insertions(+), 4 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperation.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperation.java index e13fd9720..a5240f4cb 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperation.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperation.java @@ -38,13 +38,25 @@ public Object invoke(Operation operation) { ReturnType returnType = new ReturnType(operation.method); if (param instanceof Iterable entities) { Iterable result = operation.repository.insertAll(entities); - return returnType.isVoid() ? Void.TYPE : result; + return returnInsert(returnType, result); } else if (param.getClass().isArray()) { Iterable result = operation.repository.insertAll(Arrays.asList((Object[]) param)); - return returnType.isVoid() ? Void.TYPE : result; + return returnInsert(returnType, result); } else { var result = operation.repository.insert(param); - return returnType.isVoid() ? Void.TYPE : result; + return returnInsert(returnType, result); + } + } + + private static Object returnInsert(ReturnType returnType, Object result) { + if(returnType.isVoid()){ + return Void.TYPE; + }else if(returnType.isInt()){ + return 1; + } else if(returnType.isLong()){ + return 1L; + }else { + return result; } } }, @@ -76,7 +88,9 @@ private static Object executeIterable(Operation operation, Iterable entities, Re return true; } else if (returnType.isInt()) { return count; - } else if (isArray) { + } else if(returnType.isLong()){ + return (long) count; + }else if (isArray) { return param; } else { return entities; @@ -91,6 +105,8 @@ private static Object executeSingleEntity(Operation operation, Object param, Ret return result; } else if (returnType.isInt()) { return 1; + } else if (returnType.isLong()) { + return 1L; } else { return param; } @@ -124,6 +140,8 @@ private static Object executeIterable(Operation operation, Iterable entities, Re return true; } else if (returnType.isInt()) { return (int) StreamSupport.stream(entities.spliterator(), false).count(); + } else if (returnType.isLong()) { + return StreamSupport.stream(entities.spliterator(), false).count(); } return null; } @@ -136,6 +154,8 @@ private static Object executeSingleEntity(Operation operation, Object param, Ret return true; } else if (returnType.isInt()) { return 1; + }else if (returnType.isLong()) { + return 1L; } return null; } @@ -219,5 +239,10 @@ boolean isInt() { return method.getReturnType().equals(Integer.class) || method.getReturnType().equals(Integer.TYPE); } + + public boolean isLong() { + return method.getReturnType().equals(Long.class) + || method.getReturnType().equals(Long.TYPE); + } } } From c1f2451b365f5e7f1ab893fcd6faec444ec36398 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:47:52 +0000 Subject: [PATCH 20/47] test: create query test to long scenario Signed-off-by: Otavio Santana --- .../jnosql/mapping/core/query/AnnotationOperationTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperationTest.java b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperationTest.java index 236e01c99..e52605530 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperationTest.java +++ b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AnnotationOperationTest.java @@ -216,7 +216,7 @@ void shouldUpdateArrayParameterInt() throws Throwable { @Test void shouldUpdateArrayParameterLong() throws Throwable { - Method method = PersonRepository.class.getDeclaredMethod("arrayInt", Person[].class); + Method method = PersonRepository.class.getDeclaredMethod("arrayLong", Person[].class); Person person = Person.builder().build(); Mockito.when(repository.updateAll(List.of(person))).thenReturn(1); Object invoked = UPDATE.invoke(new AnnotationOperation.Operation(method, new Object[]{new Person[]{person}}, From 7a3e216afe78b9fb8846d542fabdad3b5d5b489c Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 18:51:23 +0000 Subject: [PATCH 21/47] feat: include the implementation to keyvalue repository Signed-off-by: Otavio Santana --- .../keyvalue/query/AbstractKeyValueRepositoryProxy.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-key-value/src/main/java/org/eclipse/jnosql/mapping/keyvalue/query/AbstractKeyValueRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-key-value/src/main/java/org/eclipse/jnosql/mapping/keyvalue/query/AbstractKeyValueRepositoryProxy.java index 90dcbc490..16a250a28 100644 --- a/jnosql-mapping/jnosql-mapping-key-value/src/main/java/org/eclipse/jnosql/mapping/keyvalue/query/AbstractKeyValueRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-key-value/src/main/java/org/eclipse/jnosql/mapping/keyvalue/query/AbstractKeyValueRepositoryProxy.java @@ -67,4 +67,9 @@ protected Object executeCountByQuery(Object instance, Method method, Object[] pa protected Object executeFindByQuery(Object instance, Method method, Object[] params) { throw new DynamicQueryException("Key Value repository does not support query method"); } + + @Override + protected Object executeParameterBased(Object instance, Method method, Object[] params) { + throw new DynamicQueryException("Key Value repository does not support query method"); + } } From f3d042d35188367caf7b18dc54c90397f8d75b95 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 19:27:51 +0000 Subject: [PATCH 22/47] test: create test to keyvaleu repository Signed-off-by: Otavio Santana --- .../query/DefaultKeyValueRepositoryTest.java | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 jnosql-mapping/jnosql-mapping-key-value/src/test/java/org/eclipse/jnosql/mapping/keyvalue/query/DefaultKeyValueRepositoryTest.java diff --git a/jnosql-mapping/jnosql-mapping-key-value/src/test/java/org/eclipse/jnosql/mapping/keyvalue/query/DefaultKeyValueRepositoryTest.java b/jnosql-mapping/jnosql-mapping-key-value/src/test/java/org/eclipse/jnosql/mapping/keyvalue/query/DefaultKeyValueRepositoryTest.java new file mode 100644 index 000000000..df1b73d49 --- /dev/null +++ b/jnosql-mapping/jnosql-mapping-key-value/src/test/java/org/eclipse/jnosql/mapping/keyvalue/query/DefaultKeyValueRepositoryTest.java @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2023 Contributors to the Eclipse Foundation + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * and Apache License v2.0 which accompanies this distribution. + * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html + * and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php. + * + * You may elect to redistribute this code under either of these licenses. + * + * Contributors: + * + * Otavio Santana + */ +package org.eclipse.jnosql.mapping.keyvalue.query; + +import jakarta.nosql.keyvalue.KeyValueTemplate; +import org.eclipse.jnosql.mapping.metadata.EntityMetadata; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static org.junit.jupiter.api.Assertions.*; + + +@ExtendWith(MockitoExtension.class) +class DefaultKeyValueRepositoryTest { + + @Mock + private KeyValueTemplate template; + @Mock + private EntityMetadata metadata; + + @Test + void shouldReturnErrorWhenTemplateIsNull() { + assertThrows(NullPointerException.class, () -> DefaultKeyValueRepository.of(template, null)); + assertThrows(NullPointerException.class, () -> DefaultKeyValueRepository.of(null, metadata)); + assertThrows(NullPointerException.class, () -> DefaultKeyValueRepository.of(null, null)); + } + + @Test + void shouldCreateRepository() { + DefaultKeyValueRepository repository = DefaultKeyValueRepository.of(template, metadata); + assertNotNull(repository); + } +} \ No newline at end of file From 0926131b9ac0a6acdfb4fad0fc233d807268d0e6 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 19:38:32 +0000 Subject: [PATCH 23/47] feat: create test at keyvlue repository Signed-off-by: Otavio Santana --- .../AbstractKeyValueRepositoryProxy.java | 13 +++++------ .../query/KeyValueRepositoryProxyTest.java | 23 ++++++++++++++++++- 2 files changed, 28 insertions(+), 8 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-key-value/src/main/java/org/eclipse/jnosql/mapping/keyvalue/query/AbstractKeyValueRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-key-value/src/main/java/org/eclipse/jnosql/mapping/keyvalue/query/AbstractKeyValueRepositoryProxy.java index 16a250a28..4be8fb896 100644 --- a/jnosql-mapping/jnosql-mapping-key-value/src/main/java/org/eclipse/jnosql/mapping/keyvalue/query/AbstractKeyValueRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-key-value/src/main/java/org/eclipse/jnosql/mapping/keyvalue/query/AbstractKeyValueRepositoryProxy.java @@ -15,7 +15,6 @@ package org.eclipse.jnosql.mapping.keyvalue.query; import jakarta.nosql.keyvalue.KeyValueTemplate; -import org.eclipse.jnosql.mapping.DynamicQueryException; import org.eclipse.jnosql.mapping.core.query.AbstractRepositoryProxy; import org.eclipse.jnosql.mapping.core.repository.DynamicQueryMethodReturn; @@ -45,31 +44,31 @@ protected Object executeQuery(Object instance, Method method, Object[] params) { @Override protected Object executeDeleteByAll(Object instance, Method method, Object[] params) { - throw new DynamicQueryException("Key Value repository does not support query method"); + throw new UnsupportedOperationException("Key Value repository does not support query method"); } @Override protected Object executeFindAll(Object instance, Method method, Object[] params) { - throw new DynamicQueryException("Key Value repository does not support query method"); + throw new UnsupportedOperationException("Key Value repository does not support query method"); } @Override protected Object executeExistByQuery(Object instance, Method method, Object[] params) { - throw new DynamicQueryException("Key Value repository does not support query method"); + throw new UnsupportedOperationException("Key Value repository does not support query method"); } @Override protected Object executeCountByQuery(Object instance, Method method, Object[] params) { - throw new DynamicQueryException("Key Value repository does not support query method"); + throw new UnsupportedOperationException("Key Value repository does not support query method"); } @Override protected Object executeFindByQuery(Object instance, Method method, Object[] params) { - throw new DynamicQueryException("Key Value repository does not support query method"); + throw new UnsupportedOperationException("Key Value repository does not support query method"); } @Override protected Object executeParameterBased(Object instance, Method method, Object[] params) { - throw new DynamicQueryException("Key Value repository does not support query method"); + throw new UnsupportedOperationException("Key Value repository does not support query method"); } } diff --git a/jnosql-mapping/jnosql-mapping-key-value/src/test/java/org/eclipse/jnosql/mapping/keyvalue/query/KeyValueRepositoryProxyTest.java b/jnosql-mapping/jnosql-mapping-key-value/src/test/java/org/eclipse/jnosql/mapping/keyvalue/query/KeyValueRepositoryProxyTest.java index 76c43bad5..b6dc8b756 100644 --- a/jnosql-mapping/jnosql-mapping-key-value/src/test/java/org/eclipse/jnosql/mapping/keyvalue/query/KeyValueRepositoryProxyTest.java +++ b/jnosql-mapping/jnosql-mapping-key-value/src/test/java/org/eclipse/jnosql/mapping/keyvalue/query/KeyValueRepositoryProxyTest.java @@ -276,7 +276,7 @@ void shouldUseDefaultMethodFromOtherInterface() { @Test void shouldReturnErrorWhenExecuteMethodQuery() { - Assertions.assertThrows(DynamicQueryException.class, () -> userRepository.findByName("name")); + Assertions.assertThrows(UnsupportedOperationException.class, () -> userRepository.findByName("name")); } @Test @@ -295,6 +295,9 @@ void shouldReturnUnsupportedOperationException() { Assertions.assertThrows(UnsupportedOperationException.class, () -> userRepository.count()); Assertions.assertThrows(UnsupportedOperationException.class, () -> userRepository.findAll(null)); Assertions.assertThrows(UnsupportedOperationException.class, () -> userRepository.deleteAll()); + Assertions.assertThrows(UnsupportedOperationException.class, () -> userRepository.countByName("name")); + Assertions.assertThrows(UnsupportedOperationException.class, () -> userRepository.find("name")); + Assertions.assertThrows(UnsupportedOperationException.class, () -> userRepository.deleteByAge(10)); } @@ -341,6 +344,14 @@ void shouldSaveUsingAnnotation(){ Mockito.verify(template).insert(user); } + @Test + void shouldReturnNotSupported(){ + Assertions.assertThrows(UnsupportedOperationException.class, () -> userRepository.existByName("Ada")); + Assertions.assertThrows(UnsupportedOperationException.class, () -> userRepository.findByAge(10)); + Assertions.assertThrows(UnsupportedOperationException.class, () -> userRepository.find("Ada")); + Assertions.assertThrows(UnsupportedOperationException.class, () -> userRepository.deleteByAge(10)); + } + public interface BaseQuery { @Query("get @key") @@ -378,6 +389,16 @@ default Optional otavio() { @Delete void deleteUser(User user); + + void existByName(String name); + + User findByAge(Integer age); + + User find(String name); + + void deleteByAge(Integer age); + + int countByName(String name); } } \ No newline at end of file From 5b7773c537273f15d1e7ab37655f5cdc0aaef6fc Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 20:33:16 +0000 Subject: [PATCH 24/47] feat: create implemetnation to query paramter Signed-off-by: Otavio Santana --- .../AbstractDocumentRepositoryProxy.java | 28 +++++++++++++++++-- .../query/DocumentParameterBasedQuery.java | 9 ++---- .../DocumentParameterBasedQueryTest.java | 21 ++------------ 3 files changed, 31 insertions(+), 27 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/AbstractDocumentRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/AbstractDocumentRepositoryProxy.java index f6ef0454a..cd4646fdf 100644 --- a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/AbstractDocumentRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/AbstractDocumentRepositoryProxy.java @@ -14,11 +14,19 @@ */ package org.eclipse.jnosql.mapping.document.query; +import jakarta.data.page.Pageable; +import jakarta.data.repository.By; import org.eclipse.jnosql.communication.document.DocumentDeleteQuery; import org.eclipse.jnosql.communication.document.DocumentQuery; import org.eclipse.jnosql.mapping.core.repository.DynamicQueryMethodReturn; +import org.eclipse.jnosql.mapping.core.repository.DynamicReturn; +import org.eclipse.jnosql.mapping.core.repository.SpecialParameters; import java.lang.reflect.Method; +import java.lang.reflect.Parameter; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; import static org.eclipse.jnosql.communication.document.DocumentQuery.select; @@ -53,8 +61,8 @@ protected Object executeDeleteByAll(Object instance, Method method, Object[] par @Override protected Object executeFindAll(Object instance, Method method, Object[] params) { Class typeClass = entityMetadata().type(); - DocumentQuery queryFindAll = select().from(entityMetadata().name()).build(); - return executeFindByQuery(method, params, typeClass, updateQueryDynamically(params, queryFindAll)); + var query = select().from(entityMetadata().name()).build(); + return executeFindByQuery(method, params, typeClass, updateQueryDynamically(params, query)); } @Override @@ -73,5 +81,21 @@ protected Object executeFindByQuery(Object instance, Method method, Object[] par return executeFindByQuery(method, params, type, query(method, params)); } + @Override + protected Object executeParameterBased(Object instance, Method method, Object[] params) { + Class typeClass = entityMetadata().type(); + var parameters = method.getParameters(); + Map paramsValue = new HashMap<>(); + for (int index = 0; index < parameters.length; index++) { + Parameter parameter = parameters[index]; + By annotation = parameter.getAnnotation(By.class); + if(annotation != null) { + paramsValue.put(parameter.getName(), params[index]); + } + } + var query = DocumentParameterBasedQuery.INSTANCE.toQuery(paramsValue, entityMetadata()); + return executeFindByQuery(method, params, typeClass, updateQueryDynamically(params, query)); + } + } diff --git a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java index 379263bbb..e21cacf61 100644 --- a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java @@ -48,11 +48,10 @@ public enum DocumentParameterBasedQuery { * Constructs a DocumentQuery based on the provided parameters, pageable information, and entity metadata. * * @param params The map of parameters used for filtering documents. - * @param pageable The Pageable object containing sorting and pagination information. * @param entityMetadata Metadata describing the structure of the entity. * @return A DocumentQuery instance tailored for the specified entity. */ - public DocumentQuery toQuery(Map params, Pageable pageable, EntityMetadata entityMetadata) { + public DocumentQuery toQuery(Map params, EntityMetadata entityMetadata) { var convert = CDI.current().select(Converters.class).get(); List conditions = new ArrayList<>(); for (Map.Entry entry : params.entrySet()) { @@ -60,12 +59,8 @@ public DocumentQuery toQuery(Map params, Pageable pageable, Enti } var columnCondition = columnCondition(conditions); - var optional = Optional.ofNullable(pageable); - var sorts = optional.map(Pageable::sorts).orElse(Collections.emptyList()); - long limit = optional.map(Pageable::size).orElse(0); - long skip = optional.map(p -> NoSQLPage.skip(pageable)).orElse(0L); var columnFamily = entityMetadata.name(); - return new MappingDocumentQuery(sorts, limit, skip, columnCondition, columnFamily); + return new MappingDocumentQuery(Collections.emptyList(), 0L, 0L, columnCondition, columnFamily); } private DocumentCondition columnCondition(List conditions) { diff --git a/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java index 4f046c6e0..00e1dbcab 100644 --- a/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQueryTest.java @@ -64,7 +64,7 @@ void setUp(){ @Test void shouldCreateQuerySingleParameter(){ Map params = Map.of("name", "Ada"); - var query = DocumentParameterBasedQuery.INSTANCE.toQuery(params, null, metadata); + var query = DocumentParameterBasedQuery.INSTANCE.toQuery(params, metadata); SoftAssertions.assertSoftly(soft ->{ soft.assertThat(query.limit()).isEqualTo(0L); @@ -79,7 +79,7 @@ void shouldCreateQuerySingleParameter(){ @Test void shouldCreateQueryMultipleParams(){ Map params = Map.of("name", "Ada", "age", 10); - var query = DocumentParameterBasedQuery.INSTANCE.toQuery(params, null, metadata); + var query = DocumentParameterBasedQuery.INSTANCE.toQuery(params, metadata); SoftAssertions.assertSoftly(soft ->{ soft.assertThat(query.limit()).isEqualTo(0L); @@ -99,7 +99,7 @@ void shouldCreateQueryMultipleParams(){ @Test void shouldCreateQueryEmptyParams(){ Map params = Collections.emptyMap(); - var query = DocumentParameterBasedQuery.INSTANCE.toQuery(params, null, metadata); + var query = DocumentParameterBasedQuery.INSTANCE.toQuery(params, metadata); SoftAssertions.assertSoftly(soft ->{ soft.assertThat(query.limit()).isEqualTo(0L); @@ -110,19 +110,4 @@ void shouldCreateQueryEmptyParams(){ }); } - @Test - void shouldCreateQueryPageable(){ - Map params = Map.of("name", "Ada"); - var pageable = Pageable.ofPage(2).size(10).sortBy(Sort.asc("name")); - var query = DocumentParameterBasedQuery.INSTANCE.toQuery(params, pageable, metadata); - - SoftAssertions.assertSoftly(soft ->{ - soft.assertThat(query.name()).isEqualTo("Person"); - soft.assertThat(query.condition()).isNotEmpty(); - soft.assertThat(query.condition()).get().isEqualTo(DocumentCondition.eq(Document.of("name", "Ada"))); - soft.assertThat(query.limit()).isEqualTo(10L); - soft.assertThat(query.skip()).isEqualTo(10L); - soft.assertThat(query.sorts()).hasSize(1).contains(Sort.asc("name")); - }); - } } \ No newline at end of file From dce8d5da445cbd7386e8c8c47cce73ea74ce1aac Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 20:34:43 +0000 Subject: [PATCH 25/47] chore: update query empty params Signed-off-by: Otavio Santana --- .../query/ColumnParameterBasedQuery.java | 9 ++------ .../query/ColumnParameterBasedQueryTest.java | 22 +++---------------- 2 files changed, 5 insertions(+), 26 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java index 2416a55de..59af27e0d 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java @@ -48,11 +48,10 @@ public enum ColumnParameterBasedQuery { * Constructs a ColumnQuery based on the provided parameters, pageable information, and entity metadata. * * @param params The map of parameters used for filtering columns. - * @param pageable The Pageable object containing sorting and pagination information. * @param entityMetadata Metadata describing the structure of the entity. * @return A ColumnQuery instance tailored for the specified entity. */ - public ColumnQuery toQuery(Map params, Pageable pageable, EntityMetadata entityMetadata) { + public ColumnQuery toQuery(Map params, EntityMetadata entityMetadata) { var convert = CDI.current().select(Converters.class).get(); List conditions = new ArrayList<>(); for (Map.Entry entry : params.entrySet()) { @@ -60,12 +59,8 @@ public ColumnQuery toQuery(Map params, Pageable pageable, Entity } var columnCondition = columnCondition(conditions); - var optional = Optional.ofNullable(pageable); - var sorts = optional.map(Pageable::sorts).orElse(Collections.emptyList()); - long limit = optional.map(Pageable::size).orElse(0); - long skip = optional.map(p -> NoSQLPage.skip(pageable)).orElse(0L); var columnFamily = entityMetadata.name(); - return new MappingColumnQuery(sorts, limit, skip, columnCondition, columnFamily); + return new MappingColumnQuery(Collections.emptyList(), 0L, 0L, columnCondition, columnFamily); } private ColumnCondition columnCondition(List conditions) { diff --git a/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java index 8e6d2fe19..5f6b11442 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java @@ -62,7 +62,7 @@ void setUp(){ @Test void shouldCreateQuerySingleParameter(){ Map params = Map.of("name", "Ada"); - ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, null, metadata); + ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, metadata); SoftAssertions.assertSoftly(soft ->{ soft.assertThat(query.limit()).isEqualTo(0L); @@ -77,7 +77,7 @@ void shouldCreateQuerySingleParameter(){ @Test void shouldCreateQueryMultipleParams(){ Map params = Map.of("name", "Ada", "age", 10); - ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, null, metadata); + ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, metadata); SoftAssertions.assertSoftly(soft ->{ soft.assertThat(query.limit()).isEqualTo(0L); @@ -97,7 +97,7 @@ void shouldCreateQueryMultipleParams(){ @Test void shouldCreateQueryEmptyParams(){ Map params = Collections.emptyMap(); - ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, null, metadata); + ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, metadata); SoftAssertions.assertSoftly(soft ->{ soft.assertThat(query.limit()).isEqualTo(0L); @@ -108,20 +108,4 @@ void shouldCreateQueryEmptyParams(){ }); } - @Test - void shouldCreateQueryPageable(){ - Map params = Map.of("name", "Ada"); - var pageable = Pageable.ofPage(2).size(10).sortBy(Sort.asc("name")); - ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, pageable, metadata); - - SoftAssertions.assertSoftly(soft ->{ - soft.assertThat(query.name()).isEqualTo("Person"); - soft.assertThat(query.condition()).isNotEmpty(); - soft.assertThat(query.condition()).get().isEqualTo(ColumnCondition.eq(Column.of("name", "Ada"))); - soft.assertThat(query.limit()).isEqualTo(10L); - soft.assertThat(query.skip()).isEqualTo(10L); - soft.assertThat(query.sorts()).hasSize(1).contains(Sort.asc("name")); - }); - } - } \ No newline at end of file From 822d1da2eb70882bf24e3de6b409394e1de15cb8 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 20:39:12 +0000 Subject: [PATCH 26/47] style: remove not used imports Signed-off-by: Otavio Santana --- .../jnosql/mapping/column/query/ColumnParameterBasedQuery.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java index 59af27e0d..37628d08c 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java @@ -14,13 +14,11 @@ */ package org.eclipse.jnosql.mapping.column.query; -import jakarta.data.page.Pageable; import jakarta.enterprise.inject.spi.CDI; import org.eclipse.jnosql.communication.column.ColumnCondition; import org.eclipse.jnosql.communication.column.ColumnQuery; import org.eclipse.jnosql.mapping.column.MappingColumnQuery; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.core.NoSQLPage; import org.eclipse.jnosql.mapping.metadata.EntityMetadata; import org.eclipse.jnosql.mapping.metadata.FieldMetadata; From 244f8a9334578d911af3c4f1aa71bd06bc784cac Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 20:39:23 +0000 Subject: [PATCH 27/47] style: remove not used imports Signed-off-by: Otavio Santana --- .../jnosql/mapping/column/query/ColumnParameterBasedQuery.java | 1 - 1 file changed, 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java index 37628d08c..a3a69a0fa 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java @@ -26,7 +26,6 @@ import java.util.Collections; import java.util.List; import java.util.Map; -import java.util.Optional; import java.util.function.IntFunction; import static org.eclipse.jnosql.mapping.core.util.ConverterUtil.getValue; From 50f9879f93107d66bc87d4d948830a4eb4f65a0b Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 4 Jan 2024 20:50:01 +0000 Subject: [PATCH 28/47] feat: create abstract document repository proxy Signed-off-by: Otavio Santana --- .../query/AbstractDocumentRepositoryProxy.java | 2 +- .../query/DocumentRepositoryProxyTest.java | 17 +++++++++++++++++ 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/AbstractDocumentRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/AbstractDocumentRepositoryProxy.java index cd4646fdf..e7d9eb2e3 100644 --- a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/AbstractDocumentRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/AbstractDocumentRepositoryProxy.java @@ -90,7 +90,7 @@ protected Object executeParameterBased(Object instance, Method method, Object[] Parameter parameter = parameters[index]; By annotation = parameter.getAnnotation(By.class); if(annotation != null) { - paramsValue.put(parameter.getName(), params[index]); + paramsValue.put(annotation.value(), params[index]); } } var query = DocumentParameterBasedQuery.INSTANCE.toQuery(paramsValue, entityMetadata()); diff --git a/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentRepositoryProxyTest.java b/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentRepositoryProxyTest.java index c7c7d9a2f..44de2d7f2 100644 --- a/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentRepositoryProxyTest.java +++ b/jnosql-mapping/jnosql-mapping-document/src/test/java/org/eclipse/jnosql/mapping/document/query/DocumentRepositoryProxyTest.java @@ -14,6 +14,7 @@ */ package org.eclipse.jnosql.mapping.document.query; +import jakarta.data.repository.By; import jakarta.data.repository.PageableRepository; import jakarta.data.repository.Param; import jakarta.data.repository.Query; @@ -711,6 +712,20 @@ void shouldExecuteCustomRepository(){ }); } + @Test + void shouldExecuteMatchParameter(){ + personRepository.find("Ada"); + ArgumentCaptor captor = ArgumentCaptor.forClass(DocumentQuery.class); + verify(template).select(captor.capture()); + DocumentQuery query = captor.getValue(); + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(query.name()).isEqualTo("Person"); + var condition = query.condition().orElseThrow(); + softly.assertThat(condition.condition()).isEqualTo(Condition.EQUALS); + softly.assertThat(condition.document()).isEqualTo(Document.of("name", "Ada")); + }); + } + interface PersonRepository extends PageableRepository, PersonStatisticRepository { @@ -759,6 +774,8 @@ interface PersonRepository extends PageableRepository, PersonStati List findByActiveFalse(); List findByActiveTrue(); + + List find(@By("name") String name); } public interface VendorRepository extends PageableRepository { From ad8266b74f346f38a7f019602b9d327214a36c5f Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 03:54:27 +0000 Subject: [PATCH 29/47] feat: create implementation to column repository Signed-off-by: Otavio Santana --- .../query/AbstractColumnRepositoryProxy.java | 24 +++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/AbstractColumnRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/AbstractColumnRepositoryProxy.java index df17ba594..255fa49a6 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/AbstractColumnRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/AbstractColumnRepositoryProxy.java @@ -14,11 +14,15 @@ */ package org.eclipse.jnosql.mapping.column.query; +import jakarta.data.repository.By; import org.eclipse.jnosql.communication.column.ColumnDeleteQuery; import org.eclipse.jnosql.communication.column.ColumnQuery; import org.eclipse.jnosql.mapping.core.repository.DynamicQueryMethodReturn; import java.lang.reflect.Method; +import java.lang.reflect.Parameter; +import java.util.HashMap; +import java.util.Map; /** * Template method to Repository proxy on column @@ -50,8 +54,8 @@ protected Object executeDeleteByAll(Object instance, Method method, Object[] par @Override protected Object executeFindAll(Object instance, Method method, Object[] params) { Class type = entityMetadata().type(); - ColumnQuery queryFindAll = ColumnQuery.select().from(entityMetadata().name()).build(); - return executeFindByQuery(method, params, type, updateQueryDynamically(params, queryFindAll)); + var query = ColumnQuery.select().from(entityMetadata().name()).build(); + return executeFindByQuery(method, params, type, updateQueryDynamically(params, query)); } @Override @@ -70,4 +74,20 @@ protected Object executeFindByQuery(Object instance, Method method, Object[] par return executeFindByQuery(method, params, type, query(method, params)); } + @Override + protected Object executeParameterBased(Object instance, Method method, Object[] params) { + Class type = entityMetadata().type(); + var parameters = method.getParameters(); + Map paramsValue = new HashMap<>(); + for (int index = 0; index < parameters.length; index++) { + Parameter parameter = parameters[index]; + By annotation = parameter.getAnnotation(By.class); + if(annotation != null) { + paramsValue.put(annotation.value(), params[index]); + } + } + var query = ColumnParameterBasedQuery.INSTANCE.toQuery(paramsValue, entityMetadata()); + return executeFindByQuery(method, params, type, updateQueryDynamically(params, query)); + } + } From 5a03c6540ba589e984037bcbef96a8ab25c267d5 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 03:58:59 +0000 Subject: [PATCH 30/47] test: create column repository Signed-off-by: Otavio Santana --- .../column/query/ColumnRepositoryProxyTest.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnRepositoryProxyTest.java b/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnRepositoryProxyTest.java index 4eee538f9..5e794c7b9 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnRepositoryProxyTest.java +++ b/jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnRepositoryProxyTest.java @@ -15,6 +15,7 @@ package org.eclipse.jnosql.mapping.column.query; import jakarta.data.exceptions.MappingException; +import jakarta.data.repository.By; import jakarta.data.repository.Delete; import jakarta.data.repository.Insert; import jakarta.data.repository.OrderBy; @@ -848,6 +849,20 @@ void shouldSaveUsingAnnotation(){ Mockito.verify(template).insert(person); } + @Test + void shouldExecuteMatchParameter(){ + personRepository.find("Ada"); + ArgumentCaptor captor = ArgumentCaptor.forClass(ColumnQuery.class); + verify(template).select(captor.capture()); + ColumnQuery query = captor.getValue(); + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(query.name()).isEqualTo("Person"); + var condition = query.condition().orElseThrow(); + softly.assertThat(condition.condition()).isEqualTo(Condition.EQUALS); + softly.assertThat(condition.column()).isEqualTo(Column.of("name", "Ada")); + }); + } + public interface BaseQuery { List findByNameLessThan(String name); @@ -941,6 +956,8 @@ default Map> partcionate(String name) { @OrderBy("name") @OrderBy("age") List findByException(); + + List find(@By("name") String name); } public interface VendorRepository extends PageableRepository { From 8cb598b072e3104d9310fac05eb46dba5677accd Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 03:59:45 +0000 Subject: [PATCH 31/47] style: remove extra lines at Abstractgraph repository Signed-off-by: Otavio Santana --- .../mapping/graph/query/AbstractGraphRepositoryProxy.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java index fa848ec46..62ea5ba70 100644 --- a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java @@ -43,8 +43,6 @@ */ abstract class AbstractGraphRepositoryProxy extends AbstractRepositoryProxy { - - protected abstract Graph graph(); protected abstract GraphConverter converter(); From eaeae5e941561fbd37c07f49d9ee451feedbdd03 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 04:14:32 +0000 Subject: [PATCH 32/47] refactor: update graph query method to Signed-off-by: Otavio Santana --- .../query/AbstractGraphRepositoryProxy.java | 16 ++++++++++++++++ .../graph/query/AbstractQueryConvert.java | 2 +- .../mapping/graph/query/CountQueryConverter.java | 4 ++-- .../graph/query/DeleteQueryConverter.java | 4 ++-- .../mapping/graph/query/GraphQueryMethod.java | 8 ++++---- .../graph/query/SelectQueryConverter.java | 4 ++-- 6 files changed, 27 insertions(+), 11 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java index 62ea5ba70..6cb237560 100644 --- a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java @@ -91,6 +91,22 @@ protected Object executeFindByQuery(Object instance, Method method, Object[] par } + @Override + protected Object executeParameterBased(Object instance, Method method, Object[] params) { + Class type = entityMetadata().type(); + Supplier> querySupplier = () -> { + GraphQueryMethod queryMethod = new GraphQueryMethod(entityMetadata(), + graph().traversal().V(), + converters(), method, params); + + return SelectQueryConverter.INSTANCE.apply(queryMethod, params) + .map(converter()::toEntity); + }; + + return converter(method, type, querySupplier, params); + } + + private Object findAll(Method method, Class typeClass, Object[] args) { Supplier> querySupplier = () -> { diff --git a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractQueryConvert.java b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractQueryConvert.java index 0a685ba5a..7b3854626 100644 --- a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractQueryConvert.java +++ b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractQueryConvert.java @@ -84,7 +84,7 @@ protected GraphTraversal getGraphTraversal(GraphQueryMethod grap Supplier> whereSupplier, EntityMetadata mapping) { - GraphTraversal traversal = graphQuery.getTraversal(); + GraphTraversal traversal = graphQuery.traversal(); Optional whereOptional = whereSupplier.get(); whereOptional.ifPresent(w -> { QueryCondition condition = w.condition(); diff --git a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/CountQueryConverter.java b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/CountQueryConverter.java index 8e12818eb..077781664 100644 --- a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/CountQueryConverter.java +++ b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/CountQueryConverter.java @@ -32,8 +32,8 @@ private CountQueryConverter() { @Override public Long apply(GraphQueryMethod graphQuery, Object[] params) { - SelectQuery query = SelectMethodProvider.INSTANCE.apply(graphQuery.getMethod(), graphQuery.getEntityName()); - EntityMetadata mapping = graphQuery.getMapping(); + SelectQuery query = SelectMethodProvider.INSTANCE.apply(graphQuery.method(), graphQuery.entityName()); + EntityMetadata mapping = graphQuery.mapping(); GraphTraversal traversal = getGraphTraversal(graphQuery, query::where, mapping); traversal.hasLabel(mapping.name()); return traversal.count().next(); diff --git a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/DeleteQueryConverter.java b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/DeleteQueryConverter.java index abdadddef..a88e1bc75 100644 --- a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/DeleteQueryConverter.java +++ b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/DeleteQueryConverter.java @@ -33,8 +33,8 @@ private DeleteQueryConverter() { @Override public List apply(GraphQueryMethod graphQuery) { DeleteMethodProvider provider = DeleteMethodProvider.INSTANCE; - DeleteQuery deleteQuery = provider.apply(graphQuery.getMethod(), graphQuery.getEntityName()); - EntityMetadata mapping = graphQuery.getMapping(); + DeleteQuery deleteQuery = provider.apply(graphQuery.method(), graphQuery.entityName()); + EntityMetadata mapping = graphQuery.mapping(); GraphTraversal traversal = getGraphTraversal(graphQuery, deleteQuery::where, mapping); traversal.hasLabel(mapping.name()); return traversal.toList(); diff --git a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/GraphQueryMethod.java b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/GraphQueryMethod.java index 4c0ebe279..a91b96317 100644 --- a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/GraphQueryMethod.java +++ b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/GraphQueryMethod.java @@ -49,19 +49,19 @@ final class GraphQueryMethod { this.method = method; } - public Method getMethod() { + public Method method() { return method; } - public String getEntityName() { + public String entityName() { return mapping.name(); } - public EntityMetadata getMapping() { + public EntityMetadata mapping() { return mapping; } - public GraphTraversal getTraversal() { + public GraphTraversal traversal() { return traversal; } diff --git a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/SelectQueryConverter.java b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/SelectQueryConverter.java index e60a95ba6..eda71490d 100644 --- a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/SelectQueryConverter.java +++ b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/SelectQueryConverter.java @@ -43,8 +43,8 @@ private SelectQueryConverter() { public Stream apply(GraphQueryMethod graphQuery, Object[] params) { SelectMethodProvider selectMethodFactory = SelectMethodProvider.INSTANCE; - SelectQuery query = selectMethodFactory.apply(graphQuery.getMethod(), graphQuery.getEntityName()); - EntityMetadata mapping = graphQuery.getMapping(); + SelectQuery query = selectMethodFactory.apply(graphQuery.method(), graphQuery.entityName()); + EntityMetadata mapping = graphQuery.mapping(); RepositoryObserverParser parser = RepositoryObserverParser.of(mapping); GraphTraversal traversal = getGraphTraversal(graphQuery, query::where, mapping); traversal.hasLabel(mapping.name()); From d45309baabba6e035844404dda2a8ad95cfc29b2 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 04:26:42 +0000 Subject: [PATCH 33/47] test: create test to Abstractrepository Signed-off-by: Otavio Santana --- .../jnosql/mapping/core/query/AbstractRepositoryTest.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryTest.java b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryTest.java index 6cd391c9d..667fa4476 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryTest.java +++ b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryTest.java @@ -26,6 +26,7 @@ import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -145,6 +146,12 @@ void shouldSaveAsUpdate() { Mockito.verify(template).update(person); } + @Test + void shouldReturnException(){ + Assertions.assertThrows(NullPointerException.class, () -> this.repository.findAll()); + Assertions.assertThrows(NullPointerException.class, () -> this.repository.findAll(null)); + } + class PeopleRepository extends AbstractRepository { @Override From 7e7423c7d13c68546569163fa93c335d7124d819 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 04:36:44 +0000 Subject: [PATCH 34/47] feat: create implementation to RepositoryReflectionUtils Signed-off-by: Otavio Santana --- .../repository/RepositoryReflectionUtils.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java index bb9d71b06..c9899b549 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java @@ -16,6 +16,7 @@ +import jakarta.data.repository.By; import jakarta.data.repository.Param; import jakarta.data.repository.Query; @@ -53,6 +54,27 @@ public Map getParams(Method method, Object[] args) { return params; } + /** + * Converts values at arg at a {@link Map} + * + * @param method the method that has the {@link By} info + * @param args the arguments from the method + * @return the {@link Map} from method and its arguments + */ + public Map getBy(Method method, Object[] args) { + Map params = new HashMap<>(); + + Parameter[] parameters = method.getParameters(); + for (int index = 0; index < parameters.length; index++) { + Parameter parameter = parameters[index]; + By by = parameter.getAnnotation(By.class); + if (Objects.nonNull(by)) { + params.put(by.value(), args[index]); + } + } + return params; + } + /** * Returns the query value from the {@link Query} annotation From 890be0543795ac196bfd863443d9b617ef2f2377 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 04:37:02 +0000 Subject: [PATCH 35/47] test: create scenario to By annotation Signed-off-by: Otavio Santana --- .../repository/RepositoryReflectionUtilsTest.java | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java index 5f518264b..584d969e2 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java +++ b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java @@ -14,6 +14,7 @@ */ package org.eclipse.jnosql.mapping.core.repository; +import jakarta.data.repository.By; import jakarta.data.repository.PageableRepository; import jakarta.data.repository.Param; import jakarta.data.repository.Query; @@ -47,9 +48,18 @@ void shouldQuery(){ assertEquals("select * from Person where name = @name", query); } + @Test + void shouldBy(){ + Method method = PersonRepository.class.getDeclaredMethods()[0]; + Map params = RepositoryReflectionUtils.INSTANCE.getBy(method, new Object[]{"Ada"}); + assertThat(params) + .hasSize(1) + .containsEntry("name", "Ada"); + } + interface PersonRepository extends PageableRepository { @Query("select * from Person where name = @name") - List query(@Param("name") String name); + List query(@Param("name") @By("name") String name); } } \ No newline at end of file From 74375b2a2db52d0976262ca5e4d5ee85983aafdc Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 04:39:22 +0000 Subject: [PATCH 36/47] feat: create column repository Signed-off-by: Otavio Santana --- .../query/AbstractColumnRepositoryProxy.java | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/AbstractColumnRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/AbstractColumnRepositoryProxy.java index 255fa49a6..bc32d59fc 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/AbstractColumnRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/AbstractColumnRepositoryProxy.java @@ -14,14 +14,12 @@ */ package org.eclipse.jnosql.mapping.column.query; -import jakarta.data.repository.By; import org.eclipse.jnosql.communication.column.ColumnDeleteQuery; import org.eclipse.jnosql.communication.column.ColumnQuery; import org.eclipse.jnosql.mapping.core.repository.DynamicQueryMethodReturn; +import org.eclipse.jnosql.mapping.core.repository.RepositoryReflectionUtils; import java.lang.reflect.Method; -import java.lang.reflect.Parameter; -import java.util.HashMap; import java.util.Map; /** @@ -77,16 +75,8 @@ protected Object executeFindByQuery(Object instance, Method method, Object[] par @Override protected Object executeParameterBased(Object instance, Method method, Object[] params) { Class type = entityMetadata().type(); - var parameters = method.getParameters(); - Map paramsValue = new HashMap<>(); - for (int index = 0; index < parameters.length; index++) { - Parameter parameter = parameters[index]; - By annotation = parameter.getAnnotation(By.class); - if(annotation != null) { - paramsValue.put(annotation.value(), params[index]); - } - } - var query = ColumnParameterBasedQuery.INSTANCE.toQuery(paramsValue, entityMetadata()); + Map parameters = RepositoryReflectionUtils.INSTANCE.getBy(method, params); + var query = ColumnParameterBasedQuery.INSTANCE.toQuery(parameters, entityMetadata()); return executeFindByQuery(method, params, type, updateQueryDynamically(params, query)); } From 83e600270a0ec2b503993cc3553ea5f4e945d2a9 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 04:39:53 +0000 Subject: [PATCH 37/47] feat: refactoring the abstractdocuent repository using reflection util Signed-off-by: Otavio Santana --- .../AbstractDocumentRepositoryProxy.java | 21 +++---------------- 1 file changed, 3 insertions(+), 18 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/AbstractDocumentRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/AbstractDocumentRepositoryProxy.java index e7d9eb2e3..3991d6b26 100644 --- a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/AbstractDocumentRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/AbstractDocumentRepositoryProxy.java @@ -14,19 +14,12 @@ */ package org.eclipse.jnosql.mapping.document.query; -import jakarta.data.page.Pageable; -import jakarta.data.repository.By; import org.eclipse.jnosql.communication.document.DocumentDeleteQuery; -import org.eclipse.jnosql.communication.document.DocumentQuery; import org.eclipse.jnosql.mapping.core.repository.DynamicQueryMethodReturn; -import org.eclipse.jnosql.mapping.core.repository.DynamicReturn; -import org.eclipse.jnosql.mapping.core.repository.SpecialParameters; +import org.eclipse.jnosql.mapping.core.repository.RepositoryReflectionUtils; import java.lang.reflect.Method; -import java.lang.reflect.Parameter; -import java.util.HashMap; import java.util.Map; -import java.util.Optional; import static org.eclipse.jnosql.communication.document.DocumentQuery.select; @@ -84,16 +77,8 @@ protected Object executeFindByQuery(Object instance, Method method, Object[] par @Override protected Object executeParameterBased(Object instance, Method method, Object[] params) { Class typeClass = entityMetadata().type(); - var parameters = method.getParameters(); - Map paramsValue = new HashMap<>(); - for (int index = 0; index < parameters.length; index++) { - Parameter parameter = parameters[index]; - By annotation = parameter.getAnnotation(By.class); - if(annotation != null) { - paramsValue.put(annotation.value(), params[index]); - } - } - var query = DocumentParameterBasedQuery.INSTANCE.toQuery(paramsValue, entityMetadata()); + Map parameters = RepositoryReflectionUtils.INSTANCE.getBy(method, params); + var query = DocumentParameterBasedQuery.INSTANCE.toQuery(parameters, entityMetadata()); return executeFindByQuery(method, params, typeClass, updateQueryDynamically(params, query)); } From ddce2c4c3673b148d08c02a826516eb10963c85a Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 04:50:56 +0000 Subject: [PATCH 38/47] feat: add method name by convention Signed-off-by: Otavio Santana --- .../mapping/graph/query/GraphQueryMethod.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/GraphQueryMethod.java b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/GraphQueryMethod.java index a91b96317..29b6da313 100644 --- a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/GraphQueryMethod.java +++ b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/GraphQueryMethod.java @@ -37,6 +37,8 @@ final class GraphQueryMethod { private final Object[] args; private final Converters converters; private final Method method; + + private final String methodName; private int counter = 0; GraphQueryMethod(EntityMetadata mapping, @@ -47,6 +49,21 @@ final class GraphQueryMethod { this.args = args; this.converters = converters; this.method = method; + this.methodName = method.getName(); + } + + GraphQueryMethod(EntityMetadata mapping, + GraphTraversal traversal, + Converters converters, + Method method, + String methodName, + Object[] args) { + this.mapping = mapping; + this.traversal = traversal; + this.args = args; + this.converters = converters; + this.method = method; + this.methodName = methodName; } public Method method() { @@ -61,6 +78,10 @@ public EntityMetadata mapping() { return mapping; } + public String methodName() { + return methodName; + } + public GraphTraversal traversal() { return traversal; } From 12e40e73bc527f2a271ea567acbe6ace0c774fe2 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 04:52:11 +0000 Subject: [PATCH 39/47] feat: update select query converter to validate graph by name Signed-off-by: Otavio Santana --- .../mapping/graph/query/SelectQueryConverter.java | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/SelectQueryConverter.java b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/SelectQueryConverter.java index eda71490d..79bf33976 100644 --- a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/SelectQueryConverter.java +++ b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/SelectQueryConverter.java @@ -19,6 +19,7 @@ import org.apache.tinkerpop.gremlin.structure.Vertex; import org.eclipse.jnosql.communication.query.SelectQuery; import org.eclipse.jnosql.communication.query.method.SelectMethodProvider; +import org.eclipse.jnosql.communication.query.method.SelectMethodQueryProvider; import org.eclipse.jnosql.mapping.core.NoSQLPage; import org.eclipse.jnosql.mapping.metadata.EntityMetadata; import org.eclipse.jnosql.mapping.core.repository.DynamicReturn; @@ -42,8 +43,7 @@ private SelectQueryConverter() { @Override public Stream apply(GraphQueryMethod graphQuery, Object[] params) { - SelectMethodProvider selectMethodFactory = SelectMethodProvider.INSTANCE; - SelectQuery query = selectMethodFactory.apply(graphQuery.method(), graphQuery.entityName()); + SelectQuery query = selectQuery(graphQuery); EntityMetadata mapping = graphQuery.mapping(); RepositoryObserverParser parser = RepositoryObserverParser.of(mapping); GraphTraversal traversal = getGraphTraversal(graphQuery, query::where, mapping); @@ -53,6 +53,14 @@ public Stream apply(GraphQueryMethod graphQuery, Object[] params) { return traversal.toStream(); } + private SelectQuery selectQuery(GraphQueryMethod graphQuery) { + if(graphQuery.method() != null) { + return SelectMethodProvider.INSTANCE.apply(graphQuery.method(), graphQuery.entityName()); + } + SelectMethodQueryProvider supplier = new SelectMethodQueryProvider(); + return supplier.apply(graphQuery.methodName(), graphQuery.entityName()); + } + private static Consumer getSort(GraphTraversal traversal, RepositoryObserverParser parser) { return o -> { From 0bfdd59d1d8fd0f2296fb85199129775ff83848e Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 04:53:18 +0000 Subject: [PATCH 40/47] feat: add query condition at graph repository Signed-off-by: Otavio Santana --- .../graph/query/AbstractGraphRepositoryProxy.java | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java index 6cb237560..5e5b66bfc 100644 --- a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java @@ -25,14 +25,17 @@ import org.eclipse.jnosql.mapping.core.query.AbstractRepositoryProxy; import org.eclipse.jnosql.mapping.core.repository.DynamicQueryMethodReturn; import org.eclipse.jnosql.mapping.core.repository.DynamicReturn; +import org.eclipse.jnosql.mapping.core.repository.RepositoryReflectionUtils; import org.eclipse.jnosql.mapping.graph.GraphConverter; import org.eclipse.jnosql.mapping.graph.GraphTemplate; import java.lang.reflect.Method; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.function.Function; import java.util.function.Supplier; +import java.util.stream.Collectors; import java.util.stream.Stream; /** @@ -94,10 +97,14 @@ protected Object executeFindByQuery(Object instance, Method method, Object[] par @Override protected Object executeParameterBased(Object instance, Method method, Object[] params) { Class type = entityMetadata().type(); + Map parameters = RepositoryReflectionUtils.INSTANCE.getBy(method, params); + String methodName = "findBy" + parameters.keySet().stream() + .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1)) + .collect(Collectors.joining("And")); Supplier> querySupplier = () -> { GraphQueryMethod queryMethod = new GraphQueryMethod(entityMetadata(), graph().traversal().V(), - converters(), method, params); + converters(), null, methodName, params); return SelectQueryConverter.INSTANCE.apply(queryMethod, params) .map(converter()::toEntity); From 136a36f08c6b818defe07eb12c223efbaeda8079 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 04:53:36 +0000 Subject: [PATCH 41/47] feat: update at abstracatgraph repository var Signed-off-by: Otavio Santana --- .../mapping/graph/query/AbstractGraphRepositoryProxy.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java index 5e5b66bfc..f4242c120 100644 --- a/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-graph/src/main/java/org/eclipse/jnosql/mapping/graph/query/AbstractGraphRepositoryProxy.java @@ -98,7 +98,7 @@ protected Object executeFindByQuery(Object instance, Method method, Object[] par protected Object executeParameterBased(Object instance, Method method, Object[] params) { Class type = entityMetadata().type(); Map parameters = RepositoryReflectionUtils.INSTANCE.getBy(method, params); - String methodName = "findBy" + parameters.keySet().stream() + var methodName = "findBy" + parameters.keySet().stream() .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1)) .collect(Collectors.joining("And")); Supplier> querySupplier = () -> { From d098157af181b7df3634b70ee60196d972e4db51 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 05:25:48 +0000 Subject: [PATCH 42/47] test: create graph repository proxy Signed-off-by: Otavio Santana --- .../graph/query/GraphRepositoryProxyTest.java | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-graph/src/test/java/org/eclipse/jnosql/mapping/graph/query/GraphRepositoryProxyTest.java b/jnosql-mapping/jnosql-mapping-graph/src/test/java/org/eclipse/jnosql/mapping/graph/query/GraphRepositoryProxyTest.java index ff231b301..1988cb501 100644 --- a/jnosql-mapping/jnosql-mapping-graph/src/test/java/org/eclipse/jnosql/mapping/graph/query/GraphRepositoryProxyTest.java +++ b/jnosql-mapping/jnosql-mapping-graph/src/test/java/org/eclipse/jnosql/mapping/graph/query/GraphRepositoryProxyTest.java @@ -15,6 +15,7 @@ package org.eclipse.jnosql.mapping.graph.query; import jakarta.data.exceptions.MappingException; +import jakarta.data.repository.By; import jakarta.data.repository.Delete; import jakarta.data.repository.Insert; import jakarta.data.repository.OrderBy; @@ -585,6 +586,34 @@ void shouldSaveUsingAnnotation(){ Mockito.verify(template).insert(person); } + @Test + void shouldFind() { + + graph.addVertex(T.label, "Person", "name", "Otavio", "age", 30, "active", false, "score", 2); + graph.addVertex(T.label, "Person", "name", "Poliana", "age", 20, "active", false, "score", 12); + graph.addVertex(T.label, "Person", "name", "Ada", "age", 4, "active", false, "score", 5); + graph.addVertex(T.label, "Person", "name", "Elias", "age", 20, "active", false, "score", 15); + List people = personRepository.find("Otavio"); + assertThat(people).isNotEmpty().hasSize(1) + .map(Person::getName) + .contains("Otavio"); + + } + + @Test + void shouldFind2() { + + graph.addVertex(T.label, "Person", "name", "Otavio", "age", 30, "active", false, "score", 2); + graph.addVertex(T.label, "Person", "name", "Poliana", "age", 20, "active", false, "score", 12); + graph.addVertex(T.label, "Person", "name", "Ada", "age", 4, "active", false, "score", 5); + graph.addVertex(T.label, "Person", "name", "Elias", "age", 20, "active", false, "score", 15); + List people = personRepository.find("Otavio", 30); + assertThat(people).isNotEmpty().hasSize(1) + .map(Person::getName) + .contains("Otavio"); + + } + public interface BaseQuery { List findByScoreLessThan(int value); @@ -646,6 +675,9 @@ public interface PersonRepository extends PageableRepository, Base @OrderBy("age") List findByException(); + List find(@By("name") String name); + List find(@By("name") String name, @By("age") Integer age); + default Map> partcionate(String name) { Objects.requireNonNull(name, "name is required"); Map> map = new HashMap<>(); From cf6807520a045009db63d012f95d60063c65a4f9 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 05:27:09 +0000 Subject: [PATCH 43/47] docs: create match parameter documetantation at changelog Signed-off-by: Otavio Santana --- CHANGELOG.adoc | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc index 24a686a45..b943a16e9 100644 --- a/CHANGELOG.adoc +++ b/CHANGELOG.adoc @@ -15,6 +15,7 @@ and this project adheres to https://semver.org/spec/v2.0.0.html[Semantic Version === Added - Add support to operations annotations (Insert, Update, Delete and Save) from Jakarta Data +- Add support to match parameters == [1.0.4] - 2023-12-19 From a1e97f965a540f1862a3ac1f88243b2f114f1e2a Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 05:36:45 +0000 Subject: [PATCH 44/47] test: create scenario to abstractrepository Signed-off-by: Otavio Santana --- .../jnosql/mapping/core/query/AbstractRepositoryTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryTest.java b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryTest.java index 667fa4476..ca13c39cf 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryTest.java +++ b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryTest.java @@ -148,8 +148,8 @@ void shouldSaveAsUpdate() { @Test void shouldReturnException(){ - Assertions.assertThrows(NullPointerException.class, () -> this.repository.findAll()); - Assertions.assertThrows(NullPointerException.class, () -> this.repository.findAll(null)); + Assertions.assertThrows(UnsupportedOperationException.class, () -> this.repository.findAll()); + Assertions.assertThrows(UnsupportedOperationException.class, () -> this.repository.findAll(null)); } class PeopleRepository extends AbstractRepository { From 7517868598443404780defdaa7d85eae5cb03abd Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 05:41:40 +0000 Subject: [PATCH 45/47] style: optmizes imports at DocumentParameterBasedQuery Signed-off-by: Otavio Santana --- .../mapping/document/query/DocumentParameterBasedQuery.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java index e21cacf61..58d77e5ff 100644 --- a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java @@ -14,12 +14,10 @@ */ package org.eclipse.jnosql.mapping.document.query; -import jakarta.data.page.Pageable; import jakarta.enterprise.inject.spi.CDI; import org.eclipse.jnosql.communication.document.DocumentCondition; import org.eclipse.jnosql.communication.document.DocumentQuery; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.core.NoSQLPage; import org.eclipse.jnosql.mapping.document.MappingDocumentQuery; import org.eclipse.jnosql.mapping.metadata.EntityMetadata; import org.eclipse.jnosql.mapping.metadata.FieldMetadata; @@ -28,7 +26,6 @@ import java.util.Collections; import java.util.List; import java.util.Map; -import java.util.Optional; import java.util.function.IntFunction; import static org.eclipse.jnosql.mapping.core.util.ConverterUtil.getValue; From 5dd5c649c57c9757d654109008554995340553d5 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 05:47:11 +0000 Subject: [PATCH 46/47] style: organize code style Signed-off-by: Otavio Santana --- .../mapping/document/query/DocumentParameterBasedQuery.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java index 58d77e5ff..b2fe7a37d 100644 --- a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java @@ -61,7 +61,7 @@ public DocumentQuery toQuery(Map params, EntityMetadata entityMe } private DocumentCondition columnCondition(List conditions) { - if(conditions.isEmpty()){ + if (conditions.isEmpty()) { return null; } else if(conditions.size() == 1){ From 7e877760029d7f97bc04c315f6c77d8bfec39d3b Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 5 Jan 2024 05:50:31 +0000 Subject: [PATCH 47/47] style: fix style at based query classes Signed-off-by: Otavio Santana --- .../mapping/column/query/ColumnParameterBasedQuery.java | 5 ++--- .../mapping/document/query/DocumentParameterBasedQuery.java | 3 +-- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java index a3a69a0fa..3fae6e8bd 100644 --- a/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java @@ -61,10 +61,9 @@ public ColumnQuery toQuery(Map params, EntityMetadata entityMeta } private ColumnCondition columnCondition(List conditions) { - if(conditions.isEmpty()){ + if (conditions.isEmpty()) { return null; - } - else if(conditions.size() == 1){ + } else if (conditions.size() == 1) { return conditions.get(0); } return ColumnCondition.and(conditions.toArray(TO_ARRAY)); diff --git a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java index b2fe7a37d..6757ca603 100644 --- a/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/query/DocumentParameterBasedQuery.java @@ -63,8 +63,7 @@ public DocumentQuery toQuery(Map params, EntityMetadata entityMe private DocumentCondition columnCondition(List conditions) { if (conditions.isEmpty()) { return null; - } - else if(conditions.size() == 1){ + } else if (conditions.size() == 1) { return conditions.get(0); } return DocumentCondition.and(conditions.toArray(TO_ARRAY));