=== modified file 'interface/ndbapi/NdbOperation.i' --- a/interface/ndbapi/NdbOperation.i 2008-05-17 08:34:35 +0000 +++ b/interface/ndbapi/NdbOperation.i 2008-06-02 12:11:56 +0000 @@ -329,6 +329,52 @@ return self->setValue(anAttrId,dtval); } + voidint setDate(const char* anAttrName, NdbDate * anInputDateTime) { + + const NdbDictColumn * theColumn = self->getTable()->getColumn(anAttrName); + + Uint64 dtval = ndbFormatDateTime(theColumn,anInputDateTime); + if (dtval == 1) { + return dtval; + } + return self->setValue(anAttrName,dtval); + + } + + voidint setDate(Uint32 anAttrId, NdbDate * anInputDateTime) { + + const NdbDictColumn * theColumn = self->getTable()->getColumn(anAttrId); + + Uint64 dtval = ndbFormatDateTime(theColumn,anInputDateTime); + if (dtval == 1) { + return dtval; + } + return self->setValue(anAttrId,dtval); + } + + voidint setTime(const char* anAttrName, NdbTime * anInputDateTime) { + + const NdbDictColumn * theColumn = self->getTable()->getColumn(anAttrName); + + Uint64 dtval = ndbFormatDateTime(theColumn,anInputDateTime); + if (dtval == 1) { + return dtval; + } + return self->setValue(anAttrName,dtval); + + } + + voidint setTime(Uint32 anAttrId, NdbTime * anInputDateTime) { + + const NdbDictColumn * theColumn = self->getTable()->getColumn(anAttrId); + + Uint64 dtval = ndbFormatDateTime(theColumn,anInputDateTime); + if (dtval == 1) { + return dtval; + } + return self->setValue(anAttrId,dtval); + } + voidint setTimestamp(const char* anAttrName, NdbTimestamp anInputTimestamp) { return self->setValue(anAttrName,anInputTimestamp); } === modified file 'interface/ndbapi/NdbRecAttr.i' --- a/interface/ndbapi/NdbRecAttr.i 2008-05-29 04:52:40 +0000 +++ b/interface/ndbapi/NdbRecAttr.i 2008-06-02 12:11:56 +0000 @@ -218,7 +218,15 @@ %ndbnoexception; NdbDateTime * getDatetime() { - return new NdbDateTime(); + return createNdbDateTime(self); + } + + NdbDate * getDate() { + return createNdbDateTime(self); + } + + NdbTime * getTime() { + return createNdbDateTime(self); } %ndbexception("NdbApiException") { === modified file 'interface/ndbapi/ndbglobals.i' --- a/interface/ndbapi/ndbglobals.i 2008-05-22 17:05:11 +0000 +++ b/interface/ndbapi/ndbglobals.i 2008-06-02 12:11:56 +0000 @@ -146,6 +146,48 @@ second=0; } + NdbDateTime * createNdbDateTime(const NdbRecAttr * rec) { + NdbDateTime * dt = new NdbDateTime(); + int int_date = -1, int_time = -99; + unsigned long long datetime; + + switch(rec->getType()) { + case NdbDictionary::Column::Datetime : + datetime = rec->u_64_value(); + int_date = datetime / 1000000; + int_time = datetime - (unsigned long long) int_date * 1000000; + break; + case NdbDictionary::Column::Time : + int_time = sint3korr(rec->aRef()); + break; + case NdbDictionary::Column::Date : + int_date = uint3korr(rec->aRef()); + dt->day = (int_date & 31); // five bits + dt->month = (int_date >> 5 & 15); // four bits + dt->year = (int_date >> 9); + return dt; + default: + delete dt; + return NULL; + } + + if(int_time != -99) { + dt->hour = int_time/10000; + dt->minute = int_time/100 % 100; + dt->second = int_time % 100; + } + if(int_date != -1) { + dt->year = int_date/10000 % 10000; + dt->month = int_date/100 % 100; + dt->day = int_date % 100; + } + return dt; + + } + + typedef NdbDateTime NdbDate; + typedef NdbDateTime NdbTime; + /* We don't just typedef these right in the first place because there because that would mean NdbDictionary::Dictionary would get renamed to NdbDictionary at the C level, which @@ -265,8 +307,10 @@ break; case NDB_TYPE_DATE: { - val=(tm->year << 9) | (tm->month << 5) | tm->day; - //int3store(dt_buf, val); + printf("tm->month == %d\n",tm->month); + val=(tm->year << 9) | ((tm->month) << 5) | tm->day; + printf("val:%llu\n",val); + int3store(dt_buf, val); } break; default: @@ -317,9 +361,9 @@ typedef void (* NdbAsynchCallback)(int, NdbTransaction*, void*); typedef void (* NdbEventCallback)(NdbEventOperation*, Ndb*, void*); -typedef const char * NdbDatetime; -typedef const char * NdbDate; -typedef const char * NdbTime; +//typedef const char * NdbDatetime; +//typedef const char * NdbDate; +//typedef const char * NdbTime; typedef Uint32 NdbTimestamp; // ndbFormatString mallocs memory. Return value must be free'd by calling code === modified file 'java/Makefile.am' --- a/java/Makefile.am 2008-05-30 04:46:12 +0000 +++ b/java/Makefile.am 2008-06-02 12:14:10 +0000 @@ -152,6 +152,7 @@ ${package_srcdir}/mgmj/NdbLogEvent.java \ ${package_srcdir}/mgmj/NdbMgmFactory.java \ ${package_srcdir}/mgmj/NdbLogEventManager.java \ + ${package_srcdir}/mgmj/NdbMgmFilterListImpl.java \ ${package_srcdir}/mgmj/examples/SampleMGMJ.java \ ${srcdir}/testsuite/BaseMgmjTestCase.java \ ${srcdir}/testsuite/BaseTestCase.java \ @@ -210,6 +211,7 @@ ${package_srcdir}/ndbj/NdbTransactionManager.java \ ${package_srcdir}/ndbj/ThrowingResultSet.java \ ${package_srcdir}/ndbj/ThrowingResultSetJDBC4.java \ + ${package_srcdir}/ndbj/Util.java \ ${package_srcdir}/ndbj/examples/CRUDandScan.java \ ${package_srcdir}/ndbj/examples/DeleteUsingPrimaryKey.java \ ${package_srcdir}/ndbj/examples/ExamplesConfigurator.java \ @@ -231,6 +233,7 @@ ${srcdir}/testsuite/TestCallback.java \ ${srcdir}/testsuite/ndbj/AllTests.java \ ${srcdir}/testsuite/ndbj/BasicTest.java \ + ${srcdir}/testsuite/ndbj/DateTimeTest.java \ ${srcdir}/testsuite/ndbj/ImmediatePollTimeoutTest.java \ ${srcdir}/testsuite/ndbj/InvalidSchemaObjectVersionTest.java \ ${srcdir}/testsuite/ndbj/InsertRetryTest.java \ @@ -290,6 +293,7 @@ ${package_builddir}/ndbj/NotImplementedException.class \ ${package_builddir}/ndbj/ThrowingResultSet.class \ ${package_builddir}/ndbj/ThrowingResultSetJDBC4.class \ + ${package_builddir}/ndbj/Util.class \ ${package_builddir}/ndbj/examples/CRUDandScan.class \ ${package_builddir}/ndbj/examples/DeleteUsingPrimaryKey.class \ ${package_builddir}/ndbj/examples/ExamplesConfigurator.class \ @@ -311,6 +315,7 @@ ${builddir}/testsuite/TestCallback.class \ ${builddir}/testsuite/ndbj/AllTests.class \ ${builddir}/testsuite/ndbj/BasicTest.class \ + ${builddir}/testsuite/ndbj/DateTimeTest.class \ ${builddir}/testsuite/ndbj/ImmediatePollTimeoutTest.class \ ${builddir}/testsuite/ndbj/InvalidSchemaObjectVersionTest.java \ ${builddir}/testsuite/ndbj/InsertRetryTest.class \ @@ -379,6 +384,7 @@ ${package_builddir}/mgmj/NdbMgmSeverity.class \ ${package_builddir}/mgmj/NdbFilterItem.class \ ${package_builddir}/mgmj/NdbFilterList.class \ + ${package_builddir}/mgmj/NdbMgmFilterListImpl.class \ ${package_builddir}/mgmj/NdbLogEventCategoryListener.class \ ${package_builddir}/mgmj/NdbLogEventListener.class \ ${package_builddir}/mgmj/NdbLogEventTypeListener.class \ === added file 'java/com/mysql/cluster/mgmj/NdbMgmFilterListImpl.java' --- a/java/com/mysql/cluster/mgmj/NdbMgmFilterListImpl.java 1970-01-01 00:00:00 +0000 +++ b/java/com/mysql/cluster/mgmj/NdbMgmFilterListImpl.java 2008-05-31 07:18:46 +0000 @@ -0,0 +1,18 @@ +package com.mysql.cluster.mgmj; + +import java.util.List; + +abstract class NdbMgmFilterListImpl { + + abstract public NdbLogEventManagerImpl createNdbLogEventManager(NdbFilterList filter) throws NdbMgmException; + + public NdbLogEventManagerImpl createNdbLogEventManager(List filterList) + throws NdbMgmException { + + NdbFilterList theList = new NdbFilterList(); + for (NdbFilterItem theItem : filterList) { + theList.add(theItem); + } + return createNdbLogEventManager(theList); + } +} === modified file 'java/com/mysql/cluster/ndbj/NdbBaseOperationEquals.java' --- a/java/com/mysql/cluster/ndbj/NdbBaseOperationEquals.java 2008-03-07 11:26:02 +0000 +++ b/java/com/mysql/cluster/ndbj/NdbBaseOperationEquals.java 2008-06-02 12:11:56 +0000 @@ -262,8 +262,6 @@ * @throws NdbApiRuntimeException If a bad columnName is entered */ public void equalDatetime(String columnName, Calendar val) throws NdbApiException; - @Deprecated - public void equal(String columnName, Calendar val) throws NdbApiException; /** * @@ -273,9 +271,6 @@ * @throws NdbApiRuntimeException If a bad columnName is entered */ public void equalDatetime(long columnId, Calendar val) throws NdbApiException; - @Deprecated - public void equal(long columnId, Calendar val) throws NdbApiException; - /** * * @param columnName name of the Column in the Schema === modified file 'java/com/mysql/cluster/ndbj/NdbBaseOperationEqualsImpl.java' --- a/java/com/mysql/cluster/ndbj/NdbBaseOperationEqualsImpl.java 2008-03-07 11:26:02 +0000 +++ b/java/com/mysql/cluster/ndbj/NdbBaseOperationEqualsImpl.java 2008-06-02 12:11:56 +0000 @@ -2,7 +2,6 @@ import java.math.BigInteger; import java.sql.Timestamp; -import java.util.Calendar; public abstract class NdbBaseOperationEqualsImpl extends NdbBaseOperationResultsImpl implements NdbBaseOperationEquals { @@ -17,11 +16,6 @@ } @Deprecated - public void equal(long columnId, Calendar val) throws NdbApiException { - equalDatetime(columnId,val); - } - - @Deprecated public void equal(long columnId, int val) throws NdbApiException { equalInt(columnId,val); } @@ -52,11 +46,6 @@ } @Deprecated - public void equal(String columnName, Calendar val) throws NdbApiException { - equalDatetime(columnName,val); - } - - @Deprecated public void equal(String columnName, int val) throws NdbApiException { equalInt(columnName,val); } === modified file 'java/com/mysql/cluster/ndbj/NdbBaseOperationSet.java' --- a/java/com/mysql/cluster/ndbj/NdbBaseOperationSet.java 2008-05-22 17:05:11 +0000 +++ b/java/com/mysql/cluster/ndbj/NdbBaseOperationSet.java 2008-06-02 12:11:56 +0000 @@ -1,7 +1,10 @@ package com.mysql.cluster.ndbj; import java.math.BigDecimal; +import java.sql.Date; +import java.sql.Time; import java.sql.Timestamp; +import java.util.Calendar; public interface NdbBaseOperationSet { @@ -103,7 +106,12 @@ */ public abstract void setTimestamp(long columnId, Timestamp t) throws NdbApiException; - + public abstract void setDatetime(long columnId, Calendar t) + throws NdbApiException; + public abstract void setDate(long columnId, Date t) + throws NdbApiException; + public abstract void setTime(long columnId, Time t) + throws NdbApiException; /** * Timestamp objects stored in the database lose nanosecond accuracy. * @param columnName name of the Column in the Schema @@ -116,6 +124,12 @@ public abstract void setTimestamp(String columnName, Timestamp t) throws NdbApiException; + public abstract void setDatetime(String columnName, Calendar t) + throws NdbApiException; + public abstract void setDate(String columnName, Date t) + throws NdbApiException; + public abstract void setTime(String columnName, Time t) + throws NdbApiException; /** * * @param columnId integer position (offset) of column number in schema definition (columnId starts from position '1' for the first column in a schema) === modified file 'java/com/mysql/cluster/ndbj/NdbIndexScanOperation.java' --- a/java/com/mysql/cluster/ndbj/NdbIndexScanOperation.java 2008-05-17 04:57:29 +0000 +++ b/java/com/mysql/cluster/ndbj/NdbIndexScanOperation.java 2008-06-02 12:11:56 +0000 @@ -1,5 +1,6 @@ package com.mysql.cluster.ndbj; +import java.sql.Timestamp; import java.util.Calendar; import java.math.BigInteger; @@ -254,7 +255,7 @@ * @throws NdbApiException * @see com.mysql.cluster.ndbj.NdbIndexScanOperation#setBound(long, * com.mysql.cluster.ndbj.NdbIndexScanOperation.BoundType, - * java.util.Calendar) + * java.sql.Timestamp) */ public void setBoundDatetime(long anAttrId, BoundType type, Calendar anInputDateTime) throws NdbApiException; === modified file 'java/com/mysql/cluster/ndbj/NdbRecAttr.java' --- a/java/com/mysql/cluster/ndbj/NdbRecAttr.java 2008-05-17 08:34:35 +0000 +++ b/java/com/mysql/cluster/ndbj/NdbRecAttr.java 2008-06-02 12:11:56 +0000 @@ -1,6 +1,10 @@ package com.mysql.cluster.ndbj; +import java.math.BigDecimal; import java.math.BigInteger; +import java.sql.Date; +import java.sql.Time; +import java.sql.Timestamp; import java.util.Calendar; @@ -86,15 +90,17 @@ public abstract Calendar getDatetime() throws NdbApiException ; - public abstract String getString() throws NdbApiException ; public abstract byte[] getBytes() throws NdbApiException ; - - public abstract java.sql.Timestamp getTimestamp() throws NdbApiException ; - - public java.math.BigDecimal getDecimal() throws NdbApiException; + public abstract Timestamp getTimestamp() throws NdbApiException ; + + public abstract Date getDate() throws NdbApiException; + + public abstract Time getTime() throws NdbApiException; + + public BigDecimal getDecimal() throws NdbApiException; } === modified file 'java/com/mysql/cluster/ndbj/NdbScanFilter.java' --- a/java/com/mysql/cluster/ndbj/NdbScanFilter.java 2008-05-20 00:03:46 +0000 +++ b/java/com/mysql/cluster/ndbj/NdbScanFilter.java 2008-06-02 12:14:10 +0000 @@ -1,7 +1,7 @@ package com.mysql.cluster.ndbj; import java.sql.Timestamp; -import java.util.Calendar; +import java.util.Calendar; import java.math.BigInteger; === added file 'java/com/mysql/cluster/ndbj/Util.java' --- a/java/com/mysql/cluster/ndbj/Util.java 1970-01-01 00:00:00 +0000 +++ b/java/com/mysql/cluster/ndbj/Util.java 2008-06-02 12:11:56 +0000 @@ -0,0 +1,27 @@ +package com.mysql.cluster.ndbj; + +import java.sql.Date; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.Calendar; + +public class Util { + + public final static Calendar timeToCalendar(Time input) { + java.util.Calendar output = Calendar.getInstance(); + output.setTimeInMillis(input.getTime()); + return output; + } + + public final static Calendar dateToCalendar(Date input) { + java.util.Calendar output = Calendar.getInstance(); + output.setTime(input); + return output; + } + + public final static Calendar timestampToCalendar(Timestamp input) { + java.util.Calendar output = Calendar.getInstance(); + output.setTimeInMillis(input.getTime()); + return output; + } +} === modified file 'java/swig/NdbDateTime.i' --- a/java/swig/NdbDateTime.i 2008-05-21 03:14:15 +0000 +++ b/java/swig/NdbDateTime.i 2008-06-02 12:11:56 +0000 @@ -25,23 +25,37 @@ %typemap(javain) NdbDateTime * "$javainput" %typemap(javaout) NdbDateTime * { return (java.util.Calendar)$jnicall; } -%typemap(in) (NdbDateTime *) { +%typemap(jni) NdbTime * "jobject" +%typemap(jtype) NdbTime * "Object" +%typemap(jstype) NdbTime * "java.sql.Time" +%typemap(javain) NdbTime * "Util.timeToCalendar($javainput)" +%typemap(javaout) NdbTime * { return (java.sql.Time)$jnicall; } + +%typemap(jni) NdbDate * "jobject" +%typemap(jtype) NdbDate * "Object" +%typemap(jstype) NdbDate * "java.sql.Date" +%typemap(javain) NdbDate * "Util.dateToCalendar($javainput)" +%typemap(javaout) NdbDate * { return (java.sql.Date)$jnicall; } + +%typemap(in) NdbDateTime *, NdbDate *, NdbTime * { // NdbDateTime * dt = (NdbDateTime *)malloc(sizeof(NdbDateTime)); NdbDateTime * dt = new NdbDateTime(); static jclass calendar_class = jenv->FindClass("java/util/Calendar"); static jmethodID getID = jenv->GetMethodID(calendar_class,"get","(I)I"); - static jfieldID yearID = jenv->GetFieldID(calendar_class,"YEAR","I"); - static jfieldID monthID = jenv->GetFieldID(calendar_class,"MONTH","I"); - static jfieldID dayID = jenv->GetFieldID(calendar_class,"DAY","I"); - static jfieldID hourID = jenv->GetFieldID(calendar_class,"HOUR","I"); - static jfieldID minuteID = jenv->GetFieldID(calendar_class,"MINUTE","I"); - static jfieldID secondID = jenv->GetFieldID(calendar_class,"SECOND","I"); - static jint yearfield = jenv->GetIntField(calendar_class,yearID); - static jint monthfield = jenv->GetIntField(calendar_class,monthID); - static jint dayfield = jenv->GetIntField(calendar_class,dayID); - static jint hourfield = jenv->GetIntField(calendar_class,hourID); - static jint minutefield = jenv->GetIntField(calendar_class,minuteID); - static jint secondfield = jenv->GetIntField(calendar_class,secondID); + static jfieldID yearID = jenv->GetStaticFieldID(calendar_class,"YEAR","I"); + static jfieldID monthID = jenv->GetStaticFieldID(calendar_class,"MONTH","I"); + static jfieldID dayID = jenv->GetStaticFieldID(calendar_class,"DAY_OF_MONTH","I"); + static jfieldID hourID = jenv->GetStaticFieldID(calendar_class,"HOUR","I"); + static jfieldID minuteID = jenv->GetStaticFieldID(calendar_class, + "MINUTE","I"); + static jfieldID secondID = jenv->GetStaticFieldID(calendar_class, + "SECOND","I"); + static jint yearfield = jenv->GetStaticIntField(calendar_class,yearID); + static jint monthfield = jenv->GetStaticIntField(calendar_class,monthID); + static jint dayfield = jenv->GetStaticIntField(calendar_class,dayID); + static jint hourfield = jenv->GetStaticIntField(calendar_class,hourID); + static jint minutefield = jenv->GetStaticIntField(calendar_class,minuteID); + static jint secondfield = jenv->GetStaticIntField(calendar_class,secondID); jint yearval = jenv->CallIntMethod($input,getID,yearfield); jint monthval = jenv->CallIntMethod($input,getID,monthfield); jint dayval = jenv->CallIntMethod($input,getID,dayfield); @@ -58,16 +72,14 @@ $1 = dt; } -%typemap(out) (NdbDateTime *) { - static jclass calendar_class = jenv->FindClass("java/util/Calendar"); - static jmethodID get_calendar_instance = - jenv->GetStaticMethodID(calendar_class,"", - "()V"); - static jmethodID setID = jenv->GetMethodID(calendar_class,"set","(IIIIII)V"); - $result = jenv->CallObjectMethod(calendar_class,get_calendar_instance); - jenv->CallVoidMethod($result,setID,$1->year,$1->month,$1->day, - $1->hour,$1->minute,$1->second); - +%typemap(out) NdbDateTime *, NdbDate *, NdbTime * { + static jclass timestamp_class = jenv->FindClass("java/sql/Timestamp"); + static jmethodID timestamp_ctr = + jenv->GetStaticMethodID(timestamp_class,"", + "(IIIIIII)V"); + $result = jenv->NewObject(timestamp_class,timestamp_ctr, + $1->year,$1->month,$1->day, + $1->hour,$1->minute,$1->second); } === modified file 'java/swig/NdbOperation.i' --- a/java/swig/NdbOperation.i 2008-05-20 16:39:21 +0000 +++ b/java/swig/NdbOperation.i 2008-06-02 12:11:56 +0000 @@ -42,4 +42,5 @@ %typemap(javainterfaces) NdbOperation "NdbOperation"; %typemap(javabase) NdbOperation "NdbBaseOperationEqualsImpl"; + %include "ndbapi/NdbOperation.i" === modified file 'java/testsuite/BaseNdbjTestCase.java' --- a/java/testsuite/BaseNdbjTestCase.java 2008-05-30 04:59:35 +0000 +++ b/java/testsuite/BaseNdbjTestCase.java 2008-06-02 12:14:10 +0000 @@ -179,6 +179,8 @@ */ @Override protected void createTable(String tableName, String columnsAndOtherStuff) throws SQLException { + + super.dropTable(tableName); super.createTable(tableName, columnsAndOtherStuff); NdbDictionary theDict = ndb.getDictionary(); theDict.invalidateTable(tableName); === added file 'java/testsuite/ndbj/DateTimeTest.java' --- a/java/testsuite/ndbj/DateTimeTest.java 1970-01-01 00:00:00 +0000 +++ b/java/testsuite/ndbj/DateTimeTest.java 2008-06-02 12:11:56 +0000 @@ -0,0 +1,143 @@ +package testsuite.ndbj; + +import java.sql.Date; +import java.sql.SQLException; +import java.sql.Time; +import java.sql.Timestamp; +import java.text.DateFormat; +import java.text.SimpleDateFormat; +import java.util.Calendar; +import java.util.TimeZone; + +import com.mysql.cluster.ndbj.NdbApiException; +import com.mysql.cluster.ndbj.NdbOperation; +import com.mysql.cluster.ndbj.NdbOperation.LockMode; + +import testsuite.BaseNdbjTestCase; + +public class DateTimeTest extends BaseNdbjTestCase { + + String tablename = "t_datetime"; + Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT")); + DateFormat df = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss z"); + Calendar calGMT = Calendar.getInstance(TimeZone.getTimeZone("GMT")); + Timestamp nowTstamp = null; + Date nowDate = null; + Timestamp nowDatetime = null; + Time nowTime = null; + + public DateTimeTest(String arg0) { + super(arg0); + } + + @Override + public void setUp() throws Exception { + + super.setUp(); + + createTable(tablename, + "(id integer not null primary key, " + + "tstamp TIMESTAMP, " + + "dt DATE, " + + "dtime DATETIME, " + + "tm TIME) engine=ndbcluster"); + + cal.set(Calendar.MONTH, 6); + cal.set(Calendar.DAY_OF_MONTH, 3); + cal.set(Calendar.YEAR, 2002); + cal.set(Calendar.HOUR, 7); + cal.set(Calendar.MINUTE, 0); + cal.set(Calendar.SECOND, 0); + cal.set(Calendar.MILLISECOND, 0); + cal.set(Calendar.AM_PM, Calendar.AM); + cal.getTime(); + nowTstamp = new Timestamp(cal.getTime().getTime()); + nowDate = new java.sql.Date(cal.getTime().getTime()); + nowDatetime = new Timestamp(cal.getTime().getTime()); + nowTime = new java.sql.Time(cal.getTime().getTime()); + } + + public void testInsert() throws NdbApiException, SQLException { + + trans = ndb.startTransaction(); + + NdbOperation op = trans.getInsertOperation(tablename); + + op.equalInt("id", 1); + op.setTimestamp("tstamp", nowTstamp); + op.setDate("dt", nowDate); + op.setTimestamp("dtime", nowDatetime); + op.setTime("tm", nowTime); + + this.rs = op.resultData(); + + trans.executeCommit(); + + this.rs = this.stmt.executeQuery("SELECT * from " + tablename); + + while (this.rs.next()) { + Timestamp thenTstamp = this.rs.getTimestamp(2,cal); + assertEquals(thenTstamp.getTime(),nowTstamp.getTime()); + + Date thenDate = this.rs.getDate(3); + System.out.println(thenDate); System.out.println(nowDate); + assertEquals(thenDate.getYear()+1900,2002); + assertEquals(thenDate.getMonth(),nowDate.getMonth()); + assertEquals(thenDate.getDay(),3); + + Timestamp thenDatetime = this.rs.getTimestamp(4); + assertEquals(thenDatetime.getTime(),nowDatetime.getTime()); + + Time thenTime = this.rs.getTime(5); + assertEquals(thenTime.getTime(),nowTime.getTime()); + + } + + } + public void NotestRead() throws NdbApiException, SQLException { + this.pstmt = this.conn.prepareStatement( + "INSERT INTO " + + tablename + + " (id, tstamp, dt, dtime, tm) VALUES (?, ?, ?, ?, ?)"); + this.pstmt.setInt(1, 1); + this.pstmt.setTimestamp(2, nowTstamp, calGMT); + // have to use the same TimeZone as used to create or there will be + // shift + this.pstmt.setDate(3, nowDate, cal); + this.pstmt.setTimestamp(4, nowDatetime, calGMT); + // have to use the same TimeZone as used to create or there will be + // shift + this.pstmt.setTime(5, nowTime, cal); + this.pstmt.execute(); + + trans = ndb.startTransaction(); + + NdbOperation op = trans.getSelectOperation(tablename, + LockMode.LM_Read); + + op.equalInt("id", 1); + op.getValue("tstamp"); + op.getValue("dt"); + op.getValue("dtime"); + op.getValue("tm"); + + this.rs = op.resultData(); + + trans.executeCommit(); + + while (this.rs.next()) { + Timestamp thenTstamp = this.rs.getTimestamp("tstamp", calGMT); + assertEquals(thenTstamp.getTime(),nowTstamp.getTime()); + + Date thenDate = this.rs.getDate("dt", cal); + assertEquals(thenDate.getTime(),nowDate.getTime()); + + Timestamp thenDatetime = this.rs.getTimestamp("dtime", calGMT); + assertEquals(thenDatetime.getTime(),nowDatetime.getTime()); + + Time thenTime = this.rs.getTime("tm", cal); + assertEquals(thenTime.getTime(),nowTime.getTime()); + + } + } +}