bcp.c

ncbi源码

	if (bcp_columns(dbproc, li_numcols) == FAIL) {
		return (FAIL);
	}

	for (curptr = topptr; curptr->nextptr != (struct fflist *) NULL; curptr = curptr->nextptr) {
		hostcol = &(curptr->colinfo);
		if (bcp_colfmt(dbproc, hostcol->host_column, hostcol->datatype,
			       hostcol->prefix_len, hostcol->column_len,
                       hostcol->terminator,  hostcol->term_len ,
                       hostcol->tab_colnum ) == FAIL) {
			return (FAIL);
		}
	}
	hostcol = &(curptr->colinfo);
	if (bcp_colfmt(dbproc, hostcol->host_column, hostcol->datatype,
		       hostcol->prefix_len, hostcol->column_len,
                   hostcol->terminator,  hostcol->term_len ,
                   hostcol->tab_colnum ) == FAIL) {
		return (FAIL);
	}

	return (SUCCEED);

}

int _bcp_readfmt_colinfo(DBPROCESS *dbproc, char *buf, BCP_HOSTCOLINFO *ci)
{

	char *tok;
	int whichcol;
	char term[30];
	int i;

    enum nextcol {
		HOST_COLUMN,
		DATATYPE,
		PREFIX_LEN,
		COLUMN_LEN,
		TERMINATOR,
		TAB_COLNUM,
		NO_MORE_COLS
	};

	tok = strtok(buf, " \t");
	whichcol = HOST_COLUMN;

	while (tok != (char *) NULL && whichcol != NO_MORE_COLS) {
		switch (whichcol) {

		case HOST_COLUMN:
			ci->host_column = atoi(tok);

			if (ci->host_column < 1) {
                _bcp_err_handler(dbproc, BCPEBIHC);
				return (FALSE);
			}

			whichcol = DATATYPE;
			break;

		case DATATYPE:
			if (strcmp(tok, "SYBCHAR") == 0)
				ci->datatype = SYBCHAR;
			else if (strcmp(tok, "SYBTEXT") == 0)
				ci->datatype = SYBTEXT;
			else if (strcmp(tok, "SYBBINARY") == 0)
				ci->datatype = SYBBINARY;
			else if (strcmp(tok, "SYBIMAGE") == 0)
				ci->datatype = SYBIMAGE;
			else if (strcmp(tok, "SYBINT1") == 0)
				ci->datatype = SYBINT1;
			else if (strcmp(tok, "SYBINT2") == 0)
				ci->datatype = SYBINT2;
			else if (strcmp(tok, "SYBINT4") == 0)
				ci->datatype = SYBINT4;
			else if (strcmp(tok, "SYBFLT8") == 0)
				ci->datatype = SYBFLT8;
			else if (strcmp(tok, "SYBREAL") == 0)
				ci->datatype = SYBREAL;
			else if (strcmp(tok, "SYBBIT") == 0)
				ci->datatype = SYBBIT;
			else if (strcmp(tok, "SYBNUMERIC") == 0)
				ci->datatype = SYBNUMERIC;
			else if (strcmp(tok, "SYBDECIMAL") == 0)
				ci->datatype = SYBDECIMAL;
			else if (strcmp(tok, "SYBMONEY") == 0)
				ci->datatype = SYBMONEY;
			else if (strcmp(tok, "SYBDATETIME") == 0)
				ci->datatype = SYBDATETIME;
			else if (strcmp(tok, "SYBDATETIME4") == 0)
				ci->datatype = SYBDATETIME4;
			else {
                _bcp_err_handler(dbproc, BCPEBUDF);
				return (FALSE);
			}

			whichcol = PREFIX_LEN;
			break;

		case PREFIX_LEN:
			ci->prefix_len = atoi(tok);
			whichcol = COLUMN_LEN;
			break;
		case COLUMN_LEN:
			ci->column_len = atoi(tok);
			whichcol = TERMINATOR;
			break;
		case TERMINATOR:

			if (*tok++ != '\"')
				return (FALSE);

			for (i = 0; *tok != '\"' && i < 30; i++) {
				if (*tok == '\\') {
					tok++;
					switch (*tok) {
                    case 't':  term[i] = '\t'; break;
                    case 'n':  term[i] = '\n'; break;
                    case 'r':  term[i] = '\r'; break;
                    case '\\': term[i] = '\\'; break;
                    case '0':  term[i] = '\0'; break;
                    default:   return(FALSE);
					}
					tok++;
                }
                else
					term[i] = *tok++;
			}

			if (*tok != '\"')
				return (FALSE);

			term[i] = '\0';
			ci->terminator = (BYTE*) malloc(i + 1);
			strcpy((char*) ci->terminator, term);
			ci->term_len = strlen(term);

			whichcol = TAB_COLNUM;
			break;

		case TAB_COLNUM:
			ci->tab_colnum = atoi(tok);
			whichcol = NO_MORE_COLS;
			break;

		}
		tok = strtok((char *) NULL, " \t");
	}
	if (whichcol == NO_MORE_COLS)
		return (TRUE);
	else
		return (FALSE);
}

RETCODE bcp_writefmt(DBPROCESS *dbproc, char *filename)
{
	if (dbproc->bcp_direction == 0) {
        _bcp_err_handler(dbproc, BCPEBCPI);
		return FAIL;
	}
	return SUCCEED;
}

RETCODE bcp_moretext(DBPROCESS *dbproc, DBINT size, BYTE *text)
{
#ifdef NCBI_FTDS
    static unsigned char txtptr_and_timestamp[24]= {
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    };

    int i;
    DBINT s;
    BCP_COLINFO *bcpcol;
    TDSSOCKET *tds = dbproc->tds_socket;

    if (dbproc == NULL || text== NULL || tds == NULL) {
        return FAIL;
    }

    if ( dbproc->text_sent == 0 ) {
        for (i=dbproc->curr_text_col; i < dbproc->bcp_colcount; i++) {
            if(dbproc->host_columns[i]->datatype == 0) continue;

            bcpcol = dbproc->bcp_columns[i];
            if (bcpcol == NULL) {
                return FAIL;
            }
            if (is_blob_type (bcpcol->db_type) ) { 
                dbproc->curr_text_col = i;
                tds_put_byte (tds,0x10);
                tds_put_n(tds, txtptr_and_timestamp, 24);
                tds_put_int (tds,  bcpcol->data_size);
                break;
            }
        }
        if(i >= dbproc->bcp_colcount) return FAIL;
    }
    if(dbproc->bcp_columns[dbproc->curr_text_col]->data_size == 0 &&
       size == 0) { /* this is a NULL */
        dbproc->curr_text_col++;
        dbproc->text_sent = 0;
        return SUCCEED;
    }
    s= dbproc->bcp_columns[dbproc->curr_text_col]->data_size - dbproc->text_sent;
    if(s <= 0) return FAIL;
    if(size > s) size= s;
    tds_put_n (tds, text, size);
    dbproc->text_sent += size;
    if (dbproc->text_sent >= dbproc->bcp_columns[dbproc->curr_text_col]->data_size) {
        dbproc->text_sent = 0;
        dbproc->curr_text_col++;
    }
#else
	if (dbproc->bcp_direction == 0) {
        _bcp_err_handler(dbproc, BCPEBCPI);
		return FAIL;
	}
#endif
	return SUCCEED;
}

RETCODE bcp_batch(DBPROCESS *dbproc)
{
TDSSOCKET *tds = dbproc->tds_socket;
int marker;
int rows_copied;

	if (dbproc->bcp_direction == 0) {
        _bcp_err_handler(dbproc, BCPEBCPI);
        return FAIL;
	}

	tds_flush_packet(tds);

	do {

		marker = tds_get_byte(tds);
        if ( marker == TDS_DONE_TOKEN ) 
            rows_copied = tds_process_end(tds,marker,NULL,NULL);
        else 
			tds_process_default_tokens(tds, marker);

	} while (marker != TDS_DONE_TOKEN);


	_bcp_start_new_batch(dbproc);


    return rows_copied;
}

/* end the transfer of data from program variables */

RETCODE bcp_done(DBPROCESS *dbproc)
{

TDSSOCKET *tds = dbproc->tds_socket;
int marker;
int rows_copied = -1;

	if (dbproc->bcp_direction == 0) {
        _bcp_err_handler(dbproc, BCPEBCPI);
        return FAIL;
	}
	tds_flush_packet(tds);

	do {

		marker = tds_get_byte(tds);
        if ( marker == TDS_DONE_TOKEN ) 
            rows_copied = tds_process_end(tds,marker,NULL,NULL);
        else 
			tds_process_default_tokens(tds, marker);

	} while (marker != TDS_DONE_TOKEN);

	_bcp_clear_storage(dbproc);

	return (rows_copied);

}

/* bind a program host variable to a database column */

RETCODE bcp_bind(DBPROCESS *dbproc, BYTE *varaddr, int prefixlen, DBINT varlen,
	 BYTE * terminator, int termlen, int type, int table_column)
{

BCP_HOSTCOLINFO *hostcol;

	if (dbproc->bcp_direction == 0) {
        _bcp_err_handler(dbproc, BCPEBCPI);
		return FAIL;
	}

	if (dbproc->bcp_hostfile != (char *) NULL) {
        _bcp_err_handler(dbproc, BCPEBCPB);
		return FAIL;
	}

	if (dbproc->bcp_direction != DB_IN) {
        _bcp_err_handler(dbproc, BCPEBCPN);
		return FAIL;
	}

	if (varlen < -1) {
        _bcp_err_handler(dbproc, BCPEBCVLEN);
		return FAIL;
	}

    if (prefixlen != 0 && prefixlen != 1 &&
        prefixlen != 2 && prefixlen != 4 ) {
        _bcp_err_handler(dbproc, BCPEBCBPREF);
		return FAIL;
	}

    if (prefixlen == 0 && varlen == -1 && 
        termlen == -1 && !is_fixed_type(type)) {
		return FAIL;
	}

    if (is_fixed_type(type) && 
        (varlen != -1 && varlen != 0)) {
		return FAIL;
	}

	if (table_column > dbproc->host_colcount) {
		return FAIL;
	}

#ifndef NCBI_FTDS
    if (varaddr == (BYTE *)NULL && 
        (prefixlen != 0 || termlen != 0)) {
        _bcp_err_handler(dbproc, BCPEBCBNPR);
		return FAIL;
	}
#endif

	hostcol = dbproc->host_columns[table_column - 1];

	hostcol->host_var = varaddr;
	hostcol->datatype = type;
	hostcol->prefix_len = prefixlen;
	hostcol->column_len = varlen;
    if(termlen > 0) {
	hostcol->terminator = (BYTE *) malloc(termlen + 1);
	memcpy(hostcol->terminator, terminator, termlen);
    }
    else hostcol->terminator= NULL;
	hostcol->term_len = termlen;
	hostcol->tab_colnum = table_column;

	return SUCCEED;
}

/* for a bcp in from program variables, collate all the data */
/* into the column arrays held in dbproc...                  */

RETCODE _bcp_get_prog_data(DBPROCESS *dbproc)
{
    BCP_COLINFO *bcpcol;
    BCP_HOSTCOLINFO *hostcol;

    int i;
    TDS_TINYINT ti;
    TDS_SMALLINT si;
    TDS_INT li;
    TDS_INT desttype;
    int collen;
    int data_is_null;
    int bytes_read;
    int converted_data_size;

    BYTE *dataptr;

    /* for each host file column defined by calls to bcp_colfmt */

    for (i = 0; i < dbproc->host_colcount; i++) {
        BYTE coldata[4096];

        hostcol = dbproc->host_columns[i];
#ifdef NCBI_FTDS
        if(hostcol->datatype == 0) continue;
#endif
        dataptr = hostcol->host_var;

        data_is_null = 0;
        collen = 0;

        /* if a prefix length specified, read the correct */
        /* amount of data...                              */

        if (hostcol->prefix_len > 0) {

            switch (hostcol->prefix_len) {
            case 1:
                memcpy(&ti, dataptr, 1);
                dataptr += 1;
                collen = ti;
                break;
            case 2:
                memcpy(&si, dataptr, 2);
                dataptr += 2;
                collen = si;
                break;
            case 4:
                memcpy(&li, dataptr, 4);
                dataptr += 4;
                collen = li;
                break;
            }
            if (collen == 0)
                data_is_null = 1;

        }

        /* if (Max) column length specified take that into */
        /* consideration...                                */

        if (!data_is_null && hostcol->column_len >= 0) {
            if (hostcol->column_len == 0)
                data_is_null = 1;
            else {
                if (collen)
                    collen = (hostcol->column_len < collen) ? hostcol->column_len : collen;
                else
                    collen = hostcol->column_len;
            }
        }

        /* Fixed Length data - this over-rides anything else specified */

        if (is_fixed_type(hostcol->datatype)) {
            collen = get_size_by_type(hostcol->datatype);
        }
#ifdef NCBI_FTDS
        else if(is_numeric_type(hostcol->datatype)) {
            collen= sizeof(DBNUMERIC);
        }
#endif


        /* if this host file column contains table data,   */
        /* find the right element in the table/column list */

        if (hostcol->tab_colnum) {
            bcpcol = dbproc->bcp_columns[hostcol->tab_colnum - 1];
            if (bcpcol->tab_colnum != hostcol->tab_colnum) {
                return FAIL;
            }
        }
#ifdef NCBI_FTDS
        if(dataptr == NULL) {
            bcpcol->data_size= collen;
            continue;
        }
#endif


        /* a terminated field is specified - get the data into temporary space... */

        memset(coldata, '\0', sizeof(coldata));

        if (hostcol->term_len > 0) {
            bytes_read = _bcp_get_term_var(dataptr, hostcol->terminator, hostcol->term_len, coldata);

            if (bytes_read == -1)
                return FAIL;


            if (collen)
                collen = (bytes_read < collen) ? bytes_read : collen;
            else
                collen = bytes_read;

            if (collen == 0)
                data_is_null = 1;

            if (hostcol->tab_colnum) {
                if (data_is_null) {
                    bcpcol->data_size = 0;
                }
                else {
                    desttype = tds_get_conversion_type(bcpcol->db_type, bcpcol->db_length);

                    if ((converted_data_size = dbconvert(dbproc, hostcol->datatype, 
                                                         (BYTE *) coldata, collen,
                                                         desttype, bcpcol->data, 
                                                         bcpcol->db_length)) == FAIL) {
                        return (FAIL);
                    }

                    bcpcol->data_size = converted_data_size;
                }
            }
        }
        else {
            if (collen) {
                memcpy(coldata, dataptr, collen);
            }