开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
utility.c
资源名称：myodbc-2_50_17a-src.zip　[点击查看]
上传用户：jmzj888
上传日期：2007-01-02
资源大小：220k
文件大小：15k
源码类别：

MySQL数据库

开发平台：

Visual C++

utility.c：源码内容
  1. /* Copyright Abandoned 1996 TCX DataKonsult AB & Monty Program KB & Detron HB
  2.    This file is public domain and comes with NO WARRANTY of any kind */
  4. #include "myodbc.h"
  6. /* Use own fields instead of sql fields */
  8. void mysql_link_fields(STMT *stmt,MYSQL_FIELD *fields,uint field_count)
  9. {
  10.   MYSQL_RES *result=stmt->result;
  11.   result->fields=fields;
  12.   result->field_count=field_count;
  13.   result->current_field=0;
  14.   fix_result_types(stmt);
  15. }
  18. void fix_result_types(STMT *stmt)
  19. {
  20.   uint i;
  21.   MYSQL_RES *result=stmt->result;
  22.   DBUG_ENTER("fix_result_types");
  24.   stmt->state=ST_EXECUTED; /* Mark set found */
  25.   if ((stmt->odbc_types=(SWORD*) my_malloc(sizeof(SWORD)*result->field_count,
  26.    MYF(0))))
  27.   {
  28.     for (i=0 ; i < result->field_count ; i++)
  29.     {
  30.       MYSQL_FIELD *field=result->fields+i;
  31.       stmt->odbc_types[i]=(SWORD) unireg_to_c_datatype(field);
  32.     }
  33.   }
  34.   /*
  35.   ** Fix default values for bound columns
  36.   ** Normally there isn't any bound columns at this stage !
  37.   */
  38.   if (stmt->bind)
  39.   {
  40.     if (stmt->bound_columns < result->field_count)
  41.     {
  42.       if (!(stmt->bind=(BIND*) my_realloc((char*) stmt->bind,
  43.   sizeof(BIND) * result->field_count,
  44.   MYF(MY_FREE_ON_ERROR))))
  45.       {
  46. /* We should in principle give an error here */
  47. stmt->bound_columns=0;
  48. DBUG_VOID_RETURN;
  49.       }
  50.       bzero((gptr) (stmt->bind+stmt->bound_columns),
  51.     (result->field_count -stmt->bound_columns)*sizeof(BIND));
  52.       stmt->bound_columns=result->field_count;
  53.     }
  54.     /* Fix default types and pointers to fields */
  56.     mysql_field_seek(result,0);
  57.     for (i=0; i < result->field_count ; i++)
  58.     {
  59.         if (stmt->bind[i].fCType == SQL_C_DEFAULT)
  60.   stmt->bind[i].fCType=stmt->odbc_types[i];
  61.         stmt->bind[i].field=mysql_fetch_field(result);
  62.     }
  63.   }
  64.   DBUG_VOID_RETURN;
  65. }
  67. /* change a string + length to a zero terminated string */
  69. char *fix_str(char *to,char *from,int length)
  70. {
  71.   if (!from)
  72.     return "";
  73.   if (length == SQL_NTS)
  74.     return from;
  75.   strmake(to,from,length);
  76.   return to;
  77. }
  80. char *dupp_str(char *from,int length)
  81. {
  82.   char *to;
  83.   if (!from)
  84.     return my_strdup("",MYF(MY_WME));
  85.   if (length == SQL_NTS)
  86.     length=strlen(from);
  87.   if ((to=my_malloc(length+1,MYF(MY_WME))))
  88.   {
  89.     memcpy(to,from,length);
  90.     to[length]=0;
  91.   }
  92.   return to;
  93. }
  95. /* Return 1 if from is a null pointer or a empty string */
  97. bool empty_str(char *from,int length)
  98. {
  99.   if (!from)
  100.     return 1;
  101.   if (length == SQL_NTS)
  102.     return from[0] == 0;
  103.   return !length;
  104. }
  106. void remove_escape(char *name)
  107. {
  108.   char *to;
  109.   for (to=name ; *name ; name++)
  110.   {
  111.     if (*name == '\' && name[1])
  112.       name++;
  113.     *to++= *name;
  114.   }
  115.   *to=0;
  116. }
  118. /*
  119. ** Return (possibly truncated) results
  120. ** If result is truncated the result length contains
  121. ** length of the truncted result;
  122. */
  124. RETCODE copy_result(DBC *dbc,UCHAR FAR *rgbValue,SWORD cbValueMax,
  125.     SWORD FAR *pcbValue,char FAR *src)
  126. {
  127.   UCHAR FAR *dst=rgbValue;
  128.   SWORD save_ValueMax=cbValueMax;
  129.   if (!dst)
  130.   {
  131.     if (pcbValue)
  132.       *pcbValue=0;
  133.     return SQL_SUCCESS;
  134.   }
  135.   while (--cbValueMax)
  136.   {
  137.     if (! (*dst++ = *src++))
  138.     {
  139.       if (pcbValue)
  140.         *pcbValue= (SWORD) (dst-1 - rgbValue);
  141.       return SQL_SUCCESS;
  142.     }
  143.   }
  144.   *dst=0;
  145.   if (pcbValue)
  146.     *pcbValue=(SWORD) (dst- rgbValue);  /* +strlen(src) */
  147.   if (!*src)
  148.     return SQL_SUCCESS; /* There was room after all */
  149.   DBUG_PRINT("warning",("Truncated string of length: %d to %d",
  150. strlen(src)+ (dst-rgbValue)+1, save_ValueMax));
  151.   if (dbc)
  152.     set_error(dbc,"01004","Data truncated",4002);
  154.   return SQL_SUCCESS_WITH_INFO;
  155. }
  158. RETCODE copy_lresult(DBC FAR *dbc,UCHAR FAR *rgbValue,SDWORD cbValueMax,
  159.      SDWORD FAR *pcbValue,char *src,ulong src_length,
  160.      ulong max_length,ulong fill_length,ulong *offset)
  161. {
  162.   char *dst=(char*) rgbValue;
  163.   ulong length;
  165.   if (cbValueMax) /* If not length check */
  166.     cbValueMax--; /* Room for end null */
  167.   else
  168.     dst=0; /* Don't copy anything! */
  169.   if (max_length) /* If limit on char lengths */
  170.   {
  171.     set_if_smaller(cbValueMax,(long) max_length);
  172.     set_if_smaller(src_length,max_length);
  173.     set_if_smaller(fill_length,max_length);
  174.   }
  175.   if (fill_length < src_length || !dbc || !(dbc->flag & FLAG_PAD_SPACE))
  176.     fill_length=src_length;
  177.   if (*offset == (ulong) ~0L)
  178.     *offset=0; /* First call */
  179.   else if (*offset >= fill_length)
  180.     return SQL_NO_DATA_FOUND;
  181.   src+= *offset ; src_length-= *offset; fill_length-= *offset;
  182.   length=min(fill_length,(ulong) cbValueMax);
  183.   (*offset)+=length; /* Fix for next call */
  184.   if (pcbValue)
  185.     *pcbValue=fill_length;
  186.   if (dst) /* Bind allows null pointers */
  187.   {
  188.     ulong copy_length= ((long) src_length >= (long) length ? length :
  189. ((long) src_length >= 0 ? src_length : 0L));
  190.     memcpy(dst,src,copy_length);
  191.     bfill(dst+copy_length,length-copy_length,' ');
  192.     dst[length]=0;
  193.   }
  194.   if ((ulong) cbValueMax >= fill_length)
  195.     return SQL_SUCCESS;
  196.   if (dbc)
  197.     set_error(dbc,"01004","Data truncated",4002);
  198.   return SQL_SUCCESS_WITH_INFO;
  199. }
  202. RETCODE set_error(DBC FAR *dbc,char *state,char *message,uint errcode)
  203. {
  204.   DBUG_ENTER("set_error");
  205.   DBUG_PRINT("error",("message: %s",message));
  206.   strmov(dbc->sqlstate,state);
  207.   strmov(mysql_error(&dbc->mysql),message);
  208.   dbc->mysql.net.last_errno=errcode;
  209.   DBUG_RETURN(SQL_ERROR);
  210. }
  212. /*
  213. ** Get type, transfer length and precision for a unireg column
  214. ** Note that timestamp is changed to YYYY-MM-DD HH:MM:SS type
  215. */
  217. int unireg_to_sql_datatype(STMT FAR *stmt, MYSQL_FIELD *field, char *buff,
  218.    ulong *transfer_length,ulong *precision,
  219.    ulong *display_size)
  220. {
  221.   char *pos;
  222.   if (stmt->dbc->flag & FLAG_FIELD_LENGTH)
  223.     *transfer_length= *precision= *display_size= max(field->length,
  224.      field->max_length);
  225.   else
  226.     *transfer_length= *precision= *display_size= field->max_length;
  228.   switch(field->type) {
  229.   case FIELD_TYPE_DECIMAL:
  230.     if (buff) strmov(buff,"decimal");
  231.     return SQL_DECIMAL;
  232.   case FIELD_TYPE_CHAR:
  233.     if (buff)
  234.     {
  235.       pos=strmov(buff,"tinyint");
  236.       if (field->flags & UNSIGNED_FLAG)
  237. strmov(pos," unsigned");
  238.     }
  239.     *transfer_length=1;
  240.     return SQL_TINYINT;
  241.   case FIELD_TYPE_SHORT:
  242.     if (buff)
  243.     {
  244.       pos=strmov(buff,"smallint");
  245.       if (field->flags & UNSIGNED_FLAG)
  246. strmov(pos," unsigned");
  247.     }
  248.     *transfer_length=2;
  249.     return SQL_SMALLINT;
  250.   case FIELD_TYPE_INT24:
  251.     if (buff)
  252.     {
  253.       pos=strmov(buff,"mediumint");
  254.       if (field->flags & UNSIGNED_FLAG)
  255. strmov(pos," unsigned");
  256.     }
  257.     *transfer_length=4;
  258.     return SQL_INTEGER;
  259.   case FIELD_TYPE_LONG:
  260.     if (buff)
  261.     {
  262.       pos= strmov(buff,"int");
  263.       if (field->flags & UNSIGNED_FLAG)
  264. strmov(pos," unsigned");
  265.     }
  266.     *transfer_length=4;
  267.     return SQL_INTEGER;
  268.   case FIELD_TYPE_LONGLONG:
  269.     if (buff)
  270.     {
  271.       pos= strmov(buff,"bigint");
  272.       if (field->flags & UNSIGNED_FLAG)
  273. strmov(pos," unsigned");
  274.     }
  275.     *transfer_length=20;
  276.     return SQL_BIGINT;
  277.   case FIELD_TYPE_FLOAT:
  278.     if (buff)
  279.     {
  280.       pos= strmov(buff,"float");
  281.       if (field->flags & UNSIGNED_FLAG)
  282. strmov(pos," unsigned");
  283.     }
  284.     *transfer_length=4;
  285.     return SQL_REAL;
  286.   case FIELD_TYPE_DOUBLE:
  287.     if (buff)
  288.     {
  289.       pos= strmov(buff,"double");
  290.       if (field->flags & UNSIGNED_FLAG)
  291. strmov(pos," unsigned");
  292.     }
  293.     *transfer_length=8;
  294.     return SQL_DOUBLE;
  295.   case FIELD_TYPE_NULL:
  296.     if (buff) strmov(buff,"null");
  297.     return SQL_VARCHAR;
  298.   case FIELD_TYPE_YEAR:
  299.     if (buff)
  300.       pos=strmov(buff,"year");
  301.     *transfer_length=2;
  302.     return SQL_SMALLINT;
  303.   case FIELD_TYPE_TIMESTAMP:
  304.     if (buff) strmov(buff,"timestamp");
  305.     *transfer_length=16; /* size of timestamp_struct */
  306.     *precision= *display_size=19;
  307.     return SQL_TIMESTAMP;
  308.   case FIELD_TYPE_DATETIME:
  309.     if (buff) strmov(buff,"datetime");
  310.     *transfer_length=16; /* size of timestamp_struct */
  311.     *precision= *display_size=19;
  312.     return SQL_TIMESTAMP;
  313.   case FIELD_TYPE_NEWDATE:
  314.   case FIELD_TYPE_DATE:
  315.     if (buff) strmov(buff,"date");
  316.     *transfer_length=6; /* size of date struct */
  317.     *precision= *display_size=10;
  318.     return SQL_DATE;
  319.   case FIELD_TYPE_TIME:
  320.     if (buff) strmov(buff,"time");
  321.     *transfer_length=6; /* size of time struct */
  322.     *precision= *display_size=8;
  323.     return SQL_TIME;
  324.   case FIELD_TYPE_STRING:
  325.     if (buff) strmov(buff,"char");
  326.     return SQL_CHAR;
  327.   case FIELD_TYPE_VAR_STRING:
  328.     if (buff) strmov(buff,"varchar");
  329.     return SQL_VARCHAR;
  330.   case FIELD_TYPE_TINY_BLOB:
  331.     if (buff)
  332.       strmov(buff,(field->flags & BINARY_FLAG) ? "tinyblob" : "tinytext");
  333.     if (stmt->dbc->flag & FLAG_FIELD_LENGTH)
  334.       *transfer_length= *precision= *display_size= 255;
  335.     return (field->flags & BINARY_FLAG) ? SQL_LONGVARBINARY : SQL_LONGVARCHAR;
  336.   case FIELD_TYPE_BLOB:
  337.     if (buff)
  338.       strmov(buff,(field->flags & BINARY_FLAG) ? "blob" : "text");
  339.     if (stmt->dbc->flag & FLAG_FIELD_LENGTH)
  340.       *transfer_length= *precision= *display_size= 65535;
  341.     return (field->flags & BINARY_FLAG) ? SQL_LONGVARBINARY : SQL_LONGVARCHAR;
  342.   case FIELD_TYPE_MEDIUM_BLOB:
  343.     if (buff)
  344.       strmov(buff,((field->flags & BINARY_FLAG) ? "mediumblob" : "mediumtext"));
  345.     if (stmt->dbc->flag & FLAG_FIELD_LENGTH)
  346.       *transfer_length= *precision= *display_size= (1L << 24)-1L;
  347.     return (field->flags & BINARY_FLAG) ? SQL_LONGVARBINARY : SQL_LONGVARCHAR;
  348.   case FIELD_TYPE_LONG_BLOB:
  349.     if (buff)
  350.       strmov(buff,((field->flags & BINARY_FLAG) ? "longblob": "longtext"));
  351.     if (stmt->dbc->flag & FLAG_FIELD_LENGTH)
  352.       *transfer_length= *precision= *display_size= INT_MAX32;
  353.     return (field->flags & BINARY_FLAG) ? SQL_LONGVARBINARY : SQL_LONGVARCHAR;
  354.   case FIELD_TYPE_ENUM:
  355.     if (buff) strmov(buff,"enum");
  356.     return SQL_CHAR;
  357.   case FIELD_TYPE_SET:
  358.     if (buff) strmov(buff,"set");
  359.     return SQL_CHAR;
  360.   }
  361. }
  364. int unireg_to_c_datatype(MYSQL_FIELD *field)
  365. {
  366.   switch(field->type) {
  367.   case FIELD_TYPE_LONGLONG: /* Must be returned as char */
  368.   default:
  369.     return SQL_C_CHAR;
  370.   case FIELD_TYPE_CHAR:
  371.     return SQL_C_TINYINT;
  372.   case FIELD_TYPE_YEAR:
  373.   case FIELD_TYPE_SHORT:
  374.     return SQL_C_SHORT;
  375.   case FIELD_TYPE_INT24:
  376.   case FIELD_TYPE_LONG:
  377.     return SQL_C_LONG;
  378.   case FIELD_TYPE_FLOAT:
  379.     return SQL_C_FLOAT;
  380.   case FIELD_TYPE_DOUBLE:
  381.     return SQL_C_DOUBLE;
  382.   case FIELD_TYPE_TIMESTAMP:
  383.   case FIELD_TYPE_DATETIME:
  384.     return SQL_C_TIMESTAMP;
  385.   case FIELD_TYPE_NEWDATE:
  386.   case FIELD_TYPE_DATE:
  387.     return SQL_C_DATE;
  388.   case FIELD_TYPE_TIME:
  389.     return SQL_C_TIME;
  390.   }
  391. }
  393. int default_c_type(int sql_data_type)
  394. {
  395.   switch (sql_data_type) {
  396.   case SQL_CHAR:
  397.   case SQL_VARCHAR:
  398.   case SQL_LONGVARCHAR:
  399.   case SQL_DECIMAL:
  400.   case SQL_NUMERIC:
  401.   case SQL_BIGINT: /* This is according to standard */
  402.     return SQL_C_CHAR;
  403.   case SQL_BIT:
  404.     return SQL_C_BIT;
  405.   case SQL_TINYINT:
  406.     return SQL_C_TINYINT;
  407.   case SQL_SMALLINT:
  408.     return SQL_C_SHORT;
  409.   case SQL_INTEGER:
  410.     return SQL_C_LONG;
  411.   case SQL_REAL:
  412.   case SQL_FLOAT:
  413.     return SQL_C_FLOAT;
  414.   case SQL_DOUBLE:
  415.     return SQL_C_DOUBLE;
  416.   case SQL_BINARY:
  417.   case SQL_VARBINARY:
  418.   case SQL_LONGVARBINARY:
  419.     return SQL_C_BINARY;
  420.   case SQL_DATE:
  421.     return SQL_C_DATE;
  422.   case SQL_TIME:
  423.     return SQL_C_TIME;
  424.   case SQL_TIMESTAMP:
  425.     return SQL_C_TIMESTAMP;
  426.   }
  427. }
  429. ulong bind_length(int sql_data_type,ulong length)
  430. {
  431.   switch (sql_data_type) {
  432.   default: /* For CHAR, VARCHAR, BLOB... */
  433.     return length;
  434.   case SQL_C_BIT:
  435.   case SQL_C_TINYINT:
  436.   case SQL_C_STINYINT:
  437.   case SQL_C_UTINYINT:
  438.     return 1;
  439.   case SQL_C_SHORT:
  440.   case SQL_C_SSHORT:
  441.   case SQL_C_USHORT:
  442.     return 2;
  443.   case SQL_C_LONG:
  444.   case SQL_C_SLONG:
  445.   case SQL_C_ULONG:
  446.     return sizeof(long);
  447.   case SQL_C_FLOAT:
  448.     return sizeof(float);
  449.   case SQL_C_DOUBLE:
  450.     return sizeof(double);
  451.   case SQL_C_DATE:
  452.     return sizeof(DATE_STRUCT);
  453.   case SQL_C_TIME:
  454.     return sizeof(TIME_STRUCT);
  455.   case SQL_C_TIMESTAMP:
  456.     return sizeof(TIMESTAMP_STRUCT);
  457. #if (ODBCVER >= 0x0300)
  458.   case SQL_C_SBIGINT:
  459.   case SQL_C_UBIGINT:
  460.     return sizeof(longlong);
  461. #endif
  462.   }
  463. }
  465. /* convert a possible string to a data value */
  467. my_bool str_to_date(DATE_STRUCT *rgbValue, const char *str,uint length)
  468. {
  469.   uint field_length,year_length,digits,i,date[3];
  470.   const char *pos;
  471.   const char *end=str+length;
  472.   for (; !isdigit(*str) && str != end ; str++) ;
  473.   /*
  474.   ** calculate first number of digits.
  475.   ** If length= 4, 8 or >= 14 then year is of format YYYY
  476.      (YYYY-MM-DD,  YYYYMMDD)
  477.   */
  478.   for (pos=str; pos != end && isdigit(*pos) ; pos++) ;
  479.   digits= (uint) (pos-str);
  480.   year_length= (digits == 4 || digits == 8 || digits >= 14) ? 4 : 2;
  481.   field_length=year_length-1;
  483.   for (i=0 ; i < 3 && str != end; i++)
  484.   {
  485.     uint tmp_value=(uint) (uchar) (*str++ - '0');
  486.     while (str != end && isdigit(str[0]) && field_length--)
  487.     {
  488.       tmp_value=tmp_value*10 + (uint) (uchar) (*str - '0');
  489.       str++;
  490.     }
  491.     date[i]=tmp_value;
  492.     while (str != end && !isdigit(*str))
  493.       str++;
  494.     field_length=1; /* Rest fields can only be 2 */
  495.   }
  496.   if (i <= 1 || date[1] == 0) /* Wrong date */
  497.     return 1;
  498.   while (i < 3)
  499.     date[i++]=1;
  501.   rgbValue->year=date[0];
  502.   rgbValue->month=date[1];
  503.   rgbValue->day=date[2];
  504.   return 0;
  505. }
  508. /*****************************************************************************
  509. ** convert a time string to a (ulong) value.
  510. ** At least following formats are recogniced
  511. ** HHMMSS HHMM HH HH.MM.SS   {t HH:MM:SS }
  512. ** Return: HHMMSS
  513. *****************************************************************************/
  515. ulong str_to_time(const char *str,uint length)
  516. {
  517.   uint i,date[3];
  518.   const char *end=str+length;
  519.   for (; !isdigit(*str) && str != end ; str++) ;
  521.   for (i=0 ; i < 3 && str != end; i++)
  522.   {
  523.     uint tmp_value=(uint) (uchar) (*str++ - '0');
  524.     if (str != end && isdigit(str[0]))
  525.     {
  526.       tmp_value=tmp_value*10 + (uint) (uchar) (*str - '0');
  527.       str++;
  528.     }
  529.     date[i]=tmp_value;
  530.     while (str != end && !isdigit(*str))
  531.       str++;
  532.   }
  533.   while (i < 3)
  534.     date[i++]=0;
  535.   return (ulong) date[0]*10000L + (ulong) (date[1]*100+date[2]);
  536. }
  539. #ifndef _UNIX_
  541. /* Define functions that dosen't exist in a dll */
  543. /* _exit is called by safemalloc, mystatic & my_malloc */
  545. #ifndef WIN32
  546. void exit(int exit)
  547. {
  548. abort();
  549. }
  550. #endif
  552. /* perror is called by dbug.c */
  554. void perror(const char *str)
  555. {
  556. }
  558. /* clock is called by dbug.c when profiling */
  560. long clock(void)
  561. {
  562.   return 0L;
  563. }
  565. char *intern_filename(char *home_dir_buff,const char *home_dir)
  566. {
  567.   return "\"; /* only used by my_init */
  568. }
  570. #ifndef THREAD
  571. long getpid()
  572. {
  573.   return 0;
  574. }
  576. void my_init()
  577. {}
  578. #else
  579. int pthread_dummy(int return_value)
  580. {
  581.   return return_value;
  582. }
  583. #endif
  584. #endif /* IS NOT UNIX */