Line data    Source code

       1             : #include "common.h"
       2             : 
       3             : /* protos */
       4             : int do_fetch(CS_COMMAND * cmd);
       5             : CS_RETCODE do_results(CS_COMMAND * cmd, CS_INT * results);
       6             : 
       7             : /* defines */
       8             : #define NUMROWS 5
       9             : 
      10             : /* Testing: Test order of ct_results() */
      11             : int
      12          10 : main(void)
      13             : {
      14             :         CS_CONTEXT *ctx;
      15             :         CS_CONNECTION *conn;
      16             :         CS_COMMAND *cmd;
      17          10 :         int i, verbose = 0;
      18             : 
      19             :         CS_RETCODE results_ret;
      20             : 
      21             :         char query[1024];
      22          10 :         CS_INT insert_results[] = { CS_CMD_SUCCEED, CS_CMD_DONE };
      23          10 :         CS_INT update_results[] = { CS_CMD_SUCCEED, CS_CMD_DONE };
      24          10 :         CS_INT select_results[] = { CS_ROW_RESULT, CS_CMD_DONE };
      25             : 
      26          10 :         printf("%s: Check ordering of returns from cs_results()\n", __FILE__);
      27             :         if (verbose) {
      28             :                 printf("Trying login\n");
      29             :         }
      30          10 :         check_call(try_ctlogin, (&ctx, &conn, &cmd, verbose));
      31             : 
      32          10 :         check_call(run_command, (cmd, "CREATE TABLE #t0004 (id int)"));
      33          60 :         for (i = 0; i < NUMROWS; i++) {
      34          50 :                 sprintf(query, "INSERT #t0004 (id) VALUES (%d)", i);
      35             : 
      36          50 :                 check_call(ct_command, (cmd, CS_LANG_CMD, query, CS_NULLTERM, CS_UNUSED));
      37          50 :                 check_call(ct_send, (cmd));
      38             : 
      39          50 :                 results_ret = do_results(cmd, insert_results);
      40          50 :                 switch ((int) results_ret) {
      41             :                 case CS_END_RESULTS:
      42             :                         break;
      43           0 :                 case CS_FAIL:
      44           0 :                         fprintf(stderr, "ct_results() failed.\n");
      45           0 :                         return 1;
      46             :                         break;
      47           0 :                 default:
      48           0 :                         fprintf(stderr, "ct_results() unexpected return.\n");
      49           0 :                         return 1;
      50             :                 }
      51             :         }
      52             : 
      53          10 :         check_call(ct_command, (cmd, CS_LANG_CMD, "UPDATE #t0004 SET id = id + 1", CS_NULLTERM, CS_UNUSED));
      54          10 :         check_call(ct_send, (cmd));
      55             : 
      56          10 :         results_ret = do_results(cmd, update_results);
      57          10 :         switch ((int) results_ret) {
      58             :         case CS_END_RESULTS:
      59             :                 break;
      60           0 :         case CS_FAIL:
      61           0 :                 fprintf(stderr, "ct_results() failed.\n");
      62           0 :                 return 1;
      63             :                 break;
      64           0 :         default:
      65           0 :                 fprintf(stderr, "ct_results() unexpected return.\n");
      66           0 :                 return 1;
      67             :         }
      68             : 
      69             :         /* single row select */
      70          10 :         check_call(ct_command, (cmd, CS_LANG_CMD, "SELECT * FROM #t0004 WHERE id = 1", CS_NULLTERM, CS_UNUSED));
      71          10 :         check_call(ct_send, (cmd));
      72             : 
      73          10 :         results_ret = do_results(cmd, select_results);
      74          10 :         switch ((int) results_ret) {
      75             :         case CS_END_RESULTS:
      76             :                 break;
      77           0 :         case CS_FAIL:
      78           0 :                 fprintf(stderr, "ct_results() failed.\n");
      79           0 :                 return 1;
      80             :                 break;
      81           0 :         default:
      82           0 :                 fprintf(stderr, "ct_results() unexpected return.\n");
      83           0 :                 return 1;
      84             :         }
      85             :         if (verbose) {
      86             :                 printf("Trying logout\n");
      87             :         }
      88          10 :         check_call(try_ctlogout, (ctx, conn, cmd, verbose));
      89             : 
      90          10 :         return 0;
      91             : }
      92             : 
      93             : int
      94          10 : do_fetch(CS_COMMAND * cmd)
      95             : {
      96          10 : CS_INT count, row_count = 0;
      97             : CS_RETCODE ret;
      98             : 
      99          30 :         while ((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED) {
     100          10 :                 row_count += count;
     101             :         }
     102          10 :         if (ret == CS_ROW_FAIL) {
     103           0 :                 fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
     104           0 :                 return 1;
     105          10 :         } else if (ret == CS_END_DATA) {
     106             :                 return 0;
     107             :         } else {
     108           0 :                 fprintf(stderr, "ct_fetch() unexpected return %d on row %d.\n", ret, row_count);
     109           0 :                 return 1;
     110             :         }
     111             : }
     112             : 
     113             : CS_RETCODE
     114          70 : do_results(CS_COMMAND * cmd, CS_INT * results)
     115             : {
     116             : int result_num;
     117             : CS_RETCODE results_ret, result_type;
     118             : 
     119          70 :         result_num = 0;
     120         280 :         while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
     121         140 :                 printf("result_ret %d result_type %d\n", results_ret, result_type);
     122         140 :                 if (result_type == CS_STATUS_RESULT)
     123           0 :                         continue;
     124         140 :                 if (result_type != results[result_num]) {
     125           0 :                         fprintf(stderr, "ct_results() expected %d received %d\n", results[result_num], result_type);
     126           0 :                         return CS_FAIL;
     127             :                 }
     128         140 :                 switch ((int) result_type) {
     129          10 :                 case CS_ROW_RESULT:
     130          10 :                         if (do_fetch(cmd)) {
     131             :                                 return CS_FAIL;
     132             :                         }
     133             :                         break;
     134             :                 }
     135         140 :                 result_num++;
     136             :         }
     137             :         return results_ret;
     138             : }