Example usage for org.apache.ibatis.session RowBounds RowBounds

Introduction

In this page you can find the example usage for org.apache.ibatis.session RowBounds RowBounds.

Prototype

public RowBounds() 

Source Link

Usage

From source file:com.ewcms.common.mybatis.plugin.PaginationQueryPlugin.java

License:Open Source License

@Override
public Object intercept(Invocation invocation) throws Throwable {

    RowBounds rowBounds = (RowBounds) invocation.getArgs()[ROWBOUNDS_ARGS_INDEX];
    if (noPagination(dialect, rowBounds)) {
        return invocation.proceed();
    }//from   w ww.  j a va2s.com

    MappedStatement statement = (MappedStatement) invocation.getArgs()[MAPPED_STATEMENT_ARGS_INDEX];
    Object parameter = invocation.getArgs()[PARAMETER_ARGS_INDEX];
    BoundSql boundSql = statement.getBoundSql(parameter);
    if (StringUtils.isNotBlank(boundSql.getSql())) {
        logger.warn("query boundsql is null");
        return null;
    }

    invocation.getArgs()[MAPPED_STATEMENT_ARGS_INDEX] = newMappedStatement(statement, boundSql, rowBounds);
    invocation.getArgs()[ROWBOUNDS_ARGS_INDEX] = new RowBounds();

    return invocation.proceed();
}

---

From source file:org.sonar.db.DbSessionImplTest.java

License:Open Source License

@Test
public void all_methods_to_wrapped_SqlSession() {
    Random random = new Random();
    boolean randomBoolean = random.nextBoolean();
    int randomInt = random.nextInt(200);
    String randomStatement = randomAlphabetic(10);
    Object randomParameter = new Object();
    Cursor<Object> mockCursor = mock(Cursor.class);
    RowBounds rowBounds = new RowBounds();
    Object randomObject = new Object();
    List<Object> randomList = new ArrayList<>();
    Map<Object, Object> randomMap = new HashMap<>();
    String randomMapKey = randomAlphabetic(10);
    ResultHandler randomResultHandler = resultContext -> {
        // don't care
    };//w w w .ja  v  a  2 s . c  o m
    List<BatchResult> randomBatchResults = new ArrayList<>();
    Configuration randomConfiguration = new Configuration();

    verifyDelegation(DbSessionImpl::commit, s -> verify(s).commit());
    verifyDelegation(t -> t.commit(randomBoolean), s -> verify(s).commit(randomBoolean));

    verifyDelegation(sqlSession -> when(sqlSession.selectCursor(randomStatement)).thenReturn(mockCursor),
            dbSession -> dbSession.selectCursor(randomStatement), sqlSession -> {
                verify(sqlSession).selectCursor(randomStatement);
                return mockCursor;
            });
    verifyDelegation(
            sqlSession -> when(sqlSession.selectCursor(randomStatement, randomParameter))
                    .thenReturn(mockCursor),
            dbSession -> dbSession.selectCursor(randomStatement, randomParameter), sqlSession -> {
                verify(sqlSessionMock).selectCursor(randomStatement, randomParameter);
                return mockCursor;
            });
    verifyDelegation(
            sqlSession -> when(sqlSession.selectCursor(randomStatement, randomParameter, rowBounds))
                    .thenReturn(mockCursor),
            dbSession -> dbSession.selectCursor(randomStatement, randomParameter, rowBounds), sqlSession -> {
                verify(sqlSessionMock).selectCursor(randomStatement, randomParameter, rowBounds);
                return mockCursor;
            });

    verifyDelegation(sqlSession -> when(sqlSession.selectOne(randomStatement)).thenReturn(randomObject),
            dbSession -> dbSession.selectOne(randomStatement), sqlSession -> {
                verify(sqlSession).selectOne(randomStatement);
                return randomObject;
            });
    verifyDelegation(
            sqlSession -> when(sqlSession.selectOne(randomStatement, randomParameter)).thenReturn(randomObject),
            dbSession -> dbSession.selectOne(randomStatement, randomParameter), sqlSession -> {
                verify(sqlSessionMock).selectOne(randomStatement, randomParameter);
                return randomObject;
            });

    verifyDelegation(sqlSession -> when(sqlSession.selectList(randomStatement)).thenReturn(randomList),
            dbSession -> dbSession.selectList(randomStatement), sqlSession -> {
                verify(sqlSession).selectList(randomStatement);
                return randomList;
            });
    verifyDelegation(
            sqlSession -> when(sqlSession.selectList(randomStatement, randomParameter)).thenReturn(randomList),
            dbSession -> dbSession.selectList(randomStatement, randomParameter), sqlSession -> {
                verify(sqlSessionMock).selectList(randomStatement, randomParameter);
                return randomList;
            });
    verifyDelegation(
            sqlSession -> when(sqlSession.selectList(randomStatement, randomParameter, rowBounds))
                    .thenReturn(randomList),
            dbSession -> dbSession.selectList(randomStatement, randomParameter, rowBounds), sqlSession -> {
                verify(sqlSessionMock).selectList(randomStatement, randomParameter, rowBounds);
                return randomList;
            });

    verifyDelegation(
            sqlSession -> when(sqlSession.selectMap(randomStatement, randomMapKey)).thenReturn(randomMap),
            dbSession -> dbSession.selectMap(randomStatement, randomMapKey), sqlSession -> {
                verify(sqlSession).selectMap(randomStatement, randomMapKey);
                return randomMap;
            });
    verifyDelegation(
            sqlSession -> when(sqlSession.selectMap(randomStatement, randomParameter, randomMapKey))
                    .thenReturn(randomMap),
            dbSession -> dbSession.selectMap(randomStatement, randomParameter, randomMapKey), sqlSession -> {
                verify(sqlSessionMock).selectMap(randomStatement, randomParameter, randomMapKey);
                return randomMap;
            });
    verifyDelegation(
            sqlSession -> when(sqlSession.selectMap(randomStatement, randomParameter, randomMapKey, rowBounds))
                    .thenReturn(randomMap),
            dbSession -> dbSession.selectMap(randomStatement, randomParameter, randomMapKey, rowBounds),
            sqlSession -> {
                verify(sqlSessionMock).selectMap(randomStatement, randomParameter, randomMapKey, rowBounds);
                return randomMap;
            });

    verifyDelegation(dbSession -> dbSession.select(randomStatement, randomResultHandler),
            sqlSession -> verify(sqlSessionMock).select(randomStatement, randomResultHandler));
    verifyDelegation(dbSession -> dbSession.select(randomStatement, randomParameter, randomResultHandler),
            sqlSession -> verify(sqlSession).select(randomStatement, randomParameter, randomResultHandler));
    verifyDelegation(
            dbSession -> dbSession.select(randomStatement, randomParameter, rowBounds, randomResultHandler),
            sqlSession -> verify(sqlSessionMock).select(randomStatement, randomParameter, rowBounds,
                    randomResultHandler));

    verifyDelegation(sqlSession -> when(sqlSession.insert(randomStatement)).thenReturn(randomInt),
            dbSession -> dbSession.insert(randomStatement), sqlSession -> {
                verify(sqlSession).insert(randomStatement);
                return randomInt;
            });
    verifyDelegation(
            sqlSession -> when(sqlSession.insert(randomStatement, randomParameter)).thenReturn(randomInt),
            dbSession -> dbSession.insert(randomStatement, randomParameter), sqlSession -> {
                verify(sqlSessionMock).insert(randomStatement, randomParameter);
                return randomInt;
            });

    verifyDelegation(sqlSession -> when(sqlSession.update(randomStatement)).thenReturn(randomInt),
            dbSession -> dbSession.update(randomStatement), sqlSession -> {
                verify(sqlSession).update(randomStatement);
                return randomInt;
            });
    verifyDelegation(
            sqlSession -> when(sqlSession.update(randomStatement, randomParameter)).thenReturn(randomInt),
            dbSession -> dbSession.update(randomStatement, randomParameter), sqlSession -> {
                verify(sqlSessionMock).update(randomStatement, randomParameter);
                return randomInt;
            });

    verifyDelegation(sqlSession -> when(sqlSession.delete(randomStatement)).thenReturn(randomInt),
            dbSession -> dbSession.delete(randomStatement), sqlSession -> {
                verify(sqlSession).delete(randomStatement);
                return randomInt;
            });
    verifyDelegation(
            sqlSession -> when(sqlSession.delete(randomStatement, randomParameter)).thenReturn(randomInt),
            dbSession -> dbSession.delete(randomStatement, randomParameter), sqlSession -> {
                verify(sqlSessionMock).delete(randomStatement, randomParameter);
                return randomInt;
            });

    verifyDelegation(DbSessionImpl::rollback, s -> verify(s).rollback());
    verifyDelegation(t -> t.rollback(randomBoolean), s -> verify(s).rollback(randomBoolean));

    verifyDelegation(sqlSession -> when(sqlSession.flushStatements()).thenReturn(randomBatchResults),
            DbSessionImpl::flushStatements, sqlSession -> {
                verify(sqlSession).flushStatements();
                return randomBatchResults;
            });

    verifyDelegation(DbSessionImpl::close, s -> verify(s).close());

    verifyDelegation(DbSessionImpl::clearCache, s -> verify(s).clearCache());

    verifyDelegation(sqlSession -> when(sqlSession.getConfiguration()).thenReturn(randomConfiguration),
            DbSessionImpl::getConfiguration, sqlSession -> {
                verify(sqlSession).getConfiguration();
                return randomConfiguration;
            });

    verifyDelegation(
            sqlSession -> when(sqlSession.getMapper(DbSessionImplTest.class))
                    .thenReturn(DbSessionImplTest.this),
            dbSession -> dbSession.getMapper(DbSessionImplTest.class), sqlSession -> {
                verify(sqlSession).getMapper(DbSessionImplTest.class);
                return DbSessionImplTest.this;
            });

    verifyDelegation(DbSessionImpl::getConnection, s -> verify(s).getConnection());
}

---

From source file:org.sonar.db.DBSessionsImplTest.java

License:Open Source License

@Test
public void openSession_with_caching_returns_wrapper_of_MyBatis_DbSession_which_delegates_all_methods_but_close() {
    boolean batchOrRegular = random.nextBoolean();

    underTest.enableCaching();// www  .  j a  v a2 s.  co  m

    verifyFirstDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        dbSession.rollback();
        verify(myBatisDbSession).rollback();
    });
    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        boolean flag = random.nextBoolean();
        dbSession.rollback(flag);
        verify(myBatisDbSession).rollback(flag);
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        dbSession.commit();
        verify(myBatisDbSession).commit();
    });
    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        boolean flag = random.nextBoolean();
        dbSession.commit(flag);
        verify(myBatisDbSession).commit(flag);
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        dbSession.selectOne(str);
        verify(myBatisDbSession).selectOne(str);
    });
    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        Object object = new Object();
        dbSession.selectOne(str, object);
        verify(myBatisDbSession).selectOne(str, object);
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        dbSession.selectList(str);
        verify(myBatisDbSession).selectList(str);
    });
    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        Object object = new Object();
        dbSession.selectList(str, object);
        verify(myBatisDbSession).selectList(str, object);
    });
    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        Object parameter = new Object();
        RowBounds rowBounds = new RowBounds();
        dbSession.selectList(str, parameter, rowBounds);
        verify(myBatisDbSession).selectList(str, parameter, rowBounds);
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        String mapKey = randomAlphabetic(10);
        dbSession.selectMap(str, mapKey);
        verify(myBatisDbSession).selectMap(str, mapKey);
    });
    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        Object parameter = new Object();
        String mapKey = randomAlphabetic(10);
        dbSession.selectMap(str, parameter, mapKey);
        verify(myBatisDbSession).selectMap(str, parameter, mapKey);
    });
    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        Object parameter = new Object();
        String mapKey = randomAlphabetic(10);
        RowBounds rowBounds = new RowBounds();
        dbSession.selectMap(str, parameter, mapKey, rowBounds);
        verify(myBatisDbSession).selectMap(str, parameter, mapKey, rowBounds);
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        ResultHandler handler = mock(ResultHandler.class);
        dbSession.select(str, handler);
        verify(myBatisDbSession).select(str, handler);
    });
    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        Object parameter = new Object();
        ResultHandler handler = mock(ResultHandler.class);
        dbSession.select(str, parameter, handler);
        verify(myBatisDbSession).select(str, parameter, handler);
    });
    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        Object parameter = new Object();
        ResultHandler handler = mock(ResultHandler.class);
        RowBounds rowBounds = new RowBounds();
        dbSession.select(str, parameter, rowBounds, handler);
        verify(myBatisDbSession).select(str, parameter, rowBounds, handler);
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        dbSession.insert(str);
        verify(myBatisDbSession).insert(str);
    });
    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        Object object = new Object();
        dbSession.insert(str, object);
        verify(myBatisDbSession).insert(str, object);
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        dbSession.update(str);
        verify(myBatisDbSession).update(str);
    });
    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        Object object = new Object();
        dbSession.update(str, object);
        verify(myBatisDbSession).update(str, object);
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        dbSession.delete(str);
        verify(myBatisDbSession).delete(str);
    });
    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        String str = randomAlphabetic(10);
        Object object = new Object();
        dbSession.delete(str, object);
        verify(myBatisDbSession).delete(str, object);
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        dbSession.flushStatements();
        verify(myBatisDbSession).flushStatements();
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        dbSession.clearCache();
        verify(myBatisDbSession).clearCache();
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        Configuration expected = mock(Configuration.class);
        when(myBatisDbSession.getConfiguration()).thenReturn(expected);
        assertThat(dbSession.getConfiguration()).isSameAs(expected);
        verify(myBatisDbSession).getConfiguration();
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        Class<Object> clazz = Object.class;
        Object expected = new Object();
        when(myBatisDbSession.getMapper(clazz)).thenReturn(expected);
        assertThat(dbSession.getMapper(clazz)).isSameAs(expected);
        verify(myBatisDbSession).getMapper(clazz);
    });

    verifyDelegation(batchOrRegular, (myBatisDbSession, dbSession) -> {
        Connection connection = mock(Connection.class);
        when(myBatisDbSession.getConnection()).thenReturn(connection);
        assertThat(dbSession.getConnection()).isSameAs(connection);
        verify(myBatisDbSession).getConnection();
    });
}

---