token.c

ncbi源码

			tds->msg_info->server,
			tds->msg_info->line_number,
			tds->msg_info->message);
		tds_free_msg(tds->msg_info);
	}
	return rc;
}

char *tds_msg_get_proc_name(TDSSOCKET *tds)
{
int len_proc;
char *proc_name;

	len_proc = tds_get_byte(tds);

	if (len_proc < 0) {
		len_proc = 0;
	}
        proc_name = (char*)malloc(len_proc+1);
	if (len_proc > 0) {
              tds_get_string(tds, proc_name, len_proc);
	}
        proc_name[len_proc] = '\0';

	return proc_name;

}

int tds_reset_msg_info(TDSMSGINFO *msg_info)
{
	if (!msg_info) 
		return 0;

	msg_info->priv_msg_type = 0;
	msg_info->msg_number = 0;
	msg_info->msg_state = 0;
	msg_info->msg_level = 0;
	msg_info->line_number = 0;

	if( msg_info->message)
		TDS_ZERO_FREE(msg_info->message);
	if(msg_info->server)
		TDS_ZERO_FREE(msg_info->server);
	if(msg_info->proc_name)
		TDS_ZERO_FREE(msg_info->proc_name);

	return 0;
}

/*
** tds_process_cancel() processes the incoming token stream until it finds
** an end token (DONE, DONEPROC, DONEINPROC) with the cancel flag set.
** a that point the connetion should be ready to handle a new query.
*/
int tds_process_cancel(TDSSOCKET *tds)
{
int marker, cancelled=0;

	do {
		marker=tds_get_byte(tds);
		if (marker==TDS_DONE_TOKEN) {
			tds_process_end(tds, marker, NULL, &cancelled);
		} else if (marker==0) {
			cancelled = 1;
		} else {
			tds_process_default_tokens(tds,marker);
		}
	} while (!cancelled);
	tds->state = TDS_COMPLETED;

	return 0;
}
/* =========================== tds_is_result_row() ===========================
 * 
 * Def:  does the next token in stream signify a result row?
 * 
 * Ret:  true if stream is positioned at a row, false otherwise
 * 
 * ===========================================================================
 */
int tds_is_result_row(TDSSOCKET *tds)
{
   const int  marker = tds_peek(tds);
   int        result = 0;

   if (marker==TDS_ROW_TOKEN)
   {
      result = 1;
   }
   return result;
} /* tds_is_result_row()  */


int tds_is_result_set(TDSSOCKET *tds)
{
   const int  marker = tds_peek(tds);
   int        result = 0;

   result = (marker==TDS_COL_NAME_TOKEN 
             || marker==TDS_COL_INFO_TOKEN 
             || marker==TDS_RESULT_TOKEN
             || marker==TDS7_RESULT_TOKEN);
   return result;
} /* tds_is_result_set()  */


int tds_is_end_of_results(TDSSOCKET *tds)
{
   const int  marker = tds_peek(tds);
   int        result = 0;

   result = marker==TDS_DONE_TOKEN || marker==TDS_DONEPROC_TOKEN;
   return result;
} /* tds_is_end_of_results()  */


int tds_is_doneinproc(TDSSOCKET *tds)
{
   const int  marker = tds_peek(tds);
   int        result = 0;

   result = marker==TDS_DONEINPROC_TOKEN;
   return result;
} /* tds_is_end_of_results()  */


int tds_is_error(TDSSOCKET *tds)
{
   const int  marker = tds_peek(tds);
   int        result = 0;

   result = marker==TDS_ERR_TOKEN;
   return result;
} /* tds_is_error()  */

int tds_is_message(TDSSOCKET *tds)
{
   const int  marker = tds_peek(tds);
   int        result = 0;

   result = marker==TDS_MSG_TOKEN;
   return result;
} /* tds_is_message()  */
int tds_is_control(TDSSOCKET *tds)
{
   const int  marker = tds_peek(tds);
   int        result = 0;

   result = (marker==TDS_174_TOKEN || marker==TDS_167_TOKEN);
   return result;
}
/*
** set the null bit for the given column in the row buffer
*/
#ifdef NCBI_FTDS
static unsigned char s_null_mask[8]= {0x1,0x2,0x4,0x8,0x10,0x20,0x40,0x80};
void tds_set_null(unsigned char *current_row, int column)
{
    current_row[column >> 3]|= s_null_mask[column & 0x7];
}

/*
** clear the null bit for the given column in the row buffer
*/
void tds_clr_null(unsigned char *current_row, int column)
{
    current_row[column >> 3]&= ~s_null_mask[column & 0x7];
}

/*
** return the null bit for the given column in the row buffer
*/
int tds_get_null(unsigned char *current_row, int column)
{
 return (current_row[column >> 3] & s_null_mask[column & 0x7])? 1 : 0;
}
#else
void tds_set_null(unsigned char *current_row, int column)
{
int bytenum = column >> 3;
int bit = column & 0x7;
unsigned char mask = 1 << bit;

	tdsdump_log(TDS_DBG_INFO1,"%L setting column %d NULL bit\n", column);
	current_row[bytenum] |= mask;
}
/*
** clear the null bit for the given column in the row buffer
*/
void tds_clr_null(unsigned char *current_row, int column)
{
int bytenum = column  >> 3;
int bit = column & 0x7;
unsigned char mask = ~(1 << bit);

	tdsdump_log(TDS_DBG_INFO1, "%L clearing column %d NULL bit\n", column);
	current_row[bytenum] &= mask;
}
/*
** return the null bit for the given column in the row buffer
*/
int tds_get_null(unsigned char *current_row, int column)
{
int bytenum = column >> 3;
int bit = column & 0x7;
unsigned char mask = 1 << bit;

	return (current_row[bytenum] & mask) ? 1 : 0;
}
#endif

int tds_lookup_dynamic(TDSSOCKET *tds, char *id)
{
int i;

	for (i=0;i<tds->num_dyns;i++) {
		if (!strcmp(tds->dyns[i]->id, id)) {
			return i;
		}
	}
	return -1;
}
/*
** tds_process_dynamic()
** finds the element of the dyns array for the id
*/
static int tds_process_dynamic(TDSSOCKET *tds)
{
int token_sz;
char subtoken[2];
int id_len;
char id[TDS_MAX_DYNID_LEN+1];
int drain = 0;

	token_sz = tds_get_smallint(tds);
	subtoken[0] = tds_get_byte(tds);
	subtoken[1] = tds_get_byte(tds);
	if (subtoken[0]!=0x20 || subtoken[1]!=0x00) {
		tdsdump_log(TDS_DBG_ERROR,"Unrecognized TDS5_DYN subtoken %x,%x\n",
		        subtoken[0], subtoken[1]);
		tds_get_n(tds, NULL, token_sz-2);
		return -1;
	}
	id_len = tds_get_byte(tds);
	if (id_len > TDS_MAX_DYNID_LEN) {
		drain = id_len - TDS_MAX_DYNID_LEN;
		id_len = TDS_MAX_DYNID_LEN;
	}
	tds_get_string(tds, id, id_len);
	id[id_len]='\0';
	if (drain) { 
		tds_get_string(tds, NULL, drain);
	}
	return tds_lookup_dynamic(tds,id);
}

static void tds_process_dyn_result(TDSSOCKET *tds)
{
int hdrsize;
int col, num_cols;
TDSCOLINFO *curcol;
TDSRESULTINFO *info;
TDSDYNAMIC *dyn;

	hdrsize = tds_get_smallint(tds);
	num_cols = tds_get_smallint(tds);

	if (tds->cur_dyn_elem) {
		dyn = tds->dyns[tds->cur_dyn_elem];
		tds_free_results(dyn->res_info);
		/* read number of columns and allocate the columns structure */
		dyn->res_info = tds_alloc_results(num_cols);
		info = dyn->res_info;
	} else {
		tds_free_results(tds->res_info);
		tds->res_info = tds_alloc_results(num_cols);
		info = tds->res_info;
	}

	for (col=0;col<info->num_cols;col++) {
		curcol=info->columns[col];
		tds_get_n(tds,NULL,6);
		/* column type */
		curcol->column_type = tds_get_byte(tds);
		/* column size */
		if (!is_fixed_type(curcol->column_type)) {
			curcol->column_size = tds_get_byte(tds);
		} else { 
			curcol->column_size = get_size_by_type(curcol->column_type);
		}
		tds_get_byte(tds);
		/* fprintf(stderr,"elem %d coltype %d size %d\n",tds->cur_dyn_elem, curcol->column_type, curcol->column_size); */
	}
}

/* 
** tds_is_fixed_token()
** some tokens are fixed length while others are variable.  This function is 
** used by tds_process_cancel() to determine how to read past a token
*/
int tds_is_fixed_token(int marker)
{
	switch (marker) {
		case TDS_DONE_TOKEN:
		case TDS_DONEPROC_TOKEN:
		case TDS_DONEINPROC_TOKEN:
		case TDS_RET_STAT_TOKEN:
			return 1;
		default:
			return 0;	
	}
}

/* 
** tds_get_token_size() returns the size of a fixed length token
** used by tds_process_cancel() to determine how to read past a token
*/
int tds_get_token_size(int marker)
{
	switch(marker) {
		case TDS_DONE_TOKEN:
		case TDS_DONEPROC_TOKEN:
		case TDS_DONEINPROC_TOKEN:
			return 8;
		case TDS_RET_STAT_TOKEN:
			return 4;
		case TDS_124_TOKEN:
			return 8;
		default:
			return 0;
	}
}

void tds_swap_datatype(int coltype, unsigned char *buf)
{
TDS_NUMERIC *num;

	switch(coltype) {
#ifdef NCBI_FTDS
		case SYBINT2:
			tds_swap_2bytes(buf); break;
		case SYBINT4:
			tds_swap_4bytes(buf); break;
		case SYBINT8:
			tds_swap_8bytes(buf); break;
		case SYBREAL:
			tds_swap_4bytes(buf); break;
		case SYBFLT8:
			tds_swap_8bytes(buf); break;
		case SYBMONEY4:
			tds_swap_4bytes(buf); break;
		case SYBMONEY:
			tds_swap_4bytes(buf);
			tds_swap_4bytes(&buf[4]); break;
		case SYBDATETIME4:
			tds_swap_2bytes(buf);
			tds_swap_2bytes(&buf[2]); break;
		case SYBDATETIME:
			tds_swap_4bytes(buf);
			tds_swap_4bytes(&buf[4]); break;
		case SYBNUMERIC:
		case SYBDECIMAL:
			num = (TDS_NUMERIC *) buf;
            /* swap the sign */
            num->array[0] = (num->array[0] == 0) ? 1 : 0;
            /* swap the data */
            tds_swap_bytes(&(num->array[1]),
                           g__numeric_bytes_per_prec[num->precision] - 1); break;

        case SYBUNIQUE:
			tds_swap_4bytes(buf);
			tds_swap_2bytes(&buf[4]); 
			tds_swap_2bytes(&buf[6]); break;
#else
		case SYBINT2:
			tds_swap_bytes(buf,2); break;
		case SYBINT4:
			tds_swap_bytes(buf,4); break;
		case SYBINT8:
			tds_swap_bytes(buf,8); break;
		case SYBREAL:
			tds_swap_bytes(buf,4); break;
		case SYBFLT8:
			tds_swap_bytes(buf,8); break;
		case SYBMONEY4:
			tds_swap_bytes(buf,4); break;
		case SYBMONEY:
			tds_swap_bytes(buf,4);
			tds_swap_bytes(&buf[4],4); break;
		case SYBDATETIME4:
			tds_swap_bytes(buf,2);
			tds_swap_bytes(&buf[2],2); break;
		case SYBDATETIME:
			tds_swap_bytes(buf,4);
			tds_swap_bytes(&buf[4],4); break;
		case SYBNUMERIC:
		case SYBDECIMAL:
			num = (TDS_NUMERIC *) buf;
            /* swap the sign */
            num->array[0] = (num->array[0] == 0) ? 1 : 0;
            /* swap the data */
            tds_swap_bytes(&(num->array[1]),
                           g__numeric_bytes_per_prec[num->precision] - 1); break;

        case SYBUNIQUE:
			tds_swap_bytes(buf,4);
			tds_swap_bytes(&buf[4],2); 
			tds_swap_bytes(&buf[6],2); break;
#endif

	}
}
/*
** tds_get_varint_size() returns the size of a variable length integer
** returned in a TDS 7.0 result string
*/
static int tds_get_varint_size(int datatype)
{
	switch(datatype) {
		case SYBTEXT:
		case SYBNTEXT:
		case SYBIMAGE:
		case SYBVARIANT:
			return 4;
		case SYBVOID:
		case SYBINT1:
		case SYBBIT:
		case SYBINT2:
		case SYBINT4:
		case SYBDATETIME4:
		case SYBREAL:
		case SYBMONEY:
		case SYBDATETIME:
		case SYBFLT8:
		case SYBMONEY4:
		case SYBINT8:
			return 0;
		case XSYBNCHAR:
		case XSYBNVARCHAR:
		case XSYBCHAR:
		case XSYBVARCHAR:
		case XSYBBINARY:
		case XSYBVARBINARY:
			return 2;
		default:
			return 1;
	}
}

static int tds_get_cardinal_type(int datatype)
{
	switch(datatype) {
		case XSYBVARBINARY: 
			return SYBVARBINARY;
		case XSYBBINARY: 
			return SYBBINARY;
		case SYBNTEXT:
			return SYBTEXT;
		case XSYBNVARCHAR: 
		case XSYBVARCHAR: 
			return SYBVARCHAR;
		case XSYBNCHAR: 
		case XSYBCHAR: 
			return SYBCHAR;
	}
	return datatype;
}