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

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

生物技术

开发平台：

C/C++

bcp.c：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: bcp.c,v $
  4.  * PRODUCTION Revision 1000.1  2003/11/17 22:20:13  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [ORIGINAL] Dev-tree R1.2
  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 <unistd.h>
  37. #ifdef TARGET_API_MAC_OS8
  38. #include <stdlib.h>
  39. #include "tdsconvert.h"
  40. #endif
  42. /*    was hard coded as 32768, but that made the local stack data size > 32K,
  43.     which is not allowed on Mac OS 8/9. (mlilback, 11/7/01) */
  44. #ifdef TARGET_API_MAC_OS8
  45. #define ROWBUF_SIZE 31000
  46. #else
  47. #define ROWBUF_SIZE 32768
  48. #endif
  50. extern int (*g_dblib_msg_handler)();
  51. extern int (*g_dblib_err_handler)();
  53. extern const int g__numeric_bytes_per_prec[];
  55. static char  software_version[]   = "$Id: bcp.c,v 1000.1 2003/11/17 22:20:13 gouriano Exp $";
  56. static void *no_unused_var_warn[] = { software_version,
  57.                                      no_unused_var_warn};
  59. static RETCODE _bcp_start_copy_in(DBPROCESS *);
  60. static RETCODE _bcp_build_bulk_insert_stmt(char *, BCP_COLINFO *, int);
  61. static RETCODE _bcp_start_new_batch(DBPROCESS *);
  62. static RETCODE _bcp_send_colmetadata(DBPROCESS *);
  63. static int _bcp_rtrim_varchar(char *, int);
  64. static int _bcp_err_handler(DBPROCESS * dbproc, int bcp_errno);
  66. #ifdef NCBI_FTDS
  67. /*
  68. ** The following little table is indexed by precision-1 and will
  69. ** tell us the number of bytes required to store the specified
  70. ** precision (with the sign).
  71. ** Support precision up to 77 digits
  72. */
  73. static const int tds_numeric_bytes_per_prec[] = {
  74.         -1, 2, 2, 3, 3, 4, 4, 4, 5, 5,
  75.         6, 6, 6, 7, 7, 8, 8, 9, 9, 9,
  76.         10, 10, 11, 11, 11, 12, 12, 13, 13, 14,
  77.         14, 14, 15, 15, 16, 16, 16, 17, 17, 18,
  78.         18, 19, 19, 19, 20, 20, 21, 21, 21, 22,
  79.         22, 23, 23, 24, 24, 24, 25, 25, 26, 26,
  80.         26, 27, 27, 28, 28, 28, 29, 29, 30, 30,
  81.         31, 31, 31, 32, 32, 33, 33, 33
  82. };
  83. #endif
  85. RETCODE bcp_init(DBPROCESS *dbproc, char *tblname, char *hfile, char *errfile, int direction)
  86. {
  88. TDSSOCKET *tds = dbproc->tds_socket;
  89. BCP_COLINFO *bcpcol;
  90. TDSRESULTINFO *resinfo;
  91. int i;
  92. int rc;
  94.     char query[256];
  96. /* free allocated storage in dbproc & initialise flags, etc. */
  98. _bcp_clear_storage(dbproc);
  100. /* check validity of parameters */
  102. if (hfile != (char *) NULL) {
  104. dbproc->bcp_hostfile = (char *) malloc(strlen(hfile) + 1);
  105. strcpy(dbproc->bcp_hostfile, hfile);
  107. if (errfile != (char *) NULL) {
  108. dbproc->bcp_errorfile = (char *) malloc(strlen(errfile) + 1);
  109. strcpy(dbproc->bcp_errorfile, errfile);
  110.         }
  111.         else {
  112. dbproc->bcp_errorfile = (char *) NULL;
  113. }
  114.     }
  115.     else {
  116. dbproc->bcp_hostfile = (char *) NULL;
  117. dbproc->bcp_errorfile = (char *) NULL;
  118. dbproc->sendrow_init = 0;
  119. }
  121. if (tblname == (char *) NULL) {
  122.         _bcp_err_handler(dbproc, BCPEBCITBNM);
  123. return (FAIL);
  124. }
  126. if (strlen(tblname) > 92) { /* 30.30.30 */
  127.         _bcp_err_handler(dbproc, BCPEBCITBLEN);
  128. return (FAIL);
  129. }
  131. dbproc->bcp_tablename = (char *) malloc(strlen(tblname) + 1);
  132. strcpy(dbproc->bcp_tablename, tblname);
  134. if (direction == DB_IN || direction == DB_OUT)
  135. dbproc->bcp_direction = direction;
  136. else {
  137.         _bcp_err_handler(dbproc, BCPEBDIO);
  138. return (FAIL);
  139. }
  141. if (dbproc->bcp_direction == DB_IN) {
  142.         sprintf(query,"select * from %s where 0 = 1", dbproc->bcp_tablename);
  143.         if(tds_submit_query(tds,query) == TDS_FAIL) {
  144. return FAIL;
  145. }
  147.         while((rc= tds_process_result_tokens(tds)) == TDS_SUCCEED);
  148. if (rc != TDS_NO_MORE_RESULTS) {
  149. return FAIL;
  150. }
  152. if (!tds->res_info) {
  153. return FAIL;
  154. }
  156. resinfo = tds->res_info;
  158. dbproc->bcp_colcount = resinfo->num_cols;
  159. dbproc->bcp_columns = (BCP_COLINFO **) malloc(resinfo->num_cols * sizeof(BCP_COLINFO *));
  162. for (i = 0; i < dbproc->bcp_colcount; i++) {
  163. dbproc->bcp_columns[i] = (BCP_COLINFO *) malloc(sizeof(BCP_COLINFO));
  164. bcpcol = dbproc->bcp_columns[i];
  165. memset(bcpcol, '', sizeof(BCP_COLINFO));
  167. bcpcol->tab_colnum = i + 1; /* turn offset into ordinal */
  168. bcpcol->db_type = resinfo->columns[i]->column_type;
  169. bcpcol->db_length = resinfo->columns[i]->column_size;
  170. bcpcol->db_nullable = resinfo->columns[i]->column_nullable;
  172. if (is_numeric_type(bcpcol->db_type)) {
  173. bcpcol->data = (BYTE *) malloc(sizeof(TDS_NUMERIC));
  174. ((TDS_NUMERIC *) bcpcol->data)->precision = resinfo->columns[i]->column_prec;
  175. ((TDS_NUMERIC *) bcpcol->data)->scale = resinfo->columns[i]->column_scale;
  176.             }
  177.             else if(is_blob_type(bcpcol->db_type)) {
  178.                 bcpcol->data= (BYTE*)malloc(16);
  179.                 memset(bcpcol->data, 0, 16);
  180.             }
  181.             else {
  182. bcpcol->data = (BYTE *) malloc(bcpcol->db_length);
  183. if (bcpcol->data == (BYTE *) NULL) {
  184. printf("could not allocate %d bytes of memoryn", bcpcol->db_length);
  185. }
  186. }
  189. bcpcol->data_size = 0;
  191. if (IS_TDS7_PLUS(tds)) {
  192. bcpcol->db_usertype = resinfo->columns[i]->column_usertype;
  193. bcpcol->db_flags = resinfo->columns[i]->column_flags;
  194. bcpcol->db_type_save = resinfo->columns[i]->column_type_save;
  195. bcpcol->db_prec = resinfo->columns[i]->column_prec;
  196. bcpcol->db_scale = resinfo->columns[i]->column_scale;
  197.                 memcpy(bcpcol->db_collate, resinfo->columns[i]->collation, 5);
  198. strcpy(bcpcol->db_name, resinfo->columns[i]->column_name);
  199. bcpcol->db_varint_size = resinfo->columns[i]->column_varint_size;
  200. bcpcol->db_unicodedata = resinfo->columns[i]->column_unicodedata;
  201. }
  202. }
  203.         if(dbproc->bcp_hostfile == NULL) {
  204. dbproc->host_colcount = dbproc->bcp_colcount;
  205. dbproc->host_columns = (BCP_HOSTCOLINFO **) malloc(dbproc->host_colcount * sizeof(BCP_HOSTCOLINFO *));
  207. for (i = 0; i < dbproc->host_colcount; i++) {
  208.                 dbproc->host_columns[i] = (BCP_HOSTCOLINFO *) malloc(sizeof(BCP_HOSTCOLINFO));
  209. memset(dbproc->host_columns[i], '', sizeof(BCP_HOSTCOLINFO));
  210. }
  211. }
  212. }
  214. return SUCCEED;
  215. }
  218. RETCODE bcp_collen(DBPROCESS *dbproc, DBINT varlen, int table_column)
  219. {
  220. BCP_HOSTCOLINFO *hostcol;
  222. if (dbproc->bcp_direction == 0) {
  223.         _bcp_err_handler(dbproc, BCPEBCPI);
  224. return FAIL;
  225. }
  227. if (dbproc->bcp_direction != DB_IN) {
  228.         _bcp_err_handler(dbproc, BCPEBCPN);
  229. return FAIL;
  230. }
  232. if (table_column > dbproc->host_colcount)
  233. return FAIL;
  235. hostcol = dbproc->host_columns[table_column - 1];
  237. hostcol->column_len = varlen;
  239. return SUCCEED;
  240. }
  243. RETCODE bcp_columns(DBPROCESS *dbproc, int host_colcount)
  244. {
  246. int i;
  248. if (dbproc->bcp_direction == 0) {
  249.         _bcp_err_handler(dbproc, BCPEBCPI);
  250. return FAIL;
  251. }
  252. if (dbproc->bcp_hostfile == (char *) NULL) {
  253.         _bcp_err_handler(dbproc, BCPEBIVI);
  254. return FAIL;
  255. }
  257. if (host_colcount < 1) {
  258.         _bcp_err_handler(dbproc, BCPEBCFO);
  259. return FAIL;
  260. }
  262. dbproc->host_colcount = host_colcount;
  263. dbproc->host_columns = (BCP_HOSTCOLINFO **) malloc(host_colcount * sizeof(BCP_HOSTCOLINFO *));
  265. for (i = 0; i < host_colcount; i++) {
  266. dbproc->host_columns[i] = (BCP_HOSTCOLINFO *) malloc(sizeof(BCP_HOSTCOLINFO));
  267. memset(dbproc->host_columns[i], '', sizeof(BCP_HOSTCOLINFO));
  268. }
  270. return SUCCEED;
  271. }
  273. RETCODE bcp_colfmt(DBPROCESS *dbproc, int host_colnum, int host_type, 
  274.                    int host_prefixlen, DBINT host_collen, BYTE *host_term,
  275.                    int host_termlen, int table_colnum)
  276. {
  278. BCP_HOSTCOLINFO *hostcol;
  279. #ifdef MSDBLIB
  280. /* Microsoft specifies a "file_termlen" of zero if there's no terminator */
  281. if (host_termlen == 0)
  282. host_termlen = -1;
  283. #endif
  284. if (dbproc->bcp_direction == 0) {
  285.         _bcp_err_handler(dbproc, BCPEBCPI);
  286. return FAIL;
  287. }
  289. if (dbproc->bcp_hostfile == (char *) NULL) {
  290.         _bcp_err_handler(dbproc, BCPEBIVI);
  291. return FAIL;
  292. }
  294. if (dbproc->host_colcount == 0) {
  295.         _bcp_err_handler(dbproc, BCPEBCBC);
  296. return FAIL;
  297. }
  299. if (host_colnum < 1)
  300. return FAIL;
  302.     if (host_prefixlen != 0 && host_prefixlen != 1 &&
  303.         host_prefixlen != 2 && host_prefixlen != 4 &&
  304.         host_prefixlen != -1 ) {
  305.         _bcp_err_handler(dbproc, BCPEBCPREF);
  306. return FAIL;
  307. }
  309. if (table_colnum == 0 && host_type == 0) {
  310.         _bcp_err_handler(dbproc, BCPEBCPCTYP);
  311. return FAIL;
  312. }
  314.     if (host_prefixlen == 0 && host_collen == -1 && 
  315.         host_termlen == -1 && !is_fixed_type(host_type)) {
  316.         _bcp_err_handler(dbproc, BCPEVDPT);
  317. return FAIL;
  318. }
  320. if (host_collen < -1) {
  321.         _bcp_err_handler(dbproc, BCPEBCHLEN);
  322. return FAIL;
  323. }
  325.     if (is_fixed_type(host_type) && 
  326.         (host_collen != -1 && host_collen != 0))
  327. return FAIL;
  329. /* 
  330.  * If there's a positive terminator length, we need a valid terminator pointer.
  331.  * If the terminator length is 0 or -1, then there's no terminator.
  332.  * FIXME: look up the correct error code for a bad terminator pointer or length and return that before arriving here.   
  333.  */
  334.     /*assert ((host_termlen > 0)? (host_term != NULL) : 1);*/
  336. hostcol = dbproc->host_columns[host_colnum - 1];
  338. hostcol->host_column = host_colnum;
  339. hostcol->datatype = host_type;
  340. hostcol->prefix_len = host_prefixlen;
  341. hostcol->column_len = host_collen;
  342. if (host_term && host_termlen >= 0) { 
  343. hostcol->terminator = (BYTE *) malloc(host_termlen + 1);
  344. memcpy(hostcol->terminator, host_term, host_termlen);
  345. }
  346. hostcol->term_len = host_termlen;
  347. hostcol->tab_colnum = table_colnum;
  349. return SUCCEED;
  351. }
  355. RETCODE bcp_colfmt_ps(DBPROCESS *dbproc, int host_colnum, int host_type, int host_prefixlen, DBINT host_collen, BYTE *host_term,int host_termlen, int table_colnum, DBTYPEINFO *typeinfo)
  356. {
  357. if (dbproc->bcp_direction == 0) {
  358.         _bcp_err_handler(dbproc, BCPEBCPI);
  359. return FAIL;
  360. }
  361. return SUCCEED;
  362. }
  366. RETCODE bcp_control(DBPROCESS *dbproc, int field, DBINT value)
  367. {
  368. if (dbproc->bcp_direction == 0) {
  369.         _bcp_err_handler(dbproc, BCPEBCPI);
  370. return FAIL;
  371. }
  373. switch (field) {
  375.     case BCPMAXERRS: dbproc->maxerrs  = value; break;
  376.     case BCPFIRST:   dbproc->firstrow = value; break;
  377.     case BCPLAST:    dbproc->firstrow = value; break;
  378.     case BCPBATCH:   dbproc->bcpbatch = value; break;
  380. default:
  381.         _bcp_err_handler(dbproc, BCPEIFNB);
  382. return FAIL;
  383. }
  384. return SUCCEED;
  385. }
  387. RETCODE bcp_options(DBPROCESS *dbproc, int option, BYTE *value, int valuelen)
  388. {
  389. int i;
  390. static const char *hints[] =  { "ORDER"
  391. , "ROWS_PER_BATCH"
  392. , "KILOBYTES_PER_BATCH"
  393. , "TABLOCK"
  394. , "CHECK_CONSTRAINTS"
  395. , NULL
  396. };
  397. if (!dbproc)
  398. return FAIL;
  400. switch (option) {
  401. case BCPLABELED:
  402. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED bcp option: BCPLABELEDn");
  403. return FAIL;
  404. case BCPHINTS:
  405.                 if (!value || valuelen <= 0)
  406.                         return FAIL;
  408.                 if (dbproc->bcp_hint != NULL) /* hint already set */
  409.                         return FAIL;
  411. for(i=0; hints[i]; i++ ) { /* do we know about this hint? */
  412. if (strncasecmp((char*) value, hints[i], strlen(hints[i])) == 0)
  413. break;
  414. }
  415. if (!hints[i]) { /* no such hint */
  416. return FAIL;
  417. }
  419. /* 
  420.  * Store the bare hint, as passed from the application.  
  421.  * The process that constructs the "insert bulk" statement will incorporate the hint text.
  422.  */
  423. dbproc->bcp_hint = (char*) malloc(1+valuelen);
  424. memcpy(dbproc->bcp_hint, value, valuelen);
  425. dbproc->bcp_hint[valuelen] = ''; /* null terminate it */
  426. break;
  427. default:
  428. tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED bcp option: %un", option);
  429. return FAIL;
  430. }
  432. return SUCCEED;
  433. }
  435. RETCODE
  436. bcp_colptr(DBPROCESS * dbproc, BYTE * colptr, int table_column)
  437. {
  438. BCP_HOSTCOLINFO *hostcol;
  440. if (dbproc->bcp_direction == 0) {
  441.         _bcp_err_handler(dbproc, BCPEBCPI);
  442. return FAIL;
  443. }
  444. if (dbproc->bcp_direction != DB_IN) {
  445.         _bcp_err_handler(dbproc, BCPEBCPN);
  446. return FAIL;
  447. }
  449. if (table_column > dbproc->host_colcount)
  450. return FAIL;
  452. hostcol = dbproc->host_columns[table_column - 1];
  454. hostcol->host_var = colptr;
  456. return SUCCEED;
  457. }
  460. DBBOOL bcp_getl(LOGINREC *login)
  461. {
  462. TDSLOGIN *tdsl = (TDSLOGIN *) login->tds_login;
  464. return (tdsl->bulk_copy);
  465. }
  467. static RETCODE _bcp_exec_out(DBPROCESS *dbproc, DBINT *rows_copied)
  468. {
  470. FILE *hostfile;
  472.     int  ret;
  473. int i;
  474.     int  j;
  475.     int  k;
  476.     char *xx;
  478.     TDSSOCKET     *tds = dbproc->tds_socket;
  479. TDSRESULTINFO *resinfo;
  480. BCP_COLINFO *bcpcol;
  481. TDSCOLINFO *curcol;
  482. BCP_HOSTCOLINFO *hostcol;
  483. BYTE *src;
  484. int srctype;
  485. long len;
  486. int buflen;
  487. int destlen;
  488. BYTE *outbuf;
  489.     char          query[256];
  491. TDS_INT rowtype;
  492. TDS_INT computeid;
  493. TDS_INT result_type;
  495. TDS_TINYINT ti;
  496. TDS_SMALLINT si;
  497. TDS_INT li;
  499. TDSDATEREC when;
  501. int row_of_query;
  502. int rows_written;
  504. if (!(hostfile = fopen(dbproc->bcp_hostfile, "w"))) {
  505.         _bcp_err_handler(dbproc, BCPEBCUO);
  506. return FAIL;
  507. }
  509.     sprintf(query,"select * from %s", dbproc->bcp_tablename);
  511.     tds_submit_query(tds, query);
  513.     if (tds_process_result_tokens(tds) == TDS_FAIL) {
  514. fclose(hostfile);
  515. return FAIL;
  516. }
  517. if (!tds->res_info) {
  518. fclose(hostfile);
  519. return FAIL;
  520. }
  522. resinfo = tds->res_info;
  524. dbproc->bcp_colcount = resinfo->num_cols;
  525. dbproc->bcp_columns = (BCP_COLINFO **) malloc(resinfo->num_cols * sizeof(BCP_COLINFO *));
  527. for (i = 0; i < resinfo->num_cols; i++) {
  528. dbproc->bcp_columns[i] = (BCP_COLINFO *) malloc(sizeof(BCP_COLINFO));
  529. memset(dbproc->bcp_columns[i], '', sizeof(BCP_COLINFO));
  530. dbproc->bcp_columns[i]->tab_colnum = i + 1; /* turn offset into ordinal */
  531. dbproc->bcp_columns[i]->db_type = resinfo->columns[i]->column_type;
  532. dbproc->bcp_columns[i]->db_length = resinfo->columns[i]->column_size;
  533. if (is_numeric_type(resinfo->columns[i]->column_type))
  534. dbproc->bcp_columns[i]->data = (BYTE *) malloc(sizeof(TDS_NUMERIC));
  535. else
  536. dbproc->bcp_columns[i]->data = (BYTE *) malloc(dbproc->bcp_columns[i]->db_length);
  537. dbproc->bcp_columns[i]->data_size = 0;
  538. }
  540. row_of_query = 0;
  541. rows_written = 0;
  543.     while (tds_process_row_tokens(tds)==TDS_SUCCEED) {
  545. row_of_query++;
  547. if ((dbproc->firstrow == 0 && dbproc->lastrow == 0) ||
  548.    /** FIX this! */
  549.             ((dbproc->firstrow > 0 && row_of_query >= dbproc->firstrow) &&
  550.              (dbproc->lastrow > 0 && row_of_query <= dbproc->lastrow))) {
  551. for (i = 0; i < dbproc->bcp_colcount; i++) {
  553. bcpcol = dbproc->bcp_columns[i];
  554. curcol = resinfo->columns[bcpcol->tab_colnum - 1];
  556. src = &resinfo->current_row[curcol->column_offset];
  557. if (is_blob_type(curcol->column_type)) {
  558. /* FIX ME -- no converts supported */
  559. src = (BYTE*) ((TDSBLOBINFO *) src)->textvalue;
  560. len = curcol->cur_row_size;
  561. } else {
  563. srctype = tds_get_conversion_type(curcol->column_type, curcol->column_size);
  565. if (srctype != bcpcol->db_type) {
  566. bcpcol->db_type = srctype;
  567. }
  569. if (is_numeric_type(curcol->column_type))
  570. memcpy(bcpcol->data, src, sizeof(TDS_NUMERIC));
  571. else
  572. memcpy(bcpcol->data, src, curcol->column_size);
  574. /* null columns have zero output */
  575. if (tds_get_null(resinfo->current_row, bcpcol->tab_colnum - 1))
  576. bcpcol->data_size = 0;
  577. else
  578. bcpcol->data_size = curcol->cur_row_size;
  579. }
  580. }
  583. for (i = 0; i < dbproc->host_colcount; i++) {
  585. hostcol = dbproc->host_columns[i];
  586. if ((hostcol->tab_colnum < 1)
  587.     || (hostcol->tab_colnum > dbproc->bcp_colcount)) {
  588. continue;
  589. }
  591. if (hostcol->tab_colnum) {
  592. bcpcol = dbproc->bcp_columns[hostcol->tab_colnum - 1];
  593. if (bcpcol->tab_colnum != hostcol->tab_colnum) {
  594. return FAIL;
  595. }
  596. }
  597. /*assert(bcpcol);*/
  599. if (hostcol->datatype == 0)
  600. hostcol->datatype = bcpcol->db_type;
  602. /* work out how much space to allocate for output data */
  604. switch (hostcol->datatype) {
  606.                 case SYBINT1:        buflen = destlen = 1;  break;
  607.                 case SYBINT2:        buflen = destlen = 2;  break;
  608.                 case SYBINT4:        buflen = destlen = 4;  break;
  609.                 case SYBREAL:        buflen = destlen = 4;  break;
  610.                 case SYBFLT8:        buflen = destlen = 8;  break;
  611.                 case SYBDATETIME:    buflen = destlen = 8;  break;
  612.                 case SYBDATETIME4:   buflen = destlen = 4;  break;
  613.                 case SYBBIT:         buflen = destlen = 1;  break;
  614.                 case SYBBITN:        buflen = destlen = 1;  break;
  615.                 case SYBMONEY:       buflen = destlen = 8;  break;
  616.                 case SYBMONEY4:      buflen = destlen = 4;  break;
  617. case SYBCHAR:
  618. case SYBVARCHAR:
  619. switch (bcpcol->db_type) {
  620. case SYBVARCHAR:
  621. buflen = bcpcol->db_length + 1;
  622. destlen = -1;
  623. break;
  624. case SYBCHAR:
  625. buflen = bcpcol->db_length + 1;
  626. destlen = -2;
  627. break;
  628. case SYBINT1:
  629. buflen = 4 + 1; /*  255         */
  630. destlen = -1;
  631. break;
  632. case SYBINT2:
  633. buflen = 6 + 1; /* -32768       */
  634. destlen = -1;
  635. break;
  636. case SYBINT4:
  637. buflen = 11 + 1; /* -2147483648  */
  638. destlen = -1;
  639. break;
  640. case SYBNUMERIC:
  641. buflen = 40 + 1; /* 10 to the 38 */
  642. destlen = -1;
  643. break;
  644. case SYBDECIMAL:
  645. buflen = 40 + 1; /* 10 to the 38 */
  646. destlen = -1;
  647. break;
  648. case SYBFLT8:
  649. buflen = 40 + 1; /* 10 to the 38 */
  650. destlen = -1;
  651. break;
  652. case SYBDATETIME:
  653. buflen = 255 + 1;
  654. destlen = -1;
  655. break;
  656. default:
  657. buflen = 255 + 1;
  658. destlen = -1;
  659. break;
  660. }
  661. break;
  662. default:
  663. buflen = destlen = 255;
  664. }
  666. outbuf = (BYTE*) malloc(buflen);
  668. /* if we are converting datetime to string, need to override any 
  669.  * date time formats already established
  670.  */
  671. if ((bcpcol->db_type == SYBDATETIME || bcpcol->db_type == SYBDATETIME4)
  672.     && (hostcol->datatype == SYBCHAR || hostcol->datatype == SYBVARCHAR)) {
  673. memset(&when, 0, sizeof(when));
  674. tds_datecrack(bcpcol->db_type, bcpcol->data, &when);
  675. buflen = tds_strftime((char*)outbuf, buflen, "%Y-%m-%d %H:%M:%S.%z", &when);
  676. } else {
  677. /* 
  678.  * For null columns, the above work to determine the output buffer size is moot, 
  679.  * because bcpcol->data_size is zero, so dbconvert() won't write anything, and returns zero. 
  680.  */
  681. buflen = dbconvert(dbproc,
  682.    bcpcol->db_type,
  683.    bcpcol->data, bcpcol->data_size, hostcol->datatype, outbuf, destlen);
  684. }
  686. /* FIX ME -- does not handle prefix_len == -1 */
  687. /* The prefix */
  689. switch (hostcol->prefix_len) {
  690. case -1:
  691. if (!(is_fixed_type(hostcol->datatype))) {
  692. si = buflen;
  693. fwrite(&si, sizeof(si), 1, hostfile);
  694. }
  695. break;
  696. case 1:
  697. ti = buflen;
  698. fwrite(&ti, sizeof(ti), 1, hostfile);
  699. break;
  700. case 2:
  701. si = buflen;
  702. fwrite(&si, sizeof(si), 1, hostfile);
  703. break;
  704. case 4:
  705. li = buflen;
  706. fwrite(&li, sizeof(li), 1, hostfile);
  707. break;
  708. }
  710. /* The data */
  712. if (is_blob_type(curcol->column_type)) {
  713. fwrite(src, len, 1, hostfile);
  714. } else {
  715. if (hostcol->column_len != -1) {
  716. buflen = buflen > hostcol->column_len ? hostcol->column_len : buflen;
  717. }
  719. fwrite(outbuf, buflen, 1, hostfile);
  720. }
  722. free(outbuf);
  724. /* The terminator */
  725. if (hostcol->terminator && hostcol->term_len > 0) {
  726. fwrite(hostcol->terminator, hostcol->term_len, 1, hostfile);
  727. }
  728. }
  729. rows_written++;
  730. }
  731. }
  732. if (fclose(hostfile) != 0) {
  733.         _bcp_err_handler(dbproc, BCPEBCUC);
  734. return (FAIL);
  735. }
  737.     printf("firstrow = %d row_of_query = %d rows written %dn",
  738.            dbproc->firstrow, row_of_query, rows_written);
  739. if (dbproc->firstrow > 0 && row_of_query < dbproc->firstrow) {
  740. /* The table which bulk-copy is attempting to
  741.  * copy to a host-file is shorter than the
  742.  * number of rows which bulk-copy was instructed
  743.  * to skip.  
  744.  */
  746.         _bcp_err_handler(dbproc, BCPETTS);
  747. return (FAIL);
  748. }
  750. *rows_copied = rows_written;
  751. return SUCCEED;
  752. }
  756. RETCODE _bcp_read_hostfile(DBPROCESS *dbproc, FILE *hostfile)
  757. {
  758. BCP_COLINFO *bcpcol;
  759. BCP_HOSTCOLINFO *hostcol;
  761. int i;
  762. TDS_TINYINT ti;
  763. TDS_SMALLINT si;
  764. TDS_INT li;
  765. int collen;
  766. int data_is_null;
  767. int bytes_read;
  768. int converted_data_size;
  769. TDS_INT desttype;
  772. /* for each host file column defined by calls to bcp_colfmt */
  774. for (i = 0; i < dbproc->host_colcount; i++) {
  775. BYTE coldata[256];
  777. hostcol = dbproc->host_columns[i];
  779. data_is_null = 0;
  780. collen = 0;
  782. /* if a prefix length specified, read the correct */
  783. /* amount of data...                              */
  785. if (hostcol->prefix_len > 0) {
  787. switch (hostcol->prefix_len) {
  788. case 1:
  789. if (fread(&ti, 1, 1, hostfile) != 1) {
  790.                     _bcp_err_handler(dbproc, BCPEBCRE);
  791. return (FAIL);
  792. }
  793. collen = ti;
  794. break;
  795. case 2:
  796. if (fread(&si, 2, 1, hostfile) != 1) {
  797.                     _bcp_err_handler(dbproc, BCPEBCRE);
  798. return (FAIL);
  799. }
  800. collen = si;
  801. break;
  802. case 4:
  803. if (fread(&li, 4, 1, hostfile) != 1) {
  804.                     _bcp_err_handler(dbproc, BCPEBCRE);
  805. return (FAIL);
  806. }
  807. collen = li;
  808. break;
  809. default:
  810.              /*assert(hostcol->prefix_len <= 4);*/
  811. break;
  812. }
  814. if (collen == 0)
  815. data_is_null = 1;
  817. }
  819. /* if (Max) column length specified take that into */
  820. /* consideration...                                */
  822. if (!data_is_null && hostcol->column_len >= 0) {
  823. if (hostcol->column_len == 0)
  824. data_is_null = 1;
  825. else {
  826. if (collen)
  827. collen = (hostcol->column_len < collen) ? hostcol->column_len : collen;
  828. else
  829. collen = hostcol->column_len;
  830. }
  831. }
  833. /* Fixed Length data - this over-rides anything else specified */
  835. if (is_fixed_type(hostcol->datatype)) {
  836.             collen = get_size_by_type(hostcol->datatype);
  837. }
  838. #ifdef NCBI_FTDS
  839.       else if(hostcol->prefix_len <= 0 && hostcol->term_len <= 0) {
  840.           /* we need to know the size anyway */
  841.           if (fread(&si, 2, 1, hostfile) != 1) {
  842.               _bcp_err_handler(dbproc, BCPEBCRE);
  843.               return (FAIL);
  844.           }
  845.           collen = si;
  846.       }
  847. #endif
  849. /* if this host file column contains table data,   */
  850. /* find the right element in the table/column list */
  852. if (hostcol->tab_colnum) {
  853. bcpcol = dbproc->bcp_columns[hostcol->tab_colnum - 1];
  854. if (bcpcol->tab_colnum != hostcol->tab_colnum) {
  855. return FAIL;
  856. }
  857. }
  859. /* a terminated field is specified - get the data into temporary space... */
  861. memset(coldata, '', sizeof(coldata));
  863. if (hostcol->term_len > 0) {
  864. bytes_read = _bcp_get_term_data(hostfile, hostcol, coldata);
  866. if (bytes_read == -1)
  867. return FAIL;
  869. if (collen)
  870. collen = (bytes_read < collen) ? bytes_read : collen;
  871. else
  872. collen = bytes_read;
  874. if (collen == 0)
  875. data_is_null = 1;
  877. } else {
  878. if (collen) {
  879. if (fread(coldata, collen, 1, hostfile) != 1) {
  880.                     _bcp_err_handler(dbproc, BCPEBCRE);
  881. return (FAIL);
  882. }
  883. }
  884. }
  886. if (hostcol->tab_colnum) {
  887. if (data_is_null) {
  888. bcpcol->data_size = 0;
  889.                 }
  890.                 else {
  891. desttype = tds_get_conversion_type(bcpcol->db_type, bcpcol->db_length);
  893. converted_data_size =
  894. dbconvert(dbproc, hostcol->datatype, coldata, collen, desttype, 
  895.   bcpcol->data, bcpcol->db_length);
  896.   
  897. if (converted_data_size == FAIL) 
  898. return (FAIL);
  900. if (desttype == SYBVARCHAR) {
  901.                         bcpcol->data_size = _bcp_rtrim_varchar(bcpcol->data, converted_data_size);
  902.                     }
  903.                     else {
  904. bcpcol->data_size = converted_data_size;
  905. }
  906. }
  907. }
  909. }
  910. return SUCCEED;
  911. }
  914. /* read a terminated variable from a hostfile */
  916. RETCODE _bcp_get_term_data(FILE *hostfile, BCP_HOSTCOLINFO *hostcol, BYTE *coldata )
  917. {
  919. int j = 0;
  920. int termfound = 1;
  921. char x;
  922. char *tester = NULL;
  923. int bufpos = 0;
  924. int found = 0;
  927. if (hostcol->term_len > 1)
  928. tester = (char *) malloc(hostcol->term_len);
  931. while (!found && (x = getc(hostfile)) != EOF) {
  932. if (x != *hostcol->terminator) {
  933. *(coldata + bufpos) = x;
  934. bufpos++;
  935.         }
  936.         else {
  937. if (hostcol->term_len == 1) {
  938. *(coldata + bufpos) = '';
  939. found = 1;
  940.             }
  941.             else {
  942. ungetc(x, hostfile);
  943. fread(tester, hostcol->term_len, 1, hostfile);
  944. termfound = 1;
  945. for (j = 0; j < hostcol->term_len; j++)
  946. if (*(tester + j) != *(hostcol->terminator + j))
  947. termfound = 0;
  948. if (termfound) {
  949. *(coldata + bufpos) = '';
  950. found = 1;
  951.                 }
  952.                 else {
  953. for (j = 0; j < hostcol->term_len; j++) {
  954. *(coldata + bufpos) = *(tester + j);
  955. bufpos++;
  956. }
  957. }
  958. }
  959. }
  960. }
  961. if (found) {
  962. return (bufpos);
  963.     }
  964.     else {
  965. return (-1);
  966. }
  968. }
  970. /*
  971. ** Add fixed size columns to the row
  972. */
  974. static int _bcp_add_fixed_columns(DBPROCESS *dbproc, BYTE *rowbuffer, int start)
  975. {
  976. TDS_NUMERIC *num;
  977. int row_pos = start;
  978. BCP_COLINFO *bcpcol;
  979. int cpbytes;
  981. int i;
  983. for (i = 0; i < dbproc->bcp_colcount; i++) {
  984. bcpcol = dbproc->bcp_columns[i];
  987.         if (!is_nullable_type(bcpcol->db_type) &&
  988.             !(bcpcol->db_nullable)) {
  990. if (!(bcpcol->db_nullable) && bcpcol->data_size == 0) {
  991.                 _bcp_err_handler(dbproc, BCPEBCNN);
  992. return FAIL;
  993. }
  995. if (is_numeric_type(bcpcol->db_type)) {
  996. num = (TDS_NUMERIC *) bcpcol->data;
  997.                 cpbytes = g__numeric_bytes_per_prec[num->precision];
  998. memcpy(&rowbuffer[row_pos], num->array, cpbytes);
  999.             }
  1000.             else {
  1001.                 cpbytes = bcpcol->data_size > bcpcol->db_length 
  1002.                     ? bcpcol->db_length : bcpcol->data_size;
  1003. memcpy(&rowbuffer[row_pos], bcpcol->data, cpbytes);
  1004. }
  1006. /* Bill T commenting this out. It always seems to print 
  1007.                This error message regardless...
  1008.                if (row_pos != bcpcol->db_offset) {
  1009.                fprintf(stderr,"Error: computed offset does not match one returned from database enginen");
  1010.                }
  1011.  */
  1013. row_pos += bcpcol->db_length;
  1014. }
  1015. }
  1016. return row_pos;
  1017. }
  1019. /*
  1020. ** Add variable size columns to the row
  1021. */
  1023. static int _bcp_add_variable_columns(DBPROCESS *dbproc, BYTE *rowbuffer, int start)
  1024. {
  1025. TDSSOCKET *tds = dbproc->tds_socket;
  1026. BCP_COLINFO *bcpcol;
  1027. TDS_NUMERIC *num;
  1028. int row_pos = start;
  1029. int cpbytes;
  1030. int eod_ptr;
  1031. BYTE offset_table[256];
  1032. int offset_pos = 0;
  1033. BYTE adjust_table[256];
  1034. int adjust_pos = 0;
  1035. int num_cols = 0;
  1037. int i;
  1039. for (i = 0; i < dbproc->bcp_colcount; i++) {
  1040. bcpcol = dbproc->bcp_columns[i];
  1042.         if (is_nullable_type(bcpcol->db_type) || 
  1043.             bcpcol->db_nullable) {
  1045. if (!(bcpcol->db_nullable) && bcpcol->data_size == 0) {
  1046.                 _bcp_err_handler(dbproc, BCPEBCNN);
  1047. return FAIL;
  1048. }
  1050. if (is_blob_type(bcpcol->db_type)) {
  1052. /* no need to copy they are all zero bytes */
  1054. cpbytes = 16;
  1055. /* save for data write */
  1056. bcpcol->txptr_offset = row_pos;
  1057.             } 
  1058.             else if (is_numeric_type(bcpcol->db_type)) {
  1059. num = (TDS_NUMERIC *) bcpcol->data;
  1060.                 cpbytes = g__numeric_bytes_per_prec[num->precision];
  1061. memcpy(&rowbuffer[row_pos], num->array, cpbytes);
  1062.             }
  1063.             else {
  1064. /* compute the length to copy to the row ** buffer */
  1066.                 cpbytes = bcpcol->data_size > bcpcol->db_length 
  1067.                     ? bcpcol->db_length : bcpcol->data_size;
  1068. memcpy(&rowbuffer[row_pos], bcpcol->data, cpbytes);
  1070. }
  1072. /* update offset and adjust tables (if necessary) */
  1073. offset_table[offset_pos++] = row_pos % 256;
  1074.             if (row_pos > 255 && 
  1075.                 (adjust_pos==0 || row_pos/256 != adjust_table[adjust_pos])) {
  1076. adjust_table[adjust_pos++] = row_pos / 256;
  1077. }
  1079. num_cols++;
  1080. row_pos += cpbytes;
  1081. }
  1082. }
  1084. eod_ptr = row_pos;
  1087. /* write the marker */
  1088. if (IS_TDS50(tds))
  1089. rowbuffer[row_pos++] = num_cols + 1;
  1091. /* write the adjust table (right to left) */
  1092. for (i = adjust_pos - 1; i >= 0; i--) {
  1093. /* fprintf(stderr,"adjust %dn",adjust_table[i]); */
  1094. rowbuffer[row_pos++] = adjust_table[i];
  1095. }
  1097. /* the EOD (end of data) pointer */
  1098. rowbuffer[row_pos++] = eod_ptr;
  1100. /* write the offset table (right to left) */
  1101. for (i = offset_pos - 1; i >= 0; i--) {
  1102. /* fprintf(stderr,"offset %dn",offset_table[i]); */
  1103. rowbuffer[row_pos++] = offset_table[i];
  1104. }
  1106. return row_pos;
  1107. }
  1109. RETCODE bcp_sendrow(DBPROCESS *dbproc)
  1110. {
  1112. TDSSOCKET *tds = dbproc->tds_socket;
  1113. BCP_COLINFO *bcpcol;
  1114.     BCP_HOSTCOLINFO *hostcol;
  1115.     TDSCOLINFO      *curcol;
  1117. int i;
  1118.     int collen;
  1119. /* FIX ME -- calculate dynamically */
  1120. unsigned char rowbuffer[ROWBUF_SIZE];
  1121. int row_pos;
  1122. int row_sz_pos;
  1123. TDS_SMALLINT row_size;
  1124.     TDS_SMALLINT row_size_saved;
  1126.     int marker;
  1127. int blob_cols = 0;
  1129. unsigned char CHARBIN_NULL[] = { 0xff, 0xff };
  1130. unsigned char GEN_NULL = 0x00;
  1132. TDS_NUMERIC *num;
  1133. TDS_TINYINT numeric_size;
  1135. unsigned char row_token = 0xd1;
  1137. if (dbproc->bcp_direction == 0) {
  1138.         _bcp_err_handler(dbproc, BCPEBCPI);
  1139. return FAIL;
  1140. }
  1141. if (dbproc->bcp_hostfile != (char *) NULL) {
  1142.         _bcp_err_handler(dbproc, BCPEBCPB);
  1143. return FAIL;
  1144. }
  1146. if (dbproc->bcp_direction != DB_IN) {
  1147.         _bcp_err_handler(dbproc, BCPEBCPN);
  1148. return FAIL;
  1149. }
  1151. /* The first time sendrow is called after bcp_init,  */
  1152. /* there is a certain amount of initialisation to be */
  1153. /* done...                                           */
  1155. if (!(dbproc->sendrow_init)) {
  1157. /* first call the start_copy function, which will */
  1158. /* retrieve details of the database table columns */
  1160. if (_bcp_start_copy_in(dbproc) == FAIL)
  1161. return (FAIL);
  1163. #ifndef NCBI_FTDS
  1164.         /* Next, allocate the storage to hold data about the */
  1165.         /* program variable data - these must be the same in */
  1166.         /* number as the table columns...                    */
  1168.         dbproc->host_colcount = dbproc->bcp_colcount;
  1169.         dbproc->host_columns  = (BCP_HOSTCOLINFO **) malloc(dbproc->host_colcount * sizeof(BCP_HOSTCOLINFO *));
  1171.         for ( i = 0; i < dbproc->host_colcount; i++ ) {
  1172.             dbproc->host_columns[i] = (BCP_HOSTCOLINFO *) malloc(sizeof(BCP_HOSTCOLINFO));
  1173.             memset(dbproc->host_columns[i], '', sizeof(BCP_HOSTCOLINFO));
  1174.         }
  1175. #endif
  1177. /* set packet type to send bulk data */
  1178. tds->out_flag = 0x07;
  1180. if (IS_TDS7_PLUS(tds)) {
  1181. _bcp_send_colmetadata(dbproc);
  1182. }
  1184. dbproc->sendrow_init = 1;
  1186. }
  1189. if (_bcp_get_prog_data(dbproc) == SUCCEED) {
  1191. if (IS_TDS7_PLUS(tds)) {
  1192. tds_put_byte(tds, row_token); /* 0xd1 */
  1194. #ifdef NCBI_FTDS
  1195.             dbproc->curr_text_col= 0;
  1196. #endif
  1197. for (i = 0; i < dbproc->bcp_colcount; i++) {
  1198. bcpcol = dbproc->bcp_columns[i];
  1199. #ifdef NCBI_FTDS
  1200.                 if(dbproc->host_columns[i]->datatype == 0) continue;
  1202.                 if(is_blob_type(bcpcol->db_type)) continue;
  1203. #endif
  1205.                 if (bcpcol->data_size == 0 ) /* Are we trying to insert a NULL ? */ {
  1206.                     if(bcpcol->db_nullable)   /* is the column nullable ? */ {
  1207.                         if (bcpcol->db_type_save == XSYBCHAR || 
  1208.                             bcpcol->db_type_save == XSYBVARCHAR ||
  1209.                             bcpcol->db_type_save == XSYBBINARY ||
  1210.                             bcpcol->db_type_save == XSYBVARBINARY|| 
  1211.                             bcpcol->db_type_save == XSYBNCHAR || 
  1212.                             bcpcol->db_type_save == XSYBNVARCHAR) {
  1213. tds_put_n(tds, CHARBIN_NULL, 2);
  1214.                         }
  1215.                         else {
  1216. tds_put_byte(tds, GEN_NULL);
  1217. }
  1218.                     }
  1219.                     else {
  1220.                         _bcp_err_handler(dbproc, BCPEBCNN);
  1221.                         return FAIL;
  1222.                     }
  1223.                 }
  1224.                 else {   
  1225. switch (bcpcol->db_varint_size) {
  1226.                     case 4: tds_put_int(tds, bcpcol->data_size);
  1227. break;
  1228.                     case 2: tds_put_smallint(tds, bcpcol->data_size);
  1229. break;
  1230.                     case 1: if (is_numeric_type(bcpcol->db_type)) {
  1231.                         numeric_size = g__numeric_bytes_per_prec[bcpcol->db_prec];
  1232. tds_put_byte(tds, numeric_size);
  1233.                     }
  1234.                     else
  1235. tds_put_byte(tds, bcpcol->data_size);
  1236. break;
  1237.                     case 0: break;
  1238. }
  1240. #if WORDS_BIGENDIAN
  1241.                if (tds->emul_little_endian) {
  1242.                     tds_swap_datatype(tds_get_conversion_type(bcpcol->db_type, bcpcol->db_length),
  1243.                                       bcpcol->data);
  1244.                }
  1245. #endif
  1247. if (is_numeric_type(bcpcol->db_type)) {
  1248. num = (TDS_NUMERIC *) bcpcol->data;
  1249. #ifdef NCBI_FTDS
  1250.                         tds_put_n(tds, num->array, g__numeric_bytes_per_prec[bcpcol->db_prec]);
  1251. #else
  1252.                         tds_put_n(tds, num->array, g__numeric_bytes_per_prec[num->precision]);
  1253. #endif
  1254.                     }
  1255. #if 0
  1256.                     else if(is_blob_type(bcpcol->db_type)) { //add blob data
  1257.                         int ss;
  1258.                         char blob_buff[256];
  1259.                         for(marker= 0; marker < 256;) {
  1260.                             blob_buff[marker++]= 'T';
  1261.                             blob_buff[marker++]= 'E';
  1262.                             blob_buff[marker++]= 'S';
  1263.                             blob_buff[marker++]= 't';
  1264.                         }
  1265.                         for(marker = bcpcol->data_size; marker > 0; marker-= ss) {
  1266.                             ss= (marker > 256)? 256 : marker;
  1267.                             tds_put_n(tds, blob_buff, ss);
  1268.                         }
  1269.                     }
  1270. #endif
  1271.                     else
  1272. tds_put_n(tds, bcpcol->data, bcpcol->data_size);
  1273. }
  1274. }
  1275. return SUCCEED;
  1276.         }
  1277.         else    /* Not TDS 7 or 8 */    {
  1278. memset(rowbuffer, '', ROWBUF_SIZE); /* zero the rowbuffer */
  1280. /* offset 0 = number of var columns */
  1281. /* offset 1 = row number.  zeroed (datasever assigns) */
  1282. row_pos = 2;
  1284. rowbuffer[0] = dbproc->var_cols;
  1286.             if (row_pos = _bcp_add_fixed_columns(dbproc, rowbuffer, row_pos) == FAIL)
  1287. return (FAIL);
  1290. row_sz_pos = row_pos;
  1293. if (dbproc->var_cols) {
  1295. row_pos += 2; /* skip over row length */
  1297. if ((row_pos = _bcp_add_variable_columns(dbproc, rowbuffer, row_pos)) == FAIL)
  1298. return (FAIL);
  1299. }
  1301. row_size = row_pos;
  1304. if (dbproc->var_cols)
  1305. memcpy(&rowbuffer[row_sz_pos], &row_size, sizeof(row_size));
  1307. tds_put_smallint(tds, row_size);
  1308. tds_put_n(tds, rowbuffer, row_size);
  1310. /* row is done, now handle any text/image data */
  1312. blob_cols = 0;
  1314. for (i = 0; i < dbproc->bcp_colcount; i++) {
  1315. bcpcol = dbproc->bcp_columns[i];
  1316. if (is_blob_type(bcpcol->db_type)) {
  1317. /* unknown but zero */
  1318. tds_put_smallint(tds, 0);
  1319. tds_put_byte(tds, bcpcol->db_type);
  1320. tds_put_byte(tds, 0xff - blob_cols);
  1321. /* offset of txptr we stashed during variable
  1322.                     ** column processing */
  1323. tds_put_smallint(tds, bcpcol->txptr_offset);
  1324. tds_put_int(tds, bcpcol->data_size);
  1325. tds_put_n(tds, bcpcol->data, bcpcol->data_size);
  1326. blob_cols++;
  1327. }
  1328. }
  1329. return SUCCEED;
  1330. }
  1331. }
  1333. return FAIL;
  1334. }
  1337. static RETCODE _bcp_exec_in(DBPROCESS *dbproc, DBINT *rows_copied)
  1338. {
  1339. FILE *hostfile, *errfile;
  1340. TDSSOCKET *tds = dbproc->tds_socket;
  1341. BCP_COLINFO *bcpcol;
  1343. /* FIX ME -- calculate dynamically */
  1344. unsigned char rowbuffer[ROWBUF_SIZE];
  1345. int row_pos;
  1347. /* end of data pointer...the last byte of var data before the adjust table */
  1349. int row_sz_pos;
  1350. TDS_SMALLINT row_size;
  1352. const unsigned char CHARBIN_NULL[] = { 0xff, 0xff };
  1353. const unsigned char GEN_NULL = 0x00;
  1354. const unsigned char row_token = 0xd1;
  1356. TDS_NUMERIC *num;
  1357. TDS_TINYINT numeric_size;
  1359. int i;
  1360. int marker;
  1361. int blob_cols = 0;
  1362. int row_of_hostfile;
  1363. int rows_written_so_far;
  1364. int rows_copied_this_batch = 0;
  1365. int rows_copied_so_far = 0;
  1367. if (!(hostfile = fopen(dbproc->bcp_hostfile, "r"))) {
  1368.         _bcp_err_handler(dbproc, BCPEBCUO);
  1369. return FAIL;
  1370. }
  1372. if (dbproc->bcp_errorfile) {
  1373. if (!(errfile = fopen(dbproc->bcp_errorfile, "w"))) {
  1374. _bcp_err_handler(dbproc, SYBEBUOE);
  1375. return FAIL;
  1376. }
  1377. }
  1379. if (_bcp_start_copy_in(dbproc) == FAIL)
  1380. return (FAIL);
  1382. tds->out_flag = 0x07;
  1384. if (IS_TDS7_PLUS(tds)) {
  1385. _bcp_send_colmetadata(dbproc);
  1386. }
  1388. row_of_hostfile = 0;
  1390. rows_written_so_far = 0;
  1392. while (_bcp_read_hostfile(dbproc, hostfile/*, errfile*/) == SUCCEED) {
  1394. row_of_hostfile++;
  1396. if ((dbproc->firstrow == 0 && dbproc->lastrow == 0) ||
  1397.     ((dbproc->firstrow > 0 && row_of_hostfile >= dbproc->firstrow)
  1398.      && (dbproc->lastrow > 0 && row_of_hostfile <= dbproc->lastrow))
  1399. ) {
  1401. if (IS_TDS7_PLUS(tds)) {
  1402. tds_put_byte(tds, row_token); /* 0xd1 */
  1404. for (i = 0; i < dbproc->bcp_colcount; i++) {
  1405. bcpcol = dbproc->bcp_columns[i];
  1407. if (bcpcol->data_size == 0) { /* Are we trying to insert a NULL ? */
  1408. if (!bcpcol->db_nullable){
  1409. /* too bad if the column is not nullable */
  1410. fprintf(errfile, "Column is not nullable. Row %d, Column %dn", 
  1411. row_of_hostfile, i);
  1412. fwrite(bcpcol->data, bcpcol->data_size, 1, errfile);
  1413. _bcp_err_handler(dbproc, BCPEBCNN);
  1414. return FAIL;
  1415. }
  1417. switch (bcpcol->db_type_save) {
  1418. case XSYBCHAR:
  1419. case XSYBVARCHAR:
  1420. case XSYBBINARY:
  1421. case XSYBVARBINARY:
  1422. case XSYBNCHAR:
  1423. case XSYBNVARCHAR:
  1424. tds_put_n(tds, CHARBIN_NULL, 2);
  1425. break;
  1426. default :
  1427. tds_put_byte(tds, GEN_NULL);
  1428. break;
  1429. }
  1430. } else {
  1431. switch (bcpcol->db_varint_size) {
  1432. case 4:
  1433. tds_put_int(tds, bcpcol->data_size);
  1434. break;
  1435. case 2:
  1436. tds_put_smallint(tds, bcpcol->data_size);
  1437. break;
  1438. case 1:
  1439. if (is_numeric_type(bcpcol->db_type)) {
  1440. numeric_size = tds_numeric_bytes_per_prec[bcpcol->db_prec];
  1441. tds_put_byte(tds, numeric_size);
  1442. } else
  1443. tds_put_byte(tds, bcpcol->data_size);
  1444. break;
  1445. case 0:
  1446. break;
  1447. default:
  1448.                       /*assert(bcpcol->db_varint_size <= 4);*/
  1449. break;
  1450. }
  1452. #ifdef WORDS_BIGENDIAN
  1453. tds_swap_datatype
  1454. (tds_get_conversion_type(bcpcol->db_type, bcpcol->db_length), bcpcol->data);
  1455. #else
  1456. if (is_numeric_type(bcpcol->db_type)) {
  1457. tds_swap_datatype
  1458. (tds_get_conversion_type
  1459.  (bcpcol->db_type, bcpcol->db_length), bcpcol->data);
  1460. }
  1461. #endif
  1463. if (is_numeric_type(bcpcol->db_type)) {
  1464. num = (TDS_NUMERIC *) bcpcol->data;
  1465.                             tds_put_n(tds, num->array, g__numeric_bytes_per_prec[num->precision]);
  1466.                         }
  1467.                         else
  1468. tds_put_n(tds, bcpcol->data, bcpcol->data_size);
  1469. }
  1470. }
  1471.             }
  1472.             else    /* Not TDS 7 or 8 */    {
  1473. memset(rowbuffer, '', ROWBUF_SIZE); /* zero the rowbuffer */
  1475. /* offset 0 = number of var columns */
  1476. /* offset 1 = row number.  zeroed (datasever assigns) */
  1478. row_pos = 2;
  1480. rowbuffer[0] = dbproc->var_cols;
  1482. if ((row_pos = _bcp_add_fixed_columns(dbproc, rowbuffer, row_pos)) == FAIL)
  1483. return (FAIL);
  1485. row_sz_pos = row_pos;
  1487. if (dbproc->var_cols) {
  1489. row_pos += 2; /* skip over row length */
  1491.                     if ((row_pos = _bcp_add_variable_columns(dbproc, rowbuffer, row_pos)) == FAIL)
  1492. return (FAIL);
  1493. }
  1495. row_size = row_pos;
  1498. if (dbproc->var_cols)
  1499. memcpy(&rowbuffer[row_sz_pos], &row_size, sizeof(row_size));
  1501. tds_put_smallint(tds, row_size);
  1502. tds_put_n(tds, rowbuffer, row_size);
  1504. /* row is done, now handle any text/image data */
  1506. blob_cols = 0;
  1508. for (i = 0; i < dbproc->bcp_colcount; i++) {
  1509. bcpcol = dbproc->bcp_columns[i];
  1510. if (is_blob_type(bcpcol->db_type)) {
  1511. /* unknown but zero */
  1512. tds_put_smallint(tds, 0);
  1513. tds_put_byte(tds, bcpcol->db_type);
  1514. tds_put_byte(tds, 0xff - blob_cols);
  1515. /* offset of txptr we stashed during variable
  1516.                         ** column processing */
  1517. tds_put_smallint(tds, bcpcol->txptr_offset);
  1518. tds_put_int(tds, bcpcol->data_size);
  1519. tds_put_n(tds, bcpcol->data, bcpcol->data_size);
  1520. blob_cols++;
  1521. }
  1522. }
  1523. } /* Not TDS  7.0 or 8.0 */
  1525. rows_written_so_far++;
  1527. if (dbproc->bcpbatch > 0 && rows_written_so_far == dbproc->bcpbatch) {
  1528. rows_written_so_far = 0;
  1530. tds_flush_packet(tds);
  1532. do {
  1533. marker = tds_get_byte(tds);
  1534. if (marker == TDS_DONE_TOKEN) {
  1535. tds_process_end(tds, marker, NULL,NULL);
  1536. rows_copied_this_batch = tds->rows_affected;
  1537. rows_copied_so_far += rows_copied_this_batch;
  1538.                     } 
  1539.                     else {
  1540. tds_process_default_tokens(tds, marker);
  1541. }
  1542. } while (marker != TDS_DONE_TOKEN);
  1544. _bcp_start_new_batch(dbproc);
  1546. }
  1547. }
  1548. }
  1550. if (fclose(hostfile) != 0) {
  1551.         _bcp_err_handler(dbproc, BCPEBCUC);
  1552. return (FAIL);
  1553. }
  1555. tds_flush_packet(tds);
  1557. do {
  1558. marker = tds_get_byte(tds);
  1559. if (marker == TDS_DONE_TOKEN) {
  1560. tds_process_end(tds, marker, NULL,NULL);
  1561. rows_copied_this_batch = tds->rows_affected;
  1562. rows_copied_so_far += rows_copied_this_batch;
  1563. *rows_copied = rows_copied_so_far;
  1564.         } 
  1565.         else {
  1566. tds_process_default_tokens(tds, marker);
  1567. }
  1568. } while (marker != TDS_DONE_TOKEN);
  1570. return SUCCEED;
  1571. }
  1573. RETCODE bcp_exec(DBPROCESS *dbproc, DBINT *rows_copied)
  1574. {
  1576. RETCODE ret;
  1578. if (dbproc->bcp_direction == 0) {
  1579.         _bcp_err_handler(dbproc, BCPEBCPI);
  1580. return FAIL;
  1581. }
  1582. if (dbproc->bcp_hostfile) {
  1583. if (dbproc->bcp_direction == DB_OUT) {
  1584. ret = _bcp_exec_out(dbproc, rows_copied);
  1585.         } 
  1586.         else if (dbproc->bcp_direction==DB_IN) {
  1587. ret = _bcp_exec_in(dbproc, rows_copied);
  1588. }
  1589. _bcp_clear_storage(dbproc);
  1590. return ret;
  1591.     }
  1592.     else {
  1593.         _bcp_err_handler(dbproc, BCPEBCVH );
  1594. return FAIL;
  1595. }
  1596. }
  1598. static RETCODE _bcp_start_copy_in(DBPROCESS *dbproc)
  1599. {
  1601. TDSSOCKET *tds = dbproc->tds_socket;
  1602. BCP_COLINFO *bcpcol;
  1603.     TDSCOLINFO      *curcol;
  1604.     TDSRESULTINFO   *resinfo;
  1606. int i;
  1607. int marker;
  1608.     char colstatus;
  1610. #ifdef NCBI_FTDS
  1611.     char query[2048];
  1612.     char colclause[2048];
  1613. #else
  1614.     char query[256];
  1615.     char colclause[256];
  1616. #endif
  1617. int firstcol;
  1619. if (IS_TDS7_PLUS(tds)) {
  1620. int erc;
  1621. char *hint;
  1622.         firstcol = 1;
  1623. #ifdef NCBI_FTDS
  1624.         colclause[0]= '';
  1625.         for(i= 0; i < dbproc->bcp_colcount; i++) {
  1626.             if((!is_blob_type(dbproc->bcp_columns[i]->db_type)) &&
  1627.                (dbproc->host_columns[i]->datatype != 0)){
  1628.                 _bcp_build_bulk_insert_stmt(colclause, dbproc->bcp_columns[i], firstcol);
  1629.                 firstcol = 0;
  1630.             }
  1631.         }
  1633.         for(i= 0; i < dbproc->bcp_colcount; i++) {
  1634.             if(is_blob_type(dbproc->bcp_columns[i]->db_type) &&
  1635.                (dbproc->host_columns[i]->datatype != 0)) {
  1636.                 _bcp_build_bulk_insert_stmt(colclause, dbproc->bcp_columns[i], firstcol);
  1637.                 firstcol = 0;
  1638.             }
  1639.         }
  1640. #else
  1641. strcpy(colclause, "");
  1643. for (i = 0; i < dbproc->bcp_colcount; i++) {
  1644. bcpcol = dbproc->bcp_columns[i];
  1646. if (IS_TDS7_PLUS(tds)) {
  1647. _bcp_build_bulk_insert_stmt(colclause, bcpcol, firstcol);
  1648. firstcol = 0;
  1649. }
  1650. }
  1651. #endif
  1652. if (dbproc->bcp_hint) {
  1653. if (asprintf(&hint, " with (%s)", dbproc->bcp_hint) < 0) {
  1654. return FAIL;
  1655. }
  1656. } else {
  1657. hint = strdup("");
  1658. }
  1659. if (!hint) return FAIL;
  1661. sprintf(query, "insert bulk %s (%s)%s", dbproc->bcp_tablename, colclause, hint);
  1663. free(hint); 
  1665. } 
  1666.    else {
  1667.        sprintf(query, "insert bulk %s", dbproc->bcp_tablename);
  1668. }
  1670. tds_submit_query(tds, query);
  1672. /* save the statement for later... */
  1674.     dbproc->bcp_insert_stmt = (char *) malloc(strlen(query)+1);
  1675.     strcpy(dbproc->bcp_insert_stmt, query);
  1677. /* In TDS 5 we get the column information as a */
  1678. /* result set from the "insert bulk" command.  */
  1679. /* we're going to ignore this....              */
  1681. if (IS_TDS50(tds)) {
  1682.         if (tds_process_result_tokens(tds) == TDS_FAIL) {
  1683. return FAIL;
  1684. }
  1685. if (!tds->res_info) {
  1686. return FAIL;
  1687. }
  1689.         while (tds_process_row_tokens(tds) == SUCCEED); 
  1691.     }
  1692.     else {
  1693. marker = tds_get_byte(tds);
  1694. tds_process_default_tokens(tds, marker);
  1695. if (!is_end_token(marker)) {
  1696. return FAIL;
  1697. }
  1698. }
  1700. /* work out the number of "variable" columns -         */
  1701. /* either varying length type e.g. varchar or nullable */
  1703. dbproc->var_cols = 0;
  1705. for (i = 0; i < dbproc->bcp_colcount; i++) {
  1707. bcpcol = dbproc->bcp_columns[i];
  1708.         if (is_nullable_type(bcpcol->db_type) ||
  1709.             bcpcol->db_nullable) {
  1710. dbproc->var_cols++;
  1711. }
  1712. }
  1714. return SUCCEED;
  1716. }
  1718. static RETCODE _bcp_build_bulk_insert_stmt(char *clause, BCP_COLINFO *bcpcol, int first)
  1719. {
  1720. char column_type[32];
  1722. switch (bcpcol->db_type_save) {
  1723.     case SYBINT1:      strcpy(column_type,"tinyint");
  1724. break;
  1725.     case SYBBIT:       strcpy(column_type,"bit");
  1726. break;
  1727.     case SYBINT2:      strcpy(column_type,"smallint");
  1728. break;
  1729.     case SYBINT4:      strcpy(column_type,"int");
  1730. break;
  1731.     case SYBDATETIME:  strcpy(column_type,"datetime");
  1732. break;
  1733.     case SYBDATETIME4: strcpy(column_type,"smalldatetime");
  1734. break;
  1735.     case SYBREAL:      strcpy(column_type,"real");
  1736. break;
  1737.     case SYBMONEY:     strcpy(column_type,"money");
  1738. break;
  1739.     case SYBMONEY4:    strcpy(column_type,"smallmoney");
  1740. break;
  1741.     case SYBFLT8:      strcpy(column_type,"float");
  1742. break;
  1743.     case SYBINT8:      strcpy(column_type,"bigint");
  1744. break;
  1746.     case SYBINTN:      switch (bcpcol->db_length) {
  1747.     case 1: strcpy(column_type,"tinyint");
  1748. break;
  1749.     case 2: strcpy(column_type,"smallint");
  1750. break;
  1751.     case 4: strcpy(column_type,"int");
  1752. break;
  1753.     case 8: strcpy(column_type,"bigint");
  1754. break;
  1755. }
  1756. break;
  1758.     case SYBBITN:      strcpy(column_type,"bit");
  1759. break;
  1760.     case SYBFLTN:      switch (bcpcol->db_length) {
  1761.     case 4: strcpy(column_type,"real");
  1762. break;
  1763.     case 8: strcpy(column_type,"float");
  1764. break;
  1765. }
  1766. break;
  1767.     case SYBMONEYN:    switch (bcpcol->db_length) {
  1768.     case 4: strcpy(column_type,"smallmoney");
  1769. break;
  1770.     case 8: strcpy(column_type,"money");
  1771. break;
  1772. }
  1773. break;
  1774.     case SYBDATETIMN:  switch (bcpcol->db_length) {
  1775.     case 4: strcpy(column_type,"smalldatetime");
  1776. break;
  1777.     case 8: strcpy(column_type,"datetime");
  1778. break;
  1779. }
  1780. break;
  1781.     case SYBDECIMAL:   sprintf(column_type,"decimal(%d,%d)", bcpcol->db_prec, bcpcol->db_scale);
  1782. break;
  1783.     case SYBNUMERIC:   sprintf(column_type,"numeric(%d,%d)", bcpcol->db_prec, bcpcol->db_scale);
  1784. break;
  1786.     case XSYBVARBINARY: sprintf(column_type,"varbinary(%d)", bcpcol->db_length);
  1787. break;
  1788.     case XSYBVARCHAR  : sprintf(column_type,"varchar(%d)", bcpcol->db_length);
  1789. break;
  1790.     case XSYBBINARY   : sprintf(column_type,"binary(%d)", bcpcol->db_length);
  1791. break;
  1792.     case XSYBCHAR     : sprintf(column_type,"char(%d)", bcpcol->db_length);
  1793. break;
  1794.     case SYBTEXT      : sprintf(column_type,"text");
  1795. break;
  1796.     case SYBIMAGE     : sprintf(column_type,"image");
  1797. break;
  1798.     case XSYBNVARCHAR : sprintf(column_type,"nvarchar(%d)", bcpcol->db_length);
  1799. break;
  1800.     case XSYBNCHAR    : sprintf(column_type,"nchar(%d)", bcpcol->db_length);
  1801. break;
  1802.     case SYBNTEXT     : sprintf(column_type,"ntext");
  1803. break;
  1804. }
  1806. if (!first)
  1807. strcat(clause, ", ");
  1809. strcat(clause, bcpcol->db_name);
  1810. strcat(clause, " ");
  1812. strcat(clause, column_type);
  1814. #ifdef NCBI_FTDS
  1815. return SUCCEED;
  1816. #endif
  1817. }
  1819. static RETCODE _bcp_start_new_batch(DBPROCESS *dbproc)
  1820. {
  1822. TDSSOCKET *tds = dbproc->tds_socket;
  1823. int marker;
  1825. if (IS_TDS50(tds)) {
  1827. tds_submit_query(tds, dbproc->bcp_insert_stmt);
  1829.         if (tds_process_result_tokens(tds) == TDS_FAIL) {
  1830. return FAIL;
  1831. }
  1832. if (!tds->res_info) {
  1833. return FAIL;
  1834. }
  1836.         while (tds_process_row_tokens(tds) == SUCCEED); 
  1838.     }   
  1839.     else {
  1840. tds_submit_query(tds, dbproc->bcp_insert_stmt);
  1842. marker = tds_get_byte(tds);
  1843. tds_process_default_tokens(tds, marker);
  1844. if (!is_end_token(marker)) {
  1845. return FAIL;
  1846. }
  1847. }
  1849. tds->out_flag = 0x07;
  1851. if (IS_TDS7_PLUS(tds)) {
  1852. _bcp_send_colmetadata(dbproc);
  1853. }
  1854. return SUCCEED;
  1855. }
  1857. static RETCODE _bcp_send_colmetadata(DBPROCESS *dbproc)
  1858. {
  1860. TDSSOCKET *tds = dbproc->tds_socket;
  1861.     int          marker;
  1862. unsigned char colmetadata_token = 0x81;
  1863. BCP_COLINFO *bcpcol;
  1864. char unicode_string[256];
  1867. int i;
  1868. #ifdef NCBI_FTDS
  1869.     int n;
  1870. #endif
  1873. if (IS_TDS7_PLUS(tds)) {
  1874. /* Deep joy! - for TDS 8 we have to send a 
  1875.            colmetadata message followed by row data 
  1876.  */
  1878. tds_put_byte(tds, colmetadata_token); /* 0x81 */
  1880. #ifdef NCBI_FTDS
  1881.         for (i = 0, n= 0; i < dbproc->bcp_colcount; i++) {
  1882.             if(dbproc->host_columns[i]->datatype != 0) n++;
  1883.         }
  1884.         tds_put_smallint(tds, n);
  1885. #else
  1886. tds_put_smallint(tds, dbproc->bcp_colcount);
  1887. #endif
  1889. #ifdef NCBI_FTDS
  1890.         for(n= 2; n--;)
  1891. #endif
  1892.         for (i = 0; i < dbproc->bcp_colcount; i++) {
  1893. #ifdef NCBI_FTDS
  1894.             if(dbproc->host_columns[i]->datatype == 0) continue;
  1895.             if(n) {
  1896.                 if(is_blob_type(dbproc->bcp_columns[i]->db_type)) continue;
  1897.             }
  1898.             else
  1899.                 if(!is_blob_type(dbproc->bcp_columns[i]->db_type)) continue;
  1900. #endif
  1902. bcpcol = dbproc->bcp_columns[i];
  1903. tds_put_smallint(tds, bcpcol->db_usertype);
  1904. tds_put_smallint(tds, bcpcol->db_flags);
  1905. tds_put_byte(tds, bcpcol->db_type_save);
  1907. switch (bcpcol->db_varint_size) {
  1908.             case 4: tds_put_int(tds, bcpcol->db_length);
  1909. break;
  1910.             case 2: tds_put_smallint(tds, bcpcol->db_length);
  1911. break;
  1912.             case 1: tds_put_byte(tds, bcpcol->db_length);
  1913. break;
  1914.             case 0: break;
  1915. }
  1917. if (is_numeric_type(bcpcol->db_type)) {
  1918. tds_put_byte(tds, bcpcol->db_prec);
  1919. tds_put_byte(tds, bcpcol->db_scale);
  1920. }
  1921. #ifndef NCBI_FTDS
  1922.             if (IS_TDS80(tds) && is_collate_type(bcpcol->db_type_save)) {
  1923. #else
  1924.             if (IS_TDS80(tds) && 
  1925.                 (((bcpcol->db_flags & 0x2) != 0) || is_collate_type(bcpcol->db_type_save))) {
  1926. #endif
  1927. tds_put_n(tds, bcpcol->db_collate, 5);
  1928. }
  1929. #ifdef NCBI_FTDS
  1930.             if(is_blob_type(bcpcol->db_type)) {
  1931.                 tds_put_byte(tds, 0x0); tds_put_byte(tds, 0x0); /* don't know what it is */
  1932.             }
  1933. #endif
  1934. tds_put_byte(tds, strlen(bcpcol->db_name));
  1935. tds7_ascii2unicode(tds, bcpcol->db_name, unicode_string, 255);
  1936. tds_put_n(tds, unicode_string, strlen(bcpcol->db_name) * 2);
  1938. }
  1939. }
  1940. return SUCCEED;
  1941. }
  1944. RETCODE bcp_readfmt(DBPROCESS *dbproc, char *filename)
  1945. {
  1946. FILE *ffile;
  1947. char buffer[1024];
  1949. float lf_version = 0.0;
  1950. int li_numcols = 0;
  1951. int colinfo_count = 0;
  1953.     struct fflist {
  1954. struct fflist *nextptr;
  1955. BCP_HOSTCOLINFO colinfo;
  1956. };
  1958. struct fflist *topptr = (struct fflist *) NULL;
  1959. struct fflist *curptr = (struct fflist *) NULL;
  1961. BCP_HOSTCOLINFO *hostcol;
  1963. if (dbproc->bcp_direction == 0) {
  1964.         _bcp_err_handler(dbproc, BCPEBCPI);
  1965. return FAIL;
  1966. }
  1968. if ((ffile = fopen(filename, "r")) == (FILE *) NULL) {
  1969.         _bcp_err_handler(dbproc, BCPEBUOF);
  1970. return (FAIL);
  1971. }
  1973. if ((fgets(buffer, sizeof(buffer), ffile)) != (char *) NULL) {
  1974. buffer[strlen(buffer) - 1] = ''; /* discard newline */
  1975. lf_version = atof(buffer);
  1976. }
  1978. if ((fgets(buffer, sizeof(buffer), ffile)) != (char *) NULL) {
  1979. buffer[strlen(buffer) - 1] = ''; /* discard newline */
  1980. li_numcols = atoi(buffer);
  1981. }
  1983. while ((fgets(buffer, sizeof(buffer), ffile)) != (char *) NULL) {
  1985. buffer[strlen(buffer) - 1] = ''; /* discard newline */
  1988. if (topptr == (struct fflist *) NULL) { /* first time */
  1989. if ((topptr = (struct fflist *) malloc(sizeof(struct fflist))) == (struct fflist *) NULL) {
  1990. fprintf(stderr, "out of memoryn");
  1991. return (FAIL);
  1992. }
  1993. curptr = topptr;
  1994. curptr->nextptr = NULL;
  1995. if (_bcp_readfmt_colinfo(dbproc, buffer, &(curptr->colinfo)))
  1996. colinfo_count++;
  1997. else
  1998. return (FAIL);
  1999. } else {
  2000. if ((curptr->nextptr = (struct fflist *) malloc(sizeof(struct fflist))) == (struct fflist *) NULL) {
  2001. fprintf(stderr, "out of memoryn");
  2002. return (FAIL);
  2003. }
  2004. curptr = curptr->nextptr;
  2005. curptr->nextptr = NULL;
  2006. if (_bcp_readfmt_colinfo(dbproc, buffer, &(curptr->colinfo)))
  2007. colinfo_count++;
  2008. else
  2009. return (FAIL);
  2010. }
  2012. }
  2013. if (fclose(ffile) != 0) {
  2014.         _bcp_err_handler(dbproc, BCPEBUCF);
  2015. return (FAIL);
  2016. }
  2018. if (colinfo_count != li_numcols)
  2019. return (FAIL);
  2021. if (bcp_columns(dbproc, li_numcols) == FAIL) {
  2022. return (FAIL);
  2023. }
  2025. for (curptr = topptr; curptr->nextptr != (struct fflist *) NULL; curptr = curptr->nextptr) {
  2026. hostcol = &(curptr->colinfo);
  2027. if (bcp_colfmt(dbproc, hostcol->host_column, hostcol->datatype,
  2028.        hostcol->prefix_len, hostcol->column_len,
  2029.                        hostcol->terminator,  hostcol->term_len ,
  2030.                        hostcol->tab_colnum ) == FAIL) {
  2031. return (FAIL);
  2032. }
  2033. }
  2034. hostcol = &(curptr->colinfo);
  2035. if (bcp_colfmt(dbproc, hostcol->host_column, hostcol->datatype,
  2036.        hostcol->prefix_len, hostcol->column_len,
  2037.                    hostcol->terminator,  hostcol->term_len ,
  2038.                    hostcol->tab_colnum ) == FAIL) {
  2039. return (FAIL);
  2040. }
  2042. return (SUCCEED);
  2044. }
  2046. int _bcp_readfmt_colinfo(DBPROCESS *dbproc, char *buf, BCP_HOSTCOLINFO *ci)
  2047. {
  2049. char *tok;
  2050. int whichcol;
  2051. char term[30];
  2052. int i;
  2054.     enum nextcol {
  2055. HOST_COLUMN,
  2056. DATATYPE,
  2057. PREFIX_LEN,
  2058. COLUMN_LEN,
  2059. TERMINATOR,
  2060. TAB_COLNUM,
  2061. NO_MORE_COLS
  2062. };
  2064. tok = strtok(buf, " t");
  2065. whichcol = HOST_COLUMN;
  2067. while (tok != (char *) NULL && whichcol != NO_MORE_COLS) {
  2068. switch (whichcol) {
  2070. case HOST_COLUMN:
  2071. ci->host_column = atoi(tok);
  2073. if (ci->host_column < 1) {
  2074.                 _bcp_err_handler(dbproc, BCPEBIHC);
  2075. return (FALSE);
  2076. }
  2078. whichcol = DATATYPE;
  2079. break;
  2081. case DATATYPE:
  2082. if (strcmp(tok, "SYBCHAR") == 0)
  2083. ci->datatype = SYBCHAR;
  2084. else if (strcmp(tok, "SYBTEXT") == 0)
  2085. ci->datatype = SYBTEXT;
  2086. else if (strcmp(tok, "SYBBINARY") == 0)
  2087. ci->datatype = SYBBINARY;
  2088. else if (strcmp(tok, "SYBIMAGE") == 0)
  2089. ci->datatype = SYBIMAGE;
  2090. else if (strcmp(tok, "SYBINT1") == 0)
  2091. ci->datatype = SYBINT1;
  2092. else if (strcmp(tok, "SYBINT2") == 0)
  2093. ci->datatype = SYBINT2;
  2094. else if (strcmp(tok, "SYBINT4") == 0)
  2095. ci->datatype = SYBINT4;
  2096. else if (strcmp(tok, "SYBFLT8") == 0)
  2097. ci->datatype = SYBFLT8;
  2098. else if (strcmp(tok, "SYBREAL") == 0)
  2099. ci->datatype = SYBREAL;
  2100. else if (strcmp(tok, "SYBBIT") == 0)
  2101. ci->datatype = SYBBIT;
  2102. else if (strcmp(tok, "SYBNUMERIC") == 0)
  2103. ci->datatype = SYBNUMERIC;
  2104. else if (strcmp(tok, "SYBDECIMAL") == 0)
  2105. ci->datatype = SYBDECIMAL;
  2106. else if (strcmp(tok, "SYBMONEY") == 0)
  2107. ci->datatype = SYBMONEY;
  2108. else if (strcmp(tok, "SYBDATETIME") == 0)
  2109. ci->datatype = SYBDATETIME;
  2110. else if (strcmp(tok, "SYBDATETIME4") == 0)
  2111. ci->datatype = SYBDATETIME4;
  2112. else {
  2113.                 _bcp_err_handler(dbproc, BCPEBUDF);
  2114. return (FALSE);
  2115. }
  2117. whichcol = PREFIX_LEN;
  2118. break;
  2120. case PREFIX_LEN:
  2121. ci->prefix_len = atoi(tok);
  2122. whichcol = COLUMN_LEN;
  2123. break;
  2124. case COLUMN_LEN:
  2125. ci->column_len = atoi(tok);
  2126. whichcol = TERMINATOR;
  2127. break;
  2128. case TERMINATOR:
  2130. if (*tok++ != '"')
  2131. return (FALSE);
  2133. for (i = 0; *tok != '"' && i < 30; i++) {
  2134. if (*tok == '\') {
  2135. tok++;
  2136. switch (*tok) {
  2137.                     case 't':  term[i] = 't'; break;
  2138.                     case 'n':  term[i] = 'n'; break;
  2139.                     case 'r':  term[i] = 'r'; break;
  2140.                     case '\': term[i] = '\'; break;
  2141.                     case '0':  term[i] = ''; break;
  2142.                     default:   return(FALSE);
  2143. }
  2144. tok++;
  2145.                 }
  2146.                 else
  2147. term[i] = *tok++;
  2148. }
  2150. if (*tok != '"')
  2151. return (FALSE);
  2153. term[i] = '';
  2154. ci->terminator = (BYTE*) malloc(i + 1);
  2155. strcpy((char*) ci->terminator, term);
  2156. ci->term_len = strlen(term);
  2158. whichcol = TAB_COLNUM;
  2159. break;
  2161. case TAB_COLNUM:
  2162. ci->tab_colnum = atoi(tok);
  2163. whichcol = NO_MORE_COLS;
  2164. break;
  2166. }
  2167. tok = strtok((char *) NULL, " t");
  2168. }
  2169. if (whichcol == NO_MORE_COLS)
  2170. return (TRUE);
  2171. else
  2172. return (FALSE);
  2173. }
  2175. RETCODE bcp_writefmt(DBPROCESS *dbproc, char *filename)
  2176. {
  2177. if (dbproc->bcp_direction == 0) {
  2178.         _bcp_err_handler(dbproc, BCPEBCPI);
  2179. return FAIL;
  2180. }
  2181. return SUCCEED;
  2182. }
  2184. RETCODE bcp_moretext(DBPROCESS *dbproc, DBINT size, BYTE *text)
  2185. {
  2186. #ifdef NCBI_FTDS
  2187.     static unsigned char txtptr_and_timestamp[24]= {
  2188.         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  2189.         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  2190.         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
  2191.     };
  2193.     int i;
  2194.     DBINT s;
  2195.     BCP_COLINFO *bcpcol;
  2196.     TDSSOCKET *tds = dbproc->tds_socket;
  2198.     if (dbproc == NULL || text== NULL || tds == NULL) {
  2199.         return FAIL;
  2200.     }
  2202.     if ( dbproc->text_sent == 0 ) {
  2203.         for (i=dbproc->curr_text_col; i < dbproc->bcp_colcount; i++) {
  2204.             if(dbproc->host_columns[i]->datatype == 0) continue;
  2206.             bcpcol = dbproc->bcp_columns[i];
  2207.             if (bcpcol == NULL) {
  2208.                 return FAIL;
  2209.             }
  2210.             if (is_blob_type (bcpcol->db_type) ) { 
  2211.                 dbproc->curr_text_col = i;
  2212.                 tds_put_byte (tds,0x10);
  2213.                 tds_put_n(tds, txtptr_and_timestamp, 24);
  2214.                 tds_put_int (tds,  bcpcol->data_size);
  2215.                 break;
  2216.             }
  2217.         }
  2218.         if(i >= dbproc->bcp_colcount) return FAIL;
  2219.     }
  2220.     if(dbproc->bcp_columns[dbproc->curr_text_col]->data_size == 0 &&
  2221.        size == 0) { /* this is a NULL */
  2222.         dbproc->curr_text_col++;
  2223.         dbproc->text_sent = 0;
  2224.         return SUCCEED;
  2225.     }
  2226.     s= dbproc->bcp_columns[dbproc->curr_text_col]->data_size - dbproc->text_sent;
  2227.     if(s <= 0) return FAIL;
  2228.     if(size > s) size= s;
  2229.     tds_put_n (tds, text, size);
  2230.     dbproc->text_sent += size;
  2231.     if (dbproc->text_sent >= dbproc->bcp_columns[dbproc->curr_text_col]->data_size) {
  2232.         dbproc->text_sent = 0;
  2233.         dbproc->curr_text_col++;
  2234.     }
  2235. #else
  2236. if (dbproc->bcp_direction == 0) {
  2237.         _bcp_err_handler(dbproc, BCPEBCPI);
  2238. return FAIL;
  2239. }
  2240. #endif
  2241. return SUCCEED;
  2242. }
  2244. RETCODE bcp_batch(DBPROCESS *dbproc)
  2245. {
  2246. TDSSOCKET *tds = dbproc->tds_socket;
  2247. int marker;
  2248. int rows_copied;
  2250. if (dbproc->bcp_direction == 0) {
  2251.         _bcp_err_handler(dbproc, BCPEBCPI);
  2252.         return FAIL;
  2253. }
  2255. tds_flush_packet(tds);
  2257. do {
  2259. marker = tds_get_byte(tds);
  2260.         if ( marker == TDS_DONE_TOKEN ) 
  2261.             rows_copied = tds_process_end(tds,marker,NULL,NULL);
  2262.         else 
  2263. tds_process_default_tokens(tds, marker);
  2265. } while (marker != TDS_DONE_TOKEN);
  2268. _bcp_start_new_batch(dbproc);
  2271.     return rows_copied;
  2272. }
  2274. /* end the transfer of data from program variables */
  2276. RETCODE bcp_done(DBPROCESS *dbproc)
  2277. {
  2279. TDSSOCKET *tds = dbproc->tds_socket;
  2280. int marker;
  2281. int rows_copied = -1;
  2283. if (dbproc->bcp_direction == 0) {
  2284.         _bcp_err_handler(dbproc, BCPEBCPI);
  2285.         return FAIL;
  2286. }
  2287. tds_flush_packet(tds);
  2289. do {
  2291. marker = tds_get_byte(tds);
  2292.         if ( marker == TDS_DONE_TOKEN ) 
  2293.             rows_copied = tds_process_end(tds,marker,NULL,NULL);
  2294.         else 
  2295. tds_process_default_tokens(tds, marker);
  2297. } while (marker != TDS_DONE_TOKEN);
  2299. _bcp_clear_storage(dbproc);
  2301. return (rows_copied);
  2303. }
  2305. /* bind a program host variable to a database column */
  2307. RETCODE bcp_bind(DBPROCESS *dbproc, BYTE *varaddr, int prefixlen, DBINT varlen,
  2308.  BYTE * terminator, int termlen, int type, int table_column)
  2309. {
  2311. BCP_HOSTCOLINFO *hostcol;
  2313. if (dbproc->bcp_direction == 0) {
  2314.         _bcp_err_handler(dbproc, BCPEBCPI);
  2315. return FAIL;
  2316. }
  2318. if (dbproc->bcp_hostfile != (char *) NULL) {
  2319.         _bcp_err_handler(dbproc, BCPEBCPB);
  2320. return FAIL;
  2321. }
  2323. if (dbproc->bcp_direction != DB_IN) {
  2324.         _bcp_err_handler(dbproc, BCPEBCPN);
  2325. return FAIL;
  2326. }
  2328. if (varlen < -1) {
  2329.         _bcp_err_handler(dbproc, BCPEBCVLEN);
  2330. return FAIL;
  2331. }
  2333.     if (prefixlen != 0 && prefixlen != 1 &&
  2334.         prefixlen != 2 && prefixlen != 4 ) {
  2335.         _bcp_err_handler(dbproc, BCPEBCBPREF);
  2336. return FAIL;
  2337. }
  2339.     if (prefixlen == 0 && varlen == -1 && 
  2340.         termlen == -1 && !is_fixed_type(type)) {
  2341. return FAIL;
  2342. }
  2344.     if (is_fixed_type(type) && 
  2345.         (varlen != -1 && varlen != 0)) {
  2346. return FAIL;
  2347. }
  2349. if (table_column > dbproc->host_colcount) {
  2350. return FAIL;
  2351. }
  2353. #ifndef NCBI_FTDS
  2354.     if (varaddr == (BYTE *)NULL && 
  2355.         (prefixlen != 0 || termlen != 0)) {
  2356.         _bcp_err_handler(dbproc, BCPEBCBNPR);
  2357. return FAIL;
  2358. }
  2359. #endif
  2361. hostcol = dbproc->host_columns[table_column - 1];
  2363. hostcol->host_var = varaddr;
  2364. hostcol->datatype = type;
  2365. hostcol->prefix_len = prefixlen;
  2366. hostcol->column_len = varlen;
  2367.     if(termlen > 0) {
  2368. hostcol->terminator = (BYTE *) malloc(termlen + 1);
  2369. memcpy(hostcol->terminator, terminator, termlen);
  2370.     }
  2371.     else hostcol->terminator= NULL;
  2372. hostcol->term_len = termlen;
  2373. hostcol->tab_colnum = table_column;
  2375. return SUCCEED;
  2376. }
  2378. /* for a bcp in from program variables, collate all the data */
  2379. /* into the column arrays held in dbproc...                  */
  2381. RETCODE _bcp_get_prog_data(DBPROCESS *dbproc)
  2382. {
  2383.     BCP_COLINFO *bcpcol;
  2384.     BCP_HOSTCOLINFO *hostcol;
  2386.     int i;
  2387.     TDS_TINYINT ti;
  2388.     TDS_SMALLINT si;
  2389.     TDS_INT li;
  2390.     TDS_INT desttype;
  2391.     int collen;
  2392.     int data_is_null;
  2393.     int bytes_read;
  2394.     int converted_data_size;
  2396.     BYTE *dataptr;
  2398.     /* for each host file column defined by calls to bcp_colfmt */
  2400.     for (i = 0; i < dbproc->host_colcount; i++) {
  2401.         BYTE coldata[4096];
  2403.         hostcol = dbproc->host_columns[i];
  2404. #ifdef NCBI_FTDS
  2405.         if(hostcol->datatype == 0) continue;
  2406. #endif
  2407.         dataptr = hostcol->host_var;
  2409.         data_is_null = 0;
  2410.         collen = 0;
  2412.         /* if a prefix length specified, read the correct */
  2413.         /* amount of data...                              */
  2415.         if (hostcol->prefix_len > 0) {
  2417.             switch (hostcol->prefix_len) {
  2418.             case 1:
  2419.                 memcpy(&ti, dataptr, 1);
  2420.                 dataptr += 1;
  2421.                 collen = ti;
  2422.                 break;
  2423.             case 2:
  2424.                 memcpy(&si, dataptr, 2);
  2425.                 dataptr += 2;
  2426.                 collen = si;
  2427.                 break;
  2428.             case 4:
  2429.                 memcpy(&li, dataptr, 4);
  2430.                 dataptr += 4;
  2431.                 collen = li;
  2432.                 break;
  2433.             }
  2434.             if (collen == 0)
  2435.                 data_is_null = 1;
  2437.         }
  2439.         /* if (Max) column length specified take that into */
  2440.         /* consideration...                                */
  2442.         if (!data_is_null && hostcol->column_len >= 0) {
  2443.             if (hostcol->column_len == 0)
  2444.                 data_is_null = 1;
  2445.             else {
  2446.                 if (collen)
  2447.                     collen = (hostcol->column_len < collen) ? hostcol->column_len : collen;
  2448.                 else
  2449.                     collen = hostcol->column_len;
  2450.             }
  2451.         }
  2453.         /* Fixed Length data - this over-rides anything else specified */
  2455.         if (is_fixed_type(hostcol->datatype)) {
  2456.             collen = get_size_by_type(hostcol->datatype);
  2457.         }
  2458. #ifdef NCBI_FTDS
  2459.         else if(is_numeric_type(hostcol->datatype)) {
  2460.             collen= sizeof(DBNUMERIC);
  2461.         }
  2462. #endif
  2465.         /* if this host file column contains table data,   */
  2466.         /* find the right element in the table/column list */
  2468.         if (hostcol->tab_colnum) {
  2469.             bcpcol = dbproc->bcp_columns[hostcol->tab_colnum - 1];
  2470.             if (bcpcol->tab_colnum != hostcol->tab_colnum) {
  2471.                 return FAIL;
  2472.             }
  2473.         }
  2474. #ifdef NCBI_FTDS
  2475.         if(dataptr == NULL) {
  2476.             bcpcol->data_size= collen;
  2477.             continue;
  2478.         }
  2479. #endif
  2482.         /* a terminated field is specified - get the data into temporary space... */
  2484.         memset(coldata, '', sizeof(coldata));
  2486.         if (hostcol->term_len > 0) {
  2487.             bytes_read = _bcp_get_term_var(dataptr, hostcol->terminator, hostcol->term_len, coldata);
  2489.             if (bytes_read == -1)
  2490.                 return FAIL;
  2493.             if (collen)
  2494.                 collen = (bytes_read < collen) ? bytes_read : collen;
  2495.             else
  2496.                 collen = bytes_read;
  2498.             if (collen == 0)
  2499.                 data_is_null = 1;
  2501.             if (hostcol->tab_colnum) {
  2502.                 if (data_is_null) {
  2503.                     bcpcol->data_size = 0;
  2504.                 }
  2505.                 else {
  2506.                     desttype = tds_get_conversion_type(bcpcol->db_type, bcpcol->db_length);
  2508.                     if ((converted_data_size = dbconvert(dbproc, hostcol->datatype, 
  2509.                                                          (BYTE *) coldata, collen,
  2510.                                                          desttype, bcpcol->data, 
  2511.                                                          bcpcol->db_length)) == FAIL) {
  2512.                         return (FAIL);
  2513.                     }
  2515.                     bcpcol->data_size = converted_data_size;
  2516.                 }
  2517.             }
  2518.         }
  2519.         else {
  2520.             if (collen) {
  2521.                 memcpy(coldata, dataptr, collen);
  2522.             }
  2524.             if (hostcol->tab_colnum) {
  2525.                 if (data_is_null) {
  2526.                     bcpcol->data_size = 0;
  2527.                 }
  2528.                 else {
  2529.                     desttype = tds_get_conversion_type(bcpcol->db_type, bcpcol->db_length);
  2531.                     if ((converted_data_size = dbconvert(dbproc, hostcol->datatype, 
  2532.                                                          (BYTE *) coldata, collen,
  2533.                                                          desttype, bcpcol->data, 
  2534.                                                          bcpcol->db_length)) == FAIL) {
  2535.                         return (FAIL);
  2536.                     }
  2538.                     bcpcol->data_size = converted_data_size;
  2539.                 }
  2540.             }
  2541.         }
  2543.     }
  2544.     return SUCCEED;
  2545. }
  2547. /* for bcp in from program variables, where the program data */
  2548. /* has been identified as character terminated, get the data */
  2550. RETCODE _bcp_get_term_var(BYTE *dataptr, BYTE *term, int term_len, BYTE *coldata )
  2551. {
  2553. int bufpos = 0;
  2554. int found = 0;
  2555. BYTE *tptr;
  2558. for (tptr = dataptr; !found; tptr++) {
  2559. if (memcmp(tptr, term, term_len) != 0) {
  2560. *(coldata + bufpos) = *tptr;
  2561. bufpos++;
  2562.         }
  2563.         else
  2564. found = 1;
  2565. }
  2566. if (found) {
  2567. return (bufpos);
  2568.     }
  2569.     else {
  2570. return (-1);
  2571. }
  2573. }
  2575. static int _bcp_rtrim_varchar(char *istr, int ilen)
  2576. {
  2577. char *t;
  2578. int olen = ilen;
  2580. for (t = istr + (ilen - 1); *t == ' '; t--) {
  2581. *t = '';
  2582. olen--;
  2583. }
  2584. return olen;
  2585. }
  2587. RETCODE _bcp_clear_storage(DBPROCESS *dbproc)
  2588. {
  2590. int i;
  2592. if (dbproc->bcp_hostfile) {
  2593. free(dbproc->bcp_hostfile);
  2594. dbproc->bcp_hostfile = (char *) NULL;
  2595. }
  2597. if (dbproc->bcp_errorfile) {
  2598. free(dbproc->bcp_errorfile);
  2599. dbproc->bcp_errorfile = (char *) NULL;
  2600. }
  2602. if (dbproc->bcp_tablename) {
  2603. free(dbproc->bcp_tablename);
  2604. dbproc->bcp_tablename = (char *) NULL;
  2605. }
  2607. if (dbproc->bcp_insert_stmt) {
  2608. free(dbproc->bcp_insert_stmt);
  2609. dbproc->bcp_insert_stmt = (char *) NULL;
  2610. }
  2612. dbproc->bcp_direction = 0;
  2614. if (dbproc->bcp_columns) {
  2615. for (i = 0; i < dbproc->bcp_colcount; i++) {
  2616. if (dbproc->bcp_columns[i]->data) {
  2617. free(dbproc->bcp_columns[i]->data);
  2618. dbproc->bcp_columns[i]->data = NULL;
  2619. }
  2620. free(dbproc->bcp_columns[i]);
  2621. dbproc->bcp_columns[i] = NULL;
  2622. }
  2623. free(dbproc->bcp_columns);
  2624. dbproc->bcp_columns = NULL;
  2625. }
  2627. dbproc->bcp_colcount = 0;
  2628. #ifdef NCBI_FTDS
  2629.     dbproc->curr_text_col= 0;
  2630. #endif
  2632. /* free up storage that holds details of hostfile columns */
  2634. if (dbproc->host_columns) {
  2635. for (i = 0; i < dbproc->host_colcount; i++) {
  2636. if (dbproc->host_columns[i]->terminator) {
  2637. free(dbproc->host_columns[i]->terminator);
  2638. dbproc->host_columns[i]->terminator = NULL;
  2639. }
  2640. free(dbproc->host_columns[i]);
  2641. dbproc->host_columns[i] = NULL;
  2642. }
  2643. free(dbproc->host_columns);
  2644. dbproc->host_columns = NULL;
  2645. }
  2646. #ifdef NCBI_FTDS
  2647.    if(dbproc->bcp_hint) {
  2648.        free(dbproc->bcp_hint);
  2649.        dbproc->bcp_hint= NULL;
  2650.    }
  2651. #endif
  2652. dbproc->host_colcount = 0;
  2654. dbproc->var_cols = 0;
  2655. dbproc->sendrow_init = 0;
  2657. return (SUCCEED);
  2659. }
  2662. RETCODE _bcp_err_handler(DBPROCESS *dbproc, int bcp_errno)
  2663. {
  2664. const char *errmsg;
  2665. char *p;
  2666. int severity;
  2667. int erc;
  2669. switch (bcp_errno) {
  2671. case SYBETTS:
  2672. errmsg = "The table which bulk-copy is attempting to copy to a "
  2673. "host-file is shorter than the number of rows which bulk-copy " "was instructed to skip.";
  2674. severity = EXUSER;
  2675. break;
  2677. case SYBEBDIO:
  2678. errmsg = "Bad bulk-copy direction. Must be either IN or OUT.";
  2679. severity = EXPROGRAM;
  2680. break;
  2682. case SYBEBCVH:
  2683. errmsg = "bcp_exec() may be called only after bcp_init() has " "been passed a valid host file.";
  2684. severity = EXPROGRAM;
  2685. break;
  2687. case SYBEBIVI:
  2688. errmsg = "bcp_columns(), bcp_colfmt() and * bcp_colfmt_ps() may be used "
  2689. "only after bcp_init() has been passed a valid input file.";
  2690. severity = EXPROGRAM;
  2691. break;
  2693. case SYBEBCBC:
  2694. errmsg = "bcp_columns() must be called before bcp_colfmt().";
  2695. severity = EXPROGRAM;
  2696. break;
  2698. case SYBEBCFO:
  2699. errmsg = "Bcp host-files must contain at least one column.";
  2700. severity = EXUSER;
  2701. break;
  2703. case SYBEBCPB:
  2704. errmsg = "bcp_bind(), bcp_moretext() and bcp_sendrow() * may NOT be used "
  2705. "after bcp_init() has been passed a non-NULL input file name.";
  2706. severity = EXPROGRAM;
  2707. break;
  2709. case SYBEBCPN:
  2710. errmsg = "bcp_bind(), bcp_collen(), bcp_colptr(), bcp_moretext() and "
  2711. "bcp_sendrow() may be used only after bcp_init() has been called " "with the copy direction set to DB_IN.";
  2712. severity = EXPROGRAM;
  2713. break;
  2715. case SYBEBCPI:
  2716. errmsg = "bcp_init() must be called before any other bcp routines.";
  2717. severity = EXPROGRAM;
  2718. break;
  2720. case SYBEBCITBNM:
  2721. errmsg = "bcp_init(): tblname parameter cannot be NULL.";
  2722. severity = EXPROGRAM;
  2723. break;
  2725. case SYBEBCITBLEN:
  2726. errmsg = "bcp_init(): tblname parameter is too long.";
  2727. severity = EXPROGRAM;
  2728. break;
  2730. case SYBEBCBNPR:
  2731. errmsg = "bcp_bind(): if varaddr is NULL, prefixlen must be 0 and no " "terminator should be ** specified.";
  2732. severity = EXPROGRAM;
  2733. break;
  2735. case SYBEBCBPREF:
  2736. errmsg = "Illegal prefix length. Legal values are 0, 1, 2 or 4.";
  2737. severity = EXPROGRAM;
  2738. break;
  2740. case SYBEVDPT:
  2741. errmsg = "For bulk copy, all variable-length data * must have either " "a length-prefix or a terminator specified.";
  2742. severity = EXUSER;
  2743. break;
  2745. case SYBEBCPCTYP:
  2746. errmsg = "bcp_colfmt(): If table_colnum is 0, ** host_type cannot be 0.";
  2747. severity = EXPROGRAM;
  2748. break;
  2750. case SYBEBCHLEN:
  2751. errmsg = "host_collen should be greater than or equal to -1.";
  2752. severity = EXPROGRAM;
  2753. break;
  2755. case SYBEBCPREF:
  2756. errmsg = "Illegal prefix length. Legal values are -1, 0, 1, 2 or 4.";
  2757. severity = EXPROGRAM;
  2758. break;
  2760. case SYBEBCVLEN:
  2761. errmsg = "varlen should be greater than or equal to -1.";
  2762. severity = EXPROGRAM;
  2763. break;
  2765. case SYBEBCUO:
  2766. errmsg = "Unable to open host data-file.";
  2767. severity = EXRESOURCE;
  2768. break;
  2770. case SYBEBUOE:
  2771. erc = asprintf( &p, "Unable to open bcp error file "%s".", dbproc->bcp_errorfile );
  2772. if (p && erc != -1) {
  2773.           if(g_dblib_err_handler) {
  2774.               g_dblib_err_handler(dbproc, EXRESOURCE, bcp_errno, 0, errmsg, p);
  2775.           }
  2776.           free (p);
  2777.           return SUCCEED;
  2778. }
  2779. /* try to print silly message if unable to allocate memory */
  2780. errmsg = "Unable to open error file.";
  2781. severity = EXRESOURCE;
  2782. break;
  2784. case SYBEBUOF:
  2785. errmsg = "Unable to open format-file.";
  2786. severity = EXPROGRAM;
  2787. break;
  2789. case SYBEBUDF:
  2790. errmsg = "Unrecognized datatype found in format-file.";
  2791. severity = EXPROGRAM;
  2792. break;
  2794. case SYBEBIHC:
  2795. errmsg = "Incorrect host-column number found in bcp format-file.";
  2796. severity = EXPROGRAM;
  2797. break;
  2799. case SYBEBCUC:
  2800. errmsg = "Unable to close host data-file.";
  2801. severity = EXRESOURCE;
  2802. break;
  2804. case SYBEBUCE:
  2805. errmsg = "Unable to close error file.";
  2806. severity = EXPROGRAM;
  2807. break;
  2809. case SYBEBUCF:
  2810. errmsg = "Unable to close format-file.";
  2811. severity = EXPROGRAM;
  2812. break;
  2814. case SYBEIFNB:
  2815. errmsg = "Illegal field number passed to bcp_control().";
  2816. severity = EXPROGRAM;
  2817. break;
  2819. case SYBEBCRE:
  2820. errmsg = "I/O error while reading bcp data-file.";
  2821. severity = EXNONFATAL;
  2822. break;
  2824. case SYBEBCNN:
  2825. errmsg = "Attempt to bulk-copy a NULL value into Server column which " "does not accept NULL values.";
  2826. severity = EXUSER;
  2827. break;
  2829. case SYBEBBCI:
  2830. errmsg = "Batch successfully bulk-copied to SQL Server.";
  2831. severity = EXINFO;
  2832. break;
  2834. default:
  2835. errmsg = "Unknown bcp error";
  2836. severity = EXNONFATAL;
  2837. break;
  2838. }
  2840.     if(g_dblib_err_handler) {
  2841.         g_dblib_err_handler(dbproc, severity, bcp_errno, 0, errmsg, "");
  2842.         return (SUCCEED);
  2843.     }
  2844. }