BEGIN_NCBI_SCOPE
#define DBDATETIME4_days(x) ((x)->numdays)
#define DBDATETIME4_mins(x) ((x)->nummins)
#define DBNUMERIC_val(x) ((x)->val)
#define SQL_VARLEN_DATA (-10)
/////////////////////////////////////////////////////////////////////////////
//
// CODBC_BCPInCmd::
//
CODBC_BCPInCmd::CODBC_BCPInCmd(CODBC_Connection& conn,
SQLHDBC cmd,
const string& table_name) :
CStatementBase(conn, table_name),
m_Cmd(cmd),
m_HasTextImage(false),
m_WasBound(false)
{
string extra_msg = "Table Name: " + table_name;
SetDbgInfo( extra_msg );
if (bcp_init(cmd,
CODBCString(table_name, GetClientEncoding()).AsCWString(),
0, 0, DB_IN) != SUCCEED) {
ReportErrors();
string err_message = "bcp_init failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 423001 );
}
++m_RowCount;
}
int BCPInRecords(ifstream bcpInfile, char *szExtSystem)
{
int intImportCount = 0;
// Get current server datetime
DBDATETIME dtCurDateTime;
dtCurDateTime.dtdays = 0;
dbcmd(dbproc, "select getdate()");
dbsqlexec(dbproc);
if (dbresults(dbproc) == SUCCEED)
if (dbnextrow(dbproc) != NO_MORE_ROWS)
dbconvert(dbproc, SYBDATETIME, (dbdata(dbproc, 1)),
(DBINT)-1, SYBDATETIME, (BYTE*)&dtCurDateTime, (DBINT)-1);
if ( dtCurDateTime.dtdays == 0 )
return -1;
// Call bcp_init
if ( bcp_init(dbproc, "cags..x_import", NULL, "bcp_err.out", DB_IN) != SUCCEED )
{
errfile << ERROR_PREFIX << "failed bcp_init" << endl;
return -1;
}
bcp_bind(dbproc, (BYTE*)szExtSystem, 0, -1, (BYTE*)"", 1, SYBCHAR, 1);
bcp_bind(dbproc, (BYTE*)&dtCurDateTime, 0, -1, NULL, 0, SYBDATETIME, 2);
bcp_bind(dbproc, (BYTE*)&intImportCount, 0, -1, NULL, 0, SYBINT2, 3);
bcp_bind(dbproc, (BYTE*)buffer, 0, -1, (BYTE*)"", 1, SYBVARCHAR, 4);
while ( !bcpInfile.eof() )
{
bcpInfile.getline(buffer, 255);
// cout << buffer << endl;
intImportCount++;
// Bulk copy it into the database */
bcp_sendrow(dbproc);
}
// Close the bulk copy process so all the changes are committed
return bcp_done(dbproc);
}
BEGIN_NCBI_SCOPE
/////////////////////////////////////////////////////////////////////////////
//
// CDBL_BCPInCmd::
//
CDBL_BCPInCmd::CDBL_BCPInCmd(CDBL_Connection& conn,
DBPROCESS* cmd,
const string& table_name) :
CDBL_Cmd(conn, cmd),
impl::CBaseCmd(conn, table_name),
m_HasTextImage(false),
m_WasBound(false)
{
SetExecCntxInfo("BCP table name: " + table_name);
if (Check(bcp_init(cmd, (char*) table_name.c_str(), 0, 0, DB_IN)) != SUCCEED) {
DATABASE_DRIVER_ERROR( "bcp_init failed." + GetDbgInfo(), 223001 );
}
++m_RowCount;
}
static int
transfer_data(BCPPARAMDATA params, DBPROCESS * dbsrc, DBPROCESS * dbdest)
{
char ls_command[256];
int col;
DBINT src_numcols = 0;
DBINT src_datlen;
typedef struct migcoldata
{
DBINT coltype;
DBINT collen;
DBINT nullind;
DBCHAR *data;
} MIGCOLDATA;
MIGCOLDATA **srcdata;
DBINT rows_read = 0;
DBINT rows_sent = 0;
DBINT rows_done = 0;
DBINT ret;
struct timeval start_time;
struct timeval end_time;
double elapsed_time;
struct timeval batch_start;
struct timeval batch_end;
double elapsed_batch = 0.0;
if (params.vflag) {
printf("\nStarting copy...\n");
}
if (params.tflag) {
sprintf(ls_command, "truncate table %s", params.ddbobject);
if (dbcmd(dbdest, ls_command) == FAIL) {
printf("dbcmd failed\n");
return FALSE;
}
if (dbsqlexec(dbdest) == FAIL) {
printf("dbsqlexec failed\n");
return FALSE;
}
if (dbresults(dbdest) == FAIL) {
printf("Error in dbresults\n");
return FALSE;
}
}
sprintf(ls_command, "select * from %s", params.sdbobject);
if (dbcmd(dbsrc, ls_command) == FAIL) {
printf("dbcmd failed\n");
return FALSE;
}
if (dbsqlexec(dbsrc) == FAIL) {
printf("dbsqlexec failed\n");
return FALSE;
}
if (NO_MORE_RESULTS != dbresults(dbsrc));
{
if (0 == (src_numcols = dbnumcols(dbsrc))) {
printf("Error in dbnumcols\n");
return FALSE;
}
}
if (bcp_init(dbdest, params.ddbobject, (char *) NULL, (char *) NULL, DB_IN) == FAIL) {
printf("Error in bcp_init\n");
return FALSE;
}
srcdata = (MIGCOLDATA **) malloc(sizeof(MIGCOLDATA *) * src_numcols);
for (col = 0; col < src_numcols; col++) {
srcdata[col] = (MIGCOLDATA *) malloc(sizeof(MIGCOLDATA));
memset(srcdata[col], '\0', sizeof(MIGCOLDATA));
srcdata[col]->coltype = dbcoltype(dbsrc, col + 1);
srcdata[col]->collen = dbcollen(dbsrc, col + 1);
switch (srcdata[col]->coltype) {
case SYBBIT:
srcdata[col]->data = malloc(sizeof(DBBIT));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, BITBIND, sizeof(DBBIT), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBBIT, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBINT1:
srcdata[col]->data = malloc(sizeof(DBTINYINT));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, TINYBIND, sizeof(DBTINYINT), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBINT1, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBINT2:
srcdata[col]->data = malloc(sizeof(DBSMALLINT));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, SMALLBIND, sizeof(DBSMALLINT), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBINT2, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBINT4:
srcdata[col]->data = malloc(sizeof(DBINT));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, INTBIND, sizeof(DBINT), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBINT4, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBFLT8:
srcdata[col]->data = malloc(sizeof(DBFLT8));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, FLT8BIND, sizeof(DBFLT8), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBFLT8, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBREAL:
srcdata[col]->data = malloc(sizeof(DBREAL));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, REALBIND, sizeof(DBREAL), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBREAL, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBMONEY:
srcdata[col]->data = malloc(sizeof(DBMONEY));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, MONEYBIND, sizeof(DBMONEY), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBMONEY, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBMONEY4:
srcdata[col]->data = malloc(sizeof(DBMONEY4));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, SMALLMONEYBIND, sizeof(DBMONEY4), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBMONEY4, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBDATETIME:
srcdata[col]->data = malloc(sizeof(DBDATETIME));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, DATETIMEBIND, sizeof(DBDATETIME), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBDATETIME, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBDATETIME4:
srcdata[col]->data = malloc(sizeof(DBDATETIME4));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, SMALLDATETIMEBIND, sizeof(DBDATETIME), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBDATETIME4, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBNUMERIC:
srcdata[col]->data = malloc(sizeof(DBNUMERIC));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, NUMERICBIND, sizeof(DBNUMERIC), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, sizeof(DBNUMERIC), NULL, 0, SYBNUMERIC, col + 1) ==
FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBDECIMAL:
srcdata[col]->data = malloc(sizeof(DBDECIMAL));
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, DECIMALBIND, sizeof(DBDECIMAL), (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, sizeof(DBDECIMAL), NULL, 0, SYBDECIMAL, col + 1) ==
FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
case SYBTEXT:
case SYBCHAR:
srcdata[col]->data = malloc(srcdata[col]->collen + 1);
if (srcdata[col]->data == (char *) NULL) {
printf("allocation error\n");
return FALSE;
}
dbbind(dbsrc, col + 1, NTBSTRINGBIND, srcdata[col]->collen + 1, (BYTE *) srcdata[col]->data);
dbnullbind(dbsrc, col + 1, &(srcdata[col]->nullind));
if (bcp_bind(dbdest, (BYTE *) srcdata[col]->data, 0, -1, NULL, 0, SYBCHAR, col + 1) == FAIL) {
printf("bcp_bind error\n");
return FALSE;
}
break;
}
}
gettimeofday(&start_time, 0);
while (dbnextrow(dbsrc) != NO_MORE_ROWS) {
rows_read++;
for (col = 0; col < src_numcols; col++) {
switch (srcdata[col]->coltype) {
case SYBBIT:
case SYBINT1:
case SYBINT2:
case SYBINT4:
case SYBFLT8:
case SYBREAL:
case SYBDATETIME:
case SYBDATETIME4:
case SYBMONEY:
case SYBMONEY4:
if (srcdata[col]->nullind == -1) { /* NULL data retrieved from source */
bcp_collen(dbdest, 0, col + 1);
} else {
bcp_collen(dbdest, -1, col + 1);
}
break;
case SYBNUMERIC:
if (srcdata[col]->nullind == -1) { /* NULL data retrieved from source */
bcp_collen(dbdest, 0, col + 1);
} else {
bcp_collen(dbdest, sizeof(DBNUMERIC), col + 1);
}
break;
case SYBDECIMAL:
if (srcdata[col]->nullind == -1) { /* NULL data retrieved from source */
bcp_collen(dbdest, 0, col + 1);
} else {
bcp_collen(dbdest, sizeof(DBDECIMAL), col + 1);
}
break;
case SYBTEXT:
case SYBCHAR:
if (srcdata[col]->nullind == -1) { /* NULL data retrieved from source */
bcp_collen(dbdest, 0, col + 1);
} else {
/*
* if there is zero length data, then the
* input data MUST have been all blanks,
* trimmed down to nothing by the bind
* type of NTBSTRINGBIND.
* so find out the source data length and
* re-set the data accordingly...
*/
if (strlen(srcdata[col]->data) == 0) {
src_datlen = dbdatlen(dbsrc, col + 1);
memset(srcdata[col]->data, ' ', src_datlen);
srcdata[col]->data[src_datlen] = '\0';
}
bcp_collen(dbdest, strlen(srcdata[col]->data), col + 1);
}
break;
}
}
if (bcp_sendrow(dbdest) == FAIL) {
fprintf(stderr, "bcp_sendrow failed. \n");
return FALSE;
} else {
rows_sent++;
if (rows_sent == params.batchsize) {
gettimeofday(&batch_start, 0);
ret = bcp_batch(dbdest);
gettimeofday(&batch_end, 0);
elapsed_batch = elapsed_batch +
((double) (batch_end.tv_sec - batch_start.tv_sec) +
((double) (batch_end.tv_usec - batch_start.tv_usec) / 1000000.00)
);
if (ret == -1) {
printf("bcp_batch error\n");
return FALSE;
} else {
rows_done += ret;
printf("%d rows successfully copied (total %d)\n", ret, rows_done);
rows_sent = 0;
}
}
}
}
if (rows_read) {
gettimeofday(&batch_start, 0);
ret = bcp_done(dbdest);
gettimeofday(&batch_end, 0);
elapsed_batch = elapsed_batch +
((double) (batch_end.tv_sec - batch_start.tv_sec) +
((double) (batch_end.tv_usec - batch_start.tv_usec) / 1000000.00)
);
if (ret == -1) {
fprintf(stderr, "bcp_done failed. \n");
return FALSE;
} else {
rows_done += ret;
}
}
gettimeofday(&end_time, 0);
elapsed_time = (double) (end_time.tv_sec - start_time.tv_sec) +
((double) (end_time.tv_usec - start_time.tv_usec) / 1000000.00);
if (params.vflag) {
printf("\n");
printf("rows read : %d\n", rows_read);
printf("rows written : %d\n", rows_done);
printf("elapsed time (secs) : %f\n", elapsed_time);
printf("rows per second : %f\n", rows_done / elapsed_time);
}
return TRUE;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
int i, rows_sent=0;
int failed = 0;
const char *s;
const char *table_name = "all_types_bcp_unittest";
set_malloc_options();
read_login_info(argc, argv);
fprintf(stdout, "Starting %s\n", argv[0]);
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "bcp.c unit test");
BCP_SETL(login, 1);
fprintf(stdout, "About to open %s.%s\n", SERVER, DATABASE);
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
dbloginfree(login);
if (init(dbproc, table_name))
exit(1);
/* set up and send the bcp */
sprintf(cmd, "%s..%s", DATABASE, table_name);
fprintf(stdout, "preparing to insert into %s ... ", cmd);
if (bcp_init(dbproc, cmd, NULL, NULL, DB_IN) == FAIL) {
fprintf(stdout, "failed\n");
exit(1);
}
fprintf(stdout, "OK\n");
test_bind(dbproc);
fprintf(stdout, "Sending same row 10 times... \n");
for (i=0; i<10; i++) {
if (bcp_sendrow(dbproc) == FAIL) {
fprintf(stdout, "send failed\n");
exit(1);
}
}
fprintf(stdout, "Sending 5 more rows ... \n");
for (i=15; i <= 27; i++) {
int type = dbcoltype(dbproc, i);
int len = (type == SYBCHAR || type == SYBVARCHAR)? dbcollen(dbproc, i) : -1;
if (bcp_collen(dbproc, len, i) == FAIL) {
fprintf(stdout, "bcp_collen failed for column %d\n", i);
exit(1);
}
}
for (i=0; i<5; i++) {
if (bcp_sendrow(dbproc) == FAIL) {
fprintf(stdout, "send failed\n");
exit(1);
}
}
#if 1
rows_sent = bcp_batch(dbproc);
if (rows_sent == -1) {
fprintf(stdout, "batch failed\n");
exit(1);
}
#endif
fprintf(stdout, "OK\n");
/* end bcp. */
if ((rows_sent += bcp_done(dbproc)) == -1)
printf("Bulk copy unsuccessful.\n");
else
printf("%d rows copied.\n", rows_sent);
printf("done\n");
#if 1
sql_cmd(dbproc);
dbsqlexec(dbproc);
while ((i=dbresults(dbproc)) == SUCCEED) {
dbprhead(dbproc);
dbprrow(dbproc);
while ((i=dbnextrow(dbproc)) == REG_ROW) {
dbprrow(dbproc);
}
}
#endif
if ((s = getenv("BCP")) != NULL && 0 == strcmp(s, "nodrop")) {
fprintf(stdout, "BCP=nodrop: '%s..%s' kept\n", DATABASE, table_name);
} else {
fprintf(stdout, "Dropping table %s\n", table_name);
sql_cmd(dbproc);
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
}
dbexit();
failed = 0;
fprintf(stdout, "%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
int
main(int argc, char *argv[])
{
LOGINREC *login;
DBPROCESS *dbproc;
int i;
RETCODE ret;
int big_endian = 1;
char *out_file = "t0017.out";
static const char in_file_le[] = FREETDS_SRCDIR "/t0017.in";
static const char in_file_be[] = FREETDS_SRCDIR "/t0017.in.be";
const char *in_file = in_file_le;
const char *err_file = "t0017.err";
DBINT rows_copied;
int num_cols = 0;
int col_type[256];
DBBOOL col_varylen[256];
int prefix_len;
if (((char *) &big_endian)[0] == 1)
big_endian = 0;
if (big_endian)
in_file = in_file_be;
setbuf(stdout, NULL);
setbuf(stderr, NULL);
set_malloc_options();
read_login_info(argc, argv);
printf("Starting %s\n", software_version);
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("About to logon ... ");
login = dblogin();
assert(login);
BCP_SETL(login, TRUE);
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0017");
printf("done\n");
printf("Opening \"%s\" for \"%s\" ... ", SERVER, USER);
dbproc = dbopen(login, SERVER);
assert(dbproc);
if (strlen(DATABASE)) {
dbuse(dbproc, DATABASE);
}
dbloginfree(login);
printf("done\n");
printf("Creating table ... ");
dbcmd(dbproc, "create table #dblib0017 (c1 int null, c2 text)");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
printf("done\n");
dbcmd(dbproc, "insert into #dblib0017(c1,c2) values(1144201745,'prova di testo questo testo dovrebbe andare a finire in un campo text')");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
/* BCP out */
printf("bcp_init... ");
ret = bcp_init(dbproc, "#dblib0017", out_file, err_file, DB_OUT);
if (ret != SUCCEED)
failed = 1;
printf("done\n");
printf("Issuing SELECT ... ");
dbcmd(dbproc, "select * from #dblib0017 where 0=1");
dbsqlexec(dbproc);
printf("done\nFetching metadata ... ");
if (dbresults(dbproc) != FAIL) {
num_cols = dbnumcols(dbproc);
for (i = 0; i < num_cols; ++i) {
col_type[i] = dbcoltype(dbproc, i + 1);
col_varylen[i] = dbvarylen(dbproc, i + 1);
}
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
}
}
printf("done\n");
printf("bcp_columns ... ");
ret = bcp_columns(dbproc, num_cols);
if (ret != SUCCEED)
failed = 1;
for (i = 0; i < num_cols; i++) {
prefix_len = 0;
if (col_type[i] == SYBIMAGE || col_type[i] == SYBTEXT) {
prefix_len = 4;
} else if (col_varylen[i]) {
prefix_len = 1;
}
printf("bind %d prefix %d col_type %s\n", i, prefix_len, col_type[i] == SYBIMAGE ? "image" : "other");
ret = bcp_colfmt(dbproc, i + 1, col_type[i], prefix_len, -1, NULL, 0, i + 1);
if (ret == FAIL) {
fprintf(stderr, "return from bcp_colfmt = %d\n", ret);
failed = 1;
}
}
printf("done\n");
rows_copied = -1;
printf("bcp_exec ... ");
ret = bcp_exec(dbproc, &rows_copied);
if (ret != SUCCEED || rows_copied != 1)
failed = 1;
printf("%d rows copied\n", rows_copied);
/* delete rows */
dbcmd(dbproc, "delete from #dblib0017");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
/*
* BCP in
*/
printf("bcp_init... ");
ret = bcp_init(dbproc, "#dblib0017", in_file, err_file, DB_IN);
if (ret != SUCCEED)
failed = 1;
printf("done\n");
printf("Issuing SELECT ... ");
dbcmd(dbproc, "select * from #dblib0017 where 0=1");
dbsqlexec(dbproc);
printf("done\nFetching metadata ... ");
if (dbresults(dbproc) != FAIL) {
num_cols = dbnumcols(dbproc);
for (i = 0; i < num_cols; i++) {
col_type[i] = dbcoltype(dbproc, i + 1);
col_varylen[i] = dbvarylen(dbproc, i + 1);
}
while (dbnextrow(dbproc) != NO_MORE_ROWS) {
}
}
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
printf("done\n");
printf("bcp_columns ... ");
ret = bcp_columns(dbproc, num_cols);
if (ret != SUCCEED)
failed = 1;
for (i = 0; i < num_cols; i++) {
prefix_len = 0;
if (col_type[i] == SYBIMAGE || col_type[i] == SYBTEXT) {
prefix_len = 4;
} else if (col_varylen[i]) {
prefix_len = 1;
}
ret = bcp_colfmt(dbproc, i + 1, col_type[i], prefix_len, -1, NULL, 0, i + 1);
if (ret == FAIL) {
fprintf(stderr, "return from bcp_colfmt = %d\n", ret);
failed = 1;
}
}
printf("done\n");
printf("bcp_exec ... ");
rows_copied = -1;
ret = bcp_exec(dbproc, &rows_copied);
if (ret != SUCCEED || rows_copied != 1)
failed = 1;
printf("done\n");
/* test we inserted correctly row */
if (!failed) {
dbcmd(dbproc, "SET NOCOUNT ON DECLARE @n INT SELECT @n = COUNT(*) FROM #dblib0017 WHERE c1=1144201745 AND c2 LIKE 'prova di testo questo testo dovrebbe andare a finire in un campo text' IF @n <> 1 SELECT 0");
dbsqlexec(dbproc);
while (dbresults(dbproc) != NO_MORE_RESULTS) {
while ((ret=dbnextrow(dbproc)) != NO_MORE_ROWS) {
fprintf(stderr, "Invalid dbnextrow result %d executing query\n", ret);
failed = 1;
}
}
}
printf("%d rows copied\n", rows_copied);
dbclose(dbproc);
dbexit();
printf("dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
return failed ? 1 : 0;
}
int
main(int argc, char **argv)
{
LOGINREC *login;
DBPROCESS *dbproc;
int i, rows_sent=0;
int failed = 0;
const char *table_name = "all_types_bcp_unittest";
set_malloc_options();
read_login_info();
fprintf(stdout, "Start\n");
add_bread_crumb();
dbinit();
add_bread_crumb();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
fprintf(stdout, "About to logon\n");
add_bread_crumb();
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "bcp.c unit test");
BCP_SETL(login, 1);
fprintf(stdout, "About to open %s.%s\n", SERVER, DATABASE);
add_bread_crumb();
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
add_bread_crumb();
add_bread_crumb();
if (init(dbproc, table_name))
exit(1);
/* set up and send the bcp */
sprintf(cmd, "%s..%s", DATABASE, table_name);
fprintf(stdout, "preparing to insert into %s ... ", cmd);
if (bcp_init(dbproc, cmd, (BYTE *)NULL, (BYTE *)NULL, DB_IN) == FAIL) {
fprintf(stdout, "failed\n");
exit(1);
}
fprintf(stdout, "OK\n");
bind(dbproc);
fprintf(stdout, "Sending same row 10 times... \n");
for (i=0; i<10; i++) {
if (bcp_sendrow(dbproc) == FAIL) {
fprintf(stdout, "send failed\n");
exit(1);
}
}
#if 1
rows_sent = bcp_batch(dbproc);
if (rows_sent == -1) {
fprintf(stdout, "batch failed\n");
exit(1);
}
#endif
fprintf(stdout, "OK\n");
/* end bcp. */
if ((rows_sent += bcp_done(dbproc)) == -1)
printf("Bulk copy unsuccessful.\n");
else
printf("%d rows copied.\n", rows_sent);
printf("done\n");
add_bread_crumb();
fprintf(stdout, "Dropping table %s\n", table_name);
add_bread_crumb();
sprintf(cmd, "drop table %s", table_name);
dbcmd(dbproc, cmd);
add_bread_crumb();
dbsqlexec(dbproc);
add_bread_crumb();
while (dbresults(dbproc) != NO_MORE_RESULTS) {
/* nop */
}
add_bread_crumb();
failed = 0;
fprintf(stdout, "dblib %s on %s\n", (failed ? "failed!" : "okay"), __FILE__);
return failed ? 1 : 0;
}
