/************************************************************************************

   Copyright (C) 2013, 2018 MariaDB Corporation AB

   This library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Library General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public

   License along with this library; if not see <http://www.gnu.org/licenses>

   or write to the Free Software Foundation, Inc., 

   51 Franklin St., Fifth Floor, Boston, MA 02110, USA

*************************************************************************************/

#include <ma_odbc.h>

#include <stdint.h>

#define MADB_FIELD_IS_BINARY(_field) ((_field)->charsetnr == BINARY_CHARSETNR)

void CloseMultiStatements(MADB_Stmt *Stmt)

{

  unsigned int i;

  for (i=0; i < STMT_COUNT(Stmt->Query); ++i)

  {

    MDBUG_C_PRINT(Stmt->Connection, "-->closing %0x", Stmt->MultiStmts[i]);

    if (Stmt->MultiStmts[i] != NULL)

    {

      mysql_stmt_close(Stmt->MultiStmts[i]);

    }

  }

  MADB_FREE(Stmt->MultiStmts);

  Stmt->stmt= NULL;

}

MYSQL_STMT* MADB_NewStmtHandle(MADB_Stmt *Stmt)

{

  static const my_bool UpdateMaxLength= 1;

  MYSQL_STMT* stmt= mysql_stmt_init(Stmt->Connection->mariadb);

  if (stmt != NULL)

  {

    mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &UpdateMaxLength);

  }

  else

  {

    MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);

  }

  return stmt;

}

/* Required, but not sufficient condition */

BOOL QueryIsPossiblyMultistmt(MADB_QUERY *Query)

{

  return Query->QueryType != MADB_QUERY_CREATE_PROC && Query->QueryType != MADB_QUERY_CREATE_FUNC &&

         Query->QueryType != MADB_QUERY_CREATE_DEFINER && Query->QueryType != MADB_NOT_ATOMIC_BLOCK;

}

/* Trims spaces and/or ';' at the end of query */

int SqlRtrim(char *StmtStr, int Length)

{

  if (Length > 0)

  {

    char *end= StmtStr + Length - 1;

    while (end > StmtStr && (isspace(0x000000ff & *end) || *end == ';'))

    {

      *end= '\0';

      --end;

      --Length;

    }

  }

  return Length;

}

/* Function assumes that the query is multistatement. And, e.g. STMT_COUNT(Stmt->Query) > 1 */

unsigned int GetMultiStatements(MADB_Stmt *Stmt, BOOL ExecDirect)

{

  int          i= 0;

  unsigned int MaxParams= 0;

  char        *p= Stmt->Query.RefinedText;

  Stmt->MultiStmtNr= 0;

  Stmt->MultiStmts= (MYSQL_STMT **)MADB_CALLOC(sizeof(MYSQL_STMT) * STMT_COUNT(Stmt->Query));

  while (p < Stmt->Query.RefinedText + Stmt->Query.RefinedLength)

  {

    Stmt->MultiStmts[i]= i == 0 ? Stmt->stmt : MADB_NewStmtHandle(Stmt);

    MDBUG_C_PRINT(Stmt->Connection, "-->inited&preparing %0x(%d,%s)", Stmt->MultiStmts[i], i, p);

    if (mysql_stmt_prepare(Stmt->MultiStmts[i], p, (unsigned long)strlen(p)))

    {

      MADB_SetNativeError(&Stmt->Error, SQL_HANDLE_STMT, Stmt->MultiStmts[i]);

      CloseMultiStatements(Stmt);

      /* Last paranoid attempt make sure that we did not have a parsing error.

         More to preserve "backward-compatibility" - we did this before, but before trying to

         prepare "multi-statement". */

      if (i == 0 && Stmt->Error.NativeError !=1295 /*ER_UNSUPPORTED_PS*/)

      {

        Stmt->stmt= MADB_NewStmtHandle(Stmt);

        if (mysql_stmt_prepare(Stmt->stmt, STMT_STRING(Stmt), (unsigned long)strlen(STMT_STRING(Stmt))))

        {

          MADB_STMT_CLOSE_STMT(Stmt);

        }

        else

        {

          MADB_DeleteSubqueries(&Stmt->Query);

          return 0;

        }

      }

      return 1;

    }

    if (mysql_stmt_param_count(Stmt->MultiStmts[i]) > MaxParams)

    {

      MaxParams= mysql_stmt_param_count(Stmt->MultiStmts[i]);

    }

    p+= strlen(p) + 1;

    ++i;

  }

  if (MaxParams)

  {

    Stmt->params= (MYSQL_BIND *)MADB_CALLOC(sizeof(MYSQL_BIND) * MaxParams);

  }

  return 0;

}

my_bool MADB_CheckPtrLength(SQLINTEGER MaxLength, char *Ptr, SQLINTEGER NameLen)

{

  if(!Ptr)

    return TRUE;

  if ((NameLen == SQL_NTS && strlen(Ptr) >(size_t) MaxLength) || NameLen > MaxLength)

    return FALSE;

  return TRUE;

}

int  MADB_GetWCharType(int Type)

{

  switch (Type) {

  case SQL_CHAR:

    return SQL_WCHAR;

  case SQL_VARCHAR:

    return SQL_WVARCHAR;

  case SQL_LONGVARCHAR:

    return SQL_WLONGVARCHAR;

  default:

    return Type;

  }

}

int MADB_KeyTypeCount(MADB_Dbc *Connection, char *TableName, int KeyFlag)

{

  int          Count= 0;

  unsigned int i;

  char         StmtStr[1024];

  char         *p= StmtStr;

  char         Database[65]= {'\0'};

  MADB_Stmt    *Stmt= NULL;

  MYSQL_FIELD  *Field;

  Connection->Methods->GetAttr(Connection, SQL_ATTR_CURRENT_CATALOG, Database, 65, NULL, FALSE);

  p+= _snprintf(p, 1024, "SELECT * FROM ");

  if (Database[0] != '\0')

  {

    p+= _snprintf(p, sizeof(StmtStr) - strlen(p), "`%s`.", Database);

  }

  p+= _snprintf(p, sizeof(StmtStr) - strlen(p), "%s LIMIT 0", TableName);

  if (MA_SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)Connection, (SQLHANDLE*)&Stmt) == SQL_ERROR ||

    Stmt->Methods->ExecDirect(Stmt, (char *)StmtStr, SQL_NTS) == SQL_ERROR ||

    Stmt->Methods->Fetch(Stmt) == SQL_ERROR)

  {

    goto end;

  }

  for (i=0; i < mysql_stmt_field_count(Stmt->stmt); i++)

  {

    Field= mysql_fetch_field_direct(Stmt->metadata, i);

    if (Field->flags & KeyFlag)

    {

      ++Count;

    }

  }

end:

  if (Stmt)

  {

    Stmt->Methods->StmtFree(Stmt, SQL_DROP);

  }

  return Count;

}

/* {{{ MADB_CheckODBCType */

BOOL MADB_CheckODBCType(SQLSMALLINT Type)

{

  switch(Type)

  {

  case SQL_C_CHAR:

  case SQL_C_WCHAR:

  case SQL_C_SSHORT:

  case SQL_C_SHORT:

  case SQL_C_USHORT:

  case SQL_C_SLONG:

  case SQL_C_LONG:

  case SQL_C_ULONG:

  case SQL_C_FLOAT:

  case SQL_C_DOUBLE:

  case SQL_C_BIT:

  case SQL_C_STINYINT:

  case SQL_C_TINYINT:

  case SQL_C_UTINYINT:

  case SQL_C_SBIGINT:

  case SQL_C_UBIGINT:

  case SQL_C_BINARY:

  case SQL_C_TYPE_DATE:

  case SQL_C_TYPE_TIME:

  case SQL_C_TYPE_TIMESTAMP:

  case SQL_C_NUMERIC:

#if (ODBCVER>=0x0350)

  case SQL_C_GUID:

#endif

  case SQL_C_DEFAULT:

    return TRUE;

  default:

    return FALSE;

  }

}

/* {{{ MADB_GetTypeFromConciseType */

SQLSMALLINT MADB_GetTypeFromConciseType(SQLSMALLINT ConciseType)

{

  switch (ConciseType)

  {

    /* todo: support for interval. currently we map only date/time types */

  case SQL_C_DATE:

  case SQL_C_TIME:

  case SQL_C_TIMESTAMP:

  case SQL_TYPE_DATE:

  case SQL_TYPE_TIME:

  case SQL_TYPE_TIMESTAMP:

    return SQL_DATETIME;

  case SQL_C_INTERVAL_YEAR:

  case SQL_C_INTERVAL_YEAR_TO_MONTH:

  case SQL_C_INTERVAL_MONTH:

  case SQL_C_INTERVAL_DAY:

  case SQL_C_INTERVAL_DAY_TO_HOUR:

  case SQL_C_INTERVAL_DAY_TO_MINUTE:

  case SQL_C_INTERVAL_DAY_TO_SECOND:

  case SQL_C_INTERVAL_HOUR:

  case SQL_C_INTERVAL_HOUR_TO_MINUTE:

  case SQL_C_INTERVAL_HOUR_TO_SECOND:

  case SQL_C_INTERVAL_MINUTE:

  case SQL_C_INTERVAL_MINUTE_TO_SECOND:

  case SQL_C_INTERVAL_SECOND:

      return SQL_INTERVAL;

  default:

    return ConciseType;

  }

}

/* }}} */

/* {{{ MADB_GetTypeName */

char *MADB_GetTypeName(MYSQL_FIELD *Field)

{

  switch(Field->type) {

  case MYSQL_TYPE_DECIMAL:

  case MYSQL_TYPE_NEWDECIMAL:

    return "decimal";

  case MYSQL_TYPE_NULL:

    return "null";

  case MYSQL_TYPE_TINY:

    return (Field->flags & NUM_FLAG) ? "tinyint" : "char";

  case MYSQL_TYPE_SHORT:

    return "smallint";

  case MYSQL_TYPE_LONG:

    return "integer";

  case MYSQL_TYPE_FLOAT:

    return "float";

  case MYSQL_TYPE_DOUBLE:

    return "double";

  case MYSQL_TYPE_TIMESTAMP:

    return "timestamp";

  case MYSQL_TYPE_LONGLONG:

    return "bigint";

  case MYSQL_TYPE_INT24:

    return "mediumint";

  case MYSQL_TYPE_DATE:

    return "date";

  case MYSQL_TYPE_TIME:

    return "time";

  case MYSQL_TYPE_DATETIME:

    return "datetime";

  case MYSQL_TYPE_YEAR:

    return "year";

  case MYSQL_TYPE_NEWDATE:

    return "date";

  case MYSQL_TYPE_VARCHAR:

  case MYSQL_TYPE_VAR_STRING:

    return MADB_FIELD_IS_BINARY(Field) ? "varbinary" : "varchar";

  case MYSQL_TYPE_BIT:

    return "bit";

  case MYSQL_TYPE_ENUM:

    return "enum";

  case MYSQL_TYPE_SET:

    return "set";

  case MYSQL_TYPE_TINY_BLOB:

    return MADB_FIELD_IS_BINARY(Field) ? "tinyblob" : "tinytext";

  case MYSQL_TYPE_MEDIUM_BLOB:

    return MADB_FIELD_IS_BINARY(Field) ? "mediumblob" : "mediumtext";

  case MYSQL_TYPE_LONG_BLOB:

    return MADB_FIELD_IS_BINARY(Field) ? "longblob" : "longtext";

  case MYSQL_TYPE_BLOB:

    return MADB_FIELD_IS_BINARY(Field) ? "blob" : "text";

  case MYSQL_TYPE_STRING:

    return MADB_FIELD_IS_BINARY(Field) ? "binary" : "char";

  case MYSQL_TYPE_GEOMETRY:

    return "geometry";

  default:

    return "";

  }

}

/* }}} */

MYSQL_RES *MADB_GetDefaultColumnValues(MADB_Stmt *Stmt, MYSQL_FIELD *fields)

{

  MADB_DynString DynStr;

  unsigned int i;

  MYSQL_RES *result= NULL;

  MADB_InitDynamicString(&DynStr, "SELECT COLUMN_NAME, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA='", 512, 512);

  if (MADB_DynstrAppend(&DynStr, fields[0].db) ||

      MADB_DynstrAppend(&DynStr, "' AND TABLE_NAME='") ||

      MADB_DynstrAppend(&DynStr, fields[0].org_table) ||

      MADB_DynstrAppend(&DynStr, "' AND COLUMN_NAME IN ("))

    goto error;

  for (i=0; i < mysql_stmt_field_count(Stmt->stmt); i++)

  {

    MADB_DescRecord *Rec= MADB_DescGetInternalRecord(Stmt->Ard, i, MADB_DESC_READ);

    if (!Rec->inUse || MADB_ColumnIgnoredInAllRows(Stmt->Ard, Rec) == TRUE)

    {

      continue;

    }

    if (MADB_DynstrAppend(&DynStr, i > 0 ? ",'" : "'") ||

      MADB_DynstrAppend(&DynStr, fields[i].org_name) ||

      MADB_DynstrAppend(&DynStr, "'"))

    {

      goto error;

    }

  }

  if (MADB_DynstrAppend(&DynStr, ") AND COLUMN_DEFAULT IS NOT NULL"))

    goto error;

  LOCK_MARIADB(Stmt->Connection);

  if (mysql_query(Stmt->Connection->mariadb, DynStr.str))

    goto error;

  result= mysql_store_result(Stmt->Connection->mariadb);

error:

    UNLOCK_MARIADB(Stmt->Connection);

    MADB_DynstrFree(&DynStr);

    return result;

}

char *MADB_GetDefaultColumnValue(MYSQL_RES *res, const char *Column)

{

  MYSQL_ROW row;

  if (res == NULL || !res->row_count)

    return NULL;

  mysql_data_seek(res, 0);

  while ((row= mysql_fetch_row(res)))

  {

    if (_stricmp(row[0], Column) == 0)

     return _strdup(row[1]);

  }

  return NULL;

}

SQLLEN MADB_GetDataSize(SQLSMALLINT SqlType, SQLLEN OctetLength, BOOL Unsigned,

                        SQLSMALLINT Precision, SQLSMALLINT Scale, unsigned int CharMaxLen)

{

  switch(SqlType)

  {

  case SQL_BIT:

    return 1;

  case SQL_TINYINT:

    return 3;

  case SQL_SMALLINT:

    return 5;

  case SQL_INTEGER:

    return 10;

  case SQL_BIGINT:

    return 20 - test(Unsigned != FALSE);

  case SQL_REAL:

    return 7;

  case SQL_DOUBLE:

  case SQL_FLOAT:

    return 15;

  case SQL_DECIMAL:

  case SQL_NUMERIC:

    return Precision;

  case SQL_TYPE_DATE:

    return SQL_DATE_LEN;

  case SQL_TYPE_TIME:

    return SQL_TIME_LEN + MADB_FRACTIONAL_PART(Scale);

  case SQL_TYPE_TIMESTAMP:

    return SQL_TIMESTAMP_LEN + MADB_FRACTIONAL_PART(Scale);

  case SQL_BINARY:

  case SQL_VARBINARY:

  case SQL_LONGVARBINARY:

    return OctetLength;

  case SQL_GUID:

    return 36;;

  default:

    {

      if (CharMaxLen < 2/*i.e.0||1*/)

      {

        return OctetLength;

      }

      else

      {

        return OctetLength/CharMaxLen;

      }

    }

  }

}

/* {{{ MADB_GetDisplaySize */

size_t MADB_GetDisplaySize(MYSQL_FIELD *Field, MARIADB_CHARSET_INFO *charset)

{

  /* Todo: check these values with output from mysql --with-columntype-info */

  switch (Field->type) {

  case MYSQL_TYPE_NULL:

    return 1;

  case MYSQL_TYPE_BIT:

    return (Field->length == 1) ? 1 : (Field->length + 7) / 8 * 2;

  case MYSQL_TYPE_TINY:

    return 4 - test(Field->flags & UNSIGNED_FLAG);

  case MYSQL_TYPE_SHORT:

  case MYSQL_TYPE_YEAR:

    return 6 - test(Field->flags & UNSIGNED_FLAG);

  case MYSQL_TYPE_INT24:

    return 9 - test(Field->flags & UNSIGNED_FLAG);

  case MYSQL_TYPE_LONG:

    return 11 - test(Field->flags & UNSIGNED_FLAG);

  case MYSQL_TYPE_LONGLONG:

    return 20;

  case MYSQL_TYPE_DOUBLE:

    return 15;

  case MYSQL_TYPE_FLOAT:

    return 7;

  case MYSQL_TYPE_DECIMAL:

  case MYSQL_TYPE_NEWDECIMAL:

  {

    /* The edge case like decimal(1,1)*/

    size_t Precision= Field->length - test((Field->flags & UNSIGNED_FLAG) == 0) - test(Field->decimals != 0);

    return Field->length + test(Precision == Field->decimals);

  }

  case MYSQL_TYPE_DATE:

    return SQL_DATE_LEN; /* YYYY-MM-DD */

  case MYSQL_TYPE_TIME:

    return SQL_TIME_LEN + MADB_FRACTIONAL_PART(Field->decimals); /* HH:MM:SS.ffffff */

  case MYSQL_TYPE_NEWDATE:

  case MYSQL_TYPE_TIMESTAMP:

  case MYSQL_TYPE_DATETIME:

    return SQL_TIMESTAMP_LEN + MADB_FRACTIONAL_PART(Field->decimals);

  case MYSQL_TYPE_BLOB:

  case MYSQL_TYPE_ENUM:

  case MYSQL_TYPE_GEOMETRY:

  case MYSQL_TYPE_LONG_BLOB:

  case MYSQL_TYPE_MEDIUM_BLOB:

  case MYSQL_TYPE_SET:

  case MYSQL_TYPE_STRING:

  case MYSQL_TYPE_TINY_BLOB:

  case MYSQL_TYPE_VARCHAR:

  case MYSQL_TYPE_VAR_STRING:

  {

    if (MADB_FIELD_IS_BINARY(Field))

    {

      return Field->length*2; /* ODBC specs says we should give 2 characters per byte to display binaray data in hex form */

    }

    else if (charset == NULL || charset->char_maxlen < 2/*i.e.0||1*/)

    {

      return Field->length;

    }

    else

    {

      return Field->length/charset->char_maxlen;

    }

  }

  default:

    return SQL_NO_TOTAL;

  }

}

/* }}} */

/* {{{ MADB_GetOctetLength */

size_t MADB_GetOctetLength(MYSQL_FIELD *Field, unsigned short MaxCharLen)

{

  size_t Length= MIN(MADB_INT_MAX32, Field->length);

  switch (Field->type) {

  case MYSQL_TYPE_NULL:

    return 1;

  case MYSQL_TYPE_BIT:

    return (Field->length + 7) / 8;

  case MYSQL_TYPE_TINY:

    return 1;

  case MYSQL_TYPE_YEAR:

  case MYSQL_TYPE_SHORT:

    return 2;

  case MYSQL_TYPE_INT24:

  case MYSQL_TYPE_LONG:

    return 4;

  case MYSQL_TYPE_LONGLONG:

    return 8;

  case MYSQL_TYPE_DOUBLE:

    return 8;

  case MYSQL_TYPE_FLOAT:

    return 4;

  case MYSQL_TYPE_DECIMAL:

  case MYSQL_TYPE_NEWDECIMAL:

  {

    /* The edge case like decimal(1,1)*/

    size_t Precision= Field->length - test((Field->flags & UNSIGNED_FLAG) == 0) - test(Field->decimals != 0);

    return Field->length + test(Precision == Field->decimals);

  }

  case MYSQL_TYPE_DATE:

    return sizeof(SQL_DATE_STRUCT);

  case MYSQL_TYPE_TIME:

    return sizeof(SQL_TIME_STRUCT);

   case MYSQL_TYPE_NEWDATE:

  case MYSQL_TYPE_TIMESTAMP:

  case MYSQL_TYPE_DATETIME:

    return sizeof(SQL_TIMESTAMP_STRUCT);

  case MYSQL_TYPE_BLOB:

  case MYSQL_TYPE_ENUM:

  case MYSQL_TYPE_GEOMETRY:

  case MYSQL_TYPE_LONG_BLOB:

  case MYSQL_TYPE_MEDIUM_BLOB:

  case MYSQL_TYPE_TINY_BLOB:

    return Length;

  case MYSQL_TYPE_SET:

  case MYSQL_TYPE_STRING:

  case MYSQL_TYPE_VARCHAR:

  case MYSQL_TYPE_VAR_STRING:

    return Length; /* Field->length is calculated using current charset */

  default:

    return SQL_NO_TOTAL;

  }

}

/* }}} */

/* {{{ MADB_GetDefaultType */

int MADB_GetDefaultType(int SQLDataType)

{

  switch(SQLDataType)

  {

  case SQL_BIGINT:

    return SQL_C_SBIGINT;

  case SQL_BINARY:

    return SQL_C_BINARY;

  case SQL_BIT:

    return SQL_C_BIT;

  case SQL_CHAR:

    return SQL_C_CHAR;

  case SQL_DATE:

  case SQL_TYPE_DATE:

    return SQL_C_DATE;

  case SQL_DECIMAL:

    return SQL_C_CHAR;

  case SQL_DOUBLE:

    return SQL_C_DOUBLE; 

  case SQL_FLOAT:

    return SQL_C_FLOAT;

  case SQL_INTEGER:

    return SQL_C_LONG;

  case SQL_LONGVARBINARY:

    return SQL_C_BINARY;

  case SQL_LONGVARCHAR:

    return SQL_C_CHAR;

  case SQL_NUMERIC:

    return SQL_C_CHAR;

  case SQL_REAL:

    return SQL_C_FLOAT;

  case SQL_SMALLINT:

    return SQL_C_SHORT;

  case SQL_TIME:

  case SQL_TYPE_TIME:

    return SQL_C_TIME;

  case SQL_TIMESTAMP:

  case SQL_TYPE_TIMESTAMP:

    return SQL_C_TIMESTAMP;

  case SQL_TINYINT:

    return SQL_C_TINYINT;

  case SQL_VARBINARY:

    return SQL_C_BINARY;

  case SQL_VARCHAR:

    return SQL_C_CHAR;

  default:

    return SQL_C_CHAR;

  }

}

/* }}} */

/* {{{ MapMariadDbToOdbcType */

       /* It's not quite right to mix here C and SQL types, even though constants are sort of equal */

SQLSMALLINT MapMariadDbToOdbcType(MYSQL_FIELD *field)

{

  switch (field->type) {

    case MYSQL_TYPE_BIT:

      if (field->length > 1)

        return SQL_BINARY;

      return SQL_BIT;

    case MYSQL_TYPE_NULL:

      return SQL_VARCHAR;

    case MYSQL_TYPE_TINY:

      return field->flags & NUM_FLAG ? SQL_TINYINT : SQL_CHAR;

    case MYSQL_TYPE_YEAR:

    case MYSQL_TYPE_SHORT:

      return SQL_SMALLINT;

    case MYSQL_TYPE_INT24:

    case MYSQL_TYPE_LONG:

      return SQL_INTEGER;

    case MYSQL_TYPE_FLOAT:

      return SQL_REAL;

    case MYSQL_TYPE_DOUBLE:

      return SQL_DOUBLE;

    case MYSQL_TYPE_TIMESTAMP:

    case MYSQL_TYPE_DATETIME:

      return SQL_TYPE_TIMESTAMP;

    case MYSQL_TYPE_NEWDATE:

    case MYSQL_TYPE_DATE:

      return SQL_TYPE_DATE;

    case MYSQL_TYPE_TIME:

       return SQL_TYPE_TIME;

    case MYSQL_TYPE_TINY_BLOB:

    case MYSQL_TYPE_BLOB:

    case MYSQL_TYPE_MEDIUM_BLOB:

    case MYSQL_TYPE_LONG_BLOB:

      return MADB_FIELD_IS_BINARY(field) ? SQL_LONGVARBINARY : SQL_LONGVARCHAR;

    case MYSQL_TYPE_LONGLONG:

      return SQL_BIGINT;

    case MYSQL_TYPE_STRING:

      return MADB_FIELD_IS_BINARY(field) ? SQL_BINARY : SQL_CHAR;

    case MYSQL_TYPE_VAR_STRING:

      return MADB_FIELD_IS_BINARY(field) ? SQL_VARBINARY : SQL_VARCHAR;

    case MYSQL_TYPE_SET:

    case MYSQL_TYPE_ENUM:

      return SQL_CHAR;

    case MYSQL_TYPE_GEOMETRY:

      return SQL_LONGVARBINARY;

    case MYSQL_TYPE_DECIMAL:

    case MYSQL_TYPE_NEWDECIMAL:

      return SQL_DECIMAL;

    default:

      return SQL_UNKNOWN_TYPE;

  }

}

/* }}} */

/* {{{ MADB_GetTypeLength */

size_t MADB_GetTypeLength(SQLINTEGER SqlDataType, size_t Length)

{

  switch(SqlDataType)

  {

  case SQL_C_BIT:

  case SQL_C_TINYINT:

  case SQL_C_STINYINT:

  case SQL_C_UTINYINT:

    return 1;

  case SQL_C_SHORT:

  case SQL_C_SSHORT:

  case SQL_C_USHORT:

    return 2;

  case SQL_C_LONG:

  case SQL_C_SLONG:

  case SQL_C_ULONG:

    return sizeof(SQLINTEGER);

  case SQL_C_UBIGINT:

  case SQL_C_SBIGINT:

    return sizeof(long long);

  case SQL_C_DOUBLE:

    return sizeof(SQLDOUBLE);

  case SQL_C_FLOAT:

    return sizeof(SQLFLOAT);

  case SQL_C_NUMERIC:

    return sizeof(SQL_NUMERIC_STRUCT);

  case SQL_C_TYPE_TIME:

  case SQL_C_TIME:

    return sizeof(SQL_TIME_STRUCT);

  case SQL_C_TYPE_DATE:

  case SQL_C_DATE:

    return sizeof(SQL_DATE_STRUCT);

  case SQL_C_TYPE_TIMESTAMP:

  case SQL_C_TIMESTAMP:

    return sizeof(SQL_TIMESTAMP_STRUCT);

  default:

    return Length;

  }

}

/* }}} */

/* {{{ MADB_GetMaDBTypeAndLength */

int MADB_GetMaDBTypeAndLength(SQLINTEGER SqlDataType, my_bool *Unsigned, unsigned long *Length)

{

  *Unsigned= 0;

  switch(SqlDataType)

  {

  case SQL_C_BIT:

  case SQL_C_TINYINT:

  case SQL_C_STINYINT:

  case SQL_C_UTINYINT:

    *Length= 1;

    *Unsigned= (SqlDataType == SQL_C_UTINYINT);

    return MYSQL_TYPE_TINY;

  case SQL_C_SHORT:

  case SQL_C_SSHORT:

  case SQL_C_USHORT:

    *Length= 2;

    *Unsigned= (SqlDataType == SQL_C_USHORT);

    return MYSQL_TYPE_SHORT;

  case SQL_C_LONG:

  case SQL_C_SLONG:

  case SQL_C_ULONG:

    *Length= sizeof(SQLINTEGER);

    *Unsigned= (SqlDataType == SQL_C_ULONG);

    return MYSQL_TYPE_LONG;

  case SQL_C_UBIGINT:

  case SQL_C_SBIGINT:

    *Length= sizeof(long long);

    *Unsigned= (SqlDataType == SQL_C_UBIGINT);

    return MYSQL_TYPE_LONGLONG;

  case SQL_C_DOUBLE:

    *Length= sizeof(SQLDOUBLE);

    return MYSQL_TYPE_DOUBLE;

  case SQL_C_FLOAT:

    *Length =sizeof(SQLFLOAT);

    return MYSQL_TYPE_FLOAT;

  case SQL_C_NUMERIC:

    /**Length= sizeof(SQL_NUMERIC_STRUCT);*/

    return MYSQL_TYPE_DECIMAL;

  case SQL_C_TYPE_TIME:

  case SQL_C_TIME:

    *Length= sizeof(SQL_TIME_STRUCT);

    return MYSQL_TYPE_TIME;

  case SQL_C_TYPE_DATE:

  case SQL_C_DATE:

    *Length= sizeof(SQL_DATE_STRUCT);

    return MYSQL_TYPE_DATE;

  case SQL_C_TYPE_TIMESTAMP:

  case SQL_C_TIMESTAMP:

    *Length= sizeof(SQL_TIMESTAMP_STRUCT);

    return MYSQL_TYPE_TIMESTAMP;

  case SQL_C_INTERVAL_HOUR_TO_MINUTE:

  case SQL_C_INTERVAL_HOUR_TO_SECOND:

    *Length= sizeof(SQL_INTERVAL_STRUCT);

    return MYSQL_TYPE_TIME;

  case SQL_C_CHAR:

    return MYSQL_TYPE_STRING;

  default:

    return MYSQL_TYPE_BLOB;

  }

}

/* }}} */

void MADB_CopyOdbcTsToMadbTime(SQL_TIMESTAMP_STRUCT *Src, MYSQL_TIME *Dst)

{

  Dst->year=        Src->year;

  Dst->month=       Src->month;

  Dst->day=         Src->day;

  Dst->hour=        Src->hour;

  Dst->minute=      Src->minute;

  Dst->second=      Src->second;

  Dst->second_part= Src->fraction / 1000;

}

void MADB_CopyMadbTimeToOdbcTs(MYSQL_TIME *Src, SQL_TIMESTAMP_STRUCT *Dst)

{

  Dst->year=        Src->year;

  Dst->month=       Src->month;

  Dst->day=         Src->day;

  Dst->hour=        Src->hour;

  Dst->minute=      Src->minute;

  Dst->second=      Src->second;

  Dst->fraction=    Src->second_part*1000;

}

SQLRETURN MADB_CopyMadbTimestamp(MADB_Stmt *Stmt, MYSQL_TIME *tm, SQLPOINTER DataPtr, SQLLEN *Length, SQLLEN *Ind,

                                 SQLSMALLINT CType, SQLSMALLINT SqlType)

{

  SQLLEN Dummy;

  Length= Length == NULL ? &Dummy : Length;

  switch(CType)

  {

    case SQL_C_TIMESTAMP:

    case SQL_C_TYPE_TIMESTAMP:

    {

      SQL_TIMESTAMP_STRUCT *ts= (SQL_TIMESTAMP_STRUCT *)DataPtr;

      if (ts != NULL)

      {

        /* If time converted to timestamp - fraction is set to 0, date is set to current date */

        if (SqlType == SQL_TIME || SqlType == SQL_TYPE_TIME)

        {

          time_t sec_time;

          struct tm * cur_tm;

          sec_time= time(NULL);

          cur_tm= localtime(&sec_time);

          ts->year= 1900 + cur_tm->tm_year;

          ts->month= cur_tm->tm_mon + 1;

          ts->day= cur_tm->tm_mday;

          ts->fraction= 0;

        }

        else

        {

          ts->year= tm->year;

          ts->month= tm->month;

          ts->day= tm->day;

          ts->fraction= tm->second_part * 1000;

        }

        ts->hour= tm->hour;

        ts->minute= tm->minute;

        ts->second= tm->second;

        if (ts->year + ts->month + ts->day + ts->hour + ts->minute + ts->fraction + ts->second == 0)

        {

          if (Ind != NULL)

          {

            *Ind= SQL_NULL_DATA;

          }

          else

          {

            return MADB_SetError(&Stmt->Error, MADB_ERR_22002, NULL, 0);

          }

          break;

        }

      }

      *Length= sizeof(SQL_TIMESTAMP_STRUCT);

    }

    break;

    case SQL_C_TIME:

    case SQL_C_TYPE_TIME:

    {

      SQL_TIME_STRUCT *ts= (SQL_TIME_STRUCT *)DataPtr;

      if (ts != NULL)

      {

        /* tm(buffer from MYSQL_BIND) can be NULL. And that happens if ts(app's buffer) is null */

        if (!VALID_TIME(tm))

        {

          return MADB_SetError(&Stmt->Error, MADB_ERR_22007, NULL, 0);

        }

        ts->hour= tm->hour;

        ts->minute= tm->minute;

        ts->second= tm->second;

        *Length= sizeof(SQL_TIME_STRUCT);

        if (tm->second_part)