src/jdbc/JSqlStatement.cxx

   1 #include<AbsSqlStatement.h>
   2 #include<SqlFactory.h>
   3 #include<SqlNwStatement.h>
   4 //sqlStmtPtr
   5
   6
   7 /* DO NOT EDIT THIS FILE - it is machine generated */
   8 #include <jni.h>
   9 /* Header for class JSqlStatement */
  10
  11 #ifdef __cplusplus
  12 extern "C" {
  13 #endif
  14 /*
  15  * Class:     JSqlStatement
  16  * Method:    alloc
  17  * Signature: ()V
  18  */
  19 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_alloc
  20   (JNIEnv *env, jobject obj, jint mode)
  21 {
  22     jclass cls;
  23     jfieldID fid;
  24
  25     AbsSqlStatement *stmt;
  26     switch(mode)
  27     {
  28         case 1:
  29         {
  30             stmt = SqlFactory::createStatement(CSql);
  31             break;
  32         }
  33         case 2:
  34         {
  35             stmt = SqlFactory::createStatement(CSqlGateway);
  36             break;
  37         }
  38         case 3:
  39         {
  40             stmt = SqlFactory::createStatement(CSqlAdapter);
  41             break;
  42         }
  43         default:
  44         {
  45             stmt = new SqlNwStatement();
  46             stmt->setInnerStatement(NULL);
  47         }
  48     }
  49     cls = env->GetObjectClass( obj );
  50     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
  51     if (fid == 0)
  52     {
  53         jclass Exception = env->FindClass("java/lang/Exception");
  54         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
  55         return;
  56     }
  57     env->SetLongField( obj, fid, (jlong) stmt );
  58     return;
  59 }
  60
  61 /*
  62  * Class:     JSqlStatement
  63  * Method:    free
  64  * Signature: ()V
  65  */
  66 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_free
  67   (JNIEnv *env, jobject obj)
  68 {
  69     jclass cls;
  70     jfieldID fid;
  71
  72     cls = env->GetObjectClass(obj);
  73     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
  74     if (fid == 0)
  75     {
  76         jclass Exception = env->FindClass("java/lang/Exception");
  77         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
  78         return;
  79     }
  80     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
  81     delete stmt;
  82     return;
  83 }
  84
  85 /*
  86  * Class:     JSqlStatement
  87  * Method:    freeStmt
  88  * Signature: ()V
  89  */
  90 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_freeStmt
  91   (JNIEnv *env, jobject obj)
  92 {
  93     jclass cls;
  94     jfieldID fid;
  95
  96     cls = env->GetObjectClass(obj);
  97     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
  98     if (fid == 0)
  99     {
 100         jclass Exception = env->FindClass("java/lang/Exception");
 101         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 102         return;
 103     }
 104     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid);
 105     stmt->free();
 106     return;
 107
 108 }
 109
 110 /*
 111  * Class:     JSqlStatement
 112  * Method:    setConnectionPtr
 113  * Signature: (J)V
 114  */
 115 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setConnectionPtr
 116   (JNIEnv *env, jobject obj, jlong conn)
 117 {
 118
 119     jclass cls;
 120     jfieldID fid;
 121
 122     cls = env->GetObjectClass(obj);
 123     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 124     if (fid == 0)
 125     {
 126         jclass Exception = env->FindClass("java/lang/Exception");
 127         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 128         return;
 129     }
 130     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid);
 131     stmt->setConnection((AbsSqlConnection*) conn);
 132     return;
 133 }
 134
 135 /*
 136  * Class:     JSqlStatement
 137  * Method:    prepare
 138  * Signature: (Ljava/lang/String;)I
 139  */
 140 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_prepare
 141   (JNIEnv *env, jobject obj, jstring stmt)
 142 {
 143     jclass cls;
 144     jfieldID fid;
 145
 146     cls = env->GetObjectClass(obj);
 147     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 148     if (fid == 0)
 149     {
 150         jclass Exception = env->FindClass("java/lang/Exception");
 151         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 152         return(-1);
 153     }
 154     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 155     jboolean isCopy = JNI_TRUE;
 156     char *stmtString = (char*) env->GetStringUTFChars(stmt, &isCopy );
 157     int rv = s->prepare(stmtString);
 158     env->ReleaseStringUTFChars(stmt, stmtString);
 159     return rv;
 160 }
 161
 162 /*
 163  * Class:     JSqlStatement
 164  * Method:    isSelect
 165  * Signature: ()Z
 166  */
 167 JNIEXPORT jboolean JNICALL Java_csql_jdbc_JSqlStatement_isSelect
 168   (JNIEnv *env, jobject obj)
 169 {
 170     jclass cls;
 171     jfieldID fid;
 172
 173     cls = env->GetObjectClass(obj);
 174     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 175     if (fid == 0)
 176     {
 177         jclass Exception = env->FindClass("java/lang/Exception");
 178         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 179         return(-1);
 180     }
 181     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 182     return s->isSelect();
 183 }
 184
 185 /*
 186  * Class:     JSqlStatement
 187  * Method:    execute
 188  * Signature: ()I
 189  */
 190 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_execute
 191   (JNIEnv *env, jobject obj)
 192 {
 193     jclass cls;
 194     jfieldID fid;
 195
 196     cls = env->GetObjectClass(obj);
 197     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 198     if (fid == 0)
 199     {
 200         jclass Exception = env->FindClass("java/lang/Exception");
 201         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 202         return(-1);
 203     }
 204     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 205     int rowsAffected =0;
 206     DbRetVal rv = stmt->execute(rowsAffected);
 207     if (rv != OK) return -1;
 208     return rowsAffected;
 209 }
 210
 211 /*
 212  * Class:     JSqlStatement
 213  * Method:    next
 214  * Signature: ()J
 215  */
 216 JNIEXPORT jlong JNICALL Java_csql_jdbc_JSqlStatement_next
 217   (JNIEnv *env, jobject obj)
 218 {
 219     jclass cls;
 220     jfieldID fid;
 221     cls = env->GetObjectClass(obj);
 222     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 223     if (fid == 0)
 224     {
 225         jclass Exception = env->FindClass("java/lang/Exception");
 226         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 227         return(-1);
 228     }
 229     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 230     void *tuple = stmt->next();
 231     if (NULL == tuple) return 0; else return 1;
 232 }
 233
 234 /*
 235  * Class:     JSqlStatement
 236  * Method:    close
 237  * Signature: ()J
 238  */
 239 JNIEXPORT jlong JNICALL Java_csql_jdbc_JSqlStatement_close
 240   (JNIEnv *env, jobject obj)
 241 {
 242    //TODO::stmt currently does not support close
 243     jclass cls;
 244     jfieldID fid;
 245     cls = env->GetObjectClass(obj);
 246     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 247     if (fid == 0)
 248     {
 249         jclass Exception = env->FindClass("java/lang/Exception");
 250         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 251         return(-1);
 252     }
 253     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 254     int rv =0;
 255     rv  = stmt->close();
 256     return rv;
 257 }
 258
 259 /*
 260  * Class:     JSqlStatement
 261  * Method:    setBoolean
 262  * Signature: (I)Z
 263  */
 264 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setBoolean
 265   (JNIEnv *env, jobject obj, jint position, jint value)
 266 {};
 267
 268 /*
 269  * Class:     JSqlStatement
 270  * Method:    setShort
 271  * Signature: (IS)V
 272  */
 273 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setShort
 274   (JNIEnv *env, jobject obj, jint position, jshort value)
 275 {
 276     jclass cls;
 277     jfieldID fid;
 278
 279     cls = env->GetObjectClass( obj );
 280     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 281     if (fid == 0)
 282     {
 283         jclass Exception = env->FindClass("java/lang/Exception");
 284         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 285         return;
 286     }
 287     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 288     stmt->setShortParam(position, (short) value);
 289     return;
 290 }
 291
 292 /*
 293  * Class:     JSqlStatement
 294  * Method:    setInt
 295  * Signature: (II)V
 296  */
 297 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setInt
 298   (JNIEnv *env, jobject obj, jint position, jint value)
 299 {
 300     jclass cls;
 301     jfieldID fid;
 302
 303     cls = env->GetObjectClass( obj );
 304     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 305     if (fid == 0)
 306     {
 307         jclass Exception = env->FindClass("java/lang/Exception");
 308         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 309         return;
 310     }
 311     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 312     stmt->setIntParam(position, (int) value);
 313     return;
 314 }
 315
 316 /*
 317  * Class:     JSqlStatement
 318  * Method:    setLong
 319  * Signature: (IJ)V
 320  */
 321 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setLong
 322   (JNIEnv *env, jobject obj, jint position, jlong value)
 323 {
 324     jclass cls;
 325     jfieldID fid;
 326
 327     cls = env->GetObjectClass( obj );
 328     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 329     if (fid == 0)
 330     {
 331         jclass Exception = env->FindClass("java/lang/Exception");
 332         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 333         return;
 334     }
 335     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 336     stmt->setLongLongParam(position, (long long) value);
 337     return;
 338 }
 339
 340 /*
 341  * Class:     JSqlStatement
 342  * Method:    setByte
 343  * Signature: (IB)V
 344  */
 345 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setByte
 346   (JNIEnv *env, jobject obj, jint position, jbyte value)
 347 {
 348     jclass cls;
 349     jfieldID fid;
 350
 351     cls = env->GetObjectClass( obj );
 352     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 353     if (fid == 0)
 354     {
 355         jclass Exception = env->FindClass("java/lang/Exception");
 356         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 357         return;
 358     }
 359     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 360     stmt->setByteIntParam(position, (ByteInt) value);
 361     return;
 362 }
 363 /*
 364  * Class:     JSqlStatement
 365  * Method:    setFloat
 366  * Signature: (IF)V
 367  */
 368 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setFloat
 369   (JNIEnv *env, jobject obj, jint position, jfloat value)
 370 {
 371     jclass cls;
 372     jfieldID fid;
 373
 374     cls = env->GetObjectClass( obj );
 375     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 376     if (fid == 0)
 377     {
 378         jclass Exception = env->FindClass("java/lang/Exception");
 379         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 380         return;
 381     }
 382     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 383     stmt->setFloatParam(position, (float) value);
 384     return;
 385 }
 386
 387 /*
 388  * Class:     JSqlStatement
 389  * Method:    setDouble
 390  * Signature: (ID)V
 391  */
 392 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setDouble
 393   (JNIEnv *env, jobject obj, jint position, jdouble value)
 394 {
 395     jclass cls;
 396     jfieldID fid;
 397
 398     cls = env->GetObjectClass( obj );
 399     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 400     if (fid == 0)
 401     {
 402         jclass Exception = env->FindClass("java/lang/Exception");
 403         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 404         return;
 405     }
 406     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 407     stmt->setDoubleParam(position, (double) value);
 408     return;
 409 }
 410
 411 /*
 412  * Class:     JSqlStatement
 413  * Method:    setString
 414  * Signature: (ILjava/lang/String;)V
 415  */
 416 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setString
 417   (JNIEnv *env, jobject obj, jint position, jstring value)
 418 {
 419     jclass cls;
 420     jfieldID fid;
 421
 422     cls = env->GetObjectClass( obj );
 423     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 424     if (fid == 0)
 425     {
 426         jclass Exception = env->FindClass("java/lang/Exception");
 427         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 428         return;
 429     }
 430
 431     jboolean isCopy = JNI_TRUE;
 432     char *valueStr = (char*) env->GetStringUTFChars( value, &isCopy );
 433
 434     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 435     stmt->setStringParam(position, valueStr);
 436     env->ReleaseStringUTFChars(value, valueStr);
 437     return;
 438 }
 439
 440 /*
 441  * Class:     JSqlStatement
 442  * Method:    setDate
 443  * Signature: (ILjava/sql/Date;)V
 444  */
 445 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setDate
 446   (JNIEnv *env, jobject obj, jint position, jobject dateObj)
 447
 448 {
 449     jclass cls, datecls;
 450     jfieldID fid;
 451     jmethodID dateMethod;
 452
 453     cls = env->GetObjectClass( obj );
 454     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 455     if (fid == 0)
 456     {
 457         jclass Exception = env->FindClass("java/lang/Exception");
 458         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 459         return;
 460     }
 461     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 462
 463     // Get date, month, year from java object
 464     int d, m, y;
 465     datecls = env->GetObjectClass( dateObj );
 466     dateMethod = env->GetMethodID( datecls, "getYear", "()I");
 467     y = env->CallIntMethod( dateObj, dateMethod);
 468     dateMethod = env->GetMethodID( datecls, "getMonth", "()I");
 469     m = env->CallIntMethod( dateObj, dateMethod);
 470     dateMethod = env->GetMethodID( datecls, "getDate", "()I");
 471     d = env->CallIntMethod( dateObj, dateMethod);
 472
 473     Date date(y + 1900, m + 1, d);
 474     stmt->setDateParam(position, date);
 475
 476     return;
 477 }
 478
 479
 480 /*
 481  * Class:     JSqlStatement
 482  * Method:    setTime
 483  * Signature: (ILjava/sql/Time;)V
 484  */
 485 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setTime
 486   (JNIEnv *env, jobject obj, jint position, jobject timeObj)
 487
 488 {
 489     jclass cls, timecls;
 490     jfieldID fid;
 491     jmethodID timeMethod;
 492
 493     cls = env->GetObjectClass( obj );
 494     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 495     if (fid == 0)
 496     {
 497         jclass Exception = env->FindClass("java/lang/Exception");
 498         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 499         return;
 500     }
 501     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 502
 503     // Get hour, minures, secs from java object
 504     int h, m, s;
 505     timecls = env->GetObjectClass( timeObj );
 506     timeMethod = env->GetMethodID( timecls, "getHours", "()I");
 507     h = env->CallIntMethod( timeObj, timeMethod);
 508     timeMethod = env->GetMethodID( timecls, "getMinutes", "()I");
 509     m = env->CallIntMethod( timeObj, timeMethod);
 510     timeMethod = env->GetMethodID( timecls, "getSeconds", "()I");
 511     s = env->CallIntMethod( timeObj, timeMethod);
 512
 513     Time time(h, m, s, 0);
 514     stmt->setTimeParam(position, time);
 515
 516     return;
 517 }
 518
 519 /*
 520  * Class:     JSqlStatement
 521  * Method:    setTimestamp
 522  * Signature: (ILjava/sql/Timestamp;)V
 523  */
 524 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setTimestamp
 525   (JNIEnv *env, jobject obj, jint position, jobject timeObj)
 526
 527 {
 528     jclass cls, timecls;
 529     jfieldID fid;
 530     jmethodID timeMethod;
 531
 532     cls = env->GetObjectClass( obj );
 533     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 534     if (fid == 0)
 535     {
 536         jclass Exception = env->FindClass("java/lang/Exception");
 537         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 538         return;
 539     }
 540     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 541
 542     // Get year, month, day, hour, minutes, secs from java object
 543     int y, mo, d, h, mn, s;
 544     timecls = env->GetObjectClass( timeObj );
 545
 546     timeMethod = env->GetMethodID( timecls, "getYear", "()I");
 547     y = env->CallIntMethod( timeObj, timeMethod );
 548     timeMethod = env->GetMethodID( timecls, "getMonth", "()I");
 549     mo = env->CallIntMethod( timeObj, timeMethod );
 550     timeMethod = env->GetMethodID( timecls, "getDate", "()I");
 551     d = env->CallIntMethod( timeObj, timeMethod );
 552     timeMethod = env->GetMethodID( timecls, "getHours", "()I");
 553     h = env->CallIntMethod( timeObj, timeMethod);
 554     timeMethod = env->GetMethodID( timecls, "getMinutes", "()I");
 555     mn = env->CallIntMethod( timeObj, timeMethod);
 556     timeMethod = env->GetMethodID( timecls, "getSeconds", "()I");
 557     s = env->CallIntMethod( timeObj, timeMethod);
 558
 559     TimeStamp timeStamp(y + 1900, mo + 1, d, h, mn, s, 0);
 560     stmt->setTimeStampParam(position, timeStamp);
 561
 562     return;
 563 }
 564
 565 /*
 566  * Class:     JSqlStatement
 567  * Method:    getShort
 568  * Signature: (I)S
 569  */
 570 JNIEXPORT jshort JNICALL Java_csql_jdbc_JSqlStatement_getShort
 571   (JNIEnv *env, jobject obj, jint pos, jint type)
 572 {
 573     jclass cls;
 574     jfieldID fid;
 575
 576     cls = env->GetObjectClass( obj );
 577     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 578     if (fid == 0)
 579     {
 580         jclass Exception = env->FindClass("java/lang/Exception");
 581         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 582         return(-1);
 583     }
 584     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 585
 586     // Validate pos
 587     // Handle conversion
 588
 589     // Read data at column
 590     void *fvp = sqlStmt->getFieldValuePtr( pos );
 591     if(type == typeShort)
 592         return( * ((short*)fvp) );
 593     else {
 594         short val;
 595         AllDataType::convertToShort(&val, fvp, (DataType)type);
 596         return val;
 597     }
 598 }
 599
 600 /*
 601  * Class:     JSqlStatement
 602  * Method:    setNull
 603  * Signature: (I)V
 604  */
 605 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setNull
 606   (JNIEnv *env, jobject obj, jint pos)
 607 {
 608     jclass cls;
 609     jfieldID fid;
 610
 611     cls = env->GetObjectClass(obj);
 612     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 613     if (fid == 0)
 614     {
 615         jclass Exception = env->FindClass("java/lang/Exception");
 616         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 617         return;
 618     }
 619     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 620     s->setNull(pos);
 621     return;
 622 }
 623
 624
 625
 626 /*
 627  * Class:     csql_jdbc_JSqlStatement
 628  * Method:    isNull
 629  * Signature: (I)Z
 630  */
 631 JNIEXPORT jboolean JNICALL Java_csql_jdbc_JSqlStatement_isNull
 632   (JNIEnv *env, jobject obj, jint pos)
 633 {
 634     jclass cls;
 635     jfieldID fid;
 636
 637     cls = env->GetObjectClass(obj);
 638     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 639     if (fid == 0)
 640     {
 641         jclass Exception = env->FindClass("java/lang/Exception");
 642         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 643         return(-1);
 644     }
 645     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 646     return s->isFldNull(pos);
 647 }
 648
 649
 650 /*
 651  * Class:     csql_jdbc_JSqlStatement
 652  * Method:    findColumn
 653  * Signature: (Ljava/lang/String;)I
 654  */
 655 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_findColumn
 656   (JNIEnv *env, jobject obj, jstring value)
 657 {
 658     jclass cls;
 659     jfieldID fid;
 660
 661     cls = env->GetObjectClass(obj);
 662     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 663     if (fid == 0)
 664     {
 665         jclass Exception = env->FindClass("java/lang/Exception");
 666         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 667         return(-1);
 668     }
 669
 670     jboolean isCopy = JNI_TRUE;
 671     char *valueStr = (char*) env->GetStringUTFChars( value, &isCopy );
 672
 673     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 674     int val = s->getFldPos(valueStr);
 675     env->ReleaseStringUTFChars(value, valueStr);
 676     return val;
 677 }
 678
 679 /*
 680  * Class:     csql_jdbc_JSqlStatement
 681  * Method:    getParamFldName
 682  * Signature: (I)Ljava/lang/String;
 683  */
 684 JNIEXPORT jstring JNICALL Java_csql_jdbc_JSqlStatement_getParamFldName
 685   (JNIEnv *env, jobject obj, jint pos)
 686 {
 687     jclass cls;
 688     jfieldID fid;
 689
 690     cls = env->GetObjectClass(obj);
 691     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 692     if (fid == 0)
 693     {
 694         jclass Exception = env->FindClass("java/lang/Exception");
 695         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 696         return((jstring) 0);
 697     }
 698     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 699     FieldInfo *field = new FieldInfo();
 700     DbRetVal rv = s->getParamFldInfo(pos,field);
 701     if(rv!=OK)return NULL;
 702     _jstring *name = env->NewStringUTF( (char*) field->fldName );
 703     //For free above line is written
 704     delete field;
 705     return name;
 706 }
 707
 708 /*
 709  * Class:     csql_jdbc_JSqlStatement
 710  * Method:    getTotalparam
 711  * Signature: ()I
 712  */
 713 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_getTotalparam
 714   (JNIEnv *env, jobject obj)
 715 {
 716     jclass cls;
 717     jfieldID fid;
 718
 719     cls = env->GetObjectClass(obj);
 720     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 721     if (fid == 0)
 722     {
 723         jclass Exception = env->FindClass("java/lang/Exception");
 724         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 725         return(-1);
 726     }
 727     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 728
 729     return (s->noOfParamFields());
 730 }
 731
 732 /*
 733  * Class:     csql_jdbc_JSqlStatement
 734  * Method:    getType
 735  * Signature: (I)I
 736  */
 737 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_getType
 738   (JNIEnv *env, jobject obj, jint pos)
 739 {
 740     jclass cls;
 741     jfieldID fid;
 742
 743     cls = env->GetObjectClass(obj);
 744     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 745     if (fid == 0)
 746     {
 747         jclass Exception = env->FindClass("java/lang/Exception");
 748         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 749         return(-1);
 750     }
 751     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 752
 753     FieldInfo *field = new FieldInfo();
 754     DbRetVal rv = s->getParamFldInfo(pos,field);
 755     if(rv!=OK) { delete field; return 100; }
 756     int type = field->type;
 757     delete field;
 758     return type;
 759
 760 }
 761
 762 /*
 763  * Class:     csql_jdbc_JSqlStatement
 764  * Method:    isNullable
 765  * Signature: (I)Z
 766  */
 767 JNIEXPORT jboolean JNICALL Java_csql_jdbc_JSqlStatement_isNullable
 768   (JNIEnv *env, jobject obj, jint pos)
 769 {
 770     jclass cls;
 771     jfieldID fid;
 772
 773     cls = env->GetObjectClass(obj);
 774     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 775     if (fid == 0)
 776     {
 777         jclass Exception = env->FindClass("java/lang/Exception");
 778         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 779         return(-1);
 780     }
 781     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 782
 783     FieldInfo *field = new FieldInfo();
 784     DbRetVal rv = s->getParamFldInfo(pos,field);
 785     if(rv!=OK) { delete field; return (-1); }
 786     if(field->isNull){
 787         delete field;
 788         return true;
 789     }else{
 790         delete field;
 791         return false;
 792     }
 793 }
 794
 795
 796 /*
 797  * Class:     csql_jdbc_JSqlStatement
 798  * Method:    getTotalProjFld
 799  * Signature: ()I
 800  */
 801
 802 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_getTotalProjFld
 803   (JNIEnv *env, jobject obj)
 804 {
 805     jclass cls;
 806     jfieldID fid;
 807
 808     cls = env->GetObjectClass(obj);
 809     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 810     if (fid == 0)
 811     {
 812         jclass Exception = env->FindClass("java/lang/Exception");
 813         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 814         return(-1);
 815     }
 816     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 817
 818     return (s->noOfProjFields());
 819
 820 }
 821
 822 /*
 823  * Class:     csql_jdbc_JSqlStatement
 824  * Method:    getProjFldType
 825  * Signature: (I)I
 826  */
 827 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_getProjFldType
 828   (JNIEnv *env, jobject obj, jint pos)
 829 {
 830     jclass cls;
 831     jfieldID fid;
 832
 833     cls = env->GetObjectClass(obj);
 834     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 835     if (fid == 0)
 836     {
 837         jclass Exception = env->FindClass("java/lang/Exception");
 838         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 839         return(-1);
 840     }
 841     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 842
 843     FieldInfo *field = new FieldInfo();
 844     s->getProjFldInfo(pos,field);
 845     int type = field->type;
 846     delete field;
 847     return type;
 848 }
 849
 850 /*
 851  * Class:     csql_jdbc_JSqlStatement
 852  * Method:    getProjFldTypeArray
 853  * Signature: ()[I
 854  */
 855 JNIEXPORT jintArray JNICALL Java_csql_jdbc_JSqlStatement_getProjFldTypeArray__
 856   (JNIEnv *env, jobject obj)
 857  {
 858     jclass cls;
 859     jfieldID fid;
 860
 861     cls = env->GetObjectClass(obj);
 862     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 863     if (fid == 0)
 864     {
 865         jclass Exception = env->FindClass("java/lang/Exception");
 866         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 867         return 0;
 868     }
 869     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 870
 871     int noOfFld = s->noOfProjFields();
 872     jintArray result = env->NewIntArray(noOfFld+1);
 873     jint *resultInt = env->GetIntArrayElements(result, NULL);
 874     s->getProjFieldType((int*)resultInt);
 875     //for(int i=1; i< noOfFld+1; i++)
 876     //    printf("TYpe In ARRAY  %d \n",resultInt[i]);
 877     //printf("\n");
 878     env->ReleaseIntArrayElements(result, resultInt, 0);
 879     return result;
 880 }
 881
 882 /*
 883  * Class:     csql_jdbc_JSqlStatement
 884  * Method:    isFldNullable
 885  * Signature: (I)Z
 886  */
 887 JNIEXPORT jboolean JNICALL Java_csql_jdbc_JSqlStatement_isFldNullable
 888   (JNIEnv *env, jobject obj, jint pos)
 889 {
 890     jclass cls;
 891     jfieldID fid;
 892
 893     cls = env->GetObjectClass(obj);
 894     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 895     if (fid == 0)
 896     {
 897         jclass Exception = env->FindClass("java/lang/Exception");
 898         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 899         return(-1);
 900     }
 901     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 902     FieldInfo *field = new FieldInfo();
 903     s->getProjFldInfo(pos,field);
 904     bool nul = field->isNull;
 905     delete field;
 906     return nul;
 907 }
 908
 909
 910 /*
 911  * Class:     csql_jdbc_JSqlStatement
 912  * Method:    getProjFldName
 913  * Signature: (I)Ljava/lang/String;
 914  */
 915 JNIEXPORT jstring JNICALL Java_csql_jdbc_JSqlStatement_getProjFldName
 916   (JNIEnv *env, jobject obj, jint pos)
 917 {
 918     jclass cls;
 919     jfieldID fid;
 920
 921     cls = env->GetObjectClass(obj);
 922     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 923     if (fid == 0)
 924     {
 925         jclass Exception = env->FindClass("java/lang/Exception");
 926         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 927         return( (jstring) 0 );
 928     }
 929     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 930     FieldInfo *field = new FieldInfo();
 931     s->getProjFldInfo(pos,field);
 932     _jstring *name = env->NewStringUTF( (char*) field->fldName );
 933     delete field;
 934     return name;
 935 }
 936
 937
 938 /*
 939  * Class:     csql_jdbc_JSqlStatement
 940  * Method:    getTableName
 941  * Signature: ()Ljava/lang/String;
 942  */
 943 JNIEXPORT jstring JNICALL Java_csql_jdbc_JSqlStatement_getTableName
 944   (JNIEnv *env, jobject obj)
 945 {
 946     jclass cls;
 947     jfieldID fid;
 948
 949     cls = env->GetObjectClass(obj);
 950     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 951     if (fid == 0)
 952     {
 953         jclass Exception = env->FindClass("java/lang/Exception");
 954         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 955         return( (jstring) 0 );
 956     }
 957     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 958
 959
 960    return NULL;
 961 }
 962
 963
 964
 965 /*
 966  * Class:     JSqlStatement
 967  * Method:    getInt
 968  * Signature: (I)I
 969  */
 970 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_getInt
 971   (JNIEnv *env, jobject obj, jint pos,jint type)
 972 {
 973     jclass cls;
 974     jfieldID fid;
 975
 976     cls = env->GetObjectClass( obj );
 977     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 978     if (fid == 0)
 979     {
 980         jclass Exception = env->FindClass("java/lang/Exception");
 981         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 982         return(-1);
 983     }
 984     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 985
 986     // Validate pos
 987     // Handle conversion
 988     // Read data at column
 989     void *fvp = sqlStmt->getFieldValuePtr( pos );
 990     if(type == typeInt)
 991         return( * ((int*)fvp) );
 992     else {
 993         int val;
 994         AllDataType::convertToInt(&val, fvp, (DataType)type);
 995         return val;
 996     }
 997
 998 }
 999 /*
1000  * Class:     csql_jdbc_JSqlStatement
1001  * Method:    getIntS
1002  * Signature: (Ljava/lang/String;)I
1003  */
1004 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_getIntS
1005   (JNIEnv *env, jobject obj, jstring name)
1006 {
1007     jclass cls;
1008     jfieldID fid;
1009
1010     cls = env->GetObjectClass( obj );
1011     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1012     if (fid == 0)
1013     {
1014         jclass Exception = env->FindClass("java/lang/Exception");
1015         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1016         return(-1);
1017     }
1018     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1019     jboolean isCopy = JNI_TRUE;
1020     char *valueStr = (char*) env->GetStringUTFChars( name, &isCopy );
1021     void *fvp = sqlStmt->getFieldValuePtr( valueStr );
1022     env->ReleaseStringUTFChars(name, valueStr);
1023     return( * ((int*)fvp) );
1024 }
1025
1026 /*
1027  * Class:     csql_jdbc_JSqlStatement
1028  * Method:    getShortS
1029  * Signature: (Ljava/lang/String;)S
1030  */
1031 JNIEXPORT jshort JNICALL Java_csql_jdbc_JSqlStatement_getShortS
1032   (JNIEnv *env, jobject obj, jstring name)
1033 {
1034     jclass cls;
1035     jfieldID fid;
1036
1037     cls = env->GetObjectClass( obj );
1038     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1039     if (fid == 0)
1040     {
1041         jclass Exception = env->FindClass("java/lang/Exception");
1042         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1043         return(-1);
1044     }
1045     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1046     jboolean isCopy = JNI_TRUE;
1047     char *valueStr = (char*) env->GetStringUTFChars( name, &isCopy );
1048     void *fvp = sqlStmt->getFieldValuePtr( valueStr );
1049     env->ReleaseStringUTFChars(name, valueStr);
1050     return( * ((short*)fvp) );
1051
1052 }
1053
1054 /*
1055  * Class:     csql_jdbc_JSqlStatement
1056  * Method:    getLongS
1057  * Signature: (Ljava/lang/String;)J
1058  */
1059 JNIEXPORT jlong JNICALL Java_csql_jdbc_JSqlStatement_getLongS
1060   (JNIEnv *env, jobject obj, jstring name)
1061 {
1062   jclass cls;
1063     jfieldID fid;
1064
1065     cls = env->GetObjectClass( obj );
1066     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1067     if (fid == 0)
1068     {
1069         jclass Exception = env->FindClass("java/lang/Exception");
1070         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1071         return(-1);
1072     }
1073     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1074     jboolean isCopy = JNI_TRUE;
1075     char *valueStr = (char*) env->GetStringUTFChars( name, &isCopy );
1076     void *fvp = sqlStmt->getFieldValuePtr( valueStr );
1077     env->ReleaseStringUTFChars(name, valueStr);
1078     return( * ((long*)fvp) );
1079
1080 }
1081 /*
1082  * Class:     csql_jdbc_JSqlStatement
1083  * Method:    getByteS
1084  * Signature: (Ljava/lang/String;)B
1085  */
1086 JNIEXPORT jbyte JNICALL Java_csql_jdbc_JSqlStatement_getByteS
1087   (JNIEnv *env, jobject obj, jstring name)
1088 {
1089     jclass cls;
1090     jfieldID fid;
1091
1092     cls = env->GetObjectClass( obj );
1093     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1094     if (fid == 0)
1095     {
1096         jclass Exception = env->FindClass("java/lang/Exception");
1097         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1098         return(-1);
1099     }
1100     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1101     jboolean isCopy = JNI_TRUE;
1102     char *valueStr = (char*) env->GetStringUTFChars( name, &isCopy );
1103     void *fvp = sqlStmt->getFieldValuePtr( valueStr );
1104     env->ReleaseStringUTFChars(name, valueStr);
1105     return( * ((char*)fvp) );
1106
1107 }
1108 /*
1109  * Class:     csql_jdbc_JSqlStatement
1110  * Method:    getFloatS
1111  * Signature: (Ljava/lang/String;)F
1112  */
1113 JNIEXPORT jfloat JNICALL Java_csql_jdbc_JSqlStatement_getFloatS
1114   (JNIEnv *env, jobject obj, jstring name)
1115 {
1116     jclass cls;
1117     jfieldID fid;
1118
1119     cls = env->GetObjectClass( obj );
1120     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1121     if (fid == 0)
1122     {
1123         jclass Exception = env->FindClass("java/lang/Exception");
1124         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1125         return(-1);
1126     }
1127     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1128     jboolean isCopy = JNI_TRUE;
1129     char *valueStr = (char*) env->GetStringUTFChars( name, &isCopy );
1130     void *fvp = sqlStmt->getFieldValuePtr( valueStr );
1131     env->ReleaseStringUTFChars(name, valueStr);
1132     return( * ((float*)fvp) );
1133
1134 }
1135
1136 /*
1137  * Class:     csql_jdbc_JSqlStatement
1138  * Method:    getDoubleS
1139  * Signature: (Ljava/lang/String;)D
1140  */
1141 JNIEXPORT jdouble JNICALL Java_csql_jdbc_JSqlStatement_getDoubleS
1142   (JNIEnv *env, jobject obj, jstring name)
1143 {
1144     jclass cls;
1145     jfieldID fid;
1146
1147     cls = env->GetObjectClass( obj );
1148     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1149     if (fid == 0)
1150     {
1151         jclass Exception = env->FindClass("java/lang/Exception");
1152         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1153         return(-1);
1154     }
1155     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1156     jboolean isCopy = JNI_TRUE;
1157     char *valueStr = (char*) env->GetStringUTFChars( name, &isCopy );
1158     void *fvp = sqlStmt->getFieldValuePtr( valueStr );
1159     env->ReleaseStringUTFChars(name, valueStr);
1160     return( * ((double*)fvp) );
1161
1162 }
1163 /*
1164  * Class:     csql_jdbc_JSqlStatement
1165  * Method:    getStringS
1166  * Signature: (Ljava/lang/String;)Ljava/lang/String;
1167  */
1168 JNIEXPORT jstring JNICALL Java_csql_jdbc_JSqlStatement_getStringS
1169   (JNIEnv *env, jobject obj, jstring name)
1170 {
1171     jclass cls;
1172     jfieldID fid;
1173
1174     cls = env->GetObjectClass( obj );
1175     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1176     if (fid == 0)
1177     {
1178         jclass Exception = env->FindClass("java/lang/Exception");
1179         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1180         return( (jstring) 0 );
1181     }
1182     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1183     jboolean isCopy = JNI_TRUE;
1184     char *valueStr = (char*) env->GetStringUTFChars( name, &isCopy );
1185     void *fvp = sqlStmt->getFieldValuePtr( valueStr );
1186     env->ReleaseStringUTFChars(name, valueStr);
1187     return( env->NewStringUTF( (char*) fvp ) );
1188
1189
1190 }
1191
1192 /*
1193  * Class:     csql_jdbc_JSqlStatement
1194  * Method:    getDateS
1195  * Signature: (Ljava/lang/String;)Ljava/sql/Date;
1196  */
1197 JNIEXPORT jobject JNICALL Java_csql_jdbc_JSqlStatement_getDateS
1198   (JNIEnv *env, jobject obj, jstring name)
1199 {
1200     jclass cls;
1201     jfieldID fid;
1202
1203     cls = env->GetObjectClass( obj );
1204     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1205     if (fid == 0)
1206     {
1207         jclass Exception = env->FindClass("java/lang/Exception");
1208         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1209         return((jobject) 0);
1210     }
1211     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1212     jboolean isCopy = JNI_TRUE;
1213     char *valueStr = (char*) env->GetStringUTFChars( name, &isCopy );
1214     void *fvp = sqlStmt->getFieldValuePtr( valueStr );
1215     env->ReleaseStringUTFChars(name, valueStr);
1216
1217     jclass cDate = env->FindClass("java/sql/Date");
1218     jmethodID methodID = env->GetMethodID( cDate, "<init>", "(III)V" );
1219     jobject dateObj;
1220
1221     Date *dt = (Date*) fvp;
1222     dateObj = env->NewObject( cDate, methodID,
1223         (jint) dt->year()-1900, (jint) dt->month() - 1,
1224         (jint) dt->dayOfMonth() );
1225
1226     return( dateObj );
1227
1228
1229 }
1230
1231 /*
1232  * Class:     csql_jdbc_JSqlStatement
1233  * Method:    getTimeS
1234  * Signature: (Ljava/lang/String;)Ljava/sql/Time;
1235  */
1236 JNIEXPORT jobject JNICALL Java_csql_jdbc_JSqlStatement_getTimeS
1237   (JNIEnv *env, jobject obj, jstring name)
1238 {
1239     jclass cls;
1240     jfieldID fid;
1241
1242     cls = env->GetObjectClass( obj );
1243     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1244     if (fid == 0)
1245     {
1246         jclass Exception = env->FindClass("java/lang/Exception");
1247         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1248         return((jobject) 0);
1249     }
1250     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1251     jboolean isCopy = JNI_TRUE;
1252     char *valueStr = (char*) env->GetStringUTFChars( name, &isCopy );
1253     void *fvp = sqlStmt->getFieldValuePtr( valueStr );
1254     env->ReleaseStringUTFChars(name, valueStr);
1255     jclass cTime = env->FindClass("java/sql/Time");
1256     jmethodID methodID = env->GetMethodID( cTime, "<init>", "(III)V" );
1257     jobject timeObj;
1258
1259     Time *tm = (Time*) fvp;
1260     timeObj = env->NewObject( cTime, methodID,
1261         (jint) tm->hours(), (jint) tm->minutes(),
1262         (jint) tm->seconds() );
1263
1264     return( timeObj );
1265
1266 }
1267
1268 /*
1269  * Class:     csql_jdbc_JSqlStatement
1270  * Method:    getTimestampS
1271  * Signature: (Ljava/lang/String;)Ljava/sql/Timestamp;
1272  */
1273 JNIEXPORT jobject JNICALL Java_csql_jdbc_JSqlStatement_getTimestampS
1274   (JNIEnv *env, jobject obj, jstring name)
1275 {
1276     jclass cls;
1277     jfieldID fid;
1278
1279     cls = env->GetObjectClass( obj );
1280     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1281     if (fid == 0)
1282     {
1283         jclass Exception = env->FindClass("java/lang/Exception");
1284         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1285         return(((jobject) 0));
1286     }
1287     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1288     jboolean isCopy = JNI_TRUE;
1289     char *valueStr = (char*) env->GetStringUTFChars( name, &isCopy );
1290     void *fvp = sqlStmt->getFieldValuePtr( valueStr );
1291     env->ReleaseStringUTFChars(name, valueStr);
1292     jclass cTimestamp = env->FindClass("java/sql/Timestamp");
1293     jmethodID methodID = env->GetMethodID( cTimestamp, "<init>", "(IIIIIII)V" );
1294     jobject timeObj;
1295
1296     TimeStamp *ts = (TimeStamp*) fvp;
1297     timeObj = env->NewObject( cTimestamp, methodID, \
1298         (jint) ts->year()-1900, (jint) ts->month() - 1, (jint) ts->dayOfMonth(), \
1299         (jint) ts->hours(), (jint) ts->minutes(), (jint) ts->seconds(), (jint) 0 );
1300
1301     return( timeObj );
1302
1303 }
1304
1305 /*
1306  * Class:     csql_jdbc_JSqlStatement
1307  * Method:    getBooleanS
1308  * Signature: (Ljava/lang/String;)Z
1309  */
1310 JNIEXPORT jboolean JNICALL Java_csql_jdbc_JSqlStatement_getBooleanS
1311   (JNIEnv *env, jobject obj, jstring name)
1312 {
1313     jclass cls;
1314     jfieldID fid;
1315
1316     cls = env->GetObjectClass( obj );
1317     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1318     if (fid == 0)
1319     {
1320         jclass Exception = env->FindClass("java/lang/Exception");
1321         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1322         return( false );
1323     }
1324     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1325     jboolean isCopy = JNI_TRUE;
1326     char *valueStr = (char*) env->GetStringUTFChars( name, &isCopy );
1327     void *fvp = sqlStmt->getFieldValuePtr( valueStr );
1328     env->ReleaseStringUTFChars(name, valueStr);
1329     if(*(int*)fvp) return true;
1330     else return false;
1331 }
1332
1333 /*
1334  * Class:     JSqlStatement
1335  * Method:    getLong
1336  * Signature: (I)J
1337  */
1338 JNIEXPORT jlong JNICALL Java_csql_jdbc_JSqlStatement_getLong
1339   (JNIEnv *env, jobject obj, jint pos, jint type)
1340 {
1341     jclass cls;
1342     jfieldID fid;
1343
1344     cls = env->GetObjectClass( obj );
1345     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1346     if (fid == 0)
1347     {
1348         jclass Exception = env->FindClass("java/lang/Exception");
1349         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1350         return(-1);
1351     }
1352     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1353
1354     // Validate pos
1355     // Handle conversion
1356
1357     // Read data at column
1358     void *fvp = sqlStmt->getFieldValuePtr( pos );
1359     if(type == typeLong || type == typeLongLong)
1360         return( * ((long*)fvp) );
1361     else {
1362         long val;
1363         AllDataType::convertToLong(&val, fvp, (DataType)type);
1364         return val;
1365     }
1366 }
1367
1368 /*
1369  * Class:     JSqlStatement
1370  * Method:    getByte
1371  * Signature: (I)B
1372  */
1373 JNIEXPORT jbyte JNICALL Java_csql_jdbc_JSqlStatement_getByte
1374   (JNIEnv *env, jobject obj, jint pos, jint type)
1375 {
1376     jclass cls;
1377     jfieldID fid;
1378
1379     cls = env->GetObjectClass( obj );
1380     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1381     if (fid == 0)
1382     {
1383         jclass Exception = env->FindClass("java/lang/Exception");
1384         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1385         return(-1);
1386     }
1387     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1388
1389     // Validate pos
1390     // Handle conversion
1391
1392     // Read data at column
1393     void *fvp = sqlStmt->getFieldValuePtr( pos );
1394     if(type == typeByteInt)
1395         return( * ((char*)fvp) );
1396     else {
1397         char val;
1398         AllDataType::convertToByteInt(&val, fvp, (DataType)type);
1399         return val;
1400     }
1401 }
1402
1403 /*
1404  * Class:     JSqlStatement
1405  * Method:    getFloat
1406  * Signature: (I)F
1407  */
1408 JNIEXPORT jfloat JNICALL Java_csql_jdbc_JSqlStatement_getFloat
1409   (JNIEnv *env, jobject obj, jint pos, jint type)
1410 {
1411     jclass cls;
1412     jfieldID fid;
1413
1414     cls = env->GetObjectClass( obj );
1415     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1416     if (fid == 0)
1417     {
1418         jclass Exception = env->FindClass("java/lang/Exception");
1419         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1420         return(-1);
1421     }
1422     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1423
1424     // Validate pos
1425     // Handle conversion
1426
1427     // Read data at column
1428     void *fvp = sqlStmt->getFieldValuePtr( pos );
1429     if(type == typeFloat)
1430         return( * ((float*)fvp) );
1431     else {
1432         float val;
1433         AllDataType::convertToFloat(&val, fvp, (DataType)type);
1434         return val;
1435     }
1436
1437 }
1438
1439 /*
1440  * Class:     JSqlStatement
1441  * Method:    getDouble
1442  * Signature: (I)D
1443  */
1444 JNIEXPORT jdouble JNICALL Java_csql_jdbc_JSqlStatement_getDouble
1445   (JNIEnv *env, jobject obj, jint pos, jint type)
1446 {
1447     jclass cls;
1448     jfieldID fid;
1449
1450     cls = env->GetObjectClass( obj );
1451     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1452     if (fid == 0)
1453     {
1454         jclass Exception = env->FindClass("java/lang/Exception");
1455         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1456         return(-1);
1457     }
1458     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1459
1460     // Validate pos
1461     // Handle conversion
1462
1463     // Read data at column
1464     void *fvp = sqlStmt->getFieldValuePtr( pos );
1465     if(type == typeDouble)
1466         return( * ((double*)fvp) );
1467     else {
1468         double val;
1469         AllDataType::convertToDouble(&val, fvp, (DataType)type);
1470         return val;
1471     }
1472
1473 }
1474
1475 /*
1476  * Class:     JSqlStatement
1477  * Method:    getString
1478  * Signature: (I)Ljava/lang/String;
1479  */
1480 JNIEXPORT jstring JNICALL Java_csql_jdbc_JSqlStatement_getString
1481   (JNIEnv *env, jobject obj, jint pos, jint type)
1482 {
1483     jclass cls;
1484     jfieldID fid;
1485
1486     cls = env->GetObjectClass( obj );
1487     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1488     if (fid == 0)
1489     {
1490         jclass Exception = env->FindClass("java/lang/Exception");
1491         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1492         return( (jstring) 0 );
1493     }
1494     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1495
1496     // Validate pos
1497     // Handle conversion
1498
1499     // Read data at column
1500     void *fvp = sqlStmt->getFieldValuePtr( pos );
1501     if(type == typeString)
1502        return( env->NewStringUTF( (char*) fvp ) );
1503     else{
1504        char value[IDENTIFIER_LENGTH];
1505        AllDataType::convertToString(value, fvp, (DataType) type);
1506        return( env->NewStringUTF( value ));
1507     }
1508 }
1509
1510 /*
1511  * Class:     JSqlStatement
1512  * Method:    getBytes
1513  * Signature: (I)[B
1514  */
1515 JNIEXPORT jbyteArray JNICALL Java_csql_jdbc_JSqlStatement_getBytes
1516   (JNIEnv *, jobject, jint);
1517
1518 /*
1519  * Class:     JSqlStatement
1520  * Method:    getDate
1521  * Signature: (I)Ljava/sql/Date;
1522  */
1523 JNIEXPORT jobject JNICALL Java_csql_jdbc_JSqlStatement_getDate
1524   (JNIEnv *env, jobject obj, jint pos ,jint type)
1525 {
1526     jclass cls;
1527     jfieldID fid;
1528
1529     cls = env->GetObjectClass( obj );
1530     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1531     if (fid == 0)
1532     {
1533         jclass Exception = env->FindClass("java/lang/Exception");
1534         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1535         return( (jobject) 0 );
1536     }
1537     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1538
1539     // Validate pos
1540     // Handle conversion
1541
1542     // Read data at column
1543     void *fvp = sqlStmt->getFieldValuePtr( pos );
1544
1545     jclass cDate = env->FindClass("java/sql/Date");
1546     jmethodID methodID = env->GetMethodID( cDate, "<init>", "(III)V" );
1547     jobject dateObj;
1548     if(type == typeDate){
1549         Date *dt = (Date*) fvp;
1550         dateObj = env->NewObject( cDate, methodID,
1551             (jint) dt->year()-1900, (jint) dt->month() - 1,
1552             (jint) dt->dayOfMonth() );
1553         return( dateObj );
1554     } else {
1555         Date value;
1556         AllDataType::convertToDate(&value, fvp, (DataType) type);
1557         dateObj = env->NewObject( cDate, methodID,
1558             (jint) value.year()-1900, (jint) value.month() - 1,
1559             (jint) value.dayOfMonth() );
1560         return( dateObj );
1561     }
1562
1563 }
1564
1565 /*
1566  * Class:     JSqlStatement
1567  * Method:    getTime
1568  * Signature: (I)Ljava/sql/Time;
1569  */
1570 JNIEXPORT jobject JNICALL Java_csql_jdbc_JSqlStatement_getTime
1571   (JNIEnv *env, jobject obj, jint pos, jint type)
1572 {
1573     jclass cls;
1574     jfieldID fid;
1575
1576     cls = env->GetObjectClass( obj );
1577     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1578     if (fid == 0)
1579     {
1580         jclass Exception = env->FindClass("java/lang/Exception");
1581         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1582         return( (jobject) 0 );
1583     }
1584     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1585
1586     // Validate pos
1587     // Handle conversion
1588
1589     // Read data at column
1590     void *fvp = sqlStmt->getFieldValuePtr( pos );
1591
1592     // Create Java Object
1593     jclass cTime = env->FindClass("java/sql/Time");
1594     jmethodID methodID = env->GetMethodID( cTime, "<init>", "(III)V" );
1595     jobject timeObj;
1596     if(type == typeTime){
1597         Time *tm = (Time*) fvp;
1598         timeObj = env->NewObject( cTime, methodID,
1599             (jint) tm->hours(), (jint) tm->minutes(),
1600             (jint) tm->seconds() );
1601         return( timeObj );
1602     } else {
1603         Time value;
1604         AllDataType::convertToDate(&value, fvp, (DataType) type);
1605         timeObj = env->NewObject( cTime, methodID,
1606             (jint) value.hours(), (jint) value.minutes(),
1607             (jint) value.seconds() );
1608         return( timeObj );
1609     }
1610
1611 }
1612
1613 /*
1614  * Class:     JSqlStatement
1615  * Method:    getTimestamp
1616  * Signature: (I)Ljava/sql/Timestamp;
1617  */
1618 JNIEXPORT jobject JNICALL Java_csql_jdbc_JSqlStatement_getTimestamp
1619   (JNIEnv *env, jobject obj, jint pos, jint type)
1620 {
1621     jclass cls;
1622     jfieldID fid;
1623
1624     cls = env->GetObjectClass( obj );
1625     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1626     if (fid == 0)
1627     {
1628         jclass Exception = env->FindClass("java/lang/Exception");
1629         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1630         return( (jobject) 0 );
1631     }
1632     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1633
1634     // Validate pos
1635     // Handle conversion
1636
1637     // Read data at column
1638     void *fvp = sqlStmt->getFieldValuePtr( pos );
1639
1640     // Create Java Object
1641     jclass cTimestamp = env->FindClass("java/sql/Timestamp");
1642     jmethodID methodID = env->GetMethodID( cTimestamp, "<init>", "(IIIIIII)V" );
1643     jobject timeObj;
1644     if(type == typeTimeStamp){
1645         TimeStamp *ts = (TimeStamp*) fvp;
1646         timeObj = env->NewObject( cTimestamp, methodID, \
1647             (jint) ts->year()-1900, (jint) ts->month() - 1, (jint) ts->dayOfMonth(), \
1648             (jint) ts->hours(), (jint) ts->minutes(), (jint) ts->seconds(), (jint) 0 );
1649         return( timeObj );
1650     } else {
1651         TimeStamp value;
1652         AllDataType::convertToDate(&value, fvp, (DataType) type);
1653         timeObj = env->NewObject( cTimestamp, methodID, \
1654             (jint) value.year()-1900, (jint) value.month() - 1, (jint) value.dayOfMonth(), \
1655             (jint) value.hours(), (jint) value.minutes(), (jint) value.seconds(), (jint) 0 );
1656         return( timeObj );
1657     }
1658
1659 }
1660
1661 /*
1662  * Class:     JSqlStatement
1663  * Method:    getBoolean
1664  * Signature: (I)Z
1665  */
1666 JNIEXPORT jboolean JNICALL Java_csql_jdbc_JSqlStatement_getBoolean
1667   (JNIEnv *env, jobject obj, jint pos, jint type)
1668 {
1669     jclass cls;
1670     jfieldID fid;
1671
1672     cls = env->GetObjectClass( obj );
1673     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1674     if (fid == 0)
1675     {
1676         jclass Exception = env->FindClass("java/lang/Exception");
1677         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1678         return( false );
1679     }
1680     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1681     void *fvp = sqlStmt->getFieldValuePtr( pos );
1682     if(*(int*)fvp) return true;
1683     else return false;
1684 }
1685
1686 #ifdef __cplusplus
1687 }
1688 #endif