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

          Line data    Source code
       1             : #include <config.h>
       2             : 
       3             : #if HAVE_STRING_H
       4             : #include <string.h>
       5             : #endif /* HAVE_STRING_H */
       6             : 
       7             : #include <stdio.h>
       8             : #include <ctpublic.h>
       9             : #include <bkpublic.h>
      10             : #include "common.h"
      11             : 
      12             : /* Testing: array binding of result set */
      13             : int
      14           8 : main(int argc, char *argv[])
      15             : {
      16             :         CS_CONTEXT *ctx;
      17             :         CS_CONNECTION *conn;
      18             :         CS_COMMAND *cmd;
      19             :         CS_BLKDESC *blkdesc;
      20           8 :         int verbose = 0;
      21             : 
      22             :         CS_RETCODE ret;
      23             : 
      24             :         CS_DATAFMT datafmt;
      25           8 :         CS_INT count = 0;
      26             : 
      27             :         CS_INT  col1[2];
      28             :         CS_CHAR col2[2][5];
      29             :         CS_CHAR col3[2][32];
      30             :         CS_INT      lencol1[2];
      31             :         CS_SMALLINT indcol1[2];
      32             :         CS_INT      lencol2[2];
      33             :         CS_SMALLINT indcol2[2];
      34             :         CS_INT      lencol3[2];
      35             :         CS_SMALLINT indcol3[2];
      36             : 
      37             :         int i;
      38             : 
      39             : 
      40           8 :         printf("%s: Retrieve data using array binding \n", __FILE__);
      41             :         if (verbose) {
      42             :                 printf("Trying login\n");
      43             :         }
      44           8 :         ret = try_ctlogin(&ctx, &conn, &cmd, verbose);
      45           8 :         if (ret != CS_SUCCEED) {
      46           0 :                 fprintf(stderr, "Login failed\n");
      47           0 :                 return 1;
      48             :         }
      49             : 
      50             :         /* do not test error */
      51           8 :         ret = run_command(cmd, "IF OBJECT_ID('tempdb..#ctlibarray') IS NOT NULL DROP TABLE #ctlibarray");
      52             : 
      53           8 :         ret = run_command(cmd, "CREATE TABLE #ctlibarray (col1 int null,  col2 char(4) not null, col3 datetime not null)");
      54           8 :         if (ret != CS_SUCCEED)
      55             :                 return 1;
      56             : 
      57           8 :         ret = run_command(cmd, "insert into #ctlibarray values (1, 'AAAA', 'Jan  1 2002 10:00:00AM')");
      58           8 :         if (ret != CS_SUCCEED)
      59             :                 return 1;
      60             : 
      61           8 :         ret = run_command(cmd, "insert into #ctlibarray values (2, 'BBBB', 'Jan  2 2002 10:00:00AM')");
      62           8 :         if (ret != CS_SUCCEED)
      63             :                 return 1;
      64             : 
      65           8 :         ret = run_command(cmd, "insert into #ctlibarray values (3, 'CCCC', 'Jan  3 2002 10:00:00AM')");
      66           8 :         if (ret != CS_SUCCEED)
      67             :                 return 1;
      68             : 
      69           8 :         ret = run_command(cmd, "insert into #ctlibarray values (8, 'DDDD', 'Jan  4 2002 10:00:00AM')");
      70           8 :         if (ret != CS_SUCCEED)
      71             :                 return 1;
      72             : 
      73           8 :         ret = run_command(cmd, "insert into #ctlibarray values (NULL, 'EEEE', 'Jan  5 2002 10:00:00AM')");
      74           8 :         if (ret != CS_SUCCEED)
      75             :                 return 1;
      76             : 
      77           8 :         ret = blk_alloc(conn, BLK_VERSION_100, &blkdesc);
      78           8 :         if (ret != CS_SUCCEED) {
      79           0 :                 fprintf(stderr, "blk_alloc() failed\n");
      80           0 :                 return 1;
      81             :         }
      82             : 
      83           8 :         ret = blk_init(blkdesc, CS_BLK_OUT, "#ctlibarray", CS_NULLTERM );
      84             : 
      85           8 :         if (ret != CS_SUCCEED) {
      86           0 :                 fprintf(stderr, "blk_init() failed\n");
      87           0 :                 return 1;
      88             :         }
      89             : 
      90             : 
      91           8 :         ret = blk_describe(blkdesc, 1, &datafmt);
      92           8 :         if (ret != CS_SUCCEED) {
      93           0 :                 fprintf(stderr, "blk_describe(1) failed");
      94           0 :                 return 1;
      95             :         }
      96             : 
      97           8 :         datafmt.format = CS_FMT_UNUSED;
      98           8 :         if (datafmt.maxlength > 1024) {
      99           0 :                 datafmt.maxlength = 1024;
     100             :         }
     101             : 
     102           8 :         datafmt.count = 2;
     103             : 
     104           8 :         ret = blk_bind(blkdesc, 1, &datafmt, &col1[0], &lencol1[0], &indcol1[0]);
     105           8 :         if (ret != CS_SUCCEED) {
     106           0 :                 fprintf(stderr, "blk_bind() failed\n");
     107           0 :                 return 1;
     108             :         }
     109             : 
     110             : 
     111           8 :         ret = blk_describe(blkdesc, 2, &datafmt);
     112           8 :         if (ret != CS_SUCCEED) {
     113           0 :                 fprintf(stderr, "blk_describe(2) failed");
     114           0 :                 return 1;
     115             :         }
     116             : 
     117           8 :         datafmt.format = CS_FMT_NULLTERM;
     118           8 :         datafmt.maxlength = 5;
     119           8 :         datafmt.count = 2;
     120             : 
     121           8 :         ret = blk_bind(blkdesc, 2, &datafmt, col2[0], &lencol2[0], &indcol2[0]);
     122           8 :         if (ret != CS_SUCCEED) {
     123           0 :                 fprintf(stderr, "blk_bind() failed\n");
     124           0 :                 return 1;
     125             :         }
     126             : 
     127           8 :         ret = blk_describe(blkdesc, 3, &datafmt);
     128           8 :         if (ret != CS_SUCCEED) {
     129           0 :                 fprintf(stderr, "blk_describe() failed");
     130           0 :                 return 1;
     131             :         }
     132             : 
     133           8 :         datafmt.datatype = CS_CHAR_TYPE;
     134           8 :         datafmt.format = CS_FMT_NULLTERM;
     135           8 :         datafmt.maxlength = 32;
     136           8 :         datafmt.count = 2;
     137             : 
     138           8 :         ret = blk_bind(blkdesc, 3, &datafmt, col3[0], &lencol3[0], &indcol3[0]);
     139           8 :         if (ret != CS_SUCCEED) {
     140           0 :                 fprintf(stderr, "ct_bind() failed\n");
     141           0 :                 return 1;
     142             :         }
     143             : 
     144          24 :         while((ret = blk_rowxfer_mult(blkdesc, &count)) == CS_SUCCEED) {
     145          32 :                 for(i = 0; i < count; i++) {
     146          96 :                         printf("retrieved %d (%d,%d) %s (%d,%d) %s (%d,%d)\n", 
     147          32 :                                 col1[i], lencol1[i], indcol1[i],
     148          64 :                                 col2[i], lencol2[i], indcol2[i],
     149          64 :                                 col3[i], lencol3[i], indcol3[i] );
     150             :                 }
     151             :         }
     152           8 :         switch (ret) {
     153             :         case CS_END_DATA:
     154           8 :                 for(i = 0; i < count; i++) {
     155          24 :                         printf("retrieved %d (%d,%d) %s (%d,%d) %s (%d,%d)\n", 
     156           8 :                                 col1[i], lencol1[i], indcol1[i],
     157          16 :                                 col2[i], lencol2[i], indcol2[i],
     158          16 :                                 col3[i], lencol3[i], indcol3[i] );
     159             :                 }
     160             :                 break;
     161           0 :         case CS_FAIL:
     162             :         case CS_ROW_FAIL:
     163           0 :                 fprintf(stderr, "blk_rowxfer_mult() failed\n");
     164           0 :                 return 1;
     165             :         }
     166             : 
     167           8 :         blk_drop(blkdesc);
     168             : 
     169           8 :         ret = try_ctlogout(ctx, conn, cmd, verbose);
     170           8 :         if (ret != CS_SUCCEED) {
     171           0 :                 fprintf(stderr, "Logout failed\n");
     172           0 :                 return 1;
     173             :         }
     174             : 
     175             :         return 0;
     176             : }

Generated by: LCOV version 1.13