LCOV - code coverage report
Current view: top level - src/tds/unittests - dynamic1.c (source / functions) Hit Total Coverage
Test: FreeTDS coverage Lines: 49 75 65.3 %
Date: 2025-04-23 23:01:24 Functions: 3 4 75.0 %

          Line data    Source code
       1             : /* FreeTDS - Library of routines accessing Sybase and Microsoft databases
       2             :  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004  Brian Bruns
       3             :  *
       4             :  * This library is free software; you can redistribute it and/or
       5             :  * modify it under the terms of the GNU Library General Public
       6             :  * License as published by the Free Software Foundation; either
       7             :  * version 2 of the License, or (at your option) any later version.
       8             :  *
       9             :  * This library is distributed in the hope that it will be useful,
      10             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12             :  * Library General Public License for more details.
      13             :  *
      14             :  * You should have received a copy of the GNU Library General Public
      15             :  * License along with this library; if not, write to the
      16             :  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      17             :  * Boston, MA 02111-1307, USA.
      18             :  */
      19             : #include "common.h"
      20             : 
      21             : static int discard_result(TDSSOCKET * tds);
      22             : 
      23             : static void
      24           0 : fatal_error(const char *msg)
      25             : {
      26           0 :         fprintf(stderr, "%s\n", msg);
      27           0 :         exit(1);
      28             : }
      29             : 
      30             : static void
      31          20 : test(TDSSOCKET * tds, TDSDYNAMIC * dyn, TDS_INT n, const char *s)
      32             : {
      33             :         TDSPARAMINFO *params;
      34             :         TDSCOLUMN *curcol;
      35          20 :         int len = (int)strlen(s);
      36             : 
      37          20 :         tds_free_input_params(dyn);
      38             : 
      39          20 :         if (!(params = tds_alloc_param_result(dyn->params)))
      40           0 :                 fatal_error("out of memory!");
      41          20 :         dyn->params = params;
      42             : 
      43          20 :         curcol = params->columns[0];
      44          20 :         tds_set_param_type(tds->conn, curcol, SYBINT4);
      45             : 
      46             :         /* TODO test error */
      47          20 :         tds_alloc_param_data(curcol);
      48          20 :         curcol->column_cur_size = sizeof(TDS_INT);
      49          20 :         memcpy(curcol->column_data, &n, sizeof(n));
      50             : 
      51          20 :         if (!(params = tds_alloc_param_result(dyn->params)))
      52           0 :                 fatal_error("out of memory!");
      53          20 :         dyn->params = params;
      54             : 
      55          20 :         curcol = params->columns[1];
      56          20 :         tds_set_param_type(tds->conn, curcol, SYBVARCHAR);
      57          20 :         curcol->column_size = 40;
      58          20 :         curcol->column_cur_size = len;
      59             : 
      60          20 :         tds_alloc_param_data(curcol);
      61          20 :         memcpy(curcol->column_data, s, len);
      62             : 
      63          20 :         if (tds_submit_execute(tds, dyn) != TDS_SUCCESS)
      64           0 :                 fatal_error("tds_submit_execute() error");
      65          20 :         if (discard_result(tds) != TDS_SUCCESS)
      66           0 :                 fatal_error("tds_submit_execute() output error");
      67          20 : }
      68             : 
      69          10 : TEST_MAIN()
      70             : {
      71             :         TDSLOGIN *login;
      72             :         TDSSOCKET *tds;
      73          10 :         int verbose = 0;
      74          10 :         TDSDYNAMIC *dyn = NULL;
      75             :         int rc;
      76             : 
      77          10 :         printf("%s: Test dynamic queries\n", __FILE__);
      78          10 :         rc = try_tds_login(&login, &tds, __FILE__, verbose);
      79          10 :         if (rc != TDS_SUCCESS)
      80           0 :                 fatal_error("try_tds_login() failed");
      81             : 
      82          10 :         run_query(tds, "DROP TABLE #dynamic1");
      83          10 :         if (run_query(tds, "CREATE TABLE #dynamic1 (i INT, c VARCHAR(40))") != TDS_SUCCESS)
      84           0 :                 fatal_error("creating table error");
      85             : 
      86          10 :         if (tds->cur_dyn)
      87           0 :                 fatal_error("already a dynamic query??");
      88             : 
      89             :         /* prepare to insert */
      90          10 :         if (tds_submit_prepare(tds, "INSERT INTO #dynamic1(i,c) VALUES(?,?)", NULL, &dyn, NULL) != TDS_SUCCESS)
      91           0 :                 fatal_error("tds_submit_prepare() error");
      92          10 :         if (discard_result(tds) != TDS_SUCCESS)
      93           0 :                 fatal_error("tds_submit_prepare() output error");
      94             : 
      95          10 :         if (!dyn)
      96           0 :                 fatal_error("dynamic not present??");
      97             : 
      98             :         /* insert one record */
      99          10 :         test(tds, dyn, 123, "dynamic");
     100             : 
     101             :         /* some test */
     102          10 :         if (run_query(tds, "DECLARE @n INT SELECT @n = COUNT(*) FROM #dynamic1 IF @n <> 1 SELECT 0") != TDS_SUCCESS)
     103           0 :                 fatal_error("checking rows");
     104             : 
     105          10 :         if (run_query(tds, "DECLARE @n INT SELECT @n = COUNT(*) FROM #dynamic1 WHERE i = 123 AND c = 'dynamic' IF @n <> 1 SELECT 0")
     106             :             != TDS_SUCCESS)
     107           0 :                 fatal_error("checking rows 1");
     108             : 
     109             :         /* insert one record */
     110          10 :         test(tds, dyn, 654321, "a longer string");
     111             : 
     112             :         /* some test */
     113          10 :         if (run_query(tds, "DECLARE @n INT SELECT @n = COUNT(*) FROM #dynamic1 IF @n <> 2 SELECT 0") != TDS_SUCCESS)
     114           0 :                 fatal_error("checking rows");
     115             : 
     116          10 :         if (run_query(tds, "DECLARE @n INT SELECT @n = COUNT(*) FROM #dynamic1 WHERE i = 123 AND c = 'dynamic' IF @n <> 1 SELECT 0")
     117             :             != TDS_SUCCESS)
     118           0 :                 fatal_error("checking rows 2");
     119             : 
     120          10 :         if (run_query
     121             :             (tds,
     122             :              "DECLARE @n INT SELECT @n = COUNT(*) FROM #dynamic1 WHERE i = 654321 AND c = 'a longer string' IF @n <> 1 SELECT 0") !=
     123             :             TDS_SUCCESS)
     124           0 :                 fatal_error("checking rows 3");
     125             : 
     126          10 :         if (run_query(tds, "DROP TABLE #dynamic1") != TDS_SUCCESS)
     127           0 :                 fatal_error("dropping table error");
     128             : 
     129          10 :         tds_release_dynamic(&dyn);
     130             : 
     131          10 :         try_tds_logout(login, tds, verbose);
     132          10 :         return 0;
     133             : }
     134             : 
     135             : static int
     136          30 : discard_result(TDSSOCKET * tds)
     137             : {
     138             :         int rc;
     139             :         int result_type;
     140             : 
     141         110 :         while ((rc = tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS)) == TDS_SUCCESS) {
     142             : 
     143          50 :                 switch (result_type) {
     144             :                 case TDS_DONE_RESULT:
     145             :                 case TDS_DONEPROC_RESULT:
     146             :                 case TDS_DONEINPROC_RESULT:
     147             :                 case TDS_DESCRIBE_RESULT:
     148             :                 case TDS_STATUS_RESULT:
     149             :                 case TDS_PARAM_RESULT:
     150             :                         break;
     151           0 :                 default:
     152           0 :                         fprintf(stderr, "Error:  query should not return results\n");
     153           0 :                         return TDS_FAIL;
     154             :                 }
     155             :         }
     156          30 :         if (rc == TDS_FAIL) {
     157           0 :                 fprintf(stderr, "tds_process_tokens() returned TDS_FAIL\n");
     158           0 :                 return TDS_FAIL;
     159          30 :         } else if (rc != TDS_NO_MORE_RESULTS) {
     160           0 :                 fprintf(stderr, "tds_process_tokens() unexpected return\n");
     161           0 :                 return TDS_FAIL;
     162             :         }
     163             : 
     164             :         return TDS_SUCCESS;
     165             : }

Generated by: LCOV version 1.13