Return-Path: Delivered-To: apmail-harmony-commits-archive@www.apache.org Received: (qmail 80653 invoked from network); 3 Mar 2008 08:16:33 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (140.211.11.2) by minotaur.apache.org with SMTP; 3 Mar 2008 08:16:33 -0000 Received: (qmail 17394 invoked by uid 500); 3 Mar 2008 08:16:29 -0000 Delivered-To: apmail-harmony-commits-archive@harmony.apache.org Received: (qmail 17376 invoked by uid 500); 3 Mar 2008 08:16:29 -0000 Mailing-List: contact commits-help@harmony.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@harmony.apache.org Delivered-To: mailing list commits@harmony.apache.org Received: (qmail 17366 invoked by uid 99); 3 Mar 2008 08:16:29 -0000 Received: from athena.apache.org (HELO athena.apache.org) (140.211.11.136) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 03 Mar 2008 00:16:29 -0800 X-ASF-Spam-Status: No, hits=-2000.0 required=10.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.3] (HELO eris.apache.org) (140.211.11.3) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 03 Mar 2008 08:16:01 +0000 Received: by eris.apache.org (Postfix, from userid 65534) id C683B1A9832; Mon, 3 Mar 2008 00:16:11 -0800 (PST) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r632978 - in /harmony/enhanced/classlib/trunk/modules/sql/src: main/java/org/apache/harmony/sql/internal/nls/ main/java/org/apache/harmony/sql/internal/rowset/ test/java/org/apache/harmony/sql/tests/internal/rowset/ Date: Mon, 03 Mar 2008 08:16:08 -0000 To: commits@harmony.apache.org From: tonywu@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20080303081611.C683B1A9832@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Author: tonywu Date: Mon Mar 3 00:16:06 2008 New Revision: 632978 URL: http://svn.apache.org/viewvc?rev=632978&view=rev Log: Apply patch for HARMONY-5561 (implements all update methods in CachedRowSet) Added: harmony/enhanced/classlib/trunk/modules/sql/src/test/java/org/apache/harmony/sql/tests/internal/rowset/CachedRowSetUpdateTest.java (with props) Modified: harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/nls/messages.properties harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/rowset/CachedRow.java harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/rowset/CachedRowSetImpl.java harmony/enhanced/classlib/trunk/modules/sql/src/test/java/org/apache/harmony/sql/tests/internal/rowset/CachedRowSetImplTest.java Modified: harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/nls/messages.properties URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/nls/messages.properties?rev=632978&r1=632977&r2=632978&view=diff ============================================================================== --- harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/nls/messages.properties (original) +++ harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/nls/messages.properties Mon Mar 3 00:16:06 2008 @@ -68,5 +68,6 @@ rowset.5=There are conflicts between rowset and data source rowset.6=Errors in the process of Writing Back RowData rowset.7=Not a valid cursor -rowset.8=The Result Set Type is TYPE_FORWARD_ONLY -rowset.9=PageSize can not larger than MaxRows +rowset.8=The ResultSet type is TYPE_FORWARD_ONLY +rowset.9=PageSize can not be larger than MaxRows +rowset.10=Data type mismatch Modified: harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/rowset/CachedRow.java URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/rowset/CachedRow.java?rev=632978&r1=632977&r2=632978&view=diff ============================================================================== --- harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/rowset/CachedRow.java (original) +++ harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/rowset/CachedRow.java Mon Mar 3 00:16:06 2008 @@ -122,6 +122,14 @@ return new CachedRow(originalColumnData); } + public void setOriginal() { + isUpdate = false; + isDelete = false; + isInsert = false; + mask.flip(0, columnData.length); + originalColumnData = columnData.clone(); + } + public Object getObject(int columnIndex) { return columnData[columnIndex - 1]; } Modified: harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/rowset/CachedRowSetImpl.java URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/rowset/CachedRowSetImpl.java?rev=632978&r1=632977&r2=632978&view=diff ============================================================================== --- harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/rowset/CachedRowSetImpl.java (original) +++ harmony/enhanced/classlib/trunk/modules/sql/src/main/java/org/apache/harmony/sql/internal/rowset/CachedRowSetImpl.java Mon Mar 3 00:16:06 2008 @@ -34,8 +34,10 @@ import java.sql.SQLWarning; import java.sql.Savepoint; import java.sql.Statement; +import java.sql.Struct; import java.sql.Time; import java.sql.Timestamp; +import java.sql.Types; import java.util.ArrayList; import java.util.Calendar; import java.util.Collection; @@ -96,15 +98,50 @@ // TODO where is it initialized private CachedRowSetImpl originalResultSet; - private Object currentColumn; - private SQLWarning sqlwarn; + private Class[] columnTypes; + + private static Map TYPE_MAPPING = initialTypeMapping(); + + public static final String PROVIDER_ID = "Apache Harmony HYOptimisticProvider"; //$NON-NLS-1$ + public CachedRowSetImpl(String providerID) throws SyncFactoryException { syncProvider = SyncFactory.getInstance(providerID); initialProperties(); } + private static Map initialTypeMapping() { + HashMap map = new HashMap(); + map.put(Integer.valueOf(Types.ARRAY), Array.class); + map.put(Integer.valueOf(Types.BIGINT), Long.class); + map.put(Integer.valueOf(Types.BINARY), byte[].class); + map.put(Integer.valueOf(Types.BIT), Boolean.class); + map.put(Integer.valueOf(Types.BLOB), Blob.class); + map.put(Integer.valueOf(Types.BOOLEAN), Boolean.class); + map.put(Integer.valueOf(Types.CHAR), String.class); + map.put(Integer.valueOf(Types.CLOB), Clob.class); + map.put(Integer.valueOf(Types.DATE), Date.class); + map.put(Integer.valueOf(Types.DECIMAL), BigDecimal.class); + map.put(Integer.valueOf(Types.DOUBLE), Double.class); + map.put(Integer.valueOf(Types.FLOAT), Double.class); + map.put(Integer.valueOf(Types.INTEGER), Integer.class); + map.put(Integer.valueOf(Types.LONGVARBINARY), byte[].class); + map.put(Integer.valueOf(Types.LONGVARCHAR), String.class); + map.put(Integer.valueOf(Types.NUMERIC), BigDecimal.class); + map.put(Integer.valueOf(Types.REAL), Float.class); + map.put(Integer.valueOf(Types.REF), Ref.class); + map.put(Integer.valueOf(Types.SMALLINT), Short.class); + map.put(Integer.valueOf(Types.STRUCT), Struct.class); + map.put(Integer.valueOf(Types.TIME), Time.class); + map.put(Integer.valueOf(Types.TIMESTAMP), Timestamp.class); + map.put(Integer.valueOf(Types.TINYINT), Byte.class); + map.put(Integer.valueOf(Types.VARBINARY), byte[].class); + map.put(Integer.valueOf(Types.VARCHAR), String.class); + + return map; + } + private void initialProperties() { try { setEscapeProcessing(true); @@ -126,7 +163,7 @@ } public CachedRowSetImpl() throws SyncFactoryException { - this("Apache Harmony HYOptimisticProvider"); + this(PROVIDER_ID); } public void setRows(ArrayList data, int cloumnCount) { @@ -176,7 +213,7 @@ public boolean columnUpdated(int idx) throws SQLException { if (currentRow == null || idx > meta.getColumnCount()) { // rowset.0 = Not a valid position - throw new SQLException(Messages.getString("rowset.0")); + throw new SQLException(Messages.getString("rowset.0")); //$NON-NLS-1$ } return currentRow.getUpdateMask(idx - 1); } @@ -192,7 +229,7 @@ } } // rowset.1=Not a valid column name - throw new SQLException(Messages.getString("rowset.1")); + throw new SQLException(Messages.getString("rowset.1")); //$NON-NLS-1$ } public void commit() throws SQLException { @@ -206,7 +243,7 @@ * the attribute of BaseRowSet which are needed to deep copy */ // BaseRowSet.params - Object[] paramsObjArray = super.getParams().clone(); + Object[] paramsObjArray = super.getParams(); Hashtable paramsHashtable = new Hashtable(); for (int i = 0; i < paramsObjArray.length; i++) { paramsHashtable.put(Integer.valueOf(i), paramsObjArray[i]); @@ -298,7 +335,6 @@ CachedRowSetImpl output = (CachedRowSetImpl) createCopy(); // clean up rows data - output.currentColumn = null; output.currentRow = null; output.currentRowIndex = 0; output.insertRow = null; @@ -408,6 +444,14 @@ private void doPopulate(ResultSet rs, boolean isPaging) throws SQLException { meta = copyMetaData(rs.getMetaData()); + columnCount = meta.getColumnCount(); + // initial columnTypes + columnTypes = new Class[columnCount]; + for (int i = 1; i <= columnTypes.length; ++i) { + columnTypes[i - 1] = TYPE_MAPPING.get(Integer.valueOf(meta + .getColumnType(i))); + } + /* * this method not support paging, so before readData set pageSize and * maxRowsto 0 and restore previous values after readData @@ -526,11 +570,11 @@ public void setPageSize(int size) throws SQLException { if (size < 0) { // rowset.2=Negative page size - throw new SQLException(Messages.getString("rowset.2")); + throw new SQLException(Messages.getString("rowset.2")); //$NON-NLS-1$ } if ((getMaxRows() != 0) && (getMaxRows() < size)) { // rowset.9=PageSize can not larger than MaxRows - throw new SQLException(Messages.getString("rowset.9")); + throw new SQLException(Messages.getString("rowset.9")); //$NON-NLS-1$ } pageSize = size; } @@ -542,7 +586,7 @@ public void setTableName(String tabName) throws SQLException { if (tabName == null) { // rowset.3=Table name should not be null - throw new SQLException("rowset.3"); + throw new SQLException("rowset.3"); //$NON-NLS-1$ } tableName = tabName; } @@ -645,7 +689,7 @@ if (checkType && getType() == ResultSet.TYPE_FORWARD_ONLY) { // rowset.8=The Result Set Type is TYPE_FORWARD_ONLY - throw new SQLException(Messages.getString("rowset.8")); + throw new SQLException(Messages.getString("rowset.8")); //$NON-NLS-1$ } if (row < 0) { @@ -738,7 +782,8 @@ } public BigDecimal getBigDecimal(int columnIndex) throws SQLException { - throw new NotImplementedException(); + // TODO re-implement it + return (BigDecimal) getObject(columnIndex); } public BigDecimal getBigDecimal(int columnIndex, int scale) @@ -893,6 +938,7 @@ } public Object getObject(int columnIndex) throws SQLException { + // TODO re-implement it return currentRow.getObject(columnIndex); } @@ -949,12 +995,19 @@ return (String) value; } - private boolean checkCursorValid() throws SQLException { + private void checkColumnValid(int columnIndex) throws SQLException { + if (columnIndex <= 0 || columnIndex > meta.getColumnCount()) { + // sql.27=Invalid column index :{0} + throw new SQLException(Messages.getString("sql.27", Integer //$NON-NLS-1$ + .valueOf(columnIndex))); + } + } + + private void checkCursorValid() throws SQLException { if ((currentRowIndex <= 0) || (currentRowIndex > rows.size())) { // rowset.7=Not a valid cursor throw new SQLException(Messages.getString("rowset.7")); //$NON-NLS-1$ } - return false; } public String getString(String columnName) throws SQLException { @@ -1019,7 +1072,7 @@ checkValidRow(); if (currentRow != insertRow) { // rowset.4=Not an insert row - throw new SQLException(Messages.getString("rowset.4")); + throw new SQLException(Messages.getString("rowset.4")); //$NON-NLS-1$ } insertRow.setInsert(); rows.add(insertRow); @@ -1131,21 +1184,21 @@ public boolean rowUpdated() throws SQLException { if (!currentRow.isUpdate()) { return false; - } else { - boolean sign = false; - for (int i = 0; i < meta.getColumnCount(); ++i) { - sign = currentRow.getUpdateMask(i) | sign; - } - return sign; } + + boolean sign = false; + for (int i = 0; i < meta.getColumnCount(); ++i) { + sign = currentRow.getUpdateMask(i) | sign; + } + return sign; } public void updateArray(int columnIndex, Array x) throws SQLException { - throw new NotImplementedException(); + updateByType(columnIndex, x); } public void updateArray(String columnName, Array x) throws SQLException { - throw new NotImplementedException(); + updateArray(getIndexByName(columnName), x); } public void updateAsciiStream(int columnIndex, InputStream x, int length) @@ -1155,12 +1208,16 @@ public void updateAsciiStream(String columnName, InputStream x, int length) throws SQLException { - throw new NotImplementedException(); + updateAsciiStream(getIndexByName(columnName), x, length); } public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException { - currentRow.updateObject(columnIndex, x); + if (x == null) { + throw new NullPointerException(); + } + + updateByType(columnIndex, x); } public void updateBigDecimal(String columnName, BigDecimal x) @@ -1175,39 +1232,39 @@ public void updateBinaryStream(String columnName, InputStream x, int length) throws SQLException { - throw new NotImplementedException(); + updateBinaryStream(getIndexByName(columnName), x, length); } public void updateBlob(int columnIndex, Blob x) throws SQLException { - throw new NotImplementedException(); + updateByType(columnIndex, x); } public void updateBlob(String columnName, Blob x) throws SQLException { - throw new NotImplementedException(); + updateBlob(getIndexByName(columnName), x); } public void updateBoolean(int columnIndex, boolean x) throws SQLException { - throw new NotImplementedException(); + updateByType(columnIndex, Boolean.valueOf(x)); } public void updateBoolean(String columnName, boolean x) throws SQLException { - throw new NotImplementedException(); + updateBoolean(getIndexByName(columnName), x); } public void updateByte(int columnIndex, byte x) throws SQLException { - throw new NotImplementedException(); + updateByType(columnIndex, Byte.valueOf(x)); } public void updateByte(String columnName, byte x) throws SQLException { - throw new NotImplementedException(); + updateByte(getIndexByName(columnName), x); } public void updateBytes(int columnIndex, byte[] x) throws SQLException { - throw new NotImplementedException(); + updateByType(columnIndex, x); } public void updateBytes(String columnName, byte[] x) throws SQLException { - throw new NotImplementedException(); + updateBytes(getIndexByName(columnName), x); } public void updateCharacterStream(int columnIndex, Reader x, int length) @@ -1217,19 +1274,19 @@ public void updateCharacterStream(String columnName, Reader reader, int length) throws SQLException { - throw new NotImplementedException(); + updateCharacterStream(getIndexByName(columnName), reader, length); } public void updateClob(int columnIndex, Clob x) throws SQLException { - throw new NotImplementedException(); + updateByType(columnIndex, x); } public void updateClob(String columnName, Clob x) throws SQLException { - throw new NotImplementedException(); + updateClob(getIndexByName(columnName), x); } public void updateDate(int columnIndex, Date x) throws SQLException { - currentRow.updateObject(columnIndex, x); + updateByType(columnIndex, x); } public void updateDate(String columnName, Date x) throws SQLException { @@ -1237,7 +1294,7 @@ } public void updateDouble(int columnIndex, double x) throws SQLException { - currentRow.updateObject(columnIndex, x); + updateByType(columnIndex, Double.valueOf(x)); } public void updateDouble(String columnName, double x) throws SQLException { @@ -1245,7 +1302,7 @@ } public void updateFloat(int columnIndex, float x) throws SQLException { - currentRow.updateObject(columnIndex, x); + updateByType(columnIndex, Float.valueOf(x)); } public void updateFloat(String columnName, float x) throws SQLException { @@ -1253,7 +1310,7 @@ } public void updateInt(int columnIndex, int x) throws SQLException { - currentRow.updateObject(columnIndex, x); + updateByType(columnIndex, Integer.valueOf(x)); } public void updateInt(String columnName, int x) throws SQLException { @@ -1261,7 +1318,7 @@ } public void updateLong(int columnIndex, long x) throws SQLException { - currentRow.updateObject(columnIndex, x); + updateByType(columnIndex, Long.valueOf(x)); } public void updateLong(String columnName, long x) throws SQLException { @@ -1269,37 +1326,65 @@ } public void updateNull(int columnIndex) throws SQLException { - throw new NotImplementedException(); + checkCursorValid(); + checkColumnValid(columnIndex); + currentRow.updateObject(columnIndex, null); } public void updateNull(String columnName) throws SQLException { - throw new NotImplementedException(); + updateNull(getIndexByName(columnName)); } + /** + * note check type compatibility + */ public void updateObject(int columnIndex, Object x) throws SQLException { - throw new NotImplementedException(); + checkValidRow(); + checkColumnValid(columnIndex); + currentRow.updateObject(columnIndex, x); } public void updateObject(int columnIndex, Object x, int scale) throws SQLException { - throw new NotImplementedException(); + checkValidRow(); + checkColumnValid(columnIndex); + Class type = columnTypes[columnIndex - 1]; + // ava.sql.Types.DECIMA or java.sql.Types.NUMERIC types + if (type.equals(BigDecimal.class)) { + /* + * TODO ri doesn't check type of x and only support BigDecimal, + * should we follow ri here? If not, uncomment below fragment of + * code + */ + // if (x instanceof BigDecimal) { + x = ((BigDecimal) x).setScale(scale); + // } else if (x instanceof Double) { + // x = new BigDecimal(((Double) x).doubleValue()); + // x = ((BigDecimal) x).setScale(scale); + // } else if (x instanceof Float) { + // x = new BigDecimal(((Float) x).doubleValue()); + // x = ((BigDecimal) x).setScale(scale); + // } + } + + currentRow.updateObject(columnIndex, x); } public void updateObject(String columnName, Object x) throws SQLException { - throw new NotImplementedException(); + updateObject(getIndexByName(columnName), x); } public void updateObject(String columnName, Object x, int scale) throws SQLException { - throw new NotImplementedException(); + updateObject(getIndexByName(columnName), x, scale); } public void updateRef(int columnIndex, Ref x) throws SQLException { - throw new NotImplementedException(); + updateByType(columnIndex, x); } public void updateRef(String columnName, Ref x) throws SQLException { - throw new NotImplementedException(); + updateRef(getIndexByName(columnName), x); } public void updateRow() throws SQLException { @@ -1313,15 +1398,199 @@ } public void updateShort(int columnIndex, short x) throws SQLException { - throw new NotImplementedException(); + updateByType(columnIndex, Short.valueOf(x)); } public void updateShort(String columnName, short x) throws SQLException { - throw new NotImplementedException(); + updateShort(getIndexByName(columnName), x); } public void updateString(int columnIndex, String x) throws SQLException { - currentRow.updateObject(columnIndex, x); + updateByType(columnIndex, x); + } + + /** + * Check type compatibility and update value + * + * @param columnIndex + * @param value + * @throws SQLException + */ + private void updateByType(int columnIndex, Object value) + throws SQLException { + checkValidRow(); + checkColumnValid(columnIndex); + currentRow.updateObject(columnIndex, convertUpdateValue(columnIndex, + value)); + } + + /** + * Convert value to the JDBC type of the + * columnIndex. The columnIndex is not checked in this + * method, so caller must be sure the columnIndex is valid, + * or invoke checkColumnValid before invoke this method. + * + * TODO any better ways to do this? + * + * @param columnIndex + * index of column to be updated + * @param value + * the new value to be updated + */ + private Object convertUpdateValue(int columnIndex, Object value) + throws SQLException { + + if (value == null) { + return value; + } + + Class type = columnTypes[columnIndex - 1]; + + /* + * TODO if type == null, the type mapping is not supported by Harmony + * now, leave this type check to JDBC driver + */ + + if (type == null || type.isInstance(value)) { + return value; + } + + if (type.equals(Integer.class)) { + if (value instanceof Integer || value instanceof Short + || value instanceof Byte) { + return value; + } + + if (value instanceof Long) { + long l = ((Long) value).longValue(); + if (l >= Integer.MIN_VALUE && l <= Integer.MAX_VALUE) { + return (int) l; + } + } + + if (value instanceof BigDecimal) { + BigDecimal bigDecimal = (BigDecimal) value; + try { + return bigDecimal.intValueExact(); + + } catch (ArithmeticException e) { + // TODO load from resource file + throw new SQLException("Data Type Mismatch"); //$NON-NLS-1$ + } + } + + if (value instanceof String) { + return value; + } + } + + if (type.equals(Short.class)) { + if (value instanceof Short || value instanceof Byte) { + return value; + } + if (value instanceof Long) { + long l = ((Long) value).longValue(); + if (l >= Short.MIN_VALUE && l <= Short.MAX_VALUE) { + return (short) l; + } + } + if (value instanceof Integer) { + int i = ((Integer) value).intValue(); + if (i >= Short.MIN_VALUE && i <= Short.MAX_VALUE) { + return (short) i; + } + } + if (value instanceof BigDecimal) { + BigDecimal bigDecimal = (BigDecimal) value; + try { + return bigDecimal.intValueExact(); + + } catch (ArithmeticException e) { + // TODO load from resource file + throw new SQLException("Data Type Mismatch"); //$NON-NLS-1$ + } + } + if (value instanceof String) { + return value; + } + } + + if (type.equals(Byte.class)) { + if (value instanceof Byte) { + return value; + } + if (value instanceof Long) { + long l = ((Long) value).longValue(); + if (l >= Byte.MIN_VALUE && l <= Byte.MAX_VALUE) { + return (byte) l; + } + } + if (value instanceof Integer) { + int i = ((Integer) value).intValue(); + if (i >= Byte.MIN_VALUE && i <= Byte.MAX_VALUE) { + return (byte) i; + } + } + if (value instanceof Short) { + int i = ((Short) value).shortValue(); + if (i >= Byte.MIN_VALUE && i <= Byte.MAX_VALUE) { + return (byte) i; + } + } + if (value instanceof BigDecimal) { + BigDecimal bigDecimal = (BigDecimal) value; + try { + return bigDecimal.byteValueExact(); + + } catch (ArithmeticException e) { + // TODO load from resource file + throw new SQLException("Data Type Mismatch"); //$NON-NLS-1$ + } + } + if (value instanceof String) { + return value; + } + } + + if (type.equals(Long.class)) { + if (value instanceof Integer || value instanceof Short + || value instanceof Byte || value instanceof Long) { + return value; + } + if (value instanceof BigDecimal) { + BigDecimal bigDecimal = (BigDecimal) value; + try { + return bigDecimal.longValueExact(); + + } catch (ArithmeticException e) { + // rowset.10=Data Type Mismatch + throw new SQLException(Messages.getString("rowset.10")); //$NON-NLS-1$ + } + } + if (value instanceof String) { + return value; + } + } + + if (type.equals(Float.class) || type.equals(Double.class)) { + if (value instanceof Float || value instanceof Double + || value instanceof BigDecimal) { + return value; + } + if (value instanceof Number) { + return ((Number) value).longValue(); + } + if (value instanceof String) { + return value; + } + } + + if (type.equals(BigDecimal.class)) { + return value; + } + + // rowset.10=Data Type Mismatch + throw new SQLException(Messages.getString("rowset.10")); //$NON-NLS-1$ } public void updateString(String columnName, String x) throws SQLException { @@ -1329,7 +1598,7 @@ } public void updateTime(int columnIndex, Time x) throws SQLException { - currentRow.updateObject(columnIndex, x); + updateByType(columnIndex, x); } public void updateTime(String columnName, Time x) throws SQLException { @@ -1338,7 +1607,7 @@ public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException { - currentRow.updateObject(columnIndex, x); + updateByType(columnIndex, x); } public void updateTimestamp(String columnName, Timestamp x) Modified: harmony/enhanced/classlib/trunk/modules/sql/src/test/java/org/apache/harmony/sql/tests/internal/rowset/CachedRowSetImplTest.java URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/sql/src/test/java/org/apache/harmony/sql/tests/internal/rowset/CachedRowSetImplTest.java?rev=632978&r1=632977&r2=632978&view=diff ============================================================================== --- harmony/enhanced/classlib/trunk/modules/sql/src/test/java/org/apache/harmony/sql/tests/internal/rowset/CachedRowSetImplTest.java (original) +++ harmony/enhanced/classlib/trunk/modules/sql/src/test/java/org/apache/harmony/sql/tests/internal/rowset/CachedRowSetImplTest.java Mon Mar 3 00:16:06 2008 @@ -443,12 +443,13 @@ assertEquals(crset.getFetchDirection(), copy.getFetchDirection()); assertEquals(crset.getPageSize(), copy.getPageSize()); + assertEquals(crset.isBeforeFirst(), copy.isBeforeFirst()); + assertEquals(crset.isAfterLast(), copy.isAfterLast()); + assertEquals(crset.isFirst(), copy.isFirst()); + assertEquals(crset.isLast(), copy.isLast()); + assertEquals(crset.getRow(), copy.getRow()); + // TODO uncomment them after implemented - // assertEquals(crset.isBeforeFirst(), crsetCopy.isBeforeFirst()); - // assertEquals(crset.isAfterLast(), crsetCopy.isAfterLast()); - // assertEquals(crset.isFirst(), crsetCopy.isFirst()); - // assertEquals(crset.isLast(), crsetCopy.isLast()); - // assertEquals(crset.getRow(), copy.getRow()); // assertNotSame(crset.getWarnings(), copy.getWarnings()); // assertEquals(crset.getStatement(), copy.getStatement()); // try { @@ -720,8 +721,8 @@ rs.next(); rs.next(); rs.next(); - // TODO: Uncomment it when Writer is implemented fully. - // assertEquals("copyTest3", rs.getString(2)); + + assertEquals("copyTest3", rs.getString(2)); reloadCachedRowSet(); crset.absolute(2); @@ -729,14 +730,10 @@ crsetCopy = crset.createCopy(); assertEquals(crset.isReadOnly(), crsetCopy.isReadOnly()); - // TODO uncomment when isBeforeFirst is implemented - // assertEquals(crset.isBeforeFirst(), crsetCopy.isBeforeFirst()); - // TODO uncomment when isAfterLast is implemented - // assertEquals(crset.isAfterLast(), crsetCopy.isAfterLast()); - // TODO uncomment when isFirst is implemented - // assertEquals(crset.isFirst(), crsetCopy.isFirst()); - // TODO uncomment when isLast is implemented - // assertEquals(crset.isLast(), crsetCopy.isLast()); + assertEquals(crset.isBeforeFirst(), crsetCopy.isBeforeFirst()); + assertEquals(crset.isAfterLast(), crsetCopy.isAfterLast()); + assertEquals(crset.isFirst(), crsetCopy.isFirst()); + assertEquals(crset.isLast(), crsetCopy.isLast()); assertEquals(crset.size(), crsetCopy.size()); // different metaData object @@ -848,10 +845,9 @@ * it, and all resource would be released after connection closed. */ crset.acceptChanges(conn); - // TODO: wait the implementation of Writer - // fail("Should throw SyncProviderException"); + fail("Should throw SyncProviderException"); } catch (SyncProviderException e) { - // expected + // expected, TODO test SyncProviderException } assertEquals("updated", copy.getString(2)); @@ -1150,6 +1146,8 @@ assertNull(noInitialCrset.getCommand()); assertEquals(ResultSet.CONCUR_UPDATABLE, noInitialCrset .getConcurrency()); + assertEquals(0, crset.getRow()); + // TODO uncomment after impelemented // try { // crset.getCursorName(); @@ -1169,7 +1167,6 @@ // } catch (SQLException e) { // // expected // } - // assertEquals(0, crset.getRow()); // assertNull(crset.getStatement()); assertEquals(true, noInitialCrset.getEscapeProcessing()); Added: harmony/enhanced/classlib/trunk/modules/sql/src/test/java/org/apache/harmony/sql/tests/internal/rowset/CachedRowSetUpdateTest.java URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/sql/src/test/java/org/apache/harmony/sql/tests/internal/rowset/CachedRowSetUpdateTest.java?rev=632978&view=auto ============================================================================== --- harmony/enhanced/classlib/trunk/modules/sql/src/test/java/org/apache/harmony/sql/tests/internal/rowset/CachedRowSetUpdateTest.java (added) +++ harmony/enhanced/classlib/trunk/modules/sql/src/test/java/org/apache/harmony/sql/tests/internal/rowset/CachedRowSetUpdateTest.java Mon Mar 3 00:16:06 2008 @@ -0,0 +1,476 @@ +/* + * 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.harmony.sql.tests.internal.rowset; + +import java.math.BigDecimal; +import java.sql.Date; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.ArrayList; + +import javax.sql.rowset.spi.SyncProviderException; + +public class CachedRowSetUpdateTest extends CachedRowSetTestCase { + public void testUpdateValue() throws Exception { + + try { + crset.updateString(1, ""); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Invalid cursor position + } + + try { + crset.updateString(-1, ""); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Invalid column index + } + + crset.moveToInsertRow(); + + try { + crset.updateDate(1, new Date(10000)); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + crset.updateInt(1, 100); + crset.updateString(2, "test8"); + + try { + crset.updateBytes(2, "hello".getBytes()); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + crset.updateLong(3, 444423L); + crset.updateBigDecimal(4, new BigDecimal(12)); + crset.updateBigDecimal(5, new BigDecimal(23)); + crset.updateInt(6, 41); + crset.updateFloat(7, 4.8F); + crset.updateFloat(8, 4.888F); + crset.updateDouble(9, 4.9999); + crset.updateDate(10, new Date(965324512)); + crset.updateTime(11, new Time(452368512)); + crset.updateTimestamp(12, new Timestamp(874532105)); + + crset.insertRow(); + crset.moveToCurrentRow(); + crset.acceptChanges(conn); + + } + + public void testUpdateLong() throws SQLException { + crset.moveToInsertRow(); + + crset.updateInt(1, 100); + crset.updateString(2, "update"); + + crset.updateLong(3, 444423L); + crset.updateInt(3, 100); + crset.updateShort(3, (short) 100); + crset.updateByte(3, (byte) 10); + crset.updateBigDecimal(3, new BigDecimal(Long.MAX_VALUE)); + crset.updateString(3, "1000"); + + try { + crset.updateBigDecimal(3, new BigDecimal(Double.MAX_VALUE)); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + try { + crset.updateFloat(3, 80.98F); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + try { + crset.updateDouble(3, 80.98); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + try { + crset.updateBoolean(3, false); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + crset.updateBigDecimal(4, new BigDecimal(12)); + crset.updateBigDecimal(5, new BigDecimal(23)); + crset.updateInt(6, 41); + crset.updateFloat(7, 4.8F); + crset.updateFloat(8, 4.888F); + crset.updateDouble(9, 4.9999); + crset.updateDate(10, new Date(965324512)); + crset.updateTime(11, new Time(452368512)); + crset.updateTimestamp(12, new Timestamp(874532105)); + crset.insertRow(); + crset.moveToCurrentRow(); + crset.acceptChanges(conn); + + } + + public void testUpdateInt() throws SQLException { + crset.moveToInsertRow(); + + crset.updateInt(1, 50); + crset.updateByte(1, (byte) 10); + crset.updateShort(1, (short) 60); + crset.updateLong(1, 100L); + crset.updateBigDecimal(1, new BigDecimal(50)); + crset.updateString(1, "100"); + + try { + crset.updateBigDecimal(1, new BigDecimal(Double.MAX_VALUE)); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + try { + crset.updateLong(1, 100000000000L); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + try { + crset.updateFloat(1, 80.98F); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + try { + crset.updateDouble(1, 80.98); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + try { + crset.updateBoolean(1, false); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + crset.updateString(2, "test100"); + crset.updateLong(3, 444423L); + crset.updateBigDecimal(4, new BigDecimal(12)); + crset.updateBigDecimal(5, new BigDecimal(23)); + crset.updateInt(6, 41); + crset.updateFloat(7, 4.8F); + crset.updateFloat(8, 4.888F); + crset.updateDouble(9, 4.9999); + crset.updateDate(10, new Date(965324512)); + crset.updateTime(11, new Time(452368512)); + crset.updateTimestamp(12, new Timestamp(874532105)); + crset.insertRow(); + crset.moveToCurrentRow(); + crset.acceptChanges(conn); + + ResultSet rs = st + .executeQuery("SELECT * FROM USER_INFO WHERE ID = 100"); + assertTrue(rs.next()); + } + + public void testUpdateShort() throws SQLException { + crset.moveToInsertRow(); + + crset.updateInt(1, 50); + crset.updateString(2, "test100"); + crset.updateLong(3, 444423L); + crset.updateBigDecimal(4, new BigDecimal(12)); + crset.updateBigDecimal(5, new BigDecimal(23)); + + crset.updateShort(6, (short) 10); + crset.updateByte(6, (byte) 10); + crset.updateInt(6, 41); + crset.updateLong(6, 33); + crset.updateBigDecimal(6, new BigDecimal(23)); + + try { + crset.updateBigDecimal(6, new BigDecimal(Double.MAX_VALUE)); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + try { + crset.updateLong(6, 100000000000L); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + try { + crset.updateInt(6, Integer.MAX_VALUE); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + try { + crset.updateFloat(6, 80.98F); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + try { + crset.updateDouble(6, 80.98); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + try { + crset.updateBoolean(6, false); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + crset.updateFloat(7, 4.8F); + crset.updateFloat(8, 4.888F); + crset.updateDouble(9, 4.9999); + crset.updateDate(10, new Date(965324512)); + crset.updateTime(11, new Time(452368512)); + crset.updateTimestamp(12, new Timestamp(874532105)); + crset.insertRow(); + crset.moveToCurrentRow(); + crset.acceptChanges(conn); + } + + public void testUpdateFloat() throws SQLException { + crset.moveToInsertRow(); + + crset.updateInt(1, 50); + crset.updateString(2, "test100"); + crset.updateLong(3, 444423L); + crset.updateBigDecimal(4, new BigDecimal(12)); + crset.updateBigDecimal(5, new BigDecimal(23)); + crset.updateInt(6, 41); + + crset.updateFloat(7, 4.8F); + crset.updateDouble(7, 80.98); + + crset.updateInt(7, 10000); + crset.updateLong(7, 10000); + crset.updateShort(7, (short) 10); + crset.updateByte(7, (byte) 10); + crset.updateBigDecimal(7, new BigDecimal(100)); + crset.updateDouble(7, Float.MAX_VALUE); + + // throw exception when acceptChange + // crset.updateDouble(7, Double.MAX_VALUE); + // crset.updateBigDecimal(7, new BigDecimal(Double.MAX_VALUE)); + + try { + crset.updateBoolean(1, false); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + crset.updateFloat(8, 4.888F); + crset.updateDouble(9, 4.9999); + crset.updateDate(10, new Date(965324512)); + crset.updateTime(11, new Time(452368512)); + crset.updateTimestamp(12, new Timestamp(874532105)); + crset.insertRow(); + crset.moveToCurrentRow(); + crset.acceptChanges(conn); + } + + public void testUpdateFloat_Exception() throws SQLException { + crset.moveToInsertRow(); + crset.updateInt(1, 50); + crset.updateString(2, "test100"); + crset.updateLong(3, 444423L); + crset.updateBigDecimal(4, new BigDecimal(12)); + crset.updateBigDecimal(5, new BigDecimal(23)); + crset.updateInt(6, 41); + + // over range + crset.updateDouble(7, Double.MAX_VALUE); + + crset.updateFloat(8, 4.888F); + crset.updateDouble(9, 4.9999); + crset.updateDate(10, new Date(965324512)); + crset.updateTime(11, new Time(452368512)); + crset.updateTimestamp(12, new Timestamp(874532105)); + crset.insertRow(); + crset.moveToCurrentRow(); + + try { + crset.acceptChanges(conn); + fail("Should throw SyncProviderException"); + } catch (SyncProviderException e) { + // expected + } + } + + public void testUpdateBigDecimal() throws SQLException { + crset.moveToInsertRow(); + crset.updateInt(1, 50); + crset.updateString(2, "test100"); + crset.updateLong(3, 444423L); + + crset.updateBigDecimal(4, new BigDecimal(12)); + crset.updateByte(4, (byte) 10); + crset.updateShort(4, (short) 10); + crset.updateInt(4, 300); + crset.updateLong(4, 2000); + crset.updateFloat(4, 3.59F); + crset.updateDouble(4, 3.4994); + + crset.updateBigDecimal(5, new BigDecimal(23)); + crset.updateInt(6, 41); + crset.updateDouble(7, Float.MAX_VALUE); + crset.updateFloat(8, 4.888F); + crset.updateDouble(9, 4.9999); + crset.updateDate(10, new Date(965324512)); + crset.updateTime(11, new Time(452368512)); + crset.updateTimestamp(12, new Timestamp(874532105)); + + crset.insertRow(); + crset.moveToCurrentRow(); + + crset.acceptChanges(conn); + } + + public void testUpdateObject() throws SQLException { + crset.moveToInsertRow(); + + // updateObject doesn't check type compatibility + crset.updateObject(1, new Date(1000)); + crset.updateObject(2, new ArrayList()); + + try { + crset.updateDate(1, new Date(1000)); + fail("Should throw SQLException"); + } catch (SQLException e) { + // expected, Data Type Mismatch + } + + crset.updateObject(1, null); + + try { + crset.updateBigDecimal(7, null); + fail("Should throw NullPointerException"); + } catch (NullPointerException e) { + // expected + } + + crset.updateString(2, null); + + // TODO test Array, Blob, Clob + // crset.updateArray(3, null); + } + + public void testUpdateObject_I_LObject_I() throws Exception { + crset.moveToInsertRow(); + + crset.updateInt(1, 50); + crset.updateString(2, "test100"); + crset.updateLong(3, 444423L); + crset.updateBigDecimal(4, new BigDecimal(12)); + + crset.updateObject(5, new BigDecimal("3.1200"), 3); + + BigDecimal bigDecimal = new BigDecimal("3.1200"); + BigDecimal scaled = bigDecimal.setScale(3); + + if ("true".equals(System.getProperty("Testing Harmony"))) { + assertEquals(scaled, crset.getBigDecimal(5)); + assertEquals(scaled, crset.getObject(5)); + } else { + /* + * seems ri doesn't do scale + */ + assertEquals(bigDecimal, crset.getBigDecimal(5)); + assertEquals(bigDecimal, crset.getObject(5)); + } + + try { + crset.updateObject(5, new BigDecimal("3.1200"), 1); + fail("Should throw ArithmeticException"); + } catch (ArithmeticException e) { + // expected + } + + try { + crset.updateObject(5, null, 1); + fail("Should throw NullPointerException"); + } catch (NullPointerException e) { + // expected + } + + try { + crset.updateObject(5, Double.valueOf(3.0000), 1); + fail("Should throw ClassCastException"); + } catch (ClassCastException e) { + // ri throw ClassCastException, we follow ri + } + + try { + crset.updateObject(5, Float.valueOf(3.0000F), 3); + fail("Should throw ClassCastException"); + } catch (ClassCastException e) { + // ri throw ClassCastException, we follow ri + } + + try { + crset.updateObject(5, Integer.valueOf(3), 3); + fail("Should throw ClassCastException"); + } catch (ClassCastException e) { + // ri throw ClassCastException, we follow ri + } + + try { + crset.updateObject(5, new ArrayList(), 3); + fail("Should throw ClassCastException"); + } catch (ClassCastException e) { + // ri throw ClassCastException, we follow ri + } + + crset.updateInt(6, 41); + crset.updateFloat(7, 4.8F); + crset.updateFloat(8, 4.888F); + crset.updateDouble(9, 4.9999); + crset.updateDate(10, new Date(965324512)); + crset.updateTime(11, new Time(452368512)); + crset.updateTimestamp(12, new Timestamp(874532105)); + crset.insertRow(); + crset.moveToCurrentRow(); + crset.acceptChanges(conn); + } +} Propchange: harmony/enhanced/classlib/trunk/modules/sql/src/test/java/org/apache/harmony/sql/tests/internal/rowset/CachedRowSetUpdateTest.java ------------------------------------------------------------------------------ svn:eol-style = native