vxodbc/statement.cc

   1 /*
   2  * Description: This module contains functions related to creating
   3  *              and manipulating a statement.
   4  */
   5
   6 #ifndef _WIN32_WINNT
   7 #define _WIN32_WINNT    0x0400
   8 #endif                          /* _WIN32_WINNT */
   9
  10 #include "statement.h"
  11
  12 #include "bind.h"
  13 #include "connection.h"
  14 #include "multibyte.h"
  15 #include "qresult.h"
  16 #include "convert.h"
  17 #include "environ.h"
  18
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <ctype.h>
  22
  23 #include "pgapifunc.h"
  24
  25
  26 #define PRN_NULLCHECK
  27
  28 /*      Map sql commands to statement types */
  29 static struct {
  30     int type;
  31     char *s;
  32 } Statement_Type[] =
  33 {
  34     {
  35     STMT_TYPE_SELECT, "SELECT"}
  36     ,
  37     {
  38     STMT_TYPE_INSERT, "INSERT"}
  39     ,
  40     {
  41     STMT_TYPE_UPDATE, "UPDATE"}
  42     ,
  43     {
  44     STMT_TYPE_DELETE, "DELETE"}
  45     ,
  46     {
  47     STMT_TYPE_PROCCALL, "{"}
  48     ,
  49     {
  50     STMT_TYPE_SET, "SET"}
  51     ,
  52     {
  53     STMT_TYPE_RESET, "RESET"}
  54     ,
  55     {
  56     STMT_TYPE_CREATE, "CREATE"}
  57     ,
  58     {
  59     STMT_TYPE_DECLARE, "DECLARE"}
  60     ,
  61     {
  62     STMT_TYPE_FETCH, "FETCH"}
  63     ,
  64     {
  65     STMT_TYPE_MOVE, "MOVE"}
  66     ,
  67     {
  68     STMT_TYPE_CLOSE, "CLOSE"}
  69     ,
  70     {
  71     STMT_TYPE_PREPARE, "PREPARE"}
  72     ,
  73     {
  74     STMT_TYPE_EXECUTE, "EXECUTE"}
  75     ,
  76     {
  77     STMT_TYPE_DEALLOCATE, "DEALLOCATE"}
  78     ,
  79     {
  80     STMT_TYPE_DROP, "DROP"}
  81     ,
  82     {
  83     STMT_TYPE_START, "BEGIN"}
  84     ,
  85     {
  86     STMT_TYPE_START, "START"}
  87     ,
  88     {
  89     STMT_TYPE_TRANSACTION, "SAVEPOINT"}
  90     ,
  91     {
  92     STMT_TYPE_TRANSACTION, "RELEASE"}
  93     ,
  94     {
  95     STMT_TYPE_TRANSACTION, "COMMIT"}
  96     ,
  97     {
  98     STMT_TYPE_TRANSACTION, "END"}
  99     ,
 100     {
 101     STMT_TYPE_TRANSACTION, "ROLLBACK"}
 102     ,
 103     {
 104     STMT_TYPE_TRANSACTION, "ABORT"}
 105     ,
 106     {
 107     STMT_TYPE_LOCK, "LOCK"}
 108     ,
 109     {
 110     STMT_TYPE_ALTER, "ALTER"}
 111     ,
 112     {
 113     STMT_TYPE_GRANT, "GRANT"}
 114     ,
 115     {
 116     STMT_TYPE_REVOKE, "REVOKE"}
 117     ,
 118     {
 119     STMT_TYPE_COPY, "COPY"}
 120     ,
 121     {
 122     STMT_TYPE_ANALYZE, "ANALYZE"}
 123     ,
 124     {
 125     STMT_TYPE_NOTIFY, "NOTIFY"}
 126     ,
 127     {
 128     STMT_TYPE_EXPLAIN, "EXPLAIN"}
 129     ,
 130     {
 131     STMT_TYPE_SPECIAL, "VACUUM"}
 132     ,
 133     {
 134     STMT_TYPE_SPECIAL, "REINDEX"}
 135     ,
 136     {
 137     STMT_TYPE_SPECIAL, "CLUSTER"}
 138     ,
 139     {
 140     STMT_TYPE_SPECIAL, "CHECKPOINT"}
 141     ,
 142     {
 143     0, NULL}
 144 };
 145
 146
 147 void SC_set_Result(StatementClass *s, QResultClass *q)
 148 {
 149     if (q != s->result)
 150     {
 151         mylog("SC_set_Result(%x, %x)\n", s, q);
 152         QR_Destructor(s->result);
 153         s->result = s->curres = q;
 154     }
 155 }
 156
 157
 158 RETCODE SQL_API PGAPI_AllocStmt(HDBC hdbc, HSTMT FAR * phstmt)
 159 {
 160     CSTR func = "PGAPI_AllocStmt";
 161     ConnectionClass *conn = (ConnectionClass *) hdbc;
 162     StatementClass *stmt;
 163     ARDFields *ardopts;
 164     BindInfoClass *bookmark;
 165
 166     mylog("%s: entering...\n", func);
 167
 168     if (!conn)
 169     {
 170         CC_log_error(func, "", NULL);
 171         return SQL_INVALID_HANDLE;
 172     }
 173
 174     stmt = SC_Constructor(conn);
 175
 176     mylog("**** PGAPI_AllocStmt: hdbc = %p, stmt = %p\n", hdbc, stmt);
 177
 178     if (!stmt)
 179     {
 180         CC_set_error(conn, CONN_STMT_ALLOC_ERROR,
 181                      "No more memory to allocate a further SQL-statement",
 182                      func);
 183         *phstmt = SQL_NULL_HSTMT;
 184         return SQL_ERROR;
 185     }
 186
 187     if (!CC_add_statement(conn, stmt))
 188     {
 189         CC_set_error(conn, CONN_STMT_ALLOC_ERROR,
 190                      "Maximum number of statements exceeded.", func);
 191         SC_Destructor(stmt);
 192         *phstmt = SQL_NULL_HSTMT;
 193         return SQL_ERROR;
 194     }
 195
 196     *phstmt = (HSTMT) stmt;
 197
 198     /* Copy default statement options based from Connection options */
 199     stmt->options = stmt->options_orig = conn->stmtOptions;
 200     stmt->ardi.ardopts = conn->ardOptions;
 201     ardopts = SC_get_ARDF(stmt);
 202     bookmark = ARD_AllocBookmark(ardopts);
 203
 204     stmt->stmt_size_limit = CC_get_max_query_len(conn);
 205     /* Save the handle for later */
 206     stmt->phstmt = phstmt;
 207
 208     return SQL_SUCCESS;
 209 }
 210
 211
 212 RETCODE SQL_API PGAPI_FreeStmt(HSTMT hstmt, SQLUSMALLINT fOption)
 213 {
 214     CSTR func = "PGAPI_FreeStmt";
 215     StatementClass *stmt = (StatementClass *) hstmt;
 216
 217     mylog("hstmt=%p, fOption=%hi\n", hstmt, fOption);
 218
 219     if (!stmt)
 220     {
 221         SC_log_error(func, "", NULL);
 222         return SQL_INVALID_HANDLE;
 223     }
 224     SC_clear_error(stmt);
 225
 226     if (fOption == SQL_DROP)
 227     {
 228         ConnectionClass *conn = stmt->hdbc;
 229
 230         /* Remove the statement from the connection's statement list */
 231         if (conn)
 232         {
 233             QResultClass *res;
 234
 235             if (!CC_remove_statement(conn, stmt))
 236             {
 237                 SC_set_error(stmt, STMT_SEQUENCE_ERROR,
 238                              "Statement is currently executing a transaction.",
 239                              func);
 240                 return SQL_ERROR;       /* stmt may be executing a
 241                                          * transaction */
 242             }
 243
 244             /* Free any cursors and discard any result info */
 245             res = SC_get_Result(stmt);
 246             QR_Destructor(res);
 247             SC_init_Result(stmt);
 248         }
 249
 250         if (stmt->execute_delegate)
 251         {
 252             PGAPI_FreeStmt(stmt->execute_delegate, SQL_DROP);
 253             stmt->execute_delegate = NULL;
 254         }
 255         if (stmt->execute_parent)
 256             stmt->execute_parent->execute_delegate = NULL;
 257         /* Destroy the statement and free any results, cursors, etc. */
 258         SC_Destructor(stmt);
 259     } else if (fOption == SQL_UNBIND)
 260         SC_unbind_cols(stmt);
 261     else if (fOption == SQL_CLOSE)
 262     {
 263         /*
 264          * this should discard all the results, but leave the statement
 265          * itself in place (it can be executed again)
 266          */
 267         stmt->transition_status = 0;
 268         if (stmt->execute_delegate)
 269         {
 270             PGAPI_FreeStmt(stmt->execute_delegate, SQL_DROP);
 271             stmt->execute_delegate = NULL;
 272         }
 273         if (!SC_recycle_statement(stmt))
 274         {
 275             return SQL_ERROR;
 276         }
 277     }
 278     else
 279     {
 280         SC_set_error(stmt, STMT_OPTION_OUT_OF_RANGE_ERROR,
 281                      "Invalid option passed to PGAPI_FreeStmt.", func);
 282         return SQL_ERROR;
 283     }
 284
 285     return SQL_SUCCESS;
 286 }
 287
 288
 289 /*
 290  * StatementClass implementation
 291  */
 292 void InitializeStatementOptions(StatementOptions * opt)
 293 {
 294     memset(opt, 0, sizeof(StatementOptions));
 295     opt->maxRows = 0;           /* driver returns all rows */
 296     opt->maxLength = 0;         /* driver returns all data for char/binary */
 297     opt->keyset_size = 0;       /* fully keyset driven is the default */
 298     opt->scroll_concurrency = SQL_CONCUR_READ_ONLY;
 299     opt->cursor_type = SQL_CURSOR_FORWARD_ONLY;
 300     opt->retrieve_data = SQL_RD_ON;
 301     opt->use_bookmarks = SQL_UB_OFF;
 302     opt->metadata_id = SQL_FALSE;
 303 }
 304
 305 static void SC_clear_parse_status(StatementClass * self,
 306                                   ConnectionClass * conn)
 307 {
 308     self->parse_status = STMT_PARSE_NONE;
 309     if (PG_VERSION_LT(conn, 7.2))
 310     {
 311         SC_set_checked_hasoids(self, TRUE);
 312         self->num_key_fields = PG_NUM_NORMAL_KEYS;
 313     }
 314 }
 315
 316 static void SC_init_discard_output_params(StatementClass * self)
 317 {
 318     ConnectionClass *conn = SC_get_conn(self);
 319
 320     if (!conn)
 321         return;
 322     self->discard_output_params = 0;
 323     if (!conn->connInfo.use_server_side_prepare)
 324         self->discard_output_params = 1;
 325 }
 326
 327 static void SC_init_parse_method(StatementClass * self)
 328 {
 329     ConnectionClass *conn = SC_get_conn(self);
 330
 331     self->parse_method = 0;
 332     if (!conn)
 333         return;
 334     if (self->catalog_result)
 335         return;
 336     if (self->multi_statement <= 0 && conn->connInfo.disallow_premature)
 337         SC_set_parse_tricky(self);
 338 }
 339
 340 StatementClass *SC_Constructor(ConnectionClass * conn)
 341 {
 342     StatementClass *rv;
 343
 344     rv = (StatementClass *) malloc(sizeof(StatementClass));
 345     if (rv)
 346     {
 347         rv->hdbc = conn;
 348         rv->phstmt = NULL;
 349         rv->result = NULL;
 350         rv->curres = NULL;
 351         rv->catalog_result = FALSE;
 352         rv->prepare = NON_PREPARE_STATEMENT;
 353         rv->prepared = NOT_YET_PREPARED;
 354         rv->status = STMT_ALLOCATED;
 355         rv->internal = FALSE;
 356         rv->plan_name = NULL;
 357         rv->transition_status = 0;
 358         rv->multi_statement = -1;       /* unknown */
 359         rv->num_params = -1;    /* unknown */
 360
 361         rv->__error_message = NULL;
 362         rv->__error_number = 0;
 363         rv->pgerror = NULL;
 364
 365         rv->statement = NULL;
 366         rv->stmt_with_params = NULL;
 367         rv->load_statement = NULL;
 368         rv->execute_statement = NULL;
 369         rv->stmt_size_limit = -1;
 370         rv->statement_type = STMT_TYPE_UNKNOWN;
 371
 372         rv->currTuple = -1;
 373         SC_set_rowset_start(rv, -1, FALSE);
 374         rv->current_col = -1;
 375         rv->bind_row = 0;
 376         rv->last_fetch_count = rv->last_fetch_count_include_ommitted =
 377             0;
 378         rv->save_rowset_size = -1;
 379
 380         rv->data_at_exec = -1;
 381         rv->current_exec_param = -1;
 382         rv->exec_start_row = -1;
 383         rv->exec_end_row = -1;
 384         rv->exec_current_row = -1;
 385         rv->put_data = FALSE;
 386         rv->ref_CC_error = FALSE;
 387         rv->lock_CC_for_rb = 0;
 388         rv->join_info = 0;
 389         SC_init_parse_method(rv);
 390
 391         INIT_NAME(rv->cursor_name);
 392
 393         /* Parse Stuff */
 394         rv->ti = NULL;
 395         rv->ntab = 0;
 396         rv->num_key_fields = -1;        /* unknown */
 397         SC_clear_parse_status(rv, conn);
 398         rv->proc_return = -1;
 399         SC_init_discard_output_params(rv);
 400         rv->cancel_info = 0;
 401
 402         /* Clear Statement Options -- defaults will be set in AllocStmt */
 403         memset(&rv->options, 0, sizeof(StatementOptions));
 404         InitializeEmbeddedDescriptor((DescriptorClass *) & (rv->ardi),
 405                                      rv, SQL_ATTR_APP_ROW_DESC);
 406         InitializeEmbeddedDescriptor((DescriptorClass *) & (rv->apdi),
 407                                      rv, SQL_ATTR_APP_PARAM_DESC);
 408         InitializeEmbeddedDescriptor((DescriptorClass *) & (rv->irdi),
 409                                      rv, SQL_ATTR_IMP_ROW_DESC);
 410         InitializeEmbeddedDescriptor((DescriptorClass *) & (rv->ipdi),
 411                                      rv, SQL_ATTR_IMP_PARAM_DESC);
 412
 413         rv->pre_executing = FALSE;
 414         rv->inaccurate_result = FALSE;
 415         rv->miscinfo = 0;
 416         rv->updatable = FALSE;
 417         rv->diag_row_count = 0;
 418         rv->stmt_time = 0;
 419         rv->execute_delegate = NULL;
 420         rv->execute_parent = NULL;
 421         rv->allocated_callbacks = 0;
 422         rv->num_callbacks = 0;
 423         rv->callbacks = NULL;
 424         GetDataInfoInitialize(SC_get_GDTI(rv));
 425         INIT_STMT_CS(rv);
 426     }
 427     return rv;
 428 }
 429
 430 char SC_Destructor(StatementClass * self)
 431 {
 432     CSTR func = "SC_Destrcutor";
 433     QResultClass *res = SC_get_Result(self);
 434
 435     if (!self)
 436         return FALSE;
 437     mylog("self=%p, self->result=%p, self->hdbc=%p\n",
 438           self, res, self->hdbc);
 439     SC_clear_error(self);
 440     if (STMT_EXECUTING == self->status)
 441     {
 442         SC_set_error(self, STMT_SEQUENCE_ERROR,
 443                      "Statement is currently executing a transaction.",
 444                      func);
 445         return FALSE;
 446     }
 447
 448     if (res)
 449     {
 450         if (!self->hdbc)
 451             res->conn = NULL;   /* prevent any dbase activity */
 452
 453         QR_Destructor(res);
 454     }
 455
 456     SC_initialize_stmts(self, TRUE);
 457
 458     /* Free the parsed table information */
 459     SC_initialize_cols_info(self, FALSE, TRUE);
 460
 461     NULL_THE_NAME(self->cursor_name);
 462     /* Free the parsed field information */
 463     DC_Destructor((DescriptorClass *) SC_get_ARDi(self));
 464     DC_Destructor((DescriptorClass *) SC_get_APDi(self));
 465     DC_Destructor((DescriptorClass *) SC_get_IRDi(self));
 466     DC_Destructor((DescriptorClass *) SC_get_IPDi(self));
 467     GDATA_unbind_cols(SC_get_GDTI(self), TRUE);
 468
 469     if (self->__error_message)
 470         free(self->__error_message);
 471     if (self->pgerror)
 472         ER_Destructor(self->pgerror);
 473     cancelNeedDataState(self);
 474     if (self->callbacks)
 475         free(self->callbacks);
 476
 477     DELETE_STMT_CS(self);
 478     free(self);
 479
 480     mylog("done\n");
 481     return TRUE;
 482 }
 483
 484
 485 int statement_type(const char *statement)
 486 {
 487     int i;
 488
 489     /* ignore leading whitespace in query string */
 490     while (*statement
 491            && (isspace((UCHAR) * statement) || *statement == '('))
 492         statement++;
 493
 494     for (i = 0; Statement_Type[i].s; i++)
 495         if (!strnicmp
 496             (statement, Statement_Type[i].s,
 497              strlen(Statement_Type[i].s)))
 498             return Statement_Type[i].type;
 499
 500     return STMT_TYPE_OTHER;
 501 }
 502
 503 void SC_set_planname(StatementClass * stmt, const char *plan_name)
 504 {
 505     if (stmt->plan_name)
 506         free(stmt->plan_name);
 507     if (plan_name && plan_name[0])
 508         stmt->plan_name = strdup(plan_name);
 509     else
 510         stmt->plan_name = NULL;
 511 }
 512
 513 void
 514 SC_set_rowset_start(StatementClass * stmt, SQLLEN start,
 515                     BOOL valid_base)
 516 {
 517     QResultClass *res = SC_get_Curres(stmt);
 518     SQLLEN incr = start - stmt->rowset_start;
 519
 520     inolog("%p->SC_set_rowstart " FORMAT_LEN "->" FORMAT_LEN "(%s) ",
 521            stmt, stmt->rowset_start, start,
 522            valid_base ? "valid" : "unknown");
 523     if (res != NULL)
 524     {
 525         BOOL valid = QR_has_valid_base(res);
 526         inolog(":QR is %s",
 527                QR_has_valid_base(res) ? "valid" : "unknown");
 528
 529         if (valid)
 530         {
 531             if (valid_base)
 532                 QR_inc_rowstart_in_cache(res, incr);
 533             else
 534                 QR_set_no_valid_base(res);
 535         } else if (valid_base)
 536         {
 537             QR_set_has_valid_base(res);
 538             if (start < 0)
 539                 QR_set_rowstart_in_cache(res, -1);
 540             else
 541                 QR_set_rowstart_in_cache(res, 0);
 542         }
 543         if (!QR_get_cursor(res))
 544             res->key_base = start;
 545         inolog(":QR result=" FORMAT_LEN "(%s)",
 546                QR_get_rowstart_in_cache(res),
 547                QR_has_valid_base(res) ? "valid" : "unknown");
 548     }
 549     stmt->rowset_start = start;
 550     inolog(":stmt result=" FORMAT_LEN "\n", stmt->rowset_start);
 551 }
 552
 553 void SC_inc_rowset_start(StatementClass * stmt, SQLLEN inc)
 554 {
 555     SQLLEN start = stmt->rowset_start + inc;
 556
 557     SC_set_rowset_start(stmt, start, TRUE);
 558 }
 559 int SC_set_current_col(StatementClass * stmt, int col)
 560 {
 561     if (col == stmt->current_col)
 562         return col;
 563     if (col >= 0)
 564         reset_a_getdata_info(SC_get_GDTI(stmt), col + 1);
 565     stmt->current_col = col;
 566
 567     return stmt->current_col;
 568 }
 569
 570 // VX_CLEANUP: We don't support much in the way of prepared statements, this
 571 // may be unused.  It sure is useless.
 572 void SC_set_prepared(StatementClass * stmt, BOOL prepared)
 573 {
 574     if (NOT_YET_PREPARED == prepared)
 575         SC_set_planname(stmt, NULL);
 576     stmt->prepared = prepared;
 577 }
 578
 579 /*
 580  *      Initialize stmt_with_params, load_statement and execute_statement
 581  *              member pointer deallocating corresponding prepared plan.
 582  *      Also initialize statement member pointer if specified.
 583  */
 584 RETCODE
 585 SC_initialize_stmts(StatementClass * self, BOOL initializeOriginal)
 586 {
 587     ConnectionClass *conn = SC_get_conn(self);
 588
 589     if (self->lock_CC_for_rb > 0)
 590     {
 591         while (self->lock_CC_for_rb > 0)
 592         {
 593             LEAVE_CONN_CS(conn);
 594             self->lock_CC_for_rb--;
 595         }
 596     }
 597     if (initializeOriginal)
 598     {
 599         if (self->statement)
 600         {
 601             free(self->statement);
 602             self->statement = NULL;
 603         }
 604         if (self->execute_statement)
 605         {
 606             free(self->execute_statement);
 607             self->execute_statement = NULL;
 608         }
 609         self->prepare = NON_PREPARE_STATEMENT;
 610         SC_set_prepared(self, NOT_YET_PREPARED);
 611         self->statement_type = STMT_TYPE_UNKNOWN;       /* unknown */
 612         self->multi_statement = -1;     /* unknown */
 613         self->num_params = -1;  /* unknown */
 614         self->proc_return = -1; /* unknown */
 615         self->join_info = 0;
 616         SC_init_parse_method(self);
 617         SC_init_discard_output_params(self);
 618     }
 619     if (self->stmt_with_params)
 620     {
 621         free(self->stmt_with_params);
 622         self->stmt_with_params = NULL;
 623     }
 624     if (self->load_statement)
 625     {
 626         free(self->load_statement);
 627         self->load_statement = NULL;
 628     }
 629
 630     return 0;
 631 }
 632
 633 BOOL SC_opencheck(StatementClass * self, const char *func)
 634 {
 635     QResultClass *res;
 636
 637     if (!self)
 638         return FALSE;
 639     if (self->status == STMT_EXECUTING)
 640     {
 641         SC_set_error(self, STMT_SEQUENCE_ERROR,
 642                      "Statement is currently executing a transaction.",
 643                      func);
 644         return TRUE;
 645     }
 646     /*
 647      * We can dispose the result of PREMATURE execution any time.
 648      */
 649     if (self->prepare && self->status == STMT_PREMATURE)
 650     {
 651         mylog
 652             ("SC_opencheck: self->prepare && self->status == STMT_PREMATURE\n");
 653         return FALSE;
 654     }
 655     if (res = SC_get_Curres(self), NULL != res)
 656     {
 657         if (QR_command_maybe_successful(res) && res->backend_tuples)
 658         {
 659             SC_set_error(self, STMT_SEQUENCE_ERROR,
 660                          "The cursor is open.", func);
 661             return TRUE;
 662         }
 663     }
 664
 665     return FALSE;
 666 }
 667
 668 RETCODE SC_initialize_and_recycle(StatementClass * self)
 669 {
 670     SC_initialize_stmts(self, TRUE);
 671     if (!SC_recycle_statement(self))
 672         return SQL_ERROR;
 673
 674     return SQL_SUCCESS;
 675 }
 676
 677 /*
 678  *      Called from SQLPrepare if STMT_PREMATURE, or
 679  *      from SQLExecute if STMT_FINISHED, or
 680  *      from SQLFreeStmt(SQL_CLOSE)
 681  */
 682 char SC_recycle_statement(StatementClass * self)
 683 {
 684     CSTR func = "SC_recycle_statement";
 685     ConnectionClass *conn;
 686     QResultClass *res;
 687
 688     mylog("%s: self= %p\n", func, self);
 689
 690     SC_clear_error(self);
 691     /* This would not happen */
 692     if (self->status == STMT_EXECUTING)
 693     {
 694         SC_set_error(self, STMT_SEQUENCE_ERROR,
 695                      "Statement is currently executing a transaction.",
 696                      func);
 697         return FALSE;
 698     }
 699
 700     conn = SC_get_conn(self);
 701     switch (self->status)
 702     {
 703     case STMT_ALLOCATED:
 704         /* this statement does not need to be recycled */
 705         return TRUE;
 706
 707     case STMT_READY:
 708         break;
 709
 710     case STMT_PREMATURE:
 711
 712         /*
 713          * Premature execution of the statement might have caused the
 714          * start of a transaction. If so, we have to rollback that
 715          * transaction.
 716          */
 717         // VX_CLEANUP: This was cleaned up.
 718         break;
 719
 720     case STMT_FINISHED:
 721         break;
 722
 723     default:
 724         SC_set_error(self, STMT_INTERNAL_ERROR,
 725                      "An internal error occured while recycling statements",
 726                      func);
 727         return FALSE;
 728     }
 729
 730     switch (self->prepared)
 731     {
 732     case NOT_YET_PREPARED:
 733     case ONCE_DESCRIBED:
 734         /* Free the parsed table/field information */
 735         SC_initialize_cols_info(self, TRUE, TRUE);
 736
 737         inolog("SC_clear_parse_status\n");
 738         SC_clear_parse_status(self, conn);
 739         break;
 740     }
 741
 742     /* Free any cursors */
 743     if (res = SC_get_Result(self), res)
 744     {
 745         if (PREPARED_PERMANENTLY == self->prepared)
 746             QR_close_result(res, FALSE);
 747         else
 748         {
 749             QR_Destructor(res);
 750             SC_init_Result(self);
 751         }
 752     }
 753     self->inaccurate_result = FALSE;
 754     self->miscinfo = 0;
 755
 756     /*
 757      * Reset only parameters that have anything to do with results
 758      */
 759     self->status = STMT_READY;
 760     self->catalog_result = FALSE;       /* not very important */
 761
 762     self->currTuple = -1;
 763     SC_set_rowset_start(self, -1, FALSE);
 764     SC_set_current_col(self, -1);
 765     self->bind_row = 0;
 766     inolog("%s statement=%p ommitted=0\n", func, self);
 767     self->last_fetch_count = self->last_fetch_count_include_ommitted =
 768         0;
 769
 770     self->__error_message = NULL;
 771     self->__error_number = 0;
 772
 773     SC_initialize_stmts(self, FALSE);
 774     cancelNeedDataState(self);
 775     self->cancel_info = 0;
 776     /*
 777      *      reset the current attr setting to the original one.
 778      */
 779     self->options.scroll_concurrency =
 780         self->options_orig.scroll_concurrency;
 781     self->options.cursor_type = self->options_orig.cursor_type;
 782     self->options.keyset_size = self->options_orig.keyset_size;
 783     self->options.maxLength = self->options_orig.maxLength;
 784     self->options.maxRows = self->options_orig.maxRows;
 785
 786     return TRUE;
 787 }
 788
 789
 790 /*
 791  * Pre-execute a statement (for SQLPrepare/SQLDescribeCol)
 792  */
 793 Int4                            /* returns # of fields if successful */
 794 SC_pre_execute(StatementClass * self)
 795 {
 796     Int4 num_fields = -1;
 797     QResultClass *res;
 798     mylog("SC_pre_execute: status = %d\n", self->status);
 799
 800     res = SC_get_Curres(self);
 801     if (res && (num_fields = QR_NumResultCols(res)) > 0)
 802         return num_fields;
 803
 804     mylog("SC_pre_execute: Unknown result/number of columns\n");
 805     return -1;
 806 }
 807
 808
 809 /* This is only called from SQLFreeStmt(SQL_UNBIND) */
 810 char SC_unbind_cols(StatementClass * self)
 811 {
 812     ARDFields *opts = SC_get_ARDF(self);
 813     GetDataInfo *gdata = SC_get_GDTI(self);
 814     BindInfoClass *bookmark;
 815
 816     ARD_unbind_cols(opts, FALSE);
 817     GDATA_unbind_cols(gdata, FALSE);
 818     if (bookmark = opts->bookmark, bookmark != NULL)
 819     {
 820         bookmark->buffer = NULL;
 821         bookmark->used = NULL;
 822     }
 823
 824     return 1;
 825 }
 826
 827
 828 void SC_clear_error(StatementClass * self)
 829 {
 830     QResultClass *res;
 831
 832     self->__error_number = 0;
 833     if (self->__error_message)
 834     {
 835         free(self->__error_message);
 836         self->__error_message = NULL;
 837     }
 838     if (self->pgerror)
 839     {
 840         ER_Destructor(self->pgerror);
 841         self->pgerror = NULL;
 842     }
 843     self->diag_row_count = 0;
 844     if (res = SC_get_Curres(self), res)
 845     {
 846         QR_set_message(res, NULL);
 847         QR_set_notice(res, NULL);
 848         res->sqlstate[0] = '\0';
 849     }
 850     self->stmt_time = 0;
 851     SC_unref_CC_error(self);
 852 }
 853
 854
 855 /*
 856  *      This function creates an error info which is the concatenation
 857  *      of the result, statement, connection, and socket messages.
 858  */
 859
 860 /*      Map sql commands to statement types */
 861 static struct {
 862     int number;
 863     const char *ver3str;
 864     const char *ver2str;
 865 } Statement_sqlstate[] =
 866 {
 867     {
 868     STMT_ERROR_IN_ROW, "01S01", "01S01"},
 869     {
 870     STMT_OPTION_VALUE_CHANGED, "01S02", "01S02"},
 871     {
 872     STMT_ROW_VERSION_CHANGED, "01001", "01001"},        /* data changed */
 873     {
 874     STMT_POS_BEFORE_RECORDSET, "01S06", "01S06"},
 875     {
 876     STMT_TRUNCATED, "01004", "01004"},  /* data truncated */
 877     {
 878     STMT_INFO_ONLY, "00000", "00000"},  /* just an information that is returned, no error */
 879     {
 880     STMT_OK, "00000", "00000"}, /* OK */
 881     {
 882     STMT_EXEC_ERROR, "HY000", "S1000"}, /* also a general error */
 883     {
 884     STMT_STATUS_ERROR, "HY010", "S1010"},
 885     {
 886     STMT_SEQUENCE_ERROR, "HY010", "S1010"},     /* Function sequence error */
 887     {
 888     STMT_NO_MEMORY_ERROR, "HY001", "S1001"},    /* memory allocation failure */
 889     {
 890     STMT_COLNUM_ERROR, "07009", "S1002"},       /* invalid column number */
 891     {
 892     STMT_NO_STMTSTRING, "HY001", "S1001"},      /* having no stmtstring is also a malloc problem */
 893     {
 894     STMT_ERROR_TAKEN_FROM_BACKEND, "HY000", "S1000"},   /* general error */
 895     {
 896     STMT_INTERNAL_ERROR, "HY000", "S1000"},     /* general error */
 897     {
 898     STMT_STILL_EXECUTING, "HY010", "S1010"},
 899     {
 900     STMT_NOT_IMPLEMENTED_ERROR, "HYC00", "S1C00"},      /* == 'driver not
 901                                                          * capable' */
 902     {
 903     STMT_BAD_PARAMETER_NUMBER_ERROR, "07009", "S1093"},
 904     {
 905     STMT_OPTION_OUT_OF_RANGE_ERROR, "HY092", "S1092"},
 906     {
 907     STMT_INVALID_COLUMN_NUMBER_ERROR, "07009", "S1002"},
 908     {
 909     STMT_RESTRICTED_DATA_TYPE_ERROR, "07006", "07006"},
 910     {
 911     STMT_INVALID_CURSOR_STATE_ERROR, "07005", "24000"},
 912     {
 913     STMT_CREATE_TABLE_ERROR, "42S01", "S0001"}, /* table already exists */
 914     {
 915     STMT_NO_CURSOR_NAME, "S1015", "S1015"},
 916     {
 917     STMT_INVALID_CURSOR_NAME, "34000", "34000"},
 918     {
 919     STMT_INVALID_ARGUMENT_NO, "HY024", "S1009"},        /* invalid argument value */
 920     {
 921     STMT_ROW_OUT_OF_RANGE, "HY107", "S1107"},
 922     {
 923     STMT_OPERATION_CANCELLED, "HY008", "S1008"},
 924     {
 925     STMT_INVALID_CURSOR_POSITION, "HY109", "S1109"},
 926     {
 927     STMT_VALUE_OUT_OF_RANGE, "HY019", "22003"},
 928     {
 929     STMT_OPERATION_INVALID, "HY011", "S1011"},
 930     {
 931     STMT_PROGRAM_TYPE_OUT_OF_RANGE, "?????", "?????"},
 932     {
 933     STMT_BAD_ERROR, "08S01", "08S01"},  /* communication link failure */
 934     {
 935     STMT_INVALID_OPTION_IDENTIFIER, "HY092", "HY092"},
 936     {
 937     STMT_RETURN_NULL_WITHOUT_INDICATOR, "22002", "22002"},
 938     {
 939     STMT_INVALID_DESCRIPTOR_IDENTIFIER, "HY091", "HY091"},
 940     {
 941     STMT_OPTION_NOT_FOR_THE_DRIVER, "HYC00", "HYC00"},
 942     {
 943     STMT_FETCH_OUT_OF_RANGE, "HY106", "S1106"},
 944     {
 945     STMT_COUNT_FIELD_INCORRECT, "07002", "07002"},
 946     {
 947     STMT_INVALID_NULL_ARG, "HY009", "S1009"}
 948 };
 949
 950 static PG_ErrorInfo *SC_create_errorinfo(const StatementClass * self)
 951 {
 952     QResultClass *res = SC_get_Curres(self);
 953     ConnectionClass *conn = SC_get_conn(self);
 954     Int4 errornum;
 955     size_t pos;
 956     BOOL resmsg = FALSE, detailmsg = FALSE, msgend = FALSE;
 957     char msg[4096], *wmsg;
 958     char *ermsg = NULL, *sqlstate = NULL;
 959     PG_ErrorInfo *pgerror;
 960
 961     if (self->pgerror)
 962         return self->pgerror;
 963     errornum = self->__error_number;
 964     if (errornum == 0)
 965         return NULL;
 966
 967     msg[0] = '\0';
 968     if (res)
 969     {
 970         if (res->sqlstate[0])
 971             sqlstate = res->sqlstate;
 972         if (res->message)
 973         {
 974             strncpy(msg, res->message, sizeof(msg));
 975             detailmsg = resmsg = TRUE;
 976         }
 977         if (msg[0])
 978             ermsg = msg;
 979         else if (QR_get_notice(res))
 980         {
 981             char *notice = QR_get_notice(res);
 982             size_t len = strlen(notice);
 983             if (len < sizeof(msg))
 984             {
 985                 memcpy(msg, notice, len);
 986                 msg[len] = '\0';
 987                 ermsg = msg;
 988             } else
 989             {
 990                 ermsg = notice;
 991                 msgend = TRUE;
 992             }
 993         }
 994     }
 995     if (!msgend && (wmsg = SC_get_errormsg(self)) && wmsg[0])
 996     {
 997         pos = strlen(msg);
 998
 999         if (detailmsg)
1000         {
1001             msg[pos++] = ';';
1002             msg[pos++] = '\n';
1003         }
1004         strncpy(msg + pos, wmsg, sizeof(msg) - pos);
1005         ermsg = msg;
1006         detailmsg = TRUE;
1007     }
1008     if (!self->ref_CC_error)
1009         msgend = TRUE;
1010
1011     if (conn && !msgend)
1012     {
1013         // VX_CLEANUP: This is suspiciously similar to CC_create_errormsg, and
1014         // just as useless now that there's no socket error message.
1015         if (!resmsg && (wmsg = CC_get_errormsg(conn))
1016             && wmsg[0] != '\0')
1017         {
1018             pos = strlen(msg);
1019             snprintf(&msg[pos], sizeof(msg) - pos, ";\n%s",
1020                      CC_get_errormsg(conn));
1021         }
1022
1023         ermsg = msg;
1024     }
1025     pgerror = ER_Constructor(self->__error_number, ermsg);
1026     if (sqlstate)
1027         strcpy(pgerror->sqlstate, sqlstate);
1028     else if (conn)
1029     {
1030         if (!msgend && conn->sqlstate[0])
1031             strcpy(pgerror->sqlstate, conn->sqlstate);
1032         else
1033         {
1034             EnvironmentClass *env = (EnvironmentClass *) conn->henv;
1035
1036             errornum -= LOWEST_STMT_ERROR;
1037             if (errornum < 0 ||
1038                 errornum >=
1039                 sizeof(Statement_sqlstate) /
1040                 sizeof(Statement_sqlstate[0]))
1041                 errornum = 1 - LOWEST_STMT_ERROR;
1042             strcpy(pgerror->sqlstate, EN_is_odbc3(env) ?
1043                    Statement_sqlstate[errornum].ver3str :
1044                    Statement_sqlstate[errornum].ver2str);
1045         }
1046     }
1047
1048     return pgerror;
1049 }
1050
1051
1052 StatementClass *SC_get_ancestor(StatementClass * stmt)
1053 {
1054     StatementClass *child = stmt, *parent;
1055
1056     inolog("SC_get_ancestor in stmt=%p\n", stmt);
1057     for (child = stmt, parent = child->execute_parent; parent;
1058          child = parent, parent = child->execute_parent)
1059     {
1060         inolog("parent=%p\n", parent);
1061     }
1062     return child;
1063 }
1064
1065 void SC_reset_delegate(RETCODE retcode, StatementClass * stmt)
1066 {
1067     StatementClass *delegate = stmt->execute_delegate;
1068
1069     if (!delegate)
1070         return;
1071     PGAPI_FreeStmt(delegate, SQL_DROP);
1072 }
1073
1074 void
1075 SC_set_error(StatementClass * self, int number, const char *message,
1076              const char *func)
1077 {
1078     if (self->__error_message)
1079         free(self->__error_message);
1080     self->__error_number = number;
1081     self->__error_message = message ? strdup(message) : NULL;
1082     if (func && number != STMT_OK && number != STMT_INFO_ONLY)
1083         SC_log_error(func, "", self);
1084 }
1085
1086
1087 void SC_set_errormsg(StatementClass * self, const char *message)
1088 {
1089     if (self->__error_message)
1090         free(self->__error_message);
1091     self->__error_message = message ? strdup(message) : NULL;
1092 }
1093
1094
1095 void
1096 SC_replace_error_with_res(StatementClass * self, int number,
1097                           const char *message,
1098                           const QResultClass * from_res, BOOL check)
1099 {
1100     QResultClass *self_res;
1101     BOOL repstate;
1102
1103     inolog("SC_set_error_from_res %p->%p check=%i\n", from_res, self,
1104            check);
1105     if (check)
1106     {
1107         if (0 == number)
1108             return;
1109         if (0 > number &&       /* SQL_SUCCESS_WITH_INFO */
1110             0 < self->__error_number)
1111             return;
1112     }
1113     self->__error_number = number;
1114     if (!check || message)
1115     {
1116         if (self->__error_message)
1117             free(self->__error_message);
1118         self->__error_message = message ? strdup(message) : NULL;
1119     }
1120     if (self->pgerror)
1121     {
1122         ER_Destructor(self->pgerror);
1123         self->pgerror = NULL;
1124     }
1125     self_res = SC_get_Curres(self);
1126     if (!self_res)
1127         return;
1128     if (self_res == from_res)
1129         return;
1130     QR_add_message(self_res, QR_get_message(from_res));
1131     QR_add_notice(self_res, QR_get_notice(from_res));
1132     repstate = FALSE;
1133     if (!check)
1134         repstate = TRUE;
1135     else if (from_res->sqlstate[0])
1136     {
1137         if (!self_res->sqlstate[0]
1138             || strncmp(self_res->sqlstate, "00", 2) == 0)
1139             repstate = TRUE;
1140         else if (strncmp(from_res->sqlstate, "01", 2) >= 0)
1141             repstate = TRUE;
1142     }
1143     if (repstate)
1144         strcpy(self_res->sqlstate, from_res->sqlstate);
1145 }
1146
1147 void
1148 SC_error_copy(StatementClass * self, const StatementClass * from,
1149               BOOL check)
1150 {
1151     QResultClass *self_res, *from_res;
1152     BOOL repstate;
1153
1154     inolog("SC_error_copy %p->%p check=%i\n", from, self, check);
1155     if (self == from)
1156         return;
1157     if (check)
1158     {
1159         if (0 == from->__error_number)  /* SQL_SUCCESS */
1160             return;
1161         if (0 > from->__error_number && /* SQL_SUCCESS_WITH_INFO */
1162             0 < self->__error_number)
1163             return;
1164     }
1165     self->__error_number = from->__error_number;
1166     if (!check || from->__error_message)
1167     {
1168         if (self->__error_message)
1169             free(self->__error_message);
1170         self->__error_message =
1171             from->__error_message ? strdup(from->
1172                                            __error_message) : NULL;
1173     }
1174     if (self->pgerror)
1175     {
1176         ER_Destructor(self->pgerror);
1177         self->pgerror = NULL;
1178     }
1179     self_res = SC_get_Curres(self);
1180     from_res = SC_get_Curres(from);
1181     if (!self_res || !from_res)
1182         return;
1183     QR_add_message(self_res, QR_get_message(from_res));
1184     QR_add_notice(self_res, QR_get_notice(from_res));
1185     repstate = FALSE;
1186     if (!check)
1187         repstate = TRUE;
1188     else if (from_res->sqlstate[0])
1189     {
1190         if (!self_res->sqlstate[0]
1191             || strncmp(self_res->sqlstate, "00", 2) == 0)
1192             repstate = TRUE;
1193         else if (strncmp(from_res->sqlstate, "01", 2) >= 0)
1194             repstate = TRUE;
1195     }
1196     if (repstate)
1197         strcpy(self_res->sqlstate, from_res->sqlstate);
1198 }
1199
1200
1201 void
1202 SC_full_error_copy(StatementClass * self, const StatementClass * from,
1203                    BOOL allres)
1204 {
1205     PG_ErrorInfo *pgerror;
1206
1207     inolog("SC_full_error_copy %p->%p\n", from, self);
1208     if (self->__error_message)
1209     {
1210         free(self->__error_message);
1211         self->__error_message = NULL;
1212     }
1213     if (from->__error_message)
1214         self->__error_message = strdup(from->__error_message);
1215     self->__error_number = from->__error_number;
1216     if (from->pgerror)
1217     {
1218         if (self->pgerror)
1219             ER_Destructor(self->pgerror);
1220         self->pgerror = ER_Dup(from->pgerror);
1221         return;
1222     } else if (!allres)
1223         return;
1224     pgerror = SC_create_errorinfo(from);
1225     if (!pgerror->__error_message[0])
1226     {
1227         ER_Destructor(pgerror);
1228         return;
1229     }
1230     if (self->pgerror)
1231         ER_Destructor(self->pgerror);
1232     self->pgerror = pgerror;
1233 }
1234
1235 /*              Returns the next SQL error information. */
1236 RETCODE SQL_API
1237 PGAPI_StmtError(SQLHSTMT hstmt,
1238                 SQLSMALLINT RecNumber,
1239                 SQLCHAR FAR * szSqlState,
1240                 SQLINTEGER FAR * pfNativeError,
1241                 SQLCHAR FAR * szErrorMsg,
1242                 SQLSMALLINT cbErrorMsgMax,
1243                 SQLSMALLINT FAR * pcbErrorMsg, UWORD flag)
1244 {
1245     /* CC: return an error of a hdesc  */
1246     StatementClass *stmt = (StatementClass *) hstmt;
1247
1248     stmt->pgerror = SC_create_errorinfo(stmt);
1249     return ER_ReturnError(&(stmt->pgerror), RecNumber, szSqlState,
1250                           pfNativeError, szErrorMsg, cbErrorMsgMax,
1251                           pcbErrorMsg, flag);
1252 }
1253
1254 time_t SC_get_time(StatementClass * stmt)
1255 {
1256     if (!stmt)
1257         return time(NULL);
1258     if (0 == stmt->stmt_time)
1259         stmt->stmt_time = time(NULL);
1260     return stmt->stmt_time;
1261 }
1262
1263 /*
1264  *      Currently, the driver offers very simple bookmark support -- it is
1265  *      just the current row number.  But it could be more sophisticated
1266  *      someday, such as mapping a key to a 32 bit value
1267  */
1268 SQLULEN SC_get_bookmark(StatementClass * self)
1269 {
1270     return SC_make_bookmark(self->currTuple);
1271 }
1272
1273
1274 RETCODE SC_fetch(StatementClass * self)
1275 {
1276     CSTR func = "SC_fetch";
1277     QResultClass *res = SC_get_Curres(self);
1278     ARDFields *opts;
1279     GetDataInfo *gdata;
1280     int retval;
1281     RETCODE result;
1282
1283     Int2 num_cols, lf;
1284     OID type;
1285     char *value;
1286     ColumnInfoClass *coli;
1287     BindInfoClass *bookmark;
1288
1289     inolog("%s statement=%p ommitted=0\n", func, self);
1290     self->last_fetch_count = self->last_fetch_count_include_ommitted =
1291         0;
1292     coli = QR_get_fields(res);  /* the column info */
1293
1294     mylog("fetch_cursor=%d, %p->total_read=%d\n",
1295           0 /*SC_is_fetchcursor(self)*/, res, res->num_total_read);
1296
1297     if (self->currTuple >= (Int4) QR_get_num_total_tuples(res) - 1
1298         || (self->options.maxRows > 0
1299             && self->currTuple == self->options.maxRows - 1))
1300     {
1301         /*
1302          * if at the end of the tuples, return "no data found" and set
1303          * the cursor past the end of the result set
1304          */
1305         self->currTuple = QR_get_num_total_tuples(res);
1306         return SQL_NO_DATA_FOUND;
1307     }
1308
1309     mylog("**** %s: non-cursor_result\n", func);
1310     (self->currTuple)++;
1311
1312     if (QR_haskeyset(res))
1313     {
1314         SQLLEN kres_ridx;
1315
1316         kres_ridx = GIdx2KResIdx(self->currTuple, self, res);
1317         if (kres_ridx >= 0 && kres_ridx < res->num_cached_keys)
1318         {
1319             UWORD pstatus = res->keyset[kres_ridx].status;
1320             inolog("SC_ pstatus[%d]=%hx fetch_count=" FORMAT_LEN "\n",
1321                    kres_ridx, pstatus, self->last_fetch_count);
1322             if (0 !=
1323                 (pstatus & (CURS_SELF_DELETING | CURS_SELF_DELETED)))
1324                 return SQL_SUCCESS_WITH_INFO;
1325             if (SQL_ROW_DELETED != (pstatus & KEYSET_INFO_PUBLIC) &&
1326                 0 != (pstatus & CURS_OTHER_DELETED))
1327                 return SQL_SUCCESS_WITH_INFO;
1328             if (0 != (CURS_NEEDS_REREAD & pstatus))
1329             {
1330                 UWORD qcount;
1331
1332                 result =
1333                     SC_pos_reload(self, self->currTuple, &qcount, 0);
1334                 if (SQL_ERROR == result)
1335                     return result;
1336                 pstatus &= ~CURS_NEEDS_REREAD;
1337             }
1338         }
1339     }
1340
1341     num_cols = QR_NumPublicResultCols(res);
1342
1343     result = SQL_SUCCESS;
1344     self->last_fetch_count++;
1345     inolog("%s: stmt=%p ommitted++\n", func, self);
1346     self->last_fetch_count_include_ommitted++;
1347
1348     opts = SC_get_ARDF(self);
1349     /*
1350      * If the bookmark column was bound then return a bookmark. Since this
1351      * is used with SQLExtendedFetch, and the rowset size may be greater
1352      * than 1, and an application can use row or column wise binding, use
1353      * the code in copy_and_convert_field() to handle that.
1354      */
1355     if ((bookmark = opts->bookmark) && bookmark->buffer)
1356     {
1357         char buf[32];
1358         SQLLEN offset =
1359             opts->row_offset_ptr ? *opts->row_offset_ptr : 0;
1360
1361         sprintf(buf, FORMAT_ULEN, SC_get_bookmark(self));
1362         SC_set_current_col(self, -1);
1363         result = copy_and_convert_field(self, 0, buf,
1364                                         SQL_C_ULONG,
1365                                         bookmark->buffer + offset, 0,
1366                                         LENADDR_SHIFT(bookmark->used,
1367                                                       offset),
1368                                         LENADDR_SHIFT(bookmark->used,
1369                                                       offset));
1370     }
1371
1372     if (self->options.retrieve_data == SQL_RD_OFF)      /* data isn't required */
1373         return SQL_SUCCESS;
1374     gdata = SC_get_GDTI(self);
1375     if (gdata->allocated != opts->allocated)
1376         extend_getdata_info(gdata, opts->allocated, TRUE);
1377     for (lf = 0; lf < num_cols; lf++)
1378     {
1379         mylog
1380             ("fetch: cols=%d, lf=%d, opts = %p, opts->bindings = %p, buffer[] = %p\n",
1381              num_cols, lf, opts, opts->bindings,
1382              opts->bindings[lf].buffer);
1383
1384         /* reset for SQLGetData */
1385         gdata->gdata[lf].data_left = -1;
1386
1387         if (NULL == opts->bindings)
1388             continue;
1389         if (opts->bindings[lf].buffer != NULL)
1390         {
1391             /* this column has a binding */
1392
1393             /* type = QR_get_field_type(res, lf); */
1394             type = CI_get_oid(coli, lf);        /* speed things up */
1395
1396             mylog("type = %d\n", type);
1397
1398             SQLLEN curt = GIdx2CacheIdx(self->currTuple, self, res);
1399             inolog("base=%d curr=%d st=%d\n",
1400                    QR_get_rowstart_in_cache(res), self->currTuple,
1401                    SC_get_rowset_start(self));
1402             inolog("curt=%d\n", curt);
1403             value = (char *)QR_get_value_backend_row(res, curt, lf);
1404
1405             mylog("value = '%s'\n", (value == NULL) ? "<NULL>" : value);
1406
1407             retval =
1408                 copy_and_convert_field_bindinfo(self, type, value, lf);
1409
1410             mylog("copy_and_convert: retval = %d\n", retval);
1411
1412             switch (retval)
1413             {
1414             case COPY_OK:
1415                 break;          /* OK, do next bound column */
1416
1417             case COPY_UNSUPPORTED_TYPE:
1418                 SC_set_error(self, STMT_RESTRICTED_DATA_TYPE_ERROR,
1419                              "Received an unsupported type from Postgres.",
1420                              func);
1421                 result = SQL_ERROR;
1422                 break;
1423
1424             case COPY_UNSUPPORTED_CONVERSION:
1425                 SC_set_error(self, STMT_RESTRICTED_DATA_TYPE_ERROR,
1426                              "Couldn't handle the necessary data type conversion.",
1427                              func);
1428                 result = SQL_ERROR;
1429                 break;
1430
1431             case COPY_RESULT_TRUNCATED:
1432                 SC_set_error(self, STMT_TRUNCATED,
1433                              "Fetched item was truncated.", func);
1434                 qlog("The %dth item was truncated\n", lf + 1);
1435                 qlog("The buffer size = %d", opts->bindings[lf].buflen);
1436                 qlog(" and the value is '%s'\n", value);
1437                 result = SQL_SUCCESS_WITH_INFO;
1438                 break;
1439
1440                 /* error msg already filled in */
1441             case COPY_GENERAL_ERROR:
1442                 result = SQL_ERROR;
1443                 break;
1444
1445                 /* This would not be meaningful in SQLFetch. */
1446             case COPY_NO_DATA_FOUND:
1447                 break;
1448
1449             default:
1450                 SC_set_error(self, STMT_INTERNAL_ERROR,
1451                              "Unrecognized return value from copy_and_convert_field.",
1452                              func);
1453                 result = SQL_ERROR;
1454                 break;
1455             }
1456         }
1457     }
1458
1459     return result;
1460 }
1461
1462
1463 #define CALLBACK_ALLOC_ONCE     4
1464 int enqueueNeedDataCallback(StatementClass * stmt,
1465                             NeedDataCallfunc func, void *data)
1466 {
1467     if (stmt->num_callbacks >= stmt->allocated_callbacks)
1468     {
1469         stmt->callbacks = (NeedDataCallback *) realloc(stmt->callbacks,
1470                                                        sizeof
1471                                                        (NeedDataCallback)
1472                                                        *
1473                                                        (stmt->
1474                                                         allocated_callbacks
1475                                                         +
1476                                                         CALLBACK_ALLOC_ONCE));
1477         stmt->allocated_callbacks += CALLBACK_ALLOC_ONCE;
1478     }
1479     stmt->callbacks[stmt->num_callbacks].func = func;
1480     stmt->callbacks[stmt->num_callbacks].data = data;
1481     stmt->num_callbacks++;
1482
1483     inolog("enqueueNeedDataCallack stmt=%p, func=%p, count=%d\n", stmt,
1484            func, stmt->num_callbacks);
1485     return stmt->num_callbacks;
1486 }
1487
1488 RETCODE dequeueNeedDataCallback(RETCODE retcode, StatementClass * stmt)
1489 {
1490     RETCODE ret;
1491     NeedDataCallfunc func;
1492     void *data;
1493     int i, cnt;
1494
1495     mylog("dequeueNeedDataCallback ret=%d count=%d\n", retcode,
1496           stmt->num_callbacks);
1497     if (SQL_NEED_DATA == retcode)
1498         return retcode;
1499     if (stmt->num_callbacks <= 0)
1500         return retcode;
1501     func = stmt->callbacks[0].func;
1502     data = stmt->callbacks[0].data;
1503     for (i = 1; i < stmt->num_callbacks; i++)
1504         stmt->callbacks[i - 1] = stmt->callbacks[i];
1505     cnt = --stmt->num_callbacks;
1506     ret = (*func) (retcode, data);
1507     free(data);
1508     if (SQL_NEED_DATA != ret && cnt > 0)
1509         ret = dequeueNeedDataCallback(ret, stmt);
1510     return ret;
1511 }
1512
1513 void cancelNeedDataState(StatementClass * stmt)
1514 {
1515     int cnt = stmt->num_callbacks, i;
1516
1517     stmt->num_callbacks = 0;
1518     for (i = 0; i < cnt; i++)
1519     {
1520         if (stmt->callbacks[i].data)
1521             free(stmt->callbacks[i].data);
1522     }
1523     SC_reset_delegate(SQL_ERROR, stmt);
1524 }
1525
1526 void
1527 SC_log_error(const char *func, const char *desc,
1528              const StatementClass * self)
1529 {
1530     const char *head;
1531 #ifdef PRN_NULLCHECK
1532 #define nullcheck(a) (a ? a : "(NULL)")
1533 #endif
1534     if (self)
1535     {
1536         QResultClass *res = SC_get_Result(self);
1537         const ARDFields *opts = SC_get_ARDF(self);
1538         const APDFields *apdopts = SC_get_APDF(self);
1539         SQLLEN rowsetSize;
1540
1541         rowsetSize =
1542             (7 ==
1543              self->transition_status ? opts->
1544              size_of_rowset_odbc2 : opts->size_of_rowset);
1545         if (SC_get_errornumber(self) <= 0)
1546             head = "STATEMENT WARNING";
1547         else
1548         {
1549             head = "STATEMENT ERROR";
1550             qlog("%s: func=%s, desc='%s', errnum=%d, errmsg='%s'\n",
1551                  head, func, desc, self->__error_number,
1552                  nullcheck(self->__error_message));
1553         }
1554         mylog("%s: func=%s, desc='%s', errnum=%d, errmsg='%s'\n", head,
1555               func, desc, self->__error_number,
1556               nullcheck(self->__error_message));
1557         if (SC_get_errornumber(self) > 0)
1558         {
1559             qlog("                 ------------------------------------------------------------\n");
1560             qlog("                 hdbc=%p, stmt=%p, result=%p\n",
1561                  self->hdbc, self, res);
1562             qlog("                 prepare=%d, internal=%d\n",
1563                  self->prepare, self->internal);
1564             qlog("                 bindings=%p, bindings_allocated=%d\n", opts->bindings, opts->allocated);
1565             qlog("                 parameters=%p, parameters_allocated=%d\n", apdopts->parameters, apdopts->allocated);
1566             qlog("                 statement_type=%d, statement='%s'\n",
1567                  self->statement_type, nullcheck(self->statement));
1568             qlog("                 stmt_with_params='%s'\n",
1569                  nullcheck(self->stmt_with_params));
1570             qlog("                 data_at_exec=%d, current_exec_param=%d, put_data=%d\n", self->data_at_exec, self->current_exec_param, self->put_data);
1571             qlog("                 currTuple=%d, current_col=%d\n", self->currTuple, self->current_col);
1572             qlog("                 maxRows=%d, rowset_size=%d, keyset_size=%d, cursor_type=%d, scroll_concurrency=%d\n", self->options.maxRows, rowsetSize, self->options.keyset_size, self->options.cursor_type, self->options.scroll_concurrency);
1573             qlog("                 cursor_name='%s'\n",
1574                  SC_cursor_name(self));
1575
1576             qlog("                 ----------------QResult Info -------------------------------\n");
1577
1578             if (res)
1579             {
1580                 qlog("                 fields=%p, backend_tuples=%p, tupleField=%d, conn=%p\n", res->fields, res->backend_tuples, res->tupleField, res->conn);
1581                 qlog("                 fetch_count=%d, num_total_rows=%d, num_fields=%d, cursor='%s'\n", res->fetch_number, QR_get_num_total_tuples(res), res->num_fields, nullcheck(QR_get_cursor(res)));
1582                 qlog("                 message='%s', command='%s', notice='%s'\n", nullcheck(res->message), nullcheck(res->command), nullcheck(res->notice));
1583                 qlog("                 status=%d, inTuples=%d\n",
1584                      QR_get_rstatus(res), QR_is_fetching_tuples(res));
1585             }
1586
1587             /* Log the connection error if there is one */
1588             CC_log_error(func, desc, self->hdbc);
1589         }
1590     } else
1591     {
1592         qlog("INVALID STATEMENT HANDLE ERROR: func=%s, desc='%s'\n",
1593              func, desc);
1594         mylog("INVALID STATEMENT HANDLE ERROR: func=%s, desc='%s'\n",
1595               func, desc);
1596     }
1597 #undef PRN_NULLCHECK
1598 }
1599
1600 /*
1601  *      Extended Query
1602  */
1603
1604 enum {
1605     CancelRequestSet = 1L, CancelRequestAccepted =
1606         (1L << 1), CancelCompleted = (1L << 2)
1607 };
1608 /*      commonly used for short term lock */
1609 #if defined(WIN_MULTITHREAD_SUPPORT)
1610 extern CRITICAL_SECTION common_cs;
1611 #elif defined(POSIX_MULTITHREAD_SUPPORT)
1612 extern pthread_mutex_t common_cs;
1613 #endif                          /* WIN_MULTITHREAD_SUPPORT */
1614 BOOL SC_IsExecuting(const StatementClass * self)
1615 {
1616     BOOL ret;
1617     ENTER_COMMON_CS;            /* short time blocking */
1618     ret = (STMT_EXECUTING == self->status);
1619     LEAVE_COMMON_CS;
1620     return ret;
1621 }
1622
1623 BOOL SC_SetExecuting(StatementClass * self, BOOL on)
1624 {
1625     BOOL exeSet = FALSE;
1626     ENTER_COMMON_CS;            /* short time blocking */
1627     if (on)
1628     {
1629         if (0 == (self->cancel_info & CancelRequestSet))
1630         {
1631             self->status = STMT_EXECUTING;
1632             exeSet = TRUE;
1633         }
1634     } else
1635     {
1636         self->cancel_info = 0;
1637         self->status = STMT_FINISHED;
1638         exeSet = TRUE;
1639     }
1640     LEAVE_COMMON_CS;
1641     return exeSet;
1642 }
1643
1644 BOOL SC_SetCancelRequest(StatementClass * self)
1645 {
1646     BOOL enteredCS = FALSE;
1647
1648     ENTER_COMMON_CS;
1649     if (0 != (self->cancel_info & CancelCompleted))
1650         ;
1651     else if (STMT_EXECUTING == self->status)
1652     {
1653         self->cancel_info |= CancelRequestSet;
1654     } else
1655     {
1656         /* try to acquire */
1657         if (TRY_ENTER_STMT_CS(self))
1658             enteredCS = TRUE;
1659         else
1660             self->cancel_info |= CancelRequestSet;
1661     }
1662     LEAVE_COMMON_CS;
1663     return enteredCS;
1664 }
1665
1666 BOOL SC_AcceptedCancelRequest(const StatementClass * self)
1667 {
1668     BOOL shouldCancel = FALSE;
1669     ENTER_COMMON_CS;
1670     if (0 !=
1671         (self->
1672          cancel_info & (CancelRequestSet | CancelRequestAccepted |
1673                         CancelCompleted)))
1674         shouldCancel = TRUE;
1675     LEAVE_COMMON_CS;
1676     return shouldCancel;
1677 }