src/jdbc/JSqlStatement.cxx

   1 #include<AbsSqlStatement.h>
   2 #include<SqlNwStatement.h>
   3 #include<SqlFactory.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     return rv;
 159 }
 160
 161 /*
 162  * Class:     JSqlStatement
 163  * Method:    isSelect
 164  * Signature: ()Z
 165  */
 166 JNIEXPORT jboolean JNICALL Java_csql_jdbc_JSqlStatement_isSelect
 167   (JNIEnv *env, jobject obj)
 168 {
 169     jclass cls;
 170     jfieldID fid;
 171
 172     cls = env->GetObjectClass(obj);
 173     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 174     if (fid == 0)
 175     {
 176         jclass Exception = env->FindClass("java/lang/Exception");
 177         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 178         return(-1);
 179     }
 180     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 181     return s->isSelect();
 182 }
 183
 184 /*
 185  * Class:     JSqlStatement
 186  * Method:    execute
 187  * Signature: ()I
 188  */
 189 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_execute
 190   (JNIEnv *env, jobject obj)
 191 {
 192     jclass cls;
 193     jfieldID fid;
 194
 195     cls = env->GetObjectClass(obj);
 196     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 197     if (fid == 0)
 198     {
 199         jclass Exception = env->FindClass("java/lang/Exception");
 200         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 201         return(-1);
 202     }
 203     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 204     int rowsAffected =0;
 205     DbRetVal rv = stmt->execute(rowsAffected);
 206     if (rv != OK) return -1;
 207     return rowsAffected;
 208 }
 209
 210 /*
 211  * Class:     JSqlStatement
 212  * Method:    next
 213  * Signature: ()J
 214  */
 215 JNIEXPORT jlong JNICALL Java_csql_jdbc_JSqlStatement_next
 216   (JNIEnv *env, jobject obj)
 217 {
 218     jclass cls;
 219     jfieldID fid;
 220     cls = env->GetObjectClass(obj);
 221     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 222     if (fid == 0)
 223     {
 224         jclass Exception = env->FindClass("java/lang/Exception");
 225         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 226         return(-1);
 227     }
 228     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 229     void *tuple = stmt->next();
 230     if (NULL == tuple) return 0; else return 1;
 231 }
 232
 233 /*
 234  * Class:     JSqlStatement
 235  * Method:    close
 236  * Signature: ()J
 237  */
 238 JNIEXPORT jlong JNICALL Java_csql_jdbc_JSqlStatement_close
 239   (JNIEnv *env, jobject obj)
 240 {
 241    //TODO::stmt currently does not support close
 242     jclass cls;
 243     jfieldID fid;
 244     cls = env->GetObjectClass(obj);
 245     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 246     if (fid == 0)
 247     {
 248         jclass Exception = env->FindClass("java/lang/Exception");
 249         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 250         return(-1);
 251     }
 252     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 253     int rv =0;
 254     rv  = stmt->close();
 255     return rv;
 256 }
 257
 258 /*
 259  * Class:     JSqlStatement
 260  * Method:    setBoolean
 261  * Signature: (I)Z
 262  */
 263 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setBoolean
 264   (JNIEnv *env, jobject obj, jint position, jint value)
 265 {};
 266
 267 /*
 268  * Class:     JSqlStatement
 269  * Method:    setShort
 270  * Signature: (IS)V
 271  */
 272 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setShort
 273   (JNIEnv *env, jobject obj, jint position, jshort value)
 274 {
 275     jclass cls;
 276     jfieldID fid;
 277
 278     cls = env->GetObjectClass( obj );
 279     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 280     if (fid == 0)
 281     {
 282         jclass Exception = env->FindClass("java/lang/Exception");
 283         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 284         return;
 285     }
 286     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 287     stmt->setShortParam(position, (short) value);
 288     return;
 289 }
 290
 291 /*
 292  * Class:     JSqlStatement
 293  * Method:    setInt
 294  * Signature: (II)V
 295  */
 296 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setInt
 297   (JNIEnv *env, jobject obj, jint position, jint value)
 298 {
 299     jclass cls;
 300     jfieldID fid;
 301
 302     cls = env->GetObjectClass( obj );
 303     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 304     if (fid == 0)
 305     {
 306         jclass Exception = env->FindClass("java/lang/Exception");
 307         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 308         return;
 309     }
 310     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 311     stmt->setIntParam(position, (int) value);
 312     return;
 313 }
 314
 315 /*
 316  * Class:     JSqlStatement
 317  * Method:    setLong
 318  * Signature: (IJ)V
 319  */
 320 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setLong
 321   (JNIEnv *env, jobject obj, jint position, jlong value)
 322 {
 323     jclass cls;
 324     jfieldID fid;
 325
 326     cls = env->GetObjectClass( obj );
 327     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 328     if (fid == 0)
 329     {
 330         jclass Exception = env->FindClass("java/lang/Exception");
 331         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 332         return;
 333     }
 334     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 335     stmt->setLongLongParam(position, (long long) value);
 336     return;
 337 }
 338
 339 /*
 340  * Class:     JSqlStatement
 341  * Method:    setByte
 342  * Signature: (IB)V
 343  */
 344 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setByte
 345   (JNIEnv *env, jobject obj, jint position, jbyte value)
 346 {
 347     jclass cls;
 348     jfieldID fid;
 349
 350     cls = env->GetObjectClass( obj );
 351     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 352     if (fid == 0)
 353     {
 354         jclass Exception = env->FindClass("java/lang/Exception");
 355         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 356         return;
 357     }
 358     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 359     stmt->setByteIntParam(position, (ByteInt) value);
 360     return;
 361 }
 362 /*
 363  * Class:     JSqlStatement
 364  * Method:    setFloat
 365  * Signature: (IF)V
 366  */
 367 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setFloat
 368   (JNIEnv *env, jobject obj, jint position, jfloat value)
 369 {
 370     jclass cls;
 371     jfieldID fid;
 372
 373     cls = env->GetObjectClass( obj );
 374     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 375     if (fid == 0)
 376     {
 377         jclass Exception = env->FindClass("java/lang/Exception");
 378         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 379         return;
 380     }
 381     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 382     stmt->setFloatParam(position, (float) value);
 383     return;
 384 }
 385
 386 /*
 387  * Class:     JSqlStatement
 388  * Method:    setDouble
 389  * Signature: (ID)V
 390  */
 391 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setDouble
 392   (JNIEnv *env, jobject obj, jint position, jdouble value)
 393 {
 394     jclass cls;
 395     jfieldID fid;
 396
 397     cls = env->GetObjectClass( obj );
 398     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 399     if (fid == 0)
 400     {
 401         jclass Exception = env->FindClass("java/lang/Exception");
 402         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 403         return;
 404     }
 405     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 406     stmt->setDoubleParam(position, (double) value);
 407     return;
 408 }
 409
 410 /*
 411  * Class:     JSqlStatement
 412  * Method:    setString
 413  * Signature: (ILjava/lang/String;)V
 414  */
 415 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setString
 416   (JNIEnv *env, jobject obj, jint position, jstring value)
 417 {
 418     jclass cls;
 419     jfieldID fid;
 420
 421     cls = env->GetObjectClass( obj );
 422     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 423     if (fid == 0)
 424     {
 425         jclass Exception = env->FindClass("java/lang/Exception");
 426         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 427         return;
 428     }
 429
 430     jboolean isCopy = JNI_TRUE;
 431     char *valueStr = (char*) env->GetStringUTFChars( value, &isCopy );
 432
 433     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 434     stmt->setStringParam(position, valueStr);
 435     return;
 436 }
 437
 438 /*
 439  * Class:     JSqlStatement
 440  * Method:    setDate
 441  * Signature: (ILjava/sql/Date;)V
 442  */
 443 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setDate
 444   (JNIEnv *env, jobject obj, jint position, jobject dateObj)
 445
 446 {
 447     jclass cls, datecls;
 448     jfieldID fid;
 449     jmethodID dateMethod;
 450
 451     cls = env->GetObjectClass( obj );
 452     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 453     if (fid == 0)
 454     {
 455         jclass Exception = env->FindClass("java/lang/Exception");
 456         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 457         return;
 458     }
 459     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 460
 461     // Get date, month, year from java object
 462     int d, m, y;
 463     datecls = env->GetObjectClass( dateObj );
 464     dateMethod = env->GetMethodID( datecls, "getYear", "()I");
 465     y = env->CallIntMethod( dateObj, dateMethod);
 466     dateMethod = env->GetMethodID( datecls, "getMonth", "()I");
 467     m = env->CallIntMethod( dateObj, dateMethod);
 468     dateMethod = env->GetMethodID( datecls, "getDate", "()I");
 469     d = env->CallIntMethod( dateObj, dateMethod);
 470
 471     Date date(y + 1900, m + 1, d);
 472     stmt->setDateParam(position, date);
 473
 474     return;
 475 }
 476
 477
 478 /*
 479  * Class:     JSqlStatement
 480  * Method:    setTime
 481  * Signature: (ILjava/sql/Time;)V
 482  */
 483 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setTime
 484   (JNIEnv *env, jobject obj, jint position, jobject timeObj)
 485
 486 {
 487     jclass cls, timecls;
 488     jfieldID fid;
 489     jmethodID timeMethod;
 490
 491     cls = env->GetObjectClass( obj );
 492     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 493     if (fid == 0)
 494     {
 495         jclass Exception = env->FindClass("java/lang/Exception");
 496         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 497         return;
 498     }
 499     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 500
 501     // Get hour, minures, secs from java object
 502     int h, m, s;
 503     timecls = env->GetObjectClass( timeObj );
 504     timeMethod = env->GetMethodID( timecls, "getHours", "()I");
 505     h = env->CallIntMethod( timeObj, timeMethod);
 506     timeMethod = env->GetMethodID( timecls, "getMinutes", "()I");
 507     m = env->CallIntMethod( timeObj, timeMethod);
 508     timeMethod = env->GetMethodID( timecls, "getSeconds", "()I");
 509     s = env->CallIntMethod( timeObj, timeMethod);
 510
 511     Time time(h, m, s, 0);
 512     stmt->setTimeParam(position, time);
 513
 514     return;
 515 }
 516
 517 /*
 518  * Class:     JSqlStatement
 519  * Method:    setTimestamp
 520  * Signature: (ILjava/sql/Timestamp;)V
 521  */
 522 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setTimestamp
 523   (JNIEnv *env, jobject obj, jint position, jobject timeObj)
 524
 525 {
 526     jclass cls, timecls;
 527     jfieldID fid;
 528     jmethodID timeMethod;
 529
 530     cls = env->GetObjectClass( obj );
 531     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 532     if (fid == 0)
 533     {
 534         jclass Exception = env->FindClass("java/lang/Exception");
 535         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 536         return;
 537     }
 538     AbsSqlStatement *stmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 539
 540     // Get year, month, day, hour, minutes, secs from java object
 541     int y, mo, d, h, mn, s;
 542     timecls = env->GetObjectClass( timeObj );
 543
 544     timeMethod = env->GetMethodID( timecls, "getYear", "()I");
 545     y = env->CallIntMethod( timeObj, timeMethod );
 546     timeMethod = env->GetMethodID( timecls, "getMonth", "()I");
 547     mo = env->CallIntMethod( timeObj, timeMethod );
 548     timeMethod = env->GetMethodID( timecls, "getDate", "()I");
 549     d = env->CallIntMethod( timeObj, timeMethod );
 550     timeMethod = env->GetMethodID( timecls, "getHours", "()I");
 551     h = env->CallIntMethod( timeObj, timeMethod);
 552     timeMethod = env->GetMethodID( timecls, "getMinutes", "()I");
 553     mn = env->CallIntMethod( timeObj, timeMethod);
 554     timeMethod = env->GetMethodID( timecls, "getSeconds", "()I");
 555     s = env->CallIntMethod( timeObj, timeMethod);
 556
 557     TimeStamp timeStamp(y + 1900, mo + 1, d, h, mn, s, 0);
 558     stmt->setTimeStampParam(position, timeStamp);
 559
 560     return;
 561 }
 562
 563 /*
 564  * Class:     JSqlStatement
 565  * Method:    getShort
 566  * Signature: (I)S
 567  */
 568 JNIEXPORT jshort JNICALL Java_csql_jdbc_JSqlStatement_getShort
 569   (JNIEnv *env, jobject obj, jint pos)
 570 {
 571     jclass cls;
 572     jfieldID fid;
 573
 574     cls = env->GetObjectClass( obj );
 575     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 576     if (fid == 0)
 577     {
 578         jclass Exception = env->FindClass("java/lang/Exception");
 579         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 580         return(-1);
 581     }
 582     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 583
 584     // Validate pos
 585     // Handle conversion
 586
 587     // Read data at column
 588     void *fvp = sqlStmt->getFieldValuePtr( pos );
 589     return( * ((short*)fvp) );
 590 }
 591
 592 /*
 593  * Class:     JSqlStatement
 594  * Method:    setNull
 595  * Signature: (I)V
 596  */
 597 JNIEXPORT void JNICALL Java_csql_jdbc_JSqlStatement_setNull
 598   (JNIEnv *env, jobject obj, jint pos)
 599 {
 600     jclass cls;
 601     jfieldID fid;
 602
 603     cls = env->GetObjectClass(obj);
 604     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 605     if (fid == 0)
 606     {
 607         jclass Exception = env->FindClass("java/lang/Exception");
 608         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 609         return;
 610     }
 611     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 612     s->setNull(pos);
 613     return;
 614 }
 615
 616
 617
 618 /*
 619  * Class:     csql_jdbc_JSqlStatement
 620  * Method:    isNull
 621  * Signature: (I)Z
 622  */
 623 JNIEXPORT jboolean JNICALL Java_csql_jdbc_JSqlStatement_isNull
 624   (JNIEnv *env, jobject obj, jint pos)
 625 {
 626     jclass cls;
 627     jfieldID fid;
 628
 629     cls = env->GetObjectClass(obj);
 630     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 631     if (fid == 0)
 632     {
 633         jclass Exception = env->FindClass("java/lang/Exception");
 634         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 635         return(-1);
 636     }
 637     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 638     return s->isFldNull(pos);
 639 }
 640
 641
 642 /*
 643  * Class:     csql_jdbc_JSqlStatement
 644  * Method:    findColumn
 645  * Signature: (Ljava/lang/String;)I
 646  */
 647 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_findColumn
 648   (JNIEnv *env, jobject obj, jstring value)
 649 {
 650     jclass cls;
 651     jfieldID fid;
 652
 653     cls = env->GetObjectClass(obj);
 654     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 655     if (fid == 0)
 656     {
 657         jclass Exception = env->FindClass("java/lang/Exception");
 658         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 659         return(-1);
 660     }
 661
 662     jboolean isCopy = JNI_TRUE;
 663     char *valueStr = (char*) env->GetStringUTFChars( value, &isCopy );
 664
 665     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 666     return s->getFldPos(valueStr);
 667 }
 668
 669 /*
 670  * Class:     csql_jdbc_JSqlStatement
 671  * Method:    getParamFldName
 672  * Signature: (I)Ljava/lang/String;
 673  */
 674 JNIEXPORT jstring JNICALL Java_csql_jdbc_JSqlStatement_getParamFldName
 675   (JNIEnv *env, jobject obj, jint pos)
 676 {
 677     jclass cls;
 678     jfieldID fid;
 679
 680     cls = env->GetObjectClass(obj);
 681     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 682     if (fid == 0)
 683     {
 684         jclass Exception = env->FindClass("java/lang/Exception");
 685         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 686         return((jstring) 0);
 687     }
 688     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 689     FieldInfo *field = new FieldInfo();
 690     DbRetVal rv = s->getParamFldInfo(pos,field);
 691     if(rv!=OK)return NULL;
 692     _jstring *name = env->NewStringUTF( (char*) field->fldName );
 693     delete field;
 694     return name;
 695 }
 696
 697 /*
 698  * Class:     csql_jdbc_JSqlStatement
 699  * Method:    getTotalparam
 700  * Signature: ()I
 701  */
 702 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_getTotalparam
 703   (JNIEnv *env, jobject obj)
 704 {
 705     jclass cls;
 706     jfieldID fid;
 707
 708     cls = env->GetObjectClass(obj);
 709     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 710     if (fid == 0)
 711     {
 712         jclass Exception = env->FindClass("java/lang/Exception");
 713         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 714         return(-1);
 715     }
 716     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 717
 718     return (s->noOfParamFields());
 719 }
 720
 721 /*
 722  * Class:     csql_jdbc_JSqlStatement
 723  * Method:    getType
 724  * Signature: (I)I
 725  */
 726 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_getType
 727   (JNIEnv *env, jobject obj, jint pos)
 728 {
 729     jclass cls;
 730     jfieldID fid;
 731
 732     cls = env->GetObjectClass(obj);
 733     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 734     if (fid == 0)
 735     {
 736         jclass Exception = env->FindClass("java/lang/Exception");
 737         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 738         return(-1);
 739     }
 740     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 741
 742     FieldInfo *field = new FieldInfo();
 743     DbRetVal rv = s->getParamFldInfo(pos,field);
 744     if(rv!=OK)return 100;
 745     int type = field->type;
 746     delete field;
 747     return type;
 748 }
 749
 750 /*
 751  * Class:     csql_jdbc_JSqlStatement
 752  * Method:    isNullable
 753  * Signature: (I)Z
 754  */
 755 JNIEXPORT jboolean JNICALL Java_csql_jdbc_JSqlStatement_isNullable
 756   (JNIEnv *env, jobject obj, jint pos)
 757 {
 758     jclass cls;
 759     jfieldID fid;
 760
 761     cls = env->GetObjectClass(obj);
 762     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 763     if (fid == 0)
 764     {
 765         jclass Exception = env->FindClass("java/lang/Exception");
 766         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 767         return(-1);
 768     }
 769     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 770
 771     FieldInfo *field = new FieldInfo();
 772     DbRetVal rv = s->getParamFldInfo(pos,field);
 773     if(rv!=OK)return (-1);
 774     if(field->isNull){
 775         delete field;
 776         return true;
 777     }else{
 778         delete field;
 779         return false;
 780     }
 781 }
 782
 783
 784 /*
 785  * Class:     csql_jdbc_JSqlStatement
 786  * Method:    getTotalProjFld
 787  * Signature: ()I
 788  */
 789
 790 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_getTotalProjFld
 791   (JNIEnv *env, jobject obj)
 792 {
 793     jclass cls;
 794     jfieldID fid;
 795
 796     cls = env->GetObjectClass(obj);
 797     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 798     if (fid == 0)
 799     {
 800         jclass Exception = env->FindClass("java/lang/Exception");
 801         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 802         return(-1);
 803     }
 804     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 805
 806     return (s->noOfProjFields());
 807
 808 }
 809
 810 /*
 811  * Class:     csql_jdbc_JSqlStatement
 812  * Method:    getProjFldType
 813  * Signature: (I)I
 814  */
 815 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_getProjFldType
 816   (JNIEnv *env, jobject obj, jint pos)
 817 {
 818     jclass cls;
 819     jfieldID fid;
 820
 821     cls = env->GetObjectClass(obj);
 822     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 823     if (fid == 0)
 824     {
 825         jclass Exception = env->FindClass("java/lang/Exception");
 826         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 827         return(-1);
 828     }
 829     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 830
 831     FieldInfo *field = new FieldInfo();
 832     s->getProjFldInfo(pos,field);
 833     int type = field->type;
 834     delete field;
 835
 836     return type;
 837 }
 838
 839
 840 /*
 841  * Class:     csql_jdbc_JSqlStatement
 842  * Method:    isFldNullable
 843  * Signature: (I)Z
 844  */
 845 JNIEXPORT jboolean JNICALL Java_csql_jdbc_JSqlStatement_isFldNullable
 846   (JNIEnv *env, jobject obj, jint pos)
 847 {
 848     jclass cls;
 849     jfieldID fid;
 850
 851     cls = env->GetObjectClass(obj);
 852     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 853     if (fid == 0)
 854     {
 855         jclass Exception = env->FindClass("java/lang/Exception");
 856         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 857         return(-1);
 858     }
 859     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 860     FieldInfo *field = new FieldInfo();
 861     s->getProjFldInfo(pos,field);
 862     bool nul = field->isNull;
 863     delete field;
 864
 865     return nul;
 866 }
 867
 868
 869 /*
 870  * Class:     csql_jdbc_JSqlStatement
 871  * Method:    getProjFldName
 872  * Signature: (I)Ljava/lang/String;
 873  */
 874 JNIEXPORT jstring JNICALL Java_csql_jdbc_JSqlStatement_getProjFldName
 875   (JNIEnv *env, jobject obj, jint pos)
 876 {
 877     jclass cls;
 878     jfieldID fid;
 879
 880     cls = env->GetObjectClass(obj);
 881     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 882     if (fid == 0)
 883     {
 884         jclass Exception = env->FindClass("java/lang/Exception");
 885         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 886         return( (jstring) 0 );
 887     }
 888     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 889     FieldInfo *field = new FieldInfo();
 890     s->getProjFldInfo(pos,field);
 891     _jstring *name = env->NewStringUTF( (char*) field->fldName );
 892     delete field;
 893     return name;
 894 }
 895
 896
 897 /*
 898  * Class:     csql_jdbc_JSqlStatement
 899  * Method:    getTableName
 900  * Signature: ()Ljava/lang/String;
 901  */
 902 JNIEXPORT jstring JNICALL Java_csql_jdbc_JSqlStatement_getTableName
 903   (JNIEnv *env, jobject obj)
 904 {
 905     jclass cls;
 906     jfieldID fid;
 907
 908     cls = env->GetObjectClass(obj);
 909     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 910     if (fid == 0)
 911     {
 912         jclass Exception = env->FindClass("java/lang/Exception");
 913         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 914         return( (jstring) 0 );
 915     }
 916     AbsSqlStatement *s = (AbsSqlStatement*) env->GetLongField( obj, fid );
 917
 918
 919    return NULL;
 920 }
 921
 922
 923
 924 /*
 925  * Class:     JSqlStatement
 926  * Method:    getInt
 927  * Signature: (I)I
 928  */
 929 JNIEXPORT jint JNICALL Java_csql_jdbc_JSqlStatement_getInt
 930   (JNIEnv *env, jobject obj, jint pos)
 931 {
 932     jclass cls;
 933     jfieldID fid;
 934
 935     cls = env->GetObjectClass( obj );
 936     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 937     if (fid == 0)
 938     {
 939         jclass Exception = env->FindClass("java/lang/Exception");
 940         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 941         return(-1);
 942     }
 943     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 944
 945     // Validate pos
 946     // Handle conversion
 947
 948     // Read data at column
 949     void *fvp = sqlStmt->getFieldValuePtr( pos );
 950     return( * ((int*)fvp) );
 951 }
 952
 953 /*
 954  * Class:     JSqlStatement
 955  * Method:    getLong
 956  * Signature: (I)J
 957  */
 958 JNIEXPORT jlong JNICALL Java_csql_jdbc_JSqlStatement_getLong
 959   (JNIEnv *env, jobject obj, jint pos)
 960 {
 961     jclass cls;
 962     jfieldID fid;
 963
 964     cls = env->GetObjectClass( obj );
 965     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 966     if (fid == 0)
 967     {
 968         jclass Exception = env->FindClass("java/lang/Exception");
 969         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 970         return(-1);
 971     }
 972     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
 973
 974     // Validate pos
 975     // Handle conversion
 976
 977     // Read data at column
 978     void *fvp = sqlStmt->getFieldValuePtr( pos );
 979     return( * ((long*)fvp) );
 980 }
 981
 982 /*
 983  * Class:     JSqlStatement
 984  * Method:    getByte
 985  * Signature: (I)B
 986  */
 987 JNIEXPORT jbyte JNICALL Java_csql_jdbc_JSqlStatement_getByte
 988   (JNIEnv *env, jobject obj, jint pos)
 989 {
 990     jclass cls;
 991     jfieldID fid;
 992
 993     cls = env->GetObjectClass( obj );
 994     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
 995     if (fid == 0)
 996     {
 997         jclass Exception = env->FindClass("java/lang/Exception");
 998         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
 999         return(-1);
1000     }
1001     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1002
1003     // Validate pos
1004     // Handle conversion
1005
1006     // Read data at column
1007     void *fvp = sqlStmt->getFieldValuePtr( pos );
1008     return( * ((char*)fvp) );
1009 }
1010
1011 /*
1012  * Class:     JSqlStatement
1013  * Method:    getFloat
1014  * Signature: (I)F
1015  */
1016 JNIEXPORT jfloat JNICALL Java_csql_jdbc_JSqlStatement_getFloat
1017   (JNIEnv *env, jobject obj, jint pos)
1018 {
1019     jclass cls;
1020     jfieldID fid;
1021
1022     cls = env->GetObjectClass( obj );
1023     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1024     if (fid == 0)
1025     {
1026         jclass Exception = env->FindClass("java/lang/Exception");
1027         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1028         return(-1);
1029     }
1030     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1031
1032     // Validate pos
1033     // Handle conversion
1034
1035     // Read data at column
1036     void *fvp = sqlStmt->getFieldValuePtr( pos );
1037     return( * ((float*)fvp) );
1038 }
1039
1040 /*
1041  * Class:     JSqlStatement
1042  * Method:    getDouble
1043  * Signature: (I)D
1044  */
1045 JNIEXPORT jdouble JNICALL Java_csql_jdbc_JSqlStatement_getDouble
1046   (JNIEnv *env, jobject obj, jint pos)
1047 {
1048     jclass cls;
1049     jfieldID fid;
1050
1051     cls = env->GetObjectClass( obj );
1052     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1053     if (fid == 0)
1054     {
1055         jclass Exception = env->FindClass("java/lang/Exception");
1056         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1057         return(-1);
1058     }
1059     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1060
1061     // Validate pos
1062     // Handle conversion
1063
1064     // Read data at column
1065     void *fvp = sqlStmt->getFieldValuePtr( pos );
1066     return( * ((double*)fvp) );
1067 }
1068
1069 /*
1070  * Class:     JSqlStatement
1071  * Method:    getString
1072  * Signature: (I)Ljava/lang/String;
1073  */
1074 JNIEXPORT jstring JNICALL Java_csql_jdbc_JSqlStatement_getString
1075   (JNIEnv *env, jobject obj, jint pos)
1076 {
1077     jclass cls;
1078     jfieldID fid;
1079
1080     cls = env->GetObjectClass( obj );
1081     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1082     if (fid == 0)
1083     {
1084         jclass Exception = env->FindClass("java/lang/Exception");
1085         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1086         return( (jstring) 0 );
1087     }
1088     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1089
1090     // Validate pos
1091     // Handle conversion
1092
1093     // Read data at column
1094     void *fvp = sqlStmt->getFieldValuePtr( pos );
1095     return( env->NewStringUTF( (char*) fvp ) );
1096 }
1097
1098 /*
1099  * Class:     JSqlStatement
1100  * Method:    getBytes
1101  * Signature: (I)[B
1102  */
1103 JNIEXPORT jbyteArray JNICALL Java_csql_jdbc_JSqlStatement_getBytes
1104   (JNIEnv *, jobject, jint);
1105
1106 /*
1107  * Class:     JSqlStatement
1108  * Method:    getDate
1109  * Signature: (I)Ljava/sql/Date;
1110  */
1111 JNIEXPORT jobject JNICALL Java_csql_jdbc_JSqlStatement_getDate
1112   (JNIEnv *env, jobject obj, jint pos)
1113 {
1114     jclass cls;
1115     jfieldID fid;
1116
1117     cls = env->GetObjectClass( obj );
1118     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1119     if (fid == 0)
1120     {
1121         jclass Exception = env->FindClass("java/lang/Exception");
1122         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1123         return( (jobject) 0 );
1124     }
1125     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1126
1127     // Validate pos
1128     // Handle conversion
1129
1130     // Read data at column
1131     void *fvp = sqlStmt->getFieldValuePtr( pos );
1132
1133     // Create Java Object
1134     jclass cDate = env->FindClass("java/sql/Date");
1135     jmethodID methodID = env->GetMethodID( cDate, "<init>", "(III)V" );
1136     jobject dateObj;
1137
1138     Date *dt = (Date*) fvp;
1139     dateObj = env->NewObject( cDate, methodID,
1140         (jint) dt->year()-1900, (jint) dt->month() - 1,
1141         (jint) dt->dayOfMonth() );
1142
1143     return( dateObj );
1144 }
1145
1146 /*
1147  * Class:     JSqlStatement
1148  * Method:    getTime
1149  * Signature: (I)Ljava/sql/Time;
1150  */
1151 JNIEXPORT jobject JNICALL Java_csql_jdbc_JSqlStatement_getTime
1152   (JNIEnv *env, jobject obj, jint pos)
1153 {
1154     jclass cls;
1155     jfieldID fid;
1156
1157     cls = env->GetObjectClass( obj );
1158     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1159     if (fid == 0)
1160     {
1161         jclass Exception = env->FindClass("java/lang/Exception");
1162         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1163         return( (jobject) 0 );
1164     }
1165     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1166
1167     // Validate pos
1168     // Handle conversion
1169
1170     // Read data at column
1171     void *fvp = sqlStmt->getFieldValuePtr( pos );
1172
1173     // Create Java Object
1174     jclass cTime = env->FindClass("java/sql/Time");
1175     jmethodID methodID = env->GetMethodID( cTime, "<init>", "(III)V" );
1176     jobject timeObj;
1177
1178     Time *tm = (Time*) fvp;
1179     timeObj = env->NewObject( cTime, methodID,
1180         (jint) tm->hours(), (jint) tm->minutes(),
1181         (jint) tm->seconds() );
1182
1183     return( timeObj );
1184 }
1185
1186 /*
1187  * Class:     JSqlStatement
1188  * Method:    getTimestamp
1189  * Signature: (I)Ljava/sql/Timestamp;
1190  */
1191 JNIEXPORT jobject JNICALL Java_csql_jdbc_JSqlStatement_getTimestamp
1192   (JNIEnv *env, jobject obj, jint pos)
1193 {
1194     jclass cls;
1195     jfieldID fid;
1196
1197     cls = env->GetObjectClass( obj );
1198     fid = env->GetFieldID( cls, "sqlStmtPtr", "J");
1199     if (fid == 0)
1200     {
1201         jclass Exception = env->FindClass("java/lang/Exception");
1202         env->ThrowNew(Exception,"JNI: GetFieldID failed.\n");
1203         return( (jobject) 0 );
1204     }
1205     AbsSqlStatement *sqlStmt = (AbsSqlStatement*) env->GetLongField( obj, fid );
1206
1207     // Validate pos
1208     // Handle conversion
1209
1210     // Read data at column
1211     void *fvp = sqlStmt->getFieldValuePtr( pos );
1212
1213     // Create Java Object
1214     jclass cTimestamp = env->FindClass("java/sql/Timestamp");
1215     jmethodID methodID = env->GetMethodID( cTimestamp, "<init>", "(IIIIIII)V" );
1216     jobject timeObj;
1217
1218     TimeStamp *ts = (TimeStamp*) fvp;
1219     timeObj = env->NewObject( cTimestamp, methodID, \
1220         (jint) ts->year()-1900, (jint) ts->month() - 1, (jint) ts->dayOfMonth(), \
1221         (jint) ts->hours(), (jint) ts->minutes(), (jint) ts->seconds(), (jint) 0 );
1222
1223     return( timeObj );
1224 }
1225
1226 /*
1227  * Class:     JSqlStatement
1228  * Method:    getBoolean
1229  * Signature: (I)Z
1230  */
1231 JNIEXPORT jboolean JNICALL Java_csql_jdbc_JSqlStatement_getBoolean
1232   (JNIEnv *, jobject, jint);
1233
1234 #ifdef __cplusplus
1235 }
1236 #endif