dblib.c

ncbi源码

BYTE *dbretdata(DBPROCESS *dbproc, int retnum)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbretdata()\n");
	return NULL;
}
int dbretlen(DBPROCESS *dbproc, int retnum)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbretlen()\n");
	return -1;
}
RETCODE dbsqlok(DBPROCESS *dbproc)
{
unsigned char   marker;
RETCODE rc = SUCCEED;
TDSSOCKET *tds;

	tds = (TDSSOCKET *) dbproc->tds_socket;

	if (dbproc->text_sent) {
		tds_flush_packet(tds);
		dbproc->text_sent = 0;

		do {
			marker = tds_get_byte(tds);
			if(tds->s == 0) return FAIL;
			tds_process_default_tokens(tds, marker);
		} while (marker!=TDS_DONE_TOKEN);

		return SUCCEED;
	}
   /*
    * See what the next packet from the server is.  If it is an error
    * then we should return FAIL
    */
/* Calling dbsqlexec on an update only stored proc should read all tokens
	while (is_msg_token(tds_peek(tds))) {
		marker = tds_get_byte(tds);
		if (tds_process_default_tokens(tds, marker)!=TDS_SUCCEED) {
			rc=FAIL;
		}
	} 
*/
	do {
		marker = tds_peek(tds);
		if (!is_result_token(marker)) {
			marker = tds_get_byte(tds);
			/* tds_process_default_tokens can return TDS_ERROR in which case
			** we still want to read til end, but TDS_FAIL is an unrecoverable
			** error */
			if (tds_process_default_tokens(tds, marker)!=TDS_SUCCEED) {
				rc=FAIL;
			}
		}
#ifdef NCBI_FTDS
		if(tds->s == 0) return FAIL;
#endif
	} while (!is_hard_end_token(marker) && !is_result_token(marker));

	/* clean up */
	if (rc==FAIL && !is_end_token(marker)) {
		do {
			marker = tds_get_byte(tds);
			if (tds_process_default_tokens(tds, marker)!=TDS_SUCCEED) {
				return FAIL;
			}
#ifdef NCBI_FTDS
			if(tds->s == 0) return FAIL;
#endif
		} while (marker!=TDS_DONE_TOKEN);
	}
	return rc;
}
int dbnumalts(DBPROCESS *dbproc,int computeid)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbnumalts()\n");
	return 0;
}
BYTE *
dbbylist(DBPROCESS *dbproc, int computeid, int *size)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbbylist()\n");
	if (size) *size = 0;
	return NULL;
}
DBBOOL dbdead(DBPROCESS *dbproc)
{
	if(dbproc &&
	dbproc->tds_socket &&
	dbproc->tds_socket->s)
		return FALSE;
	else
		return TRUE;
}

EHANDLEFUNC
dberrhandle(EHANDLEFUNC handler)
{
   EHANDLEFUNC retFun = g_dblib_err_handler;

   g_dblib_err_handler = handler;
   return retFun;
}

MHANDLEFUNC
dbmsghandle(MHANDLEFUNC handler)
{
   MHANDLEFUNC retFun = g_dblib_msg_handler;

   g_dblib_msg_handler = handler;
   return retFun;
}

RETCODE dbmnyadd(DBPROCESS *dbproc, DBMONEY *m1, DBMONEY *m2, DBMONEY *sum)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyadd()\n");
	return SUCCEED;
}
RETCODE dbmnysub(DBPROCESS *dbproc, DBMONEY *m1, DBMONEY *m2, DBMONEY *diff)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnysyb()\n");
	return SUCCEED;
}
RETCODE dbmnymul(DBPROCESS *dbproc, DBMONEY *m1, DBMONEY *m2, DBMONEY *prod)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnymul()\n");
	return SUCCEED;
}
RETCODE dbmnydivide(DBPROCESS *dbproc, DBMONEY *m1, DBMONEY *m2, DBMONEY *quotient)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnydivide()\n");
	return SUCCEED;
}
RETCODE dbmnycmp(DBPROCESS *dbproc, DBMONEY *m1, DBMONEY *m2)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnycmp()\n");
	return SUCCEED;
}
RETCODE dbmnyscale(DBPROCESS *dbproc, DBMONEY *dest, int multiplier, int addend)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyscale()\n");
	return SUCCEED;
}
RETCODE dbmnyzero(DBPROCESS *dbproc, DBMONEY *dest)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyzero()\n");
	return SUCCEED;
}
RETCODE dbmnymaxpos(DBPROCESS *dbproc, DBMONEY *dest)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnymaxpos()\n");
	return SUCCEED;
}
RETCODE dbmnymaxneg(DBPROCESS *dbproc, DBMONEY *dest)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnymaxneg()\n");
	return SUCCEED;
}
RETCODE dbmnyndigit(DBPROCESS *dbproc, DBMONEY *mnyptr,DBCHAR *value, DBBOOL *zero)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyndigit()\n");
	return SUCCEED;
}
RETCODE dbmnyinit(DBPROCESS *dbproc,DBMONEY *mnyptr, int trim, DBBOOL *negative)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyinit()\n");
	return SUCCEED;
}
RETCODE dbmnydown(DBPROCESS *dbproc,DBMONEY *mnyptr, int divisor, int *remainder)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnydown()\n");
	return SUCCEED;
}
RETCODE dbmnyinc(DBPROCESS *dbproc,DBMONEY *mnyptr)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyinc()\n");
	return SUCCEED;
}
RETCODE dbmnydec(DBPROCESS *dbproc,DBMONEY *mnyptr)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnydec()\n");
	return SUCCEED;
}
RETCODE dbmnyminus(DBPROCESS *dbproc,DBMONEY *src, DBMONEY *dest)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnyminus()\n");
	return SUCCEED;
}
RETCODE dbmny4minus(DBPROCESS *dbproc, DBMONEY4 *src, DBMONEY4 *dest)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4minus()\n");
	return SUCCEED;
}
RETCODE dbmny4zero(DBPROCESS *dbproc, DBMONEY4 *dest)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4zero()\n");
	return SUCCEED;
}
RETCODE dbmny4add(DBPROCESS *dbproc, DBMONEY4 *m1, DBMONEY4 *m2, DBMONEY4 *sum)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4add()\n");
	return SUCCEED;
}
RETCODE dbmny4sub(DBPROCESS *dbproc, DBMONEY4 *m1, DBMONEY4 *m2, DBMONEY4 *diff)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4sub()\n");
	return SUCCEED;
}
RETCODE dbmny4mul(DBPROCESS *dbproc, DBMONEY4 *m1, DBMONEY4 *m2, DBMONEY4 *prod)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4mul()\n");
	return SUCCEED;
}
RETCODE dbmny4divide(DBPROCESS *dbproc, DBMONEY4 *m1, DBMONEY4 *m2, DBMONEY4 *quotient)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4divide()\n");
	return SUCCEED;
}
RETCODE dbmny4cmp(DBPROCESS *dbproc, DBMONEY4 *m1, DBMONEY4 *m2)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmny4cmp()\n");
	return SUCCEED;
}
RETCODE dbdatecmp(DBPROCESS *dbproc, DBDATETIME *d1, DBDATETIME *d2)
{
	if (d1->dtdays == d2->dtdays ) {
		if ( d1->dttime == d2->dttime )
			return 0;
		else
			return d1->dttime > d2->dttime ? 1 : -1 ;
	}

	/* date 1 is before 1900 */
	if (d1->dtdays > 2958463) {

		if (d2->dtdays > 2958463) /* date 2 is before 1900 */
			return d1->dtdays > d2->dtdays ? 1 : -1 ;
		else
			return -1;
	} else {
		/* date 1 is after 1900 */
		if (d2->dtdays < 2958463) /* date 2 is after 1900 */
			return d1->dtdays > d2->dtdays ? 1 : -1 ;
		else
			return 1;
	}
	return SUCCEED;
}
RETCODE dbdatecrack(DBPROCESS *dbproc, DBDATEREC *di, DBDATETIME *dt)
{
TDSDATEREC dr;

	tds_datecrack(SYBDATETIME, dt, &dr);

#ifndef MSDBLIB
	di->dateyear    = dr.year;
	di->datemonth   = dr.month;
	di->datedmonth  = dr.day;
	di->datedyear   = dr.dayofyear;
	di->datedweek   = dr.weekday;
	di->datehour    = dr.hour;
	di->dateminute  = dr.minute;
	di->datesecond  = dr.second;
	di->datemsecond = dr.millisecond;
#else
	di->year        = dr.year;
	di->month       = dr.month + 1;
	di->day         = dr.day;
	di->dayofyear   = dr.dayofyear;
	di->weekday     = dr.weekday + 1;
	di->hour        = dr.hour;
	di->minute      = dr.minute;
	di->second      = dr.second;
	di->millisecond = dr.millisecond;
#endif
	return SUCCEED;
}

void dbrpwclr(LOGINREC *login)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbrpwclr()\n");
}
RETCODE dbrpwset(LOGINREC *login, char *srvname, char *password, int pwlen)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbrpwset()\n");
	return SUCCEED;
}
int dbspid(DBPROCESS *dbproc)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbspid()\n");
	return 0;
}
void
dbsetuserdata(DBPROCESS *dbproc, BYTE *ptr)
{
	dbproc->user_data = ptr;
	return;
}
BYTE *dbgetuserdata(DBPROCESS *dbproc)
{
	return dbproc->user_data;
}
RETCODE dbsetversion(DBINT version)
{
	g_dblib_version  = version;
	return SUCCEED;
}
RETCODE dbmnycopy(DBPROCESS *dbproc, DBMONEY *src, DBMONEY *dest)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmnycopy()\n");
	return SUCCEED;
}
RETCODE dbcanquery(DBPROCESS *dbproc)
{
	TDSSOCKET *tds;
	int rc;

	if (dbproc == NULL)
		return FAIL;
	tds = (TDSSOCKET *) dbproc->tds_socket;
	if (!tds || !tds->s) 
		return FAIL;

	/*
	 *  Just throw away all pending rows from the last query
	 */
	do {
		rc = tds_process_row_tokens(dbproc->tds_socket);
	} while (rc == TDS_SUCCEED);

	if (rc == TDS_FAIL)
		return FAIL;

	return SUCCEED;
}
void dbfreebuf(DBPROCESS *dbproc)
{
	if(dbproc->dbbuf) {
		free(dbproc->dbbuf);
		dbproc->dbbuf = NULL;
		}
		dbproc->dbbufsz = 0;
} /* dbfreebuf()  */

RETCODE dbclropt(DBPROCESS *dbproc,int option, char *param)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbcltopt()\n");
	return SUCCEED;
}
DBBOOL dbisopt(DBPROCESS *dbproc,int option, char *param)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbisopt()\n");
	return TRUE;
}
DBINT dbcurrow(DBPROCESS *dbproc)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbcurrow()\n");
	return 0;
}
STATUS dbrowtype(DBPROCESS *dbproc)
{
	tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbrowtype()\n");
	return NO_MORE_ROWS;
}
int dbcurcmd(DBPROCESS *dbproc)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbcurcmd()\n");
	return 0;
}
RETCODE dbmorecmds(DBPROCESS *dbproc)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbmorecmds()\n");
	return SUCCEED;
}
int dbrettype(DBPROCESS *dbproc,int retnum)
{
        tdsdump_log (TDS_DBG_FUNC, "%L UNIMPLEMENTED dbrettype()\n");
	return 0;
}
int dbstrlen(DBPROCESS *dbproc)
{
	return dbproc->dbbufsz;
}
char *dbgetchar(DBPROCESS *dbproc, int pos)
{
     if (dbproc->dbbufsz > 0) {
       if (pos >= 0 && pos < dbproc->dbbufsz )
            return (char*)&dbproc->dbbuf[pos];
       else
          return (char *)NULL;
     }
    else
        return (char *)NULL;
}
RETCODE dbstrcpy(DBPROCESS *dbproc, int start, int numbytes, char *dest)
{
	dest[0] = 0; /* start with empty string being returned */
	if (dbproc->dbbufsz>0) {
		strncpy(dest, (char*)&dbproc->dbbuf[start], numbytes);
	}
	return SUCCEED;
}
RETCODE dbsafestr(DBPROCESS *dbproc,char *src, DBINT srclen, char *dest, DBINT destlen, int quotetype)
{
int i, j = 0;
int squote = FALSE, dquote = FALSE;

	
	/* check parameters */
	if (srclen<-1 || destlen<-1)
		return FAIL;

	if (srclen==-1) 
		srclen = strlen(src);

	if (quotetype == DBSINGLE || quotetype == DBBOTH)
		squote = TRUE;
	if (quotetype == DBDOUBLE || quotetype == DBBOTH)
		dquote = TRUE;

	/* return FAIL if invalid quotetype */
	if (!dquote && !squote)
		return FAIL;


	for (i=0;i<srclen;i++) {

		/* dbsafestr returns fail if the deststr is not big enough */
		/* need one char + one for terminator */
		if (destlen >= 0 && j>=destlen)
			return FAIL;

		if (squote && src[i]=='\'')
			dest[j++] = '\'';
		else if (dquote && src[i]=='\"')
			dest[j++] = '\"';

		if (destlen >= 0 && j>=destlen)
			return FAIL;

		dest[j++] = src[i];
	}

	if (destlen >= 0 && j>=destlen)
		return FAIL;

	dest[j]='\0';
	return SUCCEED;
}
char *dbprtype(int token)
{
   char  *result = NULL;

	/* 
	 * I added several types, but came up with my own result names
	 * since I don't have an MS platform to compare to.	--jkl
	 */
   switch (token)
   {
      case SYBAOPAVG:       result = "avg";             	break;
      case SYBAOPCNT:       result = "count";           	break;
      case SYBAOPMAX:       result = "max";             	break;
      case SYBAOPMIN:       result = "min";             	break;
      case SYBAOPSUM:       result = "sum";             	break;
	 
      case SYBBINARY:       result = "binary";          	break;
      case SYBBIT:          result = "bit";             	break;
      case SYBBITN:         result = "bit-null";        	break;
      case SYBCHAR:         result = "char";            	break;
      case SYBDATETIME4:    result = "smalldatetime";   	break;
      case SYBDATETIME:     result = "datetime";        	break;
      case SYBDATETIMN:     result = "datetime-null";   	break;
      case SYBDECIMAL:      result = "decimal";         	break;
      case SYBFLT8:         result = "float";           	break;
      case SYBFLTN:         result = "float-null";      	break;
      case SYBIMAGE:        result = "image";           	break;
      case SYBINT1:         result = "tinyint";         	break;
      case SYBINT2:         result = "smallint";        	break;
      case SYBINT4:         result = "int";             	break;
      case SYBINT8:         result = "long long";       	break;
      case SYBINTN:         result = "integer-null";    	break;
      case SYBMONEY4:       result = "smallmoney";      	break;
      case SYBMONEY:        result = "money";           	break;
      case SYBMONEYN:       result = "money-null";      	break;
      case SYBNTEXT:  	   result = "UCS-2 text";      	break;
      case SYBNVARCHAR:     result = "UCS-2 varchar";	 	break;
      case SYBNUMERIC:      result = "numeric";         	break;
      case SYBREAL:         result = "real";            	break;
      case SYBTEXT:         result = "text";            	break;
      case SYBUNIQUE:       result = "uniqueidentifier";	break;
      case SYBVARBINARY:    result = "varbinary";       	break;
      case SYBVARCHAR:      result = "varchar";         	break;

      case SYBVARIANT  :    result = "variant ";	    		break;
      case SYBVOID	   :    result = "void";	   		   	break;
      case XSYBBINARY  :    result = "xbinary";	    		break;
      case XSYBCHAR    :    result = "xchar";	    		break;
      case XSYBNCHAR   :    result = "x UCS-2 char";		break;
      case XSYBNVARCHAR:    result = "x UCS-2 varchar";	break;
      case XSYBVARBINARY:   result = "xvarbinary";	    	break;
      case XSYBVARCHAR :    result = "xvarchar ";	    		break;

      default:              result = "";