Anonymous avatar Anonymous committed 20635ce

tagging 1.0.3 of Java CQL driver

git-svn-id: https://svn.apache.org/repos/asf/cassandra/tags/drivers@1130850 13f79535-47bb-0310-9956-ffa450edef68

Comments (0)

Files changed (17)

java/1.0.3/src/org/apache/cassandra/cql/jdbc/AbstractResultSet.java

+package org.apache.cassandra.cql.jdbc;
+/*
+ * 
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * 
+ */
+
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.*;
+
+/** a class to hold all the unimplemented crap */
+class AbstractResultSet
+{
+    public boolean absolute(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void afterLast() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void beforeFirst() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void cancelRowUpdates() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void clearWarnings() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void deleteRow() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public int findColumn(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public boolean first() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Array getArray(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Array getArray(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public InputStream getAsciiStream(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public InputStream getAsciiStream(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public InputStream getBinaryStream(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public InputStream getBinaryStream(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Blob getBlob(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Blob getBlob(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public byte getByte(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public byte getByte(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Reader getCharacterStream(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Reader getCharacterStream(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Clob getClob(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Clob getClob(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public int getConcurrency() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public String getCursorName() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public int getFetchDirection() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public int getFetchSize() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public int getHoldability() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Ref getRef(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Ref getRef(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public RowId getRowId(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public RowId getRowId(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public SQLXML getSQLXML(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public SQLXML getSQLXML(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public short getShort(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public short getShort(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Statement getStatement() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public URL getURL(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public URL getURL(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public InputStream getUnicodeStream(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public InputStream getUnicodeStream(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public SQLWarning getWarnings() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void insertRow() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void moveToCurrentRow() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void moveToInsertRow() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public boolean previous() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void refreshRow() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public boolean relative(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public boolean rowDeleted() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public boolean rowInserted() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public boolean rowUpdated() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void setFetchDirection(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void setFetchSize(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Reader getNCharacterStream(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Reader getNCharacterStream(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public NClob getNClob(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public NClob getNClob(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public String getNString(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public String getNString(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public BigDecimal getBigDecimal(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public BigDecimal getBigDecimal(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public BigDecimal getBigDecimal(int arg0, int arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public BigDecimal getBigDecimal(String arg0, int arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    //
+    // all the update methods are unsupported, requires a separate statement in Cassandra
+    //
+
+    public void updateArray(int arg0, Array arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateArray(String arg0, Array arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateAsciiStream(int arg0, InputStream arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateAsciiStream(String arg0, InputStream arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateAsciiStream(int arg0, InputStream arg1, int arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateAsciiStream(String arg0, InputStream arg1, int arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateAsciiStream(int arg0, InputStream arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateAsciiStream(String arg0, InputStream arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBigDecimal(int arg0, BigDecimal arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBigDecimal(String arg0, BigDecimal arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBinaryStream(int arg0, InputStream arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBinaryStream(String arg0, InputStream arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBinaryStream(int arg0, InputStream arg1, int arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBinaryStream(String arg0, InputStream arg1, int arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBinaryStream(int arg0, InputStream arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBinaryStream(String arg0, InputStream arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBlob(int arg0, Blob arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBlob(String arg0, Blob arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBlob(int arg0, InputStream arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBlob(String arg0, InputStream arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBlob(int arg0, InputStream arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBlob(String arg0, InputStream arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBoolean(int arg0, boolean arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBoolean(String arg0, boolean arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateByte(int arg0, byte arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateByte(String arg0, byte arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBytes(int arg0, byte[] arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateBytes(String arg0, byte[] arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateCharacterStream(int arg0, Reader arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateCharacterStream(String arg0, Reader arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateCharacterStream(int arg0, Reader arg1, int arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateCharacterStream(String arg0, Reader arg1, int arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateCharacterStream(int arg0, Reader arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateCharacterStream(String arg0, Reader arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateClob(int arg0, Clob arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateClob(String arg0, Clob arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateClob(int arg0, Reader arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateClob(String arg0, Reader arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateClob(int arg0, Reader arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateClob(String arg0, Reader arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateDate(int arg0, Date arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateDate(String arg0, Date arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateDouble(int arg0, double arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateDouble(String arg0, double arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateFloat(int arg0, float arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateFloat(String arg0, float arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateInt(int arg0, int arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateInt(String arg0, int arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateLong(int arg0, long arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateLong(String arg0, long arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNCharacterStream(int arg0, Reader arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNCharacterStream(String arg0, Reader arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNCharacterStream(int arg0, Reader arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNCharacterStream(String arg0, Reader arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNClob(int arg0, NClob arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNClob(String arg0, NClob arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNClob(int arg0, Reader arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNClob(String arg0, Reader arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNClob(int arg0, Reader arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNClob(String arg0, Reader arg1, long arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNString(int arg0, String arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNString(String arg0, String arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNull(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateNull(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateObject(int arg0, Object arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateObject(String arg0, Object arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateObject(int arg0, Object arg1, int arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateObject(String arg0, Object arg1, int arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateRef(int arg0, Ref arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateRef(String arg0, Ref arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateRow() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateRowId(int arg0, RowId arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateRowId(String arg0, RowId arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateSQLXML(int arg0, SQLXML arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateSQLXML(String arg0, SQLXML arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateShort(int arg0, short arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateShort(String arg0, short arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateString(int arg0, String arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateString(String arg0, String arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateTime(int arg0, Time arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateTime(String arg0, Time arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateTimestamp(int arg0, Timestamp arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public void updateTimestamp(String arg0, Timestamp arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+}

java/1.0.3/src/org/apache/cassandra/cql/jdbc/CResultSet.java

+/*
+ * 
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * 
+ */
+package org.apache.cassandra.cql.jdbc;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.net.URL;
+import java.nio.ByteBuffer;
+import java.sql.*;
+import java.sql.Date;
+import java.util.*;
+
+import org.apache.cassandra.db.marshal.CounterColumnType;
+import org.apache.cassandra.thrift.Column;
+import org.apache.cassandra.thrift.CqlResult;
+import org.apache.cassandra.thrift.CqlRow;
+import org.apache.cassandra.utils.ByteBufferUtil;
+
+public class CResultSet extends AbstractResultSet implements CassandraResultSet
+{
+    private final ColumnDecoder decoder;
+    private final String keyspace;
+    private final String columnFamily;
+    
+    /** The r set iter. */
+    private Iterator<CqlRow> rSetIter;
+    int rowNumber = 0;
+    
+    // the current row key when iterating through results.
+    private byte[] curRowKey = null;
+    
+    /** The values. */
+    private List<TypedColumn> values = new ArrayList<TypedColumn>();
+    
+    /** The value map. */
+    private Map<String, TypedColumn> valueMap = new HashMap<String, TypedColumn>();
+    
+    private final CResultSetMetaData meta;
+    
+    private boolean wasNull;
+
+    /**
+     * Instantiates a new cassandra result set.
+     *
+     * @param resultSet the result set
+     */
+    CResultSet(CqlResult resultSet, ColumnDecoder decoder, String keyspace, String columnFamily)
+    {
+        this.decoder = decoder;
+        this.keyspace = keyspace;
+        this.columnFamily = columnFamily;
+        rSetIter = resultSet.getRowsIterator();
+        meta = new CResultSetMetaData();
+    }
+
+    public byte[] getKey()
+    {
+        return curRowKey;
+    }
+
+    public TypedColumn getColumn(int i)
+    {
+        return values.get(i);
+    }
+
+    public TypedColumn getColumn(String name)
+    {
+        return valueMap.get(name);
+    }
+
+    public void close() throws SQLException
+    {
+        valueMap = null;
+        values = null;
+    }
+
+    private byte[] getBytes(TypedColumn column)
+    {
+        ByteBuffer value = (ByteBuffer) column.getValue();
+        wasNull = value == null;
+        return value == null ? null : ByteBufferUtil.clone(value).array();
+    }
+
+    public byte[] getBytes(int index) throws SQLException
+    {
+        return getBytes(values.get(index - 1));
+    }
+
+    public byte[] getBytes(String name) throws SQLException
+    {
+        return getBytes(valueMap.get(name));
+    }
+
+    public Date getDate(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Date getDate(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Date getDate(int arg0, Calendar arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Date getDate(String arg0, Calendar arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public double getDouble(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public double getDouble(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public float getFloat(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public float getFloat(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public boolean getBoolean(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public boolean getBoolean(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    private BigInteger getBigInteger(TypedColumn column)
+    {
+        BigInteger value = (BigInteger) column.getValue();
+        wasNull = value == null;
+        return value;
+    }
+
+    public BigInteger getBigInteger(int i)
+    {
+        return getBigInteger(values.get(i - 1));
+    }
+
+    public BigInteger getBigInteger(String name)
+    {
+        return getBigInteger(valueMap.get(name));
+    }
+
+    private int getInt(TypedColumn column) throws SQLException
+    {
+        // bit of a hack, this, but asking for getInt seems so common that we should accomodate it
+        if (column.getValue() instanceof BigInteger)
+        {
+            wasNull = false;
+            return getBigInteger(column).intValue();
+        }
+        else if (column.getValue() instanceof Long)
+        {
+            wasNull = false;
+            return getLong(column).intValue();
+        }
+        else if (column.getValue() == null)
+        {
+            wasNull = true;
+            return 0;
+        }
+        throw new SQLException("Non-integer value " + column.getValue());
+    }
+
+    public int getInt(int index) throws SQLException
+    {
+        return getInt(values.get(index - 1));
+    }
+
+    public int getInt(String name) throws SQLException
+    {
+        return getInt(valueMap.get(name));
+    }
+
+    private Long getLong(TypedColumn column)
+    {
+        Long value = (Long) column.getValue();
+        wasNull = value == null;
+        return value == null ? 0 : value;
+    }
+
+    public long getLong(int index) throws SQLException
+    {
+        return getLong(values.get(index - 1));
+    }
+
+    public long getLong(String name) throws SQLException
+    {
+        return getLong(valueMap.get(name));
+    }
+
+    public ResultSetMetaData getMetaData() throws SQLException
+    {
+        return meta;
+    }
+
+    private Object getObject(TypedColumn column)
+    {
+        Object value = column.getValue();
+        wasNull = value == null;
+        return value;
+    }
+
+    public Object getObject(int index) throws SQLException
+    {
+        return getObject(values.get(index - 1));
+    }
+
+    public Object getObject(String name) throws SQLException
+    {
+        return getObject(valueMap.get(name));
+    }
+
+    public Object getObject(int arg0, Map<String, Class<?>> arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Object getObject(String arg0, Map<String, Class<?>> arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public int getRow() throws SQLException
+    {
+        return rowNumber;
+    }
+
+    private String getString(TypedColumn column)
+    {
+        String value = (String) column.getValue();
+        wasNull = value == null;
+        return value == null ? null : value;
+    }
+
+    public String getString(int index) throws SQLException
+    {
+        return getString(values.get(index - 1));
+    }
+
+    public String getString(String name) throws SQLException
+    {
+        return getString(valueMap.get(name));
+    }
+
+    public Time getTime(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Time getTime(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Time getTime(int arg0, Calendar arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Time getTime(String arg0, Calendar arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Timestamp getTimestamp(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Timestamp getTimestamp(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Timestamp getTimestamp(int arg0, Calendar arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public Timestamp getTimestamp(String arg0, Calendar arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public int getType() throws SQLException
+    {
+        return ResultSet.TYPE_FORWARD_ONLY;
+    }
+
+    public boolean isAfterLast() throws SQLException
+    {
+        return rowNumber == Integer.MAX_VALUE;
+    }
+
+    public boolean isBeforeFirst() throws SQLException
+    {
+        return rowNumber == 0;
+    }
+
+    public boolean isClosed() throws SQLException
+    {
+        return valueMap == null;
+    }
+
+    public boolean isFirst() throws SQLException
+    {
+        return rowNumber == 1;
+    }
+
+    public boolean isLast() throws SQLException
+    {
+        return !rSetIter.hasNext();
+    }
+
+    public boolean last() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    public <T> T unwrap(Class<T> iface) throws SQLException
+    {
+        if (iface.equals(CassandraResultSet.class))
+            return (T) this;
+        throw new SQLException("Unsupported unwrap interface: " + iface.getSimpleName());
+    }
+    
+    public boolean isWrapperFor(Class<?> iface) throws SQLException
+    {
+        return CassandraResultSet.class.isAssignableFrom(iface);
+    }
+
+    public synchronized boolean next() throws SQLException
+    {
+        if (!values.isEmpty() || !valueMap.isEmpty())
+        {
+            values.clear();
+            valueMap.clear();
+        }
+        if (rSetIter != null && rSetIter.hasNext())
+        {
+            CqlRow row = rSetIter.next();
+            rowNumber++;
+            curRowKey = row.getKey();
+            List<Column> cols = row.getColumns();
+            for (Column col : cols)
+            {
+
+                TypedColumn c = decoder.makeCol(keyspace, columnFamily, col);
+                values.add(c);
+                valueMap.put(decoder.colNameAsString(keyspace, columnFamily, col.name), c);
+            }
+            return !(values.isEmpty() && valueMap.isEmpty());
+        } 
+        else
+        {
+            rowNumber = Integer.MAX_VALUE;
+            return false;
+        }
+    }
+
+    public boolean wasNull() throws SQLException
+    {
+        return wasNull;
+    }
+    
+    /**
+     * RSMD implementation.  The metadata returned refers to the column
+     * values, not the column names.
+     */
+    class CResultSetMetaData implements ResultSetMetaData
+    {
+        private void checkIndex(int i) throws SQLException
+        {
+            if (i >= values.size())
+                throw new SQLException("Invalid column index " + i);
+        }
+        
+        public int getColumnCount() throws SQLException
+        {
+            return values.size();
+        }
+
+        public boolean isAutoIncrement(int column) throws SQLException
+        {
+            column--;
+            checkIndex(column);
+            return values.get(column).getValueType() instanceof CounterColumnType; // todo: check Value is correct.
+        }
+
+        public boolean isCaseSensitive(int column) throws SQLException
+        {
+            column--;
+            checkIndex(column);
+            TypedColumn tc = values.get(column);
+            return tc.getValueType().isCaseSensitive();
+        }
+
+        public boolean isSearchable(int column) throws SQLException
+        {
+            return false;
+        }
+
+        public boolean isCurrency(int column) throws SQLException
+        {
+            column--;
+            checkIndex(column);
+            TypedColumn tc = values.get(column);
+            return tc.getValueType().isCurrency();
+        }
+
+        /** absence is the equivalent of null in Cassandra */
+        public int isNullable(int column) throws SQLException
+        {
+            return ResultSetMetaData.columnNullable;
+        }
+
+        public boolean isSigned(int column) throws SQLException
+        {
+            column--;
+            checkIndex(column);
+            TypedColumn tc = values.get(column);
+            return tc.getValueType().isSigned();
+        }
+
+        public int getColumnDisplaySize(int column) throws SQLException
+        {
+            column--;
+            checkIndex(column);
+            return values.get(column).getValueString().length();
+        }
+
+        public String getColumnLabel(int column) throws SQLException
+        {
+            return getColumnName(column);
+        }
+
+        public String getColumnName(int column) throws SQLException
+        {
+            column--;
+            checkIndex(column);
+            return values.get(column).getNameString();
+        }
+
+        public String getSchemaName(int column) throws SQLException
+        {
+            return keyspace;
+        }
+
+        public int getPrecision(int column) throws SQLException
+        {
+            column--;
+            checkIndex(column);
+            TypedColumn col = values.get(column);
+            return col.getValueType().getPrecision(col.getValue());
+        }
+
+        public int getScale(int column) throws SQLException
+        {
+            column--;
+            checkIndex(column);
+            TypedColumn tc = values.get(column);
+            return tc.getValueType().getScale(tc.getValue());
+        }
+
+        public String getTableName(int column) throws SQLException
+        {
+            return columnFamily;
+        }
+
+        public String getCatalogName(int column) throws SQLException
+        {
+            throw new SQLFeatureNotSupportedException("Cassandra has no catalogs");
+        }
+
+        public int getColumnType(int column) throws SQLException
+        {
+            column--;
+            checkIndex(column);
+            return values.get(column).getValueType().getJdbcType();
+        }
+
+        // todo: spec says "database specific type name". this means the abstract type.
+        public String getColumnTypeName(int column) throws SQLException
+        {
+            column--;
+            checkIndex(column);
+            return values.get(column).getValueType().getClass().getSimpleName();
+        }
+
+        public boolean isReadOnly(int column) throws SQLException
+        {
+            return column == 0;
+        }
+
+        public boolean isWritable(int column) throws SQLException
+        {
+            return column > 0;
+        }
+
+        public boolean isDefinitelyWritable(int column) throws SQLException
+        {
+            return isWritable(column);
+        }
+
+        public String getColumnClassName(int column) throws SQLException
+        {
+            column--;
+            checkIndex(column);
+            return values.get(column).getValueType().getType().getName();
+        }
+
+        public <T> T unwrap(Class<T> iface) throws SQLException
+        {
+            throw new SQLException("No wrapping implemented");
+        }
+
+        public boolean isWrapperFor(Class<?> iface) throws SQLException
+        {
+            return false;
+        }
+    }
+}

java/1.0.3/src/org/apache/cassandra/cql/jdbc/CassandraConnection.java

+/*
+ * 
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * 
+ */
+package org.apache.cassandra.cql.jdbc;
+
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.CallableStatement;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.NClob;
+import java.sql.PreparedStatement;
+import java.sql.SQLClientInfoException;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Savepoint;
+import java.sql.Statement;
+import java.sql.Struct;
+import java.util.Map;
+import java.util.Properties;
+
+import org.apache.cassandra.thrift.AuthenticationException;
+import org.apache.cassandra.thrift.AuthorizationException;
+import org.apache.cassandra.thrift.InvalidRequestException;
+import org.apache.cassandra.thrift.SchemaDisagreementException;
+import org.apache.cassandra.thrift.TimedOutException;
+import org.apache.cassandra.thrift.UnavailableException;
+import org.apache.thrift.TException;
+import org.apache.thrift.transport.TTransportException;
+
+/**
+ * Implementation class for {@link Connection}.
+ */
+class CassandraConnection implements Connection
+{
+    
+    /** The cassandra con. */
+    private org.apache.cassandra.cql.jdbc.Connection cassandraCon;
+    
+    /**
+     * Instantiates a new cassandra connection.
+     *
+     * @param url the url
+     */
+    public CassandraConnection(String url)
+    {
+        try
+        {
+            final int splitIndex = url.indexOf('@');
+            final String usr_pwd = url.substring(0, splitIndex);
+            final String host_port = url.substring(splitIndex + 1);
+            final int usr_colonIdx = usr_pwd.lastIndexOf(':');
+            final int usr_backwardIdx = usr_pwd.indexOf('/');
+            final String userName = usr_pwd.substring(usr_colonIdx + 1, usr_backwardIdx);
+            final String password = usr_pwd.substring(usr_backwardIdx + 1);
+            final int host_colonIdx = host_port.indexOf(':');
+            final String hostName = host_port.substring(0, host_colonIdx);
+            final int host_backwardIdx = host_port.indexOf('/');
+            final String port = host_port.substring(host_colonIdx + 1, host_backwardIdx);
+            final String keyspace = host_port.substring(host_backwardIdx + 1);
+            cassandraCon = new org.apache.cassandra.cql.jdbc.Connection(hostName, Integer.valueOf(port), userName,
+                                                                                                                             password);
+            final String useQ = "USE " + keyspace;
+            cassandraCon.execute(useQ);
+        }
+        catch (NumberFormatException e)
+        {
+            throw new DriverResolverException(e.getMessage());
+        }
+        catch (TTransportException e)
+        {
+            throw new DriverResolverException(e.getMessage());
+        }
+        catch (AuthenticationException e)
+        {
+            throw new DriverResolverException(e.getMessage());
+        }
+        catch (AuthorizationException e)
+        {
+            throw new DriverResolverException(e.getMessage());
+        }
+        catch (TException e)
+        {
+            throw new DriverResolverException(e.getMessage());
+        }
+        catch (InvalidRequestException e)
+        {
+            throw new DriverResolverException(e.getMessage());
+        }
+        catch (UnavailableException e)
+        {
+            throw new DriverResolverException(e.getMessage());
+        }
+        catch (TimedOutException e)
+        {
+            throw new DriverResolverException(e.getMessage());
+        }
+        catch (SchemaDisagreementException e)
+        {
+            throw new DriverResolverException("schema does not match across nodes, (try again later).");
+        }
+
+    }
+    
+    /**
+     * @param arg0
+     * @return
+     * @throws SQLException
+     */
+    public boolean isWrapperFor(Class<?> arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    
+    /**
+     * @param <T>
+     * @param arg0
+     * @return
+     * @throws SQLException
+     */
+    public <T> T unwrap(Class<T> arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+
+    /**
+     * @throws SQLException
+     */
+    public void clearWarnings() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    /**
+     * On close of connection.
+     *
+     * @throws SQLException the sQL exception
+     */
+    public void close() throws SQLException
+    {
+        if (cassandraCon != null)
+        {
+            cassandraCon.close();
+        }
+    }
+
+
+    /**
+     * @throws SQLException
+     */
+    public void commit() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @param arg1
+     * @return
+     * @throws SQLException
+     */
+    public Array createArrayOf(String arg0, Object[] arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public Blob createBlob() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public Clob createClob() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public NClob createNClob() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public SQLXML createSQLXML() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+    
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public Statement createStatement() throws SQLException
+    {
+        return new CassandraStatement(this.cassandraCon);
+    }
+
+
+    /**
+     * @param arg0
+     * @param arg1
+     * @return
+     * @throws SQLException
+     */
+    public Statement createStatement(int arg0, int arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @param arg1
+     * @param arg2
+     * @return
+     * @throws SQLException
+     */
+    public Statement createStatement(int arg0, int arg1, int arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @param arg1
+     * @return
+     * @throws SQLException
+     */
+    public Struct createStruct(String arg0, Object[] arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public boolean getAutoCommit() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public String getCatalog() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public Properties getClientInfo() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @return
+     * @throws SQLException
+     */
+    public String getClientInfo(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public int getHoldability() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public DatabaseMetaData getMetaData() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public int getTransactionIsolation() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public Map<String, Class<?>> getTypeMap() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public SQLWarning getWarnings() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public boolean isClosed() throws SQLException
+    {
+        return false;
+    }
+
+
+    /**
+     * @return
+     * @throws SQLException
+     */
+    public boolean isReadOnly() throws SQLException
+    {
+        return false;
+    }
+
+
+    /**
+     * @param arg0
+     * @return
+     * @throws SQLException
+     */
+    public boolean isValid(int arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @return
+     * @throws SQLException
+     */
+    public String nativeSQL(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @return
+     * @throws SQLException
+     */
+    public CallableStatement prepareCall(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @param arg1
+     * @param arg2
+     * @return
+     * @throws SQLException
+     */
+    public CallableStatement prepareCall(String arg0, int arg1, int arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @param arg1
+     * @param arg2
+     * @param arg3
+     * @return
+     * @throws SQLException
+     */
+    public CallableStatement prepareCall(String arg0, int arg1, int arg2, int arg3) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param sql
+     * @return
+     * @throws SQLException
+     */
+    public PreparedStatement prepareStatement(String sql) throws SQLException
+    {
+        return new CassandraPreparedStatement(this.cassandraCon, sql);
+    }
+
+
+    /**
+     * @param arg0
+     * @param arg1
+     * @return
+     * @throws SQLException
+     */
+    public PreparedStatement prepareStatement(String arg0, int arg1) throws SQLException
+    {
+        return null;
+    }
+
+
+    /**
+     * @param arg0
+     * @param arg1
+     * @return
+     * @throws SQLException
+     */
+    public PreparedStatement prepareStatement(String arg0, int[] arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @param arg1
+     * @return
+     * @throws SQLException
+     */
+    public PreparedStatement prepareStatement(String arg0, String[] arg1) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @param arg1
+     * @param arg2
+     * @return
+     * @throws SQLException
+     */
+    public PreparedStatement prepareStatement(String arg0, int arg1, int arg2) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @param arg1
+     * @param arg2
+     * @param arg3
+     * @return
+     * @throws SQLException
+     */
+    public PreparedStatement prepareStatement(String arg0, int arg1, int arg2, int arg3) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @throws SQLException
+     */
+    public void releaseSavepoint(Savepoint arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+
+    }
+
+
+    /**
+     * @throws SQLException
+     */ 
+    public void rollback() throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+
+    }
+
+
+    /**
+     * @param arg0
+     * @throws SQLException
+     */
+    public void rollback(Savepoint arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+
+    }
+
+
+    /**
+     * @param arg0
+     * @throws SQLException
+     */
+    public void setAutoCommit(boolean arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+
+    }
+
+
+    /**
+     * @param arg0
+     * @throws SQLException
+     */
+    public void setCatalog(String arg0) throws SQLException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }
+
+
+    /**
+     * @param arg0
+     * @throws SQLClientInfoException
+     */
+    public void setClientInfo(Properties arg0) throws SQLClientInfoException
+    {
+        throw new UnsupportedOperationException("method not supported");
+    }