ct.c

ncbi源码

					cmd->empty_res_hack=1;
					*result_type = CS_ROW_RESULT;
					return CS_SUCCEED;
				}
			} else {
				*result_type = CS_CMD_DONE;
				return CS_END_RESULTS;
			}
		case TDS_FAIL:
			if (tds->state == TDS_DEAD) {
				return CS_FAIL;
			} else {
				*result_type = CS_CMD_FAIL;
				return CS_SUCCEED;
			}
		default:
			return CS_FAIL;
	}	
	return CS_FAIL;
}
CS_RETCODE ct_bind(CS_COMMAND *cmd, CS_INT item, CS_DATAFMT *datafmt, CS_VOID *buffer, CS_INT *copied, CS_SMALLINT *indicator)
{
TDSCOLINFO * colinfo;
CT_COLINFO *ctcolinfo; /* additional information about columns used by ctlib */
TDSRESULTINFO * resinfo;
TDSSOCKET * tds;

   tdsdump_log(TDS_DBG_FUNC, "%L inside ct_bind()\n");

   tds = (TDSSOCKET *) cmd->con->tds_socket;
   resinfo = tds->res_info;
   /* FIXME check item value */
   colinfo = resinfo->columns[item-1];
   colinfo->varaddr = (char *)buffer;
   colinfo->column_bindtype = datafmt->datatype;
   colinfo->column_bindfmt = datafmt->format;
   tdsdump_log(TDS_DBG_INFO1, "%L inside ct_bind() item = %d datafmt->datatype = %d\n", item, datafmt->datatype);
   colinfo->column_bindlen = datafmt->maxlength;
   if (indicator) {
   	colinfo->column_nullbind = (TDS_CHAR *) indicator;
   }
   if (copied) {
   	colinfo->column_lenbind = (TDS_CHAR *) copied;
   }
   return CS_SUCCEED;
}

CS_RETCODE ct_fetch(CS_COMMAND *cmd, CS_INT type, CS_INT offset, CS_INT option, CS_INT *rows_read)
{
   tdsdump_log(TDS_DBG_FUNC, "%L inside ct_fetch()\n");

   if (rows_read) *rows_read = 0;
   switch (tds_process_row_tokens(cmd->con->tds_socket)) {
      case TDS_SUCCEED:
	if (_ct_bind_data(cmd))
		return CS_ROW_FAIL;
      	if (rows_read) *rows_read = 1;
      	return TDS_SUCCEED;
      case TDS_NO_MORE_ROWS:
      	return CS_END_DATA;
      default:
      	return CS_FAIL;
   }
   return CS_SUCCEED;
}

static int _ct_bind_data(CS_COMMAND *cmd)
{
int i;
TDSCOLINFO *curcol;
TDSSOCKET *tds = cmd->con->tds_socket;
TDSRESULTINFO *resinfo = tds->res_info;
unsigned char *src;
unsigned char *dest;
int result = 0;
TDS_INT srctype, srclen, desttype, destlen, len;
CS_CONTEXT *ctx = cmd->con->ctx;

CS_DATAFMT srcfmt, destfmt;

   tdsdump_log(TDS_DBG_FUNC, "%L inside _ct_bind_data()\n");

   for (i=0; i<resinfo->num_cols; i++) {
      curcol = resinfo->columns[i];

      if (curcol->column_nullbind) {
      	if (tds_get_null(resinfo->current_row,i)) {
         		*((CS_SMALLINT *)curcol->column_nullbind) = -1;
      	} else {
         		*((CS_SMALLINT *)curcol->column_nullbind) = 0;
      	}
	 }
      /* printf("%d %s\n",i,resinfo->columns[i]->column_value); */
   
      srctype = curcol->column_type;
      desttype = _ct_get_server_type(curcol->column_bindtype);
      dest = (unsigned char *)curcol->varaddr;
  
      if (dest && !tds_get_null(resinfo->current_row,i)) {

         srctype = _ct_get_client_type(curcol->column_type, curcol->column_size);

         if (is_blob_type(curcol->column_type)) {
            src = (unsigned char *)curcol->column_textvalue;
            srclen = curcol->column_textsize;
         } else {
            src = &(resinfo->current_row[curcol->column_offset]);
	    srclen = curcol->cur_row_size;
         }

         tdsdump_log(TDS_DBG_INFO1, "%L inside _ct_bind_data() setting source length for %d = %d destlen = %d\n", i, srclen, curcol->column_bindlen);

         srcfmt.datatype  = srctype;
         srcfmt.maxlength = srclen;
         srcfmt.locale    = cmd->con->locale;

         destfmt.datatype  = curcol->column_bindtype;
         destfmt.maxlength = curcol->column_bindlen;
         destfmt.locale    = cmd->con->locale;
         destfmt.format    = curcol->column_bindfmt;

	 /* if convert return FAIL mark error but process other columns */
         if (cs_convert(ctx, &srcfmt, (CS_VOID *)src, &destfmt, (CS_VOID *)dest, &len) != CS_SUCCEED) {
		 result = 1;
		 len = 0;
	 }

         if (curcol->column_lenbind) {
            tdsdump_log(TDS_DBG_INFO1, "%L inside _ct_bind_data() length binding len = %d\n", len);
            *((CS_INT *)curcol->column_lenbind) = len;
         }

      }
   }
   return result;
}

CS_RETCODE ct_cmd_drop(CS_COMMAND *cmd)
{
	tdsdump_log(TDS_DBG_FUNC, "%L inside ct_cmd_drop()\n");
	if (cmd) {
		if (cmd->query) free(cmd->query);
		free(cmd);
	}
	return CS_SUCCEED;
}
CS_RETCODE ct_close(CS_CONNECTION *con, CS_INT option)
{
	tdsdump_log(TDS_DBG_FUNC, "%L inside ct_close()\n");
	tds_free_socket(con->tds_socket);
	return CS_SUCCEED;
}


CS_RETCODE ct_con_drop(CS_CONNECTION *con)
{
   tdsdump_log(TDS_DBG_FUNC, "%L inside ct_con_drop()\n");
   if (con) {
      if (con->userdata)   free(con->userdata);
      if (con->tds_login)  tds_free_login(con->tds_login);
      free(con);
   }
   return CS_SUCCEED;
}


static int _ct_get_client_type(int datatype, int size)
{
   tdsdump_log(TDS_DBG_FUNC, "%L inside _ct_get_client_type(type %d, size %d)\n",
                             datatype, size);
   switch (datatype) {
         case SYBBIT:
         case SYBBITN:
		return CS_BIT_TYPE;
		break;
         case SYBCHAR:
         case SYBVARCHAR:
		return CS_CHAR_TYPE;
		break;
         case SYBINT4:
      		return CS_INT_TYPE;
		break;
         case SYBINT2:
      		return CS_SMALLINT_TYPE;
		break;
         case SYBINT1:
      		return CS_TINYINT_TYPE;
		break;
	 case SYBINTN:
		if (size==4) {
			return CS_INT_TYPE;
		} else if (size==2) {
      			return CS_SMALLINT_TYPE;
		} else if (size==1) {
      			return CS_TINYINT_TYPE;
		} else {
			fprintf(stderr,"Unknown size %d for SYBINTN\n", size);
		}
		break;
         case SYBREAL:
      		return CS_REAL_TYPE;
		break;
         case SYBFLT8:
      		return CS_FLOAT_TYPE;
		break;
	 case SYBFLTN:
      		if (size==4) {
			return CS_REAL_TYPE;
		} else if (size==8) {
			return CS_FLOAT_TYPE;
		} else {
			fprintf(stderr,"Error! unknown float size of %d\n",size);
		}
         case SYBMONEY:
      		return CS_MONEY_TYPE;
		break;
         case SYBMONEY4:
      		return CS_MONEY4_TYPE;
		break;
	 case SYBMONEYN:
      		if (size==4) {
			return CS_MONEY4_TYPE;
		} else if (size==8) {
			return CS_MONEY_TYPE;
		} else {
			fprintf(stderr,"Error! unknown money size of %d\n",size);
		}
         case SYBDATETIME:
      		return CS_DATETIME_TYPE;
		break;
         case SYBDATETIME4:
      		return CS_DATETIME4_TYPE;
		break;
	 case SYBDATETIMN:
      		if (size==4) {
			return CS_DATETIME4_TYPE;
		} else if (size==8) {
			return CS_DATETIME_TYPE;
		} else {
			fprintf(stderr,"Error! unknown date size of %d\n",size);
		}
		break;
         case SYBNUMERIC:
      		return CS_NUMERIC_TYPE;
		break;
         case SYBDECIMAL:
      		return CS_DECIMAL_TYPE;
		break;
         case SYBBINARY:
      		return CS_BINARY_TYPE;
		break;
         case SYBIMAGE:
      		return CS_IMAGE_TYPE;
		break;
         case SYBVARBINARY:
      		return CS_VARBINARY_TYPE;
		break;
         case SYBTEXT:
      		return CS_TEXT_TYPE;
		break;
         case SYBUNIQUE:
      		return CS_UNIQUE_TYPE;
		break;
   }

   return CS_FAIL;
}
int _ct_get_server_type(int datatype)
{
   tdsdump_log(TDS_DBG_FUNC, "%L inside _ct_get_server_type(%d)\n", datatype);
   switch (datatype) {
      case CS_IMAGE_TYPE:
	 return SYBIMAGE;
	 break;
      case CS_BINARY_TYPE:
	 return SYBBINARY;
	 break;
      case CS_BIT_TYPE:
         return SYBBIT;
         break;
      case CS_CHAR_TYPE:
         return SYBCHAR;
         break;
      case CS_INT_TYPE:
         return SYBINT4;
         break;
      case CS_SMALLINT_TYPE:
         return SYBINT2;
         break;
      case CS_TINYINT_TYPE:
         return SYBINT1;
         break;
      case CS_REAL_TYPE:
         return SYBREAL;
         break;
      case CS_FLOAT_TYPE:
         return SYBFLT8;
         break;
      case CS_MONEY_TYPE:
         return SYBMONEY;
         break;
      case CS_MONEY4_TYPE:
         return SYBMONEY4;
         break;
      case CS_DATETIME_TYPE:
         return SYBDATETIME;
         break;
      case CS_DATETIME4_TYPE:
         return SYBDATETIME4;
         break;
      case CS_NUMERIC_TYPE:
         return SYBNUMERIC;
         break;
      case CS_DECIMAL_TYPE:
         return SYBDECIMAL;
         break;
      case CS_VARBINARY_TYPE:
         return SYBVARBINARY;
	 break;
      case CS_TEXT_TYPE:
         return SYBTEXT;
	 break;
      case CS_UNIQUE_TYPE:
         return SYBUNIQUE;
	 break;
      default:
         return -1;
         break;
   }
}

CS_RETCODE ct_cancel(CS_CONNECTION *conn, CS_COMMAND *cmd, CS_INT type)
{
   CS_RETCODE ret;

   tdsdump_log(TDS_DBG_FUNC, "%L inside ct_cancel()\n");
   if (type == CS_CANCEL_CURRENT) {
      if (conn || !cmd)  return CS_FAIL;
      while (1) {
         ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, NULL);
         if ((ret != CS_SUCCEED) && (ret != CS_ROW_FAIL)) {
            break;
         }
      }
      if (cmd->con->tds_socket) {
         tds_free_all_results(cmd->con->tds_socket);
      }
      return ret;
   }

   if ((conn && cmd) || (!conn && !cmd)) {
      return CS_FAIL;
   }
   if (cmd)  conn = cmd->con;
   tds_send_cancel(conn->tds_socket);
   tds_process_cancel(conn->tds_socket);
   return CS_SUCCEED;
}

CS_RETCODE ct_describe(CS_COMMAND *cmd, CS_INT item, CS_DATAFMT *datafmt)
{
TDSSOCKET *tds;
TDSRESULTINFO *resinfo;
TDSCOLINFO *curcol;

	tdsdump_log(TDS_DBG_FUNC, "%L inside ct_describe()\n");
	tds = cmd->con->tds_socket;

	if (cmd->dynamic_cmd) {
		resinfo = tds->dyns[tds->cur_dyn_elem]->res_info;
	} else {
 		resinfo = cmd->con->tds_socket->res_info;
	}

	if (item<1 || item>resinfo->num_cols) return CS_FAIL;	
	curcol=resinfo->columns[item-1];
	strncpy(datafmt->name, curcol->column_name, CS_MAX_NAME);
	datafmt->namelen = strlen(curcol->column_name);
	/* need to turn the SYBxxx into a CS_xxx_TYPE */
	datafmt->datatype = _ct_get_client_type(curcol->column_type, curcol->column_size); 
	tdsdump_log(TDS_DBG_INFO1, "%L inside ct_describe() datafmt->datatype = %d server type %d\n", datafmt->datatype, curcol->column_type);
	datafmt->maxlength = curcol->column_size;
	datafmt->usertype = curcol->column_usertype; 
	datafmt->precision = curcol->column_prec; 
	datafmt->scale = curcol->column_scale; 
	/* FIX ME -- TDS 5.0 has status information in the results 
	** however, this will work for 4.2 as well */
	if (is_nullable_type(curcol->column_type)) 
		datafmt->status |= CS_CANBENULL;
	datafmt->count = 1;
	datafmt->locale = NULL;
	
	return CS_SUCCEED;
}
CS_RETCODE ct_res_info_dyn(CS_COMMAND *cmd, CS_INT type, CS_VOID *buffer, CS_INT buflen, CS_INT *out_len)
{
TDSSOCKET *tds = cmd->con->tds_socket;
TDSDYNAMIC *dyn;
CS_INT int_val;

	switch(type) {
		case CS_NUMDATA:
			dyn = tds->dyns[tds->cur_dyn_elem];
			int_val = dyn->res_info->num_cols;
			memcpy(buffer, &int_val, sizeof(CS_INT));
			break;
		default:
			fprintf(stderr,"Unknown type in ct_res_info_dyn: %d\n",type);
			return CS_FAIL;
	}
	return CS_SUCCEED;
}
CS_RETCODE ct_res_info(CS_COMMAND *cmd, CS_INT type, CS_VOID *buffer, CS_INT buflen, CS_INT *out_len)
{
TDSSOCKET *tds = cmd->con->tds_socket;
TDSRESULTINFO *resinfo = tds->res_info;
CS_INT int_val;

	tdsdump_log(TDS_DBG_FUNC, "%L inside ct_res_info()\n");
	if (cmd->dynamic_cmd) {
		return ct_res_info_dyn(cmd, type, buffer, buflen, out_len);
	}
	switch(type) {
		case CS_NUMDATA:
			if (!resinfo) {
				int_val = 0;
			} else {
				int_val = resinfo->num_cols;
			}
			memcpy(buffer, &int_val, sizeof(CS_INT));
			break;
		case CS_ROW_COUNT:
			/* resinfo check by [e-mail] */
			if (resinfo) {
				int_val = resinfo->row_count;
			} else {
				int_val = tds->rows_affected;
			}
			memcpy(buffer, &int_val, sizeof(CS_INT));
			break;
		default:
			fprintf(stderr,"Unknown type in ct_res_info: %d\n",type);
			return CS_FAIL;
			break;
	}
	return CS_SUCCEED;
}
CS_RETCODE ct_config(CS_CONTEXT *ctx, CS_INT action, CS_INT property, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
{
	tdsdump_log(TDS_DBG_FUNC, "%L inside ct_config() action = %s property = %d\n",
		CS_GET ? "CS_GET" : "CS_SET", property);
	return CS_SUCCEED;
}
CS_RETCODE ct_cmd_props(CS_COMMAND *cmd, CS_INT action, CS_INT property, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
{
	tdsdump_log(TDS_DBG_FUNC, "%L inside ct_cmd_props() action = %s property = %d\n",
		CS_GET ? "CS_GET" : "CS_SET", property);
	return CS_SUCCEED;
}