Support some reserved argument types on sql provider method

* Type of Mapper interface
* Method of mapper method
* Configuration of MyBatis

Fixes gh-1013

Author: kazuki43zoo

src/main/java/org/apache/ibatis/builder/annotation/MapperAnnotationBuilder.java

@@ -465,7 +465,7 @@ private SqlSource getSqlSourceFromAnnotations(Method method, Class<?> parameterT
         return buildSqlSourceFromStrings(strings, parameterType, languageDriver);
       } else if (sqlProviderAnnotationType != null) {
         Annotation sqlProviderAnnotation = method.getAnnotation(sqlProviderAnnotationType);
-        return new ProviderSqlSource(assistant.getConfiguration(), sqlProviderAnnotation);
+        return new ProviderSqlSource(assistant.getConfiguration(), sqlProviderAnnotation, type, method);
       }
       return null;
     } catch (Exception e) {

src/main/java/org/apache/ibatis/builder/annotation/ProviderSqlSource.java

@@ -17,6 +17,7 @@
 
 import java.lang.reflect.Method;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Map;
 
 import org.apache.ibatis.builder.BuilderException;
@@ -34,16 +35,26 @@ public class ProviderSqlSource implements SqlSource {
 
   private final SqlSourceBuilder sqlSourceParser;
   private final Class<?> providerType;
+  private final Map<Integer, Object> reservedParameterPositionMapping = new LinkedHashMap<Integer, Object>();
+  private final Object[] providerMethodArgumentsForReservedParameterOnly;
+  private final int userParameterCount;
+  private final Integer firstPositionOfUserParameter;
   private Method providerMethod;
   private String[] providerMethodArgumentNames;
 
-  public ProviderSqlSource(Configuration config, Object provider) {
+  public ProviderSqlSource(Configuration configuration, Object provider) {
+    this(configuration, provider, null, null);
+  }
+
+  /**
+   * @since 3.4.5
+   */
+  public ProviderSqlSource(Configuration configuration, Object provider, Class<?> mapperInterface, Method mapperMethod) {
     String providerMethodName;
     try {
-      this.sqlSourceParser = new SqlSourceBuilder(config);
+      this.sqlSourceParser = new SqlSourceBuilder(configuration);
       this.providerType = (Class<?>) provider.getClass().getMethod("type").invoke(provider);
       providerMethodName = (String) provider.getClass().getMethod("method").invoke(provider);
-
       for (Method m : this.providerType.getMethods()) {
         if (providerMethodName.equals(m.getName())) {
           if (m.getReturnType() == String.class) {
@@ -53,7 +64,7 @@ public ProviderSqlSource(Configuration config, Object provider) {
                       + "'. Sql provider method can not overload.");
             }
             this.providerMethod = m;
-            this.providerMethodArgumentNames = new ParamNameResolver(config, m).getNames();
+            this.providerMethodArgumentNames = new ParamNameResolver(configuration, m).getNames();
           }
         }
       }
@@ -66,6 +77,23 @@ public ProviderSqlSource(Configuration config, Object provider) {
       throw new BuilderException("Error creating SqlSource for SqlProvider. Method '"
           + providerMethodName + "' not found in SqlProvider '" + this.providerType.getName() + "'.");
     }
+    Class<?>[] parameterTypes = providerMethod.getParameterTypes();
+    Integer firstPositionOfUserDefineType = null;
+    for (int i = 0; i< parameterTypes.length; i++) {
+      Class<?> parameterType = parameterTypes[i];
+      if (parameterType == Class.class) {
+        reservedParameterPositionMapping.put(i, mapperInterface);
+      } else if (parameterType == Method.class) {
+        reservedParameterPositionMapping.put(i, mapperMethod);
+      } else if (Configuration.class.isAssignableFrom(parameterType)) {
+        reservedParameterPositionMapping.put(i, configuration);
+      } else if (firstPositionOfUserDefineType == null) {
+        firstPositionOfUserDefineType = i;
+      }
+    }
+    this.providerMethodArgumentsForReservedParameterOnly = reservedParameterPositionMapping.values().toArray();
+    this.userParameterCount = parameterTypes.length - reservedParameterPositionMapping.size();
+    this.firstPositionOfUserParameter = firstPositionOfUserDefineType;
   }
 
   @Override
@@ -80,9 +108,15 @@ private SqlSource createSqlSource(Object parameterObject) {
       String sql;
       if (parameterTypes.length == 0) {
         sql = (String) providerMethod.invoke(providerType.newInstance());
-      } else if (parameterTypes.length == 1 &&
-              (parameterObject == null || parameterTypes[0].isAssignableFrom(parameterObject.getClass()))) {
-        sql = (String) providerMethod.invoke(providerType.newInstance(), parameterObject);
+      } else if (userParameterCount == 0) {
+        sql = (String) providerMethod.invoke(providerType.newInstance(), providerMethodArgumentsForReservedParameterOnly);
+      } else if (userParameterCount == 1 &&
+              (parameterObject == null || parameterTypes[firstPositionOfUserParameter].isAssignableFrom(parameterObject.getClass()))) {
+        if (reservedParameterPositionMapping.isEmpty()) {
+          sql = (String) providerMethod.invoke(providerType.newInstance(), parameterObject);
+        } else {
+          sql = (String) providerMethod.invoke(providerType.newInstance(), extractProviderMethodArguments(parameterObject, parameterTypes.length));
+        }
       } else if (parameterObject instanceof Map) {
         @SuppressWarnings("unchecked")
         Map<String, Object> params = (Map<String, Object>) parameterObject;
@@ -91,7 +125,7 @@ private SqlSource createSqlSource(Object parameterObject) {
         throw new BuilderException("Error invoking SqlProvider method ("
                 + providerType.getName() + "." + providerMethod.getName()
                 + "). Cannot invoke a method that holds "
-                + (parameterTypes.length == 1 ? "named argument(@Param)": "multiple arguments")
+                + (userParameterCount == 1 ? "named argument(@Param)": "multiple arguments")
                 + " using a specifying parameterObject. In this case, please specify a 'java.util.Map' object.");
       }
       Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
@@ -105,10 +139,23 @@ private SqlSource createSqlSource(Object parameterObject) {
     }
   }
 
+  private Object[] extractProviderMethodArguments(Object parameterObject, int length) {
+    Object[] args = new Object[length];
+    args[firstPositionOfUserParameter] = parameterObject;
+    for(Map.Entry<Integer, Object> entry : reservedParameterPositionMapping.entrySet()) {
+      args[entry.getKey()] = entry.getValue();
+    }
+    return args;
+  }
+
   private Object[] extractProviderMethodArguments(Map<String, Object> params, String[] argumentNames) {
     Object[] args = new Object[argumentNames.length];
     for (int i = 0; i < args.length; i++) {
-      args[i] = params.get(argumentNames[i]);
+      if (reservedParameterPositionMapping.containsKey(i)) {
+        args[i] = reservedParameterPositionMapping.get(i);
+      } else {
+        args[i] = params.get(argumentNames[i]);
+      }
     }
     return args;
   }

src/test/java/org/apache/ibatis/submitted/sqlprovider/BaseMapper.java

@@ -0,0 +1,69 @@
+/**
+ *    Copyright 2009-2017 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package org.apache.ibatis.submitted.sqlprovider;
+
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.SelectProvider;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.List;
+
+public interface BaseMapper<T> {
+
+  @SelectProvider(type= OurSqlBuilder.class, method= "buildSelectByIdReservedParamOnly")
+  @ContainsLogicalDelete
+  T selectById(Integer id);
+
+  @SelectProvider(type= OurSqlBuilder.class, method= "buildSelectByIdReservedParamOnly")
+  T selectActiveById(Integer id);
+
+  @SelectProvider(type= OurSqlBuilder.class, method= "buildSelectByNameOneParamAndReservedParam")
+  @ContainsLogicalDelete
+  List<T> selectByName(String name);
+
+  @SelectProvider(type= OurSqlBuilder.class, method= "buildSelectByNameOneParamAndReservedParam")
+  List<T> selectActiveByName(String name);
+
+  @SelectProvider(type= OurSqlBuilder.class, method= "buildSelectByIdAndNameMultipleParamAndReservedParamWithAtParam")
+  @ContainsLogicalDelete
+  List<T> selectByIdAndNameWithAtParam(@Param("id") Integer id, @Param("name") String name);
+
+  @SelectProvider(type= OurSqlBuilder.class, method= "buildSelectByIdAndNameMultipleParamAndReservedParamWithAtParam")
+  List<T> selectActiveByIdAndNameWithAtParam(@Param("id") Integer id, @Param("name") String name);
+
+  @SelectProvider(type= OurSqlBuilder.class, method= "buildSelectByIdAndNameMultipleParamAndReservedParam")
+  @ContainsLogicalDelete
+  List<T> selectByIdAndName(Integer id, String name);
+
+  @SelectProvider(type= OurSqlBuilder.class, method= "buildSelectByIdAndNameMultipleParamAndReservedParam")
+  List<T> selectActiveByIdAndName(Integer id, String name);
+
+  @Retention(RetentionPolicy.RUNTIME)
+  @Target(ElementType.METHOD)
+  @interface ContainsLogicalDelete {
+    boolean value() default false;
+  }
+
+  @Retention(RetentionPolicy.RUNTIME)
+  @Target(ElementType.TYPE)
+  @interface Meta {
+    String tableName();
+  }
+
+}

src/test/java/org/apache/ibatis/submitted/sqlprovider/CreateDB.sql

@@ -1,5 +1,5 @@
 --
---    Copyright 2009-2016 the original author or authors.
+--    Copyright 2009-2017 the original author or authors.
 --
 --    Licensed under the Apache License, Version 2.0 (the "License");
 --    you may not use this file except in compliance with the License.
@@ -18,11 +18,12 @@ drop table users if exists;
 
 create table users (
   id int,
-  name varchar(20)
+  name varchar(20),
+  logical_delete boolean default false
 );
 
 insert into users (id, name) values(1, 'User1');
 insert into users (id, name) values(2, 'User2');
 insert into users (id, name) values(3, 'User3');
-insert into users (id, name) values(4, 'User4');
+insert into users (id, name, logical_delete) values(4, 'User4', true);
 

src/test/java/org/apache/ibatis/submitted/sqlprovider/Mapper.java

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2009-2016 the original author or authors.
+ *    Copyright 2009-2017 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -24,7 +24,8 @@
 import org.apache.ibatis.annotations.SelectProvider;
 import org.apache.ibatis.annotations.UpdateProvider;
 
-public interface Mapper {
+@BaseMapper.Meta(tableName = "users")
+public interface Mapper extends BaseMapper<User> {
   @SelectProvider(type = OurSqlBuilder.class, method = "buildGetUsersQuery")
   List<User> getUsers(List<Integer> allFilterIds);
 

src/test/java/org/apache/ibatis/submitted/sqlprovider/OurSqlBuilder.java

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2009-2016 the original author or authors.
+ *    Copyright 2009-2017 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -17,7 +17,9 @@
 
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.jdbc.SQL;
+import org.apache.ibatis.session.Configuration;
 
+import java.lang.reflect.Method;
 import java.util.List;
 import java.util.Map;
 
@@ -148,4 +150,68 @@ public String buildDelete() {
     return "delete from users where id = #{id}";
   }
 
+  public String buildSelectByIdReservedParamOnly(Method mapperMethod, Class<?> mapperInterface, final Configuration configuration) {
+    final boolean containsLogicalDelete = mapperMethod.getAnnotation(BaseMapper.ContainsLogicalDelete.class) != null;
+    final String tableName = mapperInterface.getAnnotation(BaseMapper.Meta.class).tableName();
+    return new SQL(){{
+      SELECT("*");
+      FROM(tableName);
+      WHERE("id = #{id}");
+      if (!containsLogicalDelete){
+        WHERE("logical_delete = " + configuration.getVariables().getProperty("boolean_value_false"));
+      }
+    }}.toString();
+  }
+
+  public String buildSelectByNameOneParamAndReservedParam(final Configuration configuration, Class<?> mapperInterface, Method mapperMethod, final String name) {
+    final boolean containsLogicalDelete = mapperMethod.getAnnotation(BaseMapper.ContainsLogicalDelete.class) != null;
+    final String tableName = mapperInterface.getAnnotation(BaseMapper.Meta.class).tableName();
+    return new SQL(){{
+      SELECT("*");
+      FROM(tableName);
+      if (name != null) {
+        WHERE("name like #{name} || '%'");
+      }
+      if (!containsLogicalDelete){
+        WHERE("logical_delete = " + configuration.getVariables().getProperty("boolean_value_false"));
+      }
+    }}.toString();
+  }
+
+  public String buildSelectByIdAndNameMultipleParamAndReservedParamWithAtParam(@Param("id") final Integer id, final Configuration configuration, Class<?> mapperInterface, Method mapperMethod, @Param("name") final String name) {
+    final boolean containsLogicalDelete = mapperMethod.getAnnotation(BaseMapper.ContainsLogicalDelete.class) != null;
+    final String tableName = mapperInterface.getAnnotation(BaseMapper.Meta.class).tableName();
+    return new SQL(){{
+      SELECT("*");
+      FROM(tableName);
+      if (id != null) {
+        WHERE("id = #{id}");
+      }
+      if (name != null) {
+        WHERE("name like #{name} || '%'");
+      }
+      if (!containsLogicalDelete){
+        WHERE("logical_delete = " + configuration.getVariables().getProperty("boolean_value_false"));
+      }
+    }}.toString();
+  }
+
+  public String buildSelectByIdAndNameMultipleParamAndReservedParam(final Integer id, final String name, final Configuration configuration, Class<?> mapperInterface, Method mapperMethod) {
+    final boolean containsLogicalDelete = mapperMethod.getAnnotation(BaseMapper.ContainsLogicalDelete.class) != null;
+    final String tableName = mapperInterface.getAnnotation(BaseMapper.Meta.class).tableName();
+    return new SQL(){{
+      SELECT("*");
+      FROM(tableName);
+      if (id != null) {
+        WHERE("id = #{param1}");
+      }
+      if (name != null) {
+        WHERE("name like #{param2} || '%'");
+      }
+      if (!containsLogicalDelete){
+        WHERE("logical_delete = " + configuration.getVariables().getProperty("boolean_value_false"));
+      }
+    }}.toString();
+  }
+
 }

src/test/java/org/apache/ibatis/submitted/sqlprovider/SqlProviderTest.java

@@ -399,6 +399,54 @@ public void shouldDeleteUser() {
     }
   }
 
+  @Test
+  public void mapperReservedParamOnly() {
+    SqlSession sqlSession = sqlSessionFactory.openSession();
+    try {
+      Mapper mapper = sqlSession.getMapper(Mapper.class);
+      assertEquals("User4", mapper.selectById(4).getName());
+      assertNull(mapper.selectActiveById(4));
+    } finally {
+      sqlSession.close();
+    }
+  }
+
+  @Test
+  public void mapperOneParamAndReservedParam() {
+    SqlSession sqlSession = sqlSessionFactory.openSession();
+    try {
+      Mapper mapper = sqlSession.getMapper(Mapper.class);
+      assertEquals(1, mapper.selectByName("User4").size());
+      assertEquals(0, mapper.selectActiveByName("User4").size());
+    } finally {
+      sqlSession.close();
+    }
+  }
+
+  @Test
+  public void mapperMultipleParamAndReservedParamWithAtParam() {
+    SqlSession sqlSession = sqlSessionFactory.openSession();
+    try {
+      Mapper mapper = sqlSession.getMapper(Mapper.class);
+      assertEquals(1, mapper.selectByIdAndNameWithAtParam(4,"User4").size());
+      assertEquals(0, mapper.selectActiveByIdAndNameWithAtParam(4,"User4").size());
+    } finally {
+      sqlSession.close();
+    }
+  }
+
+  @Test
+  public void mapperMultipleParamAndReservedParam() {
+    SqlSession sqlSession = sqlSessionFactory.openSession();
+    try {
+      Mapper mapper = sqlSession.getMapper(Mapper.class);
+      assertEquals(1, mapper.selectByIdAndName(4,"User4").size());
+      assertEquals(0, mapper.selectActiveByIdAndName(4,"User4").size());
+    } finally {
+      sqlSession.close();
+    }
+  }
+
   public interface ErrorMapper {
     @SelectProvider(type = ErrorSqlBuilder.class, method = "methodNotFound")
     void methodNotFound();