Merge lp:~linuxjedi/libdrizzle/5.1-api-fixes into lp:libdrizzle

[Andrew Hutchings]

Fixups in many areas of the API

=== modified file 'cli/drizzle_binlogs.c'
--- cli/drizzle_binlogs.c	2012-12-28 23:07:33 +0000
+++ cli/drizzle_binlogs.c	2013-01-05 11:52:22 +0000
@@ -138,7 +138,7 @@
 drizzle_st *_connect(void);
 FILE *create_binlog_file(char *binlog_file);
 void get_binlogs(drizzle_st *con);
-void write_binlog(FILE* file, const uint8_t* data, uint32_t len);
+void write_binlog(FILE* file, const unsigned char* data, uint32_t len);
 
 bool get_system_user(char *dest, uint8_t len)
 {
@@ -236,7 +236,7 @@
 
   while(1)
   {
-    write_binlog(outfile, (uint8_t *)DRIZZLE_BINLOG_MAGIC, 4);
+    write_binlog(outfile, (unsigned char *)DRIZZLE_BINLOG_MAGIC, 4);
     while(1)
     {
       ret= drizzle_binlog_get_next_event(result);
@@ -274,7 +274,7 @@
   drizzle_result_free(result);
 }
 
-void write_binlog(FILE* file, const uint8_t* data, uint32_t len)
+void write_binlog(FILE* file, const unsigned char* data, uint32_t len)
 {
   if (len)
   {
 
=== modified file 'docs/api/binlog.rst'
--- docs/api/binlog.rst	2012-12-22 08:54:15 +0000
+++ docs/api/binlog.rst	2013-01-05 11:52:22 +0000
@@ -83,14 +83,14 @@
    :param result: The result set for the binlog stream
    :returns: The extra event flags
 
-.. c:function:: const uint8_t* drizzle_binlog_event_data(drizzle_result_st *result)
+.. c:function:: const unsigned char* drizzle_binlog_event_data(drizzle_result_st *result)
 
    Get the event data for the event received using :c:func:`drizzle_binlog_get_next_event`
 
    :param result: The result set for the binlog stream
    :returns: A pointer to the event data
 
-.. c:function:: const uint8_t *drizzle_binlog_event_raw_data(drizzle_result_st *result)
+.. c:function:: const unsigned char* drizzle_binlog_event_raw_data(drizzle_result_st *result)
 
    Get the raw event data (including header) for the event received using :c:func:`drizzle_binlog_get_next_event`
 
 
=== modified file 'docs/api/connection.rst'
--- docs/api/connection.rst	2013-01-04 20:47:22 +0000
+++ docs/api/connection.rst	2013-01-05 11:52:22 +0000
@@ -229,14 +229,13 @@
    :param con: A connection object
    :returns: A :c:type:`drizzle_return_t` response for the quit command sent to the server
 
-.. c:function:: drizzle_result_st* drizzle_select_db(drizzle_st *con, const char *db, drizzle_return_t *ret_ptr)
+.. c:function:: drizzle_return_t drizzle_select_db(drizzle_st *con, const char *db)
 
    Change the current default database
 
    :param con: A connection object
    :param db: The new default database
-   :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into
-   :returns: A newly allocated result object
+   :returns: A :c:type:`drizzle_return_t` response
 
 .. c:function:: drizzle_result_st* drizzle_shutdown(drizzle_st *con, drizzle_return_t *ret_ptr)
 
 
=== modified file 'docs/api/constants.rst'
--- docs/api/constants.rst	2012-12-23 14:57:06 +0000
+++ docs/api/constants.rst	2013-01-05 11:52:22 +0000
@@ -156,6 +156,26 @@
 
       No more data to retrieve
 
+   .. py:data:: DRIZZLE_RETURN_STMT_ERROR
+
+      A prepared statment error has occurred
+
+   .. py:data:: DRIZZLE_RETURN_BINLOG_CRC
+
+      A checksum error has occurred in a MySQL 5.6 binlog
+
+   .. py:data:: DRIZZLE_RETURN_TRUNCATED
+
+      The result has been truncated
+
+   .. py:data:: DRIZZLE_RETURN_INVALID_CONVERSION
+
+      The data type cannot be converted into the requested type
+
+   .. py:data:: DRIZZLE_RETURN_NOT_FOUND
+
+      The requested column was not found
+
 Connection
 ----------
 
@@ -1050,14 +1070,18 @@
 
       RBR Delete rows event for MySQL 5.1 pre-release
 
-   .. py:data:: DRIZZLE_EVENT_TYPE_WRITE_ROWS
+   .. py:data:: DRIZZLE_EVENT_TYPE_V1_WRITE_ROWS
 
       RBR Write rows event
 
-   .. py:data:: DRIZZLE_EVENT_TYPE_UPDATE_ROWS
+   .. py:data:: DRIZZLE_EVENT_TYPE_V1_UPDATE_ROWS
 
       RBR Update rows event
 
+   .. py:data:: DRIZZLE_EVENT_TYPE_V1_DELETE_ROWS
+
+      RBR Delete rows event
+
    .. py:data:: DRIZZLE_EVENT_TYPE_INCIDENT
 
       Replication incident message
@@ -1066,4 +1090,25 @@
 
       Repliaction heartbeat event
 
+   .. py:data:: DRIZZLE_EVENT_TYPE_IGNORABLE
+
+   .. py:data:: DRIZZLE_EVENT_TYPE_ROWS_QUERY
+
+   .. py:data:: DRIZZLE_EVENT_TYPE_V2_WRITE_ROWS
+
+      A MySQL 5.6 RBR Write rows event
+
+   .. py:data:: DRIZZLE_EVENT_TYPE_V2_UPDATE_ROWS
+
+      A MySQL 5.6 RBR Update rows event
+
+   .. py:data:: DRIZZLE_EVENT_TYPE_V2_DELETE_ROWS
+
+      A MySQL 5.6 RBR Delete rows event
+
+   .. py:data:: DRIZZLE_EVENT_TYPE_GTID
+
+   .. py:data:: DRIZZLE_EVENT_TYPE_ANONYMOUS_GTID
+
+   .. py:data:: DRIZZLE_EVENT_TYPE_PREVIOUS_GTIDS
 
 
=== modified file 'docs/api/query.rst'
--- docs/api/query.rst	2012-12-22 08:54:15 +0000
+++ docs/api/query.rst	2013-01-05 11:52:22 +0000
@@ -51,7 +51,7 @@
    :param from_size: the length of the source string
    :returns: the length of the 'to' string or -1 upon error due to empty parameters or overflow
 
-.. c:function:: bool drizzle_hex_string(char *to, const uint8_t *from, const size_t from_size)
+.. c:function:: bool drizzle_hex_string(char *to, const unsigned char *from, const size_t from_size)
 
    Convert data into a hexadecimal string of the data.
 
@@ -269,7 +269,7 @@
    :param column: A column object
    :returns: The number of decimal places
 
-.. c:function:: const uint8_t* drizzle_column_default_value(drizzle_column_st *column, size_t *size)
+.. c:function:: const unsigned char* drizzle_column_default_value(drizzle_column_st *column, size_t *size)
 
    Gets the default value for a given column
 
 
=== modified file 'docs/api/statement.rst'
--- docs/api/statement.rst	2013-01-04 20:47:22 +0000
+++ docs/api/statement.rst	2013-01-05 11:52:22 +0000
@@ -130,7 +130,7 @@
    :param stmt: The prepared statement object
    :returns: A return status code, :py:const:`DRIZZLE_RETURN_OK` upon success
 
-.. c:function:: drizzle_return_t drizzle_stmt_send_long_data(drizzle_stmt_st *stmt, uint16_t param_num, uint8_t *data, size_t len)
+.. c:function:: drizzle_return_t drizzle_stmt_send_long_data(drizzle_stmt_st *stmt, uint16_t param_num, unsigned char *data, size_t len)
 
    Send long binary data packet
 
@@ -171,6 +171,15 @@
    :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into
    :returns: True if NULL
 
+.. c:function:: bool drizzle_stmt_get_is_null_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
+
+   Check if a column for a fetched row is set to NULL using a column name
+
+   :param stmt: The prepared statement object
+   :param column_name: The column name to get
+   :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into, :py:const:`DRIZZLE_RETURN_NOT_FOUND` if the column name cannot be found
+   :returns: True if NULL
+
 .. c:function:: bool drizzle_stmt_get_is_unsigned(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr)
 
    Check if a column for a fetched row is unsigned
@@ -180,6 +189,15 @@
    :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into
    :returns: True if unsigned
 
+.. c:function:: bool drizzle_stmt_get_is_unsigned_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
+
+   Check if a column for a fetched row is unsigned using a column name
+
+   :param stmt: The prepared statement object
+   :param column_name: The column name to get
+   :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into, :py:const:`DRIZZLE_RETURN_NOT_FOUND` if the column name cannot be found
+   :returns: True if unsigned
+
 .. c:function:: const char *drizzle_stmt_get_string(drizzle_stmt_st *stmt, uint16_t column_number, size_t *len, drizzle_return_t *ret_ptr)
 
    Get the string value for a column of a fetched row (int types are automatically converted)
@@ -190,6 +208,16 @@
    :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into
    :returns: A pointer to the string value
 
+.. c:function:: const char *drizzle_stmt_get_string_from_name(drizzle_stmt_st *stmt, const char *column_name, size_t *len, drizzle_return_t *ret_ptr)
+
+   Get the string value for a column of a fetched row (int types are automatically converted) using a column name
+
+   :param stmt: The prepared statement object
+   :param column_name: The column name to get
+   :param len: A pointer to a :c:type:`size_t` to store the result length into
+   :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into, :py:const:`DRIZZLE_RETURN_NOT_FOUND` if the column name cannot be found
+   :returns: A pointer to the string value
+
 .. c:function:: uint32_t drizzle_stmt_get_int(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr)
 
    Get the int value for a column of a fetched row
@@ -199,6 +227,15 @@
    :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into :py:const:`DRIZZLE_RETURN_TRUNCATED` if a truncation has occurred
    :returns: The int value
 
+.. c:function:: uint32_t drizzle_stmt_get_int_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
+
+   Get the int value for a column of a fetched row using a column name
+
+   :param stmt: The prepared statement object
+   :param column_name: The column name to get
+   :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into :py:const:`DRIZZLE_RETURN_TRUNCATED` if a truncation has occurred,  :py:const:`DRIZZLE_RETURN_NOT_FOUND` if the column name cannot be found
+   :returns: The int value
+
 .. c:function:: uint64_t drizzle_stmt_get_bigint(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr)
 
    Get the bigint value for a column of a fetched row
@@ -208,6 +245,15 @@
    :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into :py:const:`DRIZZLE_RETURN_TRUNCATED` if a truncation has occurred
    :returns: The bigint value
 
+.. c:function:: uint64_t drizzle_stmt_get_bigint_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
+
+   Get the bigint value for a column of a fetched row using a column name
+
+   :param stmt: The prepared statement object
+   :param column_name: The column name to get
+   :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into :py:const:`DRIZZLE_RETURN_TRUNCATED` if a truncation has occurred,  :py:const:`DRIZZLE_RETURN_NOT_FOUND` if the column name cannot be found
+   :returns: The bigint value
+
 .. c:function:: double drizzle_stmt_get_double(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr)
 
    Get the double value for a column of a fetched row
@@ -217,6 +263,15 @@
    :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into :py:const:`DRIZZLE_RETURN_TRUNCATED` if a truncation has occurred
    :returns: The double value
 
+.. c:function:: double drizzle_stmt_get_double_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
+
+   Get the double value for a column of a fetched row from a column name
+
+   :param stmt: The prepared statement object
+   :param column_name: The column name to get
+   :param ret_ptr: A pointer to a :c:type:`drizzle_return_t` to store the return status into :py:const:`DRIZZLE_RETURN_TRUNCATED` if a truncation has occurred, :py:const:`DRIZZLE_RETURN_NOT_FOUND` if the column name cannot be found
+   :returns: The double value
+
 .. c:function:: drizzle_return_t drizzle_stmt_close(drizzle_stmt_st *stmt)
 
    Close and free a prepared statement
 
=== modified file 'docs/api/structs.rst'
--- docs/api/structs.rst	2012-12-23 14:44:44 +0000
+++ docs/api/structs.rst	2013-01-05 11:52:22 +0000
@@ -19,41 +19,7 @@
 
 .. c:type:: drizzle_datetime_st
 
-   The struct for passing a date/time to/from the prepared statement API
-
-   .. c:member:: uint16_t year
-
-      The year part of the date
-
-   .. c:member:: uint8_t month
-
-      The month part of the date
-
-   .. c:member:: uint32_t day
-
-      The day part of the date
-
-   .. c:member:: uint16_t hour
-
-      The hour part of the time
-
-   .. c:member:: uint8_t minute
-
-      The minute part of the time
-
-   .. c:member:: uint8_t second
-
-      The second part of the time
-
-   .. c:member:: uint32_t microsecond
-
-      The microsecond part of the time
-
-   .. c:member:: bool negative
-
-      Is the time negative
-
-
+   The internal struct for passing a date/time to/from the prepared statement API
 Binlog
 ------
 
 
=== modified file 'docs/examples/binlog.rst'
--- docs/examples/binlog.rst	2012-12-24 10:20:04 +0000
+++ docs/examples/binlog.rst	2013-01-05 11:52:22 +0000
@@ -38,7 +38,7 @@
       while (ret == DRIZZLE_RETURN_OK)
       {
         uint32_t i, length;
-        const uint8_t *data;
+        const unsigned char *data;
         ret= drizzle_binlog_get_event(result);
         if (ret != DRIZZLE_RETURN_OK)
           break;
 
=== modified file 'libdrizzle-5.1/binlog.h'
--- libdrizzle-5.1/binlog.h	2012-12-31 00:19:49 +0000
+++ libdrizzle-5.1/binlog.h	2013-01-05 11:52:22 +0000
@@ -73,10 +73,10 @@
 uint16_t drizzle_binlog_event_extra_flags(drizzle_result_st *result);
 
 DRIZZLE_API
-const uint8_t *drizzle_binlog_event_data(drizzle_result_st *result);
+const unsigned char *drizzle_binlog_event_data(drizzle_result_st *result);
 
 DRIZZLE_API
-const uint8_t *drizzle_binlog_event_raw_data(drizzle_result_st *result);
+const unsigned char *drizzle_binlog_event_raw_data(drizzle_result_st *result);
 
 DRIZZLE_API
 uint32_t drizzle_binlog_event_raw_length(drizzle_result_st *result);
 
=== modified file 'libdrizzle-5.1/column.h'
--- libdrizzle-5.1/column.h	2012-12-30 11:18:18 +0000
+++ libdrizzle-5.1/column.h	2013-01-05 11:52:22 +0000
@@ -145,7 +145,7 @@
  * Get default value for a column.
  */
 DRIZZLE_API
-const uint8_t *drizzle_column_default_value(drizzle_column_st *column,
+const unsigned char *drizzle_column_default_value(drizzle_column_st *column,
                                             size_t *size);
 
 /** @} */
 
=== modified file 'libdrizzle-5.1/conn.h'
--- libdrizzle-5.1/conn.h	2012-12-30 11:18:18 +0000
+++ libdrizzle-5.1/conn.h	2013-01-05 11:52:22 +0000
@@ -307,7 +307,7 @@
  * @return Scramble buffer for connection.
  */
 DRIZZLE_API
-const uint8_t *drizzle_scramble(const drizzle_st *con);
+const unsigned char *drizzle_scramble(const drizzle_st *con);
 
 /**
  * Get capabilities for a connection.
 
=== modified file 'libdrizzle-5.1/conn_client.h'
--- libdrizzle-5.1/conn_client.h	2012-12-29 21:44:53 +0000
+++ libdrizzle-5.1/conn_client.h	2013-01-05 11:52:22 +0000
@@ -83,9 +83,8 @@
  *  failure this will be NULL.
  */
 DRIZZLE_API
-drizzle_result_st *drizzle_select_db(drizzle_st *con,
-                                         const char *db,
-                                         drizzle_return_t *ret_ptr);
+drizzle_return_t drizzle_select_db(drizzle_st *con,
+                                         const char *db);
 
 /**
  * Send a shutdown message to the server.
 
=== modified file 'libdrizzle-5.1/query.h'
--- libdrizzle-5.1/query.h	2012-12-22 08:54:15 +0000
+++ libdrizzle-5.1/query.h	2013-01-05 11:52:22 +0000
@@ -90,7 +90,7 @@
 ssize_t drizzle_escape_string(char *to, const size_t max_to_size, const char *from, const size_t from_size);
 
 DRIZZLE_API
-bool drizzle_hex_string(char *to, const uint8_t *from, const size_t from_size);
+bool drizzle_hex_string(char *to, const unsigned char *from, const size_t from_size);
 
 DRIZZLE_API
 bool drizzle_mysql_password_hash(char *to, const char *from, const size_t from_size);
 
=== modified file 'libdrizzle-5.1/return.h'
--- libdrizzle-5.1/return.h	2012-12-30 20:08:04 +0000
+++ libdrizzle-5.1/return.h	2013-01-05 11:52:22 +0000
@@ -73,6 +73,7 @@
   DRIZZLE_RETURN_BINLOG_CRC,
   DRIZZLE_RETURN_TRUNCATED,
   DRIZZLE_RETURN_INVALID_CONVERSION,
+  DRIZZLE_RETURN_NOT_FOUND,
   DRIZZLE_RETURN_MAX /* Always add new codes to the end before this one. */
 };
 
 
=== modified file 'libdrizzle-5.1/statement.h'
--- libdrizzle-5.1/statement.h	2012-12-31 09:54:55 +0000
+++ libdrizzle-5.1/statement.h	2013-01-05 11:52:22 +0000
@@ -48,7 +48,7 @@
 drizzle_return_t drizzle_stmt_execute(drizzle_stmt_st *stmt);
 
 DRIZZLE_API
-drizzle_return_t drizzle_stmt_send_long_data(drizzle_stmt_st *stmt, uint16_t param_num, uint8_t *data, size_t len);
+drizzle_return_t drizzle_stmt_send_long_data(drizzle_stmt_st *stmt, uint16_t param_num, unsigned char *data, size_t len);
 
 DRIZZLE_API
 drizzle_return_t drizzle_stmt_reset(drizzle_stmt_st *stmt);
@@ -108,23 +108,41 @@
 drizzle_return_t drizzle_stmt_set_timestamp(drizzle_stmt_st *stmt, uint16_t param_num, uint16_t year, uint8_t month, uint8_t day, uint8_t hours, uint8_t minutes, uint8_t seconds, uint32_t microseconds);
 
 DRIZZLE_API
+bool drizzle_stmt_get_is_null_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr);
+
+DRIZZLE_API
 bool drizzle_stmt_get_is_null(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr);
 
 DRIZZLE_API
+bool drizzle_stmt_get_is_unsigned_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr);
+
+DRIZZLE_API
 bool drizzle_stmt_get_is_unsigned(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr);
 
 DRIZZLE_API
+const char *drizzle_stmt_get_string_from_name(drizzle_stmt_st *stmt, const char *column_name, size_t *len, drizzle_return_t *ret_ptr);
+
+DRIZZLE_API
 const char *drizzle_stmt_get_string(drizzle_stmt_st *stmt, uint16_t column_number, size_t *len, drizzle_return_t *ret_ptr);
 
 DRIZZLE_API
 uint32_t drizzle_stmt_get_int(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr);
 
 DRIZZLE_API
+uint32_t drizzle_stmt_get_int_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr);
+
+DRIZZLE_API
+uint64_t drizzle_stmt_get_bigint_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr);
+
+DRIZZLE_API
 uint64_t drizzle_stmt_get_bigint(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr);
 
 DRIZZLE_API
 double drizzle_stmt_get_double(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr);
 
+DRIZZLE_API
+double drizzle_stmt_get_double_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr);
+
 #ifdef __cplusplus
 }
 #endif
 
=== modified file 'libdrizzle-5.1/verbose.h'
--- libdrizzle-5.1/verbose.h	2012-12-18 11:36:28 +0000
+++ libdrizzle-5.1/verbose.h	2013-01-05 11:52:22 +0000
@@ -42,11 +42,10 @@
 enum drizzle_verbose_t
 {
   DRIZZLE_VERBOSE_NEVER,
-  DRIZZLE_VERBOSE_FATAL,
+  DRIZZLE_VERBOSE_CRITICAL,
   DRIZZLE_VERBOSE_ERROR,
   DRIZZLE_VERBOSE_INFO,
   DRIZZLE_VERBOSE_DEBUG,
-  DRIZZLE_VERBOSE_CRAZY,
   DRIZZLE_VERBOSE_MAX
 };
 
 
=== modified file 'libdrizzle/binlog.cc'
--- libdrizzle/binlog.cc	2012-12-29 17:31:57 +0000
+++ libdrizzle/binlog.cc	2013-01-05 11:52:22 +0000
@@ -45,8 +45,8 @@
                                             uint32_t start_position,
                                             drizzle_return_t *ret_ptr)
 { 
-  uint8_t data[128];
-  uint8_t *ptr;
+  unsigned char data[128];
+  unsigned char *ptr;
   uint8_t len= 0, fn_len= 0;
   drizzle_result_st *result;
 
@@ -179,7 +179,7 @@
   return result->binlog_event->extra_flags;
 }
 
-const uint8_t *drizzle_binlog_event_data(drizzle_result_st *result)
+const unsigned char *drizzle_binlog_event_data(drizzle_result_st *result)
 {
   if ((result == NULL) || (result->binlog_event == NULL))
   {
@@ -189,7 +189,7 @@
   return result->binlog_event->data;
 }
 
-const uint8_t *drizzle_binlog_event_raw_data(drizzle_result_st *result)
+const unsigned char *drizzle_binlog_event_raw_data(drizzle_result_st *result)
 {
   if ((result == NULL) || (result->binlog_event == NULL))
   {
@@ -306,7 +306,7 @@
       con->buffer_ptr+= 27;
       con->buffer_size-= 27;
       con->packet_size-= 27;
-      binlog_event->data= (uint8_t*)realloc(binlog_event->data, binlog_event->length);
+      binlog_event->data= (unsigned char*)realloc(binlog_event->data, binlog_event->length);
       /* 5.6.1 or higher is automatic checksums on */
       if (binlog_event->type == DRIZZLE_EVENT_TYPE_FORMAT_DESCRIPTION)
       {
 
=== modified file 'libdrizzle/column.cc'
--- libdrizzle/column.cc	2012-12-26 10:02:04 +0000
+++ libdrizzle/column.cc	2013-01-05 11:52:22 +0000
@@ -242,7 +242,7 @@
   return column->decimals;
 }
 
-const uint8_t *drizzle_column_default_value(drizzle_column_st *column,
+const unsigned char *drizzle_column_default_value(drizzle_column_st *column,
                                             size_t *size)
 {
   if (column == NULL)
@@ -442,7 +442,7 @@
  */
 
 void drizzle_column_set_default_value(drizzle_column_st *column,
-                                      const uint8_t *default_value,
+                                      const unsigned char *default_value,
                                       size_t size)
 {
   if (column == NULL)
 
=== modified file 'libdrizzle/column.h'
--- libdrizzle/column.h	2012-12-30 11:18:18 +0000
+++ libdrizzle/column.h	2013-01-05 11:52:22 +0000
@@ -43,7 +43,7 @@
 drizzle_column_st *drizzle_column_create(drizzle_result_st *result);
 
 void drizzle_column_set_default_value(drizzle_column_st *column,
-                                      const uint8_t *default_value,
+                                      const unsigned char *default_value,
                                       size_t size);
 
 
 
=== modified file 'libdrizzle/command.cc'
--- libdrizzle/command.cc	2012-12-22 08:54:15 +0000
+++ libdrizzle/command.cc	2013-01-05 11:52:22 +0000
@@ -50,8 +50,8 @@
 
 drizzle_return_t drizzle_state_command_write(drizzle_st *con)
 {
-  uint8_t *start;
-  uint8_t *ptr;
+  unsigned char *start;
+  unsigned char *ptr;
   drizzle_return_t ret;
 
   if (con == NULL)
@@ -102,7 +102,7 @@
     con->packet_number= 1;
     ptr= start;
     ptr[3]= 0;
-    ptr[4]= (uint8_t)(con->command);
+    ptr[4]= (unsigned char)(con->command);
     ptr+= 5;
 
     if (con->command == DRIZZLE_COMMAND_CHANGE_USER)
 
=== modified file 'libdrizzle/conn.cc'
--- libdrizzle/conn.cc	2013-01-04 10:21:06 +0000
+++ libdrizzle/conn.cc	2013-01-05 11:52:22 +0000
@@ -567,7 +567,7 @@
   return con->thread_id;
 }
 
-const uint8_t *drizzle_scramble(const drizzle_st *con)
+const unsigned char *drizzle_scramble(const drizzle_st *con)
 {
   if (con == NULL)
   {
@@ -671,13 +671,16 @@
   return DRIZZLE_RETURN_INVALID_ARGUMENT;
 }
 
-drizzle_result_st *drizzle_select_db(drizzle_st *con,
-                                         const char *db,
-                                         drizzle_return_t *ret_ptr)
+drizzle_return_t drizzle_select_db(drizzle_st *con,
+                                         const char *db)
 {
+  drizzle_result_st *result;
+  drizzle_return_t ret;
   drizzle_set_db(con, db);
-  return drizzle_command_write(con, NULL, DRIZZLE_COMMAND_INIT_DB,
-                                   db, strlen(db), strlen(db), ret_ptr);
+  result= drizzle_command_write(con, NULL, DRIZZLE_COMMAND_INIT_DB,
+                                   db, strlen(db), strlen(db), &ret);
+  drizzle_result_free(result);
+  return ret;
 }
 
 drizzle_result_st *drizzle_shutdown(drizzle_st *con,
@@ -780,7 +783,7 @@
     }
 
     con->command= command;
-    con->command_data= (uint8_t *)data;
+    con->command_data= (unsigned char *)data;
     con->command_size= size;
     con->command_offset= 0;
     con->command_total= total;
@@ -789,7 +792,7 @@
   }
   else if (con->command_data == NULL)
   {
-    con->command_data= (uint8_t *)data;
+    con->command_data= (unsigned char *)data;
     con->command_size= size;
   }
 
 
=== modified file 'libdrizzle/drizzle.cc'
--- libdrizzle/drizzle.cc	2012-12-30 02:23:50 +0000
+++ libdrizzle/drizzle.cc	2013-01-05 11:52:22 +0000
@@ -55,11 +55,10 @@
 static const char *_verbose_name[DRIZZLE_VERBOSE_MAX]=
 {
   "NEVER",
-  "FATAL",
+  "CRITICAL",
   "ERROR",
   "INFO",
   "DEBUG",
-  "CRAZY"
 };
 
 /** @} */
 
=== modified file 'libdrizzle/drizzle_local.h'
--- libdrizzle/drizzle_local.h	2012-12-30 11:18:18 +0000
+++ libdrizzle/drizzle_local.h	2013-01-05 11:52:22 +0000
@@ -106,10 +106,10 @@
 {
   va_list args;
 
-  if (con->verbose >= DRIZZLE_VERBOSE_FATAL)
+  if (con->verbose >= DRIZZLE_VERBOSE_CRITICAL)
   {
     va_start(args, format);
-    drizzle_log(con, DRIZZLE_VERBOSE_FATAL, format, args);
+    drizzle_log(con, DRIZZLE_VERBOSE_CRITICAL, format, args);
     va_end(args);
   }
 }
@@ -170,10 +170,10 @@
 {
   va_list args;
 
-  if (con->verbose >= DRIZZLE_VERBOSE_CRAZY)
+  if (con->verbose >= DRIZZLE_VERBOSE_DEBUG)
   {
     va_start(args, format);
-    drizzle_log(con, DRIZZLE_VERBOSE_CRAZY, format, args);
+    drizzle_log(con, DRIZZLE_VERBOSE_DEBUG, format, args);
     va_end(args);
   }
 }
 
=== modified file 'libdrizzle/error.cc'
--- libdrizzle/error.cc	2012-12-30 20:08:04 +0000
+++ libdrizzle/error.cc	2013-01-05 11:52:22 +0000
@@ -72,6 +72,7 @@
   case DRIZZLE_RETURN_BINLOG_CRC: return "DRIZZLE_RETURN_BINLOG_CRC";
   case DRIZZLE_RETURN_TRUNCATED: return "DRIZZLE_RETURN_TRUNCATED";
   case DRIZZLE_RETURN_INVALID_CONVERSION: return "DRIZZLE_RETURN_INVALID_CONVERSION";
+  case DRIZZLE_RETURN_NOT_FOUND: return "DRIZZLE_RETURN_NOT_FOUND";
   case DRIZZLE_RETURN_MAX: return "DRIZZLE_RETURN_MAX";
   }
 
 
=== modified file 'libdrizzle/handshake.cc'
--- libdrizzle/handshake.cc	2012-12-22 13:07:06 +0000
+++ libdrizzle/handshake.cc	2013-01-05 11:52:22 +0000
@@ -81,7 +81,7 @@
 
 drizzle_return_t drizzle_state_handshake_server_read(drizzle_st *con)
 {
-  uint8_t *ptr;
+  unsigned char *ptr;
   int extra_length;
   unsigned char* packet_end;
 
@@ -128,7 +128,7 @@
   }
 
   /* Look for null-terminated server version string. */
-  ptr= (uint8_t*)memchr(con->buffer_ptr, 0, con->buffer_size - 1);
+  ptr= (unsigned char*)memchr(con->buffer_ptr, 0, con->buffer_size - 1);
   if (ptr == NULL)
   {
     drizzle_set_error(con, "drizzle_state_handshake_server_read",
@@ -218,7 +218,7 @@
 
 drizzle_return_t drizzle_state_handshake_server_write(drizzle_st *con)
 {
-  uint8_t *ptr;
+  unsigned char *ptr;
 
   if (con == NULL)
   {
@@ -371,7 +371,7 @@
   con->buffer_ptr+= 23;
 
   /* Look for null-terminated user string. */
-  uint8_t *ptr= (uint8_t*)memchr(con->buffer_ptr, 0, con->buffer_size - 32);
+  unsigned char *ptr= (unsigned char*)memchr(con->buffer_ptr, 0, con->buffer_size - 32);
   if (ptr == NULL)
   {
     drizzle_set_error(con, "drizzle_state_handshake_client_read",
@@ -430,7 +430,7 @@
   }
   else
   {
-    ptr= (uint8_t*)memchr(con->buffer_ptr, 0, con->buffer_size -
+    ptr= (unsigned char*)memchr(con->buffer_ptr, 0, con->buffer_size -
                                     (34 + strlen(con->user) + scramble_size));
     if (ptr == NULL)
     {
@@ -513,7 +513,7 @@
 
 drizzle_return_t drizzle_state_handshake_client_write(drizzle_st *con)
 {
-  uint8_t *ptr;
+  unsigned char *ptr;
   int capabilities;
 #ifdef USE_OPENSSL
   int ssl_ret;
@@ -600,7 +600,7 @@
 
 drizzle_return_t drizzle_state_handshake_ssl_client_write(drizzle_st *con)
 {
-  uint8_t *ptr;
+  unsigned char *ptr;
   int capabilities;
 
   drizzle_log_debug(con, "drizzle_state_handshake_ssl_client_write");
 
=== modified file 'libdrizzle/pack.cc'
--- libdrizzle/pack.cc	2012-12-23 01:05:57 +0000
+++ libdrizzle/pack.cc	2013-01-05 11:52:22 +0000
@@ -57,7 +57,7 @@
  * Compute hash from password and scramble.
  */
 static drizzle_return_t _pack_scramble_hash(drizzle_st *con,
-                                            uint8_t *buffer);
+                                            unsigned char *buffer);
 
 /** @} */
 
@@ -65,7 +65,7 @@
  * Public definitions
  */
 
-uint8_t *drizzle_pack_length(uint64_t number, uint8_t *ptr)
+unsigned char *drizzle_pack_length(uint64_t number, unsigned char *ptr)
 {
   if (number < 251)
   {
@@ -157,7 +157,7 @@
   return length;
 }
 
-uint8_t *drizzle_pack_string(char *string, uint8_t *ptr)
+unsigned char *drizzle_pack_string(char *string, unsigned char *ptr)
 {
   if (string == NULL)
   {
@@ -176,7 +176,7 @@
   return ptr;
 }
 
-uint8_t *drizzle_pack_binary(uint8_t *data, size_t len, uint8_t *ptr)
+unsigned char *drizzle_pack_binary(unsigned char *data, size_t len, unsigned char *ptr)
 {
   ptr= drizzle_pack_length(len, ptr);
   if (len > 0)
@@ -188,7 +188,7 @@
   return ptr;
 }
 
-uint8_t *drizzle_pack_time(drizzle_datetime_st *time, uint8_t *ptr)
+unsigned char *drizzle_pack_time(drizzle_datetime_st *time, unsigned char *ptr)
 {
   uint8_t length= 0;
 
@@ -213,7 +213,7 @@
   return ptr+length;
 }
 
-uint8_t *drizzle_pack_datetime(drizzle_datetime_st *datetime, uint8_t *ptr)
+unsigned char *drizzle_pack_datetime(drizzle_datetime_st *datetime, unsigned char *ptr)
 {
   uint8_t length= 0;
 
@@ -245,7 +245,7 @@
   return ptr + length;
 }
 
-void drizzle_unpack_time(drizzle_field_t field, size_t length, uint8_t *data)
+void drizzle_unpack_time(drizzle_field_t field, size_t length, unsigned char *data)
 {
   drizzle_datetime_st *datetime= (drizzle_datetime_st*) data;
   memset(datetime, 0, length);
@@ -266,7 +266,7 @@
   }
 }
 
-void drizzle_unpack_datetime(drizzle_field_t field, size_t length, uint8_t *data)
+void drizzle_unpack_datetime(drizzle_field_t field, size_t length, unsigned char *data)
 {
   drizzle_datetime_st *datetime= (drizzle_datetime_st*) data;
   memset(datetime, 0, length);
@@ -332,7 +332,7 @@
   return DRIZZLE_RETURN_OK;
 }
 
-uint8_t *drizzle_pack_auth(drizzle_st *con, uint8_t *ptr,
+unsigned char *drizzle_pack_auth(drizzle_st *con, unsigned char *ptr,
                            drizzle_return_t *ret_ptr)
 {
   drizzle_return_t unused_ret;
@@ -408,11 +408,11 @@
  */
 
 static drizzle_return_t _pack_scramble_hash(drizzle_st *con,
-                                            uint8_t *buffer)
+                                            unsigned char *buffer)
 {
   SHA1_CTX ctx;
-  uint8_t hash_tmp1[SHA1_DIGEST_LENGTH];
-  uint8_t hash_tmp2[SHA1_DIGEST_LENGTH];
+  unsigned char hash_tmp1[SHA1_DIGEST_LENGTH];
+  unsigned char hash_tmp2[SHA1_DIGEST_LENGTH];
 
   if (SHA1_DIGEST_LENGTH != DRIZZLE_MAX_SCRAMBLE_SIZE)
   {
@@ -431,7 +431,7 @@
 
   /* First hash the password. */
   SHA1Init(&ctx);
-  SHA1Update(&ctx, (uint8_t *)(con->password), strlen(con->password));
+  SHA1Update(&ctx, (unsigned char *)(con->password), strlen(con->password));
   SHA1Final(hash_tmp1, &ctx);
 
   /* Second, hash the password hash. */
 
=== modified file 'libdrizzle/pack.h'
--- libdrizzle/pack.h	2012-12-30 02:23:50 +0000
+++ libdrizzle/pack.h	2013-01-05 11:52:22 +0000
@@ -58,7 +58,7 @@
  * Pack length-encoded number.
  */
 
-uint8_t *drizzle_pack_length(uint64_t number, uint8_t *ptr);
+unsigned char *drizzle_pack_length(uint64_t number, unsigned char *ptr);
 
 /**
  * Unpack length-encoded number.
@@ -70,17 +70,17 @@
  * Pack length-encoded string.
  */
 
-uint8_t *drizzle_pack_string(char *string, uint8_t *ptr);
-
-uint8_t *drizzle_pack_binary(uint8_t *data, size_t len, uint8_t *ptr);
-
-uint8_t *drizzle_pack_time(drizzle_datetime_st *time, uint8_t *ptr);
-
-uint8_t *drizzle_pack_datetime(drizzle_datetime_st *datetime, uint8_t *ptr);
-
-void drizzle_unpack_time(drizzle_field_t field, size_t length, uint8_t *data);
-
-void drizzle_unpack_datetime(drizzle_field_t field, size_t length, uint8_t *data);
+unsigned char *drizzle_pack_string(char *string, unsigned char *ptr);
+
+unsigned char *drizzle_pack_binary(unsigned char *data, size_t len, unsigned char *ptr);
+
+unsigned char *drizzle_pack_time(drizzle_datetime_st *time, unsigned char *ptr);
+
+unsigned char *drizzle_pack_datetime(drizzle_datetime_st *datetime, unsigned char *ptr);
+
+void drizzle_unpack_time(drizzle_field_t field, size_t length, unsigned char *data);
+
+void drizzle_unpack_datetime(drizzle_field_t field, size_t length, unsigned char *data);
 
 /**
  * Unpack length-encoded string.
@@ -91,7 +91,7 @@
 /**
  * Pack user, scramble, and db.
  */
-uint8_t *drizzle_pack_auth(drizzle_st *con, uint8_t *ptr,
+unsigned char *drizzle_pack_auth(drizzle_st *con, unsigned char *ptr,
                            drizzle_return_t *ret_ptr);
 
 /** @} */
 
=== modified file 'libdrizzle/query.cc'
--- libdrizzle/query.cc	2012-12-22 08:54:15 +0000
+++ libdrizzle/query.cc	2013-01-05 11:52:22 +0000
@@ -47,7 +47,7 @@
                                  drizzle_return_t *ret_ptr)
 {
   return drizzle_command_write(con, NULL, DRIZZLE_COMMAND_QUERY,
-                                   (uint8_t *)query, size, size, ret_ptr);
+                                   (unsigned char *)query, size, size, ret_ptr);
 }
 
 drizzle_result_st *drizzle_query_str(drizzle_st *con,
@@ -62,7 +62,7 @@
   size_t size= strlen(query);
 
   return drizzle_command_write(con, NULL, DRIZZLE_COMMAND_QUERY,
-                                   (uint8_t *)query, size, size, ret_ptr);
+                                   (unsigned char *)query, size, size, ret_ptr);
 }
 
 
@@ -135,7 +135,7 @@
   return to_size;
 }
 
-bool drizzle_hex_string(char *to, const uint8_t *from, const size_t from_size)
+bool drizzle_hex_string(char *to, const unsigned char *from, const size_t from_size)
 {
   if (to == NULL || from == NULL || from_size == 0)
   {
@@ -143,7 +143,7 @@
   }
 
   static const char hex_map[]= "0123456789ABCDEF";
-  const uint8_t *from_end;
+  const unsigned char *from_end;
 
   for (from_end= from + from_size; from != from_end; from++)
   {
@@ -164,11 +164,11 @@
   }
   
   SHA1_CTX ctx;
-  uint8_t hash_tmp1[SHA1_DIGEST_LENGTH];
-  uint8_t hash_tmp2[SHA1_DIGEST_LENGTH];
+  unsigned char hash_tmp1[SHA1_DIGEST_LENGTH];
+  unsigned char hash_tmp2[SHA1_DIGEST_LENGTH];
 
   SHA1Init(&ctx);
-  SHA1Update(&ctx, (const uint8_t*)from, from_size);
+  SHA1Update(&ctx, (const unsigned char*)from, from_size);
   SHA1Final(hash_tmp1, &ctx);
 
   SHA1Init(&ctx);
 
=== modified file 'libdrizzle/statement.cc'
--- libdrizzle/statement.cc	2012-12-31 10:02:02 +0000
+++ libdrizzle/statement.cc	2013-01-05 11:52:22 +0000
@@ -116,9 +116,9 @@
   drizzle_bind_st *param_ptr;
   size_t param_lengths= 0;
   size_t buffer_size= 0;
-  uint8_t *buffer;
-  uint8_t *buffer_pos;
-  uint8_t *data_pos;
+  unsigned char *buffer;
+  unsigned char *buffer_pos;
+  unsigned char *data_pos;
   drizzle_return_t ret;
 
   /* Calculate param lengths */
@@ -141,7 +141,7 @@
              + (stmt->param_count * 2) /* Parameter type data */
              + param_lengths; /* Parameter data */
 
-  buffer = (uint8_t*)malloc(buffer_size);
+  buffer = (unsigned char*)malloc(buffer_size);
   if (buffer == NULL)
   {
     drizzle_set_error(stmt->con, __func__, "malloc");
@@ -258,7 +258,7 @@
       case DRIZZLE_COLUMN_TYPE_STRING:
       case DRIZZLE_COLUMN_TYPE_DECIMAL:
       case DRIZZLE_COLUMN_TYPE_NEWDECIMAL:
-        data_pos= drizzle_pack_binary((uint8_t*)param_ptr->data, param_ptr->length, data_pos);
+        data_pos= drizzle_pack_binary((unsigned char*)param_ptr->data, param_ptr->length, data_pos);
         break;
       /* These types aren't handled yet, most are for older MySQL versions */
       case DRIZZLE_COLUMN_TYPE_INT24:
@@ -316,10 +316,10 @@
   return ret;
 }
 
-drizzle_return_t drizzle_stmt_send_long_data(drizzle_stmt_st *stmt, uint16_t param_num, uint8_t *data, size_t len)
+drizzle_return_t drizzle_stmt_send_long_data(drizzle_stmt_st *stmt, uint16_t param_num, unsigned char *data, size_t len)
 {
   drizzle_return_t ret;
-  uint8_t *buffer;
+  unsigned char *buffer;
 
   if ((stmt == NULL) || (param_num >= stmt->param_count))
   {
@@ -336,7 +336,7 @@
   /* TODO: rework drizzle_command_write so we can send a header and we don't
    * need this copy
    * */
-  buffer= (uint8_t*)malloc(len + 6);
+  buffer= (unsigned char*)malloc(len + 6);
 
   drizzle_set_byte4(buffer, stmt->id);
   drizzle_set_byte2(&buffer[4], param_num);
@@ -355,7 +355,7 @@
 drizzle_return_t drizzle_stmt_reset(drizzle_stmt_st *stmt)
 {
   drizzle_return_t ret;
-  uint8_t buffer[4];
+  unsigned char buffer[4];
   uint16_t current_param;
 
   if (stmt == NULL)
@@ -474,12 +474,12 @@
           memcpy(param->data, row[column_counter], 8);
           break;
         case DRIZZLE_COLUMN_TYPE_TIME:
-          drizzle_unpack_time(row[column_counter], param->length, (uint8_t*)param->data);
+          drizzle_unpack_time(row[column_counter], param->length, (unsigned char*)param->data);
           break;
         case DRIZZLE_COLUMN_TYPE_DATE:
         case DRIZZLE_COLUMN_TYPE_DATETIME:
         case DRIZZLE_COLUMN_TYPE_TIMESTAMP:
-          drizzle_unpack_datetime(row[column_counter], param->length, (uint8_t*)param->data);
+          drizzle_unpack_datetime(row[column_counter], param->length, (unsigned char*)param->data);
           break;
         case DRIZZLE_COLUMN_TYPE_TINY_BLOB:
         case DRIZZLE_COLUMN_TYPE_MEDIUM_BLOB:
@@ -544,7 +544,7 @@
 
 drizzle_return_t drizzle_stmt_close(drizzle_stmt_st *stmt)
 {
-  uint8_t buffer[4];
+  unsigned char buffer[4];
   drizzle_return_t ret;
 
   if (stmt == NULL)
 
=== modified file 'libdrizzle/statement_local.h'
--- libdrizzle/statement_local.h	2012-12-30 20:08:04 +0000
+++ libdrizzle/statement_local.h	2013-01-05 11:52:22 +0000
@@ -59,6 +59,9 @@
 DRIZZLE_LOCAL
 char *timestamp_to_string(drizzle_bind_st *param, drizzle_datetime_st *timestamp);
 
+DRIZZLE_LOCAL
+uint16_t drizzle_stmt_column_lookup(drizzle_result_st *result, const char *column_name, drizzle_return_t *ret_ptr);
+
 #ifdef __cplusplus
 }
 #endif
 
=== modified file 'libdrizzle/statement_param.cc'
--- libdrizzle/statement_param.cc	2012-12-31 09:54:55 +0000
+++ libdrizzle/statement_param.cc	2013-01-05 11:52:22 +0000
@@ -168,6 +168,21 @@
   return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TIME, timestamp, 0, false, true);
 }
 
+bool drizzle_stmt_get_is_null_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
+{
+  uint16_t column_number;
+  if ((stmt == NULL) || (stmt->result_params == NULL))
+  {
+    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
+  }
+  column_number=  drizzle_stmt_column_lookup(stmt->prepare_result, column_name, ret_ptr);
+  if (*ret_ptr != DRIZZLE_RETURN_OK)
+  {
+    return 0;
+  }
+  return drizzle_stmt_get_is_null(stmt, column_number, ret_ptr);
+}
+
 bool drizzle_stmt_get_is_null(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr)
 {
   if ((stmt == NULL) || (stmt->result_params == NULL) || (column_number >= stmt->execute_result->column_count))
@@ -180,6 +195,21 @@
   return stmt->result_params[column_number].options.is_null;
 }
 
+bool drizzle_stmt_get_is_unsigned_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
+{
+  uint16_t column_number;
+  if ((stmt == NULL) || (stmt->result_params == NULL))
+  {
+    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
+  }
+  column_number=  drizzle_stmt_column_lookup(stmt->prepare_result, column_name, ret_ptr);
+  if (*ret_ptr != DRIZZLE_RETURN_OK)
+  {
+    return 0;
+  }
+  return drizzle_stmt_get_is_unsigned(stmt, column_number, ret_ptr);
+}
+
 bool drizzle_stmt_get_is_unsigned(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr)
 {
   if ((stmt == NULL) || (stmt->result_params == NULL) || (column_number >= stmt->execute_result->column_count))
@@ -192,6 +222,21 @@
   return stmt->result_params[column_number].options.is_unsigned;
 }
 
+const char *drizzle_stmt_get_string_from_name(drizzle_stmt_st *stmt, const char *column_name, size_t *len, drizzle_return_t *ret_ptr)
+{
+  uint16_t column_number;
+  if ((stmt == NULL) || (stmt->result_params == NULL))
+  {
+    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
+  }
+  column_number=  drizzle_stmt_column_lookup(stmt->prepare_result, column_name, ret_ptr);
+  if (*ret_ptr != DRIZZLE_RETURN_OK)
+  {
+    return 0;
+  }
+  return drizzle_stmt_get_string(stmt, column_number, len, ret_ptr);
+}
+
 const char *drizzle_stmt_get_string(drizzle_stmt_st *stmt, uint16_t column_number, size_t *len, drizzle_return_t *ret_ptr)
 {
   char *val;
@@ -276,6 +321,21 @@
   return val;
 }
 
+uint32_t drizzle_stmt_get_int_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
+{
+  uint16_t column_number;
+  if ((stmt == NULL) || (stmt->result_params == NULL))
+  {
+    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
+  }
+  column_number=  drizzle_stmt_column_lookup(stmt->prepare_result, column_name, ret_ptr);
+  if (*ret_ptr != DRIZZLE_RETURN_OK)
+  {
+    return 0;
+  }
+  return drizzle_stmt_get_int(stmt, column_number, ret_ptr);
+}
+
 uint32_t drizzle_stmt_get_int(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr)
 {
   uint32_t val;
@@ -350,6 +410,21 @@
   return val;
 }
 
+uint64_t drizzle_stmt_get_bigint_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
+{
+  uint16_t column_number;
+  if ((stmt == NULL) || (stmt->result_params == NULL))
+  {
+    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
+  }
+  column_number=  drizzle_stmt_column_lookup(stmt->prepare_result, column_name, ret_ptr);
+  if (*ret_ptr != DRIZZLE_RETURN_OK)
+  {
+    return 0;
+  }
+  return drizzle_stmt_get_bigint(stmt, column_number, ret_ptr);
+}
+
 uint64_t drizzle_stmt_get_bigint(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr)
 {
   uint32_t val;
@@ -420,6 +495,21 @@
   return val;
 }
 
+double drizzle_stmt_get_double_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
+{
+  uint16_t column_number;
+  if ((stmt == NULL) || (stmt->result_params == NULL))
+  {
+    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
+  }
+  column_number=  drizzle_stmt_column_lookup(stmt->prepare_result, column_name, ret_ptr);
+  if (*ret_ptr != DRIZZLE_RETURN_OK)
+  {
+    return 0;
+  }
+  return drizzle_stmt_get_double(stmt, column_number, ret_ptr);
+}
+
 double drizzle_stmt_get_double(drizzle_stmt_st *stmt, uint16_t column_number, drizzle_return_t *ret_ptr)
 {
   double val;
@@ -557,3 +647,18 @@
   }
   return param->converted_data;
 }
+
+uint16_t drizzle_stmt_column_lookup(drizzle_result_st *result, const char *column_name, drizzle_return_t *ret_ptr)
+{
+  uint16_t current_column;
+  for (current_column= 0; current_column < result->column_count; current_column++)
+  {
+    if (strncmp(column_name, result->column_buffer[current_column].name, DRIZZLE_MAX_COLUMN_NAME_SIZE) == 0)
+    {
+      *ret_ptr= DRIZZLE_RETURN_OK;
+      return current_column;
+    }
+  }
+  *ret_ptr= DRIZZLE_RETURN_NOT_FOUND;
+  return 0;
+}
 
=== modified file 'libdrizzle/structs.h'
--- libdrizzle/structs.h	2012-12-30 20:08:04 +0000
+++ libdrizzle/structs.h	2013-01-05 11:52:22 +0000
@@ -166,23 +166,23 @@
   size_t command_total;
   size_t packet_size;
   struct addrinfo *addrinfo_next;
-  uint8_t *buffer_ptr;
-  uint8_t *command_buffer;
-  uint8_t *command_data;
+  unsigned char *buffer_ptr;
+  unsigned char *command_buffer;
+  unsigned char *command_data;
   void *context;
   drizzle_context_free_fn *context_free_fn;
   drizzle_result_st *result;
   drizzle_result_st *result_list;
-  uint8_t *scramble;
+  unsigned char *scramble;
   union
   {
     drizzle_tcp_st tcp;
     drizzle_uds_st uds;
   } socket;
-  uint8_t buffer[DRIZZLE_MAX_BUFFER_SIZE];
+  unsigned char buffer[DRIZZLE_MAX_BUFFER_SIZE];
   char db[DRIZZLE_MAX_DB_SIZE];
   char password[DRIZZLE_MAX_PASSWORD_SIZE];
-  uint8_t scramble_buffer[DRIZZLE_MAX_SCRAMBLE_SIZE];
+  unsigned char scramble_buffer[DRIZZLE_MAX_SCRAMBLE_SIZE];
   char server_version[DRIZZLE_MAX_SERVER_VERSION_SIZE];
   char server_extra[DRIZZLE_MAX_SERVER_EXTRA_SIZE];
   drizzle_state_fn *state_stack[DRIZZLE_STATE_STACK_SIZE];
@@ -305,8 +305,8 @@
   uint16_t flags;
   uint16_t extra_flags;
   uint32_t checksum;
-  uint8_t *data;
-  uint8_t *raw_data;
+  unsigned char *data;
+  unsigned char *raw_data;
   uint32_t raw_length;
 };
 
@@ -331,7 +331,7 @@
   drizzle_column_type_t type;
   int flags;
   uint8_t decimals;
-  uint8_t default_value[DRIZZLE_MAX_DEFAULT_VALUE_SIZE];
+  unsigned char default_value[DRIZZLE_MAX_DEFAULT_VALUE_SIZE];
   size_t default_value_size;
 };
 
 
=== modified file 'tests/unit/column.c'
--- tests/unit/column.c	2012-12-31 00:06:53 +0000
+++ tests/unit/column.c	2013-01-05 11:52:22 +0000
@@ -71,7 +71,7 @@
   drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
 
-  drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
+  ret= drizzle_select_db(con, "libdrizzle");
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
 
   drizzle_query_str(con, "create table libdrizzle.t1 (a int primary key auto_increment, b varchar(255), c timestamp default current_timestamp)", &ret);
@@ -80,7 +80,7 @@
   drizzle_query_str(con, "insert into libdrizzle.t1 (b) values ('this'),('is'),('war')", &ret);
   ASSERT_TRUE_(ret == DRIZZLE_RETURN_OK, "insert into libdrizzle.t1 (b) values ('this'),('is'),('war')");
 
-  result= drizzle_query_str(con, "select * from libdrizzle.t1", &ret);
+  drizzle_result_st *result= drizzle_query_str(con, "select * from libdrizzle.t1", &ret);
   ASSERT_TRUE_(ret == DRIZZLE_RETURN_OK, "select * from libdrizzle.t1");
 
   drizzle_result_buffer(result);
 
=== modified file 'tests/unit/hex.c'
--- tests/unit/hex.c	2012-12-29 10:49:09 +0000
+++ tests/unit/hex.c	2013-01-05 11:52:22 +0000
@@ -45,7 +45,7 @@
 
 int main(int argc, char* argv[])
 {
-  const uint8_t in[6]= {0x00, 0xFF, 0x7F, 0x80, 0xB9, 0xC0};
+  const unsigned char in[6]= {0x00, 0xFF, 0x7F, 0x80, 0xB9, 0xC0};
   char out[255];
   bool result;
 
 
=== modified file 'tests/unit/insert_id.c'
--- tests/unit/insert_id.c	2012-12-31 00:06:53 +0000
+++ tests/unit/insert_id.c	2013-01-05 11:52:22 +0000
@@ -70,13 +70,13 @@
   drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
 
-  drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
+  ret= drizzle_select_db(con, "libdrizzle");
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
 
   drizzle_query_str(con, "create table libdrizzle.t1 (a int primary key auto_increment, b int)", &ret);
   ASSERT_EQ_(ret, DRIZZLE_RETURN_OK, "create table libdrizzle.t1 (a int primary key auto_increment, b int)");
 
-  result= drizzle_query_str(con, "insert into libdrizzle.t1 (b) values (1),(2),(3)", &ret);
+  drizzle_result_st *result= drizzle_query_str(con, "insert into libdrizzle.t1 (b) values (1),(2),(3)", &ret);
   ASSERT_EQ_(ret, DRIZZLE_RETURN_OK, "insert into libdrizzle.t1 (b) values (1),(2),(3)");
   ASSERT_TRUE(result);
 
 
=== modified file 'tests/unit/query.c'
--- tests/unit/query.c	2012-12-31 00:06:53 +0000
+++ tests/unit/query.c	2013-01-05 11:52:22 +0000
@@ -71,7 +71,7 @@
   drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
 
-  drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
+  ret= drizzle_select_db(con, "libdrizzle");
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
 
   drizzle_query_str(con, "create table libdrizzle.t1 (a int)", &ret);
@@ -88,7 +88,7 @@
     return EXIT_FAILURE;
   }
 
-  result= drizzle_query_str(con, "select * from libdrizzle.t1", &ret);
+  drizzle_result_st *result= drizzle_query_str(con, "select * from libdrizzle.t1", &ret);
   if (ret != DRIZZLE_RETURN_OK)
   {
     printf("Select failure\n");
 
=== modified file 'tests/unit/row.c'
--- tests/unit/row.c	2012-12-31 00:06:53 +0000
+++ tests/unit/row.c	2013-01-05 11:52:22 +0000
@@ -71,7 +71,7 @@
   drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
 
-  drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
+  ret= drizzle_select_db(con, "libdrizzle");
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
 
   drizzle_query_str(con, "create table libdrizzle.t1 (a int)", &ret);
@@ -88,7 +88,7 @@
     return EXIT_FAILURE;
   }
 
-  result= drizzle_query_str(con, "select * from libdrizzle.t1", &ret);
+  drizzle_result_st *result= drizzle_query_str(con, "select * from libdrizzle.t1", &ret);
   if (ret != DRIZZLE_RETURN_OK)
   {
     printf("Select failure\n");
 
=== modified file 'tests/unit/statement.c'
--- tests/unit/statement.c	2012-12-31 09:54:55 +0000
+++ tests/unit/statement.c	2013-01-05 11:52:22 +0000
@@ -73,8 +73,7 @@
   drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
 
-  drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
-  ASSERT_TRUE(result);
+  ret= drizzle_select_db(con, "libdrizzle");
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
 
   drizzle_query_str(con, "create table libdrizzle.t1 (a int)", &ret);
@@ -133,6 +132,13 @@
       printf("Retrieved unexpected int value\n");
       return EXIT_FAILURE;
     }
+    res_val= drizzle_stmt_get_int_from_name(stmt, "a", &ret);
+    ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "drizzle_stmt_get_int (char col name)");
+    if (res_val != i)
+    {
+      printf("Rerieved unexpected int value with char col name\n");
+      return EXIT_FAILURE;
+    }
     snprintf(comp_val, 3, "%"PRIu32, i);
     if (strcmp(comp_val, char_val) != 0)
     {
 
=== modified file 'tests/unit/statement_char.c'
--- tests/unit/statement_char.c	2012-12-31 09:59:37 +0000
+++ tests/unit/statement_char.c	2013-01-05 11:52:22 +0000
@@ -74,8 +74,7 @@
   drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
 
-  drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
-  ASSERT_TRUE(result);
+  ret= drizzle_select_db(con, "libdrizzle");
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
 
   drizzle_query_str(con, "create table libdrizzle.t1 (a varchar(50))", &ret);
 
=== modified file 'tests/unit/unbuffered_query.c'
--- tests/unit/unbuffered_query.c	2012-12-31 00:06:53 +0000
+++ tests/unit/unbuffered_query.c	2013-01-05 11:52:22 +0000
@@ -71,7 +71,7 @@
   drizzle_query_str(con, "CREATE SCHEMA libdrizzle", &ret);
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "CREATE SCHEMA libdrizzle (%s)", drizzle_error(con));
 
-  drizzle_result_st *result= drizzle_select_db(con, "libdrizzle", &ret);
+  ret= drizzle_select_db(con, "libdrizzle");
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "USE libdrizzle");
 
   drizzle_query_str(con, "create table libdrizzle.t1 (a int)", &ret);
@@ -88,7 +88,7 @@
     return EXIT_FAILURE;
   }
 
-  result= drizzle_query_str(con, "select * from libdrizzle.t1", &ret);
+  drizzle_result_st *result= drizzle_query_str(con, "select * from libdrizzle.t1", &ret);
   if (ret != DRIZZLE_RETURN_OK)
   {
     printf("Select failure\n");