Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
MidaoLogger extends Logger { public static MidaoLogger getLogger(String name) { MidaoLogger mjdbcLogger = new MidaoLogger(name, null); if (isSLF4jAvailable() == true) { try { mjdbcLogger = new MidaoLogger(name, null); mjdbcLogger.setSlfLogger(MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "getLogger", new Class[]{String.class}, new Object[]{name})); } catch (MjdbcException e) { setSLF4jAvailable(false); } catch (ClassNotFoundException e) { setSLF4jAvailable(false); } } return mjdbcLogger; } private MidaoLogger(String name, String resourceBundleName); static MidaoLogger getLogger(String name); static MidaoLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); }
@Test public void testGetLoggerString() throws Exception { MidaoLogger logger = MidaoLogger.getLogger("log me!"); Assert.assertEquals(true, logger instanceof Logger); Assert.assertEquals("log me!", logger.getName()); } @Test public void testGetLoggerClass() throws Exception { MidaoLogger logger = MidaoLogger.getLogger(String.class); Assert.assertEquals(true, logger instanceof Logger); Assert.assertEquals("java.lang.String", logger.getName()); }
TypeHandlerUtils { public static Object convertClob(Connection conn, byte[] value) throws SQLException { Object result = (Object) createClob(conn); result = convertClob(result, value); return result; } static Object convertArray(Connection conn, Object[] array); static Object convertArray(Connection conn, Collection<?> array); static Object convertBlob(Connection conn, byte[] value); static Object convertBlob(Connection conn, InputStream input); static Object convertBlob(Connection conn, String value); static Object convertBlob(Object blob, byte[] value); static Object convertBlob(Object blob, InputStream input); static Object convertBlob(Object blob, String value); static Object convertClob(Connection conn, byte[] value); static Object convertClob(Connection conn, String value); static Object convertClob(Connection conn, InputStream input); static Object convertClob(Object clob, byte[] value); static Object convertClob(Object clob, String value); static Object convertClob(Object clob, InputStream input); static String convertJavaClassToSqlType(String simpleClassName); static Object convertSqlXml(Connection conn, byte[] value); static Object convertSqlXml(Connection conn, String value); static Object convertSqlXml(Connection conn, InputStream input); static Object convertSqlXml(Object sqlXml, byte[] value); static Object convertSqlXml(Object sqlXml, String value); static Object convertSqlXml(Object sqlXml, InputStream input); static byte[] readBlob(Object blob, boolean close); static byte[] readBlob(Object blob); static byte[] readClob(Object clob, boolean close); static byte[] readClob(Object clob); static byte[] readSqlXml(Object sqlXml, boolean close); static byte[] readSqlXml(Object sqlXml); static byte[] toByteArray(InputStream input); static String toString(Reader reader); static void closeQuietly(InputStream input); static void closeQuietly(OutputStream output); static long copy(InputStream input, OutputStream output); static long copy(Reader input, StringBuilder output); static Object createBlob(Connection conn); static Object createClob(Connection conn); static Object createSQLXML(Connection conn); static Object createArrayOf(Connection conn, String typeName, Object[] elements); static boolean isJDBC3(Overrider overrider); }
@Test public void testConvertClobConnByte() throws Exception { testConvertClobPrepare(); TypeHandlerUtils.convertClob(conn, "GIF".getBytes()); MappingUtils.invokeFunction(verify(conn, times(1)), "createClob", new Class[]{}, new Object[]{}); testConvertClobCheck(); } @Test public void testConvertClobConnInputStream() throws Exception { testConvertClobPrepare(); TypeHandlerUtils.convertClob(conn, new ByteArrayInputStream("BMP".getBytes())); MappingUtils.invokeFunction(verify(conn, times(1)), "createClob", new Class[]{}, new Object[]{}); testConvertClobCheck(); } @Test public void testConvertClobConnString() throws Exception { testConvertClobPrepare(); TypeHandlerUtils.convertClob(conn, "PCX"); MappingUtils.invokeFunction(verify(conn, times(1)), "createClob", new Class[]{}, new Object[]{}); testConvertClobCheck(); } @Test public void testConvertClobByte() throws Exception { testConvertClobPrepare(); TypeHandlerUtils.convertClob(clob, "JPEG".getBytes()); testConvertClobCheck(); } @Test public void testConvertClobInputStream() throws Exception { testConvertClobPrepare(); TypeHandlerUtils.convertClob(clob, new ByteArrayInputStream("PNG".getBytes())); testConvertClobCheck(); } @Test public void testConvertClobString() throws Exception { testConvertClobPrepare(); TypeHandlerUtils.convertClob(clob, "TIFF"); testConvertClobCheck(); }
TypeHandlerUtils { public static Object convertSqlXml(Connection conn, byte[] value) throws SQLException { Object result = createSQLXML(conn); result = convertSqlXml(result, value); return result; } static Object convertArray(Connection conn, Object[] array); static Object convertArray(Connection conn, Collection<?> array); static Object convertBlob(Connection conn, byte[] value); static Object convertBlob(Connection conn, InputStream input); static Object convertBlob(Connection conn, String value); static Object convertBlob(Object blob, byte[] value); static Object convertBlob(Object blob, InputStream input); static Object convertBlob(Object blob, String value); static Object convertClob(Connection conn, byte[] value); static Object convertClob(Connection conn, String value); static Object convertClob(Connection conn, InputStream input); static Object convertClob(Object clob, byte[] value); static Object convertClob(Object clob, String value); static Object convertClob(Object clob, InputStream input); static String convertJavaClassToSqlType(String simpleClassName); static Object convertSqlXml(Connection conn, byte[] value); static Object convertSqlXml(Connection conn, String value); static Object convertSqlXml(Connection conn, InputStream input); static Object convertSqlXml(Object sqlXml, byte[] value); static Object convertSqlXml(Object sqlXml, String value); static Object convertSqlXml(Object sqlXml, InputStream input); static byte[] readBlob(Object blob, boolean close); static byte[] readBlob(Object blob); static byte[] readClob(Object clob, boolean close); static byte[] readClob(Object clob); static byte[] readSqlXml(Object sqlXml, boolean close); static byte[] readSqlXml(Object sqlXml); static byte[] toByteArray(InputStream input); static String toString(Reader reader); static void closeQuietly(InputStream input); static void closeQuietly(OutputStream output); static long copy(InputStream input, OutputStream output); static long copy(Reader input, StringBuilder output); static Object createBlob(Connection conn); static Object createClob(Connection conn); static Object createSQLXML(Connection conn); static Object createArrayOf(Connection conn, String typeName, Object[] elements); static boolean isJDBC3(Overrider overrider); }
@Test public void testConvertSqlXmlConnByte() throws Exception { testConvertSqlXmlPrepare(); TypeHandlerUtils.convertSqlXml(conn, "GIF".getBytes()); MappingUtils.invokeFunction(verify(conn, times(1)), "createSQLXML", new Class[]{}, new Object[]{}); testConvertSqlXmlCheck(); } @Test public void testConvertSqlXmlConnInputStream() throws Exception { testConvertSqlXmlPrepare(); TypeHandlerUtils.convertSqlXml(conn, new ByteArrayInputStream("BMP".getBytes())); MappingUtils.invokeFunction(verify(conn, times(1)), "createSQLXML", new Class[]{}, new Object[]{}); testConvertSqlXmlCheck(); } @Test public void testConvertSqlXmlConnString() throws Exception { testConvertSqlXmlPrepare(); TypeHandlerUtils.convertSqlXml(conn, "PCX"); MappingUtils.invokeFunction(verify(conn, times(1)), "createSQLXML", new Class[]{}, new Object[]{}); testConvertSqlXmlCheck(); } @Test public void testConvertSqlXmlByte() throws Exception { testConvertSqlXmlPrepare(); TypeHandlerUtils.convertSqlXml(sqlXml, "JPEG".getBytes()); testConvertSqlXmlCheck(); } @Test public void testConvertSqlXmlInputStream() throws Exception { testConvertSqlXmlPrepare(); TypeHandlerUtils.convertSqlXml(sqlXml, new ByteArrayInputStream("PNG".getBytes())); testConvertSqlXmlCheck(); } @Test public void testConvertSqlXmlString() throws Exception { testConvertSqlXmlPrepare(); TypeHandlerUtils.convertSqlXml(sqlXml, "TIFF"); testConvertSqlXmlCheck(); }
TypeHandlerUtils { public static String convertJavaClassToSqlType(String simpleClassName) throws SQLException { if ("String".equals(simpleClassName) == true) { return "VARCHAR"; } throw new SQLException(String.format("Could not convert java class %s", simpleClassName)); } static Object convertArray(Connection conn, Object[] array); static Object convertArray(Connection conn, Collection<?> array); static Object convertBlob(Connection conn, byte[] value); static Object convertBlob(Connection conn, InputStream input); static Object convertBlob(Connection conn, String value); static Object convertBlob(Object blob, byte[] value); static Object convertBlob(Object blob, InputStream input); static Object convertBlob(Object blob, String value); static Object convertClob(Connection conn, byte[] value); static Object convertClob(Connection conn, String value); static Object convertClob(Connection conn, InputStream input); static Object convertClob(Object clob, byte[] value); static Object convertClob(Object clob, String value); static Object convertClob(Object clob, InputStream input); static String convertJavaClassToSqlType(String simpleClassName); static Object convertSqlXml(Connection conn, byte[] value); static Object convertSqlXml(Connection conn, String value); static Object convertSqlXml(Connection conn, InputStream input); static Object convertSqlXml(Object sqlXml, byte[] value); static Object convertSqlXml(Object sqlXml, String value); static Object convertSqlXml(Object sqlXml, InputStream input); static byte[] readBlob(Object blob, boolean close); static byte[] readBlob(Object blob); static byte[] readClob(Object clob, boolean close); static byte[] readClob(Object clob); static byte[] readSqlXml(Object sqlXml, boolean close); static byte[] readSqlXml(Object sqlXml); static byte[] toByteArray(InputStream input); static String toString(Reader reader); static void closeQuietly(InputStream input); static void closeQuietly(OutputStream output); static long copy(InputStream input, OutputStream output); static long copy(Reader input, StringBuilder output); static Object createBlob(Connection conn); static Object createClob(Connection conn); static Object createSQLXML(Connection conn); static Object createArrayOf(Connection conn, String typeName, Object[] elements); static boolean isJDBC3(Overrider overrider); }
@Test public void testConvertJavaClassToSqlType() throws Exception { Assert.assertEquals("VARCHAR", TypeHandlerUtils.convertJavaClassToSqlType("String")); }
TypeHandlerUtils { public static byte[] readBlob(Object blob, boolean close) throws SQLException { byte[] result = null; InputStream input = null; try { input = (InputStream) MappingUtils.invokeFunction(blob, "getBinaryStream", new Class[]{}, new Object[]{}); } catch (MjdbcException ex) { throw new MjdbcSQLException(ex); } result = toByteArray(input); if (close == true) { TypeHandlerUtils.closeQuietly(input); } return result; } static Object convertArray(Connection conn, Object[] array); static Object convertArray(Connection conn, Collection<?> array); static Object convertBlob(Connection conn, byte[] value); static Object convertBlob(Connection conn, InputStream input); static Object convertBlob(Connection conn, String value); static Object convertBlob(Object blob, byte[] value); static Object convertBlob(Object blob, InputStream input); static Object convertBlob(Object blob, String value); static Object convertClob(Connection conn, byte[] value); static Object convertClob(Connection conn, String value); static Object convertClob(Connection conn, InputStream input); static Object convertClob(Object clob, byte[] value); static Object convertClob(Object clob, String value); static Object convertClob(Object clob, InputStream input); static String convertJavaClassToSqlType(String simpleClassName); static Object convertSqlXml(Connection conn, byte[] value); static Object convertSqlXml(Connection conn, String value); static Object convertSqlXml(Connection conn, InputStream input); static Object convertSqlXml(Object sqlXml, byte[] value); static Object convertSqlXml(Object sqlXml, String value); static Object convertSqlXml(Object sqlXml, InputStream input); static byte[] readBlob(Object blob, boolean close); static byte[] readBlob(Object blob); static byte[] readClob(Object clob, boolean close); static byte[] readClob(Object clob); static byte[] readSqlXml(Object sqlXml, boolean close); static byte[] readSqlXml(Object sqlXml); static byte[] toByteArray(InputStream input); static String toString(Reader reader); static void closeQuietly(InputStream input); static void closeQuietly(OutputStream output); static long copy(InputStream input, OutputStream output); static long copy(Reader input, StringBuilder output); static Object createBlob(Connection conn); static Object createClob(Connection conn); static Object createSQLXML(Connection conn); static Object createArrayOf(Connection conn, String typeName, Object[] elements); static boolean isJDBC3(Overrider overrider); }
@Test public void testReadBlob() throws Exception { testReadBlob(false); }
TypeHandlerUtils { public static byte[] readClob(Object clob, boolean close) throws SQLException { byte[] result = null; InputStream input = null; try { input = (InputStream) MappingUtils.invokeFunction(clob, "getAsciiStream", new Class[]{}, new Object[]{}); } catch (MjdbcException ex) { throw new MjdbcSQLException(ex); } result = toByteArray(input); if (close == true) { TypeHandlerUtils.closeQuietly(input); } return result; } static Object convertArray(Connection conn, Object[] array); static Object convertArray(Connection conn, Collection<?> array); static Object convertBlob(Connection conn, byte[] value); static Object convertBlob(Connection conn, InputStream input); static Object convertBlob(Connection conn, String value); static Object convertBlob(Object blob, byte[] value); static Object convertBlob(Object blob, InputStream input); static Object convertBlob(Object blob, String value); static Object convertClob(Connection conn, byte[] value); static Object convertClob(Connection conn, String value); static Object convertClob(Connection conn, InputStream input); static Object convertClob(Object clob, byte[] value); static Object convertClob(Object clob, String value); static Object convertClob(Object clob, InputStream input); static String convertJavaClassToSqlType(String simpleClassName); static Object convertSqlXml(Connection conn, byte[] value); static Object convertSqlXml(Connection conn, String value); static Object convertSqlXml(Connection conn, InputStream input); static Object convertSqlXml(Object sqlXml, byte[] value); static Object convertSqlXml(Object sqlXml, String value); static Object convertSqlXml(Object sqlXml, InputStream input); static byte[] readBlob(Object blob, boolean close); static byte[] readBlob(Object blob); static byte[] readClob(Object clob, boolean close); static byte[] readClob(Object clob); static byte[] readSqlXml(Object sqlXml, boolean close); static byte[] readSqlXml(Object sqlXml); static byte[] toByteArray(InputStream input); static String toString(Reader reader); static void closeQuietly(InputStream input); static void closeQuietly(OutputStream output); static long copy(InputStream input, OutputStream output); static long copy(Reader input, StringBuilder output); static Object createBlob(Connection conn); static Object createClob(Connection conn); static Object createSQLXML(Connection conn); static Object createArrayOf(Connection conn, String typeName, Object[] elements); static boolean isJDBC3(Overrider overrider); }
@Test public void testReadClob() throws Exception { testReadClob(false); }
MidaoLogger extends Logger { @Override public void info(String msg) { if (isSLF4jAvailable() == false) { super.info(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "info", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.info(msg); } } } private MidaoLogger(String name, String resourceBundleName); static MidaoLogger getLogger(String name); static MidaoLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); }
@Test public void testInfo() throws Exception { }
TypeHandlerUtils { public static byte[] readSqlXml(Object sqlXml, boolean close) throws SQLException { byte[] result = null; InputStream input = null; try { input = (InputStream) MappingUtils.invokeFunction(sqlXml, "getBinaryStream", new Class[]{}, new Object[]{}); } catch (MjdbcException ex) { throw new MjdbcSQLException(ex); } result = toByteArray(input); if (close == true) { TypeHandlerUtils.closeQuietly(input); } return result; } static Object convertArray(Connection conn, Object[] array); static Object convertArray(Connection conn, Collection<?> array); static Object convertBlob(Connection conn, byte[] value); static Object convertBlob(Connection conn, InputStream input); static Object convertBlob(Connection conn, String value); static Object convertBlob(Object blob, byte[] value); static Object convertBlob(Object blob, InputStream input); static Object convertBlob(Object blob, String value); static Object convertClob(Connection conn, byte[] value); static Object convertClob(Connection conn, String value); static Object convertClob(Connection conn, InputStream input); static Object convertClob(Object clob, byte[] value); static Object convertClob(Object clob, String value); static Object convertClob(Object clob, InputStream input); static String convertJavaClassToSqlType(String simpleClassName); static Object convertSqlXml(Connection conn, byte[] value); static Object convertSqlXml(Connection conn, String value); static Object convertSqlXml(Connection conn, InputStream input); static Object convertSqlXml(Object sqlXml, byte[] value); static Object convertSqlXml(Object sqlXml, String value); static Object convertSqlXml(Object sqlXml, InputStream input); static byte[] readBlob(Object blob, boolean close); static byte[] readBlob(Object blob); static byte[] readClob(Object clob, boolean close); static byte[] readClob(Object clob); static byte[] readSqlXml(Object sqlXml, boolean close); static byte[] readSqlXml(Object sqlXml); static byte[] toByteArray(InputStream input); static String toString(Reader reader); static void closeQuietly(InputStream input); static void closeQuietly(OutputStream output); static long copy(InputStream input, OutputStream output); static long copy(Reader input, StringBuilder output); static Object createBlob(Connection conn); static Object createClob(Connection conn); static Object createSQLXML(Connection conn); static Object createArrayOf(Connection conn, String typeName, Object[] elements); static boolean isJDBC3(Overrider overrider); }
@Test public void testReadSqlXml() throws Exception { testReadSqlXml(false); }
TypeHandlerUtils { public static byte[] toByteArray(InputStream input) throws SQLException { byte[] result = null; ByteArrayOutputStream output = new ByteArrayOutputStream(); try { copy(input, output); result = output.toByteArray(); } catch (IOException ex) { throw new MjdbcSQLException(ex); } TypeHandlerUtils.closeQuietly(output); return result; } static Object convertArray(Connection conn, Object[] array); static Object convertArray(Connection conn, Collection<?> array); static Object convertBlob(Connection conn, byte[] value); static Object convertBlob(Connection conn, InputStream input); static Object convertBlob(Connection conn, String value); static Object convertBlob(Object blob, byte[] value); static Object convertBlob(Object blob, InputStream input); static Object convertBlob(Object blob, String value); static Object convertClob(Connection conn, byte[] value); static Object convertClob(Connection conn, String value); static Object convertClob(Connection conn, InputStream input); static Object convertClob(Object clob, byte[] value); static Object convertClob(Object clob, String value); static Object convertClob(Object clob, InputStream input); static String convertJavaClassToSqlType(String simpleClassName); static Object convertSqlXml(Connection conn, byte[] value); static Object convertSqlXml(Connection conn, String value); static Object convertSqlXml(Connection conn, InputStream input); static Object convertSqlXml(Object sqlXml, byte[] value); static Object convertSqlXml(Object sqlXml, String value); static Object convertSqlXml(Object sqlXml, InputStream input); static byte[] readBlob(Object blob, boolean close); static byte[] readBlob(Object blob); static byte[] readClob(Object clob, boolean close); static byte[] readClob(Object clob); static byte[] readSqlXml(Object sqlXml, boolean close); static byte[] readSqlXml(Object sqlXml); static byte[] toByteArray(InputStream input); static String toString(Reader reader); static void closeQuietly(InputStream input); static void closeQuietly(OutputStream output); static long copy(InputStream input, OutputStream output); static long copy(Reader input, StringBuilder output); static Object createBlob(Connection conn); static Object createClob(Connection conn); static Object createSQLXML(Connection conn); static Object createArrayOf(Connection conn, String typeName, Object[] elements); static boolean isJDBC3(Overrider overrider); }
@Test public void testToByteArray() throws Exception { String data = "ace"; byte[] result = null; result = TypeHandlerUtils.toByteArray(new ByteArrayInputStream(data.getBytes())); Assert.assertEquals(data, new String(result)); }
TypeHandlerUtils { public static String toString(Reader reader) throws SQLException { String result = null; StringBuilder output = new StringBuilder(); try { copy(reader, output); result = output.toString(); } catch (IOException ex) { throw new MjdbcSQLException(ex); } return result; } static Object convertArray(Connection conn, Object[] array); static Object convertArray(Connection conn, Collection<?> array); static Object convertBlob(Connection conn, byte[] value); static Object convertBlob(Connection conn, InputStream input); static Object convertBlob(Connection conn, String value); static Object convertBlob(Object blob, byte[] value); static Object convertBlob(Object blob, InputStream input); static Object convertBlob(Object blob, String value); static Object convertClob(Connection conn, byte[] value); static Object convertClob(Connection conn, String value); static Object convertClob(Connection conn, InputStream input); static Object convertClob(Object clob, byte[] value); static Object convertClob(Object clob, String value); static Object convertClob(Object clob, InputStream input); static String convertJavaClassToSqlType(String simpleClassName); static Object convertSqlXml(Connection conn, byte[] value); static Object convertSqlXml(Connection conn, String value); static Object convertSqlXml(Connection conn, InputStream input); static Object convertSqlXml(Object sqlXml, byte[] value); static Object convertSqlXml(Object sqlXml, String value); static Object convertSqlXml(Object sqlXml, InputStream input); static byte[] readBlob(Object blob, boolean close); static byte[] readBlob(Object blob); static byte[] readClob(Object clob, boolean close); static byte[] readClob(Object clob); static byte[] readSqlXml(Object sqlXml, boolean close); static byte[] readSqlXml(Object sqlXml); static byte[] toByteArray(InputStream input); static String toString(Reader reader); static void closeQuietly(InputStream input); static void closeQuietly(OutputStream output); static long copy(InputStream input, OutputStream output); static long copy(Reader input, StringBuilder output); static Object createBlob(Connection conn); static Object createClob(Connection conn); static Object createSQLXML(Connection conn); static Object createArrayOf(Connection conn, String typeName, Object[] elements); static boolean isJDBC3(Overrider overrider); }
@Test public void testToString() throws Exception { String data = "tar.gz"; String result = ""; result = TypeHandlerUtils.toString(new StringReader(data)); Assert.assertEquals(data, result); }
TypeHandlerUtils { public static void closeQuietly(InputStream input) { try { input.close(); } catch (IOException ex) { } } static Object convertArray(Connection conn, Object[] array); static Object convertArray(Connection conn, Collection<?> array); static Object convertBlob(Connection conn, byte[] value); static Object convertBlob(Connection conn, InputStream input); static Object convertBlob(Connection conn, String value); static Object convertBlob(Object blob, byte[] value); static Object convertBlob(Object blob, InputStream input); static Object convertBlob(Object blob, String value); static Object convertClob(Connection conn, byte[] value); static Object convertClob(Connection conn, String value); static Object convertClob(Connection conn, InputStream input); static Object convertClob(Object clob, byte[] value); static Object convertClob(Object clob, String value); static Object convertClob(Object clob, InputStream input); static String convertJavaClassToSqlType(String simpleClassName); static Object convertSqlXml(Connection conn, byte[] value); static Object convertSqlXml(Connection conn, String value); static Object convertSqlXml(Connection conn, InputStream input); static Object convertSqlXml(Object sqlXml, byte[] value); static Object convertSqlXml(Object sqlXml, String value); static Object convertSqlXml(Object sqlXml, InputStream input); static byte[] readBlob(Object blob, boolean close); static byte[] readBlob(Object blob); static byte[] readClob(Object clob, boolean close); static byte[] readClob(Object clob); static byte[] readSqlXml(Object sqlXml, boolean close); static byte[] readSqlXml(Object sqlXml); static byte[] toByteArray(InputStream input); static String toString(Reader reader); static void closeQuietly(InputStream input); static void closeQuietly(OutputStream output); static long copy(InputStream input, OutputStream output); static long copy(Reader input, StringBuilder output); static Object createBlob(Connection conn); static Object createClob(Connection conn); static Object createSQLXML(Connection conn); static Object createArrayOf(Connection conn, String typeName, Object[] elements); static boolean isJDBC3(Overrider overrider); }
@Test public void testCloseQuietlyInput() throws Exception { Mockito.doThrow(new IOException()).when(input).close(); try { TypeHandlerUtils.closeQuietly(input); } catch (Exception ex) { fail(); } } @Test public void testCloseQuietlyOutput() throws Exception { Mockito.doThrow(new IOException()).when(output).close(); try { TypeHandlerUtils.closeQuietly(output); } catch (Exception ex) { fail(); } }
TypeHandlerUtils { public static boolean isJDBC3(Overrider overrider) { boolean result = false; if (overrider.hasOverride(MjdbcConstants.OVERRIDE_INT_JDBC3) == true) { result = (Boolean) overrider.getOverride(MjdbcConstants.OVERRIDE_INT_JDBC3); } return result; } static Object convertArray(Connection conn, Object[] array); static Object convertArray(Connection conn, Collection<?> array); static Object convertBlob(Connection conn, byte[] value); static Object convertBlob(Connection conn, InputStream input); static Object convertBlob(Connection conn, String value); static Object convertBlob(Object blob, byte[] value); static Object convertBlob(Object blob, InputStream input); static Object convertBlob(Object blob, String value); static Object convertClob(Connection conn, byte[] value); static Object convertClob(Connection conn, String value); static Object convertClob(Connection conn, InputStream input); static Object convertClob(Object clob, byte[] value); static Object convertClob(Object clob, String value); static Object convertClob(Object clob, InputStream input); static String convertJavaClassToSqlType(String simpleClassName); static Object convertSqlXml(Connection conn, byte[] value); static Object convertSqlXml(Connection conn, String value); static Object convertSqlXml(Connection conn, InputStream input); static Object convertSqlXml(Object sqlXml, byte[] value); static Object convertSqlXml(Object sqlXml, String value); static Object convertSqlXml(Object sqlXml, InputStream input); static byte[] readBlob(Object blob, boolean close); static byte[] readBlob(Object blob); static byte[] readClob(Object clob, boolean close); static byte[] readClob(Object clob); static byte[] readSqlXml(Object sqlXml, boolean close); static byte[] readSqlXml(Object sqlXml); static byte[] toByteArray(InputStream input); static String toString(Reader reader); static void closeQuietly(InputStream input); static void closeQuietly(OutputStream output); static long copy(InputStream input, OutputStream output); static long copy(Reader input, StringBuilder output); static Object createBlob(Connection conn); static Object createClob(Connection conn); static Object createSQLXML(Connection conn); static Object createArrayOf(Connection conn, String typeName, Object[] elements); static boolean isJDBC3(Overrider overrider); }
@Test public void testIsJDBC3() { Overrider overrider = new Overrider(); Assert.assertEquals(false, TypeHandlerUtils.isJDBC3(overrider)); overrider.override(MjdbcConstants.OVERRIDE_INT_JDBC3, true); Assert.assertEquals(true, TypeHandlerUtils.isJDBC3(overrider)); overrider.override(MjdbcConstants.OVERRIDE_INT_JDBC3, false); Assert.assertEquals(false, TypeHandlerUtils.isJDBC3(overrider)); }
TypeHandlerUtils { public static long copy(InputStream input, OutputStream output) throws IOException { return copy(input, output, new byte[DEFAULT_BUFFER_SIZE]); } static Object convertArray(Connection conn, Object[] array); static Object convertArray(Connection conn, Collection<?> array); static Object convertBlob(Connection conn, byte[] value); static Object convertBlob(Connection conn, InputStream input); static Object convertBlob(Connection conn, String value); static Object convertBlob(Object blob, byte[] value); static Object convertBlob(Object blob, InputStream input); static Object convertBlob(Object blob, String value); static Object convertClob(Connection conn, byte[] value); static Object convertClob(Connection conn, String value); static Object convertClob(Connection conn, InputStream input); static Object convertClob(Object clob, byte[] value); static Object convertClob(Object clob, String value); static Object convertClob(Object clob, InputStream input); static String convertJavaClassToSqlType(String simpleClassName); static Object convertSqlXml(Connection conn, byte[] value); static Object convertSqlXml(Connection conn, String value); static Object convertSqlXml(Connection conn, InputStream input); static Object convertSqlXml(Object sqlXml, byte[] value); static Object convertSqlXml(Object sqlXml, String value); static Object convertSqlXml(Object sqlXml, InputStream input); static byte[] readBlob(Object blob, boolean close); static byte[] readBlob(Object blob); static byte[] readClob(Object clob, boolean close); static byte[] readClob(Object clob); static byte[] readSqlXml(Object sqlXml, boolean close); static byte[] readSqlXml(Object sqlXml); static byte[] toByteArray(InputStream input); static String toString(Reader reader); static void closeQuietly(InputStream input); static void closeQuietly(OutputStream output); static long copy(InputStream input, OutputStream output); static long copy(Reader input, StringBuilder output); static Object createBlob(Connection conn); static Object createClob(Connection conn); static Object createSQLXML(Connection conn); static Object createArrayOf(Connection conn, String typeName, Object[] elements); static boolean isJDBC3(Overrider overrider); }
@Test public void testCopy() throws Exception { String data = "rar"; ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); InputStream inputStream = new ByteArrayInputStream(data.getBytes()); TypeHandlerUtils.copy(inputStream, outputStream); Assert.assertEquals(data, new String(outputStream.toByteArray())); }
UniversalTypeHandler extends BaseTypeHandler { @Override public QueryParameters processInput(Statement stmt, QueryParameters params) throws SQLException { QueryParameters result = new QueryParameters(params); Object value = null; Object convertedValue = null; Integer convertedType = null; Connection conn = stmt.getConnection(); for (String parameterName : params.keySet()) { value = params.getValue(parameterName); convertedValue = null; convertedType = null; if (params.getType(parameterName) == MjdbcTypes.ARRAY) { if (value instanceof Object[]) { convertedValue = TypeHandlerUtils.convertArray(conn, (Object[]) value); } else if (value instanceof Collection) { convertedValue = TypeHandlerUtils.convertArray(conn, (Collection<?>) value); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.BLOB) { if (value instanceof String) { convertedValue = ((String) value).getBytes(); } else if (value instanceof InputStream) { convertedValue = TypeHandlerUtils.toByteArray((InputStream) value); } else if (value instanceof byte[]) { convertedValue = value; } else { convertedValue = value; } convertedType = MjdbcTypes.VARBINARY; } else if (params.getType(parameterName) == MjdbcTypes.CLOB) { if (value instanceof String) { convertedValue = value; } else if (value instanceof InputStream) { convertedValue = new String(TypeHandlerUtils.toByteArray((InputStream) value)); } else if (value instanceof byte[]) { convertedValue = new String((byte[]) value); } else { convertedValue = value; } convertedType = MjdbcTypes.VARCHAR; } else if (params.getType(parameterName) == MjdbcTypes.SQLXML) { if (value instanceof String) { convertedValue = value; } else if (value instanceof InputStream) { convertedValue = new String(TypeHandlerUtils.toByteArray((InputStream) value)); } else if (value instanceof byte[]) { convertedValue = new String((byte[]) value); } else { convertedValue = value; } convertedType = MjdbcTypes.VARCHAR; } else if (params.getType(parameterName) == MjdbcTypes.VARCHAR && TypeHandlerUtils.isJDBC3(overrider) == true && value instanceof Reader) { convertedValue = TypeHandlerUtils.toString((Reader) value); } else if (params.getType(parameterName) == MjdbcTypes.VARBINARY && TypeHandlerUtils.isJDBC3(overrider) == true && value instanceof InputStream) { convertedValue = TypeHandlerUtils.toByteArray((InputStream) value); } else { convertedValue = value; } result.updateValue(parameterName, convertedValue); if (convertedType != null) { result.updateType(parameterName, convertedType); } } return result; } UniversalTypeHandler(Overrider overrider); @Override QueryParameters processInput(Statement stmt, QueryParameters params); @Override void afterExecute(Statement stmt, QueryParameters processedInput, QueryParameters params); }
@Test public void testProcessInput() throws Exception { QueryParameters result = new UniversalTypeHandler(new Overrider()).processInput(stmt, params); MappingUtils.invokeFunction(verify(conn, never()), "createBlob", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, never()), "createClob", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, never()), "createSQLXML", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, times(1)), "createArrayOf", new Class[]{String.class, Object[].class}, new Object[]{any(String.class), any(Object[].class)}); Assert.assertEquals(MjdbcTypes.VARCHAR, result.getType("clob_byte").intValue()); Assert.assertEquals(MjdbcTypes.VARBINARY, result.getType("blob_byte").intValue()); Assert.assertEquals(MjdbcTypes.VARCHAR, result.getType("sqlXml_byte").intValue()); Assert.assertEquals(true, result.getValue("reader") instanceof Reader); Assert.assertEquals(true, result.getValue("stream") instanceof InputStream); } @Test public void testProcessInputJDBC3() throws Exception { Overrider overrider = new Overrider(); overrider.override(MjdbcConstants.OVERRIDE_INT_JDBC3, true); QueryParameters result = new UniversalTypeHandler(overrider).processInput(stmt, params); MappingUtils.invokeFunction(verify(conn, never()), "createBlob", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, never()), "createClob", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, never()), "createSQLXML", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, times(1)), "createArrayOf", new Class[]{String.class, Object[].class}, new Object[]{any(String.class), any(Object[].class)}); Assert.assertEquals(MjdbcTypes.VARCHAR, result.getType("clob_byte").intValue()); Assert.assertEquals(MjdbcTypes.VARBINARY, result.getType("blob_byte").intValue()); Assert.assertEquals(MjdbcTypes.VARCHAR, result.getType("sqlXml_byte").intValue()); Assert.assertEquals("Deadpool", result.getValue("reader")); Assert.assertEquals("Lobo", new String((byte[]) result.getValue("stream"))); }
UniversalTypeHandler extends BaseTypeHandler { @Override public void afterExecute(Statement stmt, QueryParameters processedInput, QueryParameters params) throws SQLException { Object value = null; Object convertedValue = null; Connection conn = stmt.getConnection(); for (String parameterName : params.keySet()) { value = params.getValue(parameterName); convertedValue = processedInput.getValue(parameterName); try { if (params.getType(parameterName) == MjdbcTypes.ARRAY) { if (value instanceof Object[] || value instanceof Collection) { if (convertedValue != null && MappingUtils.objectImplements(convertedValue, "java.sql.Array") == true) { MappingUtils.invokeFunction(convertedValue, "free", new Class[]{}, new Object[]{}); } } } else if (params.getType(parameterName) == MjdbcTypes.BLOB) { } else if (params.getType(parameterName) == MjdbcTypes.CLOB) { } else if (params.getType(parameterName) == MjdbcTypes.SQLXML) { } } catch (MjdbcException ex) { logger.warning("Failed to close/free resource: " + parameterName + ". Might lead to resource leak!"); } } } UniversalTypeHandler(Overrider overrider); @Override QueryParameters processInput(Statement stmt, QueryParameters params); @Override void afterExecute(Statement stmt, QueryParameters processedInput, QueryParameters params); }
@Test public void testAfterExecute() throws Exception { QueryParameters processedParams = new QueryParameters(params); processedParams.set("array_list", processedParams.getValue("array")); processedParams.set("blob_byte", processedParams.getValue("blob")); processedParams.set("clob_byte", processedParams.getValue("clob")); processedParams.set("sqlXml_byte", processedParams.getValue("sqlXml")); new UniversalTypeHandler(new Overrider()).afterExecute(stmt, processedParams, params); MappingUtils.invokeFunction(verify(blob, never()), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(clob, never()), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(array, times(1)), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(sqlXml, never()), "free", new Class[]{}, new Object[]{}); }
MidaoLogger extends Logger { @Override public void warning(String msg) { if (isSLF4jAvailable() == false) { super.warning(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "warn", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.warning(msg); } } } private MidaoLogger(String name, String resourceBundleName); static MidaoLogger getLogger(String name); static MidaoLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); }
@Test public void testWarning() throws Exception { }
BaseTypeHandler implements TypeHandler { public QueryParameters processInput(Statement stmt, QueryParameters params) throws SQLException { QueryParameters result = new QueryParameters(params); Object value = null; Object convertedValue = null; Connection conn = stmt.getConnection(); for (String parameterName : params.keySet()) { value = params.getValue(parameterName); convertedValue = null; if (params.getType(parameterName) == MjdbcTypes.ARRAY) { if (value instanceof Object[]) { convertedValue = TypeHandlerUtils.convertArray(conn, (Object[]) value); } else if (value instanceof Collection) { convertedValue = TypeHandlerUtils.convertArray(conn, (Collection<?>) value); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.BLOB) { if (value instanceof String) { convertedValue = TypeHandlerUtils.convertBlob(conn, (String) value); } else if (value instanceof InputStream) { convertedValue = TypeHandlerUtils.convertBlob(conn, (InputStream) value); } else if (value instanceof byte[]) { convertedValue = TypeHandlerUtils.convertBlob(conn, (byte[]) value); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.CLOB) { if (value instanceof String) { convertedValue = TypeHandlerUtils.convertClob(conn, (String) value); } else if (value instanceof InputStream) { convertedValue = TypeHandlerUtils.convertClob(conn, (InputStream) value); } else if (value instanceof byte[]) { convertedValue = TypeHandlerUtils.convertClob(conn, (byte[]) value); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.SQLXML) { if (value instanceof String) { convertedValue = TypeHandlerUtils.convertSqlXml(conn, (String) value); } else if (value instanceof InputStream) { convertedValue = TypeHandlerUtils.convertSqlXml(conn, (InputStream) value); } else if (value instanceof byte[]) { convertedValue = TypeHandlerUtils.convertSqlXml(conn, (byte[]) value); } else { convertedValue = value; } } else { convertedValue = value; } result.updateValue(parameterName, convertedValue); } return result; } BaseTypeHandler(Overrider overrider); QueryParameters processInput(Statement stmt, QueryParameters params); void afterExecute(Statement stmt, QueryParameters processedInput, QueryParameters params); QueryParameters processOutput(Statement stmt, QueryParameters params); List<QueryParameters> processOutput(Statement stmt, List<QueryParameters> paramsList); }
@Test public void testProcessInput() throws Exception { new BaseTypeHandler(new Overrider()).processInput(stmt, params); MappingUtils.invokeFunction(verify(conn, times(1)), "createBlob", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, times(1)), "createClob", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, times(1)), "createSQLXML", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, times(1)), "createArrayOf", new Class[]{String.class, Object[].class}, new Object[]{any(String.class), any(Object[].class)}); verify(blob, times(1)).setBinaryStream(1); verify(clob, times(1)).setAsciiStream(1); MappingUtils.invokeFunction(verify(sqlXml, times(1)), "setBinaryStream", new Class[]{}, new Object[]{}); }
BaseTypeHandler implements TypeHandler { public void afterExecute(Statement stmt, QueryParameters processedInput, QueryParameters params) throws SQLException { Object value = null; Object convertedValue = null; Connection conn = stmt.getConnection(); for (String parameterName : params.keySet()) { value = params.getValue(parameterName); convertedValue = processedInput.getValue(parameterName); try { if (params.getType(parameterName) == MjdbcTypes.ARRAY) { if (value instanceof Object[] || value instanceof Collection) { if (convertedValue != null && MappingUtils.objectImplements(convertedValue, "java.sql.Array") == true) { MappingUtils.invokeFunction(convertedValue, "free", new Class[]{}, new Object[]{}); } } } else if (params.getType(parameterName) == MjdbcTypes.BLOB) { if (value instanceof String || value instanceof InputStream || value instanceof byte[]) { if (convertedValue != null && MappingUtils.objectImplements(convertedValue, "java.sql.Blob") == true) { MappingUtils.invokeFunction(convertedValue, "free", new Class[]{}, new Object[]{}); } } } else if (params.getType(parameterName) == MjdbcTypes.CLOB) { if (value instanceof String || value instanceof InputStream || value instanceof byte[]) { if (convertedValue != null && MappingUtils.objectImplements(convertedValue, "java.sql.Clob") == true) { MappingUtils.invokeFunction(convertedValue, "free", new Class[]{}, new Object[]{}); } } } else if (params.getType(parameterName) == MjdbcTypes.SQLXML) { if (value instanceof String || value instanceof InputStream || value instanceof byte[]) { if (convertedValue != null && MappingUtils.objectImplements(convertedValue, "java.sql.SQLXML") == true) { MappingUtils.invokeFunction(convertedValue, "free", new Class[]{}, new Object[]{}); } } } } catch (MjdbcException ex) { logger.warning("Failed to close/free resource: " + parameterName + ". Might lead to resource leak!"); } } } BaseTypeHandler(Overrider overrider); QueryParameters processInput(Statement stmt, QueryParameters params); void afterExecute(Statement stmt, QueryParameters processedInput, QueryParameters params); QueryParameters processOutput(Statement stmt, QueryParameters params); List<QueryParameters> processOutput(Statement stmt, List<QueryParameters> paramsList); }
@Test public void testAfterExecute() throws Exception { QueryParameters processedParams = new QueryParameters(params); processedParams.set("array_list", processedParams.getValue("array")); processedParams.set("blob_byte", processedParams.getValue("blob")); processedParams.set("clob_byte", processedParams.getValue("clob")); processedParams.set("sqlXml_byte", processedParams.getValue("sqlXml")); new BaseTypeHandler(new Overrider()).afterExecute(stmt, processedParams, params); MappingUtils.invokeFunction(verify(array, times(1)), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(blob, times(1)), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(clob, times(1)), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(sqlXml, times(1)), "free", new Class[]{}, new Object[]{}); }
BaseTypeHandler implements TypeHandler { public QueryParameters processOutput(Statement stmt, QueryParameters params) throws SQLException { Object value = null; Object convertedValue = null; for (String parameterName : params.keySet()) { value = params.getValue(parameterName); convertedValue = null; try { if (params.getType(parameterName) == MjdbcTypes.ARRAY) { if (value != null && MappingUtils.objectImplements(value, "java.sql.Array") == true) { convertedValue = MappingUtils.invokeFunction(value, "getArray", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(value, "free", new Class[]{}, new Object[]{}); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.BLOB) { if (value != null && MappingUtils.objectImplements(value, "java.sql.Blob") == true) { convertedValue = TypeHandlerUtils.readBlob(value); MappingUtils.invokeFunction(value, "free", new Class[]{}, new Object[]{}); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.CLOB) { if (value != null && MappingUtils.objectImplements(value, "java.sql.Clob") == true) { convertedValue = new String(TypeHandlerUtils.readClob(value)); MappingUtils.invokeFunction(value, "free", new Class[]{}, new Object[]{}); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.SQLXML) { if (value != null && MappingUtils.objectImplements(value, "java.sql.SQLXML") == true) { convertedValue = TypeHandlerUtils.readSqlXml(value); MappingUtils.invokeFunction(value, "free", new Class[]{}, new Object[]{}); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.OTHER) { if (value instanceof ResultSet) { ResultSet rs = (ResultSet) value; convertedValue = MappingUtils.convertResultSet(rs); } else { convertedValue = value; } } else { convertedValue = value; } } catch (MjdbcException ex) { logger.warning("Failed to process/close resource: " + parameterName + ". Might lead to resource leak!"); convertedValue = value; } params.updateValue(parameterName, convertedValue); } return params; } BaseTypeHandler(Overrider overrider); QueryParameters processInput(Statement stmt, QueryParameters params); void afterExecute(Statement stmt, QueryParameters processedInput, QueryParameters params); QueryParameters processOutput(Statement stmt, QueryParameters params); List<QueryParameters> processOutput(Statement stmt, List<QueryParameters> paramsList); }
@Test public void testProcessOutput() throws Exception { QueryParameters result = new BaseTypeHandler(new Overrider()).processOutput(stmt, params); verify(array, times(1)).getArray(); verify(blob, times(1)).getBinaryStream(); verify(clob, times(1)).getAsciiStream(); MappingUtils.invokeFunction(verify(sqlXml, times(1)), "getBinaryStream", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(array, times(1)), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(blob, times(1)), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(clob, times(1)), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(sqlXml, times(1)), "free", new Class[]{}, new Object[]{}); } @Test public void testProcessOutputList() throws Exception { List<QueryParameters> paramsList = new ArrayList<QueryParameters>(); QueryParameters paramsClone = new QueryParameters(params); paramsList.add(new QueryParameters()); paramsList.add(params); paramsList.add(paramsClone); new BaseTypeHandler(new Overrider()).processOutput(stmt, paramsList); verify(array, times(2)).getArray(); verify(blob, times(2)).getBinaryStream(); verify(clob, times(2)).getAsciiStream(); MappingUtils.invokeFunction(verify(sqlXml, times(2)), "getBinaryStream", new Class[]{}, new Object[]{}); }
OracleTypeHandler implements TypeHandler { public QueryParameters processInput(Statement stmt, QueryParameters params) throws SQLException { QueryParameters result = new QueryParameters(params); Object value = null; Object convertedValue = null; Connection conn = stmt.getConnection(); for (String parameterName : params.keySet()) { value = params.getValue(parameterName); convertedValue = null; try { if (params.getType(parameterName) == MjdbcTypes.ARRAY) { if (value instanceof Object[]) { convertedValue = MappingUtils.invokeFunction(conn, "createARRAY", new Class[]{String.class, Object.class}, new Object[]{convertJavaClassToSqlType(value.getClass().getComponentType().getSimpleName()), value}); } else if (value instanceof Collection) { Object[] valueArray = ((Collection) value).toArray(); convertedValue = MappingUtils.invokeFunction(conn, "createARRAY", new Class[]{String.class, Object.class}, new Object[]{convertJavaClassToSqlType(valueArray.getClass().getComponentType().getSimpleName()), valueArray}); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.BLOB) { Object blob = null; Class blobClazz = Class.forName("oracle.sql.BLOB"); int blobSessionDuration = (Integer) MappingUtils.returnStaticField(blobClazz, "DURATION_SESSION"); if (value instanceof String) { blob = MappingUtils.invokeStaticFunction(blobClazz, "createTemporary", new Class[]{Connection.class, boolean.class, int.class}, new Object[]{conn, false, blobSessionDuration}); convertedValue = TypeHandlerUtils.convertBlob(blob, (String) value); } else if (value instanceof InputStream) { blob = MappingUtils.invokeStaticFunction(blobClazz, "createTemporary", new Class[]{Connection.class, boolean.class, int.class}, new Object[]{conn, false, blobSessionDuration}); convertedValue = TypeHandlerUtils.convertBlob(blob, (InputStream) value); } else if (value instanceof byte[]) { blob = MappingUtils.invokeStaticFunction(blobClazz, "createTemporary", new Class[]{Connection.class, boolean.class, int.class}, new Object[]{conn, false, blobSessionDuration}); convertedValue = TypeHandlerUtils.convertBlob(blob, (byte[]) value); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.CLOB) { Object clob = null; Class clobClazz = Class.forName("oracle.sql.CLOB"); int clobSessionDuration = (Integer) MappingUtils.returnStaticField(clobClazz, "DURATION_SESSION"); if (value instanceof String) { clob = MappingUtils.invokeStaticFunction(clobClazz, "createTemporary", new Class[]{Connection.class, boolean.class, int.class}, new Object[]{conn, false, clobSessionDuration}); convertedValue = TypeHandlerUtils.convertClob(clob, (String) value); } else if (value instanceof InputStream) { clob = MappingUtils.invokeStaticFunction(clobClazz, "createTemporary", new Class[]{Connection.class, boolean.class, int.class}, new Object[]{conn, false, clobSessionDuration}); convertedValue = TypeHandlerUtils.convertClob(clob, (InputStream) value); } else if (value instanceof byte[]) { clob = MappingUtils.invokeStaticFunction(clobClazz, "createTemporary", new Class[]{Connection.class, boolean.class, int.class}, new Object[]{conn, false, clobSessionDuration}); convertedValue = TypeHandlerUtils.convertClob(clob, (byte[]) value); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.SQLXML) { convertedValue = value; } else if (params.getType(parameterName) == MjdbcTypes.VARCHAR && TypeHandlerUtils.isJDBC3(overrider) == true && value instanceof Reader) { convertedValue = TypeHandlerUtils.toString((Reader) value); } else if (params.getType(parameterName) == MjdbcTypes.VARBINARY && TypeHandlerUtils.isJDBC3(overrider) == true && value instanceof InputStream) { convertedValue = TypeHandlerUtils.toByteArray((InputStream) value); } else { convertedValue = value; } } catch (MjdbcException ex) { logger.warning("Failed to process resource: " + parameterName + ". Might lead to error during query execution!!"); convertedValue = value; } catch (ClassNotFoundException e) { logger.warning("Failed to process resource: " + parameterName + " due to ClassNotFoundException. Please check if Oracle JDBC Driver is present in class path"); convertedValue = value; } result.updateValue(parameterName, convertedValue); } return result; } OracleTypeHandler(Overrider overrider); QueryParameters processInput(Statement stmt, QueryParameters params); void afterExecute(Statement stmt, QueryParameters processedInput, QueryParameters params); QueryParameters processOutput(Statement stmt, QueryParameters params); List<QueryParameters> processOutput(Statement stmt, List<QueryParameters> paramsList); }
@Test public void testProcessInput() throws Exception { QueryParameters result = new OracleTypeHandler(new Overrider()).processInput(stmt, params); MappingUtils.invokeFunction(verify(conn, never()), "createBlob", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, never()), "createClob", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, never()), "createSQLXML", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, never()), "createArrayOf", new Class[]{String.class, Object[].class}, new Object[]{any(String.class), any(Object[].class)}); verify(blob, never()).setBinaryStream(1); verify(clob, never()).setAsciiStream(1); Assert.assertEquals(true, result.getValue("reader") instanceof Reader); Assert.assertEquals(true, result.getValue("stream") instanceof InputStream); } @Test public void testProcessInputJDBC3() throws Exception { Overrider overrider = new Overrider(); overrider.override(MjdbcConstants.OVERRIDE_INT_JDBC3, true); QueryParameters result = new UniversalTypeHandler(overrider).processInput(stmt, params); MappingUtils.invokeFunction(verify(conn, never()), "createBlob", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, never()), "createClob", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, never()), "createSQLXML", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(conn, times(1)), "createArrayOf", new Class[]{String.class, Object[].class}, new Object[]{any(String.class), any(Object[].class)}); Assert.assertEquals(MjdbcTypes.VARCHAR, result.getType("clob_byte").intValue()); Assert.assertEquals(MjdbcTypes.VARBINARY, result.getType("blob_byte").intValue()); Assert.assertEquals(MjdbcTypes.VARCHAR, result.getType("sqlXml_byte").intValue()); Assert.assertEquals("Deadpool", result.getValue("reader")); Assert.assertEquals("Lobo", new String((byte[]) result.getValue("stream"))); }
OracleTypeHandler implements TypeHandler { public void afterExecute(Statement stmt, QueryParameters processedInput, QueryParameters params) throws SQLException { Object value = null; Object convertedValue = null; Connection conn = stmt.getConnection(); for (String parameterName : params.keySet()) { value = params.getValue(parameterName); convertedValue = processedInput.getValue(parameterName); try { if (params.getType(parameterName) == MjdbcTypes.ARRAY) { if (value instanceof Object[] || value instanceof Collection) { if (convertedValue != null && MappingUtils.objectAssignableTo(convertedValue, "oracle.sql.ARRAY") == true) { MappingUtils.invokeFunction(convertedValue, "free", new Class[]{}, new Object[]{}); } } } else if (params.getType(parameterName) == MjdbcTypes.BLOB) { if (value instanceof String || value instanceof InputStream || value instanceof byte[]) { if (convertedValue != null && MappingUtils.objectAssignableTo(convertedValue, "oracle.sql.BLOB") == true) { MappingUtils.invokeFunction(convertedValue, "freeTemporary", new Class[]{}, new Object[]{}); } } } else if (params.getType(parameterName) == MjdbcTypes.CLOB) { if (value instanceof String || value instanceof InputStream || value instanceof byte[]) { if (convertedValue != null && MappingUtils.objectAssignableTo(convertedValue, "oracle.sql.CLOB") == true) { MappingUtils.invokeFunction(convertedValue, "freeTemporary", new Class[]{}, new Object[]{}); } } } else if (params.getType(parameterName) == MjdbcTypes.SQLXML) { if (value instanceof String || value instanceof InputStream || value instanceof byte[]) { } } } catch (MjdbcException ex) { logger.warning("Failed to process/close resource: " + parameterName + ". Might lead to resource leak!"); convertedValue = value; } } } OracleTypeHandler(Overrider overrider); QueryParameters processInput(Statement stmt, QueryParameters params); void afterExecute(Statement stmt, QueryParameters processedInput, QueryParameters params); QueryParameters processOutput(Statement stmt, QueryParameters params); List<QueryParameters> processOutput(Statement stmt, List<QueryParameters> paramsList); }
@Test public void testAfterExecute() throws Exception { QueryParameters processedParams = new QueryParameters(params); processedParams.set("array_list", processedParams.getValue("array")); processedParams.set("blob_byte", processedParams.getValue("blob")); processedParams.set("clob_byte", processedParams.getValue("clob")); processedParams.set("sqlXml_byte", processedParams.getValue("sqlXml")); new OracleTypeHandler(new Overrider()).afterExecute(stmt, processedParams, params); MappingUtils.invokeFunction(verify(array, never()), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(blob, never()), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(clob, never()), "free", new Class[]{}, new Object[]{}); }
OracleTypeHandler implements TypeHandler { public QueryParameters processOutput(Statement stmt, QueryParameters params) throws SQLException { Object value = null; Object convertedValue = null; int oracleCursorType = -1; try { Class oracleTypesClazz = Class.forName("oracle.jdbc.OracleTypes"); oracleCursorType = (Integer) MappingUtils.returnStaticField(oracleTypesClazz, "CURSOR"); } catch (ClassNotFoundException e) { logger.warning("Failed to process retrieve constant: oracle.jdbc.OracleTypes.CURSOR. Please check if Oracle JDBC Driver is present in class path"); } catch (MjdbcException e) { logger.warning("Failed to process retrieve constant: oracle.jdbc.OracleTypes.CURSOR. Please check if Oracle JDBC Driver is present in class path"); } for (String parameterName : params.keySet()) { value = params.getValue(parameterName); convertedValue = null; try { if (params.getType(parameterName) == MjdbcTypes.ARRAY) { if (value != null && MappingUtils.objectAssignableTo(value, "oracle.sql.ARRAY") == true) { convertedValue = MappingUtils.invokeFunction(value, "getArray", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(value, "free", new Class[]{}, new Object[]{}); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.BLOB) { if (value != null && MappingUtils.objectAssignableTo(value, "oracle.sql.BLOB") == true) { convertedValue = TypeHandlerUtils.readBlob(value, false); MappingUtils.invokeFunction(value, "freeTemporary", new Class[]{}, new Object[]{}); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.CLOB) { if (value != null && MappingUtils.objectAssignableTo(value, "oracle.sql.CLOB") == true) { convertedValue = new String(TypeHandlerUtils.readClob(value, false)); MappingUtils.invokeFunction(value, "freeTemporary", new Class[]{}, new Object[]{}); } else { convertedValue = value; } } else if (params.getType(parameterName) == oracleCursorType) { if (value instanceof ResultSet) { ResultSet rs = (ResultSet) value; convertedValue = MappingUtils.convertResultSet(rs); } else { convertedValue = value; } } else if (params.getType(parameterName) == MjdbcTypes.SQLXML) { convertedValue = value; } else { convertedValue = value; } } catch (MjdbcException ex) { logger.warning("Failed to process/close resource: " + parameterName + ". Might lead to resource leak!"); convertedValue = value; } params.updateValue(parameterName, convertedValue); } return params; } OracleTypeHandler(Overrider overrider); QueryParameters processInput(Statement stmt, QueryParameters params); void afterExecute(Statement stmt, QueryParameters processedInput, QueryParameters params); QueryParameters processOutput(Statement stmt, QueryParameters params); List<QueryParameters> processOutput(Statement stmt, List<QueryParameters> paramsList); }
@Test public void testProcessOutput() throws Exception { new OracleTypeHandler(new Overrider()).processOutput(stmt, params); verify(array, never()).getArray(); verify(blob, never()).getBinaryStream(); verify(clob, never()).getAsciiStream(); MappingUtils.invokeFunction(verify(array, never()), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(blob, never()), "free", new Class[]{}, new Object[]{}); MappingUtils.invokeFunction(verify(clob, never()), "free", new Class[]{}, new Object[]{}); } @Test public void testProcessOutputList() throws Exception { List<QueryParameters> paramsList = new ArrayList<QueryParameters>(); QueryParameters paramsClone = new QueryParameters(params); paramsList.add(new QueryParameters()); paramsList.add(params); paramsList.add(paramsClone); new OracleTypeHandler(new Overrider()).processOutput(stmt, paramsList); verify(array, never()).getArray(); verify(blob, never()).getBinaryStream(); verify(clob, never()).getAsciiStream(); }
CallableUtils { public static boolean isFunctionCall(String decodedSql) { Pattern regexPattern = null; Matcher regexMatcher = null; regexPattern = Pattern.compile(REGEX_IS_FUNCTION, Pattern.CASE_INSENSITIVE); regexMatcher = regexPattern.matcher(decodedSql); return regexMatcher.find(); } static boolean isFunctionCall(String decodedSql); static String getStoredProcedureShortNameFromSql(String decodedSql); static String getStoredProcedureFullName(String decodedSql); static QueryParameters updateDirections(QueryParameters original, QueryParameters source); static QueryParameters updateTypes(QueryParameters original, QueryParameters source); static QueryParameters updateDirectionsByName(QueryParameters original, QueryParameters source); static QueryParameters updateTypesByName(QueryParameters original, QueryParameters source); }
@Test public void testIsFunctionCall() throws Exception { Assert.assertEquals(true, CallableUtils.isFunctionCall("{? = call make_me_some_tea()}")); }
MidaoLogger extends Logger { @Override public void severe(String msg) { if (isSLF4jAvailable() == false) { super.severe(msg); } else { try { MappingUtils.invokeFunction(slfLogger, "error", new Class[]{String.class}, new Object[]{msg}); } catch (MjdbcException e) { setSLF4jAvailable(false); super.severe(msg); } } } private MidaoLogger(String name, String resourceBundleName); static MidaoLogger getLogger(String name); static MidaoLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); }
@Test public void testSevere() throws Exception { }
CallableUtils { public static String getStoredProcedureShortNameFromSql(String decodedSql) { String spName = null; Pattern regexPattern = null; Matcher regexMatcher = null; String procedureFullName = getStoredProcedureFullName(decodedSql); String[] procedurePath = procedureFullName.split("[.]"); if (procedurePath.length > 0) { spName = procedurePath[procedurePath.length - 1]; } else { throw new IllegalArgumentException(String.format(ERROR_SHORT_PROCEDURE_NAME_NOT_FOUND, procedureFullName)); } return spName; } static boolean isFunctionCall(String decodedSql); static String getStoredProcedureShortNameFromSql(String decodedSql); static String getStoredProcedureFullName(String decodedSql); static QueryParameters updateDirections(QueryParameters original, QueryParameters source); static QueryParameters updateTypes(QueryParameters original, QueryParameters source); static QueryParameters updateDirectionsByName(QueryParameters original, QueryParameters source); static QueryParameters updateTypesByName(QueryParameters original, QueryParameters source); }
@Test public void testGetStoredProcedureShortNameFromSql() throws Exception { Assert.assertEquals("function_name", CallableUtils.getStoredProcedureShortNameFromSql("{call schema.package.function_name()}")); }
CallableUtils { public static String getStoredProcedureFullName(String decodedSql) { String spName = null; Pattern regexPattern = null; Matcher regexMatcher = null; regexPattern = Pattern.compile(REGEX_PROCEDURE_FULL_NAME, Pattern.CASE_INSENSITIVE); regexMatcher = regexPattern.matcher(decodedSql); if (regexMatcher.find() == true) { spName = regexMatcher.group(); spName = spName.trim(); } else { throw new IllegalArgumentException(String.format(ERROR_FULL_PROCEDURE_NAME_NOT_FOUND, decodedSql)); } return spName; } static boolean isFunctionCall(String decodedSql); static String getStoredProcedureShortNameFromSql(String decodedSql); static String getStoredProcedureFullName(String decodedSql); static QueryParameters updateDirections(QueryParameters original, QueryParameters source); static QueryParameters updateTypes(QueryParameters original, QueryParameters source); static QueryParameters updateDirectionsByName(QueryParameters original, QueryParameters source); static QueryParameters updateTypesByName(QueryParameters original, QueryParameters source); }
@Test public void testGetStoredProcedureFullName() throws Exception { Assert.assertEquals("schema.package.function_name", CallableUtils.getStoredProcedureFullName("{call schema.package.function_name()}")); }
CallableUtils { public static QueryParameters updateDirections(QueryParameters original, QueryParameters source) { QueryParameters updatedParams = new QueryParameters(original); Integer position = null; String originalKey = null; if (source != null) { for (String sourceKey : source.keySet()) { position = source.getFirstPosition(sourceKey); if (position != null) { originalKey = original.getNameByPosition(position); if (updatedParams.containsKey(originalKey) == true) { updatedParams.updateDirection(originalKey, source.getDirection(sourceKey)); } } } } return updatedParams; } static boolean isFunctionCall(String decodedSql); static String getStoredProcedureShortNameFromSql(String decodedSql); static String getStoredProcedureFullName(String decodedSql); static QueryParameters updateDirections(QueryParameters original, QueryParameters source); static QueryParameters updateTypes(QueryParameters original, QueryParameters source); static QueryParameters updateDirectionsByName(QueryParameters original, QueryParameters source); static QueryParameters updateTypesByName(QueryParameters original, QueryParameters source); }
@Test public void testUpdateDirections() throws Exception { QueryParameters params = new QueryParameters(); params.set("first", "age"); params.set("second", "knowledge"); QueryParameters paramsDirections = new QueryParameters(); paramsDirections.set("first", "age", QueryParameters.Direction.IN); paramsDirections.set("second", "knowledge", QueryParameters.Direction.INOUT); Assert.assertEquals(QueryParameters.Direction.IN, params.getDirection("first")); Assert.assertEquals(QueryParameters.Direction.IN, params.getDirection("second")); params = CallableUtils.updateDirections(params, paramsDirections); Assert.assertEquals(QueryParameters.Direction.IN, params.getDirection("first")); Assert.assertEquals(QueryParameters.Direction.INOUT, params.getDirection("second")); }
CallableUtils { public static QueryParameters updateTypes(QueryParameters original, QueryParameters source) { QueryParameters updatedParams = new QueryParameters(original); Integer position = null; String originalKey = null; if (source != null) { for (String sourceKey : source.keySet()) { position = source.getFirstPosition(sourceKey); if (position != null) { originalKey = original.getNameByPosition(position); if (updatedParams.containsKey(originalKey) == true) { updatedParams.updateType(originalKey, source.getType(sourceKey)); } } } } return updatedParams; } static boolean isFunctionCall(String decodedSql); static String getStoredProcedureShortNameFromSql(String decodedSql); static String getStoredProcedureFullName(String decodedSql); static QueryParameters updateDirections(QueryParameters original, QueryParameters source); static QueryParameters updateTypes(QueryParameters original, QueryParameters source); static QueryParameters updateDirectionsByName(QueryParameters original, QueryParameters source); static QueryParameters updateTypesByName(QueryParameters original, QueryParameters source); }
@Test public void testUpdateTypes() throws Exception { QueryParameters params = new QueryParameters(); params.set("first", "age"); params.set("second", "knowledge"); QueryParameters paramsTypes = new QueryParameters(); paramsTypes.set("first", "age", 10); paramsTypes.set("second", "knowledge", 11); Assert.assertEquals(MjdbcTypes.OTHER, params.getType("first").intValue()); Assert.assertEquals(MjdbcTypes.OTHER, params.getType("second").intValue()); params = CallableUtils.updateTypes(params, paramsTypes); Assert.assertEquals(10, params.getType("first").intValue()); Assert.assertEquals(11, params.getType("second").intValue()); }
CallableUtils { public static QueryParameters updateDirectionsByName(QueryParameters original, QueryParameters source) { QueryParameters updatedParams = new QueryParameters(original); if (source != null) { for (String sourceKey : source.keySet()) { if (updatedParams.containsKey(sourceKey) == true) { updatedParams.updateDirection(sourceKey, source.getDirection(sourceKey)); } } } return updatedParams; } static boolean isFunctionCall(String decodedSql); static String getStoredProcedureShortNameFromSql(String decodedSql); static String getStoredProcedureFullName(String decodedSql); static QueryParameters updateDirections(QueryParameters original, QueryParameters source); static QueryParameters updateTypes(QueryParameters original, QueryParameters source); static QueryParameters updateDirectionsByName(QueryParameters original, QueryParameters source); static QueryParameters updateTypesByName(QueryParameters original, QueryParameters source); }
@Test public void testUpdateDirectionsByName() throws Exception { QueryParameters params = new QueryParameters(); params.set("first", "age"); params.set("second", "knowledge"); QueryParameters paramsDirections = new QueryParameters(); paramsDirections.set("first", "age", QueryParameters.Direction.IN); paramsDirections.set("second", "knowledge", QueryParameters.Direction.INOUT); Assert.assertEquals(QueryParameters.Direction.IN, params.getDirection("first")); Assert.assertEquals(QueryParameters.Direction.IN, params.getDirection("second")); params = CallableUtils.updateDirections(params, paramsDirections); Assert.assertEquals(QueryParameters.Direction.IN, params.getDirection("first")); Assert.assertEquals(QueryParameters.Direction.INOUT, params.getDirection("second")); }
CallableUtils { public static QueryParameters updateTypesByName(QueryParameters original, QueryParameters source) { QueryParameters updatedParams = new QueryParameters(original); if (source != null) { for (String sourceKey : source.keySet()) { if (updatedParams.containsKey(sourceKey) == true) { updatedParams.updateType(sourceKey, source.getType(sourceKey)); } } } return updatedParams; } static boolean isFunctionCall(String decodedSql); static String getStoredProcedureShortNameFromSql(String decodedSql); static String getStoredProcedureFullName(String decodedSql); static QueryParameters updateDirections(QueryParameters original, QueryParameters source); static QueryParameters updateTypes(QueryParameters original, QueryParameters source); static QueryParameters updateDirectionsByName(QueryParameters original, QueryParameters source); static QueryParameters updateTypesByName(QueryParameters original, QueryParameters source); }
@Test public void testUpdateTypesByName() throws Exception { QueryParameters params = new QueryParameters(); params.set("first", "age"); params.set("second", "knowledge"); QueryParameters paramsTypes = new QueryParameters(); paramsTypes.set("first", "age", 10); paramsTypes.set("second", "knowledge", 11); Assert.assertEquals(MjdbcTypes.OTHER, params.getType("first").intValue()); Assert.assertEquals(MjdbcTypes.OTHER, params.getType("second").intValue()); params = CallableUtils.updateTypes(params, paramsTypes); Assert.assertEquals(10, params.getType("first").intValue()); Assert.assertEquals(11, params.getType("second").intValue()); }
MappingUtils { public static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors) { Map<String, Object> resultMap = new HashMap<String, Object>(); Object propertyValue = null; for (PropertyDescriptor property : propertyDescriptors) { propertyValue = callGetter(inputParameter, property); if ("class".equals(property.getName()) == false) { resultMap.put(property.getName(), propertyValue); } } return resultMap; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testToMap() throws Exception { int age = 5; String name = "whiskers"; Cat cat = new Cat(); cat.setAge(age); cat.setName(name); Map<String, Object> map = MappingUtils.toMap(cat, MappingUtils.propertyDescriptors(cat.getClass())); Assert.assertEquals(cat.getAge(), map.get("age")); Assert.assertEquals(cat.getName(), map.get("name")); }
MappingUtils { public static PropertyDescriptor[] propertyDescriptors(Class<?> clazz) { BeanInfo beanInfo = null; try { beanInfo = Introspector.getBeanInfo(clazz); } catch (IntrospectionException ex) { throw new IllegalArgumentException( "Bean introspection failed: " + ex.getMessage()); } return beanInfo.getPropertyDescriptors(); } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testPropertyDescriptors() throws Exception { PropertyDescriptor props[] = MappingUtils.propertyDescriptors(Cat.class); Assert.assertEquals("age", props[0].getName()); Assert.assertEquals("name", props[2].getName()); }
MappingUtils { public static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz) { PropertyDescriptor[] properties = propertyDescriptors(clazz); Map<String, PropertyDescriptor> mappedProperties = new HashMap<String, PropertyDescriptor>(); for (PropertyDescriptor property : properties) { if ("class".equals(property.getName()) == false) { mappedProperties.put(property.getName(), property); } } return mappedProperties; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testMapPropertyDescriptors() throws Exception { Map<String, PropertyDescriptor> mapProps = MappingUtils.mapPropertyDescriptors(Cat.class); Assert.assertEquals("age", mapProps.get("age").getName()); Assert.assertEquals("name", mapProps.get("name").getName()); }
MappingUtils { public static Object callGetter(Object target, PropertyDescriptor prop) { Object result = null; Method getter = prop.getReadMethod(); if (getter == null) { throw new RuntimeException("No read method for bean property " + target.getClass() + " " + prop.getName()); } try { result = getter.invoke(target, new Object[0]); } catch (InvocationTargetException e) { throw new RuntimeException("Couldn't invoke method: " + getter, e); } catch (IllegalArgumentException e) { throw new RuntimeException( "Couldn't invoke method with 0 arguments: " + getter, e); } catch (IllegalAccessException e) { throw new RuntimeException("Couldn't invoke method: " + getter, e); } return result; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testCallGetter() throws Exception { int age = 5; String name = "whiskers"; Cat cat = new Cat(); cat.setAge(age); cat.setName(name); Assert.assertEquals(age, MappingUtils.callGetter(cat, MappingUtils.propertyDescriptors(cat.getClass())[0])); Assert.assertEquals(name, MappingUtils.callGetter(cat, MappingUtils.propertyDescriptors(cat.getClass())[2])); }
MidaoLogger extends Logger { public static boolean isSLF4jAvailable() { if (SLF4jAvailable == null) { try { Class.forName("org.slf4j.Logger"); setSLF4jAvailable(true); } catch (ClassNotFoundException e) { setSLF4jAvailable(false); } } return SLF4jAvailable; } private MidaoLogger(String name, String resourceBundleName); static MidaoLogger getLogger(String name); static MidaoLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); }
@Test public void testIsSLF4jAvailable() throws Exception { Assert.assertEquals(false, MidaoLogger.isSLF4jAvailable()); }
MappingUtils { public static void callSetter(Object target, PropertyDescriptor prop, Object value) { Method setter = prop.getWriteMethod(); if (setter == null) { return; } try { setter.invoke(target, new Object[]{value}); } catch (IllegalArgumentException e) { throw new RuntimeException( "Cannot set " + prop.getName() + ": " + e.getMessage(), e); } catch (IllegalAccessException e) { throw new RuntimeException( "Cannot set " + prop.getName() + ": " + e.getMessage(), e); } catch (InvocationTargetException e) { throw new RuntimeException( "Cannot set " + prop.getName() + ": " + e.getMessage(), e); } } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testCallSetter() throws Exception { int age = 5; String name = "whiskers"; Cat cat = new Cat(); MappingUtils.callSetter(cat, MappingUtils.propertyDescriptors(cat.getClass())[0], age); MappingUtils.callSetter(cat, MappingUtils.propertyDescriptors(cat.getClass())[2], name); Assert.assertEquals(age, cat.getAge()); Assert.assertEquals(name, cat.getName()); }
MappingUtils { public static List<QueryParameters> convertResultSet(ResultSet rs) throws SQLException { List<QueryParameters> result = new ArrayList<QueryParameters>(); String columnName = null; while (rs.next() == true) { QueryParameters params = new QueryParameters(); ResultSetMetaData rsmd = rs.getMetaData(); int cols = rsmd.getColumnCount(); for (int i = 1; i <= cols; i++) { columnName = rsmd.getColumnLabel(i); if (null == columnName || 0 == columnName.length()) { columnName = rsmd.getColumnName(i); } params.set(columnName, rs.getObject(i)); params.updatePosition(columnName, i - 1); } result.add(params); } return result; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testConvertResultSet() throws Exception { ResultSet rs = mock(ResultSet.class); ResultSetMetaData rsmd = mock(ResultSetMetaData.class); when(rsmd.getColumnCount()).thenReturn(1); when(rsmd.getColumnLabel(1)).thenReturn("name"); when(rs.getMetaData()).thenReturn(rsmd); String name1 = "Bruce Lee"; String name2 = "Jackie Chan"; String name3 = "Jet Lee"; when(rs.next()).thenReturn(true).thenReturn(true).thenReturn(true).thenReturn(false); when(rs.getObject(1)).thenReturn(name1).thenReturn(name2).thenReturn(name3); List<QueryParameters> paramsList = MappingUtils.convertResultSet(rs); Assert.assertEquals(3, paramsList.size()); Assert.assertEquals(name1, paramsList.get(0).getValue("name")); Assert.assertEquals(name2, paramsList.get(1).getValue("name")); Assert.assertEquals(name3, paramsList.get(2).getValue("name")); }
MappingUtils { public static <T> T newInstance(Class<T> clazz) throws MjdbcException { try { return clazz.newInstance(); } catch (InstantiationException ex) { throw new MjdbcException( "Failed to create instance: " + clazz.getName() + " - " + ex.getMessage()); } catch (IllegalAccessException ex) { throw new MjdbcException( "Failed to create instance: " + clazz.getName() + " - " + ex.getMessage()); } } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testNewInstance() throws Exception { Cat cat = MappingUtils.newInstance(Cat.class); Assert.assertEquals(true, cat != null && cat instanceof Cat); }
MappingUtils { public static void invokeConnectionSetter(Connection conn, String functionName, Object value) throws MjdbcException { if (MjdbcConstants.connectionBeanDescription.containsKey(functionName) == true) { MappingUtils.callSetter(conn, MjdbcConstants.connectionBeanDescription.get(functionName), value); } else { throw new MjdbcException(String.format("Property %s wasn't found", functionName)); } } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testInvokeConnectionSetter() throws MjdbcException { MappingUtils.invokeConnectionSetter(conn, "readOnly", false); MappingUtils.invokeConnectionSetter(conn, "catalog", ""); MappingUtils.invokeConnectionSetter(conn, "typeMap", null); MappingUtils.invokeConnectionSetter(conn, "holdability", 0); MappingUtils.invokeConnectionSetter(conn, "clientInfo", null); MappingUtils.invokeFunction(verify(conn, times(1)), "setReadOnly", new Class[]{boolean.class}, new Object[]{any(boolean.class)}); MappingUtils.invokeFunction(verify(conn, times(1)), "setCatalog", new Class[]{String.class}, new Object[]{""}); MappingUtils.invokeFunction(verify(conn, times(1)), "setTypeMap", new Class[]{Map.class}, new Object[]{any(Map.class)}); MappingUtils.invokeFunction(verify(conn, times(1)), "setHoldability", new Class[]{int.class}, new Object[]{any(int.class)}); MappingUtils.invokeFunction(verify(conn, times(1)), "setClientInfo", new Class[]{Properties.class}, new Object[]{any(Properties.class)}); }
MappingUtils { public static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values) throws MjdbcException { Object result = null; try { Method method = object.getClass().getMethod(functionName, parameters); method.setAccessible(true); result = method.invoke(object, values); } catch (Exception ex) { throw new MjdbcException(ex); } return result; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testInvokeFunction() throws MjdbcException { Assert.assertEquals(true, MappingUtils.invokeFunction("", "isEmpty", new Class[]{}, new Object[]{})); Assert.assertEquals(false, MappingUtils.invokeFunction("bla", "isEmpty", new Class[]{}, new Object[]{})); }
MappingUtils { public static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values) throws MjdbcException { Object result = null; try { Method method = clazz.getMethod(functionName, parameters); method.setAccessible(true); result = method.invoke(null, values); } catch (Exception ex) { throw new MjdbcException(ex); } return result; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testInvokeStaticFunction() throws MjdbcException { Assert.assertEquals("1", MappingUtils.invokeStaticFunction(String.class, "valueOf", new Class[]{int.class}, new Object[]{1})); Assert.assertEquals("3", MappingUtils.invokeStaticFunction(String.class, "valueOf", new Class[]{int.class}, new Object[]{3})); }
MappingUtils { public static boolean hasFunction(Object object, String functionName, Class[] parameters) { boolean result = false; try { Method method = object.getClass().getMethod(functionName, parameters); if (method != null) { result = true; } } catch (NoSuchMethodException ex) { result = false; } return result; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testHasFunction() { Assert.assertEquals(true, MappingUtils.hasFunction("", "length", new Class[]{})); Assert.assertEquals(false, MappingUtils.hasFunction("", "bla", new Class[]{})); }
MappingUtils { public static boolean objectImplements(Object object, String interfaceClass) { AssertUtils.assertNotNull(object); boolean result = false; Class[] interfaces = object.getClass().getInterfaces(); for (int i = 0; i < interfaces.length; i++) { if (interfaces[i].getName().equals(interfaceClass) == true) { result = true; break; } } return result; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testObjectImplements() { Assert.assertEquals(true, MappingUtils.objectImplements(conn, "java.sql.Connection")); Assert.assertEquals(true, MappingUtils.objectImplements(conn, "org.mockito.cglib.proxy.Factory")); Assert.assertEquals(false, MappingUtils.objectImplements(conn, "com.some.bla.bla")); }
MappingUtils { public static boolean objectExtends(Object object, String superClassName) { AssertUtils.assertNotNull(object); boolean result = false; Class superClass = object.getClass().getSuperclass(); if (superClass.getName().equals(superClassName) == true) { result = true; } return result; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testObjectExtends() { Assert.assertEquals(true, MappingUtils.objectExtends(new Integer(0), "java.lang.Number")); Assert.assertEquals(false, MappingUtils.objectExtends(new Integer(0), "java.lang.Comparable")); }
MappingUtils { public static Object returnStaticField(Class clazz, String fieldName) throws MjdbcException { Object result = null; Field field = null; try { field = clazz.getField(fieldName); result = field.get(null); } catch (NoSuchFieldException ex) { throw new MjdbcException(ex); } catch (IllegalAccessException ex) { throw new MjdbcException(ex); } return result; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testReturnStaticField() throws MjdbcException { Assert.assertEquals(Integer.SIZE, MappingUtils.returnStaticField(Integer.class, "SIZE")); Assert.assertEquals(Integer.MAX_VALUE, MappingUtils.returnStaticField(Integer.class, "MAX_VALUE")); }
MidaoLogger extends Logger { public static boolean isSLF4jImplementationAvailable() { if (SLF4jImplementationAvailable == null) { if (isSLF4jAvailable() == true) { try { Object obj = MappingUtils.invokeStaticFunction(Class.forName("org.slf4j.LoggerFactory"), "getILoggerFactory", new Class[]{}, new Object[]{}); if (obj.getClass().getSimpleName().equals("NOPLoggerFactory") == true) { SLF4jImplementationAvailable = false; } else { SLF4jImplementationAvailable = true; } } catch (MjdbcException e) { SLF4jImplementationAvailable = false; } catch (ClassNotFoundException e) { SLF4jImplementationAvailable = false; } } else { SLF4jImplementationAvailable = false; } } return SLF4jImplementationAvailable; } private MidaoLogger(String name, String resourceBundleName); static MidaoLogger getLogger(String name); static MidaoLogger getLogger(Class clazz); @Override void info(String msg); @Override void warning(String msg); @Override void severe(String msg); static boolean isSLF4jAvailable(); static boolean isSLF4jImplementationAvailable(); }
@Test public void testIsSLF4jImplementationAvailable() throws Exception { Assert.assertEquals(false, MidaoLogger.isSLF4jImplementationAvailable()); }
MappingUtils { public static boolean objectInstanceOf(Object object, String className) { AssertUtils.assertNotNull(object); boolean result = false; Class clazz = object.getClass(); if (clazz.getName().equals(className) == true) { result = true; } return result; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testObjectInstanceOf() { Assert.assertEquals(true, MappingUtils.objectInstanceOf("", "java.lang.String")); Assert.assertEquals(true, MappingUtils.objectInstanceOf(new Integer(0), "java.lang.Integer")); Assert.assertEquals(false, MappingUtils.objectInstanceOf(new Integer(0), "java.lang.Number")); }
MappingUtils { public static boolean objectAssignableTo(Object object, String className) throws MjdbcException { AssertUtils.assertNotNull(object); boolean result = false; Class clazz = null; try { clazz = Class.forName(className); } catch (ClassNotFoundException ex) { throw new MjdbcException(ex); } result = clazz.isAssignableFrom(object.getClass()); return result; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testObjectAssignableTo() throws MjdbcException { Assert.assertEquals(true, MappingUtils.objectAssignableTo("", "java.lang.String")); Assert.assertEquals(true, MappingUtils.objectAssignableTo(new Integer(0), "java.lang.Integer")); Assert.assertEquals(true, MappingUtils.objectAssignableTo(new Integer(0), "java.lang.Number")); Assert.assertEquals(false, MappingUtils.objectAssignableTo(new Integer(0), "java.lang.Double")); }
MappingUtils { public static boolean isCustomBean(Object value) { assertNotNull(value); return !value.getClass().getName().startsWith("java"); } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testIsCustomBean() { Assert.assertEquals(true, MappingUtils.isCustomBean(new Cat())); Assert.assertEquals(false, MappingUtils.isCustomBean(new String())); }
MappingUtils { public static boolean isPrimitive(Object value) { if (value == null) { return true; } else if (value.getClass().isPrimitive() == true) { return true; } else if (Integer.class.isInstance(value)) { return true; } else if (Long.class.isInstance(value)) { return true; } else if (Double.class.isInstance(value)) { return true; } else if (Float.class.isInstance(value)) { return true; } else if (Short.class.isInstance(value)) { return true; } else if (Byte.class.isInstance(value)) { return true; } else if (Character.class.isInstance(value)) { return true; } else if (Boolean.class.isInstance(value)) { return true; } else if (BigDecimal.class.isInstance(value)) { return true; } else if (BigInteger.class.isInstance(value)) { return true; } return false; } static Map<String, Object> toMap(Object inputParameter, PropertyDescriptor[] propertyDescriptors); static PropertyDescriptor[] propertyDescriptors(Class<?> clazz); static Map<String, PropertyDescriptor> mapPropertyDescriptors(Class<?> clazz); static Object callGetter(Object target, PropertyDescriptor prop); static void callSetter(Object target, PropertyDescriptor prop, Object value); static List<QueryParameters> convertResultSet(ResultSet rs); static T newInstance(Class<T> clazz); static void invokeConnectionSetter(Connection conn, String functionName, Object value); static Object invokeFunction(Object object, String functionName, Class[] parameters, Object[] values); static Object invokeStaticFunction(Class clazz, String functionName, Class[] parameters, Object[] values); static boolean hasFunction(Object object, String functionName, Class[] parameters); static boolean objectImplements(Object object, String interfaceClass); static boolean objectExtends(Object object, String superClassName); static boolean objectInstanceOf(Object object, String className); static boolean objectAssignableTo(Object object, String className); static Object returnStaticField(Class clazz, String fieldName); static Object returnField(Object object, String fieldName); static boolean isPrimitive(Object value); static boolean isCustomBean(Object value); }
@Test public void testIsPrimitive() { Assert.assertTrue(MappingUtils.isPrimitive(1)); Assert.assertTrue(MappingUtils.isPrimitive(new Integer(1))); Assert.assertFalse(MappingUtils.isPrimitive("")); }
InputUtils { public static void defineOrder(ProcessedInput processedInput, QueryParameters parameters) { String parameterName = null; for (int i = 0; i < processedInput.getAmountOfParameters(); i++) { parameterName = processedInput.getParameterName(i); if (parameterName != null) { parameters.updatePosition(parameterName, i); } } } static void defineOrder(ProcessedInput processedInput, QueryParameters parameters); static String getClassName(Map<String, Object> map); static void setClassName(Map<String, Object> map, String className); static boolean isClassNameKey(String key); static String addClassName(String className, String key); static String removeClassName(String classNameKey); static String getParameterPrefix(); static String addParameterPrefix(String str); static String removeParameterPrefix(String str); }
@Test public void testDefineOrder() throws Exception { QueryParameters params = new QueryParameters(); params.set("name", "whiskers"); params.set("age", 10); ProcessedInput input = new ProcessedInput(""); input.addParameter("age", 10, 12); input.addParameter("name", 14, 15); Assert.assertEquals(0, params.getFirstPosition("name").intValue()); Assert.assertEquals(1, params.getFirstPosition("age").intValue()); InputUtils.defineOrder(input, params); Assert.assertEquals(1, params.getFirstPosition("name").intValue()); Assert.assertEquals(0, params.getFirstPosition("age").intValue()); }
InputUtils { public static String getClassName(Map<String, Object> map) { String className = null; if (map.containsKey(MAP_CLASS_NAME) == true) { className = (String) map.get(MAP_CLASS_NAME); } return className; } static void defineOrder(ProcessedInput processedInput, QueryParameters parameters); static String getClassName(Map<String, Object> map); static void setClassName(Map<String, Object> map, String className); static boolean isClassNameKey(String key); static String addClassName(String className, String key); static String removeClassName(String classNameKey); static String getParameterPrefix(); static String addParameterPrefix(String str); static String removeParameterPrefix(String str); }
@Test public void testGetClassName() throws Exception { Map<String, Object> map = new HashMap<String, Object>(); InputUtils.setClassName(map, "cat"); Assert.assertEquals("cat", InputUtils.getClassName(map)); }
InputUtils { public static void setClassName(Map<String, Object> map, String className) { String processedClassName = className; if (processedClassName != null) { processedClassName = processedClassName.replaceAll("\\.", "_"); } map.put(MAP_CLASS_NAME, processedClassName); } static void defineOrder(ProcessedInput processedInput, QueryParameters parameters); static String getClassName(Map<String, Object> map); static void setClassName(Map<String, Object> map, String className); static boolean isClassNameKey(String key); static String addClassName(String className, String key); static String removeClassName(String classNameKey); static String getParameterPrefix(); static String addParameterPrefix(String str); static String removeParameterPrefix(String str); }
@Test public void testSetClassName() throws Exception { Map<String, Object> map = new HashMap<String, Object>(); InputUtils.setClassName(map, "cat"); Assert.assertEquals("cat", InputUtils.getClassName(map)); InputUtils.setClassName(map, "hot.dog"); Assert.assertEquals("hot_dog", InputUtils.getClassName(map)); }
InputUtils { public static boolean isClassNameKey(String key) { boolean equals = false; if (MAP_CLASS_NAME.equals(key) == true) { equals = true; } return equals; } static void defineOrder(ProcessedInput processedInput, QueryParameters parameters); static String getClassName(Map<String, Object> map); static void setClassName(Map<String, Object> map, String className); static boolean isClassNameKey(String key); static String addClassName(String className, String key); static String removeClassName(String classNameKey); static String getParameterPrefix(); static String addParameterPrefix(String str); static String removeParameterPrefix(String str); }
@Test public void testIsClassNameKey() throws Exception { Map<String, Object> map = new HashMap<String, Object>(); InputUtils.setClassName(map, "cat"); Assert.assertEquals(true, InputUtils.isClassNameKey(map.keySet().toArray(new String[]{})[0])); }
InputUtils { public static String addClassName(String className, String key) { return className.toLowerCase() + "." + key.toLowerCase(); } static void defineOrder(ProcessedInput processedInput, QueryParameters parameters); static String getClassName(Map<String, Object> map); static void setClassName(Map<String, Object> map, String className); static boolean isClassNameKey(String key); static String addClassName(String className, String key); static String removeClassName(String classNameKey); static String getParameterPrefix(); static String addParameterPrefix(String str); static String removeParameterPrefix(String str); }
@Test public void testAddClassName() throws Exception { String className = "cat"; String key = "name"; String separator = "."; String result = InputUtils.addClassName(className, key); Assert.assertEquals(className + separator + key, result); }
InputUtils { public static String removeClassName(String classNameKey) { String[] splitKey = classNameKey.split("[.]"); String resultString = ""; for (int i = 1; i < splitKey.length; i++) { resultString = resultString.concat(splitKey[i]); if ((i + 1) < splitKey.length) { resultString = resultString.concat("."); } } if (resultString.length() == 0) { resultString = classNameKey; } return resultString; } static void defineOrder(ProcessedInput processedInput, QueryParameters parameters); static String getClassName(Map<String, Object> map); static void setClassName(Map<String, Object> map, String className); static boolean isClassNameKey(String key); static String addClassName(String className, String key); static String removeClassName(String classNameKey); static String getParameterPrefix(); static String addParameterPrefix(String str); static String removeParameterPrefix(String str); }
@Test public void testRemoveClassName() throws Exception { String className = "cat"; String key = "name"; String separator = "."; String result = InputUtils.removeClassName(className + separator + key); Assert.assertEquals(key, result); }
Overrider { public void overrideOnce(String operation, Object value) { this.overrideOnce.put(operation, value); } Overrider(); Overrider(Overrider overrider); void overrideOnce(String operation, Object value); void override(String operation, Object value); void removeOverride(String operation); boolean hasOverride(String operation); Object getOverride(String operation); }
@Test public void testOverrideOnce() throws Exception { String name = "value"; String value = "once"; overrider.overrideOnce(name, value); Assert.assertEquals(overrider.hasOverride(name), true); Assert.assertEquals(overrider.getOverride(name), value); Assert.assertEquals(overrider.getOverride(name), null); Assert.assertEquals(overrider.hasOverride(name), false); }
InputUtils { public static String getParameterPrefix() { return PARAMETER_PREFIX; } static void defineOrder(ProcessedInput processedInput, QueryParameters parameters); static String getClassName(Map<String, Object> map); static void setClassName(Map<String, Object> map, String className); static boolean isClassNameKey(String key); static String addClassName(String className, String key); static String removeClassName(String classNameKey); static String getParameterPrefix(); static String addParameterPrefix(String str); static String removeParameterPrefix(String str); }
@Test public void testGetParameterPrefix() throws Exception { Assert.assertEquals(":", InputUtils.getParameterPrefix()); }
InputUtils { public static String addParameterPrefix(String str) { return getParameterPrefix() + str; } static void defineOrder(ProcessedInput processedInput, QueryParameters parameters); static String getClassName(Map<String, Object> map); static void setClassName(Map<String, Object> map, String className); static boolean isClassNameKey(String key); static String addClassName(String className, String key); static String removeClassName(String classNameKey); static String getParameterPrefix(); static String addParameterPrefix(String str); static String removeParameterPrefix(String str); }
@Test public void testAddParameterPrefix() throws Exception { String key = "cat.name"; Assert.assertEquals(InputUtils.getParameterPrefix() + key, InputUtils.addParameterPrefix(key)); }
InputUtils { public static String removeParameterPrefix(String str) { return str.substring(getParameterPrefix().length()); } static void defineOrder(ProcessedInput processedInput, QueryParameters parameters); static String getClassName(Map<String, Object> map); static void setClassName(Map<String, Object> map, String className); static boolean isClassNameKey(String key); static String addClassName(String className, String key); static String removeClassName(String classNameKey); static String getParameterPrefix(); static String addParameterPrefix(String str); static String removeParameterPrefix(String str); }
@Test public void testRemoveParameterPrefix() throws Exception { String key = "cat.name"; Assert.assertEquals(key, InputUtils.removeParameterPrefix(InputUtils.addParameterPrefix(key))); }
AbstractQueryInputHandler extends AbstractInputHandler<T> { public abstract QueryParameters update(Object[] outParamValues); protected AbstractQueryInputHandler(QueryInputProcessor processor); abstract QueryParameters update(Object[] outParamValues); abstract String getQueryString(); abstract QueryParameters getQueryParameters(); }
@Test public void testUpdate() throws Exception { String favouritePast = "superman"; String favouritePresent = "hulk"; invokeQueries(); verify(inputHandler, never()).update(any(Object[].class)); QueryInputHandler queryInputHandler = new QueryInputHandler("SELECT strength from HEROES WHEN name = :favourite", new QueryParameters().set("favourite", favouritePast, QueryParameters.Direction.INOUT)); Assert.assertEquals(favouritePast, queryInputHandler.getQueryParameters().getValue("favourite")); QueryParameters updateParams = queryInputHandler.update(new Object[]{favouritePresent}); Assert.assertEquals(favouritePresent, updateParams.getValue("favourite")); }
QueryInputHandler extends AbstractQueryInputHandler<QueryParameters> { @Override public QueryParameters getQueryParameters() { return this.queryParameters; } QueryInputHandler(String encodedQuery, QueryParameters inputParameter); QueryInputHandler(String encodedQuery, QueryParameters inputParameter, String parameterName); protected QueryInputHandler(QueryInputProcessor processor, String encodedQuery, QueryParameters inputParameter, String parameterName); @Override String getQueryString(); @Override QueryParameters getQueryParameters(); @Override QueryParameters update(Object[] outParamValues); }
@Test public void testGeneral() { QueryParameters params = new QueryParameters(); params.set("boss", "artie"); params.set("agent", "myka"); QueryInputHandler input = new QueryInputHandler("SELECT * FROM AGENTS WHERE name = :boss OR name = :agent", params); Assert.assertEquals(false, params == input.getQueryParameters()); Assert.assertEquals(params.getValue("boss"), input.getQueryParameters().getValue("boss")); Assert.assertEquals(params.getValue("agent"), input.getQueryParameters().getValue("agent")); }
AbstractInputHandler implements InputHandler<T> { protected Map<String, Object> mergeMaps(String encodedQuery, List<Map<String, Object>> mapList, boolean addPrefix) { Map<String, Object> mergedMap = new HashMap<String, Object>(); String className = null; for (Map<String, Object> map : mapList) { className = InputUtils.getClassName(map); for (String key : map.keySet()) { if (InputUtils.isClassNameKey(key) == false) { if (className != null && addPrefix == true) { mergedMap.put(InputUtils.addClassName(className.toLowerCase(), key.toLowerCase()), map.get(key)); } else { mergedMap.put(key.toLowerCase(), map.get(key)); } } } } return mergedMap; } protected AbstractInputHandler(QueryInputProcessor processor); }
@Test public void testMergeMaps() throws Exception { TestAbstractInputHandler testInputHandler = new TestAbstractInputHandler(); Map<String, Object> map1 = new HashMap<String, Object>(); map1.put("strength", 50); map1.put("intellect", 200); InputUtils.setClassName(map1, "ironman"); Map<String, Object> map2 = new HashMap<String, Object>(); map2.put("strength", 55); map2.put("intellect", 120); InputUtils.setClassName(map2, "c.america"); Map<String, Object> map3 = new HashMap<String, Object>(); map3.put("strength", 95); map3.put("intellect", 120); InputUtils.setClassName(map3, "thor"); Map<String, Object> map = new HashMap<String, Object>(); map.put("strength", 99999); map.put("intellect", 5); InputUtils.setClassName(map, "hulk"); Map<String, Object> avengers = testInputHandler.mergeMaps("", Arrays.asList(map1, map2, map3, map), true); Object[] expected = new Object[]{"ironman.strength", "ironman.intellect", "c_america.strength", "c_america.intellect", "thor.strength", "thor.intellect", "hulk.strength", "hulk.intellect"}; Arrays.sort(expected); Object[] returned = avengers.keySet().toArray(); Arrays.sort(returned); org.junit.Assert.assertArrayEquals(expected, returned); }
AbstractInputHandler implements InputHandler<T> { protected void validateSqlString(String originalSql) { if (originalSql == null) { throw new IllegalArgumentException(ERROR_SQL_QUERY_NULL); } if (processor.hasUnnamedParameters(originalSql) == true) { throw new IllegalArgumentException(ERROR_FOUND_UNNAMED_PARAMETER); } } protected AbstractInputHandler(QueryInputProcessor processor); }
@Test public void testValidateSqlString() throws Exception { TestAbstractInputHandler testInputHandler = new TestAbstractInputHandler(); try { testInputHandler.validateSqlString(null); fail(); } catch (IllegalArgumentException ex) { } try { testInputHandler.validateSqlString("some acceptable string"); } catch (IllegalArgumentException ex) { fail(); } try { testInputHandler.validateSqlString("SELECT GOLD from BANK where AMOUNT > :expectedGoldAmount AND ADDRESS = ?"); fail(); } catch (IllegalArgumentException ex) { } try { testInputHandler.validateSqlString("SELECT GOLD from BANK where AMOUNT > :expectedGoldAmount AND ADDRESS = :someAddress"); } catch (IllegalArgumentException ex) { fail(); } }
AbstractNamedInputHandler extends AbstractInputHandler<T> { protected Map<String, Object> updateMap(Map<String, Object> target, Map<String, Object> source) { Map<String, Object> resultMap = new HashMap<String, Object>(target); String keyWOClassName = null; for (String sourceKey : source.keySet()) { keyWOClassName = InputUtils.removeClassName(sourceKey); if (target.containsKey(sourceKey) == true) { resultMap.put(sourceKey, source.get(sourceKey)); } else if (target.containsKey(keyWOClassName) == true) { resultMap.put(keyWOClassName, source.get(keyWOClassName)); } } return resultMap; } protected AbstractNamedInputHandler(QueryInputProcessor processor); abstract T updateInput(QueryParameters updatedInput); abstract String getEncodedQueryString(); abstract String getQueryString(); abstract QueryParameters getQueryParameters(); }
@Test public void testUpdateMap() throws Exception { Map<String, Object> washMap = new HashMap<String, Object>(); washMap.put("name", "Wash"); washMap.put("skill", "Pilot"); washMap.put("number", 7); Map<String, Object> jayneMap = new HashMap<String, Object>(); jayneMap.put("name", "Jayne"); jayneMap.put("skill", "Hired gun"); jayneMap.put("number", 5); Map<String, Object> jayneMapClone = new TestNamedInputHandler<Character>().updateMap(washMap, jayneMap); Assert.assertEquals("Jayne", jayneMapClone.get("name")); Assert.assertEquals("Hired gun", jayneMapClone.get("skill")); Assert.assertEquals(5, ((Integer) jayneMapClone.get("number")).intValue()); }
AbstractNamedInputHandler extends AbstractInputHandler<T> { protected T updateBean(T object, Map<String, Object> source) { T clone = copyProperties(object); updateProperties(clone, source); return clone; } protected AbstractNamedInputHandler(QueryInputProcessor processor); abstract T updateInput(QueryParameters updatedInput); abstract String getEncodedQueryString(); abstract String getQueryString(); abstract QueryParameters getQueryParameters(); }
@Test public void testUpdateBean() throws Exception { Character mal = new Character(); mal.setName("Mal"); mal.setSkill("Sergeant/Smuggler"); mal.setNumber(57); Map<String, Object> zoeMap = new HashMap<String, Object>(); zoeMap.put("name", "Zoe"); zoeMap.put("skill", "Corporal/Warrior woman"); zoeMap.put("number", 57); Character zoe = new TestNamedInputHandler<Character>().updateBean(mal, zoeMap); Assert.assertEquals("Zoe", zoe.getName()); Assert.assertEquals("Corporal/Warrior woman", zoe.getSkill()); Assert.assertEquals(57, zoe.getNumber().intValue()); }
BeanListOutputHandler extends AbstractOutputListHandler<T> { public List<T> handle(List<QueryParameters> outputList) throws MjdbcException { return this.outputProcessor.toBeanList(outputList, this.type); } BeanListOutputHandler(Class<T> type); BeanListOutputHandler(Class<T> type, QueryOutputProcessor processor); List<T> handle(List<QueryParameters> outputList); }
@Test public void testHandle() throws MjdbcException { List<Character> result = new BeanListOutputHandler<Character>(Character.class).handle(paramsList); Assert.assertArrayEquals(new Object[]{"jack", "sheriff", 36}, new Object[]{result.get(0).getName(), result.get(0).getOccupation(), result.get(0).getAge()}); Assert.assertArrayEquals(new Object[]{"henry", "mechanic", 36}, new Object[]{result.get(1).getName(), result.get(1).getOccupation(), result.get(1).getAge()}); Assert.assertArrayEquals(new Object[]{"alison", "agent", 30}, new Object[]{result.get(2).getName(), result.get(2).getOccupation(), result.get(2).getAge()}); } @Test public void testEmpty() throws MjdbcException { List<Character> result = new BeanListOutputHandler<Character>(Character.class).handle(emptyList); Assert.assertEquals(0, result.size()); }
Overrider { public void override(String operation, Object value) { this.override.put(operation, value); } Overrider(); Overrider(Overrider overrider); void overrideOnce(String operation, Object value); void override(String operation, Object value); void removeOverride(String operation); boolean hasOverride(String operation); Object getOverride(String operation); }
@Test public void testOverride() throws Exception { String name = "value"; String value = "many"; overrider.override(name, value); Assert.assertEquals(overrider.hasOverride(name), true); Assert.assertEquals(overrider.getOverride(name), value); Assert.assertEquals(overrider.getOverride(name), value); Assert.assertEquals(overrider.hasOverride(name), true); }
BeanOutputHandler extends AbstractOutputHandler<T> { public T handle(List<QueryParameters> outputList) throws MjdbcException { return (T) this.outputProcessor.toBean(outputList, this.type); } BeanOutputHandler(Class<T> type); BeanOutputHandler(Class<T> type, QueryOutputProcessor outputProcessor); T handle(List<QueryParameters> outputList); }
@Test public void testHandle() throws Exception { BeanOutputHandler<Character> handler = new BeanOutputHandler<Character>(Character.class); Character result = handler.handle(paramsList); org.junit.Assert.assertArrayEquals(new Object[]{"jack", "sheriff", 36}, new Object[]{result.getName(), result.getOccupation(), result.getAge()}); } @Test public void testEmpty() throws MjdbcException { BeanOutputHandler<Character> handler = new BeanOutputHandler<Character>(Character.class); Character result = handler.handle(emptyList); Assert.assertEquals(null, result); }
ArrayOutputHandler extends AbstractOutputHandler<Object[]> { public Object[] handle(List<QueryParameters> outputList) { return this.outputProcessor.toArray(outputList); } ArrayOutputHandler(); ArrayOutputHandler(QueryOutputProcessor outputProcessor); Object[] handle(List<QueryParameters> outputList); }
@Test public void testHandle() { Object[] result = new ArrayOutputHandler().handle(paramsList); Assert.assertArrayEquals(new Object[]{"jack", "sheriff", 36}, result); } @Test public void testEmpty() { Object[] result = new ArrayOutputHandler().handle(emptyList); Assert.assertEquals(0, result.length); }
ArrayListOutputHandler extends AbstractOutputListHandler<Object[]> { public List<Object[]> handle(List<QueryParameters> outputList) { return this.outputProcessor.toArrayList(outputList); } ArrayListOutputHandler(); ArrayListOutputHandler(QueryOutputProcessor processor); List<Object[]> handle(List<QueryParameters> outputList); }
@Test public void testHandle() { List<Object[]> result = new ArrayListOutputHandler().handle(paramsList); Assert.assertArrayEquals(new Object[]{"jack", "sheriff", 36}, result.get(0)); Assert.assertArrayEquals(new Object[]{"henry", "mechanic", 36}, result.get(1)); Assert.assertArrayEquals(new Object[]{"alison", "agent", 30}, result.get(2)); } @Test public void testEmpty() { List<Object[]> result = new ArrayListOutputHandler().handle(emptyList); Assert.assertEquals(0, result.size()); }
RowCountOutputHandler extends AbstractOutputHandler<T> { public T handle(List<QueryParameters> outputList) { Number result = 0; if (outputList == null || outputList.isEmpty() == true) { throw new IllegalArgumentException("Error! Output should always contain at least one element"); } QueryParameters stmtParams = outputList.get(0); if (stmtParams.containsKey(HandlersConstants.STMT_UPDATE_COUNT) == false) { throw new IllegalArgumentException("Error! Expected to get update count, but key wasn't found!"); } result = (Integer) stmtParams.getValue(HandlersConstants.STMT_UPDATE_COUNT); return (T) result; } RowCountOutputHandler(); T handle(List<QueryParameters> outputList); }
@Test public void testHandle() throws Exception { RowCountOutputHandler<Integer> handler = new RowCountOutputHandler<Integer>(); paramsList.get(0).set(HandlersConstants.STMT_UPDATE_COUNT, 3); Integer result = handler.handle(paramsList); Assert.assertEquals(3, result.intValue()); } @Test public void testIncorrect() { RowCountOutputHandler<Integer> handler = new RowCountOutputHandler<Integer>(); try { Integer result = handler.handle(paramsList); fail(); } catch (IllegalArgumentException ex) { } } @Test public void testEmpty() { RowCountOutputHandler<Integer> handler = new RowCountOutputHandler<Integer>(); try { Integer result = handler.handle(emptyList); fail(); } catch (IllegalArgumentException ex) { } }
Overrider { public void removeOverride(String operation) { if (this.overrideOnce.containsKey(operation) == true) { this.overrideOnce.remove(operation); } if (this.override.containsKey(operation) == true) { this.override.remove(operation); } } Overrider(); Overrider(Overrider overrider); void overrideOnce(String operation, Object value); void override(String operation, Object value); void removeOverride(String operation); boolean hasOverride(String operation); Object getOverride(String operation); }
@Test public void testRemoveOverride() throws Exception { String name = "value"; String value = "many"; overrider.override(name, value); Assert.assertEquals(overrider.hasOverride(name), true); Assert.assertEquals(overrider.getOverride(name), value); overrider.removeOverride(name); Assert.assertEquals(overrider.getOverride(name), null); Assert.assertEquals(overrider.hasOverride(name), false); }
KeyedOutputHandler extends AbstractKeyedOutputHandler<K, Map<String, Object>> { @Override protected Map<String, Object> createRow(QueryParameters params) throws MjdbcException { return this.outputProcessor.toMap(params); } KeyedOutputHandler(); KeyedOutputHandler(QueryOutputProcessor processor); KeyedOutputHandler(int columnIndex); KeyedOutputHandler(String columnName); private KeyedOutputHandler(QueryOutputProcessor processor, int columnIndex, String columnName); }
@Test public void testCreateRow() throws Exception { KeyedOutputHandler<String> handler = new KeyedOutputHandler<String>(); Map<String, Object> result = handler.createRow(params); Assert.assertEquals(params.getValue("name"), result.get("name")); Assert.assertEquals(params.getValue("occupation"), result.get("occupation")); Assert.assertEquals(params.getValue("age"), result.get("age")); }
BeanLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<BeanLazyScrollUpdateOutputHandler, S> { public boolean hasNext() { return super.innerHasNext(); } BeanLazyScrollUpdateOutputHandler(Class<S> type); BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(S row); void insertRow(S row); }
@Test public void testHasNext() throws Exception { innerTestHasPrepare(); innerTestHasNext(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
BeanLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<BeanLazyScrollUpdateOutputHandler, S> { public S getNext() { S result = null; QueryParameters params = innerGetNext(); try { result = processor.toBean(params, this.type); } catch (MjdbcException ex) { throw new MjdbcRuntimeException(ex); } return result; } BeanLazyScrollUpdateOutputHandler(Class<S> type); BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(S row); void insertRow(S row); }
@Test public void testGetNext() throws Exception { innerTestGetPrepare(); innerTestGetNext(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
BeanLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<BeanLazyScrollUpdateOutputHandler, S> { public S getCurrent() { S result = null; QueryParameters params = innerGetCurrent(); try { result = processor.toBean(params, this.type); } catch (MjdbcException ex) { throw new MjdbcRuntimeException(ex); } return result; } BeanLazyScrollUpdateOutputHandler(Class<S> type); BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(S row); void insertRow(S row); }
@Test public void testGetCurrent() throws Exception { innerTestGetPrepare(); innerTestGetCurrent(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
BeanLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<BeanLazyScrollUpdateOutputHandler, S> { public void close() { innerClose(); } BeanLazyScrollUpdateOutputHandler(Class<S> type); BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(S row); void insertRow(S row); }
@Test public void testClose() throws Exception { innerTestClosePrepare(); innerTestClose(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
BeanLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<BeanLazyScrollUpdateOutputHandler, S> { public BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList) throws MjdbcException { if (outputList instanceof QueryParametersLazyList) { return new BeanLazyScrollUpdateOutputHandler(this.type, this.processor, (QueryParametersLazyList) outputList); } else { throw new MjdbcRuntimeException("LazyOutputHandler can be used only together with LazyStatementHandler. \n" + "Please assign LazyStatementHandler to this QueryRunner or create new QueryRunnerService via MjdbcFactory"); } } BeanLazyScrollUpdateOutputHandler(Class<S> type); BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(S row); void insertRow(S row); }
@Test public void testHandle() throws Exception { innerTestHandle(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false)) instanceof BeanLazyScrollUpdateOutputHandler); } @Test public void testEmpty() throws Exception { innerTestEmpty(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
BeanLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<BeanLazyScrollUpdateOutputHandler, S> { public boolean hasPrev() { return innerHasPrev(); } BeanLazyScrollUpdateOutputHandler(Class<S> type); BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(S row); void insertRow(S row); }
@Test public void testHasPrev() throws Exception { innerTestHasPrepare(); innerTestHasPrev(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
BeanLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<BeanLazyScrollUpdateOutputHandler, S> { public S getPrev() { S result = null; QueryParameters params = innerGetPrev(); try { result = processor.toBean(params, this.type); } catch (MjdbcException ex) { throw new MjdbcRuntimeException(ex); } return result; } BeanLazyScrollUpdateOutputHandler(Class<S> type); BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(S row); void insertRow(S row); }
@Test public void testGetPrev() throws Exception { innerTestGetPrepare(); innerTestGetPrev(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
BeanLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<BeanLazyScrollUpdateOutputHandler, S> { public boolean moveTo(int row) { return innerMoveTo(row); } BeanLazyScrollUpdateOutputHandler(Class<S> type); BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(S row); void insertRow(S row); }
@Test public void testMoveTo() throws Exception { innerTestGetPrepare(); innerTestMoveTo(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
Overrider { public boolean hasOverride(String operation) { boolean result = false; if (this.overrideOnce.containsKey(operation) == true || this.override.containsKey(operation) == true) { result = true; } return result; } Overrider(); Overrider(Overrider overrider); void overrideOnce(String operation, Object value); void override(String operation, Object value); void removeOverride(String operation); boolean hasOverride(String operation); Object getOverride(String operation); }
@Test public void testHasOverride() throws Exception { String name = "value"; String value = "once"; overrider.overrideOnce(name, value); Assert.assertEquals(overrider.hasOverride(name), true); overrider.removeOverride(name); Assert.assertEquals(overrider.hasOverride(name), false); }
BeanLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<BeanLazyScrollUpdateOutputHandler, S> { public boolean moveRelative(int rows) { return innerMoveRelative(rows); } BeanLazyScrollUpdateOutputHandler(Class<S> type); BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(S row); void insertRow(S row); }
@Test public void testMoveRelative() throws Exception { innerTestGetPrepare(); innerTestMoveRelative(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
BeanLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<BeanLazyScrollUpdateOutputHandler, S> { public int position() { return innerPosition(); } BeanLazyScrollUpdateOutputHandler(Class<S> type); BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(S row); void insertRow(S row); }
@Test public void testPosition() throws Exception { innerTestGetPrepare(); innerTestPosition(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
BeanLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<BeanLazyScrollUpdateOutputHandler, S> { public void updateRow(S row) throws SQLException { innerUpdateRow(new QueryParameters(row.getClass(), row)); } BeanLazyScrollUpdateOutputHandler(Class<S> type); BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(S row); void insertRow(S row); }
@Test public void testUpdateRow() throws Exception { testTestUpdatePrepare(); QueryParametersLazyList queryParamsLazyList = new QueryParametersLazyList(stmt, typeHandler, false); queryParamsLazyList.setType(QueryParametersLazyList.Type.UPDATE_SCROLL); testTestUpdateRow(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(queryParamsLazyList), zoe); }
BeanLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<BeanLazyScrollUpdateOutputHandler, S> { public void insertRow(S row) throws SQLException { innerInsertRow(new QueryParameters(row.getClass(), row)); } BeanLazyScrollUpdateOutputHandler(Class<S> type); BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor); private BeanLazyScrollUpdateOutputHandler(Class<S> type, QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); S getNext(); S getCurrent(); void close(); BeanLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); S getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(S row); void insertRow(S row); }
@Test public void testInsertRow() throws Exception { testTestUpdatePrepare(); QueryParametersLazyList queryParamsLazyList = new QueryParametersLazyList(stmt, typeHandler, false); queryParamsLazyList.setType(QueryParametersLazyList.Type.UPDATE_SCROLL); testTestInsertRow(new BeanLazyScrollUpdateOutputHandler<Character>(Character.class).handle(queryParamsLazyList), zoe); }
MapLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<MapLazyScrollUpdateOutputHandler, Map<String, Object>> { public boolean hasNext() { return innerHasNext(); } MapLazyScrollUpdateOutputHandler(); MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); }
@Test public void testHasNext() throws Exception { innerTestHasPrepare(); innerTestHasNext(new MapLazyScrollUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
MapLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<MapLazyScrollUpdateOutputHandler, Map<String, Object>> { public Map<String, Object> getNext() { Map<String, Object> result = null; QueryParameters params = innerGetNext(); result = processor.toMap(params); return result; } MapLazyScrollUpdateOutputHandler(); MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); }
@Test public void testGetNext() throws Exception { innerTestGetPrepare(); innerTestGetNext(new MapLazyScrollUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
MapLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<MapLazyScrollUpdateOutputHandler, Map<String, Object>> { public Map<String, Object> getCurrent() { Map<String, Object> result = null; QueryParameters params = innerGetCurrent(); result = processor.toMap(params); return result; } MapLazyScrollUpdateOutputHandler(); MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); }
@Test public void testGetCurrent() throws Exception { innerTestGetPrepare(); innerTestGetCurrent(new MapLazyScrollUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
MapLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<MapLazyScrollUpdateOutputHandler, Map<String, Object>> { public void close() { innerClose(); } MapLazyScrollUpdateOutputHandler(); MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); }
@Test public void testClose() throws Exception { innerTestClosePrepare(); innerTestClose(new MapLazyScrollUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
MapLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<MapLazyScrollUpdateOutputHandler, Map<String, Object>> { public MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList) throws MjdbcException { if (outputList instanceof QueryParametersLazyList) { return new MapLazyScrollUpdateOutputHandler(this.processor, (QueryParametersLazyList) outputList); } else { throw new MjdbcRuntimeException("LazyOutputHandler can be used only together with LazyStatementHandler. \n" + "Please assign LazyStatementHandler to this QueryRunner or create new QueryRunnerService via MjdbcFactory"); } } MapLazyScrollUpdateOutputHandler(); MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); }
@Test public void testHandle() throws Exception { innerTestHandle(new MapLazyScrollUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false)) instanceof MapLazyScrollUpdateOutputHandler); } @Test public void testEmpty() throws Exception { innerTestEmpty(new MapLazyScrollUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
Overrider { public Object getOverride(String operation) { Object result = null; if (this.overrideOnce.containsKey(operation) == true) { result = this.overrideOnce.get(operation); this.overrideOnce.remove(operation); } else if (this.override.containsKey(operation) == true) { result = this.override.get(operation); } return result; } Overrider(); Overrider(Overrider overrider); void overrideOnce(String operation, Object value); void override(String operation, Object value); void removeOverride(String operation); boolean hasOverride(String operation); Object getOverride(String operation); }
@Test public void testGetOverride() throws Exception { testOverrideOnce(); testOverride(); }
MapLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<MapLazyScrollUpdateOutputHandler, Map<String, Object>> { public boolean hasPrev() { return innerHasPrev(); } MapLazyScrollUpdateOutputHandler(); MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); }
@Test public void testHasPrev() throws Exception { innerTestHasPrepare(); innerTestHasPrev(new MapLazyScrollUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
MapLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<MapLazyScrollUpdateOutputHandler, Map<String, Object>> { public Map<String, Object> getPrev() { Map<String, Object> result = null; QueryParameters params = innerGetPrev(); result = processor.toMap(params); return result; } MapLazyScrollUpdateOutputHandler(); MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); }
@Test public void testGetPrev() throws Exception { innerTestGetPrepare(); innerTestGetPrev(new MapLazyScrollUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
MapLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<MapLazyScrollUpdateOutputHandler, Map<String, Object>> { public boolean moveTo(int row) { return innerMoveTo(row); } MapLazyScrollUpdateOutputHandler(); MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); }
@Test public void testMoveTo() throws Exception { innerTestGetPrepare(); innerTestMoveTo(new MapLazyScrollUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
MapLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<MapLazyScrollUpdateOutputHandler, Map<String, Object>> { public boolean moveRelative(int rows) { return innerMoveRelative(rows); } MapLazyScrollUpdateOutputHandler(); MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); }
@Test public void testMoveRelative() throws Exception { innerTestGetPrepare(); innerTestMoveRelative(new MapLazyScrollUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
MapLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<MapLazyScrollUpdateOutputHandler, Map<String, Object>> { public int position() { return innerPosition(); } MapLazyScrollUpdateOutputHandler(); MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); }
@Test public void testPosition() throws Exception { innerTestGetPrepare(); innerTestPosition(new MapLazyScrollUpdateOutputHandler().handle(new QueryParametersLazyList(stmt, typeHandler, false))); }
MapLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<MapLazyScrollUpdateOutputHandler, Map<String, Object>> { public void updateRow(Map<String, Object> row) throws SQLException { innerUpdateRow(new QueryParameters(row)); } MapLazyScrollUpdateOutputHandler(); MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); }
@Test public void testUpdateRow() throws Exception { testTestUpdatePrepare(); QueryParametersLazyList queryParamsLazyList = new QueryParametersLazyList(stmt, typeHandler, false); queryParamsLazyList.setType(QueryParametersLazyList.Type.UPDATE_SCROLL); testTestUpdateRow(new MapLazyScrollUpdateOutputHandler().handle(queryParamsLazyList), params.toMap()); }
MapLazyScrollUpdateOutputHandler extends AbstractScrollUpdateLazyOutputHandler implements LazyScrollUpdateOutputHandler<MapLazyScrollUpdateOutputHandler, Map<String, Object>> { public void insertRow(Map<String, Object> row) throws SQLException { innerInsertRow(new QueryParameters(row)); } MapLazyScrollUpdateOutputHandler(); MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor); private MapLazyScrollUpdateOutputHandler(QueryOutputProcessor processor, QueryParametersLazyList paramsList); boolean hasNext(); Map<String, Object> getNext(); Map<String, Object> getCurrent(); void close(); MapLazyScrollUpdateOutputHandler handle(List<QueryParameters> outputList); boolean hasPrev(); Map<String, Object> getPrev(); boolean moveTo(int row); boolean moveRelative(int rows); int position(); void updateRow(Map<String, Object> row); void insertRow(Map<String, Object> row); }
@Test public void testInsertRow() throws Exception { testTestUpdatePrepare(); QueryParametersLazyList queryParamsLazyList = new QueryParametersLazyList(stmt, typeHandler, false); queryParamsLazyList.setType(QueryParametersLazyList.Type.UPDATE_SCROLL); testTestInsertRow(new MapLazyScrollUpdateOutputHandler().handle(queryParamsLazyList), params.toMap()); }