build.xml

@@ -16,7 +16,7 @@
 
     <target depends="init" name="build" description="Builds the drivers" >
         <mkdir dir="${classes}"/>
-        <javac destdir="${classes}" includes="com/octetstring/**" srcdir="${src}">
+        <javac source="8" destdir="${classes}" includes="com/octetstring/**" srcdir="${src}">
             <classpath>
                 <pathelement location="${lib}/junit.jar" />
             </classpath>

src/com/octetstring/jdbcLdap/browser/JdbcLdapBrowser.java

@@ -146,7 +146,7 @@ public class JdbcLdapBrowser {
 			
 			for (int i=0;i<children.length;i++) {
 				try {
-					urls[i] = children[i].toURL();
+					urls[i] = children[i].toURI().toURL();
 				} catch (MalformedURLException e2) {
 					MessageDialog.openError(Display.getCurrent().getActiveShell(),"Could not load drivers",e2.toString());
 				}

src/com/octetstring/jdbcLdap/browser/Rebind.java

@@ -22,6 +22,9 @@ import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.*;
 import org.eclipse.swt.events.*;
+
+import java.nio.charset.StandardCharsets;
+
 /**
  * @author Marc Boorshtein
  *
@@ -153,7 +156,7 @@ class DoRebind extends SelectionAdapter {
 	 */
 	public void widgetSelected(SelectionEvent e) {
 		try {
-			rebind.con.getConnection().bind(3,rebind.user.getText(),rebind.pass.getText());
+			rebind.con.getConnection().bind(3,rebind.user.getText(),rebind.pass.getText().getBytes(StandardCharsets.UTF_8));
 			rebind.conInfo.user = rebind.user.getText();
 			rebind.conInfo.pass = rebind.pass.getText();
 			

src/com/octetstring/jdbcLdap/jndi/Delete.java

@@ -54,9 +54,9 @@ public class Delete {
 		else {
 			try {
 				
-				LDAPSearchResults enum = res.searchUpInsJldap(del);
-				while (enum.hasMore()) {
-					LDAPEntry entry = enum.next(); 
+				LDAPSearchResults entries = res.searchUpInsJldap(del);
+				while (entries.hasMore()) {
+					LDAPEntry entry = entries.next();
 					con.delete(entry.getDN());
 					count++;
 				}

src/com/octetstring/jdbcLdap/jndi/JndiLdapConnection.java

@@ -526,7 +526,11 @@ public class JndiLdapConnection implements java.sql.Connection {
     public java.sql.Savepoint setSavepoint() throws java.sql.SQLException {
         return null;
     }
-    
+
+	public void setSchema(String schema) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
     public boolean isReadOnly() throws java.sql.SQLException {
         return false;
     }
@@ -534,7 +538,11 @@ public class JndiLdapConnection implements java.sql.Connection {
     public void setHoldability(int param) throws java.sql.SQLException {
         
     }
-    
+
+	public void setNetworkTimeout(java.util.concurrent.Executor executor, int milliseconds) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
     public void rollback() throws java.sql.SQLException {
         if (! this.ignoreTransactions) {
         	throw new SQLException("LDAP Does Not Support Transactions");
@@ -653,7 +661,19 @@ public class JndiLdapConnection implements java.sql.Connection {
     public java.sql.DatabaseMetaData getMetaData() throws java.sql.SQLException {
         return new JdbcLdapDBMetaData(this);
     }
-    
+
+	public int getNetworkTimeout() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public String getSchema() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void abort(java.util.concurrent.Executor executor) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
     public void clearWarnings() throws java.sql.SQLException {
     }
     
@@ -662,7 +682,59 @@ public class JndiLdapConnection implements java.sql.Connection {
     			throw new SQLException("LDAP Does Not Support Transactions");
     		}
     }
-    
+
+	public java.sql.Clob createClob() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.sql.Blob createBlob() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.sql.NClob createNClob() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.sql.SQLXML createSQLXML() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public boolean isValid(int timeout) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void setClientInfo(String name, String value) throws java.sql.SQLClientInfoException {
+		throw new SQLClientInfoException("Not implemented", null);
+	}
+
+	public void setClientInfo(Properties properties) throws java.sql.SQLClientInfoException {
+		throw new SQLClientInfoException("Not implemented", null);
+	}
+
+	public String getClientInfo(String name) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public Properties getClientInfo() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.sql.Array createArrayOf(String typeName, Object[] elements) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.sql.Struct createStruct(String typeName, Object[] attributes) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public <T>T unwrap(Class<T> iface) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public boolean isWrapperFor(Class<?> iface) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @return trie if expanding rows
 	 */

src/com/octetstring/jdbcLdap/jndi/UnpackResults.java

@@ -349,7 +349,7 @@ public class UnpackResults {
 			if (bval == null) {
 				bval = new byte[0];
 			}
-			if (Base64.isValidUTF8(bval, /*isUCS2Only=*/false)) {
+			if (com.novell.ldap.util.Base64.isValidUTF8(bval, /*isUCS2Only=*/false)) {
 				svals = attrib.getStringValueArray();
 				if ("1.3.6.1.4.1.1466.115.121.1.41".equals(
 					con.schema.getAttributeSchema(attrib.getName()).getSyntaxString())) {
@@ -364,7 +364,7 @@ public class UnpackResults {
 				byteVals = attrib.getByteValueArray();
 				svals  = new String[byteVals.length];
 				for (int i=0,m=byteVals.length;i<m;i++) {
-					svals[i] = Base64.encode(byteVals[i]);
+					svals[i] = com.novell.ldap.util.Base64.encode(byteVals[i]);
 				}
 				
 			}

src/com/octetstring/jdbcLdap/jndi/Update.java

@@ -53,10 +53,10 @@ public class Update {
 		
 		try {
 			if (update.getSearchScope() != 0) {
-				LDAPSearchResults enum = res.searchUpInsJldap(update);
-				//System.out.println("enum.hasMore : " + enum.hasMore());
-				while (enum.hasMore()) {
-					seres =  enum.next();
+				LDAPSearchResults entries = res.searchUpInsJldap(update);
+				//System.out.println("entries.hasMore : " + entries.hasMore());
+				while (entries.hasMore()) {
+					seres =  entries.next();
 					buf.setLength(0);
 					
 					name = seres.getDN();

src/com/octetstring/jdbcLdap/jndi/UpdateEntry.java

@@ -112,9 +112,9 @@ public class UpdateEntry {
 		try {
 			int count = 0;
 			if (stmt.getSearchScope() != 0) {
-				LDAPSearchResults enum = res.searchUpInsJldap(stmt);
-				while (enum.hasMore()) {
-					entry = enum.next();
+				LDAPSearchResults entries = res.searchUpInsJldap(stmt);
+				while (entries.hasMore()) {
+					entry = entries.next();
 					buf.setLength(0);
 					
 					name = entry.getDN();

src/com/octetstring/jdbcLdap/junit/sql/TestResultSet.java

@@ -65,10 +65,10 @@ public class TestResultSet extends junit.framework.TestCase {
         String field;
         
         
-        LDAPMessageQueue enum = (LDAPMessageQueue) sel.executeQuery();
+        LDAPMessageQueue queue = (LDAPMessageQueue) sel.executeQuery();
         
         UnpackResults pack = new UnpackResults(con);
-        pack.unpackJldap(enum,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),sel.getSqlStore().getRevFieldMap());
+        pack.unpackJldap(queue,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),sel.getSqlStore().getRevFieldMap());
         
         LdapResultSet rs = new LdapResultSet(con,null,pack,sel.getBaseContext());
         
@@ -135,10 +135,10 @@ public class TestResultSet extends junit.framework.TestCase {
         String field;
         StringBuffer buf = new StringBuffer();
         
-        LDAPMessageQueue enum = (LDAPMessageQueue) sel.executeQuery();
+        LDAPMessageQueue queue = (LDAPMessageQueue) sel.executeQuery();
         
         UnpackResults pack = new UnpackResults(con);
-        pack.unpackJldap(enum,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),sel.getSqlStore().getRevFieldMap());
+        pack.unpackJldap(queue,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),sel.getSqlStore().getRevFieldMap());
         
         LdapResultSet rs = new LdapResultSet(con,null,pack,sel.getBaseContext());
         

src/com/octetstring/jdbcLdap/junit/sql/TestSelectRetrieve.java

@@ -213,9 +213,9 @@ public class TestSelectRetrieve extends junit.framework.TestCase {
     
     /**
      *Loads a NamingEnumeration into a LinkedList
-     *@param enum Search Results
+     *@param naming Search Results
      */
-    LinkedList load(NamingEnumeration enum) throws Exception {
+    LinkedList load(NamingEnumeration naming) throws Exception {
         LinkedList list = new LinkedList();
         LinkedList row;
         SearchResult res;
@@ -227,9 +227,9 @@ public class TestSelectRetrieve extends junit.framework.TestCase {
         String val;
         Object obj;
         
-        while (enum.hasMore()) {
+        while (naming.hasMore()) {
             row = new LinkedList();
-            res = (SearchResult) enum.next();
+            res = (SearchResult) naming.next();
             //System.out.println(res.getName());
             atts = (Attributes) res.getAttributes();
             

src/com/octetstring/jdbcLdap/junit/sql/TestUnpack.java

@@ -67,10 +67,10 @@ public class TestUnpack extends junit.framework.TestCase {
         
         
         
-        LDAPMessageQueue enum = (LDAPMessageQueue) sel.executeQuery();
+        LDAPMessageQueue queue = (LDAPMessageQueue) sel.executeQuery();
         
         UnpackResults pack = new UnpackResults(con);
-        pack.unpackJldap(enum,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),null);
+        pack.unpackJldap(queue,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),null);
         
         ArrayList fieldsExp = new ArrayList();
         
@@ -186,12 +186,12 @@ public class TestUnpack extends junit.framework.TestCase {
 				String field;
         
         
-				LDAPMessageQueue enum = (LDAPMessageQueue) sel.executeQuery();
+				LDAPMessageQueue queue = (LDAPMessageQueue) sel.executeQuery();
         
-				System.out.println(enum);
+				System.out.println(queue);
 				
 				UnpackResults pack = new UnpackResults(con);
-				pack.unpackJldap(enum,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),null);
+				pack.unpackJldap(queue,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),null);
         
         
 				ArrayList fieldsExp = new ArrayList();
@@ -263,10 +263,10 @@ public class TestUnpack extends junit.framework.TestCase {
         String field;
         
         
-        LDAPMessageQueue enum = (LDAPMessageQueue) sel.executeQuery();
+        LDAPMessageQueue queue = (LDAPMessageQueue) sel.executeQuery();
         
         UnpackResults pack = new UnpackResults(con);
-        pack.unpackJldap(enum,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),null);
+        pack.unpackJldap(queue,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),null);
         
         
         ArrayList fieldsExp = new ArrayList();
@@ -356,10 +356,10 @@ public class TestUnpack extends junit.framework.TestCase {
         String field;
         
         
-        LDAPMessageQueue enum = (LDAPMessageQueue) sel.executeQuery();
+        LDAPMessageQueue queue = (LDAPMessageQueue) sel.executeQuery();
         
         UnpackResults pack = new UnpackResults(con);
-        pack.unpackJldap(enum,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),null);
+        pack.unpackJldap(queue,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),null);
         
         ArrayList fieldsExp = new ArrayList();
         
@@ -470,11 +470,11 @@ public class TestUnpack extends junit.framework.TestCase {
         sel.getArgs()[0] = "Peons";
         sel.getArgs()[1] = "A*";
         
-        LDAPMessageQueue enum = (LDAPMessageQueue) sel.executeQuery();
-        //if (! enum.hasMore()) System.out.println("no results");
+        LDAPMessageQueue queue = (LDAPMessageQueue) sel.executeQuery();
+        //if (! queue.hasMore()) System.out.println("no results");
         
         UnpackResults pack = new UnpackResults(con);
-        pack.unpackJldap(enum,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),null);
+        pack.unpackJldap(queue,sel.getRetrieveDN(),sel.getSqlStore().getFrom(),con.getBaseDN(),null);
         
         ArrayList fieldsExp = new ArrayList();
         

src/com/octetstring/jdbcLdap/sql/JdbcLdapDBMetaData.java

@@ -9,6 +9,7 @@ package com.octetstring.jdbcLdap.sql;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
+import java.sql.RowIdLifetime;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -238,6 +239,20 @@ public class JdbcLdapDBMetaData implements DatabaseMetaData {
 		return 0;
 	}
 
+	/* (non-Javadoc)
+	 * @see java.sql.DatabaseMetaData#getRowIdLifetime()
+	 */
+	public RowIdLifetime getRowIdLifetime() throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/* (non-Javadoc)
+	 * @see java.sql.DatabaseMetaData#getSchemas(String, String)
+	 */
+	public ResultSet getSchemas(String catalog, String schemaPattern) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/* (non-Javadoc)
 	 * @see java.sql.DatabaseMetaData#getSQLStateType()
 	 */
@@ -262,6 +277,13 @@ public class JdbcLdapDBMetaData implements DatabaseMetaData {
 		return true;
 	}
 
+	/* (non-Javadoc)
+	 * @see java.sql.DatabaseMetaData#autoCommitFailureClosesAllResultSets()
+	 */
+	public boolean autoCommitFailureClosesAllResultSets() throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/* (non-Javadoc)
 	 * @see java.sql.DatabaseMetaData#dataDefinitionCausesTransactionCommit()
 	 */
@@ -286,6 +308,13 @@ public class JdbcLdapDBMetaData implements DatabaseMetaData {
 		return false;
 	}
 
+	/* (non-Javadoc)
+	 * @see java.sql.DatabaseMetaData#generatedKeyAlwaysReturned()
+	 */
+	public boolean generatedKeyAlwaysReturned() throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/* (non-Javadoc)
 	 * @see java.sql.DatabaseMetaData#isCatalogAtStart()
 	 */
@@ -816,6 +845,13 @@ public class JdbcLdapDBMetaData implements DatabaseMetaData {
 		return false;
 	}
 
+	/* (non-Javadoc)
+	 * @see java.sql.DatabaseMetaData#supportsStoredFunctionsUsingCallSyntax()
+	 */
+	public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/* (non-Javadoc)
 	 * @see java.sql.DatabaseMetaData#supportsStoredProcedures()
 	 */
@@ -1036,6 +1072,13 @@ public class JdbcLdapDBMetaData implements DatabaseMetaData {
 		return null;
 	}
 
+	/* (non-Javadoc)
+	 * @see java.sql.DatabaseMetaData#getClientInfoProperties()
+	 */
+	public ResultSet getClientInfoProperties() throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/* (non-Javadoc)
 	 * @see java.sql.DatabaseMetaData#getDatabaseProductName()
 	 */
@@ -1076,6 +1119,20 @@ public class JdbcLdapDBMetaData implements DatabaseMetaData {
 		return null;
 	}
 
+	/* (non-Javadoc)
+	 * @see java.sql.DatabaseMetaData#getFunctionColumns(String, String, String, String)
+	 */
+	public ResultSet getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern, String columnNamePattern) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/* (non-Javadoc)
+	 * @see java.sql.DatabaseMetaData#getFunctions(String, String, String)
+	 */
+	public ResultSet getFunctions(String catalog, String schemaPattern, String functionNamePattern) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/* (non-Javadoc)
 	 * @see java.sql.DatabaseMetaData#getIdentifierQuoteString()
 	 */
@@ -1100,6 +1157,13 @@ public class JdbcLdapDBMetaData implements DatabaseMetaData {
 		return null;
 	}
 
+	/* (non-Javadoc)
+	 * @see java.sql.DatabaseMetaData#getPseudoColumns()
+	 */
+	public ResultSet getPseudoColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/* (non-Javadoc)
 	 * @see java.sql.DatabaseMetaData#getSQLKeywords()
 	 */
@@ -1385,5 +1449,19 @@ public class JdbcLdapDBMetaData implements DatabaseMetaData {
 		return null;
 	}
 
+	/* (non-Javadoc)
+	 * @see java.sql.Wrapper#unwrap(Class<T>)
+	 */
+	public <T>T unwrap(Class<T> iface) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/* (non-Javadoc)
+	 * @see java.sql.Wrapper#isWrapperFor(Class<?>)
+	 */
+	public boolean isWrapperFor(Class<?> iface) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 
 }

src/com/octetstring/jdbcLdap/sql/JdbcLdapDriver.java

@@ -111,7 +111,11 @@ public class JdbcLdapDriver implements java.sql.Driver {
     public int getMinorVersion() {
         return MINOR_VERSION;
     }
-    
+
+	public java.util.logging.Logger getParentLogger() throws java.sql.SQLFeatureNotSupportedException {
+		throw new SQLFeatureNotSupportedException("Not implemented");
+	}
+
     public java.sql.DriverPropertyInfo[] getPropertyInfo(java.lang.String str, java.util.Properties properties) throws java.sql.SQLException {
         DriverPropertyInfo[] props = new DriverPropertyInfo[5];
         props[0] = new DriverPropertyInfo("user","Security Principal");

src/com/octetstring/jdbcLdap/sql/JdbcLdapMetaData.java

@@ -141,5 +141,13 @@ public class JdbcLdapMetaData implements java.sql.ResultSetMetaData {
     public boolean isWritable(int param) throws java.sql.SQLException {
         return false;
     }
+
+	public <T>T unwrap(Class<T> iface) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public boolean isWrapperFor(Class<?> iface) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
     
 }

src/com/octetstring/jdbcLdap/sql/JdbcLdapPreparedStatement.java

@@ -70,6 +70,7 @@ public class JdbcLdapPreparedStatement extends JdbcLdapStatement implements java
 
 	
     
+	@Deprecated
     public void setUnicodeStream(int param, java.io.InputStream inputStream, int param2) throws java.sql.SQLException {
         char[] c = new char[param2];
         try {
@@ -107,7 +108,11 @@ public class JdbcLdapPreparedStatement extends JdbcLdapStatement implements java
     public void setURL(int param, java.net.URL uRL) throws java.sql.SQLException {
         setVal(param,uRL.toString());
     }
-    
+
+    public void setAsciiStream(int param, java.io.InputStream inputStream) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
     public void setAsciiStream(int param, java.io.InputStream inputStream, int param2) throws java.sql.SQLException {
         char[] c = new char[param2];
         try {
@@ -122,6 +127,10 @@ public class JdbcLdapPreparedStatement extends JdbcLdapStatement implements java
         }
         setVal(param,String.valueOf(c));
     }
+
+    public void setAsciiStream(int param, java.io.InputStream inputStream, long param2) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
     
     public void setByte(int param, byte param1) throws java.sql.SQLException {
         setVal(param,Byte.toString(param1));
@@ -138,7 +147,11 @@ public class JdbcLdapPreparedStatement extends JdbcLdapStatement implements java
     public void setDate(int param, java.sql.Date date) throws java.sql.SQLException {
         setVal(param,date.toString());
     }
-    
+
+	public void setBinaryStream(int param, java.io.InputStream inputStream) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
     public void setBinaryStream(int param, java.io.InputStream inputStream, int param2) throws java.sql.SQLException {
         char[] c = new char[param2];
         try {
@@ -153,6 +166,10 @@ public class JdbcLdapPreparedStatement extends JdbcLdapStatement implements java
         }
         setVal(param,String.valueOf(c));
     }
+
+	public void setBinaryStream(int param, java.io.InputStream inputStream, long param2) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
     
     public java.sql.ParameterMetaData getParameterMetaData() throws java.sql.SQLException {
         return null;
@@ -164,7 +181,15 @@ public class JdbcLdapPreparedStatement extends JdbcLdapStatement implements java
     
     public void setBlob(int param, java.sql.Blob blob) throws java.sql.SQLException {
     }
-    
+
+	public void setBlob(int param, java.io.InputStream inputStream) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void setBlob(int param, java.io.InputStream inputStream, long length) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
     public java.sql.ResultSet executeQuery() throws java.sql.SQLException {
         if (this.con.isDSML()) {
         	res.unpackJldap((LDAPSearchResults) stmt.executeQuery(),stmt.getRetrieveDN(),this.stmt.getSqlStore().getFrom(),con.getBaseDN(),this.stmt.getSqlStore().getRevFieldMap());
@@ -176,7 +201,11 @@ public class JdbcLdapPreparedStatement extends JdbcLdapStatement implements java
         this.rs = new LdapResultSet(con,this,res,((JdbcLdapSelect) stmt).getBaseContext());
         return rs;
     }
-    
+
+	public void setCharacterStream(int param, java.io.Reader reader) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
     public void setCharacterStream(int param, java.io.Reader reader, int param2) throws java.sql.SQLException {
         char[] c = new char[param2];
         try {
@@ -191,6 +220,10 @@ public class JdbcLdapPreparedStatement extends JdbcLdapStatement implements java
         }
         setVal(param,String.valueOf(c));
     }
+
+	public void setCharacterStream(int param, java.io.Reader reader, long param2) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
     
     public java.sql.ResultSetMetaData getMetaData() throws java.sql.SQLException {
         return rs.getMetaData();
@@ -249,6 +282,10 @@ public class JdbcLdapPreparedStatement extends JdbcLdapStatement implements java
     public int executeUpdate() throws java.sql.SQLException {
         return ((Integer) stmt.executeUpdate()).intValue();
     }
+
+	public void setSQLXML(int parameterIndex, java.sql.SQLXML xmlObject) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
     
     public void setString(int param, java.lang.String str) throws java.sql.SQLException {
         setVal(param,str);
@@ -256,7 +293,15 @@ public class JdbcLdapPreparedStatement extends JdbcLdapStatement implements java
     
     public void setClob(int param, java.sql.Clob clob) throws java.sql.SQLException {
     }
-    
+
+	public void setClob(int param, java.io.Reader reader) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void setClob(int param, java.io.Reader reader, long length) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
     public void addBatch() throws java.sql.SQLException {
         statements.add(stmt);
         loadSQL(stmt.getSqlStore());
@@ -264,7 +309,31 @@ public class JdbcLdapPreparedStatement extends JdbcLdapStatement implements java
     
     public void clearParameters() throws java.sql.SQLException {
     }
-    
+
+	public void setNCharacterStream(int parameterIndex, java.io.Reader reader) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void setNCharacterStream(int parameterIndex, java.io.Reader reader, long length) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void setNClob(int parameterIndex, java.sql.NClob value) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void setNClob(int parameterIndex, java.io.Reader reader) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void setNClob(int parameterIndex, java.io.Reader reader, long length) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void setNString(int parameterIndex, java.lang.String value) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
     public void setNull(int param, int param1) throws java.sql.SQLException {
         setVal(param,null);
     }
@@ -272,5 +341,9 @@ public class JdbcLdapPreparedStatement extends JdbcLdapStatement implements java
     public void setNull(int param, int param1, java.lang.String str) throws java.sql.SQLException {
         setVal(param,null);
     }
+
+	public void setRowId(int parameterIndex, java.sql.RowId x) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
     
 }

src/com/octetstring/jdbcLdap/sql/JdbcLdapStatement.java

@@ -157,6 +157,10 @@ public class JdbcLdapStatement implements java.sql.Statement {
 	public void close() throws java.sql.SQLException {
 	}
 
+	public void closeOnCompletion() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public boolean execute(java.lang.String str) throws java.sql.SQLException {
 		executeQuery(str);
 		return true;
@@ -307,6 +311,18 @@ public class JdbcLdapStatement implements java.sql.Statement {
 		return null;
 	}
 
+	public boolean isClosed() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public boolean isCloseOnCompletion() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public boolean isPoolable() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void setCursorName(java.lang.String str)
 		throws java.sql.SQLException {
 	}
@@ -329,8 +345,20 @@ public class JdbcLdapStatement implements java.sql.Statement {
 		this.maxResults = param;
 	}
 
+	public void setPoolable(boolean poolable) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void setQueryTimeout(int param) throws java.sql.SQLException {
 		this.timeOut = param;
 	}
 
+	public <T>T unwrap(Class<T> iface) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public boolean isWrapperFor(Class<?> iface) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 }

src/com/octetstring/jdbcLdap/sql/LdapResultSet.java

@@ -28,6 +28,7 @@ import java.io.*;
 import java.util.*;
 import java.net.*;
 import java.math.BigDecimal;
+import java.nio.charset.StandardCharsets;
 
 /**
  *Stores the result from a query
@@ -183,12 +184,12 @@ public class LdapResultSet implements java.sql.ResultSet {
 
 	public java.io.InputStream getAsciiStream(int param)
 		throws java.sql.SQLException {
-		return new StringBufferInputStream(getByNum(param));
+		return new ByteArrayInputStream(getByNum(param).getBytes(StandardCharsets.US_ASCII));
 	}
 
 	public java.io.InputStream getAsciiStream(java.lang.String str)
 		throws java.sql.SQLException {
-		return new StringBufferInputStream(getByName(str));
+		return new ByteArrayInputStream(getByName(str).getBytes(StandardCharsets.US_ASCII));
 	}
 
 	public java.math.BigDecimal getBigDecimal(int param)
@@ -201,11 +202,13 @@ public class LdapResultSet implements java.sql.ResultSet {
 		return new BigDecimal(getByName(str));
 	}
 
+	@Deprecated
 	public java.math.BigDecimal getBigDecimal(int param, int param1)
 		throws java.sql.SQLException {
 		return new BigDecimal(getByNum(param));
 	}
 
+	@Deprecated
 	public java.math.BigDecimal getBigDecimal(java.lang.String str, int param)
 		throws java.sql.SQLException {
 		return new BigDecimal(getByName(str));
@@ -330,6 +333,10 @@ public class LdapResultSet implements java.sql.ResultSet {
 		return Float.parseFloat(getByName(str));
 	}
 
+	public int getHoldability() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public int getInt(int param) throws java.sql.SQLException {
 		String val = getByNum(param);
 		return val.length() == 0 ? 0 : Integer.parseInt(val);
@@ -357,22 +364,61 @@ public class LdapResultSet implements java.sql.ResultSet {
 			this.baseDN);
 	}
 
+	public java.io.Reader getNCharacterStream(int columnIndex)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.io.Reader getNCharacterStream(java.lang.String columnLabel)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.sql.NClob getNClob(int columnIndex)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.sql.NClob getNClob(java.lang.String columnLabel)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.lang.String getNString(int columnIndex)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.lang.String getNString(java.lang.String columnLabel)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public java.lang.Object getObject(int param) throws java.sql.SQLException {
 		return getByNum(param);
 	}
 
+	public <T>T getObject(int param, Class<T> type) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public java.lang.Object getObject(java.lang.String str)
 		throws java.sql.SQLException {
 		return getByName(str);
 	}
 
-	public java.lang.Object getObject(int param, java.util.Map map)
+	public <T>T getObject(java.lang.String str, Class<T> type)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.lang.Object getObject(int param, java.util.Map<String, Class<?>> map)
 		throws java.sql.SQLException {
 		return getByNum(param);
 
 	}
 
-	public java.lang.Object getObject(java.lang.String str, java.util.Map map)
+	public java.lang.Object getObject(java.lang.String str, java.util.Map<String, Class<?>> map)
 		throws java.sql.SQLException {
 		return getByName(str);
 	}
@@ -390,6 +436,16 @@ public class LdapResultSet implements java.sql.ResultSet {
 		return pos;
 	}
 
+	public java.sql.RowId getRowId(int columnIndex)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.sql.RowId getRowId(java.lang.String columnLabel)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public short getShort(int param) throws java.sql.SQLException {
 		return Short.parseShort(getByNum(param));
 	}
@@ -398,6 +454,14 @@ public class LdapResultSet implements java.sql.ResultSet {
 		return Short.parseShort(getByName(str));
 	}
 
+	public java.sql.SQLXML getSQLXML(int columnIndex) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public java.sql.SQLXML getSQLXML(java.lang.String columnLabel) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public java.sql.Statement getStatement() throws java.sql.SQLException {
 		return this.statement;
 	}
@@ -477,14 +541,16 @@ public class LdapResultSet implements java.sql.ResultSet {
 		}
 	}
 
+	@Deprecated
 	public java.io.InputStream getUnicodeStream(int param)
 		throws java.sql.SQLException {
-		return new StringBufferInputStream(getByNum(param));
+		return new ByteArrayInputStream(getByNum(param).getBytes(StandardCharsets.UTF_8));
 	}
 
+	@Deprecated
 	public java.io.InputStream getUnicodeStream(java.lang.String str)
 		throws java.sql.SQLException {
-		return new StringBufferInputStream(getByName(str));
+		return new ByteArrayInputStream(getByName(str).getBytes(StandardCharsets.UTF_8));
 	}
 
 	public java.sql.SQLWarning getWarnings() throws java.sql.SQLException {
@@ -503,6 +569,10 @@ public class LdapResultSet implements java.sql.ResultSet {
 		return pos == -1;
 	}
 
+	public boolean isClosed() throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public boolean isFirst() throws java.sql.SQLException {
 		return pos == 0;
 	}
@@ -573,6 +643,13 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateAsciiStream(
+		int param,
+		java.io.InputStream inputStream)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateAsciiStream(
 		int param,
 		java.io.InputStream inputStream,
@@ -581,6 +658,21 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateAsciiStream(
+		int param,
+		java.io.InputStream inputStream,
+		long param2)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateAsciiStream(
+		java.lang.String str,
+		java.io.InputStream inputStream)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateAsciiStream(
 		java.lang.String str,
 		java.io.InputStream inputStream,
@@ -589,6 +681,14 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateAsciiStream(
+		java.lang.String str,
+		java.io.InputStream inputStream,
+		long param)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateBigDecimal(int param, java.math.BigDecimal bigDecimal)
 		throws java.sql.SQLException {
 		throw new SQLException("Not implemented");
@@ -601,6 +701,13 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateBinaryStream(
+		int param,
+		java.io.InputStream inputStream)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateBinaryStream(
 		int param,
 		java.io.InputStream inputStream,
@@ -609,6 +716,21 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateBinaryStream(
+		int param,
+		java.io.InputStream inputStream,
+		long param2)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateBinaryStream(
+		java.lang.String str,
+		java.io.InputStream inputStream)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateBinaryStream(
 		java.lang.String str,
 		java.io.InputStream inputStream,
@@ -617,6 +739,14 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateBinaryStream(
+		java.lang.String str,
+		java.io.InputStream inputStream,
+		long param)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateBlob(int param, java.sql.Blob blob)
 		throws java.sql.SQLException {
 		throw new SQLException("Not implemented");
@@ -627,6 +757,26 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateBlob(int columnIndex, java.io.InputStream inputStream)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateBlob(int columnIndex, java.io.InputStream inputStream, long length)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateBlob(java.lang.String columnLabel, java.io.InputStream inputStream)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateBlob(java.lang.String columnLabel, java.io.InputStream inputStream, long length)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateBoolean(int param, boolean param1)
 		throws java.sql.SQLException {
 		throw new SQLException("Not implemented");
@@ -657,6 +807,13 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateCharacterStream(
+		int param,
+		java.io.Reader reader)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateCharacterStream(
 		int param,
 		java.io.Reader reader,
@@ -665,6 +822,21 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateCharacterStream(
+		int param,
+		java.io.Reader reader,
+		long param2)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateCharacterStream(
+		java.lang.String str,
+		java.io.Reader reader)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateCharacterStream(
 		java.lang.String str,
 		java.io.Reader reader,
@@ -673,6 +845,14 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateCharacterStream(
+		java.lang.String str,
+		java.io.Reader reader,
+		long param)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateClob(int param, java.sql.Clob clob)
 		throws java.sql.SQLException {
 		throw new SQLException("Not implemented");
@@ -683,6 +863,26 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateClob(int columnIndex, java.io.Reader reader)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateClob(int columnIndex, java.io.Reader reader, long length)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateClob(java.lang.String columnLabel, java.io.Reader reader)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateClob(java.lang.String columnLabel, java.io.Reader reader, long length)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateDate(int param, java.sql.Date date)
 		throws java.sql.SQLException {
 		throw new SQLException("Not implemented");
@@ -732,6 +932,64 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateNCharacterStream(int columnIndex, java.io.Reader x)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateNCharacterStream(int columnIndex, java.io.Reader x, long length)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateNCharacterStream(java.lang.String columnLabel, java.io.Reader x)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateNCharacterStream(java.lang.String columnLabel, java.io.Reader x, long length)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateNClob(int columnIndex, java.sql.NClob nClob)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateNClob(int columnIndex, java.io.Reader reader)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateNClob(int columnIndex, java.io.Reader reader, long length)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateNClob(java.lang.String columnLabel, java.sql.NClob nClob)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateNClob(java.lang.String columnLabel, java.io.Reader reader)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateNClob(java.lang.String columnLabel, java.io.Reader reader, long length)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateNString(int columnIndex, java.lang.String nString) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateNString(java.lang.String columnLabel, java.lang.String nString) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateNull(int param) throws java.sql.SQLException {
 		throw new SQLException("Not implemented");
 	}
@@ -777,6 +1035,16 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateRowId(int columnIndex, java.sql.RowId x)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateRowId(java.lang.String columnLabel, java.sql.RowId x)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateShort(int param, short param1)
 		throws java.sql.SQLException {
 		throw new SQLException("Not implemented");
@@ -787,6 +1055,16 @@ public class LdapResultSet implements java.sql.ResultSet {
 		throw new SQLException("Not implemented");
 	}
 
+	public void updateSQLXML(int columnIndex, java.sql.SQLXML xmlObject)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public void updateSQLXML(java.lang.String columnLabel, java.sql.SQLXML xmlObject)
+		throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	public void updateString(int param, java.lang.String str)
 		throws java.sql.SQLException {
 		throw new SQLException("Not implemented");
@@ -823,4 +1101,12 @@ public class LdapResultSet implements java.sql.ResultSet {
 		return this.wasNull;
 	}
 
+	public <T>T unwrap(Class<T> iface) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	public boolean isWrapperFor(Class<?> iface) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 }

src/com/octetstring/jdbcLdap/util/LDIF.java

@@ -360,12 +360,6 @@ public class LDIF {
 	}
 }
 
-class Compare implements Comparator {
-	public int compare(Object v1, Object v2) {
-		return ((String) v1).compareTo(v2);
-	}
-}
-
 class Entry {
 	String dn;
 	HashMap atts;

src/com/octetstring/jdbcLdap/util/ObjRS.java

@@ -14,11 +14,14 @@ import java.sql.Array;
 import java.sql.Blob;
 import java.sql.Clob;
 import java.sql.Date;
+import java.sql.NClob;
 import java.sql.Ref;
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
+import java.sql.RowId;
 import java.sql.SQLException;
 import java.sql.SQLWarning;
+import java.sql.SQLXML;
 import java.sql.Statement;
 import java.sql.Time;
 import java.sql.Timestamp;
@@ -359,6 +362,13 @@ public  class ObjRS implements ResultSet, Serializable {
 		return 0;
 	}
 
+	/**
+	 * @see java.sql.ResultSet#getHoldability()
+	 */
+	public int getHoldability() throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#getInt(int)
 	 */
@@ -590,6 +600,13 @@ public  class ObjRS implements ResultSet, Serializable {
 		return null;
 	}
 
+	/**
+	 * @see java.sql.ResultSet#getObject(int, Class<T>)
+	 */
+	public <T>T getObject(int columnIndex, Class<T> type) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#getObject(String)
 	 */
@@ -597,6 +614,13 @@ public  class ObjRS implements ResultSet, Serializable {
 		return null;
 	}
 
+	/**
+	 * @see java.sql.ResultSet#getObject(String, Class<T>)
+	 */
+	public <T>T getObject(String columnName, Class<T> type) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#findColumn(String)
 	 */
@@ -646,6 +670,13 @@ public  class ObjRS implements ResultSet, Serializable {
 		return false;
 	}
 
+	/**
+	 * @see java.sql.ResultSet#isClosed()
+	 */
+	public boolean isClosed() throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#isFirst()
 	 */
@@ -693,6 +724,20 @@ public  class ObjRS implements ResultSet, Serializable {
 		return 0;
 	}
 
+	/**
+	 * @see java.sql.ResultSet#getRowId(int)
+	 */
+	public RowId getRowId(int columnIndex) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#getRowId(String)
+	 */
+	public RowId getRowId(String columnLabel) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#absolute(int)
 	 */
@@ -775,6 +820,100 @@ public  class ObjRS implements ResultSet, Serializable {
 		return false;
 	}
 
+	/**
+	 * @see updateNCharacterStream(int, Reader)
+	 */
+	public void updateNCharacterStream(int columnIndex, Reader x)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see updateNCharacterStream(int, Reader, long)
+	 */
+	public void updateNCharacterStream(int columnIndex, Reader x, long length)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see updateNCharacterStream(String, Reader)
+	 */
+	public void updateNCharacterStream(String columnLabel, Reader x)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see updateNCharacterStream(String, Reader, long)
+	 */
+	public void updateNCharacterStream(String columnLabel, Reader x, long length)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see updateNClob(int, java.sql.NClob)
+	 */
+	public void updateNClob(int columnIndex, java.sql.NClob nClob)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see updateNClob(int, Reader)
+	 */
+	public void updateNClob(int columnIndex, Reader reader)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see updateNClob(int, Reader, long)
+	 */
+	public void updateNClob(int columnIndex, Reader reader, long length)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see updateNClob(java.lang.String, java.sql.NClob)
+	 */
+	public void updateNClob(java.lang.String columnLabel, java.sql.NClob nClob)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see updateNClob(java.lang.String, Reader)
+	 */
+	public void updateNClob(java.lang.String columnLabel, Reader reader)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see updateNClob(java.lang.String, Reader, long)
+	 */
+	public void updateNClob(java.lang.String columnLabel, Reader reader, long length)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateNString(int, String)
+	 */
+	public void updateNString(int columnIndex, String nString) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateNString(String, String)
+	 */
+	public void updateNString(String columnLabel, String nString) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#updateNull(int)
 	 */
@@ -830,6 +969,22 @@ public  class ObjRS implements ResultSet, Serializable {
 		throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#updateSQLXML(int, SQLXML)
+	 */
+	public void updateSQLXML(int columnIndex, SQLXML xmlObject)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateSQLXML(String, SQLXML)
+	 */
+	public void updateSQLXML(String columnLabel, SQLXML xmlObject)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#updateString(int, String)
 	 */
@@ -861,6 +1016,14 @@ public  class ObjRS implements ResultSet, Serializable {
 		throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#updateAsciiStream(int, InputStream)
+	 */
+	public void updateAsciiStream(int columnIndex, InputStream x)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#updateAsciiStream(int, InputStream, int)
 	 */
@@ -868,6 +1031,22 @@ public  class ObjRS implements ResultSet, Serializable {
 		throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#updateAsciiStream(int, InputStream, long)
+	 */
+	public void updateAsciiStream(int columnIndex, InputStream x, long length)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateBinaryStream(int, InputStream)
+	 */
+	public void updateBinaryStream(int columnIndex, InputStream x)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#updateBinaryStream(int, InputStream, int)
 	 */
@@ -875,6 +1054,21 @@ public  class ObjRS implements ResultSet, Serializable {
 		throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#updateBinaryStream(int, InputStream, long)
+	 */
+	public void updateBinaryStream(int columnIndex, InputStream x, long length)
+		throws SQLException {
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateCharacterStream(int, Reader)
+	 */
+	public void updateCharacterStream(int columnIndex, Reader x)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#updateCharacterStream(int, Reader, int)
 	 */
@@ -882,6 +1076,14 @@ public  class ObjRS implements ResultSet, Serializable {
 		throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#updateCharacterStream(int, Reader, long)
+	 */
+	public void updateCharacterStream(int columnIndex, Reader x, long length)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#updateObject(int, Object, int)
 	 */
@@ -982,6 +1184,14 @@ public  class ObjRS implements ResultSet, Serializable {
 		throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#updateAsciiStream(String, InputStream)
+	 */
+	public void updateAsciiStream(String columnName, InputStream x)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#updateAsciiStream(String, InputStream, int)
 	 */
@@ -989,6 +1199,24 @@ public  class ObjRS implements ResultSet, Serializable {
 		throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#updateAsciiStream(String, InputStream, long)
+	 */
+	public void updateAsciiStream(String columnName, InputStream x, long length)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateBinaryStream(String, InputStream)
+	 */
+	public void updateBinaryStream(
+		String columnName,
+		InputStream x)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#updateBinaryStream(String, InputStream, int)
 	 */
@@ -999,6 +1227,27 @@ public  class ObjRS implements ResultSet, Serializable {
 		throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#updateBinaryStream(String, InputStream, long)
+	 */
+	public void updateBinaryStream(
+		String columnName,
+		InputStream x,
+		long length)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateCharacterStream(String, Reader)
+	 */
+	public void updateCharacterStream(
+		String columnName,
+		Reader reader)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#updateCharacterStream(String, Reader, int)
 	 */
@@ -1009,6 +1258,17 @@ public  class ObjRS implements ResultSet, Serializable {
 		throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#updateCharacterStream(String, Reader, long)
+	 */
+	public void updateCharacterStream(
+		String columnName,
+		Reader reader,
+		long length)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#updateObject(String, Object, int)
 	 */
@@ -1034,6 +1294,20 @@ public  class ObjRS implements ResultSet, Serializable {
 	public void updateRow() throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#updateRowId(int, RowId)
+	 */
+	public void updateRowId(int columnIndex, RowId x) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateRowId(String, RowId)
+	 */
+	public void updateRowId(String columnLabel, RowId x) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#deleteRow()
 	 */
@@ -1064,6 +1338,20 @@ public  class ObjRS implements ResultSet, Serializable {
 	public void moveToCurrentRow() throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#getSQLXML(int)
+	 */
+	public SQLXML getSQLXML(int columnIndex) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#getSQLXML(String)
+	 */
+	public SQLXML getSQLXML(String columnLabel) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#getStatement()
 	 */
@@ -1072,9 +1360,55 @@ public  class ObjRS implements ResultSet, Serializable {
 	}
 
 	/**
-	 * @see java.sql.ResultSet#getObject(int, Map)
+	 * @see java.sql.ResultSet#getNCharacterStream(int)
 	 */
-	public Object getObject(int i, Map map) throws SQLException {
+	public Reader getNCharacterStream(int columnIndex)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#getNCharacterStream(String)
+	 */
+	public Reader getNCharacterStream(String columnLabel)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#getNClob(int)
+	 */
+	public NClob getNClob(int columnIndex) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#getNClob(String)
+	 */
+	public NClob getNClob(String columnLabel) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#getNString(int)
+	 */
+	public String getNString(int columnIndex)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#getNString(String)
+	 */
+	public String getNString(String columnLabel)
+		throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#getObject(int, Map<String, Class<?>>)
+	 */
+	public Object getObject(int i, Map<String, Class<?>> map) throws SQLException {
 		return null;
 	}
 
@@ -1107,9 +1441,9 @@ public  class ObjRS implements ResultSet, Serializable {
 	}
 
 	/**
-	 * @see java.sql.ResultSet#getObject(String, Map)
+	 * @see java.sql.ResultSet#getObject(String, Map<String, Class<?>>)
 	 */
-	public Object getObject(String colName, Map map) throws SQLException {
+	public Object getObject(String colName, Map<String, Class<?>> map) throws SQLException {
 		return null;
 	}
 
@@ -1223,6 +1557,34 @@ public  class ObjRS implements ResultSet, Serializable {
 	public void updateBlob(String columnName, Blob x) throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#updateBlob(int, InputStream)
+	 */
+	public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateBlob(int, InputStream, long)
+	 */
+	public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateBlob(String, InputStream)
+	 */
+	public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateBlob(String, InputStream, long)
+	 */
+	public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#updateClob(int, Clob)
 	 */
@@ -1235,6 +1597,34 @@ public  class ObjRS implements ResultSet, Serializable {
 	public void updateClob(String columnName, Clob x) throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.ResultSet#updateClob(int, Reader)
+	 */
+	public void updateClob(int columnIndex, Reader reader) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateClob(int, Reader, long)
+	 */
+	public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateClob(String, Reader)
+	 */
+	public void updateClob(String columnLabel, Reader reader) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.ResultSet#updateClob(String, Reader, long)
+	 */
+	public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 	/**
 	 * @see java.sql.ResultSet#updateArray(int, Array)
 	 */
@@ -1247,4 +1637,18 @@ public  class ObjRS implements ResultSet, Serializable {
 	public void updateArray(String columnName, Array x) throws SQLException {
 	}
 
+	/**
+	 * @see java.sql.Wrapper#unwrap(Class<T>)
+	 */
+	public <T>T unwrap(Class<T> iface) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
+	/**
+	 * @see java.sql.Wrapper#isWrapperFor(Class<?>)
+	 */
+	public boolean isWrapperFor(Class<?> iface) throws java.sql.SQLException {
+		throw new SQLException("Not implemented");
+	}
+
 }

src/com/octetstring/jdbcLdap/util/RSMetaData.java

@@ -343,6 +343,14 @@ public String getColumnClassName(int x) throws java.sql.SQLException {
 	return "";
 }
 
+public <T>T unwrap(Class<T> iface) throws java.sql.SQLException {
+	throw new SQLException("Not implemented");
+}
+
+public boolean isWrapperFor(Class<?> iface) throws java.sql.SQLException {
+	throw new SQLException("Not implemented");
+}
+
 // *********************************************************************
 //
 //                END OF PUBLIC INTERFACE