LCOV - code coverage report
Current view: top level - src/ctlib/unittests - get_send_data.c (source / functions) Hit Total Coverage
Test: FreeTDS coverage Lines: 75 144 52.1 %
Date: 2025-01-18 12:13:41 Functions: 1 1 100.0 %

          Line data    Source code
       1             : #include <config.h>
       2             : 
       3             : #include <stdarg.h>
       4             : #include <stdio.h>
       5             : 
       6             : #if HAVE_STRING_H
       7             : #include <string.h>
       8             : #endif /* HAVE_STRING_H */
       9             : 
      10             : #include <ctpublic.h>
      11             : #include "common.h"
      12             : 
      13             : static CS_CONNECTION *conn = NULL;
      14             : 
      15             : /* Testing: Retrieve CS_TEXT_TYPE using ct_bind() */
      16             : int
      17           8 : main(int argc, char **argv)
      18             : {
      19             :         CS_CONTEXT *ctx;
      20             :         CS_COMMAND *cmd;
      21           8 :         int i, verbose = 0;
      22             : 
      23             :         CS_RETCODE ret;
      24             :         CS_RETCODE ret2;
      25             :         CS_RETCODE results_ret;
      26             :         CS_INT result_type;
      27             :         CS_INT num_cols;
      28             : 
      29             :         CS_DATAFMT datafmt;
      30             :         CS_INT datalength;
      31             :         CS_SMALLINT ind;
      32           8 :         CS_INT count, row_count = 0;
      33             : 
      34             :         CS_INT  id;
      35             :         CS_CHAR name[600];
      36             :         CS_CHAR *nameptr;
      37             :         CS_INT  getlen;
      38             : 
      39             :         char large_sql[1024];
      40             :         char len600[601];
      41             :         char len800[801];
      42             :         char temp[11];
      43             : 
      44             :         char *textptr;
      45             :         CS_IODESC iodesc;
      46             : 
      47             :         int tds_version;
      48             : 
      49           8 :         len600[0] = 0;
      50           8 :         name[0] = 0;
      51         488 :         for (i = 0; i < 60; i++) {
      52         480 :                 sprintf(temp, "_abcde_%03d", (i + 1) * 10);
      53         480 :                 strcat(len600, temp);
      54             :         }
      55           8 :         len600[600] = '\0';
      56             : 
      57           8 :         len800[0] = 0;
      58         648 :         for (i = 0; i < 80; i++) {
      59         640 :                 sprintf(temp, "_zzzzz_%03d", (i + 1) * 10);
      60         640 :                 strcat(len800, temp);
      61             :         }
      62           8 :         len800[800] = '\0';
      63             : 
      64             : 
      65           8 :         printf("%s: Retrieve CS_TEXT_TYPE using ct_bind()\n", __FILE__);
      66             :         if (verbose) {
      67             :                 printf("Trying login\n");
      68             :         }
      69           8 :         ret = try_ctlogin(&ctx, &conn, &cmd, verbose);
      70           8 :         if (ret != CS_SUCCEED) {
      71           0 :                 fprintf(stderr, "Login failed\n");
      72           0 :                 return 1;
      73             :         }
      74             : 
      75           8 :         ret = ct_con_props(conn, CS_GET, CS_TDS_VERSION, &tds_version, CS_UNUSED, NULL);
      76           8 :         if (ret == CS_SUCCEED) {
      77           8 :                 if (tds_version >= CS_TDS_72) {
      78           2 :                         printf("Protocol TDS7.2+ detected, test not supported\n");
      79           2 :                         try_ctlogout(ctx, conn, cmd, verbose);
      80           2 :                         return 0;
      81             :                 }
      82             :         }
      83             : 
      84           6 :         ret = run_command(cmd, "CREATE TABLE #test_table (id int, name text)");
      85           6 :         if (ret != CS_SUCCEED)
      86             :                 return 1;
      87             : 
      88           6 :         sprintf(large_sql, "INSERT #test_table (id, name) VALUES (2, '%s')", len600);
      89           6 :         ret = run_command(cmd, large_sql);
      90           6 :         if (ret != CS_SUCCEED)
      91             :                 return 1;
      92             : 
      93           6 :         ret = ct_command(cmd, CS_LANG_CMD, "SELECT id, name FROM #test_table", CS_NULLTERM, CS_UNUSED);
      94           6 :         if (ret != CS_SUCCEED) {
      95           0 :                 fprintf(stderr, "ct_command() failed\n");
      96           0 :                 return 1;
      97             :         }
      98           6 :         ret = ct_send(cmd);
      99           6 :         if (ret != CS_SUCCEED) {
     100           0 :                 fprintf(stderr, "ct_send() failed\n");
     101           0 :                 return 1;
     102             :         }
     103          18 :         while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
     104          12 :                 switch ((int) result_type) {
     105             :                 case CS_CMD_SUCCEED:
     106             :                         break;
     107             :                 case CS_CMD_DONE:
     108             :                         break;
     109           0 :                 case CS_CMD_FAIL:
     110           0 :                         fprintf(stderr, "ct_results() result_type CS_CMD_FAIL.\n");
     111           0 :                         return 1;
     112           6 :                 case CS_ROW_RESULT:
     113           6 :                         ret = ct_res_info(cmd, CS_NUMDATA, &num_cols, CS_UNUSED, NULL);
     114           6 :                         if (ret != CS_SUCCEED) {
     115           0 :                                 fprintf(stderr, "ct_res_info() failed");
     116           0 :                                 return 1;
     117             :                         }
     118           6 :                         if (num_cols != 2) {
     119           0 :                                 fprintf(stderr, "num_cols %d != 2", num_cols);
     120           0 :                                 return 1;
     121             :                         }
     122             : 
     123           6 :                         ret = ct_describe(cmd, 1, &datafmt);
     124           6 :                         if (ret != CS_SUCCEED) {
     125           0 :                                 fprintf(stderr, "ct_describe() failed");
     126           0 :                                 return 1;
     127             :                         }
     128           6 :                         datafmt.format = CS_FMT_UNUSED;
     129           6 :                         if (datafmt.maxlength > 1024) {
     130           0 :                                 datafmt.maxlength = 1024;
     131             :                         }
     132           6 :                         ret = ct_bind(cmd, 1, &datafmt, &id, &datalength, &ind);
     133           6 :                         if (ret != CS_SUCCEED) {
     134           0 :                                 fprintf(stderr, "ct_bind() failed\n");
     135           0 :                                 return 1;
     136             :                         }
     137             : 
     138          12 :                         while (((ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count)) == CS_SUCCEED)
     139           6 :                                || (ret == CS_ROW_FAIL)) {
     140           6 :                                 row_count += count;
     141           6 :                                 if (ret == CS_ROW_FAIL) {
     142           0 :                                         fprintf(stderr, "ct_fetch() CS_ROW_FAIL on row %d.\n", row_count);
     143           0 :                                         return 1;
     144             :                                 } else {        /* ret == CS_SUCCEED */
     145             :                                         if (verbose) {
     146             :                                                 printf("id = '%d'\n", id);
     147             :                                         }
     148             : 
     149             :                                         nameptr = name;
     150          18 :                                         while ((ret2 = ct_get_data(cmd, 2 , nameptr, 200, &getlen )) == CS_SUCCEED) {
     151          12 :                                                 nameptr += getlen;
     152             :                                         }
     153           6 :                                         if (ret2 != CS_END_DATA) {
     154           0 :                                                 fprintf(stderr, "ct_get_data() failed\n");
     155           0 :                                                 return 1;
     156             :                                         }
     157             : 
     158           6 :                                         if (memcmp(name, len600, 600)) {
     159           0 :                                                 fprintf(stderr, "Bad return data\n");
     160           0 :                                                 return 1;
     161             :                                         }
     162           6 :                                         printf("%s: Trying ct_data_info on text column\n", __FILE__);
     163             : 
     164           6 :                                         if (ct_data_info(cmd, CS_GET, 2, &iodesc) != CS_SUCCEED) {
     165           0 :                                                 fprintf(stderr, "ct_data_info() failed\n");
     166           0 :                                                 return 1;
     167             :                                         } else {
     168           6 :                                                 printf("datatype = %d\n", iodesc.datatype);
     169           6 :                                                 printf("usertype = %d\n", iodesc.usertype);
     170           6 :                                                 printf("text len = %d\n", iodesc.total_txtlen);
     171           6 :                                                 printf("name     = %*.*s\n", iodesc.namelen, iodesc.namelen, iodesc.name);
     172             :                                         }
     173             :                                 }
     174             :                         }
     175           6 :                         switch ((int) ret) {
     176             :                         case CS_END_DATA:
     177             :                                 break;
     178           0 :                         case CS_FAIL:
     179           0 :                                 fprintf(stderr, "ct_fetch() returned CS_FAIL.\n");
     180           0 :                                 return 1;
     181           0 :                         default:
     182           0 :                                 fprintf(stderr, "ct_fetch() unexpected return.\n");
     183           0 :                                 return 1;
     184             :                         }
     185             :                         break;
     186           0 :                 case CS_COMPUTE_RESULT:
     187           0 :                         fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
     188           0 :                         return 1;
     189           0 :                 default:
     190           0 :                         fprintf(stderr, "ct_results() unexpected result_type.\n");
     191           0 :                         return 1;
     192             :                 }
     193             :         }
     194           6 :         switch ((int) results_ret) {
     195             :         case CS_END_RESULTS:
     196             :                 break;
     197           0 :         case CS_FAIL:
     198           0 :                 fprintf(stderr, "ct_results() failed.\n");
     199           0 :                 return 1;
     200             :                 break;
     201           0 :         default:
     202           0 :                 fprintf(stderr, "ct_results() unexpected return.\n");
     203           0 :                 return 1;
     204             :         }
     205             : 
     206           6 :         if ((ret = ct_command(cmd, CS_SEND_DATA_CMD, NULL, CS_UNUSED, CS_COLUMN_DATA)) != CS_SUCCEED) {
     207           0 :                 fprintf(stderr, "ct_command(CS_SEND_DATA_CMD) failed.\n");
     208           0 :                 return 1;
     209             :         }
     210             : 
     211           6 :         iodesc.total_txtlen = 800;
     212           6 :         iodesc.log_on_update = CS_TRUE;
     213             : 
     214           6 :         if (ct_data_info(cmd, CS_SET, CS_UNUSED, &iodesc) != CS_SUCCEED) {
     215           0 :                 fprintf(stderr, "ct_data_info() failed\n");
     216           0 :                 return 1;
     217             :         }
     218             : 
     219          24 :         for ( i = 0 ; i < 800 ; i += 200 ) {
     220          24 :                 textptr = &len800[i];
     221             : 
     222          24 :                 ret = ct_send_data(cmd, textptr, (CS_INT) 200);
     223          24 :                 if (ret != CS_SUCCEED) {
     224           0 :                         fprintf(stderr, "ct_send_data failed\n");
     225           0 :                         return 1;
     226             :                 }
     227             :         }
     228           6 :         ret = ct_send(cmd);
     229             : 
     230           6 :         if (ret != CS_SUCCEED) {
     231           0 :                 fprintf(stderr, "ct_send failed\n");
     232           0 :                 return 1;
     233             :         }
     234             : 
     235          22 :         while ((results_ret = ct_results(cmd, &result_type)) == CS_SUCCEED) {
     236          16 :                 switch ((int) result_type) {
     237             :                 case CS_CMD_SUCCEED:
     238             :                         break;
     239             :                 case CS_CMD_DONE:
     240             :                         break;
     241           0 :                 case CS_CMD_FAIL:
     242           0 :                         fprintf(stderr, "ct_results() result_type CS_CMD_FAIL.\n");
     243           0 :                         return 1;
     244             :                 case CS_ROW_RESULT:
     245             :                         break;
     246             :                 case CS_PARAM_RESULT:
     247             :                         break;
     248           0 :                 case CS_COMPUTE_RESULT:
     249           0 :                         fprintf(stderr, "ct_results() unexpected CS_COMPUTE_RESULT.\n");
     250           0 :                         return 1;
     251           0 :                 default:
     252           0 :                         fprintf(stderr, "ct_results() unexpected result_type.\n");
     253           0 :                         return 1;
     254             :                 }
     255             :         }
     256           6 :         switch ((int) results_ret) {
     257             :         case CS_END_RESULTS:
     258             :                 break;
     259           0 :         case CS_FAIL:
     260           0 :                 fprintf(stderr, "ct_results() failed.\n");
     261           0 :                 return 1;
     262             :                 break;
     263           0 :         default:
     264           0 :                 fprintf(stderr, "ct_results() unexpected return.\n");
     265           0 :                 return 1;
     266             :         }
     267             : 
     268             :         if (verbose) {
     269             :                 printf("Trying logout\n");
     270             :         }
     271           6 :         ret = try_ctlogout(ctx, conn, cmd, verbose);
     272           6 :         if (ret != CS_SUCCEED) {
     273           0 :                 fprintf(stderr, "Logout failed\n");
     274           0 :                 return 1;
     275             :         }
     276             : 
     277             :         return 0;
     278             : }

Generated by: LCOV version 1.13