// // Returns true if this method is allowed to raise SQLFeatureNotSupportedException. // private boolean isExcludable(Method method) throws Exception { Class iface = method.getDeclaringClass(); HashSet<Method> excludableMethods = excludableMap.get(iface); if (excludableMethods == null) { return false; } return excludableMethods.contains(method); }
// // Initialize the hashtable of methods which are allowed to raise // SQLFeatureNotSupportedException. // private void initializeExcludableMap(HashSet<String> vanishedMethodList) throws Exception { excludableMap = new Hashtable<Class, HashSet<Method>>(); int count = rawExcludables.length; for (int i = 0; i < count; i++) { Exclusions exclusions = rawExcludables[i]; Class<?> iface = exclusions.getInterface(); MD[] mds = exclusions.getExcludedMethods(); int exclusionCount = mds.length; HashSet<Method> excludedMethodSet = new HashSet<Method>(); for (int j = 0; j < exclusionCount; j++) { MD md = mds[j]; if (!md.requiredAtThisLevel()) { continue; } // // If we are strictly enforcing the JDBC standard, // then expose the mandatory methods which we know Derby // doesn't implement. // if (STRICT_ENFORCEMENT && !md.isOptional()) { continue; } Method method = null; try { method = iface.getMethod(md.getMethodName(), md.getArgTypes()); } catch (NoSuchMethodException e) { } if (method == null) { vanishedMethodList.add( "Method has vanished from SQL interface: " + iface.getName() + "." + md); } excludedMethodSet.add(method); } excludableMap.put(iface, excludedMethodSet); } }
// // Record an unexpected error. // private void recordUnexpectedError( Object candidate, Class iface, Method method, HashSet<String> notUnderstoodList, Throwable cause) throws Exception { notUnderstoodList.add(candidate.getClass().getName() + " " + method + " raises " + cause); }
// debug print the list of methods which have disappeared from the SQL interface private void printVanishedMethodList(HashSet<String> vanishedMethodList) { int count = vanishedMethodList.size(); if (count == 0) { return; } println("--------------- VANISHED METHODS ------------------"); println("--"); String[] result = new String[count]; vanishedMethodList.toArray(result); Arrays.sort(result); for (int i = 0; i < count; i++) { println(result[i]); } }
// debug print the list of methods which throw SQLFeatureNotSupportedException private void printUnsupportedList(HashSet<String> unsupportedList) { int count = unsupportedList.size(); if (count == 0) { return; } println("--------------- UNSUPPORTED METHODS ------------------"); println("--"); String[] result = new String[count]; unsupportedList.toArray(result); Arrays.sort(result); for (int i = 0; i < count; i++) { println(result[i]); } }
// Debug print the list of method failures which we don't understand private void printNotUnderstoodList(HashSet<String> notUnderstoodList) { int count = notUnderstoodList.size(); if (count == 0) { return; } println("\n\n"); println("--------------- NOT UNDERSTOOD METHODS ------------------"); println("--"); String[] result = new String[count]; notUnderstoodList.toArray(result); Arrays.sort(result); for (int i = 0; i < count; i++) { println(result[i]); } }
// // Examine a single method to see if it raises SQLFeatureNotSupportedException. // private void vetMethod( Object candidate, Class iface, Method method, HashSet<String> unsupportedList, HashSet<String> notUnderstoodList) throws Exception { try { method.invoke(candidate, getNullArguments(method.getParameterTypes())); // it's ok for the method to succeed } catch (Throwable e) { if (!(e instanceof InvocationTargetException)) { recordUnexpectedError(candidate, iface, method, notUnderstoodList, e); } else { Throwable cause = e.getCause(); if (cause instanceof SQLFeatureNotSupportedException) { boolean isExcludable = isExcludable(method); if (!isExcludable) { StackTraceElement[] stack = cause.getStackTrace(); int i = 0; while (i < stack.length && !stack[i].getMethodName().equals("notImplemented")) { ++i; } while (i < stack.length && stack[i].getMethodName().equals("notImplemented")) { ++i; } if (i == stack.length) { // cause.printStackTrace(); } unsupportedList.add( candidate.getClass().getName() + ": " + method + "@" + (i == stack.length ? "no source" : cause.getStackTrace()[i])); } else { } } else if (cause instanceof SQLException) { // swallow other SQLExceptions, caused by bogus args } else if (cause instanceof NullPointerException) { // swallow other NPEs, caused by bogus args } else if (cause instanceof ArrayIndexOutOfBoundsException) { // swallow these, caused by bogus args } else { recordUnexpectedError(candidate, iface, method, notUnderstoodList, cause); } } } }
/** Find all methods in this framework which raise SQLFeatureNotSupportedException. */ public void testSupportedMethods() throws Exception { getTestConfiguration().setVerbosity(true); HashSet<String> vanishedMethodList = new HashSet<String>(); HashSet<String> unsupportedList = new HashSet<String>(); HashSet<String> notUnderstoodList = new HashSet<String>(); // Build map of interfaces to their methods which may raise SQLFeatureNotSupportedException. initializeExcludableMap(vanishedMethodList); vetDataSource(unsupportedList, notUnderstoodList); vetConnectionPooledDataSource(unsupportedList, notUnderstoodList); vetXADataSource(unsupportedList, notUnderstoodList); // // Print methods which behave unexpectedly. // printVanishedMethodList(vanishedMethodList); printUnsupportedList(unsupportedList); printNotUnderstoodList(notUnderstoodList); int actualErrorCount = vanishedMethodList.size() + unsupportedList.size() + notUnderstoodList.size(); assertEquals("Unexpected discrepancies.", 0, actualErrorCount); }
public void fireStatementErrorOccurred(PreparedStatement ps, SQLException error) { Set mlCopy; synchronized (this) { mlCopy = (Set) mlisteners.clone(); } StatementEvent evt = new StatementEvent(source, ps, error); for (Iterator i = mlCopy.iterator(); i.hasNext(); ) { StatementEventListener cl = (StatementEventListener) i.next(); cl.statementErrorOccurred(evt); } }
public static void main(String[] argv) { try { ComboPooledDataSource cpds = new ComboPooledDataSource(); cpds.setJdbcUrl(argv[0]); cpds.setUser(argv[1]); cpds.setPassword(argv[2]); cpds.setMinPoolSize(5); cpds.setAcquireIncrement(5); cpds.setMaxPoolSize(20); System.err.println("Initial..."); display(cpds); Thread.sleep(2000); HashSet hs = new HashSet(); for (int i = 0; i < 20; ++i) { Connection c = cpds.getConnection(); hs.add(c); System.err.println("Adding (" + (i + 1) + ") " + c); display(cpds); Thread.sleep(1000); // if (i == 9) // { // //System.err.println("hardReset()ing"); // //cpds.hardReset(); // System.err.println("softReset()ing"); // cpds.softReset(); // } } int count = 0; for (Iterator ii = hs.iterator(); ii.hasNext(); ) { Connection c = ((Connection) ii.next()); System.err.println("Removing " + ++count); ii.remove(); try { c.getMetaData().getTables(null, null, "PROBABLYNOT", new String[] {"TABLE"}); } catch (Exception e) { System.err.println(e); System.err.println(); continue; } finally { c.close(); } Thread.sleep(2000); display(cpds); } System.err.println( "Closing data source, \"forcing\" garbage collection, and sleeping for 5 seconds..."); cpds.close(); System.gc(); System.err.println("Main Thread: Sleeping for five seconds!"); Thread.sleep(5000); // System.gc(); // Thread.sleep(5000); System.err.println("Bye!"); } catch (Exception e) { e.printStackTrace(); } }
public synchronized int getListenerCount() { return mlisteners.size(); }
public synchronized void removeStatementEventListener(StatementEventListener mlistener) { mlisteners.remove(mlistener); }
public synchronized void addStatementEventListener(StatementEventListener mlistener) { mlisteners.add(mlistener); }