src/iodbc/result.c

   1 /*
   2  *  result.c
   3  *
   4  *  $Id$
   5  *
   6  *  Prepare for getting query result
   7  *
   8  *  The iODBC driver manager.
   9  *
  10  *  Copyright (C) 1995 by Ke Jin <kejin@empress.com>
  11  *
  12  *  This library is free software; you can redistribute it and/or
  13  *  modify it under the terms of the GNU Library General Public
  14  *  License as published by the Free Software Foundation; either
  15  *  version 2 of the License, or (at your option) any later version.
  16  *
  17  *  This library is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  *  Library General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU Library General Public
  23  *  License along with this library; if not, write to the Free
  24  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25  */
  26
  27 #include        <config.h>
  28
  29 #include        <isql.h>
  30 #include        <isqlext.h>
  31
  32 #include        <dlproc.h>
  33
  34 #include        <herr.h>
  35 #include        <henv.h>
  36 #include        <hdbc.h>
  37 #include        <hstmt.h>
  38
  39 #include        <itrace.h>
  40
  41 RETCODE SQL_API
  42 SQLBindCol (
  43     HSTMT hstmt,
  44     UWORD icol,
  45     SWORD fCType,
  46     PTR rgbValue,
  47     SDWORD cbValueMax,
  48     SDWORD FAR * pcbValue)
  49 {
  50   STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  51   HPROC hproc = SQL_NULL_HPROC;
  52   RETCODE retcode;
  53
  54   if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
  55     {
  56       return SQL_INVALID_HANDLE;
  57     }
  58
  59   /* check argument */
  60   switch (fCType)
  61      {
  62      case SQL_C_DEFAULT:
  63      case SQL_C_CHAR:
  64      case SQL_C_BINARY:
  65      case SQL_C_BIT:
  66      case SQL_C_TINYINT:
  67      case SQL_C_STINYINT:
  68      case SQL_C_UTINYINT:
  69      case SQL_C_SHORT:
  70      case SQL_C_SSHORT:
  71      case SQL_C_USHORT:
  72      case SQL_C_LONG:
  73      case SQL_C_SLONG:
  74      case SQL_C_ULONG:
  75      case SQL_C_FLOAT:
  76      case SQL_C_DOUBLE:
  77      case SQL_C_DATE:
  78      case SQL_C_TIME:
  79      case SQL_C_TIMESTAMP:
  80        break;
  81
  82      default:
  83        PUSHSQLERR (pstmt->herr, en_S1003);
  84        return SQL_ERROR;
  85      }
  86
  87   if (cbValueMax < 0)
  88     {
  89       PUSHSQLERR (pstmt->herr, en_S1090);
  90
  91       return SQL_ERROR;
  92     }
  93
  94   /* check state */
  95   if (pstmt->state > en_stmt_needdata || pstmt->asyn_on != en_NullProc)
  96     {
  97       PUSHSQLERR (pstmt->herr, en_S1010);
  98       return SQL_ERROR;
  99     }
 100
 101   /* call driver's function */
 102   hproc = _iodbcdm_getproc (pstmt->hdbc, en_BindCol);
 103
 104   if (hproc == SQL_NULL_HPROC)
 105     {
 106       PUSHSQLERR (pstmt->herr, en_IM001);
 107
 108       return SQL_ERROR;
 109     }
 110
 111   CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_BindCol,
 112     (pstmt->dhstmt, icol, fCType, rgbValue, cbValueMax, pcbValue))
 113
 114   return retcode;
 115 }
 116
 117
 118 RETCODE SQL_API
 119 SQLGetCursorName (
 120     HSTMT hstmt,
 121     UCHAR FAR * szCursor,
 122     SWORD cbCursorMax,
 123     SWORD FAR * pcbCursor)
 124 {
 125   STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
 126   HPROC hproc;
 127   RETCODE retcode;
 128
 129   if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
 130     {
 131       return SQL_INVALID_HANDLE;
 132     }
 133
 134   /* check argument */
 135   if (cbCursorMax < (SWORD) 0)
 136     {
 137       PUSHSQLERR (pstmt->herr, en_S1090);
 138
 139       return SQL_ERROR;
 140     }
 141
 142   /* check state */
 143   if (pstmt->state >= en_stmt_needdata || pstmt->asyn_on != en_NullProc)
 144     {
 145       PUSHSQLERR (pstmt->herr, en_S1010);
 146
 147       return SQL_ERROR;
 148     }
 149
 150   if (pstmt->state < en_stmt_cursoropen
 151       && pstmt->cursor_state == en_stmt_cursor_no)
 152     {
 153       PUSHSQLERR (pstmt->herr, en_S1015);
 154
 155       return SQL_ERROR;
 156     }
 157
 158   /* call driver's function */
 159   hproc = _iodbcdm_getproc (pstmt->hdbc, en_GetCursorName);
 160
 161   if (hproc == SQL_NULL_HPROC)
 162     {
 163       PUSHSQLERR (pstmt->herr, en_IM001);
 164
 165       return SQL_ERROR;
 166     }
 167
 168   CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_GetCursorName,
 169     (pstmt->dhstmt, szCursor, cbCursorMax, pcbCursor))
 170
 171   return retcode;
 172 }
 173
 174
 175 RETCODE SQL_API
 176 SQLRowCount (
 177     HSTMT hstmt,
 178     SDWORD FAR * pcrow)
 179 {
 180   STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
 181   HPROC hproc;
 182   RETCODE retcode;
 183
 184   if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
 185     {
 186       return SQL_INVALID_HANDLE;
 187     }
 188
 189   /* check state */
 190   if (pstmt->state >= en_stmt_needdata
 191       || pstmt->state <= en_stmt_prepared
 192       || pstmt->asyn_on != en_NullProc)
 193     {
 194       PUSHSQLERR (pstmt->herr, en_S1010);
 195
 196       return SQL_ERROR;
 197     }
 198
 199   /* call driver */
 200   hproc = _iodbcdm_getproc (pstmt->hdbc, en_RowCount);
 201
 202   if (hproc == SQL_NULL_HPROC)
 203     {
 204       PUSHSQLERR (pstmt->herr, en_IM001);
 205
 206       return SQL_ERROR;
 207     }
 208
 209   CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_RowCount,
 210     (pstmt->dhstmt, pcrow))
 211
 212   return retcode;
 213 }
 214
 215
 216 RETCODE SQL_API
 217 SQLNumResultCols (
 218     HSTMT hstmt,
 219     SWORD FAR * pccol)
 220 {
 221   STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
 222   HPROC hproc;
 223   RETCODE retcode;
 224   SWORD ccol;
 225
 226   if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
 227     {
 228       return SQL_INVALID_HANDLE;
 229     }
 230
 231   /* check state */
 232   if (pstmt->asyn_on == en_NullProc)
 233     {
 234       if (pstmt->state == en_stmt_allocated
 235           || pstmt->state >= en_stmt_needdata)
 236         {
 237           PUSHSQLERR (pstmt->herr, en_S1010);
 238           return SQL_ERROR;
 239         }
 240     }
 241   else if (pstmt->asyn_on != en_NumResultCols)
 242     {
 243       PUSHSQLERR (pstmt->herr, en_S1010);
 244
 245       return SQL_ERROR;
 246     }
 247
 248   /* call driver */
 249   hproc = _iodbcdm_getproc (pstmt->hdbc, en_NumResultCols);
 250
 251   if (hproc == SQL_NULL_HPROC)
 252     {
 253       PUSHSQLERR (pstmt->herr, en_IM001);
 254
 255       return SQL_ERROR;
 256     }
 257
 258   CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_NumResultCols,
 259     (pstmt->dhstmt, &ccol))
 260
 261   /* state transition */
 262   if (pstmt->asyn_on == en_NumResultCols)
 263     {
 264       switch (retcode)
 265          {
 266          case SQL_SUCCESS:
 267          case SQL_SUCCESS_WITH_INFO:
 268          case SQL_ERROR:
 269            pstmt->asyn_on = en_NullProc;
 270
 271          case SQL_STILL_EXECUTING:
 272          default:
 273            break;
 274          }
 275     }
 276
 277   switch (retcode)
 278      {
 279      case SQL_SUCCESS:
 280      case SQL_SUCCESS_WITH_INFO:
 281        break;
 282
 283      case SQL_STILL_EXECUTING:
 284        ccol = 0;
 285        pstmt->asyn_on = en_NumResultCols;
 286        break;
 287
 288      default:
 289        ccol = 0;
 290        break;
 291      }
 292
 293   if (pccol)
 294     {
 295       *pccol = ccol;
 296     }
 297
 298   return retcode;
 299 }
 300
 301
 302 RETCODE SQL_API
 303 SQLDescribeCol (
 304     HSTMT hstmt,
 305     UWORD icol,
 306     UCHAR FAR * szColName,
 307     SWORD cbColNameMax,
 308     SWORD FAR * pcbColName,
 309     SWORD FAR * pfSqlType,
 310     UDWORD FAR * pcbColDef,
 311     SWORD FAR * pibScale,
 312     SWORD FAR * pfNullable)
 313 {
 314   STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
 315   HPROC hproc;
 316   RETCODE retcode;
 317   int sqlstat = en_00000;
 318
 319   if (hstmt == SQL_NULL_HSTMT
 320       || pstmt->hdbc == SQL_NULL_HDBC)
 321     {
 322       return SQL_INVALID_HANDLE;
 323     }
 324
 325   /* check arguments */
 326   if (icol == 0)
 327     {
 328       sqlstat = en_S1002;
 329     }
 330   else if (cbColNameMax < 0)
 331     {
 332       sqlstat = en_S1090;
 333     }
 334
 335   if (sqlstat != en_00000)
 336     {
 337       PUSHSQLERR (pstmt->herr, sqlstat);
 338
 339       return SQL_ERROR;
 340     }
 341
 342   /* check state */
 343   if (pstmt->asyn_on == en_NullProc)
 344     {
 345       if (pstmt->asyn_on == en_stmt_allocated
 346           || pstmt->asyn_on >= en_stmt_needdata)
 347         {
 348           sqlstat = en_S1010;
 349         }
 350     }
 351   else if (pstmt->asyn_on != en_DescribeCol)
 352     {
 353       sqlstat = en_S1010;
 354     }
 355
 356   if (sqlstat != en_00000)
 357     {
 358       PUSHSQLERR (pstmt->herr, sqlstat);
 359
 360       return SQL_ERROR;
 361     }
 362
 363   /* call driver */
 364   hproc = _iodbcdm_getproc (pstmt->hdbc, en_DescribeCol);
 365
 366   if (hproc == SQL_NULL_HPROC)
 367     {
 368       PUSHSQLERR (pstmt->herr, en_IM001);
 369
 370       return SQL_ERROR;
 371     }
 372
 373   CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_DescribeCol,
 374     (pstmt->dhstmt, icol, szColName, cbColNameMax, pcbColName,
 375       pfSqlType, pcbColDef, pibScale, pfNullable))
 376
 377   /* state transition */
 378   if (pstmt->asyn_on == en_DescribeCol)
 379     {
 380       switch (retcode)
 381          {
 382          case SQL_SUCCESS:
 383          case SQL_SUCCESS_WITH_INFO:
 384          case SQL_ERROR:
 385            pstmt->asyn_on = en_NullProc;
 386            break;
 387
 388          default:
 389            return retcode;
 390          }
 391     }
 392
 393   switch (pstmt->state)
 394      {
 395      case en_stmt_prepared:
 396      case en_stmt_cursoropen:
 397      case en_stmt_fetched:
 398      case en_stmt_xfetched:
 399        if (retcode == SQL_STILL_EXECUTING)
 400          {
 401            pstmt->asyn_on = en_DescribeCol;
 402          }
 403        break;
 404
 405      default:
 406        break;
 407      }
 408
 409   return retcode;
 410 }
 411
 412
 413 RETCODE SQL_API
 414 SQLColAttributes (
 415     HSTMT hstmt,
 416     UWORD icol,
 417     UWORD fDescType,
 418     PTR rgbDesc,
 419     SWORD cbDescMax,
 420     SWORD FAR * pcbDesc,
 421     SDWORD FAR * pfDesc)
 422 {
 423   STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
 424   HPROC hproc;
 425   RETCODE retcode;
 426   int sqlstat = en_00000;
 427
 428   if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
 429     {
 430       return SQL_INVALID_HANDLE;
 431     }
 432
 433   /* check arguments */
 434   if (icol == 0 && fDescType != SQL_COLUMN_COUNT)
 435     {
 436       sqlstat = en_S1002;
 437     }
 438   else if (cbDescMax < 0)
 439     {
 440       sqlstat = en_S1090;
 441     }
 442   else if (                     /* fDescType < SQL_COLATT_OPT_MIN || *//* turnoff warning */
 443         (fDescType > SQL_COLATT_OPT_MAX
 444           && fDescType < SQL_COLUMN_DRIVER_START))
 445     {
 446       sqlstat = en_S1091;
 447     }
 448
 449   if (sqlstat != en_00000)
 450     {
 451       PUSHSQLERR (pstmt->herr, sqlstat);
 452
 453       return SQL_ERROR;
 454     }
 455
 456   /* check state */
 457   if (pstmt->asyn_on == en_NullProc)
 458     {
 459       if (pstmt->asyn_on == en_stmt_allocated
 460           || pstmt->asyn_on >= en_stmt_needdata)
 461         {
 462           sqlstat = en_S1010;
 463         }
 464     }
 465   else if (pstmt->asyn_on != en_ColAttributes)
 466     {
 467       sqlstat = en_S1010;
 468     }
 469
 470   if (sqlstat != en_00000)
 471     {
 472       PUSHSQLERR (pstmt->herr, sqlstat);
 473
 474       return SQL_ERROR;
 475     }
 476
 477   /* call driver */
 478   hproc = _iodbcdm_getproc (pstmt->hdbc, en_ColAttributes);
 479
 480   if (hproc == SQL_NULL_HPROC)
 481     {
 482       PUSHSQLERR (pstmt->herr, en_IM001);
 483
 484       return SQL_ERROR;
 485     }
 486
 487   CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ColAttributes,
 488     (pstmt->dhstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc))
 489
 490   /* state transition */
 491   if (pstmt->asyn_on == en_ColAttributes)
 492     {
 493       switch (retcode)
 494          {
 495          case SQL_SUCCESS:
 496          case SQL_SUCCESS_WITH_INFO:
 497          case SQL_ERROR:
 498            pstmt->asyn_on = en_NullProc;
 499            break;
 500
 501          default:
 502            return retcode;
 503          }
 504     }
 505
 506   switch (pstmt->state)
 507      {
 508      case en_stmt_prepared:
 509      case en_stmt_cursoropen:
 510      case en_stmt_fetched:
 511      case en_stmt_xfetched:
 512        if (retcode == SQL_STILL_EXECUTING)
 513          {
 514            pstmt->asyn_on = en_ColAttributes;
 515          }
 516        break;
 517
 518      default:
 519        break;
 520      }
 521
 522   return retcode;
 523 }