开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
dblib.c
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：72k
源码类别：

生物技术

开发平台：

C/C++

dblib.c：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: dblib.c,v $
  4.  * PRODUCTION Revision 1000.1  2003/11/17 22:20:19  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [ORIGINAL] Dev-tree R1.7
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* FreeTDS - Library of routines accessing Sybase and Microsoft databases
  11.  * Copyright (C) 1998-1999  Brian Bruns
  12.  *
  13.  * This library is free software; you can redistribute it and/or
  14.  * modify it under the terms of the GNU Library General Public
  15.  * License as published by the Free Software Foundation; either
  16.  * version 2 of the License, or (at your option) any later version.
  17.  *
  18.  * This library is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21.  * Library General Public License for more details.
  22.  *
  23.  * You should have received a copy of the GNU Library General Public
  24.  * License along with this library; if not, write to the
  25.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  26.  * Boston, MA 02111-1307, USA.
  27.  */
  29. #include <tds_config.h>
  30. #include "tdsutil.h"
  31. #include "tds.h"
  32. #include "sybfront.h"
  33. #include "sybdb.h"
  34. #include "dblib.h"
  35. #include "tdsconvert.h"
  36. #include <unistd.h>
  37. #include <stdlib.h>
  38. #include <assert.h>
  39. #include <time.h>
  40. #include <stdarg.h>
  42. static char  software_version[]   = "$Id: dblib.c,v 1000.1 2003/11/17 22:20:19 gouriano Exp $";
  43. static void *no_unused_var_warn[] = {software_version,
  44.                                      no_unused_var_warn};
  46. #if !HAVE_VASPRINTF
  47. int vasprintf(char **ret, const char *fmt, va_list ap);
  48. #endif
  50. static int _db_get_server_type(int bindtype);
  51. static int _get_printable_size(TDSCOLINFO *colinfo);
  53. static void _set_null_value(DBPROCESS *dbproc, BYTE *varaddr, int datatype, int maxlen);
  55. /* info/err message handler functions (or rather pointers to them) */
  56. int (*g_dblib_msg_handler)() = NULL;
  57. int (*g_dblib_err_handler)() = NULL;
  59. typedef struct dblib_context {
  60. TDSCONTEXT *tds_ctx;
  61. TDSSOCKET *connection_list[TDS_MAX_CONN];
  62. } DBLIBCONTEXT;
  64. static DBLIBCONTEXT *g_dblib_ctx = NULL;
  65. #ifdef TDS42
  66. int g_dblib_version = DBVERSION_42;
  67. #endif
  68. #ifdef TDS50
  69. int g_dblib_version = DBVERSION_100;
  70. #endif
  71. #ifdef TDS46
  72. int g_dblib_version = DBVERSION_46;
  73. #endif
  74. /* I'm taking some liberties here, there is no such thing as DBVERSION_70 in 
  75. ** the real world, so we make it up as we go along */
  76. #ifdef TDS70
  77. int g_dblib_version = DBVERSION_70;
  78. #endif
  79. #ifdef TDS80
  80. int g_dblib_version = DBVERSION_80;
  81. #endif
  83. static int dblib_add_connection(DBLIBCONTEXT *ctx, TDSSOCKET *tds)
  84. {
  85. int i = 0;
  87. while (i<TDS_MAX_CONN && ctx->connection_list[i]) i++;
  88. if (i==TDS_MAX_CONN) {
  89. fprintf(stderr,"Max connections reached, increase value of TDS_MAX_CONNn");
  90. return 1;
  91. } else {
  92. ctx->connection_list[i] = tds;
  93. return 0;
  94. }
  95. }
  97. static void dblib_del_connection(DBLIBCONTEXT *ctx, TDSSOCKET *tds)
  98. {
  99. int i=0;
  101. while (i<TDS_MAX_CONN && ctx->connection_list[i]!=tds) i++;
  102. if (i==TDS_MAX_CONN) {
  103. /* connection wasn't on the free list...now what */
  104. } else {
  105. /* remove it */
  106. ctx->connection_list[i] = NULL;
  107. }
  108. }
  110. static void buffer_init(DBPROC_ROWBUF *buf)
  111. {
  112.    memset(buf, 0x0, sizeof(*buf));
  114. #ifndef NCBI_FTDS
  115.    buf->buffering_on     = 0;
  116.    buf->first_in_buf     = 0;
  117. #endif
  118.    buf->newest           = -1;
  119. #ifndef NCBI_FTDS
  120.    buf->oldest           = 0;
  121.    buf->elcount          = 0;
  122.    buf->element_size     = 0;
  123.    buf->rows_in_buf      = 0;
  124.    buf->rows             = NULL;
  125. #endif
  126.    buf->next_row         = 1;
  127. } /* buffer_init()  */
  129. static void buffer_clear(DBPROC_ROWBUF *buf)
  130. {
  131.    buf->next_row         = 1;
  132.    buf->first_in_buf     = 0;
  133.    buf->newest           = -1;
  134. #ifdef NCBI_FTDS
  135.    buf->rows_offset      = 0;
  136. #endif
  137.    buf->oldest           = 0;
  138.    buf->rows_in_buf      = 0;
  139.    if (buf->rows) {
  140.       free(buf->rows);
  141.    }
  142.    buf->rows             = NULL;
  143. } /* buffer_clear()  */
  146. static void buffer_free(DBPROC_ROWBUF *buf)
  147. {
  148.    if (buf->rows != NULL)
  149.    {
  150.       free(buf->rows);
  151.    }
  152.    buf->rows = NULL;
  153. } /* clear_buffer()  */
  155. static void buffer_delete_rows(
  156.    DBPROC_ROWBUF *buf,    /* (U) buffer to clear             */
  157.    int            count)  /* (I) number of elements to purge */
  158. {
  159.    assert(count <= buf->elcount); /* possibly a little to pedantic */
  161.    if (count > buf->rows_in_buf)
  162.    {
  163.       count = buf->rows_in_buf;
  164.    }
  166.    
  167.    buf->oldest        = (buf->oldest + count) % buf->elcount;
  168.    buf->rows_in_buf  -= count;
  169.    buf->first_in_buf  = count==buf->rows_in_buf ? buf->next_row-1 : buf->first_in_buf + count;
  171.    
  172.    assert(buf->first_in_buf >= 0);
  173. } /* buffer_delete_rows() */
  176. static int buffer_start_resultset(
  177.    DBPROC_ROWBUF *buf,          /* (U) buffer to clear */
  178.    int            element_size) /*                     */
  179. {
  180.    int    space_needed = -1;
  182.    assert(element_size > 0);
  184.    if (buf->rows != NULL)
  185.    {
  186. #ifndef NCBI_FTDS
  187.       memset(buf->rows, 0xad, buf->element_size*buf->rows_in_buf);
  188. #endif
  189.       free(buf->rows);
  190.    }
  192.    buf->first_in_buf     = 0;
  193.    buf->next_row         = 1;
  194.    buf->newest           = -1;
  195. #ifdef NCBI_FTDS
  196.    buf->rows_offset     = 0;
  197. #endif
  198.    buf->oldest           = 0;
  199.    buf->elcount          = buf->buffering_on ? buf->elcount : 1;
  200.    buf->element_size     = element_size;
  201.    buf->rows_in_buf      = 0;
  202.    space_needed          = element_size * buf->elcount;   
  203.    buf->rows             = malloc(space_needed);
  205.    return buf->rows==NULL ? FAIL : SUCCEED;
  206. } /* buffer_start_resultset()  */
  209. static void buffer_delete_all_rows(
  210.    DBPROC_ROWBUF *buf)    /* (U) buffer to clear */
  211. {
  212.    buffer_delete_rows(buf, buf->rows_in_buf);
  213. } /* delete_all_buffer_rows() */
  215. static int buffer_index_of_resultset_row(
  216.    DBPROC_ROWBUF *buf,         /* (U) buffer to clear                 */
  217.    int            row_number)  /* (I)                                 */
  218. {
  219.    int   result = -1;
  221.    if (row_number < buf->first_in_buf)
  222.    {
  223.       result = -1;
  224.    }
  225.    else if (row_number > ((buf->rows_in_buf + buf->first_in_buf) -1))
  226.    {
  227.       result = -1;
  228.    }
  229.    else
  230.    {
  231.       result = ((row_number - buf->first_in_buf) 
  232.                 + buf->oldest) % buf->elcount;
  233.    }
  234.    return result;
  235. } /* buffer_index_of_resultset_row()  */
  238. static void *buffer_row_address(
  239.    DBPROC_ROWBUF *buf,    /* (U) buffer to clear                 */
  240.    int            index)  /* (I) raw index of row to return      */
  241. {
  242.    void   *result = NULL;
  244.    assert(index >= 0);
  245.    assert(index < buf->elcount);
  247.    if (index>=buf->elcount || index<0)
  248.    {
  249.       result = NULL;
  250.    }
  251.    else
  252.    {
  253.       int   offset = buf->element_size * (index % buf->elcount);
  254.       result = (char *)buf->rows + offset;
  255.    }
  256.    return result;
  257. } /* buffer_row_address()  */
  259. static void buffer_add_row(
  260.    DBPROC_ROWBUF *buf,       /* (U) buffer to add row into  */
  261.    void          *row,       /* (I) pointer to the row data */
  262.    int            row_size)
  263. {
  264.    void   *dest = NULL;
  266.    assert(row_size > 0);
  267.    assert(row_size == buf->element_size);
  268.    
  269.    assert(buf->elcount >= 1);
  270. #ifdef NCBI_FTDS
  271.    if(++buf->newest >= buf->elcount){
  272. buf->newest=0;
  273.    }
  274.    if(buf->newest==0){
  275. buf->rows_offset=0;
  276.    } else {
  277. buf->rows_offset += buf->element_size;
  278.    }
  279.    /***buf->newest = (buf->newest+1)%buf->elcount;**/
  280.    if (buf->rows_in_buf==0 && buf->first_in_buf==0)
  281.    {
  282.       buf->first_in_buf = 1;
  283.    }
  284.    buf->rows_in_buf++;
  286.    /* 
  287.     * if we have wrapped around we need to adjust oldest
  288.     * and rows_in_buf
  289.     */
  290.    if (buf->rows_in_buf > buf->elcount)
  291.    {
  292.       buf->oldest = (buf->oldest + 1) % buf->elcount;
  293.       buf->first_in_buf++;
  294.       buf->rows_in_buf--;
  295.    }
  296.    
  297.    assert(buf->elcount >= buf->rows_in_buf);
  298.    assert( buf->rows_in_buf==0
  299.            || (((buf->oldest+buf->rows_in_buf) - 1)%buf->elcount)==buf->newest);
  300.    assert(buf->rows_in_buf>0 || (buf->first_in_buf==buf->next_row-1));
  301.    assert(buf->rows_in_buf==0 || 
  302.           (buf->first_in_buf<=buf->next_row));
  303.    assert(buf->next_row-1 <= (buf->first_in_buf + buf->rows_in_buf));
  306. /*   dest = buffer_row_address(buf, buf->newest);
  307.    memcpy(dest, row, row_size);*/
  308.    memcpy((char*)buf->rows + buf->rows_offset,row,row_size);
  309. #else
  310.    
  311.    buf->newest = (buf->newest + 1) % buf->elcount;
  312.    if (buf->rows_in_buf==0 && buf->first_in_buf==0)
  313.    {
  314.       buf->first_in_buf = 1;
  315.    }
  316.    buf->rows_in_buf++;
  318.    /* 
  319.     * if we have wrapped around we need to adjust oldest
  320.     * and rows_in_buf
  321.     */
  322.    if (buf->rows_in_buf > buf->elcount)
  323.    {
  324.       buf->oldest = (buf->oldest + 1) % buf->elcount;
  325.       buf->first_in_buf++;
  326.       buf->rows_in_buf--;
  327.    }
  328.    
  329.    assert(buf->elcount >= buf->rows_in_buf);
  330.    assert( buf->rows_in_buf==0
  331.            || (((buf->oldest+buf->rows_in_buf) - 1)%buf->elcount)==buf->newest);
  332.    assert(buf->rows_in_buf>0 || (buf->first_in_buf==buf->next_row-1));
  333.    assert(buf->rows_in_buf==0 || 
  334.           (buf->first_in_buf<=buf->next_row));
  335.    assert(buf->next_row-1 <= (buf->first_in_buf + buf->rows_in_buf));
  337.    dest = buffer_row_address(buf, buf->newest);
  338.    memcpy(dest, row, row_size);
  339. #endif
  340. } /* buffer_add_row()  */
  342. static int buffer_is_full(DBPROC_ROWBUF *buf)
  343. {
  344.    return buf->rows_in_buf==buf->elcount;
  345. } /* buffer_is_full()  */
  347. static void buffer_set_buffering(
  348.    DBPROC_ROWBUF *buf,      /* (U)                                         */
  349.    int            buf_size) /* (I) number of rows to buffer, 0 to turn off */
  350. {
  351.    /* XXX If the user calls this routine in the middle of 
  352.     * a result set and changes the size of the buffering
  353.     * they are pretty much toast.
  354.     *
  355.     * We need to figure out what to do if the user shrinks the 
  356.     * size of the row buffer.  What rows should be thrown out, 
  357.     * what should happen to the current row, etc?
  358.     */
  360.    assert(buf_size >= 0);
  362.    if (buf_size < 0)
  363.    {
  364.       /* XXX is it okay to ignore this? */
  365.    }
  366.    else if (buf_size == 0)
  367.    {
  368.       buf->buffering_on = 0;
  369.       buf->elcount = 1;
  370.       buffer_delete_all_rows(buf);
  371.    }
  372.    else
  373.    {
  374.       buf->buffering_on = 1;
  375.       buffer_clear(buf);
  376.       buffer_free(buf);
  377.       buf->elcount = buf_size;
  378.       if (buf->element_size > 0)
  379.       {
  380.          buf->rows = malloc(buf->element_size * buf->elcount);
  381.       }
  382.       else
  383.       {
  384.          buf->rows = NULL;
  385.       }
  386.    }
  387. } /* buffer_set_buffering()  */
  389. static void buffer_transfer_bound_data(
  390.    DBPROC_ROWBUF *buf,      /* (U)                                         */
  391.    DBPROCESS     *dbproc,   /* (I)                                         */
  392.    int            row_num)  /* (I) resultset row number                    */
  393. {
  394. int            i;
  395. TDSCOLINFO    *curcol;
  396. TDSRESULTINFO *resinfo;
  397. TDSSOCKET     *tds;
  398. int            srctype;
  399. BYTE          *src;
  400. int            desttype;
  401. int            destlen;
  402. /* this should probably go somewhere else */
  403.    
  404. tds     = (TDSSOCKET *) dbproc->tds_socket;
  405. resinfo = tds->res_info;
  406.    
  407. for (i=0;i<resinfo->num_cols;i++) {
  408. curcol = resinfo->columns[i];
  409. if (curcol->column_nullbind) {
  410. if (tds_get_null(resinfo->current_row,i)) {
  411. *((DBINT *)curcol->column_nullbind)=-1;
  412. } else {
  413. *((DBINT *)curcol->column_nullbind)=0;
  414. }
  415. }
  416. if (curcol->varaddr) {
  417.   DBINT srclen = -1;
  418. int   index = buffer_index_of_resultset_row(buf, row_num);
  419.          
  420. assert (index >= 0);
  421. /* XXX now what? */
  423. if (is_blob_type(curcol->column_type)) {
  424. srclen =  curcol->column_textsize;
  425. src = (BYTE *)curcol->column_textvalue;
  426. } else {
  427. src = ((BYTE *)buffer_row_address(buf, index)) 
  428. + curcol->column_offset;
  429. }
  430. desttype = _db_get_server_type(curcol->column_bindtype);
  431. srctype = tds_get_conversion_type(curcol->column_type,
  432. curcol->column_size);
  434. if (tds_get_null(resinfo->current_row,i)) {
  435. _set_null_value(dbproc, curcol->varaddr, desttype, 
  436. curcol->column_bindlen);
  437.    } else {
  439.              if (curcol->column_bindtype == STRINGBIND)
  440.                destlen = -2;
  441.             else if (curcol->column_bindtype == NTBSTRINGBIND)
  442.                     destlen = -1;
  443.                  else
  444.                     destlen = curcol->column_bindlen;
  446.          dbconvert(dbproc,
  447.       srctype, /* srctype  */
  448.       src, /* src      */
  449.       srclen, /* srclen   */
  450.       desttype, /* desttype */
  451.       (BYTE *)curcol->varaddr, /* dest     */
  452.       destlen);        /* destlen  */
  453. } /* else not null */
  454. }
  455. }
  456. } /* buffer_transfer_bound_data()  */
  458. RETCODE dbinit()
  459. {
  460. /* DBLIBCONTEXT stores a list of current connections so they may be closed
  461. ** with dbexit() */
  462. g_dblib_ctx = (DBLIBCONTEXT *) malloc(sizeof(DBLIBCONTEXT));
  463. memset(g_dblib_ctx,'',sizeof(DBLIBCONTEXT));
  465. g_dblib_ctx->tds_ctx = tds_alloc_context();
  466. tds_ctx_set_parent(g_dblib_ctx->tds_ctx, g_dblib_ctx);
  468. /* set the functions in the TDS layer to point to the correct info/err
  469. * message handler functions */
  470. g_dblib_ctx->tds_ctx->msg_handler = dblib_handle_info_message;
  471. g_dblib_ctx->tds_ctx->err_handler = dblib_handle_err_message;
  474. if( g_dblib_ctx->tds_ctx->locale && !g_dblib_ctx->tds_ctx->locale->date_fmt ) {
  475. /* set default in case there's no locale file */
  476. g_dblib_ctx->tds_ctx->locale->date_fmt = strdup("%b %e %Y %l:%M:%S:%z%p"); 
  477. }
  479. return SUCCEED;
  480. }
  481. LOGINREC *dblogin()
  482. {
  483. LOGINREC * loginrec;
  485. loginrec = (LOGINREC *) malloc(sizeof(LOGINREC));
  486. loginrec->tds_login = (void *) tds_alloc_login();
  488. /* set default values for loginrec */
  489. tds_set_library(loginrec->tds_login,"DB-Library");
  490. /* tds_set_charset(loginrec->tds_login,"iso_1"); */
  491. /* tds_set_packet(loginrec->tds_login,TDS_DEF_BLKSZ); */
  493. return loginrec;
  494. }
  495. void dbloginfree(LOGINREC *login)
  496. {
  497. if (login) {
  498. tds_free_login(login->tds_login);
  499. free(login);
  500. }
  501. }
  502. RETCODE dbsetlname(LOGINREC *login, char *value, int which)
  503. {
  504. switch (which) {
  505. case DBSETHOST:
  506. tds_set_host(login->tds_login, value);
  507. return SUCCEED;
  508. break;
  509. case DBSETUSER:
  510. tds_set_user(login->tds_login, value);
  511. return SUCCEED;
  512. break;
  513. case DBSETPWD:
  514. tds_set_passwd(login->tds_login, value);
  515. return SUCCEED;
  516. break;
  517. case DBSETAPP:
  518. tds_set_app(login->tds_login, value);
  519. return SUCCEED;
  520. break;
  521. case DBSETCHARSET:
  522. tds_set_charset(login->tds_login, value);
  523. return SUCCEED;
  524. break;
  525. case DBSETNATLANG:
  526. tds_set_language(login->tds_login, value);
  527. return SUCCEED;
  528. break;
  529. case DBSETHID:
  530. default:
  531. tdsdump_log(TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetlname() which = %dn", which);
  532. return FAIL;
  533. break;
  534. }
  535. }
  537. RETCODE dbsetllong(LOGINREC *login, long value, int which)
  538. {
  539. switch (which) {
  540. case DBSETPACKET:
  541. tds_set_packet(login->tds_login, (short) value); /* XXX */
  542. return SUCCEED;
  543. break;
  544. default:
  545. tdsdump_log(TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetllong() which = %dn", which);
  546. return FAIL;
  547. break;
  548. }
  549. }
  551. RETCODE dbsetlshort(LOGINREC *login, int value, int which)
  552. {
  553. switch (which) {
  554. case DBSETHIER:
  555. default:
  556. tdsdump_log(TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetlshort() which = %dn", which);
  557. return FAIL;
  558. break;
  559. }
  560. }
  562. RETCODE dbsetlbool(LOGINREC *login, int value, int which)
  563. {
  564. switch (which) {
  565. case DBSETBCP:
  566. tds_set_bulk(login->tds_login, (TDS_TINYINT) value);
  567. return SUCCEED;
  568. break;
  569. case DBSETNOSHORT:
  570. case DBSETENCRYPT:
  571. case DBSETLABELED:
  572. default:
  573. tdsdump_log(TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetlbool() which = %dn", which);
  574. return FAIL;
  575. break;
  577. }
  579. }
  581. DBPROCESS *tdsdbopen(LOGINREC *login,char *server)
  582. {
  583. DBPROCESS *dbproc;
  584.    
  585. dbproc = (DBPROCESS *) malloc(sizeof(DBPROCESS));
  586. memset(dbproc,'',sizeof(DBPROCESS));
  587. dbproc->avail_flag = TRUE;
  589. tds_set_server(login->tds_login,server);
  590.    
  591.    dbproc->tds_socket = (void *) tds_connect(login->tds_login, g_dblib_ctx->tds_ctx, (void *)dbproc);
  592.    dbproc->dbbuf = NULL;
  593.    dbproc->dbbufsz = 0;
  595.    if(dbproc->tds_socket) {
  596.       /* tds_set_parent( dbproc->tds_socket, dbproc); */
  597.       dblib_add_connection(g_dblib_ctx, dbproc->tds_socket);
  598.    } else {
  599.       fprintf(stderr,"DB-Library: Login incorrect.n");
  600.       free(dbproc); /* memory leak fix (mlilback, 11/17/01) */
  601.       return NULL;
  602.    }
  603.    
  604.    buffer_init(&(dbproc->row_buf));
  605.    
  606.    return dbproc;
  607. }
  609. RETCODE dbfcmd(DBPROCESS *dbproc, char *fmt, ...)
  610. {
  611. va_list ap;
  612. char *s;
  613. int len;
  614. RETCODE ret;
  616. va_start(ap, fmt);
  617. len = vasprintf(&s, fmt, ap);
  618. va_end(ap);
  620. if (len < 0) return FAIL;
  622. ret = dbcmd(dbproc, s);
  623. free(s);
  625. return ret;
  626. }
  628. RETCODE dbcmd(DBPROCESS *dbproc, char *cmdstring)
  629. {
  630. int newsz;
  631. void *p;
  633. if(dbproc == NULL) {
  634. return FAIL;
  635. }
  636. dbproc->avail_flag = FALSE;
  638. if(dbproc->dbbufsz == 0) {
  639. dbproc->dbbuf = (unsigned char *) malloc(strlen(cmdstring)+1);
  640. if(dbproc->dbbuf == NULL) {
  641. return FAIL;
  642. }
  643. strcpy((char *)dbproc->dbbuf, cmdstring);
  644. dbproc->dbbufsz = strlen(cmdstring) + 1;
  645. } else {
  646. newsz = strlen(cmdstring) + dbproc->dbbufsz;
  647. if((p=realloc(dbproc->dbbuf,newsz)) == NULL) {
  648. return FAIL;
  649. }
  650. dbproc->dbbuf = (unsigned char *)p;
  651. strcat((char *)dbproc->dbbuf, cmdstring);
  652. dbproc->dbbufsz = newsz;
  653. }
  655. return SUCCEED;
  656. }
  657. RETCODE dbsqlexec(DBPROCESS *dbproc)
  658. {
  659. RETCODE   rc = FAIL;
  660. TDSSOCKET *tds;
  662.    if (dbproc == NULL) {
  663.       return FAIL;
  664.    }
  665.    tds = (TDSSOCKET *) dbproc->tds_socket;
  666.    if (!tds || !tds->s) return FAIL;
  668.    if (tds->res_info && tds->res_info->more_results) 
  669.    /* if (dbproc->more_results && tds_is_end_of_results(dbproc->tds_socket)) */
  670.    {
  671.       dbresults(dbproc);
  672.    }
  673.       
  674.    if (SUCCEED == (rc = dbsqlsend(dbproc)))
  675.    {
  676.       /* 
  677.        * XXX We need to observe the timeout value and abort 
  678.        * if this times out.
  679.        */
  680.       rc = dbsqlok(dbproc);
  681.    }
  682.    dbproc->empty_res_hack = 0;
  683.    return rc;
  684. }
  686. RETCODE
  687. dbuse(DBPROCESS *dbproc, char *dbname)
  688. {
  689.    /* FIXME quote dbname if needed */
  690.    if ((dbproc == NULL)
  691.        || (dbfcmd(dbproc, "use %s", dbname) == FAIL)
  692.        || (dbsqlexec(dbproc) == FAIL)
  693.        || (dbcanquery(dbproc) == FAIL))
  694.       return FAIL;
  695.    return SUCCEED;
  696. }
  698. void
  699. dbclose(DBPROCESS *dbproc)
  700. {
  701. TDSSOCKET *tds;
  702. int i;
  704. tds = (TDSSOCKET *) dbproc->tds_socket;
  705. if (tds) {
  706.                 buffer_free(&(dbproc->row_buf));
  707. tds_free_socket(tds);
  708. }
  709. if (dbproc->bcp_tablename)
  710. free(dbproc->bcp_tablename);
  711. if (dbproc->bcp_hostfile)
  712. free(dbproc->bcp_hostfile);
  713. if (dbproc->bcp_errorfile)
  714. free(dbproc->bcp_errorfile);
  715. if (dbproc->bcp_columns) {
  716. for (i=0;i<dbproc->bcp_colcount;i++) {
  717. #ifdef NCBI_FTDS
  718.           if(dbproc->bcp_hostfile)
  719. #endif
  720. if (dbproc->bcp_columns[i]->data)
  721. free(dbproc->bcp_columns[i]->data);
  722. free(dbproc->bcp_columns[i]);
  723. }
  724. free(dbproc->bcp_columns);
  725. }
  726. if (dbproc->host_columns) {
  727. for (i=0;i<dbproc->host_colcount;i++) {
  728. if (dbproc->host_columns[i]->terminator)
  729. free(dbproc->host_columns[i]->terminator);
  730. free(dbproc->host_columns[i]);
  731. }
  732. free(dbproc->host_columns);
  733. }
  734. #ifdef NCBI_FTDS
  735.    if(dbproc->bcp_hint)
  736.        free(dbproc->bcp_hint);
  737. #endif
  739.     dbfreebuf(dbproc);
  740.         dblib_del_connection(g_dblib_ctx, dbproc->tds_socket);
  741. free(dbproc);
  743.         return;
  744. }
  746. void
  747. dbexit()
  748. {
  749. TDSSOCKET *tds;
  750. DBPROCESS *dbproc;
  751. int i;
  753. /* FIX ME -- this breaks if ctlib/dblib used in same process */
  754. for (i=0;i<TDS_MAX_CONN;i++) {
  755. tds = g_dblib_ctx->connection_list[i];
  756. if (tds) {
  757. dbproc = (DBPROCESS *) tds->parent;
  758. dbclose(dbproc);
  759. }
  760. }
  761. tds_free_context(g_dblib_ctx->tds_ctx);
  762. }
  765. RETCODE dbresults_r(DBPROCESS *dbproc, int recursive)
  766. {
  767. RETCODE       retcode = FAIL;
  768. TDSSOCKET *tds;
  770.    
  771.    /* 
  772.     * For now let's assume we have only 5 possible classes of tokens 
  773.     * at the next byte in the TDS stream
  774.     *   1) The start of a result set, either TDS_RESULT_TOKEN (tds ver 5.0)
  775.     *      or TDS_COL_NAME_TOKEN (tds ver 4.2).
  776.     *   2) A row token (TDS_ROW_TOKEN)
  777.     *   3) An end token (either 0xFD or 0xFE)
  778.     *   4) A done in proc token (0xFF)
  779.     *   5) A message or error token
  780.     */
  782.    if (dbproc == NULL) return FAIL;
  783.    buffer_clear(&(dbproc->row_buf));
  785.    tds = dbproc->tds_socket;
  786.    if (!tds || !tds->s) return FAIL;
  788.    retcode = tds_process_result_tokens(tds);
  790.    if (retcode == TDS_NO_MORE_RESULTS) {
  791. if (tds->res_info && tds->res_info->rows_exist) {
  792. return NO_MORE_RESULTS;
  793. } else {
  794. if (!dbproc->empty_res_hack) {
  795. dbproc->empty_res_hack = 1;
  796. return SUCCEED;
  797. } else {
  798. dbproc->empty_res_hack = 0;
  799. return NO_MORE_RESULTS;
  800. }
  801. }
  802.    }
  803.    if (retcode == TDS_SUCCEED) {
  804.     retcode = buffer_start_resultset(&(dbproc->row_buf), 
  805.                                       tds->res_info->row_size);
  806.    }
  807.    return retcode;
  808. }
  809.    
  810. /* =============================== dbresults() ===============================
  811.  * 
  812.  * Def: 
  813.  * 
  814.  * Ret:  SUCCEED, FAIL, NO_MORE_RESULTS, or NO_MORE_RPC_RESULTS
  815.  * 
  816.  * ===========================================================================
  817.  */
  818. RETCODE dbresults(DBPROCESS *dbproc)
  819. {
  820. RETCODE rc;
  821.    tdsdump_log(TDS_DBG_FUNC, "%L inside dbresults()n");
  822.    if (dbproc == NULL) return FAIL;
  823.    rc = dbresults_r(dbproc, 0);
  824.    tdsdump_log(TDS_DBG_FUNC, "%L leaving dbresults() returning %dn",rc);
  825.    return rc;
  826. }
  829. int dbnumcols(DBPROCESS *dbproc)
  830. {
  831. TDSRESULTINFO *resinfo;
  832. TDSSOCKET *tds;
  834. tds = (TDSSOCKET *) dbproc->tds_socket;
  835. resinfo = tds->res_info;
  836. if (resinfo)
  837. return resinfo->num_cols;
  838. return 0;
  839. }
  840. char *dbcolname(DBPROCESS *dbproc, int column)
  841. {
  842. #ifdef NCBI_FTDS
  843.     TDSRESULTINFO *resinfo;
  844.     TDSSOCKET *tds;
  845.     
  846.     tds = (TDSSOCKET *) dbproc->tds_socket;
  847.     resinfo = tds->res_info;
  848.     if (column < 1 || column > resinfo->num_cols || !resinfo->columns[column-1]) return NULL;
  849.     return resinfo->columns[column-1]->column_name;
  850. #else    
  851. static char buf[255];
  852. TDSRESULTINFO *resinfo;
  853. TDSSOCKET *tds;
  855. tds = (TDSSOCKET *) dbproc->tds_socket;
  856. resinfo = tds->res_info;
  857. if (column < 1 || column > resinfo->num_cols) return NULL;
  858. strcpy (buf,resinfo->columns[column-1]->column_name);
  859. return buf;
  860. #endif
  861. }
  863. RETCODE dbgetrow(
  864.    DBPROCESS *dbproc, 
  865.    DBINT row)
  866. {
  867.    RETCODE   result = FAIL;
  868.    int       index = buffer_index_of_resultset_row(&(dbproc->row_buf), row);
  869.    if (-1 == index)
  870.    {
  871.       result = NO_MORE_ROWS;
  872.    }
  873.    else
  874.    {
  875.       dbproc->row_buf.next_row = row;
  876.       buffer_transfer_bound_data(&(dbproc->row_buf), dbproc, row);
  877.       dbproc->row_buf.next_row++;
  878.       result = REG_ROW;
  879.    }
  881.    return result;
  882. }
  884. RETCODE dbnextrow(DBPROCESS *dbproc)
  885. {
  886.    TDSRESULTINFO *resinfo;
  887.    TDSSOCKET     *tds;
  888.    int            rc;
  889.    RETCODE        result = FAIL;
  890.    
  891.    tdsdump_log(TDS_DBG_FUNC, "%L inside dbnextrow()n");
  893.    if (dbproc == NULL) return FAIL;
  894.    tds = (TDSSOCKET *) dbproc->tds_socket;
  895.    if (!tds || !tds->s) {
  896.       tdsdump_log(TDS_DBG_FUNC, "%L leaving dbnextrow() returning %dn",FAIL);
  897.       return FAIL;
  898.    }
  900.    resinfo = tds->res_info;
  901.    if (!resinfo) {
  902.       tdsdump_log(TDS_DBG_FUNC, "%L leaving dbnextrow() returning %dn",NO_MORE_ROWS);
  903.       return NO_MORE_ROWS;
  904.    }
  906.    if (dbproc->row_buf.buffering_on && buffer_is_full(&(dbproc->row_buf))
  907.        && (-1 == buffer_index_of_resultset_row(&(dbproc->row_buf), 
  908.                                                dbproc->row_buf.next_row)))
  909.    {
  910.       result = BUF_FULL;
  911.    }
  912.    else 
  913.    {
  914.       /*
  915.        * Now try to get the dbproc->row_buf.next_row item into the row
  916.        * buffer
  917.        */
  918.       if (-1 != buffer_index_of_resultset_row(&(dbproc->row_buf), 
  919.                                               dbproc->row_buf.next_row))
  920.       {
  921.          /*
  922.           * Cool, the item we want is already there
  923.           */
  924.          rc     = TDS_SUCCEED;
  925.          result = REG_ROW;
  926.       }
  927.       else
  928.       {
  929.             /* 
  930.              * XXX Note- we need to handle "compute" results as well.
  931.              * I don't believe the current src/tds/token.c handles those
  932.              * so we don't handle them yet either.
  933.              */
  935.             /* 
  936.              * Get the row from the TDS stream.
  937.              */
  938.             rc = tds_process_row_tokens(dbproc->tds_socket);
  939.             if (rc == TDS_SUCCEED)
  940.             {
  941.                /*
  942.                 * Add the row to the row buffer
  943.                 */
  944.                buffer_add_row(&(dbproc->row_buf), resinfo->current_row, 
  945.                               resinfo->row_size);
  946.                result = REG_ROW;
  947.             }
  948.             else if (rc == TDS_NO_MORE_ROWS)
  949.             {
  950.                result = NO_MORE_ROWS;
  951.             }
  952.             else 
  953.             {
  954.                result = FAIL;
  955.             }
  956.       }
  957.    
  958.       if (result == REG_ROW)
  959.       {
  960.          /*
  961.           * The data is in the row buffer, now transfer it to the 
  962.           * bound variables
  963.           */
  964.          buffer_transfer_bound_data(&(dbproc->row_buf), dbproc, 
  965.                                     dbproc->row_buf.next_row);
  966.          dbproc->row_buf.next_row++;
  967.       }
  968.    }
  969.    tdsdump_log(TDS_DBG_FUNC, "%L leaving dbnextrow() returning %dn",result);
  970.    return result;
  971. } /* dbnextrow()  */
  973. static int _db_get_server_type(int bindtype)
  974. {
  975. switch (bindtype) {
  976. case CHARBIND:
  977. case STRINGBIND:
  978. case NTBSTRINGBIND:
  979. return SYBCHAR;
  980. break;
  981. case FLT8BIND:
  982. return SYBFLT8;
  983. break;
  984. case REALBIND:
  985. return SYBREAL;
  986. break;
  987. case INTBIND:
  988. return SYBINT4;
  989. break;
  990. case SMALLBIND:
  991. return SYBINT2;
  992. break;
  993. case TINYBIND:
  994. return SYBINT1;
  995. break;
  996.           case DATETIMEBIND:
  997.                return SYBDATETIME;
  998.                break;
  999.           case SMALLDATETIMEBIND:
  1000.                return SYBDATETIME4;
  1001.                break;
  1002.           case MONEYBIND:
  1003.                return SYBMONEY;
  1004.                break;
  1005.           case SMALLMONEYBIND:
  1006.                return SYBMONEY4;
  1007.                break;
  1008.           case BINARYBIND:
  1009.                return SYBBINARY;
  1010.                break;
  1011.           case VARYCHARBIND:
  1012.                return SYBVARCHAR;
  1013.                break;
  1014.           case BITBIND:
  1015.                return SYBBIT;
  1016.                break;
  1017.           case NUMERICBIND:
  1018.                return SYBNUMERIC;
  1019.                break;
  1020.           case DECIMALBIND:
  1021.                return SYBDECIMAL;
  1022.                break;
  1023.           default:
  1024.                return -1;
  1025.                break;
  1026. }
  1027. }
  1028. /**
  1029.  * Conversion functions are handled in the TDS layer.
  1030.  * 
  1031.  * The main reason for this is that ctlib and ODBC (and presumably DBI) need
  1032.  * to be able to do conversions between datatypes. This is possible because
  1033.  * the format of complex data (dates, money, numeric, decimal) is defined by
  1034.  * its representation on the wire; thus what we call DBMONEY is exactly its
  1035.  * format on the wire. CLIs that need a different representation (ODBC?) 
  1036.  * need to convert from this format anyway, so the code would already be in
  1037.  * place.
  1038.  * 
  1039.  * Each datatype is also defined by its Server-type so all CLIs should be 
  1040.  * able to map native types to server types as well.
  1041.  *
  1042.  * tds_convert copies from src to dest and returns the output data length,
  1043.  * period.  All padding and termination is the responsibility of the API library
  1044.  * and is done post-conversion.  The peculiar rule in dbconvert() is that
  1045.  * a destlen of -1 and a desttype of SYBCHAR means the output buffer
  1046.  * should be null-terminated.  
  1047.  */
  1049. DBINT dbconvert(DBPROCESS *dbproc,
  1050. int srctype,
  1051. BYTE *src,
  1052. DBINT srclen,
  1053. int desttype,
  1054. BYTE *dest,
  1055. DBINT destlen)
  1056. {
  1057. TDSSOCKET *tds = NULL;
  1059. CONV_RESULT dres;
  1060. DBINT       ret;
  1061. int         i;
  1062. int         len;
  1063. DBNUMERIC   *num;
  1065. tdsdump_log(TDS_DBG_INFO1, "%L inside dbconvert() srctype = %d desttype = %dn",srctype, desttype);
  1067. if (dbproc) {
  1068. tds = (TDSSOCKET *) dbproc->tds_socket;
  1069. }
  1071.     if (src == NULL || srclen == 0) {
  1073.        /* FIX set appropriate NULL value for destination type */
  1074.        memset(dest,'', destlen);
  1075.        return 0;
  1076.     }
  1078.     /* srclen of -1 means the source data is definitely NULL terminated */
  1079.     if (srclen == -1) 
  1080.        srclen = strlen((char *)src);
  1082.     if (dest == NULL) {
  1083.        /* FIX call error handler */
  1084.        return -1;
  1085.     }
  1086.     
  1088.     /* oft times we are asked to convert a data type to itself */
  1090.     if (srctype == desttype) {
  1092.    tdsdump_log(TDS_DBG_INFO1, "%L inside dbconvert() srctype == desttypen");
  1093.        switch (desttype) {
  1095.           case SYBBINARY:
  1096.           case SYBIMAGE:
  1097.                if (srclen > destlen && destlen >= 0) {
  1098.                   ret = -1;
  1099.                }
  1100.                else {
  1101.                   memcpy(dest, src, srclen);
  1102.   if (srclen < destlen)
  1103.   memset(dest+srclen,0,destlen-srclen);
  1104.                   ret = srclen;
  1105.                }
  1106.                break;
  1108.           case SYBCHAR:
  1109.           case SYBVARCHAR:
  1110.           case SYBTEXT:
  1112.                /* srclen of -1 means the source data is definitely NULL terminated */
  1114.                if (srclen == -1) 
  1115.                   srclen = strlen((char *)src);
  1117.                if (destlen == 0 || destlen < -2) {
  1118.                   ret = FAIL;
  1119.                }
  1120.                else if (destlen == -1) { /* rtrim and null terminate */
  1121.                   for (i = srclen-1; i>=0 && src[i] == ' '; --i) {
  1122.       srclen = i;
  1123.   } 
  1124.                   memcpy(dest,src,srclen);
  1125.                   dest[srclen] = '';
  1126.                   ret = srclen;
  1127.                }
  1128.                else if (destlen == -2) { /* just null terminate */
  1129.                   memcpy(dest,src,srclen);
  1130.                   dest[srclen] = '';
  1131.                   ret = srclen;
  1132.                }
  1133.                else { /* destlen is > 0 */
  1134.                   if (srclen > destlen) {
  1135.                      /* fprintf(stderr,"%s: Line%d: Data-conversion resulted in overflow.n", __FILE__, __LINE__);
  1136.                      fprintf(stderr,"tsrclen (%d)> destlen (%d).n", srclen, destlen); */
  1137.                     ret = -1;
  1138.                   }
  1139.                   else {
  1140.                      memcpy(dest, src, srclen);
  1141.                      for (i = srclen; i < destlen; i++ )
  1142.                        dest[i] = ' ';
  1143.                      ret = srclen;
  1144.                   }
  1145.                }
  1146.                   
  1147.                break;
  1148.           case SYBINT1: 
  1149.           case SYBINT2:
  1150.           case SYBINT4:
  1151.           case SYBINT8:
  1152.           case SYBFLT8:
  1153.           case SYBREAL:
  1154.           case SYBBIT:
  1155.           case SYBBITN:
  1156.           case SYBMONEY:
  1157.           case SYBMONEY4:
  1158.           case SYBDATETIME:
  1159.           case SYBDATETIME4:
  1160.           case SYBUNIQUE:
  1161.                ret = get_size_by_type(desttype);
  1162.                memcpy(dest, src, ret);
  1163.                break;
  1165.           case SYBNUMERIC:
  1166.           case SYBDECIMAL:
  1167.                memcpy(dest, src, sizeof(DBNUMERIC));
  1168.                ret = sizeof(DBNUMERIC);
  1169.                break;
  1171.        }
  1172.        return ret;
  1173.     }          /* srctype == desttype */
  1176.      /* FIXME what happen if client do not reset values ??? */
  1177. /* FIXME act differently for ms and sybase */
  1178. if (is_numeric_type(desttype)) {
  1179. num = (DBNUMERIC *)dest;
  1180. if ( num->precision == 0 )
  1181. dres.n.precision = 18;
  1182. else
  1183. dres.n.precision = num->precision;
  1184. if ( num->scale == 0 )
  1185. dres.n.scale = 0;
  1186. else
  1187. dres.n.scale = num->scale;
  1188. }
  1190. tdsdump_log(TDS_DBG_INFO1, "%L inside dbconvert() calling tds_convertn");
  1192. len = tds_convert (g_dblib_ctx->tds_ctx, srctype, (TDS_CHAR *)src, srclen, 
  1193.                        desttype, &dres);
  1194.    
  1195. if( len == TDS_FAIL )
  1196. return 0;
  1198.     switch (desttype) {
  1199.         case SYBBINARY:
  1200.         case SYBIMAGE:
  1202.              if (len > destlen && destlen >= 0) {
  1203.                 fprintf(stderr,"%s: Line %d: Data-conversion resulted in overflow.n", __FILE__, __LINE__);
  1204.                 fprintf(stderr,"tlen (%d) > destlen (%d).n", len, destlen);
  1205.                 ret = -1;
  1206.              } else {
  1207.                 memcpy(dest, dres.ib, len);
  1208.                 free(dres.ib);
  1209. if (len < destlen)
  1210. memset(dest+len,0,destlen-len);
  1211. ret = len;
  1212.              }
  1213.              break;
  1214.         case SYBINT1:
  1215.              memcpy(dest,&(dres.ti),1);
  1216.              ret = 1;
  1217.              break;
  1218.         case SYBINT2:
  1219.              memcpy(dest,&(dres.si),2);
  1220.              ret = 2;
  1221.              break;
  1222.         case SYBINT4:
  1223.              memcpy(dest,&(dres.i),4);
  1224.              ret = 4;
  1225.              break;
  1226.         case SYBFLT8:
  1227.              memcpy(dest,&(dres.f),8);
  1228.              ret = 8;
  1229.              break;
  1230.         case SYBREAL:
  1231.              memcpy(dest,&(dres.r),4);
  1232.              ret = 4;
  1233.              break;
  1234.         case SYBBIT:
  1235.         case SYBBITN:
  1236.              memcpy(dest,&(dres.ti),1);
  1237.              ret = 1;
  1238.              break;
  1239.         case SYBMONEY:
  1240.              memcpy(dest,&(dres.m),sizeof(TDS_MONEY));
  1241.              ret = sizeof(TDS_MONEY);
  1242.              break;
  1243.         case SYBMONEY4:
  1244.              memcpy(dest,&(dres.m4),sizeof(TDS_MONEY4));
  1245.              ret = sizeof(TDS_MONEY4);
  1246.              break;
  1247.         case SYBDATETIME:
  1248.              memcpy(dest,&(dres.dt),sizeof(TDS_DATETIME));
  1249.              ret = sizeof(TDS_DATETIME);
  1250.              break;
  1251.         case SYBDATETIME4:
  1252.              memcpy(dest,&(dres.dt4),sizeof(TDS_DATETIME4));
  1253.              ret = sizeof(TDS_DATETIME4);
  1254.              break;
  1255.         case SYBNUMERIC:
  1256.         case SYBDECIMAL:
  1257.              memcpy(dest,&(dres.n), sizeof(TDS_NUMERIC));
  1258.              ret = sizeof(TDS_NUMERIC);
  1259.              break;
  1260.         case SYBCHAR:
  1261.         case SYBVARCHAR:
  1262.         case SYBTEXT:
  1264.          tdsdump_log(TDS_DBG_INFO1, "%L inside dbconvert() outputting %d bytes character data destlen = %d n", len, destlen);
  1265.              if (destlen == 0 || destlen < -2) {
  1266.                 ret = FAIL;
  1267.              }
  1268.              else if (destlen == -1) { /* rtrim and null terminate */
  1269.                 for (i = len-1; i>=0 && dres.c[i] == ' '; --i) {
  1270.     len = i;
  1271. }
  1272.                 memcpy(dest, dres.c, len);
  1273. dest[len] = '';
  1274.                 ret = len;
  1275.              }
  1276.              else if (destlen == -2) { /* just null terminate */
  1277.                 memcpy(dest,dres.c,len);
  1278. dest[len] = 0;
  1279.                 ret = len;
  1280.              }
  1281.              else { /* destlen is > 0 */
  1282.                 if (len > destlen) {
  1283.                  /*fprintf(stderr,"%s: Line%d: Data-conversion resulted in overflow.n", __FILE__, __LINE__);
  1284.                  fprintf(stderr,"tlen (%d)> destlen (%d).n", len, destlen);*/
  1285.                      ret = -1;
  1286.                 }
  1287.                 else
  1288.                    memcpy(dest, dres.c, len);
  1289.                    for (i = len; i < destlen; i++ )
  1290.                        dest[i] = ' ';
  1291.                    ret = len;
  1292.              }
  1293.                 
  1294.              free(dres.c);
  1296.              break;
  1298.      }
  1299.      return(ret);
  1300. }
  1302. DBINT dbconvert_ps(DBPROCESS *dbproc,
  1303. int srctype,
  1304. BYTE *src,
  1305. DBINT srclen,
  1306. int desttype,
  1307. BYTE *dest,
  1308. DBINT destlen,
  1309. DBTYPEINFO *typeinfo)
  1310. {
  1311. DBNUMERIC *s;
  1312. DBNUMERIC *d;
  1314. if (is_numeric_type(desttype)) {
  1315. if (typeinfo == (DBTYPEINFO *) NULL ) {
  1316. if (is_numeric_type(srctype)) {
  1317. s = (DBNUMERIC *)src;
  1318. d = (DBNUMERIC *)dest;
  1319. d->precision = s->precision;
  1320. d->scale     = s->scale;
  1321. } else {
  1322. d = (DBNUMERIC *)dest;
  1323. d->precision = 18;
  1324. d->scale     = 0;
  1325. }
  1326. } else {
  1327. d = (DBNUMERIC *)dest;
  1328. d->precision = typeinfo->precision;
  1329. d->scale     = typeinfo->scale;
  1330. }
  1331. }
  1333. return dbconvert(dbproc, srctype, src, srclen,
  1334. desttype, dest, destlen);
  1335. }
  1337. RETCODE dbbind(
  1338.    DBPROCESS *dbproc,
  1339.    int        column,
  1340.    int        vartype,
  1341.    DBINT      varlen,
  1342.    BYTE      *varaddr)
  1343. {
  1344.    TDSCOLINFO    *colinfo = NULL;
  1345.    TDSRESULTINFO *resinfo = NULL;
  1346.    TDSSOCKET     *tds     = NULL;
  1347.    int            srctype = -1;   
  1348.    int            desttype = -1;   
  1349.    int            okay    = TRUE; /* so far, so good */
  1351. tdsdump_log(TDS_DBG_INFO1, "%L dbbind() column = %d %d %dn",column, vartype, varlen);
  1352. dbproc->avail_flag = FALSE;
  1353.    /* 
  1354.     * Note on logic-  I'm using a boolean variable 'okay' to tell me if
  1355.     * everything that has happened so far has gone okay.  Basically if 
  1356.     * something happened that wasn't okay we don't want to keep doing 
  1357.     * things, but I also don't want to have a half dozen exit points from 
  1358.     * this function.  So basically I've wrapped each set of operation in a 
  1359.     * "if (okay)" statement.  Once okay becomes false we skip everything 
  1360.     * else.
  1361.     */
  1362. okay = (dbproc!=NULL && dbproc->tds_socket!=NULL && varaddr!=NULL);
  1364. if (okay) {
  1365. tds = (TDSSOCKET *) dbproc->tds_socket;
  1366. resinfo = tds->res_info;
  1367. }
  1368.    
  1369. okay = okay && ((column >= 1) && (column <= resinfo->num_cols));
  1371. if (okay) {
  1372. colinfo  = resinfo->columns[column-1];
  1373. srctype = tds_get_conversion_type(colinfo->column_type,
  1374. colinfo->column_size);
  1375. desttype = _db_get_server_type(vartype);
  1377. tdsdump_log(TDS_DBG_INFO1, "%L dbbind() srctype = %d desttype = %d n",srctype, desttype);
  1379. okay = okay && dbwillconvert(srctype, _db_get_server_type(vartype));
  1380. }
  1382. if (okay) {   
  1383. colinfo->varaddr         = (char *)varaddr;
  1384. colinfo->column_bindtype = vartype;
  1385. colinfo->column_bindlen  = varlen;
  1386. }
  1388. return okay ? SUCCEED : FAIL;
  1389. } /* dbbind()  */
  1391. void dbsetifile(char *filename)
  1392. {
  1393. set_interfaces_file_loc(filename);
  1394. }
  1395. RETCODE dbnullbind(DBPROCESS *dbproc, int column, DBINT *indicator)
  1396. {
  1397. TDSCOLINFO * colinfo;
  1398. TDSRESULTINFO * resinfo;
  1399. TDSSOCKET * tds;
  1401.         /*
  1402.          *  XXX Need to check for possibly problems before assuming
  1403.          *  everything is okay
  1404.          */
  1405. tds = (TDSSOCKET *) dbproc->tds_socket;
  1406. resinfo = tds->res_info;
  1407. colinfo = resinfo->columns[column-1];
  1408. colinfo->column_nullbind = (TDS_CHAR *) indicator;
  1410.         return SUCCEED;
  1411. }
  1412. DBINT dbcount(DBPROCESS *dbproc)
  1413. {
  1414. TDSRESULTINFO * resinfo;
  1415. TDSSOCKET * tds;
  1417. tds = (TDSSOCKET *) dbproc->tds_socket;
  1418. resinfo = tds->res_info;
  1419. if (resinfo) 
  1420. return resinfo->row_count;
  1421. else return tds->rows_affected;
  1422. }
  1423. void dbclrbuf(DBPROCESS *dbproc, DBINT n)
  1424. {
  1425.    if (n <= 0) return;
  1427.    if (dbproc->row_buf.buffering_on)
  1428.    {
  1429.       if (n >= dbproc->row_buf.rows_in_buf) {
  1430.        buffer_delete_rows(&(dbproc->row_buf), dbproc->row_buf.rows_in_buf - 1);
  1431.       } else {
  1432.        buffer_delete_rows(&(dbproc->row_buf), n);
  1433.       }
  1434.    }
  1435. }
  1437. DBBOOL dbwillconvert(int srctype, int desttype)
  1438. {
  1439.    return tds_willconvert (srctype, desttype);
  1440. }
  1442. int dbcoltype(DBPROCESS *dbproc,int column)
  1443. {
  1444. TDSCOLINFO * colinfo;
  1445. TDSRESULTINFO * resinfo;
  1446. TDSSOCKET * tds;
  1448. tds = (TDSSOCKET *) dbproc->tds_socket;
  1449. resinfo = tds->res_info;
  1450. colinfo = resinfo->columns[column-1];
  1451. switch (colinfo->column_type) {
  1452. case SYBVARCHAR:
  1453. return SYBCHAR; 
  1454. case SYBVARBINARY:
  1455. return SYBBINARY;
  1456. case SYBDATETIMN:
  1457. if (colinfo->column_size==8)
  1458. return SYBDATETIME;
  1459. else if (colinfo->column_size==4)
  1460. return SYBDATETIME4;
  1461. case SYBMONEYN:
  1462. /* needs to be based on column size (mlilback, 11/7/01) */
  1463. if (colinfo->column_size==4)
  1464. return SYBMONEY4;
  1465. else
  1466. return SYBMONEY;
  1467. case SYBFLTN:
  1468. if (colinfo->column_size==8)
  1469. return SYBFLT8;
  1470. else if (colinfo->column_size==4)
  1471. return SYBREAL;
  1472. case SYBINTN:
  1473. if (colinfo->column_size==4)
  1474. return SYBINT4;
  1475. else if (colinfo->column_size==2)
  1476. return SYBINT2; 
  1477. else if (colinfo->column_size==1)
  1478. return SYBINT1; 
  1479. else if (colinfo->column_size==8)
  1480.     return SYBINT8;
  1481. default:
  1482. return colinfo->column_type;
  1483. }
  1484. #ifndef NCBI_FTDS
  1485. return 0; /* something went wrong */
  1486. #endif
  1487. }
  1489. int dbcolutype(DBPROCESS *dbproc,int column)
  1490. {
  1491. TDSCOLINFO * colinfo;
  1492. TDSRESULTINFO * resinfo;
  1493. TDSSOCKET * tds;
  1495. tds = (TDSSOCKET *) dbproc->tds_socket;
  1496. resinfo = tds->res_info;
  1497. colinfo = resinfo->columns[column-1];
  1498.         return colinfo->column_usertype;
  1499. }
  1501. DBTYPEINFO *dbcoltypeinfo(DBPROCESS *dbproc, int column)
  1502. {
  1503. /* moved typeinfo from static into dbproc structure to make thread safe. 
  1504. (mlilback 11/7/01) */
  1505. TDSCOLINFO * colinfo;
  1506. TDSRESULTINFO * resinfo;
  1507. TDSSOCKET * tds;
  1509. tds = (TDSSOCKET *) dbproc->tds_socket;
  1510. resinfo = tds->res_info;
  1511. colinfo = resinfo->columns[column-1];
  1512. dbproc->typeinfo.precision = colinfo->column_prec;
  1513. dbproc->typeinfo.scale = colinfo->column_scale;
  1514. return &dbproc->typeinfo;
  1515. }
  1516. char *dbcolsource(DBPROCESS *dbproc,int colnum)
  1517. {
  1518. TDSCOLINFO * colinfo;
  1519. TDSRESULTINFO * resinfo;
  1520. TDSSOCKET * tds;
  1522. tds = (TDSSOCKET *) dbproc->tds_socket;
  1523. resinfo = tds->res_info;
  1524. colinfo = resinfo->columns[colnum-1];
  1525. #ifdef NCBI_FTDS
  1526.    return colinfo->full_column_name;
  1527. #else
  1528. return colinfo->column_name;
  1529. #endif
  1530. }
  1531. DBINT dbcollen(DBPROCESS *dbproc, int column)
  1532. {
  1533. TDSCOLINFO * colinfo;
  1534. TDSRESULTINFO * resinfo;
  1535. TDSSOCKET * tds;
  1537. tds = (TDSSOCKET *) dbproc->tds_socket;
  1538. resinfo = tds->res_info;
  1539. if (column<1 || column>resinfo->num_cols) return -1;
  1540. colinfo = resinfo->columns[column-1];
  1541. return colinfo->column_size;
  1542. }
  1543. /* dbvarylen(), pkleef@openlinksw.com 01/21/02 */
  1544. DBINT dbvarylen(DBPROCESS *dbproc, int column)
  1545. {
  1546. TDSCOLINFO * colinfo;
  1547. TDSRESULTINFO *resinfo;
  1548. TDSSOCKET *tds;
  1550. tds = (TDSSOCKET *) dbproc->tds_socket;
  1551. resinfo = tds->res_info;
  1552. if (column<1 || column>resinfo->num_cols) 
  1553. return FALSE;
  1554. colinfo = resinfo->columns[column-1];
  1556. if (tds_get_null (resinfo->current_row, column))
  1557. return TRUE;
  1559. switch (colinfo->column_type) {
  1560. /* variable length fields */
  1561. case SYBNVARCHAR:
  1562. case SYBVARBINARY:
  1563. case SYBVARCHAR:
  1564. return TRUE;
  1566. /* types that can be null */
  1567. case SYBBITN:
  1568. case SYBDATETIMN:
  1569. case SYBDECIMAL:
  1570. case SYBFLTN:
  1571. case SYBINTN:
  1572. case SYBMONEYN:
  1573. case SYBNUMERIC:
  1574. return TRUE;
  1576. /* blob types */
  1577. case SYBIMAGE:
  1578. case SYBNTEXT:
  1579. case SYBTEXT:
  1580. return TRUE;
  1581. }
  1582. return FALSE;
  1583. }
  1584. DBINT dbdatlen(DBPROCESS *dbproc, int column)
  1585. {
  1586. TDSCOLINFO * colinfo;
  1587. TDSRESULTINFO * resinfo;
  1588. TDSSOCKET * tds;
  1589. DBINT ret;
  1591. /* FIXME -- this is the columns info, need per row info */
  1592. /* Fixed by adding cur_row_size to colinfo, filled in by process_row
  1593. in token.c. (mlilback, 11/7/01) */
  1594. tds = (TDSSOCKET *) dbproc->tds_socket;
  1595. resinfo = tds->res_info;
  1596. if (column<1 || column>resinfo->num_cols) return -1;
  1597. colinfo = resinfo->columns[column-1];
  1598. tdsdump_log(TDS_DBG_INFO1, "%L dbdatlen() type = %dn",colinfo->column_type);
  1600. if (tds_get_null(resinfo->current_row,column-1))
  1601. ret = 0;
  1602. else
  1603. ret = colinfo->cur_row_size;
  1604. tdsdump_log(TDS_DBG_FUNC, "%L leaving dbdatlen() returning %dn",ret);
  1605. return ret;
  1606. }
  1608. BYTE *
  1609. dbdata(DBPROCESS *dbproc, int column)
  1610. {
  1611. TDSCOLINFO * colinfo;
  1612. TDSRESULTINFO * resinfo;
  1613. TDS_VARBINARY *varbin;
  1614.  register TDS_SMALLINT t;
  1616. resinfo = dbproc->tds_socket->res_info;
  1617. if (column<1 || column>resinfo->num_cols) return NULL;
  1619. if (tds_get_null(resinfo->current_row,column-1)) {
  1620. return NULL;
  1621. }
  1623. colinfo = resinfo->columns[column-1];
  1624. t= colinfo->column_type;
  1625. if (is_blob_type(t)) {
  1626. return (BYTE *)colinfo->column_textvalue;
  1627. } 
  1628. if (t == SYBVARBINARY) {
  1629. varbin = (TDS_VARBINARY *)
  1630. &(resinfo->current_row[colinfo->column_offset]);
  1631. return (BYTE *)varbin->array;
  1632. }
  1634. /* else */
  1635. return &resinfo->current_row[colinfo->column_offset];
  1636. }
  1638. RETCODE dbcancel(DBPROCESS *dbproc)
  1639. {
  1640.    tds_send_cancel(dbproc->tds_socket);
  1641.    tds_process_cancel(dbproc->tds_socket);
  1642.    /* tds_process_default_tokens(dbproc->tds_socket,CANCEL); */
  1643.    return SUCCEED;
  1644. }
  1645. DBINT dbspr1rowlen(DBPROCESS *dbproc)
  1646. {
  1647. TDSCOLINFO * colinfo;
  1648. TDSRESULTINFO * resinfo;
  1649. TDSSOCKET * tds;
  1650. int col,len=0,collen,namlen;
  1652. tds = (TDSSOCKET *) dbproc->tds_socket;
  1653. resinfo = tds->res_info;
  1655. for (col=0;col<resinfo->num_cols;col++)
  1656. {
  1657. colinfo = resinfo->columns[col];
  1658. collen = _get_printable_size(colinfo);
  1659. namlen = strlen(colinfo->column_name);
  1660. len += collen > namlen ? collen : namlen;
  1661. }
  1662. /* the space between each column */
  1663. len += resinfo->num_cols - 1;
  1664. /* the newline */
  1665. len++;
  1667. return len;
  1668. }
  1669. RETCODE dbspr1row(DBPROCESS *dbproc, char *buffer, DBINT buf_len)
  1670. {
  1671. TDSCOLINFO * colinfo;
  1672. TDSRESULTINFO * resinfo;
  1673. TDSSOCKET * tds;
  1674. int i,col,collen,namlen,len;
  1675. char dest[256];
  1676. int desttype, srctype;
  1677. int buf_cur=0;
  1678. RETCODE ret;
  1680. tds = (TDSSOCKET *) dbproc->tds_socket;
  1681. resinfo = tds->res_info;
  1683. buffer[0]='';
  1685. if ((ret = dbnextrow(dbproc))!=REG_ROW) 
  1686. return ret;
  1688. for (col=0;col<resinfo->num_cols;col++)
  1689. {
  1690. colinfo = resinfo->columns[col];
  1691. if (tds_get_null(resinfo->current_row,col)) {
  1692. strcpy(dest,"NULL");
  1693. } else {
  1694. desttype = _db_get_server_type(STRINGBIND);
  1695. srctype = tds_get_conversion_type(colinfo->column_type,colinfo->column_size);
  1696. dbconvert(dbproc, srctype ,dbdata(dbproc,col+1), -1, desttype, (BYTE *)dest, 255);
  1698. }
  1699. collen = _get_printable_size(colinfo);
  1700. namlen = strlen(colinfo->column_name);
  1701. len = collen > namlen ? collen : namlen;
  1702. for (i=strlen(dest);i<len;i++)
  1703. strcat(dest," ");
  1704. if (strlen(dest) + buf_cur < buf_len) {
  1705. strcat(buffer,dest);
  1706. buf_cur+=strlen(dest);
  1707. }
  1708. if (strlen(buffer)<buf_len) {
  1709. strcat(buffer," ");
  1710. buf_cur++;
  1711. }
  1712. }
  1713. if (strlen(buffer)<buf_len) 
  1714. strcat(buffer,"n");
  1715. return ret;
  1716. }
  1718. RETCODE
  1719. dbprrow(DBPROCESS *dbproc)
  1720. {
  1721. TDSCOLINFO * colinfo;
  1722. TDSRESULTINFO * resinfo;
  1723. TDSSOCKET * tds;
  1724. int i,col,collen,namlen,len;
  1725. char dest[256];
  1726. int desttype, srctype;
  1728. tds = (TDSSOCKET *) dbproc->tds_socket;
  1729. resinfo = tds->res_info;
  1731. while(dbnextrow(dbproc)==REG_ROW) {
  1732. for (col=0;col<resinfo->num_cols;col++)
  1733. {
  1734. colinfo = resinfo->columns[col];
  1735. if (tds_get_null(resinfo->current_row,col)) {
  1736. strcpy(dest,"NULL");
  1737. } else {
  1738. desttype = _db_get_server_type(STRINGBIND);
  1739. srctype = tds_get_conversion_type(colinfo->column_type,colinfo->column_size);
  1740. dbconvert(dbproc, srctype ,dbdata(dbproc,col+1), -1, desttype, (BYTE *)dest, 255);
  1742. /* printf ("some datat"); */
  1743. }
  1744. printf("%s",dest);
  1745. collen = _get_printable_size(colinfo);
  1746. namlen = strlen(colinfo->column_name);
  1747. len = collen > namlen ? collen : namlen;
  1748. for (i=strlen(dest);i<len;i++)
  1749. printf(" ");
  1750. printf(" ");
  1751. }
  1752. printf ("n");
  1753. }
  1754. return SUCCEED;
  1755. }
  1756. static int _get_printable_size(TDSCOLINFO *colinfo)
  1757. {
  1758. switch (colinfo->column_type) {
  1759. case SYBINTN:
  1760. switch(colinfo->column_size) {
  1761. case 1: return 3;
  1762. case 2: return 6;
  1763. case 4: return 11;
  1764. }
  1765. case SYBINT1:
  1766. return 3;
  1767. case SYBINT2:
  1768. return 6;
  1769. case SYBINT4:
  1770.          return 11;
  1771. case SYBVARCHAR:
  1772. case SYBCHAR:
  1773. return colinfo->column_size;
  1774. case SYBFLT8:
  1775. return 11; /* FIX ME -- we do not track precision */
  1776. case SYBREAL:
  1777. return 11; /* FIX ME -- we do not track precision */
  1778. case SYBMONEY:
  1779.          return 12; /* FIX ME */
  1780. case SYBMONEY4:
  1781.          return 12; /* FIX ME */
  1782. case SYBDATETIME:
  1783.          return 26; /* FIX ME */
  1784. case SYBDATETIME4:
  1785.          return 26; /* FIX ME */
  1786. case SYBBIT:
  1787. case SYBBITN:
  1788. return 1;
  1789. /* FIX ME -- not all types present */
  1790. default:
  1791. return 0;
  1792. }
  1794. }
  1795. RETCODE dbsprline(DBPROCESS *dbproc,char *buffer, DBINT buf_len, DBCHAR line_char)
  1796. {
  1797. TDSCOLINFO * colinfo;
  1798. TDSRESULTINFO * resinfo;
  1799. TDSSOCKET * tds;
  1800. int i,col, len, collen, namlen;
  1801. char line_str[2],dest[256];
  1802. int buf_cur=0;
  1804. tds = (TDSSOCKET *) dbproc->tds_socket;
  1805. resinfo = tds->res_info;
  1807. buffer[0]='';
  1808. line_str[0]=line_char;
  1809. line_str[1]='';
  1811. for (col=0;col<resinfo->num_cols;col++)
  1812. {
  1813. dest[0]='';
  1814. colinfo = resinfo->columns[col];
  1815. collen = _get_printable_size(colinfo);
  1816. namlen = strlen(colinfo->column_name);
  1817. len = collen > namlen ? collen : namlen;
  1818. for (i=0;i<len;i++) 
  1819. strcat(dest,line_str);
  1820. if (strlen(dest)<buf_len-buf_cur) {
  1821. strcat(buffer,dest);
  1822. buf_cur += strlen(dest);
  1823. }
  1824. if (strlen(dest)<buf_len-buf_cur) {
  1825. strcat(buffer," ");
  1826. buf_cur++;
  1827. }
  1828. }
  1829. if (strlen(dest)<buf_len-buf_cur) 
  1830. strcat(buffer,"n");
  1831. return SUCCEED;
  1832. }
  1833. RETCODE dbsprhead(DBPROCESS *dbproc,char *buffer, DBINT buf_len)
  1834. {
  1835. TDSCOLINFO * colinfo;
  1836. TDSRESULTINFO * resinfo;
  1837. TDSSOCKET * tds;
  1838. int i,col, len, collen, namlen;
  1839. char dest[256];
  1840. int buf_cur=0;
  1842. tds = (TDSSOCKET *) dbproc->tds_socket;
  1843. resinfo = tds->res_info;
  1845. buffer[0]='';
  1847. for (col=0;col<resinfo->num_cols;col++)
  1848. {
  1849. colinfo = resinfo->columns[col];
  1850. collen = _get_printable_size(colinfo);
  1851. namlen = strlen(colinfo->column_name);
  1852. len = collen > namlen ? collen : namlen;
  1853. strcpy(dest,colinfo->column_name);
  1854. for (i=strlen(colinfo->column_name);i<len;i++)
  1855. strcat(dest," ");
  1856. if (strlen(dest) < buf_len-buf_cur) {
  1857. strcat(buffer,dest);
  1858. buf_cur += strlen(dest);
  1859. }
  1860. if (strlen(dest) < buf_len-buf_cur) {
  1861. strcat(buffer," ");
  1862. buf_cur++;
  1863. }
  1864. }
  1865. if (strlen(dest) < buf_len-buf_cur) 
  1866. strcat(buffer,"n");
  1867. return SUCCEED;
  1868. }
  1869. void dbprhead(DBPROCESS *dbproc)
  1870. {
  1871. TDSCOLINFO * colinfo;
  1872. TDSRESULTINFO * resinfo;
  1873. TDSSOCKET * tds;
  1874. int i,col, len, collen, namlen;
  1876. tds = (TDSSOCKET *) dbproc->tds_socket;
  1877. resinfo = tds->res_info;
  1878. for (col=0;col<resinfo->num_cols;col++)
  1879. {
  1880. colinfo = resinfo->columns[col];
  1881. collen = _get_printable_size(colinfo);
  1882. namlen = strlen(colinfo->column_name);
  1883. len = collen > namlen ? collen : namlen;
  1884. printf("%s",colinfo->column_name);
  1885. for (i=strlen(colinfo->column_name);i<len;i++)
  1886. printf(" ");
  1887. printf(" ");
  1888. }
  1889. printf ("n");
  1890. for (col=0;col<resinfo->num_cols;col++)
  1891. {
  1892. colinfo = resinfo->columns[col];
  1893. collen = _get_printable_size(colinfo);
  1894. namlen = strlen(colinfo->column_name);
  1895. len = collen > namlen ? collen : namlen;
  1896. for (i=0;i<len;i++)
  1897. printf("-");
  1898. printf(" ");
  1899. }
  1900. printf ("n");
  1902. }
  1904. RETCODE
  1905. dbrows(DBPROCESS *dbproc)
  1906. {
  1907. TDSRESULTINFO * resinfo;
  1908. TDSSOCKET * tds;
  1910. tds = (TDSSOCKET *) dbproc->tds_socket;
  1911. resinfo = tds->res_info;
  1912. if (resinfo && resinfo->rows_exist) return SUCCEED;
  1913. else return FAIL;
  1914. }
  1915. /* STUBS */
  1916. RETCODE dbsetdeflang(char *language)
  1917. {
  1918. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetdeflang()n");
  1919. return SUCCEED;
  1920. }
  1921. int dbgetpacket(DBPROCESS *dbproc)
  1922. {
  1923. TDSSOCKET *tds = dbproc->tds_socket;
  1925. if (!tds || !tds->env) {
  1926. return TDS_DEF_BLKSZ;
  1927. } else {
  1928. return tds->env->block_size;
  1929. }
  1930. }
  1931. RETCODE dbsetmaxprocs(int maxprocs)
  1932. {
  1933. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetmaxprocs()n");
  1934. return SUCCEED;
  1935. }
  1936. RETCODE dbsettime(int seconds)
  1937. {
  1938. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsettime()n");
  1939. return SUCCEED;
  1940. }
  1941. RETCODE dbsetlogintime(int seconds)
  1942. {
  1943. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetlogintime()n");
  1944. return SUCCEED;
  1945. }
  1946. DBBOOL dbhasretstat(DBPROCESS *dbproc)
  1947. {
  1948. TDSSOCKET *tds = (TDSSOCKET *) dbproc->tds_socket;
  1949. if (tds->has_status) {
  1950. return TRUE;
  1951. } else {
  1952. return FALSE;
  1953. }
  1954. }
  1955. DBINT dbretstatus(DBPROCESS *dbproc)
  1956. {
  1957. TDSSOCKET *tds = (TDSSOCKET *) dbproc->tds_socket;
  1958. return tds->ret_status;
  1959. }
  1960. RETCODE dbcmdrow(DBPROCESS *dbproc)
  1961. {
  1962.         TDSSOCKET *tds = (TDSSOCKET *) dbproc->tds_socket;
  1963.         if (tds->res_info)
  1964.                 return SUCCEED;
  1965.         return TDS_FAIL;
  1966. }
  1967. int dbaltcolid(DBPROCESS *dbproc, int computeid, int column)
  1968. {
  1969. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbaltcolid()n");
  1970. return -1;
  1971. }
  1972. DBINT 
  1973. dbadlen(DBPROCESS *dbproc,int computeid, int column)
  1974. {
  1975. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbaddlen()n");
  1976. return 0;
  1977. }
  1978. int dbalttype(DBPROCESS *dbproc, int computeid, int column)
  1979. {
  1980. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbalttype()n");
  1981. return 0;
  1982. }
  1983. BYTE *dbadata(DBPROCESS *dbproc, int computeid, int column)
  1984. {
  1985. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbadata()n");
  1986. return (BYTE*)"";
  1987. }
  1988. int dbaltop(DBPROCESS *dbproc, int computeid, int column)
  1989. {
  1990. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbaltop()n");
  1991. return -1;
  1992. }
  1993. RETCODE dbsetopt(DBPROCESS *dbproc, int option, char *char_param, int int_param)
  1994. {
  1995.    switch (option) {
  1996.       case DBBUFFER:
  1997.       {
  1998.          /* XXX should be more robust than just a atoi() */
  1999.          buffer_set_buffering(&(dbproc->row_buf), atoi(char_param));
  2000.          break;
  2001.       }
  2002.       default:
  2003.       {
  2004.          break;
  2005.       }
  2006.    }
  2007.    return SUCCEED;
  2008. }
  2010. void
  2011. dbsetinterrupt(DBPROCESS *dbproc, int (*ckintr)(),int (*hndlintr)())
  2012. {
  2013. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetinterrupt()n");
  2014. }
  2015. int dbnumrets(DBPROCESS *dbproc)
  2016. {
  2017. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbnumrets()n");
  2018. return 0;
  2019. }
  2020. char *dbretname(DBPROCESS *dbproc, int retnum)
  2021. {
  2022. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbretname()n");
  2023. return NULL;
  2024. }
  2025. BYTE *dbretdata(DBPROCESS *dbproc, int retnum)
  2026. {
  2027. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbretdata()n");
  2028. return NULL;
  2029. }
  2030. int dbretlen(DBPROCESS *dbproc, int retnum)
  2031. {
  2032. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbretlen()n");
  2033. return -1;
  2034. }
  2035. RETCODE dbsqlok(DBPROCESS *dbproc)
  2036. {
  2037. unsigned char   marker;
  2038. RETCODE rc = SUCCEED;
  2039. TDSSOCKET *tds;
  2041. tds = (TDSSOCKET *) dbproc->tds_socket;
  2043. if (dbproc->text_sent) {
  2044. tds_flush_packet(tds);
  2045. dbproc->text_sent = 0;
  2047. do {
  2048. marker = tds_get_byte(tds);
  2049. if(tds->s == 0) return FAIL;
  2050. tds_process_default_tokens(tds, marker);
  2051. } while (marker!=TDS_DONE_TOKEN);
  2053. return SUCCEED;
  2054. }
  2055.    /*
  2056.     * See what the next packet from the server is.  If it is an error
  2057.     * then we should return FAIL
  2058.     */
  2059. /* Calling dbsqlexec on an update only stored proc should read all tokens
  2060. while (is_msg_token(tds_peek(tds))) {
  2061. marker = tds_get_byte(tds);
  2062. if (tds_process_default_tokens(tds, marker)!=TDS_SUCCEED) {
  2063. rc=FAIL;
  2064. }
  2065. } 
  2066. */
  2067. do {
  2068. marker = tds_peek(tds);
  2069. if (!is_result_token(marker)) {
  2070. marker = tds_get_byte(tds);
  2071. /* tds_process_default_tokens can return TDS_ERROR in which case
  2072. ** we still want to read til end, but TDS_FAIL is an unrecoverable
  2073. ** error */
  2074. if (tds_process_default_tokens(tds, marker)!=TDS_SUCCEED) {
  2075. rc=FAIL;
  2076. }
  2077. }
  2078. #ifdef NCBI_FTDS
  2079. if(tds->s == 0) return FAIL;
  2080. #endif
  2081. } while (!is_hard_end_token(marker) && !is_result_token(marker));
  2083. /* clean up */
  2084. if (rc==FAIL && !is_end_token(marker)) {
  2085. do {
  2086. marker = tds_get_byte(tds);
  2087. if (tds_process_default_tokens(tds, marker)!=TDS_SUCCEED) {
  2088. return FAIL;
  2089. }
  2090. #ifdef NCBI_FTDS
  2091. if(tds->s == 0) return FAIL;
  2092. #endif
  2093. } while (marker!=TDS_DONE_TOKEN);
  2094. }
  2095. return rc;
  2096. }
  2097. int dbnumalts(DBPROCESS *dbproc,int computeid)
  2098. {
  2099. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbnumalts()n");
  2100. return 0;
  2101. }
  2102. BYTE *
  2103. dbbylist(DBPROCESS *dbproc, int computeid, int *size)
  2104. {
  2105. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbbylist()n");
  2106. if (size) *size = 0;
  2107. return NULL;
  2108. }
  2109. DBBOOL dbdead(DBPROCESS *dbproc)
  2110. {
  2111. if(dbproc &&
  2112. dbproc->tds_socket &&
  2113. dbproc->tds_socket->s)
  2114. return FALSE;
  2115. else
  2116. return TRUE;
  2117. }
  2119. EHANDLEFUNC
  2120. dberrhandle(EHANDLEFUNC handler)
  2121. {
  2122.    EHANDLEFUNC retFun = g_dblib_err_handler;
  2124.    g_dblib_err_handler = handler;
  2125.    return retFun;
  2126. }
  2128. MHANDLEFUNC
  2129. dbmsghandle(MHANDLEFUNC handler)
  2130. {
  2131.    MHANDLEFUNC retFun = g_dblib_msg_handler;
  2133.    g_dblib_msg_handler = handler;
  2134.    return retFun;
  2135. }
  2137. RETCODE dbmnyadd(DBPROCESS *dbproc, DBMONEY *m1, DBMONEY *m2, DBMONEY *sum)
  2138. {
  2139.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyadd()n");
  2140. return SUCCEED;
  2141. }
  2142. RETCODE dbmnysub(DBPROCESS *dbproc, DBMONEY *m1, DBMONEY *m2, DBMONEY *diff)
  2143. {
  2144.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnysyb()n");
  2145. return SUCCEED;
  2146. }
  2147. RETCODE dbmnymul(DBPROCESS *dbproc, DBMONEY *m1, DBMONEY *m2, DBMONEY *prod)
  2148. {
  2149.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnymul()n");
  2150. return SUCCEED;
  2151. }
  2152. RETCODE dbmnydivide(DBPROCESS *dbproc, DBMONEY *m1, DBMONEY *m2, DBMONEY *quotient)
  2153. {
  2154.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnydivide()n");
  2155. return SUCCEED;
  2156. }
  2157. RETCODE dbmnycmp(DBPROCESS *dbproc, DBMONEY *m1, DBMONEY *m2)
  2158. {
  2159.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnycmp()n");
  2160. return SUCCEED;
  2161. }
  2162. RETCODE dbmnyscale(DBPROCESS *dbproc, DBMONEY *dest, int multiplier, int addend)
  2163. {
  2164.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyscale()n");
  2165. return SUCCEED;
  2166. }
  2167. RETCODE dbmnyzero(DBPROCESS *dbproc, DBMONEY *dest)
  2168. {
  2169.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyzero()n");
  2170. return SUCCEED;
  2171. }
  2172. RETCODE dbmnymaxpos(DBPROCESS *dbproc, DBMONEY *dest)
  2173. {
  2174.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnymaxpos()n");
  2175. return SUCCEED;
  2176. }
  2177. RETCODE dbmnymaxneg(DBPROCESS *dbproc, DBMONEY *dest)
  2178. {
  2179.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnymaxneg()n");
  2180. return SUCCEED;
  2181. }
  2182. RETCODE dbmnyndigit(DBPROCESS *dbproc, DBMONEY *mnyptr,DBCHAR *value, DBBOOL *zero)
  2183. {
  2184.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyndigit()n");
  2185. return SUCCEED;
  2186. }
  2187. RETCODE dbmnyinit(DBPROCESS *dbproc,DBMONEY *mnyptr, int trim, DBBOOL *negative)
  2188. {
  2189.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyinit()n");
  2190. return SUCCEED;
  2191. }
  2192. RETCODE dbmnydown(DBPROCESS *dbproc,DBMONEY *mnyptr, int divisor, int *remainder)
  2193. {
  2194.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnydown()n");
  2195. return SUCCEED;
  2196. }
  2197. RETCODE dbmnyinc(DBPROCESS *dbproc,DBMONEY *mnyptr)
  2198. {
  2199.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyinc()n");
  2200. return SUCCEED;
  2201. }
  2202. RETCODE dbmnydec(DBPROCESS *dbproc,DBMONEY *mnyptr)
  2203. {
  2204.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnydec()n");
  2205. return SUCCEED;
  2206. }
  2207. RETCODE dbmnyminus(DBPROCESS *dbproc,DBMONEY *src, DBMONEY *dest)
  2208. {
  2209.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyminus()n");
  2210. return SUCCEED;
  2211. }
  2212. RETCODE dbmny4minus(DBPROCESS *dbproc, DBMONEY4 *src, DBMONEY4 *dest)
  2213. {
  2214.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4minus()n");
  2215. return SUCCEED;
  2216. }
  2217. RETCODE dbmny4zero(DBPROCESS *dbproc, DBMONEY4 *dest)
  2218. {
  2219.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4zero()n");
  2220. return SUCCEED;
  2221. }
  2222. RETCODE dbmny4add(DBPROCESS *dbproc, DBMONEY4 *m1, DBMONEY4 *m2, DBMONEY4 *sum)
  2223. {
  2224.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4add()n");
  2225. return SUCCEED;
  2226. }
  2227. RETCODE dbmny4sub(DBPROCESS *dbproc, DBMONEY4 *m1, DBMONEY4 *m2, DBMONEY4 *diff)
  2228. {
  2229.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4sub()n");
  2230. return SUCCEED;
  2231. }
  2232. RETCODE dbmny4mul(DBPROCESS *dbproc, DBMONEY4 *m1, DBMONEY4 *m2, DBMONEY4 *prod)
  2233. {
  2234.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4mul()n");
  2235. return SUCCEED;
  2236. }
  2237. RETCODE dbmny4divide(DBPROCESS *dbproc, DBMONEY4 *m1, DBMONEY4 *m2, DBMONEY4 *quotient)
  2238. {
  2239.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4divide()n");
  2240. return SUCCEED;
  2241. }
  2242. RETCODE dbmny4cmp(DBPROCESS *dbproc, DBMONEY4 *m1, DBMONEY4 *m2)
  2243. {
  2244.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4cmp()n");
  2245. return SUCCEED;
  2246. }
  2247. RETCODE dbdatecmp(DBPROCESS *dbproc, DBDATETIME *d1, DBDATETIME *d2)
  2248. {
  2249. if (d1->dtdays == d2->dtdays ) {
  2250. if ( d1->dttime == d2->dttime )
  2251. return 0;
  2252. else
  2253. return d1->dttime > d2->dttime ? 1 : -1 ;
  2254. }
  2256. /* date 1 is before 1900 */
  2257. if (d1->dtdays > 2958463) {
  2259. if (d2->dtdays > 2958463) /* date 2 is before 1900 */
  2260. return d1->dtdays > d2->dtdays ? 1 : -1 ;
  2261. else
  2262. return -1;
  2263. } else {
  2264. /* date 1 is after 1900 */
  2265. if (d2->dtdays < 2958463) /* date 2 is after 1900 */
  2266. return d1->dtdays > d2->dtdays ? 1 : -1 ;
  2267. else
  2268. return 1;
  2269. }
  2270. return SUCCEED;
  2271. }
  2272. RETCODE dbdatecrack(DBPROCESS *dbproc, DBDATEREC *di, DBDATETIME *dt)
  2273. {
  2274. TDSDATEREC dr;
  2276. tds_datecrack(SYBDATETIME, dt, &dr);
  2278. #ifndef MSDBLIB
  2279. di->dateyear    = dr.year;
  2280. di->datemonth   = dr.month;
  2281. di->datedmonth  = dr.day;
  2282. di->datedyear   = dr.dayofyear;
  2283. di->datedweek   = dr.weekday;
  2284. di->datehour    = dr.hour;
  2285. di->dateminute  = dr.minute;
  2286. di->datesecond  = dr.second;
  2287. di->datemsecond = dr.millisecond;
  2288. #else
  2289. di->year        = dr.year;
  2290. di->month       = dr.month + 1;
  2291. di->day         = dr.day;
  2292. di->dayofyear   = dr.dayofyear;
  2293. di->weekday     = dr.weekday + 1;
  2294. di->hour        = dr.hour;
  2295. di->minute      = dr.minute;
  2296. di->second      = dr.second;
  2297. di->millisecond = dr.millisecond;
  2298. #endif
  2299. return SUCCEED;
  2300. }
  2302. void dbrpwclr(LOGINREC *login)
  2303. {
  2304.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbrpwclr()n");
  2305. }
  2306. RETCODE dbrpwset(LOGINREC *login, char *srvname, char *password, int pwlen)
  2307. {
  2308.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbrpwset()n");
  2309. return SUCCEED;
  2310. }
  2311. int dbspid(DBPROCESS *dbproc)
  2312. {
  2313.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbspid()n");
  2314. return 0;
  2315. }
  2316. void
  2317. dbsetuserdata(DBPROCESS *dbproc, BYTE *ptr)
  2318. {
  2319. dbproc->user_data = ptr;
  2320. return;
  2321. }
  2322. BYTE *dbgetuserdata(DBPROCESS *dbproc)
  2323. {
  2324. return dbproc->user_data;
  2325. }
  2326. RETCODE dbsetversion(DBINT version)
  2327. {
  2328. g_dblib_version  = version;
  2329. return SUCCEED;
  2330. }
  2331. RETCODE dbmnycopy(DBPROCESS *dbproc, DBMONEY *src, DBMONEY *dest)
  2332. {
  2333. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnycopy()n");
  2334. return SUCCEED;
  2335. }
  2336. RETCODE dbcanquery(DBPROCESS *dbproc)
  2337. {
  2338. TDSSOCKET *tds;
  2339. int rc;
  2341. if (dbproc == NULL)
  2342. return FAIL;
  2343. tds = (TDSSOCKET *) dbproc->tds_socket;
  2344. if (!tds || !tds->s) 
  2345. return FAIL;
  2347. /*
  2348.  *  Just throw away all pending rows from the last query
  2349.  */
  2350. do {
  2351. rc = tds_process_row_tokens(dbproc->tds_socket);
  2352. } while (rc == TDS_SUCCEED);
  2354. if (rc == TDS_FAIL)
  2355. return FAIL;
  2357. return SUCCEED;
  2358. }
  2359. void dbfreebuf(DBPROCESS *dbproc)
  2360. {
  2361. if(dbproc->dbbuf) {
  2362. free(dbproc->dbbuf);
  2363. dbproc->dbbuf = NULL;
  2364. }
  2365. dbproc->dbbufsz = 0;
  2366. } /* dbfreebuf()  */
  2368. RETCODE dbclropt(DBPROCESS *dbproc,int option, char *param)
  2369. {
  2370.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbcltopt()n");
  2371. return SUCCEED;
  2372. }
  2373. DBBOOL dbisopt(DBPROCESS *dbproc,int option, char *param)
  2374. {
  2375.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbisopt()n");
  2376. return TRUE;
  2377. }
  2378. DBINT dbcurrow(DBPROCESS *dbproc)
  2379. {
  2380.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbcurrow()n");
  2381. return 0;
  2382. }
  2383. STATUS dbrowtype(DBPROCESS *dbproc)
  2384. {
  2385. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbrowtype()n");
  2386. return NO_MORE_ROWS;
  2387. }
  2388. int dbcurcmd(DBPROCESS *dbproc)
  2389. {
  2390.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbcurcmd()n");
  2391. return 0;
  2392. }
  2393. RETCODE dbmorecmds(DBPROCESS *dbproc)
  2394. {
  2395.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmorecmds()n");
  2396. return SUCCEED;
  2397. }
  2398. int dbrettype(DBPROCESS *dbproc,int retnum)
  2399. {
  2400.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbrettype()n");
  2401. return 0;
  2402. }
  2403. int dbstrlen(DBPROCESS *dbproc)
  2404. {
  2405. return dbproc->dbbufsz;
  2406. }
  2407. char *dbgetchar(DBPROCESS *dbproc, int pos)
  2408. {
  2409.      if (dbproc->dbbufsz > 0) {
  2410.        if (pos >= 0 && pos < dbproc->dbbufsz )
  2411.             return (char*)&dbproc->dbbuf[pos];
  2412.        else
  2413.           return (char *)NULL;
  2414.      }
  2415.     else
  2416.         return (char *)NULL;
  2417. }
  2418. RETCODE dbstrcpy(DBPROCESS *dbproc, int start, int numbytes, char *dest)
  2419. {
  2420. dest[0] = 0; /* start with empty string being returned */
  2421. if (dbproc->dbbufsz>0) {
  2422. strncpy(dest, (char*)&dbproc->dbbuf[start], numbytes);
  2423. }
  2424. return SUCCEED;
  2425. }
  2426. RETCODE dbsafestr(DBPROCESS *dbproc,char *src, DBINT srclen, char *dest, DBINT destlen, int quotetype)
  2427. {
  2428. int i, j = 0;
  2429. int squote = FALSE, dquote = FALSE;
  2432. /* check parameters */
  2433. if (srclen<-1 || destlen<-1)
  2434. return FAIL;
  2436. if (srclen==-1) 
  2437. srclen = strlen(src);
  2439. if (quotetype == DBSINGLE || quotetype == DBBOTH)
  2440. squote = TRUE;
  2441. if (quotetype == DBDOUBLE || quotetype == DBBOTH)
  2442. dquote = TRUE;
  2444. /* return FAIL if invalid quotetype */
  2445. if (!dquote && !squote)
  2446. return FAIL;
  2449. for (i=0;i<srclen;i++) {
  2451. /* dbsafestr returns fail if the deststr is not big enough */
  2452. /* need one char + one for terminator */
  2453. if (destlen >= 0 && j>=destlen)
  2454. return FAIL;
  2456. if (squote && src[i]==''')
  2457. dest[j++] = ''';
  2458. else if (dquote && src[i]=='"')
  2459. dest[j++] = '"';
  2461. if (destlen >= 0 && j>=destlen)
  2462. return FAIL;
  2464. dest[j++] = src[i];
  2465. }
  2467. if (destlen >= 0 && j>=destlen)
  2468. return FAIL;
  2470. dest[j]='';
  2471. return SUCCEED;
  2472. }
  2473. char *dbprtype(int token)
  2474. {
  2475.    char  *result = NULL;
  2477. /* 
  2478.  * I added several types, but came up with my own result names
  2479.  * since I don't have an MS platform to compare to. --jkl
  2480.  */
  2481.    switch (token)
  2482.    {
  2483.       case SYBAOPAVG:       result = "avg";              break;
  2484.       case SYBAOPCNT:       result = "count";            break;
  2485.       case SYBAOPMAX:       result = "max";              break;
  2486.       case SYBAOPMIN:       result = "min";              break;
  2487.       case SYBAOPSUM:       result = "sum";              break;
  2488.  
  2489.       case SYBBINARY:       result = "binary";           break;
  2490.       case SYBBIT:          result = "bit";              break;
  2491.       case SYBBITN:         result = "bit-null";         break;
  2492.       case SYBCHAR:         result = "char";             break;
  2493.       case SYBDATETIME4:    result = "smalldatetime";    break;
  2494.       case SYBDATETIME:     result = "datetime";         break;
  2495.       case SYBDATETIMN:     result = "datetime-null";    break;
  2496.       case SYBDECIMAL:      result = "decimal";          break;
  2497.       case SYBFLT8:         result = "float";            break;
  2498.       case SYBFLTN:         result = "float-null";       break;
  2499.       case SYBIMAGE:        result = "image";            break;
  2500.       case SYBINT1:         result = "tinyint";          break;
  2501.       case SYBINT2:         result = "smallint";         break;
  2502.       case SYBINT4:         result = "int";              break;
  2503.       case SYBINT8:         result = "long long";        break;
  2504.       case SYBINTN:         result = "integer-null";     break;
  2505.       case SYBMONEY4:       result = "smallmoney";       break;
  2506.       case SYBMONEY:        result = "money";            break;
  2507.       case SYBMONEYN:       result = "money-null";       break;
  2508.       case SYBNTEXT:      result = "UCS-2 text";       break;
  2509.       case SYBNVARCHAR:     result = "UCS-2 varchar";   break;
  2510.       case SYBNUMERIC:      result = "numeric";          break;
  2511.       case SYBREAL:         result = "real";             break;
  2512.       case SYBTEXT:         result = "text";             break;
  2513.       case SYBUNIQUE:       result = "uniqueidentifier"; break;
  2514.       case SYBVARBINARY:    result = "varbinary";        break;
  2515.       case SYBVARCHAR:      result = "varchar";          break;
  2517.       case SYBVARIANT  :    result = "variant ";      break;
  2518.       case SYBVOID    :    result = "void";         break;
  2519.       case XSYBBINARY  :    result = "xbinary";      break;
  2520.       case XSYBCHAR    :    result = "xchar";      break;
  2521.       case XSYBNCHAR   :    result = "x UCS-2 char"; break;
  2522.       case XSYBNVARCHAR:    result = "x UCS-2 varchar"; break;
  2523.       case XSYBVARBINARY:   result = "xvarbinary";      break;
  2524.       case XSYBVARCHAR :    result = "xvarchar ";      break;
  2526.       default:              result = "";                 break;
  2527.    }
  2528.    return result;
  2529. } 
  2531. DBBINARY *dbtxtimestamp(DBPROCESS *dbproc, int column)
  2532. {
  2533. TDSSOCKET *tds;
  2534. TDSRESULTINFO * resinfo;
  2536.    tds = (TDSSOCKET *) dbproc->tds_socket;
  2537.    if (!tds->res_info) return NULL;
  2538.    resinfo = tds->res_info;
  2539.    if (column < 1 || column > resinfo->num_cols) return NULL;
  2540.    /* else */
  2541.    return (DBBINARY *) resinfo->columns[column-1]->column_timestamp;
  2542. }
  2543. DBBINARY *dbtxptr(DBPROCESS *dbproc,int column)
  2544. {
  2545. TDSSOCKET *tds;
  2546. TDSRESULTINFO * resinfo;
  2548.    tds = (TDSSOCKET *) dbproc->tds_socket;
  2549.    if (!tds->res_info) return NULL;
  2550.    resinfo = tds->res_info;
  2551.    if (column < 1 || column > resinfo->num_cols) return NULL;
  2552.    /* else */
  2553.    return (DBBINARY *) &resinfo->columns[column-1]->column_textptr;
  2554. }
  2556. RETCODE
  2557. dbwritetext(DBPROCESS *dbproc, char *objname, DBBINARY *textptr, DBTINYINT textptrlen, DBBINARY *timestamp, DBBOOL log, DBINT size, BYTE *text)
  2558. {
  2559. char query[1024];
  2560. char textptr_string[35]; /* 16 * 2 + 2 (0x) + 1 */
  2561. char timestamp_string[19]; /* 8 * 2 + 2 (0x) + 1 */
  2562. int marker;
  2563. TDSSOCKET *tds = (TDSSOCKET *) dbproc->tds_socket;
  2565.     if (textptrlen > DBTXPLEN) return FAIL;
  2566.     dbconvert(dbproc, SYBBINARY, (TDS_CHAR *)textptr, textptrlen, SYBCHAR, textptr_string, -1);
  2567.     dbconvert(dbproc, SYBBINARY, (TDS_CHAR *)timestamp, 8, SYBCHAR, timestamp_string, -1);
  2568.     
  2570. sprintf(query, "writetext bulk %s 0x%s timestamp = 0x%s",
  2571. objname, textptr_string, timestamp_string); 
  2572. if (tds_submit_query(dbproc->tds_socket, query)!=TDS_SUCCEED) {
  2573. return FAIL;
  2574. }
  2576. #ifdef NCBI_FTDS
  2577.     if (!dbproc->tds_socket->s) return FAIL;
  2578. dbproc->tds_socket->out_flag=0x07;
  2579. tds_put_int(dbproc->tds_socket, size);
  2581. if (!text) {
  2582. dbproc->text_size = size;
  2583. dbproc->text_sent = 0;
  2584. return SUCCEED;
  2585. }
  2586. #endif
  2588. /* read the end token */
  2589. marker = tds_get_byte(dbproc->tds_socket);
  2591.     if (!dbproc->tds_socket->s) return FAIL;
  2593. tds_process_default_tokens(dbproc->tds_socket, marker);
  2594. if (marker != TDS_DONE_TOKEN) {
  2595. return FAIL;
  2596. }
  2598. #ifndef NCBI_FTDS
  2599. dbproc->tds_socket->out_flag=0x07;
  2600. tds_put_int(dbproc->tds_socket, size);
  2602. if (!text) {
  2603. dbproc->text_size = size;
  2604. dbproc->text_sent = 0;
  2605. return SUCCEED;
  2606. }
  2607. #endif
  2609. tds_put_bulk_data(dbproc->tds_socket, text, size);
  2610. tds_flush_packet(dbproc->tds_socket);
  2612. do {
  2613. marker = tds_get_byte(dbproc->tds_socket);
  2614. if(marker == 0 && dbproc->tds_socket->s == 0) return FAIL;
  2615. tds_process_default_tokens(dbproc->tds_socket, marker);
  2616. } while (marker!=TDS_DONE_TOKEN);
  2618. return SUCCEED;
  2619. }
  2620. STATUS dbreadtext(DBPROCESS *dbproc, void *buf, DBINT bufsize)
  2621. {
  2622. TDSSOCKET *tds;
  2623. TDSCOLINFO *curcol;
  2624. int cpbytes, bytes_avail, rc;
  2626. tds = dbproc->tds_socket;
  2628. if (!tds || !tds->res_info || !tds->res_info->columns[0])
  2629. return -1;
  2631. curcol = tds->res_info->columns[0];
  2633. /* if the current position is beyond the end of the text
  2634. ** set pos to 0 and return 0 to denote the end of the 
  2635. ** text */
  2636. if (curcol->column_textpos &&
  2637.    curcol->column_textpos>=curcol->column_textsize) {
  2638. curcol->column_textpos = 0;
  2639. return 0;
  2640. }
  2642. /* if pos is 0 (first time through or last call exhausted the text)
  2643. ** then read another row */ 
  2644. if (curcol->column_textpos==0) {
  2645.          rc = tds_process_row_tokens(dbproc->tds_socket);
  2646.          if (rc != TDS_SUCCEED) {
  2647. return NO_MORE_ROWS;
  2648. }
  2649. }
  2651. /* find the number of bytes to return */
  2652. bytes_avail = curcol->column_textsize - curcol->column_textpos;
  2653. cpbytes = bytes_avail > bufsize ? bufsize : bytes_avail;
  2654. memcpy(buf,&curcol->column_textvalue[curcol->column_textpos],cpbytes);
  2655. curcol->column_textpos += cpbytes;
  2656. return cpbytes;
  2657. }
  2658. RETCODE dbmoretext(DBPROCESS *dbproc, DBINT size, BYTE *text)
  2659. {
  2660. tds_put_bulk_data(dbproc->tds_socket, text, size);
  2661. dbproc->text_sent += size;
  2663. return SUCCEED;
  2664. }
  2665. void dbrecftos(char *filename)
  2666. {
  2667. }
  2668. char *dbversion()
  2669. {
  2670.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbversion()n");
  2671. return NULL;
  2672. }
  2673. RETCODE dbsetdefcharset(char *charset)
  2674. {
  2675.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetdefcharset()n");
  2676. return SUCCEED;
  2677. }
  2678. RETCODE dbreginit(
  2679.       DBPROCESS *dbproc,
  2680.       DBCHAR *procedure_name,
  2681.       DBSMALLINT namelen )
  2682. {
  2683.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbreginit()n");
  2684.         return SUCCEED;
  2685. }
  2686. RETCODE dbreglist(DBPROCESS *dbproc)
  2687. {
  2688.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbreglist()n");
  2689.         return SUCCEED;
  2690. }
  2691. RETCODE dbregparam(
  2692.       DBPROCESS    *dbproc,
  2693.       char         *param_name,
  2694.       int          type,
  2695.       DBINT        datalen,
  2696.       BYTE         *data )
  2697. {
  2698.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbregparam()n");
  2699.         return SUCCEED;
  2700. }
  2701. RETCODE dbregexec(
  2702.       DBPROCESS      *dbproc,
  2703.       DBUSMALLINT    options)
  2704. {
  2705.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbregexec()n");
  2706. return SUCCEED;
  2707. }
  2708. char      *dbmonthname(DBPROCESS *dbproc,char *language,int monthnum,DBBOOL shortform)
  2709. {
  2710. char *shortmon[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
  2711. char *longmon[] = {"January","February","March","April","May","June","July","August","September","October","November","December"};
  2713. if (shortform)
  2714. return shortmon[monthnum-1];
  2715. else
  2716. return longmon[monthnum-1];
  2717. }
  2718. char      *dbname(DBPROCESS *dbproc)
  2719. {
  2720. return NULL;
  2721. }
  2722. RETCODE dbsqlsend(DBPROCESS *dbproc)
  2723. {
  2724. int   result = FAIL;
  2725. TDSSOCKET *tds;
  2727. dbproc->avail_flag = FALSE;
  2729. tds = (TDSSOCKET *) dbproc->tds_socket;
  2730. if (tds->res_info && tds->res_info->more_results) {
  2731.       /* 
  2732.        * XXX If I read the documentation correctly it gets a
  2733.        * bit more complicated than this.
  2734.        *
  2735.        * You see if the person did a query and retrieved all 
  2736.        * the rows but didn't call dbresults() and if the query 
  2737.        * didn't return multiple results then this routine should
  2738.        * just end the TDS_DONE_TOKEN packet and be done with it.
  2739.        *
  2740.        * Unfortunately the only way we can know that is by peeking 
  2741.        * ahead to the next byte.  Peeking could block and this is supposed
  2742.        * to be a non-blocking call.  
  2743.        *
  2744.        */
  2745.  
  2746.       result = FAIL;
  2747.    }
  2748.    else
  2749.    {
  2750.       dbproc->more_results = TRUE;
  2751.       dbproc->empty_res_hack = 0;
  2752.       if (tds_submit_query(dbproc->tds_socket, (char *)dbproc->dbbuf)!=TDS_SUCCEED) {
  2753. return FAIL;
  2754.       }
  2755.       if (! dbproc->noautofree)
  2756.       {
  2757. dbfreebuf(dbproc);
  2758.       }
  2759.       result = SUCCEED;
  2760.    }
  2761.    return result;
  2762. }
  2763. RETCODE dbaltutype(DBPROCESS *dbproc, int computeid, int column)
  2764. {
  2765.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbaltutype()n");
  2766. return SUCCEED;
  2767. }
  2768. RETCODE dbaltlen(DBPROCESS *dbproc, int computeid, int column)
  2769. {
  2770.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbaltlen()n");
  2771. return SUCCEED;
  2772. }
  2773. RETCODE dbpoll(DBPROCESS *dbproc, long milliseconds, DBPROCESS **ready_dbproc, int *return_reason)
  2774. {
  2775.         tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbpoll()n");
  2776. return SUCCEED;
  2777. }
  2779. DBINT dblastrow(DBPROCESS *dbproc)
  2780. {
  2781. TDSRESULTINFO * resinfo;
  2782. TDSSOCKET * tds;
  2784. tds = (TDSSOCKET *) dbproc->tds_socket;
  2785. resinfo = tds->res_info;
  2786. return resinfo->row_count;
  2787. #if 0
  2788.   DBINT   result;
  2790.    if (dbproc->row_buf.rows_in_buf == 0)
  2791.    {
  2792.       result = 0;
  2793.    }
  2794.    else
  2795.    {
  2796.       /* rows returned from the row buffer start with 1 instead of 0
  2797.       ** newest is 0 based. */
  2798.       result = dbproc->row_buf.newest + 1;
  2799.    }
  2800.    return result;
  2801. #endif
  2802. }
  2804. DBINT dbfirstrow(DBPROCESS *dbproc)
  2805. {
  2806.    DBINT   result;
  2808.    if (dbproc->row_buf.rows_in_buf == 0)
  2809.    {
  2810.       result = 0;
  2811.    }
  2812.    else
  2813.    {
  2814.       result = dbproc->row_buf.oldest;
  2815.    }
  2816.    return result;
  2817. }
  2818. int dbiordesc(DBPROCESS *dbproc)
  2819. {
  2820.    return dbproc->tds_socket->s;
  2821. }
  2822. int dbiowdesc(DBPROCESS *dbproc)
  2823. {
  2824.    return dbproc->tds_socket->s;
  2825. }
  2826.  
  2827. static void _set_null_value(DBPROCESS *dbproc, BYTE *varaddr, int datatype, int maxlen)
  2828. {
  2829. switch (datatype) {
  2830. case SYBINT4:
  2831. memset(varaddr,'',4);
  2832. break;
  2833. case SYBINT2:
  2834. memset(varaddr,'',2);
  2835. break;
  2836. case SYBINT1:
  2837. memset(varaddr,'',1);
  2838. break;
  2839. case SYBFLT8:
  2840. memset(varaddr,'',8);
  2841. break;
  2842. case SYBREAL:
  2843. memset(varaddr,'',4);
  2844. break;
  2845. case SYBCHAR:
  2846. case SYBVARCHAR:
  2847. varaddr[0]='';
  2848. break;
  2849. }
  2850. }
  2851. DBBOOL dbisavail(DBPROCESS *dbproc)
  2852. {
  2853. return dbproc->avail_flag;
  2854. }
  2855. void dbsetavail(DBPROCESS *dbproc)
  2856. {
  2857. dbproc->avail_flag = TRUE;
  2858. }