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           8 : main(void)
      13             : {
      14             :         CS_CONTEXT *ctx;
      15             :         CS_CONNECTION *conn;
      16             :         CS_COMMAND *cmd;
      17           8 :         int i, verbose = 0;
      18             : 
      19             :         CS_RETCODE results_ret;
      20             : 
      21             :         char query[1024];
      22           8 :         CS_INT insert_results[] = { CS_CMD_SUCCEED, CS_CMD_DONE };
      23           8 :         CS_INT update_results[] = { CS_CMD_SUCCEED, CS_CMD_DONE };
      24           8 :         CS_INT select_results[] = { CS_ROW_RESULT, CS_CMD_DONE };
      25             : 
      26           8 :         printf("%s: Check ordering of returns from cs_results()\n", __FILE__);
      27             :         if (verbose) {
      28             :                 printf("Trying login\n");
      29             :         }
      30           8 :         check_call(try_ctlogin, (&ctx, &conn, &cmd, verbose));
      31             : 
      32           8 :         check_call(run_command, (cmd, "CREATE TABLE #t0004 (id int)"));
      33          48 :         for (i = 0; i < NUMROWS; i++) {
      34          40 :                 sprintf(query, "INSERT #t0004 (id) VALUES (%d)", i);
      35             : 
      36          40 :                 check_call(ct_command, (cmd, CS_LANG_CMD, query, CS_NULLTERM, CS_UNUSED));
      37          40 :                 check_call(ct_send, (cmd));
      38             : 
      39          40 :                 results_ret = do_results(cmd, insert_results);
      40          40 :                 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           8 :         check_call(ct_command, (cmd, CS_LANG_CMD, "UPDATE #t0004 SET id = id + 1", CS_NULLTERM, CS_UNUSED));
      54           8 :         check_call(ct_send, (cmd));
      55             : 
      56           8 :         results_ret = do_results(cmd, update_results);
      57           8 :         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           8 :         check_call(ct_command, (cmd, CS_LANG_CMD, "SELECT * FROM #t0004 WHERE id = 1", CS_NULLTERM, CS_UNUSED));
      71           8 :         check_call(ct_send, (cmd));
      72             : 
      73           8 :         results_ret = do_results(cmd, select_results);
      74           8 :         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           8 :         check_call(try_ctlogout, (ctx, conn, cmd, verbose));
      89             : 
      90           8 :         return 0;
      91             : }
      92             : 
      93             : int
      94           8 : do_fetch(CS_COMMAND * cmd)
      95             : {
      96           8 : CS_INT count, row_count = 0;
      97             : CS_RETCODE ret;
      98             : 
      99          24 :         while ((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED) {
     100           8 :                 row_count += count;
     101             :         }
     102           8 :         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           8 :         } 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          56 : do_results(CS_COMMAND * cmd, CS_INT * results)
     115             : {
     116             : int result_num;
     117             : CS_RETCODE results_ret, result_type;
     118             : 
     119          56 :         result_num = 0;
     120         224 :         while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
     121         112 :                 printf("result_ret %d result_type %d\n", results_ret, result_type);
     122         112 :                 if (result_type == CS_STATUS_RESULT)
     123           0 :                         continue;
     124         112 :                 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         112 :                 switch ((int) result_type) {
     129           8 :                 case CS_ROW_RESULT:
     130           8 :                         if (do_fetch(cmd)) {
     131             :                                 return CS_FAIL;
     132             :                         }
     133             :                         break;
     134             :                 }
     135         112 :                 result_num++;
     136             :         }
     137             :         return results_ret;
     138             : }