← Back to branch summary

~ubuntu-branches/ubuntu/raring/wxwidgets2.8/raring

« back to all changes in this revision

Viewing changes to src/iodbc/execute.c

  • Committer: Package Import Robot
  • Author(s): Stéphane Graber
  • Date: 2012-01-07 13:59:25 UTC
  • mfrom: (1.1.9) (5.1.10 sid)
  • Revision ID: package-import@ubuntu.com-20120107135925-2601miy9ullcon9j
Tags: 2.8.12.1-6ubuntu1
https://launchpad.net/bugs/632984
* Resync from Debian, changes that were kept:
  - debian/rules: re-enable mediactrl. This allows libwx_gtk2u_media-2.8 to be
    built, as this is required by some applications (LP: #632984)
  - debian/control: Build-dep on libxt-dev for mediactrl.
  - Patches
    + fix-bashism-in-example
* Add conflict on python-wxgtk2.8 (<< 2.8.12.1-6ubuntu1~) to python-wxversion
  to guarantee upgrade ordering when moving from pycentral to dh_python2.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/iodbc/execute.c
1
 
/*
2
 
 *  execute.c
3
 
 *
4
 
 *  $Id: execute.c 2613 1999-06-01 15:32:12Z VZ $
5
 
 *
6
 
 *  Invoke a query
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
 
static void 
42
 
do_cursoropen (STMT_t FAR * pstmt)
43
 
{
44
 
  RETCODE retcode;
45
 
  SWORD ncol;
46
 
 
47
 
  pstmt->state = en_stmt_executed;
48
 
 
49
 
  retcode = SQLNumResultCols (pstmt, &ncol);
50
 
 
51
 
  if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
52
 
    {
53
 
      if (ncol)
54
 
        {
55
 
          pstmt->state = en_stmt_cursoropen;
56
 
          pstmt->cursor_state = en_stmt_cursor_opened;
57
 
        }
58
 
      else
59
 
        {
60
 
          pstmt->state = en_stmt_executed;
61
 
          pstmt->cursor_state = en_stmt_cursor_no;
62
 
        }
63
 
    }
64
 
}
65
 
 
66
 
 
67
 
RETCODE SQL_API 
68
 
SQLExecute (HSTMT hstmt)
69
 
{
70
 
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
71
 
  HPROC hproc = SQL_NULL_HPROC;
72
 
  RETCODE retcode;
73
 
 
74
 
  int sqlstat = en_00000;
75
 
 
76
 
  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
77
 
    {
78
 
      return SQL_INVALID_HANDLE;
79
 
    }
80
 
 
81
 
  /* check state */
82
 
  if (pstmt->asyn_on == en_NullProc)
83
 
    {
84
 
      switch (pstmt->state)
85
 
         {
86
 
         case en_stmt_allocated:
87
 
           sqlstat = en_S1010;
88
 
           break;
89
 
 
90
 
         case en_stmt_executed:
91
 
           if (!pstmt->prep_state)
92
 
             {
93
 
               sqlstat = en_S1010;
94
 
             }
95
 
           break;
96
 
 
97
 
         case en_stmt_cursoropen:
98
 
           if (!pstmt->prep_state)
99
 
             {
100
 
               sqlstat = en_S1010;
101
 
             }
102
 
           break;
103
 
 
104
 
         case en_stmt_fetched:
105
 
         case en_stmt_xfetched:
106
 
           if (!pstmt->prep_state)
107
 
             {
108
 
               sqlstat = en_S1010;
109
 
             }
110
 
           else
111
 
             {
112
 
               sqlstat = en_24000;
113
 
             }
114
 
           break;
115
 
 
116
 
         case en_stmt_needdata:
117
 
         case en_stmt_mustput:
118
 
         case en_stmt_canput:
119
 
           sqlstat = en_S1010;
120
 
           break;
121
 
 
122
 
         default:
123
 
           break;
124
 
         }
125
 
    }
126
 
  else if (pstmt->asyn_on != en_Execute)
127
 
    {
128
 
      sqlstat = en_S1010;
129
 
    }
130
 
 
131
 
  if (sqlstat == en_00000)
132
 
    {
133
 
      hproc = _iodbcdm_getproc (pstmt->hdbc, en_Execute);
134
 
 
135
 
      if (hproc == SQL_NULL_HPROC)
136
 
        {
137
 
          sqlstat = en_IM001;
138
 
        }
139
 
    }
140
 
 
141
 
  if (sqlstat != en_00000)
142
 
    {
143
 
      PUSHSQLERR (pstmt->herr, sqlstat);
144
 
 
145
 
      return SQL_ERROR;
146
 
    }
147
 
 
148
 
  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Execute,
149
 
    (pstmt->dhstmt))
150
 
 
151
 
  /* stmt state transition */
152
 
  if (pstmt->asyn_on == en_Execute)
153
 
    {
154
 
      switch (retcode)
155
 
         {
156
 
         case SQL_SUCCESS:
157
 
         case SQL_SUCCESS_WITH_INFO:
158
 
         case SQL_NEED_DATA:
159
 
         case SQL_ERROR:
160
 
           pstmt->asyn_on = en_NullProc;
161
 
           break;
162
 
 
163
 
         case SQL_STILL_EXECUTING:
164
 
         default:
165
 
           return retcode;
166
 
         }
167
 
    }
168
 
 
169
 
  switch (pstmt->state)
170
 
     {
171
 
     case en_stmt_prepared:
172
 
       switch (retcode)
173
 
          {
174
 
          case SQL_SUCCESS:
175
 
          case SQL_SUCCESS_WITH_INFO:
176
 
            do_cursoropen (hstmt);
177
 
            break;
178
 
 
179
 
          case SQL_NEED_DATA:
180
 
            pstmt->state = en_stmt_needdata;
181
 
            pstmt->need_on = en_Execute;
182
 
            break;
183
 
 
184
 
          case SQL_STILL_EXECUTING:
185
 
            pstmt->asyn_on = en_Execute;
186
 
            break;
187
 
 
188
 
          default:
189
 
            break;
190
 
          }
191
 
       break;
192
 
 
193
 
     case en_stmt_executed:
194
 
       switch (retcode)
195
 
          {
196
 
          case SQL_ERROR:
197
 
            pstmt->state = en_stmt_allocated;
198
 
            pstmt->cursor_state = en_stmt_cursor_no;
199
 
            pstmt->prep_state = 0;
200
 
            break;
201
 
 
202
 
          case SQL_NEED_DATA:
203
 
            pstmt->state = en_stmt_needdata;
204
 
            pstmt->need_on = en_Execute;
205
 
            break;
206
 
 
207
 
          case SQL_STILL_EXECUTING:
208
 
            pstmt->asyn_on = en_Execute;
209
 
            break;
210
 
 
211
 
          default:
212
 
            break;
213
 
          }
214
 
       break;
215
 
 
216
 
     default:
217
 
       break;
218
 
     }
219
 
 
220
 
  return retcode;
221
 
}
222
 
 
223
 
 
224
 
RETCODE SQL_API 
225
 
SQLExecDirect (
226
 
    HSTMT hstmt,
227
 
    UCHAR FAR * szSqlStr,
228
 
    SDWORD cbSqlStr)
229
 
{
230
 
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
231
 
  HPROC hproc = SQL_NULL_HPROC;
232
 
 
233
 
  int sqlstat = en_00000;
234
 
  RETCODE retcode = SQL_SUCCESS;
235
 
 
236
 
  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
237
 
    {
238
 
      return SQL_INVALID_HANDLE;
239
 
    }
240
 
 
241
 
  /* check arguments */
242
 
  if (szSqlStr == NULL)
243
 
    {
244
 
      sqlstat = en_S1009;
245
 
    }
246
 
  else if (cbSqlStr < 0 && cbSqlStr != SQL_NTS)
247
 
    {
248
 
      sqlstat = en_S1090;
249
 
    }
250
 
 
251
 
  if (sqlstat != en_00000)
252
 
    {
253
 
      PUSHSQLERR (pstmt->herr, sqlstat);
254
 
 
255
 
      return SQL_ERROR;
256
 
    }
257
 
 
258
 
  /* check state */
259
 
  if (pstmt->asyn_on == en_NullProc)
260
 
    {
261
 
      switch (pstmt->state)
262
 
         {
263
 
         case en_stmt_fetched:
264
 
         case en_stmt_xfetched:
265
 
           sqlstat = en_24000;
266
 
           break;
267
 
 
268
 
         case en_stmt_needdata:
269
 
         case en_stmt_mustput:
270
 
         case en_stmt_canput:
271
 
           sqlstat = en_S1010;
272
 
           break;
273
 
 
274
 
         default:
275
 
           break;
276
 
         }
277
 
    }
278
 
  else if (pstmt->asyn_on != en_ExecDirect)
279
 
    {
280
 
      sqlstat = en_S1010;
281
 
    }
282
 
 
283
 
  if (sqlstat != en_00000)
284
 
    {
285
 
      PUSHSQLERR (pstmt->herr, sqlstat);
286
 
 
287
 
      return SQL_ERROR;
288
 
    }
289
 
 
290
 
  hproc = _iodbcdm_getproc (pstmt->hdbc, en_ExecDirect);
291
 
 
292
 
  if (hproc == SQL_NULL_HPROC)
293
 
    {
294
 
      PUSHSQLERR (pstmt->herr, en_IM001);
295
 
 
296
 
      return SQL_ERROR;
297
 
    }
298
 
 
299
 
  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ExecDirect,
300
 
    (pstmt->dhstmt, szSqlStr, cbSqlStr))
301
 
 
302
 
  /* stmt state transition */
303
 
  if (pstmt->asyn_on == en_ExecDirect)
304
 
    {
305
 
      switch (retcode)
306
 
         {
307
 
         case SQL_SUCCESS:
308
 
         case SQL_SUCCESS_WITH_INFO:
309
 
         case SQL_NEED_DATA:
310
 
         case SQL_ERROR:
311
 
           pstmt->asyn_on = en_NullProc;
312
 
           break;
313
 
 
314
 
         case SQL_STILL_EXECUTING:
315
 
         default:
316
 
           return retcode;
317
 
         }
318
 
    }
319
 
 
320
 
  if (pstmt->state <= en_stmt_executed)
321
 
    {
322
 
      switch (retcode)
323
 
         {
324
 
         case SQL_SUCCESS:
325
 
         case SQL_SUCCESS_WITH_INFO:
326
 
           do_cursoropen (hstmt);
327
 
           break;
328
 
 
329
 
         case SQL_NEED_DATA:
330
 
           pstmt->state = en_stmt_needdata;
331
 
           pstmt->need_on = en_ExecDirect;
332
 
           break;
333
 
 
334
 
         case SQL_STILL_EXECUTING:
335
 
           pstmt->asyn_on = en_ExecDirect;
336
 
           break;
337
 
 
338
 
         case SQL_ERROR:
339
 
           pstmt->state = en_stmt_allocated;
340
 
           pstmt->cursor_state = en_stmt_cursor_no;
341
 
           pstmt->prep_state = 0;
342
 
           break;
343
 
 
344
 
         default:
345
 
           break;
346
 
         }
347
 
    }
348
 
 
349
 
  return retcode;
350
 
}
351
 
 
352
 
 
353
 
RETCODE SQL_API 
354
 
SQLPutData (
355
 
    HSTMT hstmt,
356
 
    PTR rgbValue,
357
 
    SDWORD cbValue)
358
 
{
359
 
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
360
 
  HPROC hproc;
361
 
  RETCODE retcode;
362
 
 
363
 
  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
364
 
    {
365
 
      return SQL_INVALID_HANDLE;
366
 
    }
367
 
 
368
 
  /* check argument value */
369
 
  if (rgbValue == NULL && 
370
 
        (cbValue != SQL_DEFAULT_PARAM && cbValue != SQL_NULL_DATA))
371
 
    {
372
 
      PUSHSQLERR (pstmt->herr, en_S1009);
373
 
 
374
 
      return SQL_ERROR;
375
 
    }
376
 
 
377
 
  /* check state */
378
 
  if (pstmt->asyn_on == en_NullProc)
379
 
    {
380
 
      if (pstmt->state <= en_stmt_xfetched)
381
 
        {
382
 
          PUSHSQLERR (pstmt->herr, en_S1010);
383
 
 
384
 
          return SQL_ERROR;
385
 
        }
386
 
    }
387
 
  else if (pstmt->asyn_on != en_PutData)
388
 
    {
389
 
      PUSHSQLERR (pstmt->herr, en_S1010);
390
 
 
391
 
      return SQL_ERROR;
392
 
    }
393
 
 
394
 
  /* call driver */
395
 
  hproc = _iodbcdm_getproc (pstmt->hdbc, en_PutData);
396
 
 
397
 
  if (hproc == SQL_NULL_HPROC)
398
 
    {
399
 
      PUSHSQLERR (pstmt->herr, en_IM001);
400
 
 
401
 
      return SQL_ERROR;
402
 
    }
403
 
 
404
 
  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_PutData,
405
 
    (pstmt->dhstmt, rgbValue, cbValue))
406
 
 
407
 
  /* state transition */
408
 
  if (pstmt->asyn_on == en_PutData)
409
 
    {
410
 
      switch (retcode)
411
 
         {
412
 
         case SQL_SUCCESS:
413
 
         case SQL_SUCCESS_WITH_INFO:
414
 
         case SQL_ERROR:
415
 
           pstmt->asyn_on = en_NullProc;
416
 
           break;
417
 
 
418
 
         case SQL_STILL_EXECUTING:
419
 
         default:
420
 
           return retcode;
421
 
         }
422
 
    }
423
 
 
424
 
  /* must in mustput or canput states */
425
 
  switch (retcode)
426
 
     {
427
 
     case SQL_SUCCESS:
428
 
     case SQL_SUCCESS_WITH_INFO:
429
 
       pstmt->state = en_stmt_canput;
430
 
       break;
431
 
 
432
 
     case SQL_ERROR:
433
 
       switch (pstmt->need_on)
434
 
          {
435
 
          case en_ExecDirect:
436
 
            pstmt->state = en_stmt_allocated;
437
 
            pstmt->need_on = en_NullProc;
438
 
            break;
439
 
 
440
 
          case en_Execute:
441
 
            if (pstmt->prep_state)
442
 
              {
443
 
                pstmt->state = en_stmt_prepared;
444
 
                pstmt->need_on = en_NullProc;
445
 
              }
446
 
            break;
447
 
 
448
 
          case en_SetPos:
449
 
            /* Is this possible ???? */
450
 
            pstmt->state = en_stmt_xfetched;
451
 
            break;
452
 
 
453
 
          default:
454
 
            break;
455
 
          }
456
 
       break;
457
 
 
458
 
     case SQL_STILL_EXECUTING:
459
 
       pstmt->asyn_on = en_PutData;
460
 
       break;
461
 
 
462
 
     default:
463
 
       break;
464
 
     }
465
 
 
466
 
  return retcode;
467
 
}
468
 
 
469
 
 
470
 
RETCODE SQL_API 
471
 
SQLParamData (
472
 
    HSTMT hstmt,
473
 
    PTR FAR * prgbValue)
474
 
{
475
 
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
476
 
  HPROC hproc;
477
 
  RETCODE retcode;
478
 
 
479
 
  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
480
 
    {
481
 
      return SQL_INVALID_HANDLE;
482
 
    }
483
 
 
484
 
  /* check argument */
485
 
 
486
 
  /* check state */
487
 
  if (pstmt->asyn_on == en_NullProc)
488
 
    {
489
 
      if (pstmt->state <= en_stmt_xfetched)
490
 
        {
491
 
          PUSHSQLERR (pstmt->herr, en_S1010);
492
 
 
493
 
          return SQL_ERROR;
494
 
        }
495
 
    }
496
 
  else if (pstmt->asyn_on != en_ParamData)
497
 
    {
498
 
      PUSHSQLERR (pstmt->herr, en_S1010);
499
 
 
500
 
      return SQL_ERROR;
501
 
    }
502
 
 
503
 
  /* call driver */
504
 
  hproc = _iodbcdm_getproc (pstmt->hdbc, en_ParamData);
505
 
 
506
 
  if (hproc == SQL_NULL_HPROC)
507
 
    {
508
 
      PUSHSQLERR (pstmt->herr, en_IM001);
509
 
 
510
 
      return SQL_ERROR;
511
 
    }
512
 
 
513
 
  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ParamData,
514
 
    (pstmt->dhstmt, prgbValue))
515
 
 
516
 
  /* state transition */
517
 
  if (pstmt->asyn_on == en_ParamData)
518
 
    {
519
 
      switch (retcode)
520
 
         {
521
 
         case SQL_SUCCESS:
522
 
         case SQL_SUCCESS_WITH_INFO:
523
 
         case SQL_ERROR:
524
 
           pstmt->asyn_on = en_NullProc;
525
 
           break;
526
 
 
527
 
         case SQL_STILL_EXECUTING:
528
 
         default:
529
 
           return retcode;
530
 
         }
531
 
    }
532
 
 
533
 
  if (pstmt->state < en_stmt_needdata)
534
 
    {
535
 
      return retcode;
536
 
    }
537
 
 
538
 
  switch (retcode)
539
 
     {
540
 
     case SQL_ERROR:
541
 
       switch (pstmt->need_on)
542
 
          {
543
 
          case en_ExecDirect:
544
 
            pstmt->state = en_stmt_allocated;
545
 
            break;
546
 
 
547
 
          case en_Execute:
548
 
            pstmt->state = en_stmt_prepared;
549
 
            break;
550
 
 
551
 
          case en_SetPos:
552
 
            pstmt->state = en_stmt_xfetched;
553
 
            pstmt->cursor_state
554
 
                = en_stmt_cursor_xfetched;
555
 
            break;
556
 
 
557
 
          default:
558
 
            break;
559
 
          }
560
 
       pstmt->need_on = en_NullProc;
561
 
       break;
562
 
 
563
 
     case SQL_SUCCESS:
564
 
     case SQL_SUCCESS_WITH_INFO:
565
 
       switch (pstmt->state)
566
 
          {
567
 
          case en_stmt_needdata:
568
 
            pstmt->state = en_stmt_mustput;
569
 
            break;
570
 
 
571
 
          case en_stmt_canput:
572
 
            switch (pstmt->need_on)
573
 
               {
574
 
               case en_SetPos:
575
 
                 pstmt->state
576
 
                     = en_stmt_xfetched;
577
 
                 pstmt->cursor_state
578
 
                     = en_stmt_cursor_xfetched;
579
 
                 break;
580
 
 
581
 
               case en_ExecDirect:
582
 
               case en_Execute:
583
 
                 do_cursoropen (hstmt);
584
 
                 break;
585
 
 
586
 
               default:
587
 
                 break;
588
 
               }
589
 
            break;
590
 
 
591
 
          default:
592
 
            break;
593
 
          }
594
 
       pstmt->need_on = en_NullProc;
595
 
       break;
596
 
 
597
 
     case SQL_NEED_DATA:
598
 
       pstmt->state = en_stmt_mustput;
599
 
       break;
600
 
 
601
 
     default:
602
 
       break;
603
 
     }
604
 
 
605
 
  return retcode;
606
 
}
607
 
 
608
 
 
609
 
RETCODE SQL_API 
610
 
SQLNumParams (
611
 
    HSTMT hstmt,
612
 
    SWORD FAR * pcpar)
613
 
{
614
 
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
615
 
  HPROC hproc;
616
 
  RETCODE retcode;
617
 
 
618
 
  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
619
 
    {
620
 
      return SQL_INVALID_HANDLE;
621
 
    }
622
 
 
623
 
  /* check argument */
624
 
 
625
 
  /* check state */
626
 
  if (pstmt->asyn_on == en_NullProc)
627
 
    {
628
 
      switch (pstmt->state)
629
 
         {
630
 
         case en_stmt_allocated:
631
 
         case en_stmt_needdata:
632
 
         case en_stmt_mustput:
633
 
         case en_stmt_canput:
634
 
           PUSHSQLERR (pstmt->herr, en_S1010);
635
 
           return SQL_ERROR;
636
 
 
637
 
         default:
638
 
           break;
639
 
         }
640
 
    }
641
 
  else if (pstmt->asyn_on != en_NumParams)
642
 
    {
643
 
      PUSHSQLERR (pstmt->herr, en_S1010);
644
 
 
645
 
      return SQL_ERROR;
646
 
    }
647
 
 
648
 
  /* call driver */
649
 
  hproc = _iodbcdm_getproc (pstmt->hdbc, en_NumParams);
650
 
 
651
 
  if (hproc == SQL_NULL_HPROC)
652
 
    {
653
 
      PUSHSQLERR (pstmt->herr, en_IM001);
654
 
 
655
 
      return SQL_ERROR;
656
 
    }
657
 
 
658
 
  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_NumParams,
659
 
    (pstmt->dhstmt, pcpar))
660
 
 
661
 
  /* state transition */
662
 
  if (pstmt->asyn_on == en_NumParams)
663
 
    {
664
 
      switch (retcode)
665
 
         {
666
 
         case SQL_SUCCESS:
667
 
         case SQL_SUCCESS_WITH_INFO:
668
 
         case SQL_ERROR:
669
 
           break;
670
 
 
671
 
         default:
672
 
           return retcode;
673
 
         }
674
 
    }
675
 
 
676
 
  if (retcode == SQL_STILL_EXECUTING)
677
 
    {
678
 
      pstmt->asyn_on = en_NumParams;
679
 
    }
680
 
 
681
 
  return retcode;
682
 
}
683
 
 
684
 
 
685
 
RETCODE SQL_API 
686
 
SQLDescribeParam (
687
 
    HSTMT hstmt,
688
 
    UWORD ipar,
689
 
    SWORD FAR * pfSqlType,
690
 
    UDWORD FAR * pcbColDef,
691
 
    SWORD FAR * pibScale,
692
 
    SWORD FAR * pfNullable)
693
 
{
694
 
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
695
 
  HPROC hproc;
696
 
  RETCODE retcode;
697
 
 
698
 
  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
699
 
    {
700
 
      return SQL_INVALID_HANDLE;
701
 
    }
702
 
 
703
 
  /* check argument */
704
 
  if (ipar == 0)
705
 
    {
706
 
      PUSHSQLERR (pstmt->herr, en_S1093);
707
 
 
708
 
      return SQL_ERROR;
709
 
    }
710
 
 
711
 
  /* check state */
712
 
  if (pstmt->asyn_on == en_NullProc)
713
 
    {
714
 
      switch (pstmt->state)
715
 
         {
716
 
         case en_stmt_allocated:
717
 
         case en_stmt_needdata:
718
 
         case en_stmt_mustput:
719
 
         case en_stmt_canput:
720
 
           PUSHSQLERR (pstmt->herr, en_S1010);
721
 
           return SQL_ERROR;
722
 
 
723
 
         default:
724
 
           break;
725
 
         }
726
 
    }
727
 
  else if (pstmt->asyn_on != en_DescribeParam)
728
 
    {
729
 
      PUSHSQLERR (pstmt->herr, en_S1010);
730
 
 
731
 
      return SQL_ERROR;
732
 
    }
733
 
 
734
 
  /* call driver */
735
 
  hproc = _iodbcdm_getproc (pstmt->hdbc, en_DescribeParam);
736
 
 
737
 
  if (hproc == SQL_NULL_HPROC)
738
 
    {
739
 
      PUSHSQLERR (pstmt->herr, en_IM001);
740
 
 
741
 
      return SQL_ERROR;
742
 
    }
743
 
 
744
 
  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_DescribeParam,
745
 
    (pstmt->dhstmt, ipar, pfSqlType, pcbColDef, pibScale, pfNullable))
746
 
 
747
 
  /* state transition */
748
 
  if (pstmt->asyn_on == en_DescribeParam)
749
 
    {
750
 
      switch (retcode)
751
 
         {
752
 
         case SQL_SUCCESS:
753
 
         case SQL_SUCCESS_WITH_INFO:
754
 
         case SQL_ERROR:
755
 
           break;
756
 
 
757
 
         default:
758
 
           return retcode;
759
 
         }
760
 
    }
761
 
 
762
 
  if (retcode == SQL_STILL_EXECUTING)
763
 
    {
764
 
      pstmt->asyn_on = en_DescribeParam;
765
 
    }
766
 
 
767
 
  return retcode;
768
 
}