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

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

MySQL数据库

开发平台：

Visual C++

results.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. /*
  5. ** Returning results and information about results.
  6. */
  9. #include "myodbc.h"
  10. #include <m_ctype.h>
  11. #include <locale.h>
  13. #define digit(A) ((int) (A - '0'))
  15. RETCODE SQL_API sql_get_data(STMT *stm,SWORD fCType,MYSQL_FIELD *field,
  16.      PTR rgbValue,
  17.      SDWORD  cbValueMax, SDWORD FAR *pcbValue,
  18.      char *value,uint length);
  21. /*
  22. ** Execute the query if it is only prepared. This is needed because the ODBC
  23. ** standard allows calling some functions before SQLExecute(). (Stupid!)
  24. */
  26. static RETCODE check_result(STMT FAR *stmt)
  27. {
  28.   RETCODE error;
  29.   DBUG_ENTER("check_result");
  31.   switch (stmt->state) {
  32.   case ST_UNKNOWN:
  33.     error=set_error(stmt->dbc,"24000","Invalid cursor state",0);
  34.     break;
  35.   case ST_PREPARED:
  36.     if ((error=my_SQLExecute(stmt)) == SQL_SUCCESS)
  37.       stmt->state=ST_PRE_EXECUTED; /* mark for execute */
  38.     break;
  39.   case ST_PRE_EXECUTED:
  40.   case ST_EXECUTED:
  41.     error=SQL_SUCCESS;
  42.    }
  43.    DBUG_RETURN(error);
  44. }
  47. //      This returns the number of columns associated with the database
  48. //      attached to "hstmt".
  50. RETCODE SQL_API SQLNumResultCols(HSTMT  hstmt, SWORD FAR *pccol)
  51. {
  52.   RETCODE error;
  53.   STMT FAR *stmt=(STMT FAR*) hstmt;
  54.   DBUG_ENTER("SQLNumResultCols");
  56.   if ((error=check_result(stmt)) != SQL_SUCCESS)
  57.     DBUG_RETURN(error);
  58.   if (!stmt->result)
  59.     *pccol=0; /* Not a select */
  60.   else
  61.     *pccol=stmt->result->field_count;
  62.   DBUG_PRINT("exit",("columns: %d",*pccol));
  63.   DBUG_RETURN(SQL_SUCCESS);
  64. }
  67. //      Return information about the database column the user wants
  68. //      information about.
  70. RETCODE SQL_API SQLDescribeCol(HSTMT hstmt, UWORD icol, UCHAR FAR *szColName,
  71.        SWORD cbColNameMax, SWORD FAR *pcbColName,
  72.        SWORD FAR *pfSqlType, UDWORD FAR *pcbColDef,
  73.        SWORD FAR *pibScale, SWORD FAR *pfNullable)
  74. {
  75.   RETCODE error;
  76.   MYSQL_FIELD *field;
  77.   STMT FAR *stmt=(STMT FAR*) hstmt;
  78.   ulong transfer_length,precision,display_size;
  79.   int type;
  80.   DBUG_ENTER("SQLDescribeCol");
  82.   if ((error=check_result(stmt)) != SQL_SUCCESS)
  83.     DBUG_RETURN(error);
  84.   mysql_field_seek(stmt->result,icol-1);
  85.   if (!(field=mysql_fetch_field(stmt->result)))
  86.     DBUG_RETURN(set_error(stmt->dbc,"S1002","Invalid column number",0));
  87.   type=unireg_to_sql_datatype(stmt,field,0,&transfer_length,&precision,&display_size);
  88.   if (pfSqlType)
  89.     *pfSqlType=type;
  90.   if (pcbColDef)
  91.     *pcbColDef=precision;
  92.   if (pibScale)
  93.     *pibScale=field->decimals;
  94.   if (pfNullable)
  95.     *pfNullable= (field->flags & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) == NOT_NULL_FLAG ?
  96.                  SQL_NO_NULLS : SQL_NULLABLE;
  97.   DBUG_PRINT("info",("col: %d type: %d  precision: %ld  decimals: %d",
  98.                       icol,type,precision,field->decimals));
  99.   DBUG_RETURN(copy_result(stmt->dbc,szColName,cbColNameMax,pcbColName,
  100.   field->name));
  101. }
  105. //      Returns result column descriptor information for a result set.
  107. RETCODE SQL_API SQLColAttributes(HSTMT hstmt,UWORD icol,UWORD fDescType,
  108.  SQLPOINTER rgbDesc, SWORD cbDescMax,
  109.  SWORD FAR *pcbDesc, SDWORD FAR *pfDesc)
  110. {
  111.   MYSQL_FIELD *field;
  112.   STMT FAR *stmt=(STMT FAR*) hstmt;
  113.   SWORD dummy;
  114.   ulong transfer_length,precision,display_size;
  115.   RETCODE error;
  116.   DBUG_ENTER("SQLColAttributes");
  117.   DBUG_PRINT("enter",("type: %d",fDescType));
  119.   if (!pcbDesc)
  120.     pcbDesc= &dummy;
  122.   if ((error=check_result(stmt)) != SQL_SUCCESS)
  123.     DBUG_RETURN(error);
  124.   mysql_field_seek(stmt->result,icol-1);
  125.   if (!(field=mysql_fetch_field(stmt->result)))
  126.     DBUG_RETURN(set_error(stmt->dbc,"S1002","Invalid column number",0));
  128.   switch (fDescType) {
  129.   case SQL_COLUMN_COUNT:
  130.     *pfDesc= stmt->result->field_count;
  131.     *pcbDesc=sizeof(int);
  132.     break;
  133.   case SQL_COLUMN_LABEL:
  134.   case SQL_COLUMN_NAME:
  135.     DBUG_RETURN(copy_result(stmt->dbc,(uchar*) rgbDesc,cbDescMax,pcbDesc,
  136.     field->name));
  137.   case SQL_COLUMN_TYPE:
  138.     *pfDesc=unireg_to_sql_datatype(stmt,field,0,&transfer_length,&precision,
  139.    &display_size);
  140.     *pcbDesc=sizeof(int);
  141.     break;
  142.   case SQL_COLUMN_DISPLAY_SIZE:
  143.     (void) unireg_to_sql_datatype(stmt,field,0,&transfer_length,&precision,
  144.   &display_size);
  145.     *pfDesc=display_size;
  146.     *pcbDesc=sizeof(int);
  147.     break;
  148.   case SQL_COLUMN_PRECISION:
  149.     (void) unireg_to_sql_datatype(stmt,field,0,&transfer_length,&precision,
  150.   &display_size);
  151.     *pfDesc=precision;
  152.     *pcbDesc=sizeof(int);
  153.     break;
  154.   case SQL_COLUMN_LENGTH:
  155.     (void) unireg_to_sql_datatype(stmt,field,0,&transfer_length,&precision,
  156.   &display_size);
  157.     *pfDesc=transfer_length;
  158.     *pcbDesc=sizeof(int);
  159.     break;
  160.   case SQL_COLUMN_SCALE:
  161.     *pfDesc=field->decimals;
  162.     *pcbDesc=sizeof(int);
  163.     break;
  164.   case SQL_COLUMN_NULLABLE:
  165.     *pfDesc= (field->flags & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) == NOT_NULL_FLAG ?
  166.              SQL_NO_NULLS : SQL_NULLABLE;
  167.     *pcbDesc=sizeof(int);
  168.     break;
  169.   case SQL_COLUMN_SEARCHABLE:
  170.     *pfDesc= SQL_SEARCHABLE;
  171.     *pcbDesc=sizeof(int);
  172.     break;
  173.   case SQL_COLUMN_UNSIGNED:
  174.     if (pfDesc)
  175.       *pfDesc= field->flags & UNSIGNED_FLAG ? TRUE : FALSE;
  176.     *pcbDesc=sizeof(int);
  177.     break;
  178.   case SQL_COLUMN_MONEY:
  179.     *pfDesc=0;
  180.     break;
  181.   case SQL_COLUMN_AUTO_INCREMENT:
  182.     if (pfDesc)
  183.       *pfDesc= field->flags & AUTO_INCREMENT_FLAG ? TRUE : FALSE;
  184.     break;
  185.   case SQL_COLUMN_CASE_SENSITIVE:
  186.     *pfDesc= field->flags & BINARY_FLAG ? FALSE : TRUE;
  187.     *pcbDesc=sizeof(int);
  188.     break;
  189.   case SQL_COLUMN_UPDATABLE:
  190.     *pfDesc = (field->table && field->table[0] ? SQL_COLUMN_UPDATABLE :
  191.        SQL_ATTR_READONLY);
  192.     *pcbDesc= sizeof(int);
  193.     break;
  194.   case SQL_COLUMN_TYPE_NAME:
  195.   {
  196.     char buff[40];
  197.     (void) unireg_to_sql_datatype(stmt,field,buff,&transfer_length,&precision,&display_size);
  198.     DBUG_RETURN(copy_result(stmt->dbc,(uchar*) rgbDesc,cbDescMax,pcbDesc,
  199.     buff));
  200.   }
  201.   case SQL_COLUMN_OWNER_NAME:
  202.   case SQL_COLUMN_QUALIFIER_NAME:
  203.     DBUG_RETURN(copy_result(stmt->dbc,(uchar*) rgbDesc,cbDescMax,pcbDesc,""));
  204.   }
  205.   DBUG_RETURN(SQL_SUCCESS);
  206. }
  209. //      Associate a user-supplied buffer with a database column.
  211. RETCODE SQL_API SQLBindCol(HSTMT hstmt, UWORD icol, SWORD fCType, PTR rgbValue,
  212.    SDWORD  cbValueMax, SDWORD FAR *pcbValue)
  213. {
  214.   BIND *bind;
  215.   STMT FAR *stmt=(STMT FAR*) hstmt;
  216.   RETCODE error;
  217.   DBUG_ENTER("SQLBindCol");
  218.   DBUG_PRINT("enter",
  219.      ("icol: %d  Type: %d  ValueMax: %ld  Valueptr: %lx  Value: %ld",
  220.       icol,fCType,(long) cbValueMax,pcbValue,
  221.       (long) (pcbValue ? *pcbValue : 0L)));
  223.   icol--;
  224.   /*
  225.   ** The next case if because of VB 5.0 that binds columns before preparing
  226.   ** a statement
  227.   */
  229.   if (stmt->state == ST_UNKNOWN)
  230.   {
  231.     DBUG_PRINT("info",("Binding columns without a statement; Hope you know what you are doing"));
  232.     if (icol >= stmt->bound_columns)
  233.     {
  234.       if (!(stmt->bind=(BIND*) my_realloc((char*) stmt->bind,
  235.   (icol+1)*sizeof(BIND),
  236.   MYF(MY_ALLOW_ZERO_PTR |
  237.       MY_FREE_ON_ERROR))))
  238.       {
  239. stmt->bound_columns=0;
  240. DBUG_RETURN(set_error(stmt->dbc,"S1001","Not enough memory",4001));
  241.       }
  242.       bzero((gptr) (stmt->bind+stmt->bound_columns),
  243.     (icol+1-stmt->bound_columns)*sizeof(BIND));
  244.       stmt->bound_columns=icol+1;
  245.     }
  246.   }
  247.   else
  248.   {
  249.     /* Bind parameter to current set  ( The normal case ) */
  250.     if ((error=check_result(stmt)) != SQL_SUCCESS)
  251.       DBUG_RETURN(error);
  253.     if (!stmt->result || (uint) icol >= stmt->result->field_count)
  254.     {
  255.       DBUG_RETURN(set_error(stmt->dbc,"S1002","Invalid column number",0));
  256.     }
  257.     if (!stmt->bind)
  258.     {
  259.       if (!(stmt->bind=(BIND*) my_malloc(sizeof(BIND)*
  260.  stmt->result->field_count,
  261.  MYF(MY_ZEROFILL))))
  262. DBUG_RETURN(set_error(stmt->dbc,"S1001","Not enough memory",4001));
  263.       stmt->bound_columns=stmt->result->field_count;
  264.     }
  265.     mysql_field_seek(stmt->result,icol);
  266.     stmt->bind[icol].field=mysql_fetch_field(stmt->result);
  267.   }
  268.   bind=stmt->bind+icol;
  269.   bind->fCType=fCType;
  270.   if (fCType == SQL_C_DEFAULT && stmt->odbc_types)
  271.     bind->fCType=stmt->odbc_types[icol];
  272.   bind->rgbValue=rgbValue;
  273.   bind->cbValueMax=bind_length(bind->fCType,cbValueMax);
  274.   bind->pcbValue=pcbValue;
  275.   DBUG_RETURN(SQL_SUCCESS);
  276. }
  279. //      Returns data for bound columns in the current row ("stmt->iCursor"),
  280. //      advances the cursor.
  282. RETCODE SQL_API SQLFetch(HSTMT hstmt)
  283. {
  284.   MYSQL_ROW values;
  285.   RETCODE res,tmp_res;
  286.   STMT FAR *stmt=(STMT FAR*) hstmt;
  287.   DBUG_ENTER("SQLFetch");
  289.   if (!stmt->result)
  290.     DBUG_RETURN(set_error(stmt->dbc,"24000","Fetch without a SELECT",0));
  291.   if (stmt->result_array)
  292.   {
  293.     if (stmt->current_row >= stmt->result->row_count)
  294.       DBUG_RETURN(SQL_NO_DATA_FOUND);
  295.     values=stmt->result_array+(stmt->current_row++)*
  296.       stmt->result->field_count;
  297.   }
  298.   else
  299.   {
  300.     if (!(values=mysql_fetch_row(stmt->result)))
  301.       DBUG_RETURN(SQL_NO_DATA_FOUND);
  302.     stmt->current_row++; /* For SQLGetStmtOption */
  303.     if (stmt->fix_fields)
  304.       values=(*stmt->fix_fields)(stmt,values);
  305.     else
  306.       stmt->result_lengths=mysql_fetch_lengths(stmt->result);
  307.   }
  308.   stmt->current_values=values; /* For SQLGetData */
  309.   stmt->last_getdata_col= (uint) ~0;
  311.   res=SQL_SUCCESS;
  312.   if (stmt->bind)
  313.   {
  314.     uint *lengths=stmt->result_lengths;
  315.     BIND *bind,*end;
  317.     setlocale(LC_NUMERIC,"English"); /* force use of '.' as decimal point */
  318.     for (bind=stmt->bind,end=bind + stmt->result->field_count ;
  319.  bind < end ;
  320.  bind++,values++)
  321.     {
  322.       if (bind->rgbValue || bind->pcbValue)
  323.       {
  324. stmt->getdata_offset= (ulong) ~0L;
  325.   if ((tmp_res=sql_get_data(stmt,bind->fCType,bind->field,bind->rgbValue,
  326.   bind->cbValueMax,bind->pcbValue,
  327.   *values, lengths ? *lengths : *values ?
  328.   strlen(*values) : 0) )
  329.     != SQL_SUCCESS)
  330. {
  331.   if (tmp_res == SQL_SUCCESS_WITH_INFO)
  332.   {
  333.             DBUG_PRINT("info",("Problem with column: %d, value: '%s'",
  334.                                (int) (bind - stmt->bind)+1,
  335.        *values ? *values : "NULL"));
  336.             if (res == SQL_SUCCESS)
  337.       res= tmp_res;
  338.   }
  339.   else
  340.     res=SQL_ERROR;
  341. }
  342.       }
  343.       if (lengths)
  344. lengths++;
  345.     }
  346.     setlocale(LC_NUMERIC,default_locale);
  347.   }
  348.   stmt->getdata_offset= (ulong) ~0L;
  349.   DBUG_RETURN(res);
  350. }
  354. //  Returns result data for a single column in the current row.
  356. RETCODE SQL_API SQLGetData(HSTMT hstmt,UWORD icol,SWORD fCType,PTR rgbValue,
  357.    SDWORD cbValueMax, SDWORD FAR *pcbValue)
  358. {
  359.   STMT FAR *stmt=(STMT FAR*) hstmt;
  360.   RETCODE result;
  361.   DBUG_ENTER("SQLGetData");
  363.   if (!stmt->result || !stmt->current_values)
  364.   {
  365.     set_error(stmt->dbc,"24000","SQLGetData without a preceding SELECT",0);
  366.     DBUG_RETURN(SQL_ERROR);
  367.   }
  368.   icol--;   /* Easier code if start from 0 */
  369.   if (icol != stmt->last_getdata_col)
  370.   { /* New column. Reset old offset */
  371.     stmt->last_getdata_col=icol;
  372.     stmt->getdata_offset= (ulong) ~0L;
  373.   }
  375. #ifdef LOG_ALL
  376.   DBUG_PRINT("QQ",("icol: %d  fCType: %d  default: %d  value: %.10s",
  377.    icol+1,fCType,
  378.    stmt->odbc_types[icol],
  379.    (stmt->current_values[icol] ? stmt->current_values[icol] :
  380.     "NULL")));
  381. #endif
  382.   setlocale(LC_NUMERIC,"English");
  383.   result=sql_get_data(stmt,
  384.       (SWORD) (fCType == SQL_C_DEFAULT ?
  385.        stmt->odbc_types[icol] :
  386.        fCType),
  387.       stmt->result->fields+icol,
  388.       rgbValue,cbValueMax,pcbValue,
  389.       stmt->current_values[icol],
  390.       (stmt->result_lengths ? stmt->result_lengths[icol] :
  391.        (stmt->current_values[icol] ?
  392. strlen(stmt->current_values[icol]) : 0 )));
  393.   setlocale(LC_NUMERIC,default_locale);
  394.   DBUG_RETURN(result);
  395. }
  397. /*
  398. ** Get data.  rgbValue or pcbValue may be NULL pointers!
  399. */
  401. RETCODE SQL_API sql_get_data(STMT *stmt,SWORD fCType,MYSQL_FIELD *field,
  402.      PTR rgbValue, SDWORD  cbValueMax,
  403.      SDWORD FAR *pcbValue,
  404.      char *value, uint length)
  405. {
  406.   DBC *dbc=stmt->dbc;
  407.   long tmp;
  408.   if (!pcbValue)
  409.     pcbValue= &tmp; /* Easier code */
  411.   if (!value)
  412.   {
  413.     *pcbValue=SQL_NULL_DATA;
  414.   }
  415.   else switch (fCType) {
  416.   case SQL_C_BINARY:
  417.   case SQL_C_CHAR:
  418.   {
  419.     char buff[21];
  420.     if (field->type == FIELD_TYPE_TIMESTAMP && length != 19)
  421.     {
  422.       /* MySQL doesn't have '-' in timestamp */
  423.       /* Convert timestamp to ANSI format */
  425.       char *pos;
  426.       uint i;
  427.       if (length == 6 || length == 12) /* YYMMDD or YYMMDDHHMMSS timestamp */
  428.       {
  429. if (value[0] <= '6')
  430. {
  431.   buff[0]='2';
  432.   buff[1]='0';
  433. }
  434. else
  435. {
  436.   buff[0]='1';
  437.   buff[1]='9';
  438. }
  439.       }
  440.       else
  441.       {
  442. buff[0]=value[0];
  443. buff[1]=value[1];
  444. value+=2;
  445. length-=2;
  446.       }
  447.       buff[2]= *value++;
  448.       buff[3]= *value++;
  449.       buff[4]='-';
  450.       if (value[0] == '0' && value[1] == '0')
  451.       {
  452. *pcbValue=SQL_NULL_DATA; /* ODBC can't handle 0000-00-00 dates */
  453. break;
  454.       }
  455.       pos=buff+5;
  456.       length&= 30; /* Ensure that length is ok */
  457.       for (i=1, length-=2 ; (int) length > 0 ; length-=2,i++)
  458.       {
  459. *pos++= *value++;
  460. *pos++= *value++;
  461. *pos++= i < 2 ? '-' : (i == 2) ? ' ' : ':';
  462.       }
  463.       for ( ; pos != buff+20 ; i++)
  464.       {
  465. *pos++= '0';
  466. *pos++= '0';
  467. *pos++= i < 2 ? '-' : (i == 2) ? ' ' : ':';
  468.       }
  469.       value=buff;
  470.       length=19;
  471.     }
  472.     return copy_lresult(dbc,(char*) rgbValue,cbValueMax,pcbValue,value,
  473. length,stmt->stmt_options.max_length,
  474. field->type == FIELD_TYPE_STRING ? field->length : 0L,
  475. &stmt->getdata_offset);
  476.   }
  477.   case SQL_C_BIT:
  478.     if (rgbValue)
  479.       *((char*) rgbValue)= (atoi(value) == 0 ? 0 : 1);
  480.     *pcbValue=1;
  481.     break;
  482.   case SQL_C_TINYINT:
  483.   case SQL_C_STINYINT:
  484.     if (rgbValue)
  485.       *((char*) rgbValue)= ((char) atoi(value));
  486.     *pcbValue=1;
  487.     break;
  488.   case SQL_C_UTINYINT:
  489.     if (rgbValue)
  490.       *((uchar*) rgbValue)= ((uchar) (uint) atoi(value));
  491.     *pcbValue=1;
  492.     break;
  493.   case SQL_C_SHORT:
  494.   case SQL_C_SSHORT:
  495.     if (rgbValue)
  496.       *((short*) rgbValue)= (short) atoi(value);
  497.     *pcbValue=sizeof(short);
  498.     break;
  499.   case SQL_C_USHORT:
  500.     if (rgbValue)
  501.       *((ushort*) rgbValue)= (ushort) (uint) atol(value);
  502.     *pcbValue=sizeof(short);
  503.     break;
  504.   case SQL_C_LONG:
  505.   case SQL_C_SLONG:
  506.     if (rgbValue)
  507.       *((long*) rgbValue)= (long) atol(value);
  508.     *pcbValue=sizeof(long);
  509.     break;
  510.   case SQL_C_ULONG:
  511.     if (rgbValue)
  512.     {
  513.       char *end_ptr;
  514.       *((ulong*) rgbValue)= strtoul(value,&end_ptr,10);
  515.     }
  516.     *pcbValue=sizeof(long);
  517.     break;
  518.   case SQL_C_FLOAT:
  519.     if (rgbValue)
  520.       *((float*) rgbValue)= (float) atof(value);
  521.     *pcbValue=sizeof(float);
  522.     break;
  523.   case SQL_C_DOUBLE:
  524.     if (rgbValue)
  525.       *((double*) rgbValue)= (double) atof(value);
  526.     *pcbValue=sizeof(double);
  527.     break;
  528.   case SQL_C_DATE:
  529.   {
  530.     DATE_STRUCT tmp_date;
  531.     if (!rgbValue)
  532.       rgbValue=(char*) &tmp_date;
  533.     if (!str_to_date((DATE_STRUCT *) rgbValue,value,length))
  534.       *pcbValue=sizeof(DATE_STRUCT);
  535.     else
  536.     {
  537.       *pcbValue=SQL_NULL_DATA; /* ODBC can't handle 0000-00-00 dates */
  538.     }
  539.     break;
  540.   }
  541.   case SQL_C_TIME:
  542.   {
  543.     if (rgbValue)
  544.     {
  545.       ulong time=str_to_time(value,length);
  546.       TIME_STRUCT *time_info=(TIME_STRUCT *) rgbValue;
  547.       time_info->hour=  (UWORD) (time/10000);
  548.       time_info->minute=(UWORD) (time/100%100);
  549.       time_info->second=(UWORD) (time%100);
  550.     }
  551.     *pcbValue=sizeof(TIME_STRUCT);
  552.     break;
  553.   }
  554.   case SQL_C_TIMESTAMP:
  555.   {
  556.     uint year,length;
  557.     char buff[15],*to;
  558.     TIMESTAMP_STRUCT tmp_timestamp;
  559.     TIMESTAMP_STRUCT *time_stamp;
  560.     if (!rgbValue)
  561.       rgbValue= (char*) &tmp_timestamp;
  562.     time_stamp=(TIMESTAMP_STRUCT *) rgbValue;
  563.     for (to=buff ; *value && to < buff+sizeof(buff)-1 ; value++)
  564.     {
  565.       if (isdigit(*value))
  566. *to++ = *value;
  567.     }
  568.     length= (uint) (to-buff);
  569.     if (length == 6 || length == 12) /* YYMMDD or YYMMDDHHMMSS */
  570.     {
  571.       bmove_upp(to+2,to,length);
  572.       if (buff[0] <= '6')
  573.       {
  574. buff[0]='2';
  575. buff[1]='0';
  576.       }
  577.       else
  578.       {
  579. buff[0]='1';
  580. buff[1]='9';
  581.       }
  582.       length+=2;
  583.     }
  584.     if (length < 14)
  585.       strfill(to,14 - length,'0');
  586.     else
  587.       *to=0;
  588.     year=(digit(buff[0])*1000+digit(buff[1])*100+digit(buff[2])*10+
  589.   digit(buff[3]));
  590.     if (buff[4] == '0' && buff[5] == '0')
  591.       *pcbValue=SQL_NULL_DATA; /* ODBC can't handle 0000-00-00 dates */
  592.     else
  593.     {
  594.       time_stamp->year=   year;
  595.       time_stamp->month=  digit(buff[4])*10+digit(buff[5]);
  596.       time_stamp->day=    digit(buff[6])*10+digit(buff[7]);
  597.       time_stamp->hour=   digit(buff[8])*10+digit(buff[9]);
  598.       time_stamp->minute= digit(buff[10])*10+digit(buff[11]);
  599.       time_stamp->second= digit(buff[12])*10+digit(buff[13]);
  600.       time_stamp->fraction=0;
  601.       *pcbValue=sizeof(*time_stamp);
  602.     }
  603.     break;
  604.   }
  605. #if (ODBCVER >= 0x0300)
  606.   case SQL_C_SBIGINT:
  607.   {
  608.     if (rgbValue)
  609.       *((longlong*) rgbValue)= atoll(value);
  610.     *pcbValue=sizeof(longlong);
  611.     break;
  612.   }
  613.   case SQL_C_UBIGINT:
  614.   {
  615.     if (rgbValue)
  616.       *((ulonglong*) rgbValue)= (ulonglong) atoll(value);
  617.     *pcbValue=sizeof(ulonglong);
  618.     break;
  619.   }
  620. #endif
  621.   }
  622.   if (stmt->getdata_offset != (ulong) ~0L) /* Second call to getdata */
  623.   {
  624.     return SQL_NO_DATA_FOUND;
  625.   }
  626.   stmt->getdata_offset=0L; /* All data is retrevied */
  627.   return SQL_SUCCESS;
  628. }
  631. //  This determines whether there are more results sets available for
  632. //  the "hstmt".
  634. RETCODE SQL_API SQLMoreResults(HSTMT  hstmt)
  635. {
  636.   DBUG_ENTER("SQLMoreResults");
  637.   DBUG_RETURN(SQL_NO_DATA_FOUND);
  638. }
  641. //      This returns the number of rows affected byt an UPDATE, INSERT or
  642. // DELETE statement
  644. RETCODE SQL_API SQLRowCount(HSTMT hstmt, SDWORD FAR *pcrow)
  645. {
  646.   STMT FAR *stmt=(STMT FAR*) hstmt;
  647.   DBUG_ENTER("SQLRowCount");
  648.   if (stmt->result)
  649.   {
  650. *pcrow=mysql_num_rows(stmt->result);
  651. DBUG_PRINT("exit",("Rows in set: %ld",*pcrow));
  652.   }
  653.   else
  654.   {
  655. *pcrow=mysql_affected_rows(&stmt->dbc->mysql);
  656. DBUG_PRINT("exit",("Affected rows: %ld",*pcrow));
  657.   }
  658.   DBUG_RETURN(SQL_SUCCESS);
  659. }
  662. //      This positions the cursor within a block of data.
  664. RETCODE SQL_API SQLSetPos(HSTMT hstmt, UWORD irow, UWORD fRefresh, UWORD fLock)
  665. {
  666.   STMT FAR *stmt=(STMT FAR*) hstmt;
  667.   DBUG_ENTER("SQLSetPos");
  668.   if (!stmt->result || !stmt->rows_found_in_set)
  669.   {
  670.     set_error(stmt->dbc,"S1010",
  671.       "SQLSetPos without a preceding SQLExtendedFetch",0);
  672.     DBUG_RETURN(SQL_ERROR);
  673.   }
  674.   irow--;
  675.   if ((uint) irow >= stmt->rows_found_in_set)
  676.   {
  677.     DBUG_PRINT("error",("Tried to get irow: %d from a set of %d rows",
  678.                          irow,stmt->rows_found_in_set));
  679.     set_error(stmt->dbc,"S1107","SQLSetpos: Row is out of range",4000);
  680.     DBUG_RETURN(SQL_ERROR);
  681.   }
  682.   stmt->position_in_set=irow;
  683.   if (stmt->result_array)
  684.     stmt->current_values=stmt->result_array+((stmt->current_row+irow)*
  685.       stmt->result->field_count);
  686.   else
  687.   {
  688.     mysql_data_seek(stmt->result,stmt->current_row+irow);
  689.     stmt->current_values=mysql_fetch_row(stmt->result);
  690.     if (stmt->fix_fields)
  691.       stmt->current_values=(*stmt->fix_fields)(stmt,stmt->current_values);
  692.     else
  693.       stmt->result_lengths=mysql_fetch_lengths(stmt->result);
  694.   }
  695.   if (fLock || fRefresh)
  696.   {
  697.     set_error(stmt->dbc,"S1109",
  698.       "SQLSetPos with lock or refresh is not supported",4000);
  699.     DBUG_RETURN(SQL_ERROR);
  700.   }
  701.   DBUG_RETURN(SQL_SUCCESS);
  702. }
  705. //      This fetchs a block of data (rowset).
  707. RETCODE SQL_API SQLExtendedFetch(HSTMT hstmt, UWORD fFetchType, SDWORD irow,
  708.  UDWORD FAR *pcrow, UWORD FAR *rgfRowStatus)
  709. {
  710.   ulong cur_row,max_row,rows_to_fetch;
  711.   uint i;
  712.   RETCODE res,tmp_res;
  713.   STMT FAR *stmt=(STMT FAR*) hstmt;
  714.   MYSQL_ROW values;
  715.   MYSQL_ROW_OFFSET save_position;
  716.   DBUG_ENTER("SQLExtendedFetch");
  718.   if (!stmt->result)
  719.     DBUG_RETURN(set_error(stmt->dbc,"24000","Fetch without a SELECT",0));
  720.   DBUG_PRINT("enter",
  721.      ("fetchtype: %d  row: %ld  current top-row: %ld  rows_found: %ld",
  722.       fFetchType,irow,stmt->current_row,stmt->rows_found_in_set));
  724.   max_row=mysql_num_rows(stmt->result);
  725.   stmt->last_getdata_col=(uint)  ~0;
  726.   stmt->current_values=0; /* For SQLGetData */
  727.   stmt->position_in_set=0;
  729.   switch (fFetchType) {
  730.   case SQL_FETCH_NEXT:
  731.     cur_row=stmt->current_row+stmt->rows_found_in_set;
  732.     break;
  733.   case SQL_FETCH_PRIOR:
  734.     cur_row=stmt->current_row-stmt->stmt_options.rows_in_set;
  735.     break;
  736.   case SQL_FETCH_FIRST:
  737.     cur_row=0L;
  738.     break;
  739.   case SQL_FETCH_LAST:
  740.     cur_row=max_row-stmt->stmt_options.rows_in_set;
  741.     break;
  742.   case SQL_FETCH_ABSOLUTE:
  743.   if (irow == 0)
  744.   {
  745.     *pcrow=stmt->rows_found_in_set=0;
  746.     stmt->current_row=0; /* Fix for next fetch */
  747.     mysql_data_seek(stmt->result,0L);
  748.     DBUG_RETURN(SQL_NO_DATA_FOUND);
  749.   }
  750.   else if (irow < 0)
  751.   {
  752.     cur_row=(ulong) (max_row+irow);
  753.   }
  754.   else
  755.   {
  756.     cur_row=(ulong) irow-1;
  757.   }
  758.   break;
  759.   case SQL_FETCH_RELATIVE:
  760.     cur_row=(ulong) stmt->current_row +(ulong) irow;
  761.     break;
  762.   default:
  763.     DBUG_RETURN(set_error(stmt->dbc,"S1106","Fetch type out of range",0));
  764.   }
  766.   if ((long) cur_row < 0)
  767.   {
  768.     if (-((long) cur_row) >= (long) stmt->stmt_options.rows_in_set)
  769.     { /* Does not overlap start of set */
  770.       stmt->current_row=0; /* Fix for next fetch */
  771.       if (pcrow)
  772.         *pcrow=0;
  773.       stmt->rows_found_in_set=0;        /* Return nothing */
  774.       mysql_data_seek(stmt->result,0L);
  775.       DBUG_RETURN(SQL_NO_DATA_FOUND);
  776.     }
  777.     /* max_row= stmt->stmt_options.rows_in_set + cur_row; */
  778.     cur_row=0; /* Fix seek for overlapping start */
  779.   }
  780.   if (cur_row > max_row)
  781.     cur_row=max_row;
  782.   if (!stmt->result_array)
  783.   {
  784.     if (cur_row && cur_row == stmt->current_row + stmt->rows_found_in_set)
  785.       mysql_row_seek(stmt->result,stmt->end_of_set);
  786.     else
  787.       mysql_data_seek(stmt->result,cur_row);
  788.   }
  789.   stmt->current_row=cur_row;
  791.   rows_to_fetch=min(max_row-cur_row,stmt->stmt_options.rows_in_set);
  792.   if (!rows_to_fetch)
  793.   {
  794.     if (pcrow)
  795.       *pcrow=0;
  796.     stmt->rows_found_in_set=0;
  797.     DBUG_RETURN(SQL_NO_DATA_FOUND);
  798.   }
  800.   setlocale(LC_NUMERIC,"English");
  801.   res=SQL_SUCCESS;
  802.   for (i=0 ; i < rows_to_fetch ; i++)
  803.   {
  804.     if (stmt->result_array)
  805.     {
  806.       values=stmt->result_array+cur_row*stmt->result->field_count;
  807.       if (i == 0)
  808. stmt->current_values=values;
  809.     }
  810.     else
  811.     {
  812.       if (i == 0)
  813. save_position=mysql_row_tell(stmt->result);
  814.       if (!(values=mysql_fetch_row(stmt->result)))
  815.         break; /* This shouldn't never happen */
  816.       if (stmt->fix_fields)
  817. values=(*stmt->fix_fields)(stmt,values);
  818.       else
  819. stmt->result_lengths=mysql_fetch_lengths(stmt->result);
  820.       stmt->current_values=values;
  821.     }
  822.     if (rgfRowStatus)
  823.       rgfRowStatus[i]=SQL_ROW_SUCCESS;
  824.     if (stmt->bind)
  825.     { /* Should always be true */
  826.       uint *lengths=stmt->result_lengths;
  827.       BIND *bind,*end;
  828.       for (bind=stmt->bind,end=bind + stmt->result->field_count ;
  829.    bind < end ;
  830.    bind++,values++)
  831.       {
  832. if (bind->rgbValue || bind->pcbValue)
  833. {
  834.   ulong offset,pcb_offset;
  835.   if (stmt->stmt_options.bind_type == SQL_BIND_BY_COLUMN)
  836.   {
  837.     offset=bind->cbValueMax*i;
  838.     pcb_offset=sizeof(SDWORD)*i;
  839.   }
  840.   else
  841.     pcb_offset=offset=stmt->stmt_options.bind_type*i;
  842.   stmt->getdata_offset= (ulong) ~0L;
  843.   if ((tmp_res=sql_get_data(stmt,bind->fCType,
  844.     bind->field,
  845.     (bind->rgbValue ?
  846.      (char*) bind->rgbValue + offset : 0),
  847.     bind->cbValueMax,
  848.     (bind->pcbValue ?
  849.     (SDWORD*) ((char*) bind->pcbValue +
  850.        pcb_offset) : 0),
  851.      *values,
  852.     (lengths ? *lengths : *values ?
  853.      strlen(*values) : 0)))
  854.       != SQL_SUCCESS)
  855.   {
  856.     if (tmp_res == SQL_SUCCESS_WITH_INFO)
  857.     {
  858.       if (res == SQL_SUCCESS)
  859. res= tmp_res;
  860.     }
  861.     else
  862.       res=SQL_ERROR;
  863.   }
  864. }
  865. if (lengths)
  866.   lengths++;
  867.       }
  868.     }
  869.     cur_row++;
  870.   }
  871.   stmt->rows_found_in_set=i;
  872.   if (pcrow)
  873.     *pcrow=i;
  875.   if (rgfRowStatus)
  876.     for ( ; i < stmt->stmt_options.rows_in_set ; i++)
  877.       rgfRowStatus[i]=SQL_ROW_NOROW;
  879.   if (!stmt->result_array)
  880.   { /* read data from first row */
  881.     stmt->end_of_set=mysql_row_seek(stmt->result,save_position);
  882.     if (i > 1)
  883.     {
  884.       stmt->current_values=mysql_fetch_row(stmt->result);
  885.       if (stmt->fix_fields)
  886.         stmt->current_values=(*stmt->fix_fields)(stmt,stmt->current_values);
  887.       else
  888.         stmt->result_lengths=mysql_fetch_lengths(stmt->result);
  889.     }
  890.   }
  891.   setlocale(LC_NUMERIC,default_locale);
  892.   DBUG_RETURN(res);
  893. }
  896. //  Returns the next SQL error information.
  898. RETCODE SQL_API SQLError(HENV henv, HDBC hdbc, HSTMT hstmt,
  899.  UCHAR FAR *szSqlState, SDWORD FAR *pfNativeError,
  900.  UCHAR FAR *szErrorMsg, SWORD cbErrorMsgMax,
  901.  SWORD FAR *pcbErrorMsg)
  902. {
  903.   char *errmsg;
  904.   RETCODE error;
  905.   SWORD tmp_size;
  906.   DBUG_ENTER("SQLError");
  907.   DBUG_PRINT("enter",("szErrorMsg: %lx",szErrorMsg));
  909.   if (!pcbErrorMsg)
  910.     pcbErrorMsg= &tmp_size;
  911.   *pcbErrorMsg=0;
  912.   if (!hstmt && !hdbc)
  913.     goto no_error;
  914.   if (hstmt && !hdbc)
  915.     hdbc=(HDBC) ((STMT FAR*) hstmt)->dbc;
  916.   if (!(errmsg=mysql_error(&((DBC FAR*) hdbc)->mysql))[0])
  917.     goto no_error;
  918.   if (szSqlState)
  919.     strmov((char*) szSqlState,((DBC FAR*) hdbc)->sqlstate);
  920.   if (pfNativeError)
  921.     *pfNativeError=mysql_errno(&((DBC FAR*) hdbc)->mysql);
  922.   DBUG_PRINT("error",("Message: %s",errmsg));
  923.   if ((error=copy_result((DBC FAR*) 0,szErrorMsg,cbErrorMsgMax,pcbErrorMsg,
  924.        "[TCX][MyODBC]")) == SQL_SUCCESS)
  925.   {
  926.     int start_length= *pcbErrorMsg;
  927.     cbErrorMsgMax-= start_length;
  928.     szErrorMsg+=    start_length;
  929.     error=copy_result((DBC FAR*) 0,szErrorMsg,cbErrorMsgMax,pcbErrorMsg,
  930.      errmsg);
  931.     (*pcbErrorMsg)+= start_length;
  932.   }
  933.   errmsg[0]=0; /* Clear for next loop */
  934.   DBUG_RETURN(error);
  936. no_error:
  937.   if (cbErrorMsgMax)
  938.     *szErrorMsg=0;
  939.   if (pcbErrorMsg)
  940.     *pcbErrorMsg=0; /* Some extra safety */
  941.   if (szSqlState)
  942.     strmov(szSqlState,"00000");
  943.   DBUG_RETURN(SQL_NO_DATA_FOUND);
  944. }