dblib.c

ncbi源码

TDSRESULTINFO * resinfo;
TDSSOCKET * tds;

	tds = (TDSSOCKET *) dbproc->tds_socket;
	resinfo = tds->res_info;
	colinfo = resinfo->columns[colnum-1];
#ifdef NCBI_FTDS
   return colinfo->full_column_name;
#else
	return colinfo->column_name;
#endif
}
DBINT dbcollen(DBPROCESS *dbproc, int column)
{
TDSCOLINFO * colinfo;
TDSRESULTINFO * resinfo;
TDSSOCKET * tds;

	tds = (TDSSOCKET *) dbproc->tds_socket;
	resinfo = tds->res_info;
	if (column<1 || column>resinfo->num_cols) return -1;
	colinfo = resinfo->columns[column-1];
	return colinfo->column_size;
}
/* dbvarylen(), [e-mail] 01/21/02 */
DBINT dbvarylen(DBPROCESS *dbproc, int column)
{
TDSCOLINFO * colinfo;
TDSRESULTINFO *resinfo;
TDSSOCKET *tds;

	tds = (TDSSOCKET *) dbproc->tds_socket;
	resinfo = tds->res_info;
	if (column<1 || column>resinfo->num_cols) 
		return FALSE;
	colinfo = resinfo->columns[column-1];

	if (tds_get_null (resinfo->current_row, column))
		return TRUE;

	switch (colinfo->column_type) {
		/* variable length fields */
		case SYBNVARCHAR:
		case SYBVARBINARY:
		case SYBVARCHAR:
				return TRUE;
		
		/* types that can be null */
		case SYBBITN:
		case SYBDATETIMN:
		case SYBDECIMAL:
		case SYBFLTN:
		case SYBINTN:
		case SYBMONEYN:
		case SYBNUMERIC:
				return TRUE;

		/* blob types */
		case SYBIMAGE:
		case SYBNTEXT:
		case SYBTEXT:
				return TRUE;
	}
	return FALSE;
}
DBINT dbdatlen(DBPROCESS *dbproc, int column)
{
TDSCOLINFO * colinfo;
TDSRESULTINFO * resinfo;
TDSSOCKET * tds;
DBINT ret;

	/* FIXME -- this is the columns info, need per row info */
	/* Fixed by adding cur_row_size to colinfo, filled in by process_row
		in token.c. (mlilback, 11/7/01) */
	tds = (TDSSOCKET *) dbproc->tds_socket;
	resinfo = tds->res_info;
	if (column<1 || column>resinfo->num_cols) return -1;
	colinfo = resinfo->columns[column-1];
	tdsdump_log(TDS_DBG_INFO1, "%L dbdatlen() type = %d\n",colinfo->column_type);
	
	if (tds_get_null(resinfo->current_row,column-1))
		ret = 0;
	else
		ret = colinfo->cur_row_size;
	tdsdump_log(TDS_DBG_FUNC, "%L leaving dbdatlen() returning %d\n",ret);
	return ret;
}

BYTE *
dbdata(DBPROCESS *dbproc, int column)
{
TDSCOLINFO * colinfo;
TDSRESULTINFO * resinfo;
TDS_VARBINARY *varbin;
 register TDS_SMALLINT t;

	resinfo = dbproc->tds_socket->res_info;
	if (column<1 || column>resinfo->num_cols) return NULL;

	if (tds_get_null(resinfo->current_row,column-1)) {
		return NULL;
	}

	colinfo = resinfo->columns[column-1];
	t= colinfo->column_type;
	if (is_blob_type(t)) {
		return (BYTE *)colinfo->column_textvalue;
	} 
	if (t == SYBVARBINARY) {
		varbin = (TDS_VARBINARY *)
			&(resinfo->current_row[colinfo->column_offset]);
		return (BYTE *)varbin->array;
	}

	/* else */
	return &resinfo->current_row[colinfo->column_offset];
}

RETCODE dbcancel(DBPROCESS *dbproc)
{
   tds_send_cancel(dbproc->tds_socket);
   tds_process_cancel(dbproc->tds_socket);
   /* tds_process_default_tokens(dbproc->tds_socket,CANCEL); */
   return SUCCEED;
}
DBINT dbspr1rowlen(DBPROCESS *dbproc)
{
TDSCOLINFO * colinfo;
TDSRESULTINFO * resinfo;
TDSSOCKET * tds;
int col,len=0,collen,namlen;

	tds = (TDSSOCKET *) dbproc->tds_socket;
	resinfo = tds->res_info;

	for (col=0;col<resinfo->num_cols;col++)
	{
		colinfo = resinfo->columns[col];
		collen = _get_printable_size(colinfo);
		namlen = strlen(colinfo->column_name);
		len += collen > namlen ? collen : namlen;
	}
	/* the space between each column */
	len += resinfo->num_cols - 1;
	/* the newline */
	len++;

	return len;
}
RETCODE dbspr1row(DBPROCESS *dbproc, char *buffer, DBINT buf_len)
{
TDSCOLINFO * colinfo;
TDSRESULTINFO * resinfo;
TDSSOCKET * tds;
int i,col,collen,namlen,len;
char dest[256];
int desttype, srctype;
int buf_cur=0;
RETCODE ret;

	tds = (TDSSOCKET *) dbproc->tds_socket;
	resinfo = tds->res_info;

	buffer[0]='\0';

	if ((ret = dbnextrow(dbproc))!=REG_ROW) 
		return ret;

	for (col=0;col<resinfo->num_cols;col++)
	{
		colinfo = resinfo->columns[col];
		if (tds_get_null(resinfo->current_row,col)) {
			strcpy(dest,"NULL");
		} else {
			desttype = _db_get_server_type(STRINGBIND);
			srctype = tds_get_conversion_type(colinfo->column_type,colinfo->column_size);
			dbconvert(dbproc, srctype ,dbdata(dbproc,col+1), -1, desttype, (BYTE *)dest, 255);

		}
		collen = _get_printable_size(colinfo);
		namlen = strlen(colinfo->column_name);
		len = collen > namlen ? collen : namlen;
		for (i=strlen(dest);i<len;i++)
			strcat(dest," ");
		if (strlen(dest) + buf_cur < buf_len) {
			strcat(buffer,dest);
			buf_cur+=strlen(dest);
		}
		if (strlen(buffer)<buf_len) {
			strcat(buffer," ");
			buf_cur++;
		}
	}
	if (strlen(buffer)<buf_len) 
		strcat(buffer,"\n");
	return ret;
}

RETCODE
dbprrow(DBPROCESS *dbproc)
{
TDSCOLINFO * colinfo;
TDSRESULTINFO * resinfo;
TDSSOCKET * tds;
int i,col,collen,namlen,len;
char dest[256];
int desttype, srctype;

	tds = (TDSSOCKET *) dbproc->tds_socket;
	resinfo = tds->res_info;

	while(dbnextrow(dbproc)==REG_ROW) {
		for (col=0;col<resinfo->num_cols;col++)
		{
			colinfo = resinfo->columns[col];
			if (tds_get_null(resinfo->current_row,col)) {
				strcpy(dest,"NULL");
			} else {
				desttype = _db_get_server_type(STRINGBIND);
				srctype = tds_get_conversion_type(colinfo->column_type,colinfo->column_size);
				dbconvert(dbproc, srctype ,dbdata(dbproc,col+1), -1, desttype, (BYTE *)dest, 255);

				/* printf ("some data\t"); */
			}
			printf("%s",dest);
			collen = _get_printable_size(colinfo);
			namlen = strlen(colinfo->column_name);
			len = collen > namlen ? collen : namlen;
			for (i=strlen(dest);i<len;i++)
				printf(" ");
			printf(" ");
		}
		printf ("\n");
	}
	return SUCCEED;
}
static int _get_printable_size(TDSCOLINFO *colinfo)
{
	switch (colinfo->column_type) {
		case SYBINTN:
			switch(colinfo->column_size) {
				case 1: return 3;
				case 2: return 6;
				case 4: return 11;
			}
		case SYBINT1:
			return 3;
		case SYBINT2:
			return 6;
		case SYBINT4:
        		return 11;
		case SYBVARCHAR:
		case SYBCHAR:
			return colinfo->column_size;
		case SYBFLT8:
			return 11; /* FIX ME -- we do not track precision */
		case SYBREAL:
			return 11; /* FIX ME -- we do not track precision */
		case SYBMONEY:
        		return 12; /* FIX ME */
		case SYBMONEY4:
        		return 12; /* FIX ME */
		case SYBDATETIME:
        		return 26; /* FIX ME */
		case SYBDATETIME4:
        		return 26; /* FIX ME */
		case SYBBIT:
		case SYBBITN:
			return 1;
		/* FIX ME -- not all types present */
		default:
			return 0;
	}

}
RETCODE dbsprline(DBPROCESS *dbproc,char *buffer, DBINT buf_len, DBCHAR line_char)
{
TDSCOLINFO * colinfo;
TDSRESULTINFO * resinfo;
TDSSOCKET * tds;
int i,col, len, collen, namlen;
char line_str[2],dest[256];
int buf_cur=0;

	tds = (TDSSOCKET *) dbproc->tds_socket;
	resinfo = tds->res_info;

	buffer[0]='\0';
	line_str[0]=line_char;
	line_str[1]='\0';

	for (col=0;col<resinfo->num_cols;col++)
	{
		dest[0]='\0';
		colinfo = resinfo->columns[col];
		collen = _get_printable_size(colinfo);
		namlen = strlen(colinfo->column_name);
		len = collen > namlen ? collen : namlen;
		for (i=0;i<len;i++) 
			strcat(dest,line_str);
		if (strlen(dest)<buf_len-buf_cur) {
			strcat(buffer,dest);
			buf_cur += strlen(dest);
		}
		if (strlen(dest)<buf_len-buf_cur) {
			strcat(buffer," ");
			buf_cur++;
		}
	}
	if (strlen(dest)<buf_len-buf_cur) 
		strcat(buffer,"\n");
	return SUCCEED;
}
RETCODE dbsprhead(DBPROCESS *dbproc,char *buffer, DBINT buf_len)
{
TDSCOLINFO * colinfo;
TDSRESULTINFO * resinfo;
TDSSOCKET * tds;
int i,col, len, collen, namlen;
char dest[256];
int buf_cur=0;

	tds = (TDSSOCKET *) dbproc->tds_socket;
	resinfo = tds->res_info;

	buffer[0]='\0';

	for (col=0;col<resinfo->num_cols;col++)
	{
		colinfo = resinfo->columns[col];
		collen = _get_printable_size(colinfo);
		namlen = strlen(colinfo->column_name);
		len = collen > namlen ? collen : namlen;
		strcpy(dest,colinfo->column_name);
		for (i=strlen(colinfo->column_name);i<len;i++)
			strcat(dest," ");
		if (strlen(dest) < buf_len-buf_cur) {
			strcat(buffer,dest);
			buf_cur += strlen(dest);
		}
		if (strlen(dest) < buf_len-buf_cur) {
			strcat(buffer," ");
			buf_cur++;
		}
	}
	if (strlen(dest) < buf_len-buf_cur) 
		strcat(buffer,"\n");
	return SUCCEED;
}
void dbprhead(DBPROCESS *dbproc)
{
TDSCOLINFO * colinfo;
TDSRESULTINFO * resinfo;
TDSSOCKET * tds;
int i,col, len, collen, namlen;

	tds = (TDSSOCKET *) dbproc->tds_socket;
	resinfo = tds->res_info;
	for (col=0;col<resinfo->num_cols;col++)
	{
		colinfo = resinfo->columns[col];
		collen = _get_printable_size(colinfo);
		namlen = strlen(colinfo->column_name);
		len = collen > namlen ? collen : namlen;
		printf("%s",colinfo->column_name);
		for (i=strlen(colinfo->column_name);i<len;i++)
			printf(" ");
		printf(" ");
	}
	printf ("\n");
	for (col=0;col<resinfo->num_cols;col++)
	{
		colinfo = resinfo->columns[col];
		collen = _get_printable_size(colinfo);
		namlen = strlen(colinfo->column_name);
		len = collen > namlen ? collen : namlen;
		for (i=0;i<len;i++)
			printf("-");
		printf(" ");
	}
	printf ("\n");

}

RETCODE
dbrows(DBPROCESS *dbproc)
{
TDSRESULTINFO * resinfo;
TDSSOCKET * tds;

	tds = (TDSSOCKET *) dbproc->tds_socket;
	resinfo = tds->res_info;
	if (resinfo && resinfo->rows_exist) return SUCCEED;
	else return FAIL;
}
/* STUBS */
RETCODE dbsetdeflang(char *language)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetdeflang()\n");
	return SUCCEED;
}
int dbgetpacket(DBPROCESS *dbproc)
{
TDSSOCKET *tds = dbproc->tds_socket;

	if (!tds || !tds->env) {
		return TDS_DEF_BLKSZ;
	} else {
		return tds->env->block_size;
	}
}
RETCODE dbsetmaxprocs(int maxprocs)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetmaxprocs()\n");
	return SUCCEED;
}
RETCODE dbsettime(int seconds)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsettime()\n");
	return SUCCEED;
}
RETCODE dbsetlogintime(int seconds)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetlogintime()\n");
	return SUCCEED;
}
DBBOOL dbhasretstat(DBPROCESS *dbproc)
{
TDSSOCKET *tds = (TDSSOCKET *) dbproc->tds_socket;
	if (tds->has_status) {
		return TRUE;
	} else {
		return FALSE;
	}
}
DBINT dbretstatus(DBPROCESS *dbproc)
{
TDSSOCKET *tds = (TDSSOCKET *) dbproc->tds_socket;
	return tds->ret_status;
}
RETCODE dbcmdrow(DBPROCESS *dbproc)
{
        TDSSOCKET *tds = (TDSSOCKET *) dbproc->tds_socket;
        if (tds->res_info)
                return SUCCEED;
        return TDS_FAIL;
}
int dbaltcolid(DBPROCESS *dbproc, int computeid, int column)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbaltcolid()\n");
	return -1;
}
DBINT 
dbadlen(DBPROCESS *dbproc,int computeid, int column)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbaddlen()\n");
	return 0;
}
int dbalttype(DBPROCESS *dbproc, int computeid, int column)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbalttype()\n");
	return 0;
}
BYTE *dbadata(DBPROCESS *dbproc, int computeid, int column)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbadata()\n");
	return (BYTE*)"";
}
int dbaltop(DBPROCESS *dbproc, int computeid, int column)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbaltop()\n");
	return -1;
}
RETCODE dbsetopt(DBPROCESS *dbproc, int option, char *char_param, int int_param)
{
   switch (option) {
      case DBBUFFER:
      {
         /* XXX should be more robust than just a atoi() */
         buffer_set_buffering(&(dbproc->row_buf), atoi(char_param));
         break;
      }
      default:
      {
         break;
      }
   }
   return SUCCEED;
}

void
dbsetinterrupt(DBPROCESS *dbproc, int (*ckintr)(),int (*hndlintr)())
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbsetinterrupt()\n");
}
int dbnumrets(DBPROCESS *dbproc)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbnumrets()\n");
	return 0;
}
char *dbretname(DBPROCESS *dbproc, int retnum)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbretname()\n");
	return NULL;
}