@Override public <T extends BaseDto> List<Object[]> queryFieldValues( Class<T> entityClass, String[] queryfields, String wheresql, Object[] queryParams, int startRow, int rows) { String entityname = sqlBuilder.getEntityName(entityClass); Query query = getEntityManager() .createQuery( sqlBuilder.buildSelect(queryfields, "o") + " FROM " + entityname + " o " + (wheresql == null ? "" : "WHERE " + wheresql)); setQueryParams(query, queryParams); if (startRow >= 0) { query.setFirstResult(startRow); } if (rows > 0) { query.setMaxResults(rows); } return query.getResultList(); }
@Test public void shouldResetParameterIndexWhenContinueWithOnOpenStatementGiven() throws SQLException { sqlBuilder.prepareStatement("select 1 from dual"); sqlBuilder.withParameter(true); sqlBuilder.withParameter(false); sqlBuilder.continueWith().prepareStatement("select 2 from dual"); sqlBuilder.withParameter("test"); verify(preparedStatementMock, times(1)).setBoolean(1, true); verify(preparedStatementMock, times(1)).setBoolean(2, false); verify(preparedStatementMock, times(1)).setString(1, "test"); }
public <T extends BaseDto> long getCountByWhere( Class<T> entityClass, String whereql, Object[] queryParams) { StringBuffer sf_QL = new StringBuffer("SELECT COUNT(") .append(sqlBuilder.getPkField(entityClass, "o")) .append(") FROM ") .append(sqlBuilder.getEntityName(entityClass)) .append(" o WHERE 1=1 "); if (whereql != null && whereql.length() != 0) { sf_QL.append(" AND ").append(whereql); } Query query = getEntityManager().createQuery(sf_QL.toString()); this.setQueryParams(query, queryParams); return (Long) query.getSingleResult(); }
@Test public void shouldAddSecondParameterWithIndexTwoWhenTwoIntegerParametersGiven() throws SQLException { sqlBuilder.prepareStatement("query").withParameter(1).withParameter(2); verify(preparedStatementMock, atLeastOnce()).setInt(1, 1); verify(preparedStatementMock, atLeastOnce()).setInt(2, 2); }
@Test public void shouldAddSecondParameterWithIndexTwoWhenTwoStringParametersGiven() throws SQLException { sqlBuilder.prepareStatement("query").withParameter("test").withParameter("second"); verify(preparedStatementMock, atLeastOnce()).setString(1, "test"); verify(preparedStatementMock, atLeastOnce()).setString(2, "second"); }
@Test public void shouldAddSecondParameterWithIndexTwoWhenTwoBooleanParametersGiven() throws SQLException { sqlBuilder.prepareStatement("query").withParameter(false).withParameter(true); verify(preparedStatementMock, atLeastOnce()).setBoolean(1, false); verify(preparedStatementMock, atLeastOnce()).setBoolean(2, true); }
/** * 根据条件查询实体指定字段的值并回填到实体内. <br> * <b>注意:</b> <br> * 实体必须有包括要查询的字段为参数的构造函数. */ private <T extends BaseDto> QueryResult<T> scroll( Class<T> entityClass, String[] queryfields, int firstindex, int maxresult, String wherejpql, Object queryParams, LinkedHashMap<String, String> orderby) { QueryResult<T> qr = new QueryResult<T>(); String entityname = sqlBuilder.getEntityName(entityClass); String where = ""; if (wherejpql != null) { if (wherejpql.length() > 0) { where = "WHERE " + wherejpql; } } Query query = getEntityManager() .createQuery( (sqlBuilder.buildSelect(entityname, queryfields, "o") + "FROM " + entityname + " o " + where + sqlBuilder.buildOrderby(orderby))); setQueryParams(query, queryParams); if (firstindex != -1 && maxresult != -1) query .setFirstResult(firstindex) .setMaxResults(maxresult) .setHint("org.hibernate.cacheable", true); qr.setResultlist(query.getResultList()); query = getEntityManager() .createQuery( "SELECT COUNT(" + sqlBuilder.getPkField(entityClass, "o") + ") FROM " + entityname + " o " + where); setQueryParams(query, queryParams); qr.setTotalrecord((Long) query.getSingleResult()); return qr; }
public <T extends BaseDto> List<T> queryByWhere( Class<T> entityClass, String wheresql, Object[] queryParams) { String entityname = sqlBuilder.getEntityName(entityClass); Query query = getEntityManager() .createQuery( "SELECT o FROM " + entityname + " o " + ((wheresql == null || wheresql.length() == 0) ? "" : "WHERE " + wheresql)); setQueryParams(query, queryParams); query.setHint("org.hibernate.cacheable", true); return query.getResultList(); }
public <T extends BaseDto> void deleteByWhere( Class<T> entityClass, String where, Object[] delParams) { StringBuffer sf_QL = new StringBuffer("DELETE FROM ") .append(sqlBuilder.getEntityName(entityClass)) .append(" o WHERE 1=1 "); if (where != null && where.length() != 0) { sf_QL.append(" AND ").append(where); } Query query = getEntityManager().createQuery(sf_QL.toString()); this.setQueryParams(query, delParams); query.executeUpdate(); }
@Test public void shouldCloseConnectionWhenOpenConnectionGiven() throws SQLException { sqlBuilder.close(); verify(connectionMock, atLeastOnce()).close(); }
@Test(expected = IllegalStateException.class) public void shouldThrowExceptionWhenUpdateWithoutStatementGiven() throws SQLException { sqlBuilder.update(); }
@Test(expected = IllegalStateException.class) public void shouldThrowExceptionWhenClosedSqlBuilderGiven() throws SQLException { SqlBuilder sqlBuilder = new SqlBuilder(dataSourceMock); sqlBuilder.close(); sqlBuilder.prepareStatement("some query"); }
@Test public void shouldAddParameterWhenStringParameterGiven() throws SQLException { sqlBuilder.prepareStatement("query").withParameter("test"); verify(preparedStatementMock, atLeastOnce()).setString(1, "test"); }
@Override public String toString() { return sqlBuilder.toString(); }
@Test(expected = IllegalStateException.class) public void shouldThrowExceptionWhenContinueOnAlreadyClosedBuilderGiven() throws SQLException { sqlBuilder.close(); sqlBuilder.continueWith(); }
void orderBy(CanBeOrdered first, CanBeOrdered... rest) { List<CanBeOrdered> elements = ImmutableList.<CanBeOrdered>builder().add(first).add(rest).build(); sqlBuilder.append(" order by ").on(',').join(elements); }
protected void putMyInner2SqlInto(SqlBuilder sqlB) { sqlB.appendString("AND "); };
@Test(expected = IllegalStateException.class) public void shouldThrowExceptionWhenStringParameterWithoutStatementGiven() throws SQLException { sqlBuilder.withParameter("test"); }
@Test public void shouldCloseStatementWhenContinueWithOnOpenStatementGiven() throws SQLException { sqlBuilder.prepareStatement("select 1 from dual"); sqlBuilder.continueWith(); verify(preparedStatementMock, times(1)).close(); }
@Test(expected = IllegalStateException.class) public void shouldThrowExceptionWhenResultWithoutStatementGiven() throws SQLException { sqlBuilder.resultSet(); }
@Test(expected = IllegalStateException.class) public void shouldThrowExceptionWhenParameterOnClosedBuilderGiven() throws SQLException { sqlBuilder.close(); sqlBuilder.prepareStatement("bla"); }
@Test(expected = IllegalStateException.class) public void shouldThrowExceptionWhenUpdateOnClosedStatementGiven() throws SQLException { sqlBuilder.prepareStatement("select 1 from dual"); sqlBuilder.close(); sqlBuilder.update(); }
protected void putMyInner1SqlInto(SqlBuilder sqlB) { sqlB.appendString("NOT BETWEEN "); };
@Test(expected = JdbcException.class) public void shouldThrowRuntimeExceptionWhenSqlExceptionGiven() throws SQLException { Mockito.doThrow(new SQLException("something bad happened")).when(connectionMock).close(); sqlBuilder.prepareStatement("select 1 from dual"); sqlBuilder.close(); }
void from(CanBeSelectedFrom table1) { sqlBuilder.append(" from ").append(table1); }
@Test public void shouldReturnResultSetWhenUpdateOnOpenStatementGiven() throws SQLException { sqlBuilder.prepareStatement("select 1 from dual"); sqlBuilder.update(); verify(preparedStatementMock, times(1)).executeUpdate(); }
void where(Condition condition) { parameterList.add(condition); sqlBuilder.append(" where ").append(condition); }
@Test public void shouldPrepareStatementWhenSqlQueryGiven() throws SQLException { sqlBuilder.prepareStatement("select 1 from dual"); verify(connectionMock, atLeastOnce()).prepareStatement("select 1 from dual"); }
void buildSelect(CanBeSelected... columns) { List<CanBeSelected> elements = ImmutableList.copyOf(columns); sqlBuilder.append("select ").on(',').join(elements); }
@Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionWhenNoSqlQueryGiven() throws SQLException { sqlBuilder.prepareStatement(null); }