Merge lp:~linuxjedi/libdrizzle/date-time into lp:libdrizzle

[Andrew Hutchings]

Wraps up Wim's date/time fixes and fixes libdrizzle trunk so it should pass Jenkins tests.

[lp:~linuxjedi/libdrizzle/date-time]

119. By Andrew Hutchings on 2013-04-21

Fix connect SKIP in common.c

120. By Andrew Hutchings on 2013-04-21

Fix UDS test SKIP

=== modified file 'configure.ac'
--- configure.ac	2013-01-27 21:26:07 +0000
+++ configure.ac	2013-04-21 22:19:27 +0000
@@ -62,6 +62,9 @@
 
 AC_PATH_ZLIB
 
+# Check for -lm
+LT_LIB_M
+
 # Checks for header files.
 AC_DEFUN([CHECK_FOR_CXXABI],
          [AC_LANG_PUSH([C++])

=== modified file 'libdrizzle-5.1/constants.h'
--- libdrizzle-5.1/constants.h	2013-03-05 03:27:07 +0000
+++ libdrizzle-5.1/constants.h	2013-04-21 22:19:27 +0000
@@ -621,6 +621,8 @@
   ((uint64_t)drizzle_get_byte4(((uint8_t *)__buffer)+4) << 32))
 
 /* Protocol packing macros. */
+#define drizzle_set_byte1(__buffer, __int) do { \
+    (__buffer)[0] = (uint8_t)(__int); } while (0)
 #define drizzle_set_byte2(__buffer, __int) do { \
   (__buffer)[0]= (uint8_t)((__int) & 0xFF); \
   (__buffer)[1]= (uint8_t)(((__int) >> 8) & 0xFF); } while (0)

=== modified file 'libdrizzle/pack.cc'
--- libdrizzle/pack.cc	2013-03-12 16:33:14 +0000
+++ libdrizzle/pack.cc	2013-04-21 22:19:27 +0000
@@ -193,71 +193,78 @@
 {
   uint8_t length= 0;
 
-  /* If nothing is set then we are sending a 0 length time */
-  if (time->day || time->hour || time->minute || time->second)
-  {
-    ptr[0]= (time->negative) ? 1 : 0;
-    drizzle_set_byte4(&ptr[1], time->day);
-    ptr[5]= (uint8_t) time->hour;
-    ptr[6]= time->minute;
-    ptr[7]= time->second;
-    length= 8;
-  }
   /* NOTE: MySQL has a bug here and doesn't follow this part of the protocol
    * when packing, we will for now, no idea if it works
    * */
   if (time->microsecond)
   {
-    drizzle_set_byte4(&ptr[8], time->microsecond);
+    drizzle_set_byte4(ptr+9, time->microsecond);
     length= 12;
   }
-  return ptr+length;
+
+  if (length || time->day || time->hour || time->minute || time->second)
+  {
+    ptr[1]= (time->negative) ? 1 : 0;
+    drizzle_set_byte4(ptr+2, time->day);
+    drizzle_set_byte1(ptr+6, time->hour);
+    drizzle_set_byte1(ptr+7, time->minute);
+    drizzle_set_byte1(ptr+8, time->second);
+    /* If no microseconds, then we are packing 8 bytes */
+    if (!length)
+      length= 8;
+  }
+
+  /* If nothing is set then we are sending a 0 length time */
+
+  drizzle_set_byte1(ptr, length);
+  return ptr + 1 + length;
 }
 
 unsigned char *drizzle_pack_datetime(drizzle_datetime_st *datetime, unsigned char *ptr)
 {
   uint8_t length= 0;
 
+  if (datetime->microsecond)
+  {
+    drizzle_set_byte4(ptr+8, datetime->microsecond);
+    length = 11;
+  }
+
+  if (length || datetime->hour || datetime->minute || datetime->second)
+  {
+    drizzle_set_byte1(ptr+5, datetime->hour);
+    drizzle_set_byte1(ptr+6, datetime->minute);
+    drizzle_set_byte1(ptr+7, datetime->second);
+    /* If only date+time is provided then we are packing 7 bytes */
+    if (!length)
+      length = 7;
+  }
+
+  if (length || datetime->year || datetime->month || datetime->day)
+  {
+    drizzle_set_byte2(ptr+1, datetime->year);
+    drizzle_set_byte1(ptr+3, datetime->month);
+    drizzle_set_byte1(ptr+4, datetime->day);
+    /* If only date is provided then we are packing 4 bytes */
+    if (!length)
+      length = 4;
+  }
+
   /* If nothing is set then we are sending a 0 length datetime */
 
-  /* If only date is provided then we are packing 4 bytes */
-  if (datetime->year || datetime->month || datetime->day)
-  {
-    drizzle_set_byte2(ptr, datetime->year);
-    ptr[2]= datetime->month;
-    ptr[3]= datetime->day;
-    length= 4;
-  }
-
-  if (datetime->hour || datetime->minute || datetime->second)
-  {
-    ptr[4]= (uint8_t) datetime->hour;
-    ptr[5]= datetime->minute;
-    ptr[6]= datetime->second;
-    length= 7;
-  }
-
-  if (datetime->microsecond)
-  {
-    drizzle_set_byte4(&ptr[7], datetime->microsecond);
-    length= 11;
-  }
-
-  return ptr + length;
+  drizzle_set_byte1(ptr, length);
+  return ptr + 1 + length;
 }
 
-void drizzle_unpack_time(drizzle_field_t field, size_t length, unsigned char *data)
+void drizzle_unpack_time(drizzle_field_t field, size_t length, drizzle_datetime_st *datetime)
 {
-  drizzle_datetime_st *datetime= (drizzle_datetime_st*) data;
-  memset(datetime, 0, length);
+  memset(datetime, 0, sizeof(*datetime));
 
   if (length)
   {
     datetime->negative= field[0];
     datetime->day= drizzle_get_byte4(&field[1]);
     datetime->hour= field[5];
-    datetime->hour= datetime->day * 24;
-    datetime->day= 0;
     datetime->minute= field[6];
     datetime->second= field[7];
     if (length > 8)
@@ -267,10 +274,9 @@
   }
 }
 
-void drizzle_unpack_datetime(drizzle_field_t field, size_t length, unsigned char *data)
+void drizzle_unpack_datetime(drizzle_field_t field, size_t length, drizzle_datetime_st *datetime)
 {
-  drizzle_datetime_st *datetime= (drizzle_datetime_st*) data;
-  memset(datetime, 0, length);
+  memset(datetime, 0, sizeof(*datetime));
 
   if (length)
   {

=== modified file 'libdrizzle/pack.h'
--- libdrizzle/pack.h	2013-03-06 18:05:42 +0000
+++ libdrizzle/pack.h	2013-04-21 22:19:27 +0000
@@ -79,9 +79,9 @@
 
 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_time(drizzle_field_t field, size_t length, drizzle_datetime_st *datetime);
 
-void drizzle_unpack_datetime(drizzle_field_t field, size_t length, unsigned char *data);
+void drizzle_unpack_datetime(drizzle_field_t field, size_t length, drizzle_datetime_st *datetime);
 
 /**
  * Unpack length-encoded string.

=== modified file 'libdrizzle/statement.cc'
--- libdrizzle/statement.cc	2013-03-21 10:44:02 +0000
+++ libdrizzle/statement.cc	2013-04-21 22:19:27 +0000
@@ -471,13 +471,13 @@
           break;
         case DRIZZLE_COLUMN_TYPE_TIME:
           param->data= param->data_buffer;
-          drizzle_unpack_time(row[column_counter], param->length, (unsigned char*)param->data);
+          drizzle_unpack_time(row[column_counter], param->length, (drizzle_datetime_st *)param->data);
           break;
         case DRIZZLE_COLUMN_TYPE_DATE:
         case DRIZZLE_COLUMN_TYPE_DATETIME:
         case DRIZZLE_COLUMN_TYPE_TIMESTAMP:
           param->data= param->data_buffer;
-          drizzle_unpack_datetime(row[column_counter], param->length, (unsigned char*)param->data);
+          drizzle_unpack_datetime(row[column_counter], param->length, (drizzle_datetime_st *)param->data);
           break;
         case DRIZZLE_COLUMN_TYPE_TINY_BLOB:
         case DRIZZLE_COLUMN_TYPE_MEDIUM_BLOB:

=== modified file 'libdrizzle/statement_param.cc'
--- libdrizzle/statement_param.cc	2013-03-11 17:33:00 +0000
+++ libdrizzle/statement_param.cc	2013-04-21 22:19:27 +0000
@@ -129,6 +129,8 @@
   drizzle_datetime_st *time;
   time= (drizzle_datetime_st*) stmt->query_params[param_num].data_buffer;
 
+  bzero(time, sizeof(*time));
+
   time->negative= is_negative;
   time->day= days;
   time->hour= hours;
@@ -145,6 +147,8 @@
   drizzle_datetime_st *timestamp;
   timestamp= (drizzle_datetime_st*) stmt->query_params[param_num].data_buffer;
 
+  bzero(timestamp, sizeof(*timestamp));
+
   timestamp->negative= false;
   timestamp->year= year;
   timestamp->day= day;
@@ -156,7 +160,7 @@
   timestamp->microsecond= microseconds;
 
   /* Length not important because we will figure that out when packing */ 
-  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TIME, timestamp, 0, false);
+  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TIMESTAMP, timestamp, 0, false);
 }
 
 bool drizzle_stmt_get_is_null_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
@@ -546,7 +550,7 @@
       val= (double) (*(float*)param->data);
       break;
     case DRIZZLE_COLUMN_TYPE_DOUBLE:
-      val= (uint32_t) (*(double*)param->data);
+      val= (*(double*)param->data);
       break;
     case DRIZZLE_COLUMN_TYPE_TIME:
     case DRIZZLE_COLUMN_TYPE_DATE:
@@ -619,29 +623,46 @@
 {
   /* Max time is -HHH:MM:SS.ssssss + NUL = 17 */
   char* buffer= param->data_buffer + 50;
-  if (time->microsecond == 0)
-  {
-    snprintf(buffer, 17, "%s%"PRIu16":%"PRIu8":%"PRIu8, (time->negative) ? "-" : "", time->hour, time->minute, time->second);
-  }
-  else
-  {
-    snprintf(buffer, 17, "%s%"PRIu16":%"PRIu8":%"PRIu8".%"PRIu32, (time->negative) ? "-" : "", time->hour, time->minute, time->second, time->microsecond);
-  }
+  int buffersize = 17;
+  int used = 0;
+    
+  /* Values are transferred with days separated from hours, but presented with days folded into hours. */
+  used = snprintf(buffer, buffersize-used, "%s%02u:%02"PRIu8":%02"PRIu8, (time->negative) ? "-" : "", time->hour + 24 * time->day, time->minute, time->second);
+
+  /* TODO: the existence (and length) of the decimals should be decided based on the number of fields sent by the server or possibly the column's "decimals" value, not by whether the microseconds are 0 */
+  if (time->microsecond)
+    used += snprintf(buffer+used, buffersize-used, ".%06" PRIu32, time->microsecond);
+  
+  assert(used < buffersize);
+    
   return buffer;
 }
 
 char *timestamp_to_string(drizzle_bind_st *param, drizzle_datetime_st *timestamp)
 {
-  /* Max timestamp is YYYY-MM-DD HH:MM:SS.ssssss + NUL = 26 */
+  /* Max timestamp is YYYY-MM-DD HH:MM:SS.ssssss + NUL = 27 */
   char* buffer= param->data_buffer + 50;
-  if (timestamp->microsecond == 0)
-  {
-    snprintf(buffer, 26, "%"PRIu16"-%"PRIu8"-%"PRIu32" %"PRIu16":%"PRIu8":%"PRIu8, timestamp->year, timestamp->month, timestamp->day, timestamp->hour, timestamp->minute, timestamp->second);
-  }
-  else
-  {
-    snprintf(buffer, 26, "%"PRIu16"-%"PRIu8"-%"PRIu32" %"PRIu16":%"PRIu8":%"PRIu8".%"PRIu32, timestamp->year, timestamp->month, timestamp->day, timestamp->hour, timestamp->minute, timestamp->second, timestamp->microsecond);
-  }
+  int buffersize = 27;
+  int used = 0;
+  
+  used += snprintf(buffer, buffersize-used, "%"PRIu16"-%02"PRIu8"-%02"PRIu32,
+     timestamp->year, timestamp->month, timestamp->day);
+  assert(used < buffersize);
+  
+  if (param->type == DRIZZLE_COLUMN_TYPE_DATE)
+    return buffer;
+  
+  used += snprintf(buffer+used, buffersize-used, " %02"PRIu16":%02"PRIu8":%02"PRIu8,
+    timestamp->hour, timestamp->minute, timestamp->second);
+
+  /* TODO: the existence (and length) of the decimals should be decided based on the number of fields sent by the server or possibly the column's "decimals" value, not by whether the microseconds are 0 */
+  if (timestamp->microsecond)
+  {
+    used += snprintf(buffer+used, buffersize-used, ".%06"PRIu32, timestamp->microsecond);
+  }
+  
+  assert(used < buffersize);
+  
   return buffer;
 }
 

=== modified file 'tests/unit/common.c'
--- tests/unit/common.c	2013-03-19 20:38:59 +0000
+++ tests/unit/common.c	2013-04-21 22:19:27 +0000
@@ -66,16 +66,16 @@
                       getenv("MYSQL_PASSWORD"),
                       getenv("MYSQL_SCHEMA"), 0);
   ASSERT_NOT_NULL_(con, "Drizzle connection object creation error");
-  atexit(close_connection_on_exit);
   
   driz_ret= drizzle_connect(con);
   SKIP_IF_(driz_ret == DRIZZLE_RETURN_COULD_NOT_CONNECT, "%s", drizzle_strerror(driz_ret));
+  atexit(close_connection_on_exit);
   ASSERT_EQ_(DRIZZLE_RETURN_OK, driz_ret, "%s(%s)", drizzle_error(con), drizzle_strerror(driz_ret));
 }
 
 void set_up_schema(void)
 {
-  drizzle_result_st *result;
+  drizzle_result_st VARIABLE_IS_NOT_USED *result;
   drizzle_return_t driz_ret;
 
   CHECKED_QUERY("DROP SCHEMA IF EXISTS libdrizzle");
@@ -85,7 +85,7 @@
 
 void tear_down_schema(void)
 {
-  drizzle_result_st *result;
+  drizzle_result_st VARIABLE_IS_NOT_USED *result;
   drizzle_return_t driz_ret;
 
   CHECKED_QUERY("DROP SCHEMA IF EXISTS libdrizzle");

=== modified file 'tests/unit/common.h'
--- tests/unit/common.h	2013-03-19 20:38:59 +0000
+++ tests/unit/common.h	2013-04-21 22:19:27 +0000
@@ -37,18 +37,21 @@
 
 #pragma once
 
-#ifdef  __cplusplus
-# include <cstdlib>
-# include <cstdio>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <libdrizzle-5.1/libdrizzle.h>
+
+#ifdef __GNUC__
+#define VARIABLE_IS_NOT_USED __attribute__ ((unused))
+#else
+#define VARIABLE_IS_NOT_USED
+#endif
+
+#ifdef __cplusplus
 extern "C" {
-#else
-# include <stdlib.h>
-# include <stdio.h>
 #endif
 
-#include <libdrizzle-5.1/libdrizzle.h>
-
-
 extern drizzle_st *con;
 
 /* Common connection setup used by the unit tests. 
@@ -61,10 +64,6 @@
 extern void set_up_schema(void);
 extern void tear_down_schema(void);
 
-#ifdef  __cplusplus
-} /* extern "C" */
-#endif
-
 /* Perform a query; assign the result to 'result' and the returncode to 'driz_ret'; assert that the returncode is DRIZZLE_RETURN_OK. */
 #define CHECKED_QUERY(cmd) result = drizzle_query(con, cmd, 0, &driz_ret); \
     ASSERT_EQ_(driz_ret, DRIZZLE_RETURN_OK, "Error (%s): %s, from \"%s\"", drizzle_strerror(driz_ret), drizzle_error(con), cmd);
@@ -73,4 +72,6 @@
 #define CHECK(s) driz_ret = (s); \
     ASSERT_EQ_(driz_ret, DRIZZLE_RETURN_OK, "Error (%s): %s, in \"%s\"", drizzle_strerror(driz_ret), drizzle_error(con), #s);
 
-
+#ifdef __cplusplus
+} /* extern "C" */
+#endif

=== modified file 'tests/unit/connect_uds.c'
--- tests/unit/connect_uds.c	2013-03-19 20:38:59 +0000
+++ tests/unit/connect_uds.c	2013-04-21 22:19:27 +0000
@@ -55,10 +55,10 @@
                       getenv("MYSQL_PASSWORD"),
                       getenv("MYSQL_SCHEMA"), 0);
   ASSERT_NOT_NULL_(con, "Drizzle connection object creation error");
-  atexit(close_connection_on_exit);
 
   drizzle_return_t ret= drizzle_connect(con);
   SKIP_IF_(ret == DRIZZLE_RETURN_COULD_NOT_CONNECT, "%s(%s)", drizzle_error(con), drizzle_strerror(ret));
+  atexit(close_connection_on_exit);
   ASSERT_EQ_(DRIZZLE_RETURN_OK, ret, "%s socket: %s", drizzle_strerror(ret), getenv("MYSQL_SOCK"));
 
   drizzle_query(con, "SELECT 1", 0, &ret);

=== modified file 'tests/unit/datetypes.c'
--- tests/unit/datetypes.c	2013-03-19 21:04:42 +0000
+++ tests/unit/datetypes.c	2013-04-21 22:19:27 +0000
@@ -35,6 +35,8 @@
  *
  */
 
+#define _GNU_SOURCE
+
 #include <yatl/lite.h>
 #include "tests/unit/common.h"
 
@@ -276,7 +278,8 @@
   for (unsigned checking_column = 2; checking_column < 10; checking_column ++) {
     const char *col_name = column_names[checking_column];
     char *query_buf = NULL;
-    asprintf(&query_buf, "select a, %s, cast(%s as char) from libdrizzle.dt1",
+    int VARIABLE_IS_NOT_USED unused;
+    unused = asprintf(&query_buf, "select a, %s, cast(%s as char) from libdrizzle.dt1",
 	     col_name, col_name);
     query = query_buf;
 

=== modified file 'tests/unit/include.am'
--- tests/unit/include.am	2013-03-19 21:04:42 +0000
+++ tests/unit/include.am	2013-04-21 22:19:27 +0000
@@ -49,6 +49,7 @@
 
 tests_unit_numbers_SOURCES= tests/unit/numbers.c tests/unit/common.c
 tests_unit_numbers_LDADD= libdrizzle/libdrizzle.la
+tests_unit_numbers_LDADD+= -lm
 check_PROGRAMS+= tests/unit/numbers
 noinst_PROGRAMS+= tests/unit/numbers
 

=== modified file 'tests/unit/numbers.c'
--- tests/unit/numbers.c	2013-03-19 20:38:59 +0000
+++ tests/unit/numbers.c	2013-04-21 22:19:27 +0000
@@ -257,8 +257,8 @@
       ASSERT_STREQ(expect_strval, col_strval);
     }
     
-    float expect_floatval;
-    double expect_dblval;
+    float expect_floatval = 0.0;
+    double expect_dblval = 0.0;
     switch (columnA) {
       case 1:
         expect_floatval = 1.0;