vxodbc/descriptor.cc

   1 /*
   2  * Description: This module contains functions related to creating
   3  *              and manipulating a statement.
   4  */
   5 #include "environ.h"
   6 #include "connection.h"
   7 #include "descriptor.h"
   8 #include "statement.h"
   9
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <ctype.h>
  13
  14 #include "pgapifunc.h"
  15
  16
  17 void TI_Constructor(TABLE_INFO * self, const ConnectionClass * conn)
  18 {
  19     memset(self, 0, sizeof(TABLE_INFO));
  20     TI_set_updatable(self);
  21     if (PG_VERSION_LT(conn, 7.2))
  22     {
  23         char qual[32];
  24
  25         STR_TO_NAME(self->bestitem, OID_NAME);
  26         sprintf(qual, "\"oid\" = %%u");
  27         STR_TO_NAME(self->bestqual, qual);
  28         TI_set_hasoids(self);
  29         TI_set_hasoids_checked(self);
  30     }
  31 }
  32 void TI_Destructor(TABLE_INFO ** ti, int count)
  33 {
  34     int i;
  35
  36     inolog("TI_Destructor count=%d\n", count);
  37     if (ti)
  38     {
  39         for (i = 0; i < count; i++)
  40         {
  41             if (ti[i])
  42             {
  43                 NULL_THE_NAME(ti[i]->schema_name);
  44                 NULL_THE_NAME(ti[i]->table_name);
  45                 NULL_THE_NAME(ti[i]->table_alias);
  46                 NULL_THE_NAME(ti[i]->bestitem);
  47                 NULL_THE_NAME(ti[i]->bestqual);
  48                 free(ti[i]);
  49                 ti[i] = NULL;
  50             }
  51         }
  52     }
  53 }
  54 void FI_Constructor(FIELD_INFO * self, BOOL reuse)
  55 {
  56     inolog("FI_Constructor reuse=%d\n", reuse);
  57     if (reuse)
  58         FI_Destructor(&self, 1, FALSE);
  59     memset(self, 0, sizeof(FIELD_INFO));
  60     self->nullable = TRUE;
  61 }
  62 void FI_Destructor(FIELD_INFO ** fi, int count, BOOL freeFI)
  63 {
  64     int i;
  65
  66     inolog("FI_Destructor count=%d\n", count);
  67     if (fi)
  68     {
  69         for (i = 0; i < count; i++)
  70         {
  71             if (fi[i])
  72             {
  73                 NULL_THE_NAME(fi[i]->column_name);
  74                 NULL_THE_NAME(fi[i]->column_alias);
  75                 NULL_THE_NAME(fi[i]->schema_name);
  76                 NULL_THE_NAME(fi[i]->before_dot);
  77                 if (freeFI)
  78                 {
  79                     free(fi[i]);
  80                     fi[i] = NULL;
  81                 }
  82             }
  83         }
  84         if (freeFI)
  85             free(fi);
  86     }
  87 }
  88
  89 void DC_Constructor(DescriptorClass * self, BOOL embedded,
  90                     StatementClass * stmt)
  91 {
  92     memset(self, 0, sizeof(DescriptorClass));
  93     self->embedded = embedded;
  94 }
  95
  96 static void ARDFields_free(ARDFields * self)
  97 {
  98     inolog("ARDFields_free %p bookmark=%p", self, self->bookmark);
  99     if (self->bookmark)
 100     {
 101         free(self->bookmark);
 102         self->bookmark = NULL;
 103     }
 104     inolog(" hey");
 105     /*
 106      * the memory pointed to by the bindings is not deallocated by the
 107      * driver but by the application that uses that driver, so we don't
 108      * have to care
 109      */
 110     ARD_unbind_cols(self, TRUE);
 111 }
 112
 113 static void APDFields_free(APDFields * self)
 114 {
 115     if (self->bookmark)
 116     {
 117         free(self->bookmark);
 118         self->bookmark = NULL;
 119     }
 120     /* param bindings */
 121     APD_free_params(self, STMT_FREE_PARAMS_ALL);
 122 }
 123
 124 static void IRDFields_free(IRDFields * self)
 125 {
 126     /* Free the parsed field information */
 127     if (self->fi)
 128     {
 129         FI_Destructor(self->fi, self->allocated, TRUE);
 130         self->fi = NULL;
 131     }
 132     self->allocated = 0;
 133     self->nfields = 0;
 134 }
 135
 136 static void IPDFields_free(IPDFields * self)
 137 {
 138     /* param bindings */
 139     IPD_free_params(self, STMT_FREE_PARAMS_ALL);
 140 }
 141
 142 void DC_Destructor(DescriptorClass * self)
 143 {
 144     if (self->__error_message)
 145     {
 146         free(self->__error_message);
 147         self->__error_message = NULL;
 148     }
 149     if (self->pgerror)
 150     {
 151         ER_Destructor(self->pgerror);
 152         self->pgerror = NULL;
 153     }
 154     if (self->type_defined)
 155     {
 156         switch (self->desc_type)
 157         {
 158         case SQL_ATTR_APP_ROW_DESC:
 159             ARDFields_free((ARDFields *) (self + 1));
 160             break;
 161         case SQL_ATTR_APP_PARAM_DESC:
 162             APDFields_free((APDFields *) (self + 1));
 163             break;
 164         case SQL_ATTR_IMP_ROW_DESC:
 165             IRDFields_free((IRDFields *) (self + 1));
 166             break;
 167         case SQL_ATTR_IMP_PARAM_DESC:
 168             IPDFields_free((IPDFields *) (self + 1));
 169             break;
 170         }
 171     }
 172 }
 173
 174 void InitializeEmbeddedDescriptor(DescriptorClass * desc,
 175                                   StatementClass * stmt,
 176                                   UInt4 desc_type)
 177 {
 178     DC_Constructor(desc, TRUE, stmt);
 179     DC_get_conn(desc) = SC_get_conn(stmt);
 180     desc->type_defined = TRUE;
 181     desc->desc_type = desc_type;
 182     switch (desc_type)
 183     {
 184     case SQL_ATTR_APP_ROW_DESC:
 185         memset(desc + 1, 0, sizeof(ARDFields));
 186         stmt->ard = (ARDClass *) desc;
 187         break;
 188     case SQL_ATTR_APP_PARAM_DESC:
 189         memset(desc + 1, 0, sizeof(APDFields));
 190         stmt->apd = (APDClass *) desc;
 191         break;
 192     case SQL_ATTR_IMP_ROW_DESC:
 193         memset(desc + 1, 0, sizeof(IRDFields));
 194         stmt->ird = (IRDClass *) desc;
 195         stmt->ird->irdopts.stmt = stmt;
 196         break;
 197     case SQL_ATTR_IMP_PARAM_DESC:
 198         memset(desc + 1, 0, sizeof(IPDFields));
 199         stmt->ipd = (IPDClass *) desc;
 200         break;
 201     }
 202 }
 203
 204 /*
 205  * ARDFields initialize
 206  */
 207 void InitializeARDFields(ARDFields * opt)
 208 {
 209     memset(opt, 0, sizeof(ARDFields));
 210     opt->size_of_rowset = 1;
 211     opt->bind_size = 0;         /* default is to bind by column */
 212     opt->size_of_rowset_odbc2 = 1;
 213 }
 214
 215 /*
 216  * APDFields initialize
 217  */
 218 void InitializeAPDFields(APDFields * opt)
 219 {
 220     memset(opt, 0, sizeof(APDFields));
 221     opt->paramset_size = 1;
 222     opt->param_bind_type = 0;   /* default is to bind by column */
 223     opt->paramset_size_dummy = 1;       /* dummy setting */
 224 }
 225
 226 BindInfoClass *ARD_AllocBookmark(ARDFields * ardopts)
 227 {
 228     if (!ardopts->bookmark)
 229     {
 230         ardopts->bookmark =
 231             (BindInfoClass *) malloc(sizeof(BindInfoClass));
 232         memset(ardopts->bookmark, 0, sizeof(BindInfoClass));
 233     }
 234     return ardopts->bookmark;
 235 }
 236
 237
 238 #define DESC_INCREMENT  10
 239 char CC_add_descriptor(ConnectionClass * self, DescriptorClass * desc)
 240 {
 241     int i;
 242
 243     mylog("CC_add_descriptor: self=%p, desc=%p\n", self, desc);
 244
 245     for (i = 0; i < self->num_descs; i++)
 246     {
 247         if (!self->descs[i])
 248         {
 249             DC_get_conn(desc) = self;
 250             self->descs[i] = desc;
 251             return TRUE;
 252         }
 253     }
 254     /* no more room -- allocate more memory */
 255     self->descs =
 256         (DescriptorClass **) realloc(self->descs,
 257                                      sizeof(DescriptorClass *) *
 258                                      (DESC_INCREMENT +
 259                                       self->num_descs));
 260     if (!self->descs)
 261         return FALSE;
 262
 263     memset(&self->descs[self->num_descs], 0, sizeof(DescriptorClass *) *
 264            DESC_INCREMENT);
 265     DC_get_conn(desc) = self;
 266     self->descs[self->num_descs] = desc;
 267     self->num_descs += DESC_INCREMENT;
 268
 269     return TRUE;
 270 }
 271
 272 /*
 273  *      This API allocates a Application descriptor.
 274  */
 275 RETCODE SQL_API PGAPI_AllocDesc(HDBC ConnectionHandle,
 276                                 SQLHDESC * DescriptorHandle)
 277 {
 278     CSTR func = "PGAPI_AllocDesc";
 279     ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
 280     RETCODE ret = SQL_SUCCESS;
 281     DescriptorClass *desc =
 282         (DescriptorClass *) malloc(sizeof(DescriptorAlloc));
 283
 284     mylog("%s: entering...\n", func);
 285     if (desc)
 286     {
 287         memset(desc, 0, sizeof(DescriptorAlloc));
 288         DC_get_conn(desc) = conn;
 289         if (CC_add_descriptor(conn, desc))
 290             *DescriptorHandle = desc;
 291         else
 292         {
 293             free(desc);
 294             CC_set_error(conn, CONN_STMT_ALLOC_ERROR,
 295                          "Maximum number of descriptors exceeded",
 296                          func);
 297             ret = SQL_ERROR;
 298         }
 299     } else
 300     {
 301         CC_set_error(conn, CONN_STMT_ALLOC_ERROR,
 302                      "No more memory ti allocate a further descriptor",
 303                      func);
 304         ret = SQL_ERROR;
 305     }
 306     return ret;
 307 }
 308
 309 RETCODE SQL_API PGAPI_FreeDesc(SQLHDESC DescriptorHandle)
 310 {
 311     CSTR func = "PGAPI_FreeDesc";
 312     DescriptorClass *desc = (DescriptorClass *) DescriptorHandle;
 313     RETCODE ret = SQL_SUCCESS;
 314
 315     mylog("%s: entering...\n", func);
 316     DC_Destructor(desc);
 317     if (!desc->embedded)
 318     {
 319         int i;
 320         ConnectionClass *conn = DC_get_conn(desc);
 321
 322         for (i = 0; i < conn->num_descs; i++)
 323         {
 324             if (conn->descs[i] == desc)
 325             {
 326                 conn->descs[i] = NULL;
 327                 break;
 328             }
 329         }
 330         free(desc);
 331     }
 332     return ret;
 333 }
 334
 335 static void BindInfoClass_copy(const BindInfoClass * src,
 336                                BindInfoClass * target)
 337 {
 338     memcpy(target, src, sizeof(BindInfoClass));
 339 }
 340 static void ARDFields_copy(const ARDFields * src, ARDFields * target)
 341 {
 342     memcpy(target, src, sizeof(ARDFields));
 343     target->bookmark = NULL;
 344     if (src->bookmark)
 345     {
 346         BindInfoClass *bookmark = ARD_AllocBookmark(target);
 347         BindInfoClass_copy(src->bookmark, bookmark);
 348     }
 349     if (src->allocated <= 0)
 350     {
 351         target->allocated = 0;
 352         target->bindings = NULL;
 353     } else
 354     {
 355         int i;
 356
 357         target->bindings = (BindInfoClass *)
 358             malloc(target->allocated * sizeof(BindInfoClass));
 359         for (i = 0; i < target->allocated; i++)
 360             BindInfoClass_copy(&src->bindings[i], &target->bindings[i]);
 361     }
 362 }
 363
 364 static void ParameterInfoClass_copy(const ParameterInfoClass * src,
 365                                     ParameterInfoClass * target)
 366 {
 367     memcpy(target, src, sizeof(ParameterInfoClass));
 368 }
 369 static void APDFields_copy(const APDFields * src, APDFields * target)
 370 {
 371     memcpy(target, src, sizeof(APDFields));
 372     if (src->bookmark)
 373     {
 374         target->bookmark = (ParameterInfoClass *)
 375             malloc(sizeof(ParameterInfoClass));
 376         ParameterInfoClass_copy(src->bookmark, target->bookmark);
 377     }
 378     if (src->allocated <= 0)
 379     {
 380         target->allocated = 0;
 381         target->parameters = NULL;
 382     } else
 383     {
 384         int i;
 385
 386         target->parameters = (ParameterInfoClass *)
 387             malloc(target->allocated * sizeof(ParameterInfoClass));
 388         for (i = 0; i < target->allocated; i++)
 389             ParameterInfoClass_copy(&src->parameters[i],
 390                                     &target->parameters[i]);
 391     }
 392 }
 393
 394 static void ParameterImplClass_copy(const ParameterImplClass * src,
 395                                     ParameterImplClass * target)
 396 {
 397     memcpy(target, src, sizeof(ParameterImplClass));
 398 }
 399 static void IPDFields_copy(const IPDFields * src, IPDFields * target)
 400 {
 401     memcpy(target, src, sizeof(IPDFields));
 402     if (src->allocated <= 0)
 403     {
 404         target->allocated = 0;
 405         target->parameters = NULL;
 406     } else
 407     {
 408         int i;
 409
 410         target->parameters =
 411             (ParameterImplClass *) malloc(target->allocated *
 412                                           sizeof(ParameterInfoClass));
 413         for (i = 0; i < target->allocated; i++)
 414             ParameterImplClass_copy(&src->parameters[i],
 415                                     &target->parameters[i]);
 416     }
 417 }
 418
 419 RETCODE SQL_API
 420 PGAPI_CopyDesc(SQLHDESC SourceDescHandle, SQLHDESC TargetDescHandle)
 421 {
 422     CSTR func = "PGAPI_CopyDesc";
 423     RETCODE ret = SQL_ERROR;
 424     DescriptorClass *src, *target;
 425     ARDFields *ard_src, *ard_tgt;
 426     APDFields *apd_src, *apd_tgt;
 427     IPDFields *ipd_src, *ipd_tgt;
 428
 429     mylog("%s: entering...\n", func);
 430     src = (DescriptorClass *) SourceDescHandle;
 431     target = (DescriptorClass *) TargetDescHandle;
 432     if (!src->type_defined)
 433     {
 434         mylog("source type undefined\n");
 435         DC_set_error(target, DESC_EXEC_ERROR,
 436                      "source handle type undefined");
 437         return ret;
 438     }
 439     if (target->type_defined)
 440     {
 441         inolog("source type=%d -> target type=%d\n", src->desc_type,
 442                target->desc_type);
 443         if (SQL_ATTR_IMP_ROW_DESC == target->desc_type)
 444         {
 445             mylog("can't modify IRD\n");
 446             DC_set_error(target, DESC_EXEC_ERROR, "can't copy to IRD");
 447             return ret;
 448         } else if (target->desc_type != src->desc_type)
 449         {
 450             mylog("src type != target type\n");
 451             DC_set_error(target, DESC_EXEC_ERROR,
 452                          "src descriptor != target type");
 453             return ret;
 454         }
 455         DC_Destructor(target);
 456     }
 457     ret = SQL_SUCCESS;
 458     switch (src->desc_type)
 459     {
 460     case SQL_ATTR_APP_ROW_DESC:
 461         inolog("src=%p target=%p type=%d", src, target, src->desc_type);
 462         if (!target->type_defined)
 463         {
 464             target->desc_type = src->desc_type;
 465         }
 466         ard_src = (ARDFields *) (src + 1);
 467         inolog(" rowset_size=%d bind_size=%d ope_ptr=%p off_ptr=%p\n",
 468                ard_src->size_of_rowset, ard_src->bind_size,
 469                ard_src->row_operation_ptr, ard_src->row_offset_ptr);
 470         ard_tgt = (ARDFields *) (target + 1);
 471         inolog(" target=%p", ard_tgt);
 472         ARDFields_copy(ard_src, ard_tgt);
 473         inolog(" offset_ptr=%p\n", ard_tgt->row_offset_ptr);
 474         break;
 475     case SQL_ATTR_APP_PARAM_DESC:
 476         if (!target->type_defined)
 477         {
 478             target->desc_type = src->desc_type;
 479         }
 480         apd_src = (APDFields *) (src + 1);
 481         apd_tgt = (APDFields *) (target + 1);
 482         APDFields_copy(apd_src, apd_tgt);
 483         break;
 484     case SQL_ATTR_IMP_PARAM_DESC:
 485         if (!target->type_defined)
 486         {
 487             target->desc_type = src->desc_type;
 488         }
 489         ipd_src = (IPDFields *) (src + 1);
 490         ipd_tgt = (IPDFields *) (target + 1);
 491         IPDFields_copy(ipd_src, ipd_tgt);
 492         break;
 493     default:
 494         mylog("invalid descriptor handle type=%d\n", src->desc_type);
 495         DC_set_error(target, DESC_EXEC_ERROR,
 496                      "invalid descriptor type");
 497         ret = SQL_ERROR;
 498     }
 499
 500     if (SQL_SUCCESS == ret)
 501         target->type_defined = TRUE;
 502     return ret;
 503 }
 504
 505 void DC_clear_error(DescriptorClass * self)
 506 {
 507     if (self->__error_message)
 508     {
 509         free(self->__error_message);
 510         self->__error_message = NULL;
 511     }
 512     if (self->pgerror)
 513     {
 514         ER_Destructor(self->pgerror);
 515         self->pgerror = NULL;
 516     }
 517     self->__error_number = 0;
 518     self->error_row = 0;
 519     self->error_index = 0;
 520 }
 521
 522 void DC_set_error(DescriptorClass * desc, int errornumber,
 523                   const char *errormsg)
 524 {
 525     if (desc->__error_message)
 526         free(desc->__error_message);
 527     desc->__error_number = errornumber;
 528     desc->__error_message = errormsg ? strdup(errormsg) : NULL;
 529 }
 530 void DC_set_errormsg(DescriptorClass * desc, const char *errormsg)
 531 {
 532     if (desc->__error_message)
 533         free(desc->__error_message);
 534     desc->__error_message = errormsg ? strdup(errormsg) : NULL;
 535 }
 536 const char *DC_get_errormsg(const DescriptorClass * desc)
 537 {
 538     return desc->__error_message;
 539 }
 540 int DC_get_errornumber(const DescriptorClass * desc)
 541 {
 542     return desc->__error_number;
 543 }
 544
 545 /*      Map sql commands to statement types */
 546 static struct {
 547     int number;
 548     const char *ver3str;
 549     const char *ver2str;
 550 } Descriptor_sqlstate[] =
 551 {
 552     {
 553     DESC_ERROR_IN_ROW, "01S01", "01S01"},
 554     {
 555     DESC_OPTION_VALUE_CHANGED, "01S02", "01S02"},
 556     {
 557     DESC_OK, "00000", "00000"}, /* OK */
 558     {
 559     DESC_EXEC_ERROR, "HY000", "S1000"}, /* also a general error */
 560     {
 561     DESC_STATUS_ERROR, "HY010", "S1010"},
 562     {
 563     DESC_SEQUENCE_ERROR, "HY010", "S1010"},     /* Function sequence error */
 564     {
 565     DESC_NO_MEMORY_ERROR, "HY001", "S1001"},    /* memory allocation failure */
 566     {
 567     DESC_COLNUM_ERROR, "07009", "S1002"},       /* invalid column number */
 568     {
 569     DESC_NO_STMTSTRING, "HY001", "S1001"},      /* having no stmtstring is also a malloc problem */
 570     {
 571     DESC_ERROR_TAKEN_FROM_BACKEND, "HY000", "S1000"},   /* general error */
 572     {
 573     DESC_INTERNAL_ERROR, "HY000", "S1000"},     /* general error */
 574     {
 575     DESC_STILL_EXECUTING, "HY010", "S1010"},
 576     {
 577     DESC_NOT_IMPLEMENTED_ERROR, "HYC00", "S1C00"},      /* == 'driver not
 578                                                          * capable' */
 579     {
 580     DESC_BAD_PARAMETER_NUMBER_ERROR, "07009", "S1093"},
 581     {
 582     DESC_OPTION_OUT_OF_RANGE_ERROR, "HY092", "S1092"},
 583     {
 584     DESC_INVALID_COLUMN_NUMBER_ERROR, "07009", "S1002"},
 585     {
 586     DESC_RESTRICTED_DATA_TYPE_ERROR, "07006", "07006"},
 587     {
 588     DESC_INVALID_CURSOR_STATE_ERROR, "07005", "24000"},
 589     {
 590     DESC_CREATE_TABLE_ERROR, "42S01", "S0001"}, /* table already exists */
 591     {
 592     DESC_NO_CURSOR_NAME, "S1015", "S1015"},
 593     {
 594     DESC_INVALID_CURSOR_NAME, "34000", "34000"},
 595     {
 596     DESC_INVALID_ARGUMENT_NO, "HY024", "S1009"},        /* invalid argument value */
 597     {
 598     DESC_ROW_OUT_OF_RANGE, "HY107", "S1107"},
 599     {
 600     DESC_OPERATION_CANCELLED, "HY008", "S1008"},
 601     {
 602     DESC_INVALID_CURSOR_POSITION, "HY109", "S1109"},
 603     {
 604     DESC_VALUE_OUT_OF_RANGE, "HY019", "22003"},
 605     {
 606     DESC_OPERATION_INVALID, "HY011", "S1011"},
 607     {
 608     DESC_PROGRAM_TYPE_OUT_OF_RANGE, "?????", "?????"},
 609     {
 610     DESC_BAD_ERROR, "08S01", "08S01"},  /* communication link failure */
 611     {
 612     DESC_INVALID_OPTION_IDENTIFIER, "HY092", "HY092"},
 613     {
 614     DESC_RETURN_NULL_WITHOUT_INDICATOR, "22002", "22002"},
 615     {
 616     DESC_INVALID_DESCRIPTOR_IDENTIFIER, "HY091", "HY091"},
 617     {
 618     DESC_OPTION_NOT_FOR_THE_DRIVER, "HYC00", "HYC00"},
 619     {
 620     DESC_FETCH_OUT_OF_RANGE, "HY106", "S1106"},
 621     {
 622 DESC_COUNT_FIELD_INCORRECT, "07002", "07002"},};
 623
 624 static PG_ErrorInfo *DC_create_errorinfo(const DescriptorClass * desc)
 625 {
 626     PG_ErrorInfo *error;
 627     ConnectionClass *conn;
 628     EnvironmentClass *env;
 629     Int4 errornum;
 630     BOOL env_is_odbc3 = TRUE;
 631
 632     if (desc->pgerror)
 633         return desc->pgerror;
 634     errornum = desc->__error_number;
 635     error = ER_Constructor(errornum, desc->__error_message);
 636     if (!error)
 637         return error;
 638     conn = DC_get_conn(desc);
 639     if (conn && (env = (EnvironmentClass *) conn->henv))
 640         env_is_odbc3 = EN_is_odbc3(env);
 641     errornum -= LOWEST_DESC_ERROR;
 642     if (errornum < 0 ||
 643         errornum >=
 644         sizeof(Descriptor_sqlstate) / sizeof(Descriptor_sqlstate[0]))
 645         errornum = 1 - LOWEST_DESC_ERROR;
 646     strcpy(error->sqlstate,
 647            env_is_odbc3 ? Descriptor_sqlstate[errornum].
 648            ver3str : Descriptor_sqlstate[errornum].ver2str);
 649     return error;
 650 }
 651 void
 652 DC_log_error(const char *func, const char *desc,
 653              const DescriptorClass * self)
 654 {
 655 #define nullcheck(a) (a ? a : "(NULL)")
 656     if (self)
 657     {
 658         qlog("DESCRIPTOR ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'\n", func, desc, self->__error_number, nullcheck(self->__error_message));
 659         mylog
 660             ("DESCRIPTOR ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'\n",
 661              func, desc, self->__error_number,
 662              nullcheck(self->__error_message));
 663     }
 664 }
 665
 666 /*              Returns the next SQL error information. */
 667 RETCODE SQL_API
 668 PGAPI_DescError(SQLHDESC hdesc,
 669                 SQLSMALLINT RecNumber,
 670                 SQLCHAR FAR * szSqlState,
 671                 SQLINTEGER FAR * pfNativeError,
 672                 SQLCHAR FAR * szErrorMsg,
 673                 SQLSMALLINT cbErrorMsgMax,
 674                 SQLSMALLINT FAR * pcbErrorMsg, UWORD flag)
 675 {
 676     CSTR func = "PGAPI_DescError";
 677     /* CC: return an error of a hdesc  */
 678     DescriptorClass *desc = (DescriptorClass *) hdesc;
 679
 680     mylog("%s RecN=%d\n", func);
 681     desc->pgerror = DC_create_errorinfo(desc);
 682     return ER_ReturnError(&(desc->pgerror), RecNumber, szSqlState,
 683                           pfNativeError, szErrorMsg, cbErrorMsgMax,
 684                           pcbErrorMsg, flag);
 685 }