Update Query supporting param match

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
 

jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/AbstractColumnRepositoryProxy.java

@@ -17,8 +17,10 @@
 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.util.Map;
 
 /**
  * Template method to Repository proxy on column
@@ -50,8 +52,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 +72,12 @@ 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();
+        Map<String, Object> parameters = RepositoryReflectionUtils.INSTANCE.getBy(method, params);
+        var query = ColumnParameterBasedQuery.INSTANCE.toQuery(parameters, entityMetadata());
+        return executeFindByQuery(method, params, type, updateQueryDynamically(params, query));
+    }
+
 }

jnosql-mapping/jnosql-mapping-column/src/main/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQuery.java

@@ -0,0 +1,79 @@
+/*
+ *  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.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.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.function.IntFunction;
+
+import static org.eclipse.jnosql.mapping.core.util.ConverterUtil.getValue;
+
+/**
+ * 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 enum ColumnParameterBasedQuery {
+
+
+    INSTANCE;
+    private static final IntFunction<ColumnCondition[]> TO_ARRAY = ColumnCondition[]::new;
+
+    /**
+     * Constructs a ColumnQuery based on the provided parameters, pageable information, and entity metadata.
+     *
+     * @param params          The map of parameters used for filtering columns.
+     * @param entityMetadata  Metadata describing the structure of the entity.
+     * @return                 A ColumnQuery instance tailored for the specified entity.
+     */
+    public ColumnQuery toQuery(Map<String, Object> params, EntityMetadata entityMetadata) {
+        var convert = CDI.current().select(Converters.class).get();
+        List<ColumnCondition> conditions = new ArrayList<>();
+        for (Map.Entry<String, Object> entry : params.entrySet()) {
+            conditions.add(getCondition(convert, entityMetadata, entry));
+        }
+
+        var columnCondition = columnCondition(conditions);
+        var columnFamily = entityMetadata.name();
+        return new MappingColumnQuery(Collections.emptyList(), 0L, 0L, columnCondition, columnFamily);
+    }
+
+    private ColumnCondition columnCondition(List<ColumnCondition> 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<String, Object> 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);
+    }
+}

jnosql-mapping/jnosql-mapping-column/src/test/java/org/eclipse/jnosql/mapping/column/query/ColumnParameterBasedQueryTest.java

@@ -0,0 +1,111 @@
+/*
+ *  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.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;
+
+
+@EnableAutoWeld
+@AddPackages(value = {Converters.class, ColumnEntityConverter.class})
+@AddPackages(MockProducer.class)
+@AddPackages(Reflections.class)
+@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<String, Object> params = Map.of("name", "Ada");
+        ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, 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<String, Object> params = Map.of("name", "Ada", "age", 10);
+        ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, 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<List<ColumnCondition>>() {
+            })).contains(ColumnCondition.eq(Column.of("name", "Ada")),
+                    ColumnCondition.eq(Column.of("age", 10)));
+        });
+
+    }
+
+    @Test
+    void shouldCreateQueryEmptyParams(){
+        Map<String, Object> params = Collections.emptyMap();
+        ColumnQuery query = ColumnParameterBasedQuery.INSTANCE.toQuery(params, 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();
+        });
+    }
+
+}

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<ColumnQuery> 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<T> {
 
         List<T> findByNameLessThan(String name);
@@ -941,6 +956,8 @@ default Map<Boolean, List<Person>> partcionate(String name) {
         @OrderBy("name")
         @OrderBy("age")
         List<Person> findByException();
+
+        List<Person> find(@By("name") String name);
     }
 
     public interface VendorRepository extends PageableRepository<Vendor, String> {

jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryProxy.java

@@ -118,6 +118,17 @@ public abstract class AbstractRepositoryProxy<T, K> 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
     public Object invoke(Object instance, Method method, Object[] params) throws Throwable {
 
@@ -128,30 +139,33 @@ 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));
             }
             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();