Merge lp:~mumair/drizzle/drizzle-IPv6Address into lp:~drizzle-trunk/drizzle/development

[Muhammad Umair]

merge lp:~mumair/drizzle/drizzle-IPv6Address

Participate in Google Summer of Code 2011 for the Drizzle Project. Establish Native IPV6 Date Type for Drizzle. Branch can be tested from the test case suit name "ipv6_type".

[Olaf van der Spek (olafvdspek)]

I think there's a problem with the diff. See for example drizzled/module/registry.cc
Seems you didn't pick up some updates in trunk.

review: Needs Fixing

[Stewart Smith (stewart)]

A couple of general comments:
- style
  - int foo()const; sholud have a space before 'const'
  - (C) header should follow standard format, and then have one for
    included code
- not sure about binary length versus string length, and some of the
  names for constants aren't obvious as to what you're referring to.

On Sun, 07 Aug 2011 13:22:59 -0000, Muhammad Umair <email address hidden> wrote:
> --- drizzled/field/ipv6.h 1970-01-01 00:00:00 +0000
> +++ drizzled/field/ipv6.h 2011-08-07 13:22:33 +0000
> + int store(double ) { return 0; }

this doesn't look right to me

> + inline String *val_str(String *str) { return val_str(str, str); }
> + uint32_t size_of() const { return sizeof(*this); }
> +
> + static size_t max_string_length()
> + {
> + return type::IPv6::LENGTH;
> + }
> +};
> --- drizzled/module/registry.cc 2011-06-23 11:44:30 +0000
> +++ drizzled/module/registry.cc 2011-08-07 13:22:33 +0000
> @@ -51,55 +50,85 @@
>
> module::Registry::~Registry()
> {
> + plugin::Plugin::map::iterator plugin_iter;
> +
> /* Give all plugins a chance to cleanup, before
> * all plugins are deleted.
> * This can be used if shutdown code references
> * other plugins.
> */
> - BOOST_FOREACH(plugin::Plugin::map::reference it, plugin_registry)
> - it.second->shutdownPlugin();
> + plugin_iter= plugin_registry.begin();
> + while (plugin_iter != plugin_registry.end())
> + {
> + (*plugin_iter).second->shutdownPlugin();
> + ++plugin_iter;
> + }

Any reason why BOOST_FOREACH replaced?

Most of the rest of the changes around BOOST things I'm also
questionable about, especially so in a patch that sholud only add a
type.

There are a lot of needless changes here.

> + sprintf( destination ,
> "%03x:%03x:%03x:%03x:%03x:%03x:%03d.%03d.%03d.%03d" ,

don't use sprintf, use safer function (such as snprintf)

> === modified file 'plugin/auth_file/auth_file.cc'
> --- plugin/auth_file/auth_file.cc 2011-06-21 12:02:57 +0000
> +++ plugin/auth_file/auth_file.cc 2011-08-07 13:22:33 +0000

this all looks unneeded

> +class Generate: public drizzled::Item_str_func
> +{
> +public:
> + Generate(): drizzled::Item_str_func() {}
> + void fix_length_and_dec()
> + {
> +
> + max_length= (drizzled::type::IPv6::IPV6_BUFFER_LENGTH) * drizzled::system_charset_info->mbmaxlen;
> + }
> + const char *func_name() const{ return "ipv6"; }
> + const char *fully_qualified_func_name() const { return "ipv6()"; }
> + drizzled::String *val_str(drizzled::String *);
> +};

function take any arguments? should have method fo rchecking argument count.

--
Stewart Smith

review: Needs Fixing

Unmerged revisions

2345. By Muhammad Umair <umair@RemoteDesk> on 2011-08-07

IPV6 Branch with passed test cases

2344. By Muhammad Umair <umair@RemoteDesk> on 2011-08-06

With Passed Test Cases

2343. By Muhammad Umair <umair@RemoteDesk> on 2011-08-06

IPV6 BRANCH

2342. By Muhammad Umair <umair@RemoteDesk> on 2011-08-05

Merged from trunk

2341. By Muhammad Umair <umair@RemoteDesk> on 2011-08-05

IPV6 Branch Updated

2340. By Muhammad Umair <umair@RemoteDesk> on 2011-08-02

IPV6 Branch

2339. By Muhammad Umair <umair@RemoteDesk> on 2011-07-28

IPV6 Branch

2338. By Muhammad Umair <umair@RemoteDesk> on 2011-07-26

IPV6 Branch

2337. By Muhammad Umair <umair@RemoteDesk> on 2011-07-23

IPV6 Branch

2336. By Muhammad Umair <umair@RemoteDesk> on 2011-07-21

IPV6 Branch with test cases

=== modified file 'drizzled/common.h'
--- drizzled/common.h	2011-05-21 00:29:07 +0000
+++ drizzled/common.h	2011-08-07 13:22:33 +0000
@@ -187,9 +187,10 @@
                         DRIZZLE_TYPE_TIME,
                         DRIZZLE_TYPE_BOOLEAN,
                         DRIZZLE_TYPE_UUID,
-                        DRIZZLE_TYPE_MICROTIME
+                        DRIZZLE_TYPE_MICROTIME,
+                        DRIZZLE_TYPE_IPV6
 };
-const int enum_field_types_size= DRIZZLE_TYPE_MICROTIME + 1;
+const int enum_field_types_size= DRIZZLE_TYPE_IPV6 + 1;
 
 } /* namespace drizzled */
 

=== modified file 'drizzled/create_field.cc'
--- drizzled/create_field.cc	2011-08-04 08:13:04 +0000
+++ drizzled/create_field.cc	2011-08-07 13:22:33 +0000
@@ -45,6 +45,7 @@
 #include <drizzled/field/datetime.h>
 #include <drizzled/field/varstring.h>
 #include <drizzled/field/uuid.h>
+#include <drizzled/field/ipv6.h>
 #include <drizzled/temporal.h>
 #include <drizzled/item/string.h>
 #include <drizzled/table.h>
@@ -290,6 +291,9 @@
     case DRIZZLE_TYPE_UUID:
       length= field::Uuid::max_string_length();
       break;
+    case DRIZZLE_TYPE_IPV6:
+      length= field::IPv6::max_string_length();
+      break;
     case DRIZZLE_TYPE_BOOLEAN:
       length= field::Boolean::max_string_length();
       break;

=== modified file 'drizzled/display.cc'
--- drizzled/display.cc	2011-05-21 00:29:07 +0000
+++ drizzled/display.cc	2011-08-07 13:22:33 +0000
@@ -56,6 +56,7 @@
 static const std::string DRIZZLE_TYPE_BLOB("DRIZZLE_TYPE_BLOB"); 
 static const std::string DRIZZLE_TYPE_UUID("DRIZZLE_TYPE_UUID"); 
 static const std::string DRIZZLE_TYPE_BOOLEAN("DRIZZLE_TYPE_BOOLEAN"); 
+static const std::string DRIZZLE_TYPE_IPV6("DRIZZLE_TYPE_IPV6"); 
 
 static const std::string FIELD_ITEM("FIELD_ITEM");
 static const std::string FUNC_ITEM("FUNC_ITEM");
@@ -279,6 +280,8 @@
     return DRIZZLE_TYPE_UUID;
   case drizzled::DRIZZLE_TYPE_BOOLEAN : 
     return DRIZZLE_TYPE_BOOLEAN;
+  case drizzled::DRIZZLE_TYPE_IPV6 : 
+    return DRIZZLE_TYPE_IPV6;
   }
 
   assert(0);

=== modified file 'drizzled/error.cc'
--- drizzled/error.cc	2011-03-24 00:03:05 +0000
+++ drizzled/error.cc	2011-08-07 13:22:33 +0000
@@ -597,6 +597,9 @@
   // For UUID type
   ADD_ERROR_MESSAGE(ER_INVALID_UUID_VALUE, N_("Received an invalid UUID value"));
   ADD_ERROR_MESSAGE(ER_INVALID_UUID_TIME, N_("The UUID was not created with a valid time"));
+  
+  // For IPV6 type
+  ADD_ERROR_MESSAGE(ER_INVALID_IPV6_VALUE, N_("Received an invalid IPV6 value"));
 
   // For BOOL type
   ADD_ERROR_MESSAGE(ER_INVALID_BOOLEAN_VALUE, N_("Received an invalid BOOLEAN value '%s'."));

=== modified file 'drizzled/error_t.h'
--- drizzled/error_t.h	2011-03-14 05:40:28 +0000
+++ drizzled/error_t.h	2011-08-07 13:22:33 +0000
@@ -850,6 +850,7 @@
   ER_INVALID_CAST_TO_UNSIGNED,
   ER_INVALID_UUID_TIME,
   ER_INVALID_UUID_VALUE,
+  ER_INVALID_IPV6_VALUE,
   ER_SQL_KEYWORD,
   ER_TABLE_DROP,
   ER_TABLE_DROP_ERROR_OCCURRED,

=== modified file 'drizzled/field.cc'
--- drizzled/field.cc	2011-08-03 10:04:55 +0000
+++ drizzled/field.cc	2011-08-07 13:22:33 +0000
@@ -48,6 +48,7 @@
 #include <drizzled/field/microtime.h>
 #include <drizzled/field/varstring.h>
 #include <drizzled/field/uuid.h>
+#include <drizzled/field/ipv6.h>
 #include <drizzled/time_functions.h>
 #include <drizzled/internal/m_string.h>
 #include <drizzled/table.h>
@@ -99,6 +100,8 @@
     DRIZZLE_TYPE_VARCHAR,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_DOUBLE -> */
   {
@@ -132,6 +135,8 @@
     DRIZZLE_TYPE_VARCHAR,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_NULL -> */
   {
@@ -165,6 +170,8 @@
     DRIZZLE_TYPE_UUID,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_MICROTIME,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_TIMESTAMP -> */
   {
@@ -198,6 +205,8 @@
     DRIZZLE_TYPE_VARCHAR,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_LONGLONG -> */
   {
@@ -230,6 +239,8 @@
     DRIZZLE_TYPE_VARCHAR,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_DATETIME -> */
   {
@@ -263,6 +274,8 @@
     DRIZZLE_TYPE_VARCHAR,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_DATE -> */
   {
@@ -296,6 +309,8 @@
     DRIZZLE_TYPE_VARCHAR,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_VARCHAR -> */
   {
@@ -329,6 +344,8 @@
     DRIZZLE_TYPE_VARCHAR,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_DECIMAL -> */
   {
@@ -362,6 +379,8 @@
     DRIZZLE_TYPE_VARCHAR,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_ENUM -> */
   {
@@ -395,6 +414,8 @@
     DRIZZLE_TYPE_VARCHAR,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
    },
   /* DRIZZLE_TYPE_BLOB -> */
   {
@@ -428,6 +449,8 @@
     DRIZZLE_TYPE_VARCHAR,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_TIME -> */
   {
@@ -461,6 +484,8 @@
     DRIZZLE_TYPE_UUID,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_BOOLEAN -> */
   {
@@ -494,6 +519,8 @@
     DRIZZLE_TYPE_VARCHAR,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_UUID -> */
   {
@@ -527,6 +554,8 @@
     DRIZZLE_TYPE_UUID,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
   },
   /* DRIZZLE_TYPE_MICROTIME -> */
   {
@@ -560,7 +589,45 @@
     DRIZZLE_TYPE_UUID,
     //DRIZZLE_TYPE_MICROTIME
     DRIZZLE_TYPE_MICROTIME,
-  },
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
+  },
+ /* DRIZZLE_TYPE_IPV6 -> */
+  {
+    //DRIZZLE_TYPE_LONG
+    DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_DOUBLE
+    DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_NULL
+    DRIZZLE_TYPE_IPV6,
+    //DRIZZLE_TYPE_TIMESTAMP
+    DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_LONGLONG
+    DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_DATETIME
+    DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_DATE
+    DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_VARCHAR
+    DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_DECIMAL
+    DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_VARCHAR,
+    DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_BLOB
+    DRIZZLE_TYPE_BLOB,
+    //DRIZZLE_TYPE_TIME
+    DRIZZLE_TYPE_TIME,
+    //DRIZZLE_TYPE_BOOLEAN
+    DRIZZLE_TYPE_VARCHAR,
+    //DRIZZLE_TYPE_UUID
+    DRIZZLE_TYPE_UUID,
+    //DRIZZLE_TYPE_MICROTIME
+    DRIZZLE_TYPE_MICROTIME,
+    //DRIZZLE_TYPE_IPV6
+    DRIZZLE_TYPE_VARCHAR,
+  },
+
 };
 
 static Item_result field_types_result_type [enum_field_types_size]=
@@ -595,6 +662,8 @@
   STRING_RESULT,
   //DRIZZLE_TYPE_MICROTIME
   STRING_RESULT,
+  //DRIZZLE_TYPE_IPV6
+  STRING_RESULT,
 };
 
 bool test_if_important_data(const charset_info_st * const cs, 
@@ -1111,6 +1180,7 @@
   case DRIZZLE_TYPE_MICROTIME: return field::Microtime::max_string_length();
   case DRIZZLE_TYPE_TIMESTAMP: return field::Epoch::max_string_length();
   case DRIZZLE_TYPE_BOOLEAN: return field::Boolean::max_string_length();
+  case DRIZZLE_TYPE_IPV6: return field::IPv6::max_string_length();
   case DRIZZLE_TYPE_DATE:
   case DRIZZLE_TYPE_ENUM:
   case DRIZZLE_TYPE_LONG: return 4;

=== modified file 'drizzled/field.h'
--- drizzled/field.h	2011-08-03 10:04:55 +0000
+++ drizzled/field.h	2011-08-07 13:22:33 +0000
@@ -762,6 +762,7 @@
   case DRIZZLE_TYPE_LONGLONG:
   case DRIZZLE_TYPE_NULL:
   case DRIZZLE_TYPE_UUID:
+  case DRIZZLE_TYPE_IPV6:
   case DRIZZLE_TYPE_VARCHAR:
     return false;
   }

=== added file 'drizzled/field/ipv6.cc'
--- drizzled/field/ipv6.cc	1970-01-01 00:00:00 +0000
+++ drizzled/field/ipv6.cc	2011-08-07 13:22:33 +0000
@@ -0,0 +1,143 @@
+/*
+  Original copyright header listed below. This comes via rsync.
+  Any additional changes are provided via the same license as the original.
+
+  Copyright (C) 2011 Muhammad Umair
+
+*/
+/*
+ * Copyright (C) 1996-2001  Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
+ * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+ * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <algorithm>
+
+
+
+#include <drizzled/field/ipv6.h>
+
+#include <drizzled/error.h>
+#include <drizzled/internal/my_sys.h>
+#include <drizzled/session.h>
+#include <drizzled/table.h>
+
+
+namespace drizzled
+{
+namespace field
+{
+
+IPv6::IPv6(unsigned char *ptr_arg,
+           uint32_t len_arg,
+           unsigned char *null_ptr_arg,
+           unsigned char null_bit_arg,
+           const char *field_name_arg) :
+  Field(ptr_arg, len_arg,
+        null_ptr_arg,
+        null_bit_arg,
+        Field::NONE,
+        field_name_arg)
+{
+}
+
+int IPv6::cmp(const unsigned char *a, const unsigned char *b)
+{
+  return memcmp(a, b, max_string_length());
+}
+
+  
+int IPv6::store(const char *from, uint32_t, const charset_info_st * const )
+{
+  ASSERT_COLUMN_MARKED_FOR_WRITE;
+  type::IPv6 ptr_address;
+
+
+  if (not ptr_address.inet_pton(from))
+  {
+    my_error(ER_INVALID_IPV6_VALUE, MYF(ME_FATALERROR));
+    return 1;
+  }
+
+ ptr_address.store_object(ptr);
+
+  return 0;
+}
+
+int IPv6::store(int64_t , bool )
+{
+  ASSERT_COLUMN_MARKED_FOR_WRITE;
+  my_error(ER_INVALID_IPV6_VALUE, MYF(ME_FATALERROR));
+  return 1;
+}
+
+int IPv6::store_decimal(const drizzled::type::Decimal*)
+{
+  ASSERT_COLUMN_MARKED_FOR_WRITE;
+  my_error(ER_INVALID_IPV6_VALUE, MYF(ME_FATALERROR));
+  return 1;
+}
+
+void IPv6::sql_type(String &res) const
+{
+  res.set_ascii(STRING_WITH_LEN("ipv6"));
+}
+
+double IPv6::val_real()const
+{
+  ASSERT_COLUMN_MARKED_FOR_READ;
+  my_error(ER_INVALID_IPV6_VALUE, MYF(ME_FATALERROR));
+  return 0;
+}
+
+int64_t IPv6::val_int()const
+{
+  ASSERT_COLUMN_MARKED_FOR_READ;
+  my_error(ER_INVALID_IPV6_VALUE, MYF(ME_FATALERROR));
+  return 0;
+}
+
+String *IPv6::val_str(String *val_buffer, String *)const
+{
+
+  const charset_info_st * const cs= &my_charset_bin;
+  uint32_t mlength= (type::IPv6::IPV6_BUFFER_LENGTH)  * cs->mbmaxlen;  
+  type::IPv6 ptr_address;
+
+  val_buffer->alloc(mlength);
+  char *buffer=(char*) val_buffer->ptr();
+ 
+
+  ASSERT_COLUMN_MARKED_FOR_READ;
+
+  ptr_address.restore_object(ptr);  
+  ptr_address.inet_ntop(buffer);
+
+  val_buffer->length(type::IPv6::IPV6_DISPLAY_LENGTH);
+
+  return val_buffer;
+
+}
+
+void IPv6::sort_string(unsigned char *to, uint32_t length_arg)
+{
+  assert(length_arg == type::IPv6::LENGTH);
+  memcpy(to, ptr, length_arg);
+}
+
+
+} /* namespace field */
+} /* namespace drizzled */

=== added file 'drizzled/field/ipv6.h'
--- drizzled/field/ipv6.h	1970-01-01 00:00:00 +0000
+++ drizzled/field/ipv6.h	2011-08-07 13:22:33 +0000
@@ -0,0 +1,84 @@
+/*
+  Original copyright header listed below. This comes via rsync.
+  Any additional changes are provided via the same license as the original.
+
+  Copyright (C) 2011 Muhammad Umair
+
+*/
+/*
+ * Copyright (C) 1996-2001  Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
+ * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+ * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+
+#ifndef DRIZZLED_FIELD_IPV6_H_INCLUDED
+#define DRIZZLED_FIELD_IPV6_H_INCLUDED
+
+
+#include <drizzled/field.h>
+#include <string>
+#include <drizzled/type/ipv6.h>
+
+
+namespace drizzled
+{
+namespace field
+{
+
+class IPv6:public Field {
+//  const CHARSET_INFO *field_charset;
+  const charset_info_st *field_charset;
+
+public:
+  IPv6(unsigned char *ptr_arg,
+            uint32_t len_arg,
+            unsigned char *null_ptr_arg,
+            unsigned char null_bit_arg,
+            const char *field_name_arg);
+
+  enum_field_types type() const { return DRIZZLE_TYPE_IPV6; }
+  enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
+  bool zero_pack() const { return 0; }
+  int  reset(void) { memset(ptr, 0, type::IPv6::LENGTH); return 0; }
+  uint32_t pack_length() const { return type::IPv6::LENGTH; }
+  uint32_t key_length() const { return type::IPv6::LENGTH; }
+
+  int  store(const char *to,uint32_t length, const charset_info_st * const charset);
+  int  store(int64_t nr, bool unsigned_val);
+  double val_real()const;
+  int64_t val_int()const;
+  String *val_str(String*,String *)const;
+  void sql_type(drizzled::String&) const;
+  int store_decimal(const drizzled::type::Decimal*);
+
+  Item_result result_type () const { return STRING_RESULT; }
+  int cmp(const unsigned char*, const unsigned char*);
+  void sort_string(unsigned char*, uint32_t);
+  uint32_t max_display_length() { return type::IPv6::IPV6_DISPLAY_LENGTH; }
+
+  int  store(double ) { return 0; }
+  inline String *val_str(String *str) { return val_str(str, str); }
+  uint32_t size_of() const { return sizeof(*this); }
+
+  static size_t max_string_length()
+  {
+    return type::IPv6::LENGTH;
+  }
+};
+
+} /* namespace field */
+} /* namespace drizzled */
+
+#endif // DRIZZLED_FIELD_IPV6_H_INCLUDED

=== modified file 'drizzled/include.am'
--- drizzled/include.am	2011-08-04 08:13:04 +0000
+++ drizzled/include.am	2011-08-07 13:22:33 +0000
@@ -111,6 +111,7 @@
 			      drizzled/field/str.h \
 			      drizzled/field/time.h \
 			      drizzled/field/uuid.h \
+			      drizzled/field/ipv6.h \
 			      drizzled/field/varstring.h \
 			      drizzled/field_iterator.h \
 			      drizzled/file_exchange.h \
@@ -506,6 +507,7 @@
 			      drizzled/type/decimal.h \
 			      drizzled/type/time.h \
 			      drizzled/type/uuid.h \
+			      drizzled/type/ipv6.h \
 			      drizzled/typelib.h \
 			      drizzled/unique.h \
 			      drizzled/unireg.h \
@@ -586,6 +588,7 @@
 			   drizzled/field/str.cc \
 			   drizzled/field/time.cc \
 			   drizzled/field/uuid.cc \
+			   drizzled/field/ipv6.cc \
 			   drizzled/field/varstring.cc \
 			   drizzled/field_conv.cc \
 			   drizzled/field_iterator.cc \

=== modified file 'drizzled/item.cc'
--- drizzled/item.cc	2011-07-07 13:57:49 +0000
+++ drizzled/item.cc	2011-08-07 13:22:33 +0000
@@ -1182,6 +1182,7 @@
     break;
   case DRIZZLE_TYPE_BOOLEAN:
   case DRIZZLE_TYPE_UUID:
+  case DRIZZLE_TYPE_IPV6:
   case DRIZZLE_TYPE_ENUM:
   case DRIZZLE_TYPE_VARCHAR:
     return make_string_field(table);
@@ -1330,6 +1331,7 @@
   case DRIZZLE_TYPE_VARCHAR:
   case DRIZZLE_TYPE_BOOLEAN:
   case DRIZZLE_TYPE_UUID:
+  case DRIZZLE_TYPE_IPV6:
   case DRIZZLE_TYPE_DECIMAL:
     {
       if (String* res=val_str(buffer))

=== modified file 'drizzled/item/type_holder.cc'
--- drizzled/item/type_holder.cc	2011-06-22 20:05:58 +0000
+++ drizzled/item/type_holder.cc	2011-08-07 13:22:33 +0000
@@ -209,6 +209,7 @@
   case DRIZZLE_TYPE_TIME:
   case DRIZZLE_TYPE_BOOLEAN:
   case DRIZZLE_TYPE_UUID:
+  case DRIZZLE_TYPE_IPV6:
   case DRIZZLE_TYPE_MICROTIME:
   case DRIZZLE_TYPE_TIMESTAMP:
   case DRIZZLE_TYPE_DATETIME:

=== modified file 'drizzled/message.cc'
--- drizzled/message.cc	2011-07-14 22:12:02 +0000
+++ drizzled/message.cc	2011-08-07 13:22:33 +0000
@@ -51,6 +51,7 @@
 static const std::string TIME("TIME");
 static const std::string UUID("UUID");
 static const std::string BOOLEAN("BOOLEAN");
+static const std::string IPV6("IPV6");
 
 static const std::string UNDEFINED("UNDEFINED");
 static const std::string RESTRICT("RESTRICT");
@@ -109,6 +110,7 @@
   case message::Table::Field::TIME:
   case message::Table::Field::UUID:
   case message::Table::Field::BOOLEAN:
+  case message::Table::Field::IPV6:
     break;
   }
 
@@ -147,6 +149,8 @@
     return UUID;
   case message::Table::Field::BOOLEAN:
     return BOOLEAN;
+  case message::Table::Field::IPV6:
+    return IPV6;
   }
 
   abort();
@@ -182,6 +186,8 @@
     return UUID;
   case message::Table::Field::BOOLEAN:
     return BOOLEAN;
+  case message::Table::Field::IPV6:
+    return IPV6;
   }
 
   abort();

=== modified file 'drizzled/message/statement_transform.cc'
--- drizzled/message/statement_transform.cc	2011-04-28 18:07:05 +0000
+++ drizzled/message/statement_transform.cc	2011-08-07 13:22:33 +0000
@@ -1425,6 +1425,9 @@
   case Table::Field::UUID:
     destination.append(" UUID");
     break;
+  case Table::Field::IPV6:
+    destination.append(" IPV6");
+    break;
   case Table::Field::BOOLEAN:
     destination.append(" BOOLEAN");
     break;
@@ -1606,6 +1609,8 @@
     return Table::Field::UUID;
   case DRIZZLE_TYPE_BOOLEAN:
     return Table::Field::BOOLEAN;
+  case DRIZZLE_TYPE_IPV6:
+    return Table::Field::IPV6;
   }
 
   assert(false);

=== modified file 'drizzled/message/table.proto'
--- drizzled/message/table.proto	2011-04-04 21:37:55 +0000
+++ drizzled/message/table.proto	2011-08-07 13:22:33 +0000
@@ -82,6 +82,7 @@
       UUID = 11;
       TIME = 12;
       BOOLEAN = 13;
+      IPV6 = 14;
     }
 
     message FieldOptions {

=== modified file 'drizzled/module/registry.cc'
--- drizzled/module/registry.cc	2011-06-23 11:44:30 +0000
+++ drizzled/module/registry.cc	2011-08-07 13:22:33 +0000
@@ -32,14 +32,13 @@
 #include <drizzled/show.h>
 #include <drizzled/cursor.h>
 #include <drizzled/abort_exception.h>
-#include <drizzled/util/find_ptr.h>
 
 #include <boost/bind.hpp>
-#include <boost/foreach.hpp>
 
 using namespace std;
 
-namespace drizzled {
+namespace drizzled
+{
 
 module::Registry::Registry() :
   module_registry_(),
@@ -51,55 +50,85 @@
 
 module::Registry::~Registry()
 {
+  plugin::Plugin::map::iterator plugin_iter;
+
   /* Give all plugins a chance to cleanup, before
    * all plugins are deleted.
    * This can be used if shutdown code references
    * other plugins.
    */
-  BOOST_FOREACH(plugin::Plugin::map::reference it, plugin_registry)
-    it.second->shutdownPlugin();
+  plugin_iter= plugin_registry.begin();
+  while (plugin_iter != plugin_registry.end())
+  {
+    (*plugin_iter).second->shutdownPlugin();
+    ++plugin_iter;
+  }
 
   plugin::Plugin::vector error_plugins;
-  BOOST_FOREACH(plugin::Plugin::map::reference it, plugin_registry)
+  plugin_iter= plugin_registry.begin();
+  while (plugin_iter != plugin_registry.end())
   {
-    if (it.second->removeLast())
-      error_plugins.push_back(it.second);
+    if ((*plugin_iter).second->removeLast())
+    {
+      error_plugins.push_back((*plugin_iter).second);
+    }
     else
-      delete it.second;
+    {
+      delete (*plugin_iter).second;
+    }
+    ++plugin_iter;
   }
 
-  BOOST_FOREACH(plugin::Plugin::vector::reference it, error_plugins)
-    delete it;
+  for (plugin::Plugin::vector::iterator iter= error_plugins.begin();
+       iter != error_plugins.end(); iter++)
+  {
+    delete *iter;
+  }
 
   plugin_registry.clear();
 
 #if 0
-  /*
   @TODO When we delete modules here, we segfault on a bad string. Why?
-   */
+   ModuleMap::iterator module_iter= module_registry_.begin();
 
-  BOOST_FOREACH(ModuleMap::reference it, module_registry_)
-    delete it.second;
+  while (module_iter != module_registry_.end())
+  {
+    delete (*module_iter).second;
+    ++module_iter;
+  }
   module_registry_.clear();
 #endif
-  BOOST_FOREACH(LibraryMap::reference it, library_registry_)
-    delete it.second;
+  LibraryMap::iterator library_iter= library_registry_.begin();
+  while (library_iter != library_registry_.end())
+  {
+    delete (*library_iter).second;
+    ++library_iter;
+  }
   library_registry_.clear();
 }
 
 void module::Registry::shutdown()
 {
-  delete &singleton();
+  module::Registry& registry= singleton();
+  delete &registry;
 }
 
-module::Module* module::Registry::find(const std::string& name)
+module::Module *module::Registry::find(std::string name)
 {
-  return find_ptr2(module_registry_, boost::to_lower_copy(name));
+  std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+
+  ModuleMap::iterator map_iter;
+  map_iter= module_registry_.find(name);
+  if (map_iter != module_registry_.end())
+    return (*map_iter).second;
+  return NULL;
 }
 
 void module::Registry::add(module::Module *handle)
 {
-  std::string add_str(boost::to_lower_copy(handle->getName()));
+  std::string add_str(handle->getName());
+  transform(add_str.begin(), add_str.end(),
+            add_str.begin(), ::tolower);
 
   module_registry_[add_str]= handle;
 
@@ -108,23 +137,45 @@
   depend_graph_->properties(handle_vertex)= vertex_info;
 
   handle->setVertexHandle(new VertexHandle(handle_vertex));
+
 }
 
 void module::Registry::remove(module::Module *handle)
 {
-  module_registry_.erase(boost::to_lower_copy(handle->getName()));
+  std::string remove_str(handle->getName());
+  std::transform(remove_str.begin(), remove_str.end(),
+                 remove_str.begin(), ::tolower);
+
+  module_registry_.erase(remove_str);
+}
+
+void module::Registry::copy(plugin::Plugin::vector &arg)
+{    
+  arg.reserve(plugin_registry.size());
+
+  std::transform(plugin_registry.begin(),
+                 plugin_registry.end(),
+                 std::back_inserter(arg),
+                 boost::bind(&plugin::Plugin::map::value_type::second, _1) );
+  assert(arg.size() == plugin_registry.size());
 }
 
 void module::Registry::buildDeps()
 {
-  BOOST_FOREACH(ModuleMap::reference map_iter, module_registry_)
+  ModuleMap::iterator map_iter= module_registry_.begin();
+  while (map_iter != module_registry_.end())
   {
-    Module* handle= map_iter.second;
-    BOOST_FOREACH(Module::Depends::const_reference handle_deps, handle->getDepends())
+    Module *handle= (*map_iter).second;
+    Module::Depends::const_iterator handle_deps= handle->getDepends().begin();
+    while (handle_deps != handle->getDepends().end())
     {
-      std::string dep_str(boost::to_lower_copy(handle_deps));
+      std::string dep_str((*handle_deps));
+      transform(dep_str.begin(), dep_str.end(),
+                dep_str.begin(), ::tolower);
+
       bool found_dep= false;
-      for (vertex_iter it= boost::vertices(depend_graph_->getGraph()).first; it != vertices(depend_graph_->getGraph()).second; it++)
+      vertex_iter it= boost::vertices(depend_graph_->getGraph()).first;
+      while (it != vertices(depend_graph_->getGraph()).second)
       {
         if (depend_graph_->properties(*it).getName() == dep_str)
         {
@@ -132,14 +183,21 @@
           add_edge(handle->getVertexHandle()->getVertexDesc(), *it, depend_graph_->getGraph());
           break;
         }
+        ++it;
       }
       if (not found_dep)
       {
-        errmsg_printf(error::ERROR, _("Couldn't process plugin module dependencies. %s depends on %s but %s is not to be loaded.\n"),
-          handle->getName().c_str(), dep_str.c_str(), dep_str.c_str());
+        errmsg_printf(error::ERROR,
+                      _("Couldn't process plugin module dependencies. "
+                        "%s depends on %s but %s is not to be loaded.\n"),
+                      handle->getName().c_str(),
+                      dep_str.c_str(), dep_str.c_str());
         DRIZZLE_ABORT;
       }
+
+      ++handle_deps;
     }
+    ++map_iter;
   }
   deps_built_= true;
 }
@@ -147,47 +205,67 @@
 module::Registry::ModuleList module::Registry::getList()
 {
   if (not deps_built_)
+  {
     buildDeps();
+  }
+
+  std::vector<module::Module *> plugins;
+
   VertexList vertex_list;
+
   boost::topological_sort(depend_graph_->getGraph(), std::back_inserter(vertex_list));
-  ModuleList plugins;
-  BOOST_FOREACH(VertexList::reference it, vertex_list)
+
+  for (VertexList::iterator i = vertex_list.begin();
+       i != vertex_list.end(); ++i)
   {
-    if (Module* mod_ptr= depend_graph_->properties(it).getModule())
+    Module *mod_ptr= depend_graph_->properties(*i).getModule();
+    if (mod_ptr != NULL)
+    {
       plugins.push_back(mod_ptr);
+    }  
   }
+
   return plugins;
 }
 
-module::Library *module::Registry::addLibrary(const std::string &plugin_name, bool builtin)
+module::Library *module::Registry::addLibrary(const std::string &plugin_name,
+                                              bool builtin)
 {
+
   /* If this dll is already loaded just return it */
   module::Library *library= findLibrary(plugin_name);
-  if (library)
+  if (library != NULL)
+  {
     return library;
+  }
 
   library= module::Library::loadLibrary(plugin_name, builtin);
-  if (library)
+  if (library != NULL)
   {
     /* Add this dll to the map */
     library_registry_.insert(make_pair(plugin_name, library));
   }
+
   return library;
 }
 
 void module::Registry::removeLibrary(const std::string &plugin_name)
 {
-  LibraryMap::iterator iter= library_registry_.find(plugin_name);
+  std::map<std::string, module::Library *>::iterator iter=
+    library_registry_.find(plugin_name);
   if (iter != library_registry_.end())
   {
+    library_registry_.erase(iter);
     delete iter->second;
-    library_registry_.erase(iter);
   }
 }
 
 module::Library *module::Registry::findLibrary(const std::string &plugin_name) const
 {
-  return find_ptr2(library_registry_, plugin_name);
+  LibraryMap::const_iterator iter= library_registry_.find(plugin_name);
+  if (iter != library_registry_.end())
+    return iter->second;
+  return NULL;
 }
 
 void module::Registry::shutdownModules()

=== modified file 'drizzled/module/registry.h'
--- drizzled/module/registry.h	2011-07-25 04:35:53 +0000
+++ drizzled/module/registry.h	2011-08-07 13:22:33 +0000
@@ -25,24 +25,24 @@
 #include <algorithm>
 #include <iosfwd>
 
-#include <boost/algorithm/string.hpp>
 #include <boost/scoped_ptr.hpp>
 
 #include <drizzled/gettext.h>
 #include <drizzled/unireg.h>
 #include <drizzled/errmsg_print.h>
 #include <drizzled/plugin/plugin.h>
-#include <drizzled/util/find_ptr.h>
+
 
 namespace drizzled {
 namespace module {
 
-class Registry : boost::noncopyable
+class Registry
 {
 public:
-  typedef std::map<std::string, Library*> LibraryMap;
-  typedef std::map<std::string, Module*> ModuleMap;
-  typedef std::vector<Module*> ModuleList;
+
+  typedef std::map<std::string, Library *> LibraryMap;
+  typedef std::map<std::string, Module *> ModuleMap;
+  typedef std::vector<Module *> ModuleList;
 private:
   LibraryMap library_registry_;
   ModuleMap module_registry_;
@@ -53,6 +53,8 @@
   bool deps_built_;
 
   Registry();
+  Registry(const Registry&);
+  Registry& operator=(const Registry&);
   ~Registry();
 
   void buildDeps();
@@ -60,18 +62,21 @@
 
   static Registry& singleton()
   {
-    static Registry* registry= new Registry();
+    static Registry *registry= new Registry();
     return *registry;
   }
 
+  void copy(plugin::Plugin::vector &arg);
+
   static void shutdown();
 
-  Module* find(const std::string&);
-
-  void add(Module*);
-  void remove(Module*);
-
-  ModuleList getList();
+  Module *find(std::string name);
+
+  void add(Module *module);
+
+  void remove(Module *module);
+
+  std::vector<Module *> getList();
 
   const plugin::Plugin::map &getPluginsMap() const
   {
@@ -93,21 +98,32 @@
   void add(T *plugin)
   {
     bool failed= false;
-    std::string plugin_type(boost::to_lower_copy(plugin->getTypeName()));
-    std::string plugin_name(boost::to_lower_copy(plugin->getName()));
-    if (find_ptr(plugin_registry, std::make_pair(plugin_type, plugin_name)))
-    {
-      errmsg_printf(error::ERROR, _("Loading plugin %s failed: a %s plugin by that name already exists.\n"), 
-        plugin->getTypeName().c_str(), plugin->getName().c_str());
-      failed= true;
-    }
-    if (T::addPlugin(plugin)) // Olaf: Should addPlugin be called when failed is already true?
-      failed= true; 
+    std::string plugin_type(plugin->getTypeName());
+    std::transform(plugin_type.begin(), plugin_type.end(),
+                   plugin_type.begin(), ::tolower);
+    std::string plugin_name(plugin->getName());
+    std::transform(plugin_name.begin(), plugin_name.end(),
+                   plugin_name.begin(), ::tolower);
+    if (plugin_registry.find(std::make_pair(plugin_type, plugin_name)) != plugin_registry.end())
+    {
+      errmsg_printf(error::ERROR,
+                    _("Loading plugin %s failed: a %s plugin by that name "
+                      "already exists.\n"),
+                    plugin->getTypeName().c_str(),
+                    plugin->getName().c_str());
+      failed= true;
+    }
+    if (T::addPlugin(plugin))
+    {
+      failed= true;
+    }
 
     if (failed)
     {
-      errmsg_printf(error::ERROR, _("Fatal error: Failed initializing %s::%s plugin.\n"), 
-        plugin->getTypeName().c_str(), plugin->getName().c_str());
+      errmsg_printf(error::ERROR,
+                    _("Fatal error: Failed initializing %s::%s plugin.\n"),
+                    plugin->getTypeName().c_str(),
+                    plugin->getName().c_str());
       unireg_abort(1);
     }
     plugin_registry.insert(std::make_pair(std::make_pair(plugin_type, plugin_name), plugin));
@@ -116,8 +132,12 @@
   template<class T>
   void remove(T *plugin)
   {
-    std::string plugin_type(boost::to_lower_copy(plugin->getTypeName()));
-    std::string plugin_name(boost::to_lower_copy(plugin->getName()));
+    std::string plugin_type(plugin->getTypeName());
+    std::transform(plugin_type.begin(), plugin_type.end(),
+                   plugin_type.begin(), ::tolower);
+    std::string plugin_name(plugin->getName());
+    std::transform(plugin_name.begin(), plugin_name.end(),
+                   plugin_name.begin(), ::tolower);
     T::removePlugin(plugin);
     plugin_registry.erase(std::make_pair(plugin_type, plugin_name));
   }

=== modified file 'drizzled/parser.cc'
--- drizzled/parser.cc	2011-08-03 10:04:55 +0000
+++ drizzled/parser.cc	2011-08-07 13:22:33 +0000
@@ -597,6 +597,15 @@
   return DRIZZLE_TYPE_UUID;
 }
 
+drizzled::enum_field_types buildIPv6Column(LEX *lex)
+{
+  if (lex->field())
+    lex->field()->set_type(message::Table::Field::IPV6);
+
+  return DRIZZLE_TYPE_IPV6;
+}
+
+
 drizzled::enum_field_types buildDoubleColumn(LEX *lex)
 {
   if (lex->field())

=== modified file 'drizzled/parser.h'
--- drizzled/parser.h	2011-08-03 10:04:55 +0000
+++ drizzled/parser.h	2011-08-07 13:22:33 +0000
@@ -147,6 +147,7 @@
 drizzled::enum_field_types buildBlobColumn(LEX *lex);
 drizzled::enum_field_types buildBooleanColumn(LEX *lex);
 drizzled::enum_field_types buildUuidColumn(LEX *lex);
+drizzled::enum_field_types buildIPv6Column(LEX *lex);
 drizzled::enum_field_types buildDoubleColumn(LEX *lex);
 drizzled::enum_field_types buildTimestampColumn(LEX *lex, const char *length);
 drizzled::enum_field_types buildDecimalColumn(LEX *lex);

=== modified file 'drizzled/plugin/listen.cc'
--- drizzled/plugin/listen.cc	2011-06-09 15:47:07 +0000
+++ drizzled/plugin/listen.cc	2011-08-07 13:22:33 +0000
@@ -32,16 +32,18 @@
 
 #include <poll.h>
 
-namespace drizzled {
-namespace plugin {
+namespace drizzled
+{
+namespace plugin
+{
 
-static std::vector<plugin::Listen*> listen_list;
-std::vector<plugin::Listen*> listen_fd_list;
+static std::vector<plugin::Listen *> listen_list;
+std::vector<plugin::Listen *> listen_fd_list;
 std::vector<pollfd> fd_list;
 uint32_t fd_count= 0;
 int wakeup_pipe[2];
 
-ListenVector& Listen::getListenProtocols()
+ListenVector &Listen::getListenProtocols()
 {
   return listen_list;
 }
@@ -54,34 +56,42 @@
 
 void Listen::removePlugin(plugin::Listen *listen_obj)
 {
-  listen_list.erase(std::remove(listen_list.begin(), listen_list.end(), listen_obj), listen_list.end());
+  listen_list.erase(std::remove(listen_list.begin(),
+                                listen_list.end(),
+                                listen_obj),
+                    listen_list.end());
 }
 
-bool Listen::setup()
+bool Listen::setup(void)
 {
-  BOOST_FOREACH(plugin::Listen* it, listen_list)
+  std::vector<plugin::Listen *>::iterator it;
+
+  for (it= listen_list.begin(); it < listen_list.end(); ++it)
   {
     std::vector<int> fds;
-    if (it->getFileDescriptors(fds))
+    std::vector<int>::iterator fd;
+
+    if ((*it)->getFileDescriptors(fds))
     {
       errmsg_printf(error::ERROR, _("Error getting file descriptors"));
       return true;
     }
 
     fd_list.resize(fd_count + fds.size() + 1);
-    
-    BOOST_FOREACH(int fd, fds)
+
+    for (fd= fds.begin(); fd < fds.end(); ++fd)
     {
-      fd_list[fd_count].fd= fd;
+      fd_list[fd_count].fd= *fd;
       fd_list[fd_count].events= POLLIN | POLLERR;
-      listen_fd_list.push_back(it);
+      listen_fd_list.push_back(*it);
       fd_count++;
     }
   }
 
   if (fd_count == 0)
   {
-    errmsg_printf(error::ERROR, _("No sockets could be bound for listening"));
+    errmsg_printf(error::ERROR,
+                  _("No sockets could be bound for listening"));
     return true;
   }
 
@@ -104,17 +114,21 @@
   return false;
 }
 
-Client *plugin::Listen::getClient()
+Client *plugin::Listen::getClient(void)
 {
+  int ready;
+  plugin::Client *client;
+
   while (1)
   {
-    int ready= poll(&fd_list[0], fd_count, -1);
+    ready= poll(&fd_list[0], fd_count, -1);
     if (ready == -1)
     {
       if (errno != EINTR)
       {
         sql_perror("poll()");
       }
+
       continue;
     }
     else if (ready == 0)
@@ -142,22 +156,25 @@
         return NULL;
       }
 
-      if (plugin::Client* client= listen_fd_list[x]->getClient(fd_list[x].fd))
-        return client;
+      if (!(client= listen_fd_list[x]->getClient(fd_list[x].fd)))
+        continue;
+
+      return client;
     }
   }
 }
 
-Client *plugin::Listen::getNullClient()
+Client *plugin::Listen::getNullClient(void)
 {
   return new plugin::NullClient();
 }
 
-void Listen::shutdown()
+void Listen::shutdown(void)
 {
   ssize_t ret= write(wakeup_pipe[1], "\0", 1);
   assert(ret == 1);
 }
 
+
 } /* namespace plugin */
 } /* namespace drizzled */

=== modified file 'drizzled/sql_table.cc'
--- drizzled/sql_table.cc	2011-07-07 13:41:07 +0000
+++ drizzled/sql_table.cc	2011-08-07 13:22:33 +0000
@@ -503,6 +503,7 @@
   case DRIZZLE_TYPE_NULL:
   case DRIZZLE_TYPE_TIME:
   case DRIZZLE_TYPE_UUID:
+  case DRIZZLE_TYPE_IPV6:
   case DRIZZLE_TYPE_VARCHAR:
     break;
   }

=== modified file 'drizzled/sql_yacc.yy'
--- drizzled/sql_yacc.yy	2011-08-04 08:13:04 +0000
+++ drizzled/sql_yacc.yy	2011-08-07 13:22:33 +0000
@@ -365,6 +365,7 @@
 %token  IS                            /* SQL-2003-R */
 %token  ISOLATION                     /* SQL-2003-R */
 %token  ITERATE_SYM
+%token  IPV6_SYM
 %token  JOIN_SYM                      /* SQL-2003-R */
 %token  KEYS
 %token  KEY_BLOCK_SIZE
@@ -1335,6 +1336,10 @@
           {
             $$= parser::buildUuidColumn(&Lex);
           }
+        | IPV6_SYM opt_attribute
+          {
+            $$= parser::buildIPv6Column(&Lex);
+          }
         | BOOLEAN_SYM opt_attribute_boolean
           {
             $$= parser::buildBooleanColumn(&Lex);
@@ -3047,6 +3052,14 @@
             }
             Lex.setCacheable(false);
 	  }
+        | IPV6_SYM '(' ')'
+          {
+            if (! ($$= parser::reserved_keyword_function(YYSession, "ipv6", NULL)))
+            {
+              DRIZZLE_YYABORT;
+            }
+            Lex.setCacheable(false);
+	  }
         | WAIT_SYM '(' expr ',' expr ')'
           {
             List<Item> *args= new (YYSession->mem_root) List<Item>;
@@ -5301,6 +5314,7 @@
         | IMPORT                   {}
         | INDEXES                  {}
         | ISOLATION                {}
+        | IPV6_SYM                 {}
         | KEY_BLOCK_SIZE           {}
         | LAST_SYM                 {}
         | LEVEL_SYM                {}

=== modified file 'drizzled/symbol_hash.gperf'
--- drizzled/symbol_hash.gperf	2011-07-01 18:59:28 +0000
+++ drizzled/symbol_hash.gperf	2011-08-07 13:22:33 +0000
@@ -209,6 +209,7 @@
 IS, IS
 ISOLATION, ISOLATION
 ITERATE, ITERATE_SYM
+IPV6, IPV6_SYM
 JOIN, JOIN_SYM
 KEY, KEY_SYM
 KEYS, KEYS

=== modified file 'drizzled/table/instance/base.cc'
--- drizzled/table/instance/base.cc	2011-08-04 08:13:04 +0000
+++ drizzled/table/instance/base.cc	2011-08-07 13:22:33 +0000
@@ -80,6 +80,7 @@
 #include <drizzled/field/microtime.h>
 #include <drizzled/field/varstring.h>
 #include <drizzled/field/uuid.h>
+#include <drizzled/field/ipv6.h>
 #include <drizzled/plugin/storage_engine.h>
 #include <drizzled/definition/cache.h>
 #include <drizzled/typelib.h>
@@ -132,6 +133,9 @@
   case message::Table::Field::UUID:
     return  DRIZZLE_TYPE_UUID;
 
+  case message::Table::Field::IPV6:
+    return  DRIZZLE_TYPE_IPV6;
+
   case message::Table::Field::BOOLEAN:
     return DRIZZLE_TYPE_BOOLEAN;
 
@@ -185,6 +189,7 @@
   case DRIZZLE_TYPE_DATE:
   case DRIZZLE_TYPE_ENUM:
   case DRIZZLE_TYPE_UUID:
+  case DRIZZLE_TYPE_IPV6:
   case DRIZZLE_TYPE_MICROTIME:
   case DRIZZLE_TYPE_BOOLEAN:
     default_item= new Item_string(default_value->c_str(),
@@ -1169,6 +1174,9 @@
     case DRIZZLE_TYPE_UUID:
       field_length= field::Uuid::max_string_length();
       break;
+    case DRIZZLE_TYPE_IPV6:
+      field_length= field::IPv6::max_string_length();
+      break;
     case DRIZZLE_TYPE_BOOLEAN:
       field_length= field::Boolean::max_string_length();
       break;
@@ -1228,6 +1236,7 @@
     case DRIZZLE_TYPE_LONGLONG:
     case DRIZZLE_TYPE_NULL:
     case DRIZZLE_TYPE_UUID:
+    case DRIZZLE_TYPE_IPV6:
     case DRIZZLE_TYPE_BOOLEAN:
       break;
     }
@@ -1955,6 +1964,12 @@
                                        null_pos,
                                        null_bit,
                                        field_name);
+  case DRIZZLE_TYPE_IPV6:
+    return new (&mem_root) field::IPv6(ptr,
+                                       field_length,
+                                       null_pos,
+                                       null_bit,
+                                       field_name);
   case DRIZZLE_TYPE_BOOLEAN:
     return new (&mem_root) field::Boolean(ptr,
                                           field_length,

=== modified file 'drizzled/table_proto.cc'
--- drizzled/table_proto.cc	2011-07-24 16:27:12 +0000
+++ drizzled/table_proto.cc	2011-08-07 13:22:33 +0000
@@ -135,6 +135,7 @@
     case message::Table::Field::DATE:
     case message::Table::Field::DATETIME:
     case message::Table::Field::UUID:
+    case message::Table::Field::IPV6:
     case message::Table::Field::TIME:
     case message::Table::Field::BOOLEAN:
       break;

=== added file 'drizzled/type/ipv6.h'
--- drizzled/type/ipv6.h	1970-01-01 00:00:00 +0000
+++ drizzled/type/ipv6.h	2011-08-07 13:22:33 +0000
@@ -0,0 +1,470 @@
+/*
+  Original copyright header listed below. This comes via rsync.
+  Any additional changes are provided via the same license as the original.
+
+  Copyright (C) 2011 Muhammad Umair
+
+*/
+/*
+ * Copyright (C) 1996-2001  Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
+ * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+ * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+
+#ifndef DRIZZLED_TYPE_IPV6_ADDRESS_H_INCLUDED
+#define DRIZZLED_TYPE_IPV6_ADDRESS_H_INCLUDED
+
+
+
+#include<cstdio>
+#include<cstring>
+#include <iostream>
+
+
+namespace drizzled
+{
+namespace type
+{
+
+class IPv6 {
+
+    struct ipv6_ds
+    {
+    	unsigned short ip6[8];
+    }str;
+    
+    //Function to store the IPv4 address in IPv6 Data Structure
+    int ipv4_inet_pton(const char *src)
+    {
+
+	    char *ptr_src ;
+
+	    char ipv6h[20],ipv4[16], octet_h[5],octet_h1[5],group[20];
+	    int octet[4],octet_index = 0;
+
+	    memset(ipv6h, NULL, sizeof(ipv6h));
+	    strcpy(ipv6h,src);
+
+	    memset(octet, NULL, sizeof(octet));
+	    memset(ipv4, NULL, sizeof(ipv4));
+	    memset(octet_h, NULL, sizeof(octet_h));
+	    memset(octet_h1, NULL, sizeof(octet_h1));
+	    memset(group, NULL, sizeof(group));
+
+	    ptr_src = strtok(ipv6h,"::");
+
+	    strcpy(ipv4,ptr_src);
+
+	    ptr_src = strtok(ipv4,".");
+
+	    while (ptr_src != '\0')
+	    {
+
+		sscanf( ptr_src,"%d", &octet[octet_index]);
+
+		 if(octet[octet_index++] > 255)
+		 {
+		    return 0; // Invalid IP Address
+		 }
+
+		ptr_src = strtok (NULL, ".");
+
+	    }// end of main while loop
+
+
+	    if(octet_index < 4 || octet_index > 4)
+	    {
+		return 0; // Invalid IP Address
+	    }
+
+
+	    octet_index = 0;
+
+            str.ip6[0] = str.ip6[1] = str.ip6[2] = str.ip6[3] = str.ip6[4] = str.ip6[5] =0;
+
+	    for (int i=6 ; i <= 7; i++)
+	    {
+		if (i == 7)
+		{
+		    ++octet_index;
+		}
+
+		sprintf(octet_h, "%02x", octet[octet_index]);
+
+		sprintf(octet_h1, "%02x", octet[++octet_index]);
+
+		strcpy(group,octet_h);
+
+		strcat(group,octet_h1);
+
+		sscanf(group,"%x",(unsigned int *)&str.ip6[i]);
+
+		memset(octet_h, NULL, sizeof(octet_h));
+
+		memset(octet_h1, NULL, sizeof(octet_h1));
+
+		memset(group, NULL, sizeof(group));
+	    }
+
+	    return 1;
+    }//end of ipv4_inet_pton() function
+
+    //Function to retain the IPv4 address from IPv6 Data Structure
+    char * ipv4_inet_ntop(char *destination)
+    {
+
+	    memset(destination,NULL,sizeof(destination));
+
+	    sprintf( destination , "%03x:%03x:%03x:%03x:%03x:%03x:%03d.%03d.%03d.%03d" ,
+	    str.ip6[0],str.ip6[1],str.ip6[2],str.ip6[3],str.ip6[4],str.ip6[5],
+	    (((unsigned int )str.ip6[6]>>8) & 0xFF),
+	    ((unsigned int )str.ip6[6] & 0xFF),
+	    (((unsigned int )str.ip6[7]>>8) & 0xFF),
+	    ((unsigned int )str.ip6[7] & 0xFF));
+
+	    return destination;
+
+     }// end of ipv4_inet_ntop function
+
+
+    //Function to store the IPv6 address in IPv6 Data Structure
+    int ipv6_inet_pton(const char *src)
+    {
+        //Local variables
+        char ipv6[IPV6_BUFFER_LENGTH];
+        
+        memset(ipv6,NULL,IPV6_BUFFER_LENGTH);
+        
+        strcpy(ipv6,src);
+        
+        char ipv6_temp[IPV6_BUFFER_LENGTH], ipv6_temp1[IPV6_BUFFER_LENGTH], ipv6_temp2[IPV6_BUFFER_LENGTH];
+
+        memset(ipv6_temp,NULL,IPV6_BUFFER_LENGTH);
+
+        strcpy(ipv6_temp,ipv6);
+
+        memset(ipv6_temp1,NULL,IPV6_BUFFER_LENGTH);
+
+        strcpy(ipv6_temp1,ipv6);
+
+        memset(ipv6_temp2,NULL,IPV6_BUFFER_LENGTH);
+
+        strcpy(ipv6_temp2,ipv6);
+
+
+        static const char hex[] = "0123456789abcdef";
+        char temp[IPV6_BUFFER_LENGTH];
+        char *ptr_src ,*ptr_char, *ptr_src1;
+        const char *char_ptr_src;  // get the src char
+        int char_int = NULL, index_ip6 = 0 ,octet_count=0, not_colon = 0, col =0, count_col = 0;
+        char temp_first[IPV6_BUFFER_LENGTH],temp_end[IPV6_BUFFER_LENGTH];
+
+        memset(temp_first, NULL,IPV6_BUFFER_LENGTH);
+
+        memset(temp_end, NULL,IPV6_BUFFER_LENGTH);
+
+/*
+        if (sizeof(ipv6) > IPV6_BUFFER_LENGTH)
+        {
+            return (0); //Invalid IP Address
+        }
+
+*/
+        ptr_src = ipv6;
+        //while loop check three consective colons
+         while (*ptr_src != '\0')
+         {
+
+            if (*ptr_src == ':' && *++ptr_src == ':' && *++ptr_src == ':')
+            {
+                return 0; // Invalid IP Address
+            }
+
+            ++ptr_src;
+          }
+
+        //while loop count the total number of octets
+        ptr_src = strtok (ipv6_temp2,":");
+
+
+        while (ptr_src != NULL)
+        {
+            octet_count++;
+
+            ptr_src = strtok (NULL, ":");
+        }
+
+        //Retrun zero if total number of octets are greater than 8
+        if(octet_count > 8)
+        {
+            return 0 ; // Invalid IP Address
+        }
+
+        int num_miss_octet =0, size =0; 
+
+
+	num_miss_octet = 8 - octet_count;
+        size = 2*num_miss_octet +1;
+        
+	char * zero_append = new char[size];
+
+
+        memset(zero_append,NULL,sizeof(zero_append));
+
+
+        ptr_src = ipv6_temp;
+
+        //while loop locate the "::" position (start,middle or end)
+        while(*ptr_src != '\0')
+        {
+            if(*ptr_src == ':' && *++ptr_src == ':')
+            {
+                if (*++ptr_src=='\0')
+                {
+                    col =2;
+                }
+                else if (not_colon == 0)
+                {
+                    col=1;
+                }
+                else
+                {
+                    col=3;
+                }
+
+                count_col++;
+
+                if(count_col == 2)
+                {
+                    return 0; // Invalid IP Address. Ther must be single time double  colon '::'
+                }
+            }
+
+            ptr_src++;
+            not_colon++;
+        }// end of while loop
+
+        // if col = 0 means the IPv6 Address string is in presffered form otherwise first it covert it into prefeered form
+        if(col>0)
+        {
+            //zero padding format according to the '::' position
+            strcpy(zero_append,"");
+
+
+            for (int i= 0; i < num_miss_octet; i++)
+            {
+                if(col==1) // start
+                {
+                    strcat(zero_append,"0:");
+                }
+                if(col==2 || col==3)  //middle or end col =2 shows at end
+                {
+                    strcat(zero_append,":0");
+                }
+            }
+            if(col==3)
+            {
+                strcat(zero_append,":");
+            }
+
+            ptr_src = temp_end;
+
+            if(col==1 || col==3)
+            {  //only for start and middle
+
+              ptr_src1 = strstr (ipv6_temp,"::");
+
+              ptr_src1 = ptr_src1+2;
+
+              while(*ptr_src1 != '\0')
+              {
+                *ptr_src++ = *ptr_src1++;
+
+                if(*ptr_src1 == '\0')
+                {
+                    *ptr_src ='\0';
+                }
+              }
+            }
+
+            //copy the input IPv6 string before and after '::'
+            ptr_src1 = strstr (ipv6_temp1,"::");
+
+            *ptr_src1 ='\0';
+
+
+            strcpy(temp_first,ipv6_temp1);
+
+            if(col==2) // end
+            {
+                strcat(temp_first,zero_append);
+            }
+            else
+            {
+                strcat(temp_first,zero_append);
+
+                strcat(temp_first,temp_end);
+            }
+
+            memset(ipv6,NULL,IPV6_BUFFER_LENGTH);
+
+            strcpy(ipv6,temp_first);
+        }// end of main if statement
+
+
+
+        //while loop store each octet on ipv6 struture in decimal value of hexadecimal digits
+        ptr_char = temp;
+
+        ptr_src = strtok (ipv6,":");
+
+
+        while (ptr_src != NULL)
+        {
+                strcpy(temp, ptr_src);
+
+                ptr_char = temp;
+
+                int octet_length = strlen(ptr_char);
+
+                *(ptr_char + octet_length) = '\0';
+
+
+                while(*ptr_char != '\0')
+                {
+                    char_int = tolower(*ptr_char);
+
+                    char_ptr_src = strchr (hex, char_int);
+
+                    if(char_ptr_src == NULL)
+                    {
+                        return 0; // Invalid IP Address
+
+                    }
+
+                        *ptr_char = *char_ptr_src;
+                        ptr_char++;
+                }//end of inner while loop
+
+                ptr_char-= octet_length;
+
+
+                unsigned int  *ptr  =  (unsigned int *)&(str.ip6[index_ip6++]);
+
+                sscanf( ptr_char,"%x", ptr);
+
+
+                memset(temp,NULL,IPV6_BUFFER_LENGTH);
+
+
+                ptr_src = strtok (NULL, ":");
+        }// end of main while loop
+	
+	delete [] zero_append;
+
+        return 1;
+    }// end of Ipv6_Inet_pton function
+
+    //Function to retain the IPv6 address from IPv6 Data Structure
+    char* ipv6_inet_ntop(char *destination)
+    {
+        char temp[10];
+
+        memset(temp,NULL,sizeof(temp));
+
+        memset(destination,NULL,IPV6_BUFFER_LENGTH);
+        
+    
+        for (int i= 0; i <= 7; i++)
+        {
+            if(i==7)
+            {
+                sprintf(temp,"%04x",str.ip6[i]);
+
+                strcat(destination,temp);
+            }
+            else
+            {
+                sprintf(temp,"%04x:",str.ip6[i]);
+
+                strcat(destination,temp);
+            }
+
+            memset(temp,NULL,sizeof(temp));
+        }
+
+
+        return destination;
+    }// end of Ipv6_Inet_ntop function
+
+
+    public:
+
+    IPv6()
+    {
+        str.ip6[0] = str.ip6[1] = str.ip6[2] = str.ip6[3] = str.ip6[4] = str.ip6[5] = str.ip6[6] = str.ip6[7] = 0;    
+    }
+
+
+    void store_object(unsigned char *out)
+    {
+	memcpy(out, (unsigned char *)&str, sizeof(str));
+    }
+
+    void restore_object(const unsigned char * in)
+    {
+    	memcpy(&str, (struct ipv6_ds *)in,  sizeof(str));
+    } 
+
+    int inet_pton(const char *ip)
+    {
+         char * pch;
+
+         pch=strchr((char *)ip,'.');
+
+         if(pch == NULL)
+         {
+            return ipv6_inet_pton(ip);
+         }
+         else
+         {
+            return ipv4_inet_pton(ip);
+         }
+    }
+
+    char * inet_ntop(char *dest)
+    {
+        if (str.ip6[0]==0 && str.ip6[1]==0 && str.ip6[2]==0 && str.ip6[3]==0 && str.ip6[4]==0 && str.ip6[5]==0 && str.ip6[6]!=0)
+        {
+            return ipv4_inet_ntop(dest);
+        }
+        else
+        {
+            return ipv6_inet_ntop(dest);
+        }
+    }
+    
+
+    static const size_t LENGTH= 16;
+    static const size_t IPV6_DISPLAY_LENGTH= 39;
+    static const size_t IPV6_BUFFER_LENGTH= IPV6_DISPLAY_LENGTH+1;
+
+};  // endof class
+
+
+} /* namespace type */
+} /* namespace drizzled */
+
+#endif // DRIZZLED_TYPE_IPV6_ADDRESS_H_INCLUDED

=== modified file 'plugin/auth_file/auth_file.cc'
--- plugin/auth_file/auth_file.cc	2011-06-21 12:02:57 +0000
+++ plugin/auth_file/auth_file.cc	2011-08-07 13:22:33 +0000
@@ -40,19 +40,23 @@
 using namespace std;
 using namespace drizzled;
 
-namespace auth_file {
+namespace auth_file
+{
 
 static const fs::path DEFAULT_USERS_FILE= SYSCONFDIR "/drizzle.users";
 
-class AuthFile : public plugin::Authentication
+class AuthFile: public plugin::Authentication
 {
+  const fs::path users_file;
+
 public:
-  AuthFile(fs::path users_file_arg);
+
+  AuthFile(string name_arg, fs::path users_file_arg);
 
   /**
    * Retrieve the last error encountered in the class.
    */
-  const string& getError() const;
+  string& getError(void);
 
   /**
    * Load the users file into a map cache.
@@ -60,7 +64,7 @@
    * @return True on success, false on error. If false is returned an error
    *  is set and can be retrieved with getError().
    */
-  bool loadFile();
+  bool loadFile(void);
 
 private:
 
@@ -85,41 +89,44 @@
                        const string &scrambled_password);
 
   string error;
-  const fs::path users_file;
 
   /**
    * Cache or username:password entries from the file.
    */
-  typedef std::map<string, string> users_t;
-  users_t users;
+  std::map<string, string> users;
 };
 
-AuthFile::AuthFile(fs::path users_file_arg) :
-  plugin::Authentication("auth_file"),
-  users_file(users_file_arg)
+AuthFile::AuthFile(string name_arg, fs::path users_file_arg):
+  plugin::Authentication(name_arg),
+  users_file(users_file_arg),
+  error(),
+  users()
 {
 }
 
-const string& AuthFile::getError() const
+string& AuthFile::getError(void)
 {
   return error;
 }
 
-bool AuthFile::loadFile()
+bool AuthFile::loadFile(void)
 {
   ifstream file(users_file.string().c_str());
 
   if (!file.is_open())
   {
-    error = "Could not open users file: " + users_file.string();
+    error = "Could not open users file: ";
+    error += users_file.string();
     return false;
   }
 
-  string line;
-  while (getline(file, line))
+  while (!file.eof())
   {
+    string line;
+    getline(file, line);
+
     /* Ignore blank lines and lines starting with '#'. */
-    if (line.empty() || line[line.find_first_not_of(" \t")] == '#')
+    if (line == "" || line[line.find_first_not_of(" \t")] == '#')
       continue;
 
     string username;
@@ -133,12 +140,19 @@
       password = string(line, password_offset + 1);
     }
 
-    if (not users.insert(pair<string, string>(username, password)).second)
+    std::pair<std::map<std::string, std::string>::iterator, bool> result=
+      users.insert(std::pair<std::string, std::string>(username, password));
+
+    if (result.second == false)
     {
-      error = "Duplicate entry found in users file: " + username;
+      error = "Duplicate entry found in users file: ";
+      error += username;
+      file.close();
       return false;
     }
   }
+
+  file.close();
   return true;
 }
 
@@ -146,7 +160,8 @@
                                const string &scramble_bytes,
                                const string &scrambled_password)
 {
-  if (scramble_bytes.size() != SHA1_DIGEST_LENGTH || scrambled_password.size() != SHA1_DIGEST_LENGTH)
+  if (scramble_bytes.size() != SHA1_DIGEST_LENGTH ||
+      scrambled_password.size() != SHA1_DIGEST_LENGTH)
   {
     return false;
   }
@@ -158,7 +173,8 @@
 
   /* Generate the double SHA1 hash for the password stored locally first. */
   SHA1Init(&ctx);
-  SHA1Update(&ctx, reinterpret_cast<const uint8_t *>(password.c_str()), password.size());
+  SHA1Update(&ctx, reinterpret_cast<const uint8_t *>(password.c_str()),
+             password.size());
   SHA1Final(temp_hash, &ctx);
 
   SHA1Init(&ctx);
@@ -167,7 +183,8 @@
 
   /* Hash the scramble that was sent to client with the local password. */
   SHA1Init(&ctx);
-  SHA1Update(&ctx, reinterpret_cast<const uint8_t*>(scramble_bytes.c_str()), SHA1_DIGEST_LENGTH);
+  SHA1Update(&ctx, reinterpret_cast<const uint8_t*>(scramble_bytes.c_str()),
+             SHA1_DIGEST_LENGTH);
   SHA1Update(&ctx, local_scrambled_password, SHA1_DIGEST_LENGTH);
   SHA1Final(temp_hash, &ctx);
 
@@ -187,22 +204,28 @@
 
 bool AuthFile::authenticate(const identifier::User &sctx, const string &password)
 {
-  string* user= find_ptr(users, sctx.username());
-  if (not user)
+  std::map<std::string, std::string>::const_iterator user= users.find(sctx.username());
+  if (user == users.end())
     return false;
-  return sctx.getPasswordType() == identifier::User::MYSQL_HASH
-    ? verifyMySQLHash(*user, sctx.getPasswordContext(), password)
-    : password == *user;
+
+  if (sctx.getPasswordType() == identifier::User::MYSQL_HASH)
+    return verifyMySQLHash(user->second, sctx.getPasswordContext(), password);
+
+  if (password == user->second)
+    return true;
+
+  return false;
 }
 
 static int init(module::Context &context)
 {
   const module::option_map &vm= context.getOptions();
 
-  AuthFile *auth_file = new AuthFile(fs::path(vm["users"].as<string>()));
+  AuthFile *auth_file = new AuthFile("auth_file", fs::path(vm["users"].as<string>()));
   if (not auth_file->loadFile())
   {
-    errmsg_printf(error::ERROR, _("Could not load auth file: %s\n"), auth_file->getError().c_str());
+    errmsg_printf(error::ERROR, _("Could not load auth file: %s\n"),
+                  auth_file->getError().c_str());
     delete auth_file;
     return 1;
   }

=== modified file 'plugin/innobase/handler/ha_innodb.cc'
--- plugin/innobase/handler/ha_innodb.cc	2011-07-25 14:24:19 +0000
+++ plugin/innobase/handler/ha_innodb.cc	2011-08-07 13:22:33 +0000
@@ -3903,6 +3903,8 @@
   case DRIZZLE_TYPE_BLOB:
     return(DATA_BLOB);
   case DRIZZLE_TYPE_BOOLEAN:
+  case DRIZZLE_TYPE_IPV6:
+   return(DATA_FIXBINARY);
   case DRIZZLE_TYPE_UUID:
     return(DATA_FIXBINARY);
   case DRIZZLE_TYPE_NULL:

=== added directory 'plugin/ipv6_function'
=== added file 'plugin/ipv6_function/ipv6_function.cc'
--- plugin/ipv6_function/ipv6_function.cc	1970-01-01 00:00:00 +0000
+++ plugin/ipv6_function/ipv6_function.cc	2011-08-07 13:22:33 +0000
@@ -0,0 +1,107 @@
+/*
+  Original copyright header listed below. This comes via rsync.
+  Any additional changes are provided via the same license as the original.
+
+  Copyright (C) 2011 Muhammad Umair
+
+*/
+/*
+ * Copyright (C) 1996-2001  Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
+ * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+ * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+
+#include <config.h>
+#include <drizzled/error.h>
+#include <drizzled/charset.h>
+#include <drizzled/function/str/strfunc.h>
+#include <drizzled/item/func.h>
+#include <drizzled/plugin/function.h>
+#include <drizzled/type/ipv6.h>
+
+
+namespace plugin {
+namespace ipv6_function {
+
+class Generate: public drizzled::Item_str_func
+{
+public:
+  Generate(): drizzled::Item_str_func() {}
+  void fix_length_and_dec()
+  {
+
+    max_length= (drizzled::type::IPv6::IPV6_BUFFER_LENGTH) * drizzled::system_charset_info->mbmaxlen;
+  }
+  const char *func_name() const{ return "ipv6"; }
+  const char *fully_qualified_func_name() const { return "ipv6()"; }
+  drizzled::String *val_str(drizzled::String *);
+};
+
+
+drizzled::String *Generate::val_str(drizzled::String *str)
+{
+  drizzled::String _result;
+  drizzled::String *result= val_str(&_result);
+  drizzled::type::IPv6 ptr_address;
+
+  if (not ptr_address.inet_pton(result->c_str()))
+  {
+    drizzled::my_error(drizzled::ER_INVALID_IPV6_VALUE, MYF(ME_FATALERROR));
+     str->length(0);
+
+    return str;
+  }
+
+  char *ipv6_string;
+  str->realloc(drizzled::type::IPv6::IPV6_BUFFER_LENGTH);
+  str->length(drizzled::type::IPv6::IPV6_BUFFER_LENGTH);
+  str->set_charset(drizzled::system_charset_info);
+  ipv6_string= (char *) str->ptr();
+
+  if (not ptr_address.inet_ntop(ipv6_string))
+  {
+    drizzled::my_error(drizzled::ER_INVALID_IPV6_VALUE, MYF(ME_FATALERROR));
+    str->length(0);
+
+    return str;
+  }
+  str->length(max_length);
+
+  return str;
+}
+
+} // namespace ipv6_function
+} // namespace plugin
+
+static int initialize(drizzled::module::Context &context)
+{
+  context.add(new drizzled::plugin::Create_function<plugin::ipv6_function::Generate>("ipv6"));
+
+  return 0;
+}
+
+DRIZZLE_DECLARE_PLUGIN
+{
+  DRIZZLE_VERSION_ID,
+  "ipv6",
+  "1.0",
+  "Muhammad Umair",
+  "IPV6() function",
+  drizzled::PLUGIN_LICENSE_GPL,
+  initialize, /* Plugin Init */
+  NULL,   /* depends */
+  NULL    /* config options */
+}
+DRIZZLE_DECLARE_PLUGIN_END;

=== added file 'plugin/ipv6_function/plugin.ini'
--- plugin/ipv6_function/plugin.ini	1970-01-01 00:00:00 +0000
+++ plugin/ipv6_function/plugin.ini	2011-08-07 13:22:33 +0000
@@ -0,0 +1,9 @@
+[plugin]
+title=IPV6() plugin
+author=Muhammad Umair
+version=1.0
+license=PLUGIN_LICENSE_GPL
+description=IPV6() function plugin
+load_by_default=yes
+sources= ipv6_function.cc
+static=yes

=== modified file 'plugin/logging_stats/scoreboard.cc'
--- plugin/logging_stats/scoreboard.cc	2011-07-05 16:50:17 +0000
+++ plugin/logging_stats/scoreboard.cc	2011-08-07 13:22:33 +0000
@@ -63,25 +63,39 @@
   /* calculate the number of elements in each bucket */
   number_per_bucket= static_cast<uint32_t> ( ceil( static_cast<double>(number_sessions) / static_cast<double>(number_buckets) ) );
 
-  vector_of_scoreboard_vectors.reserve(number_buckets);
   /* populate the vector of scoreboard vectors */
   for (uint32_t j= 0; j < number_buckets; ++j)
   {
-    vector<ScoreboardSlot* > *scoreboard_vector= new vector<ScoreboardSlot*>;
+    vector<ScoreboardSlot* > *scoreboard_vector= new vector<ScoreboardSlot* >();
 
-    scoreboard_vector->reserve(number_per_bucket);
     /* preallocate the individual vectors */
+    vector<ScoreboardSlot* >::iterator scoreboard_vector_iterator= scoreboard_vector->begin();
     for (uint32_t h= 0; h < number_per_bucket; ++h)
-      scoreboard_vector->push_back(new ScoreboardSlot);
+    {
+      ScoreboardSlot *scoreboard_slot= new ScoreboardSlot();
+      scoreboard_vector_iterator= scoreboard_vector->insert(scoreboard_vector_iterator, scoreboard_slot);
+    }  
+    scoreboard_vector->resize(number_per_bucket);
+
 
     /* insert the vector into the vector of scoreboard vectors */
-    vector_of_scoreboard_vectors.push_back(scoreboard_vector); 
+    vector<vector<ScoreboardSlot* >* >::iterator vector_of_scoreboard_vectors_iterator= 
+      vector_of_scoreboard_vectors.begin();
+
+    vector_of_scoreboard_vectors_iterator= 
+      vector_of_scoreboard_vectors.insert(vector_of_scoreboard_vectors_iterator, scoreboard_vector); 
   }
+  vector_of_scoreboard_vectors.resize(number_buckets);
   
-  vector_of_scoreboard_locks.reserve(number_buckets);
   /* populate the scoreboard locks vector each ScoreboardSlot vector gets a lock */
+  vector<boost::shared_mutex* >::iterator vector_of_scoreboard_locks_iterator= vector_of_scoreboard_locks.begin();
   for (uint32_t k= 0; k < number_buckets; ++k)
-    vector_of_scoreboard_locks.push_back(new boost::shared_mutex);
+  {
+    boost::shared_mutex* lock= new boost::shared_mutex();
+    vector_of_scoreboard_locks_iterator= 
+      vector_of_scoreboard_locks.insert(vector_of_scoreboard_locks_iterator, lock);   
+  } 
+  vector_of_scoreboard_locks.resize(number_buckets);
 
   /* calculate the approximate memory allocation of the scoreboard */
   size_t statusVarsSize= sizeof(StatusVars) + sizeof(system_status_var);
@@ -92,19 +106,37 @@
 
 Scoreboard::~Scoreboard()
 {
-  BOOST_FOREACH(std::vector<ScoreboardSlot*>* it0, vector_of_scoreboard_vectors)
-  {
-    BOOST_FOREACH(ScoreboardSlot* it, *it0)
-      delete it; 
-    delete it0;
+  vector<vector<ScoreboardSlot* >* >::iterator v_of_scoreboard_v_begin_it= vector_of_scoreboard_vectors.begin();
+  vector<vector<ScoreboardSlot* >* >::iterator v_of_scoreboard_v_end_it= vector_of_scoreboard_vectors.end();
+
+  for (; v_of_scoreboard_v_begin_it != v_of_scoreboard_v_end_it; ++v_of_scoreboard_v_begin_it)
+  {
+    vector<ScoreboardSlot* > *scoreboard_vector= *v_of_scoreboard_v_begin_it; 
+
+    vector<ScoreboardSlot* >::iterator scoreboard_vector_it= scoreboard_vector->begin();
+    vector<ScoreboardSlot* >::iterator scoreboard_vector_end= scoreboard_vector->end();
+    for (; scoreboard_vector_it != scoreboard_vector_end; ++scoreboard_vector_it)
+    {
+      delete *scoreboard_vector_it; 
+    }
+    
+    scoreboard_vector->clear();
+    delete scoreboard_vector;
+  } // vector_of_scoreboard_vectors is not on the stack and does not deletion
+  
+  vector<boost::shared_mutex* >::iterator vector_of_scoreboard_locks_it= vector_of_scoreboard_locks.begin();
+  vector<boost::shared_mutex* >::iterator vector_of_scoreboard_locks_end= vector_of_scoreboard_locks.end();
+
+  for (; vector_of_scoreboard_locks_it != vector_of_scoreboard_locks_end; ++vector_of_scoreboard_locks_it)
+  {
+    boost::shared_mutex* lock= *vector_of_scoreboard_locks_it;
+    delete lock;
   }
-  BOOST_FOREACH(boost::shared_mutex* it, vector_of_scoreboard_locks)
-    delete it;
 }
 
-uint32_t Scoreboard::getBucketNumber(Session *session) const
+uint32_t Scoreboard::getBucketNumber(Session *session)
 {
-  return session->getSessionId() % number_buckets;
+  return (session->getSessionId() % number_buckets);
 }
 
 ScoreboardSlot* Scoreboard::findScoreboardSlotToLog(Session *session) 
@@ -118,29 +150,39 @@
   /* Check if this session has already claimed a slot */
   int32_t session_scoreboard_slot= session->getScoreboardIndex();
 
-  if (session_scoreboard_slot != -1)
-    return scoreboard_vector->at(session_scoreboard_slot);
-
-  boost::shared_mutex* LOCK_scoreboard_vector= vector_of_scoreboard_locks.at(bucket_number);
-  LOCK_scoreboard_vector->lock();
-
-  int32_t slot_index= 0;
-  for (vector<ScoreboardSlot*>::iterator it= scoreboard_vector->begin(); it != scoreboard_vector->end(); ++it, ++slot_index)
-  {
-    ScoreboardSlot& slot= **it;
-    if (slot.isInUse())
-      continue;
-    slot.setInUse(true);
-    slot.setSessionId(session->getSessionId());
-    slot.setUser(session->user()->username());
-    slot.setIp(session->user()->address());
-    session->setScoreboardIndex(slot_index);
-    LOCK_scoreboard_vector->unlock();
-    return &slot; 
+  if (session_scoreboard_slot == -1)
+  {
+    boost::shared_mutex* LOCK_scoreboard_vector= vector_of_scoreboard_locks.at(bucket_number);
+    LOCK_scoreboard_vector->lock();
+ 
+    ScoreboardSlot *scoreboard_slot= NULL;
+
+    int32_t slot_index= 0;
+    for (vector<ScoreboardSlot *>::iterator it= scoreboard_vector->begin();
+         it != scoreboard_vector->end(); ++it, ++slot_index)
+    {
+      scoreboard_slot= *it;
+
+      if (scoreboard_slot->isInUse() == false)
+      {
+        scoreboard_slot->setInUse(true);
+        scoreboard_slot->setSessionId(session->getSessionId());
+        scoreboard_slot->setUser(session->user()->username());
+        scoreboard_slot->setIp(session->user()->address());
+        session->setScoreboardIndex(slot_index);
+        LOCK_scoreboard_vector->unlock();
+        return scoreboard_slot; 
+      }
+    }
+  
+    LOCK_scoreboard_vector->unlock(); 
+  } 
+  else // already claimed a slot just do a lookup
+  {
+    ScoreboardSlot *scoreboard_slot= scoreboard_vector->at(session_scoreboard_slot);
+    return scoreboard_slot;  
   }
 
-  LOCK_scoreboard_vector->unlock(); 
-
   /* its possible we did not claim a slot if the scoreboard size is somehow smaller then the 
      active connections */ 
   return NULL; 
@@ -148,9 +190,20 @@
 
 ScoreboardSlot* Scoreboard::findOurScoreboardSlot(Session *session)
 {
+  /* our bucket */
+  uint32_t bucket_number= getBucketNumber(session);
+
+  /* our vector corresponding to bucket_number */
+  vector<ScoreboardSlot* > *scoreboard_vector= vector_of_scoreboard_vectors.at(bucket_number);
+
   /* Check if this session has already claimed a slot */
   int32_t session_scoreboard_slot= session->getScoreboardIndex();
+
   if (session_scoreboard_slot == -1) 
+  {
     return NULL;
-  return vector_of_scoreboard_vectors.at(getBucketNumber(session))->at(session_scoreboard_slot);
+  }
+
+  ScoreboardSlot *scoreboard_slot= scoreboard_vector->at(session_scoreboard_slot);
+  return scoreboard_slot;
 }

=== modified file 'plugin/logging_stats/scoreboard.h'
--- plugin/logging_stats/scoreboard.h	2011-07-05 16:50:17 +0000
+++ plugin/logging_stats/scoreboard.h	2011-08-07 13:22:33 +0000
@@ -62,19 +62,19 @@
    */
   ScoreboardSlot* findOurScoreboardSlot(drizzled::Session *session);
 
-  uint32_t getBucketNumber(drizzled::Session*) const;
+  uint32_t getBucketNumber(drizzled::Session *session);
 
-  uint32_t getNumberBuckets() const
+  uint32_t getNumberBuckets()
   {
     return number_buckets;
   }
 
-  uint32_t getNumberPerBucket() const
+  uint32_t getNumberPerBucket()
   {
     return number_per_bucket;
   }
 
-  uint64_t getScoreboardSizeBytes() const
+  uint64_t getScoreboardSizeBytes()
   {
     return scoreboard_size_bytes;
   } 
@@ -94,8 +94,8 @@
   uint32_t number_per_bucket;
   uint32_t number_buckets;
   uint64_t scoreboard_size_bytes;
-  std::vector<std::vector<ScoreboardSlot*>*> vector_of_scoreboard_vectors;
-  std::vector<boost::shared_mutex*> vector_of_scoreboard_locks;
+  std::vector<std::vector<ScoreboardSlot* >* > vector_of_scoreboard_vectors;
+  std::vector<boost::shared_mutex* > vector_of_scoreboard_locks;
 
   ScoreboardSlot* claimOpenScoreboardSlot(drizzled::Session *session); 
 };

=== modified file 'plugin/mysql_protocol/mysql_protocol.cc'
--- plugin/mysql_protocol/mysql_protocol.cc	2011-06-13 14:33:05 +0000
+++ plugin/mysql_protocol/mysql_protocol.cc	2011-08-07 13:22:33 +0000
@@ -516,6 +516,10 @@
         pos[6]= DRIZZLE_COLUMN_TYPE_VARCHAR;
         break;
 
+      case DRIZZLE_TYPE_IPV6:
+        pos[6]= DRIZZLE_COLUMN_TYPE_VARCHAR;
+        break;
+
       case DRIZZLE_TYPE_BOOLEAN:
         pos[6]= DRIZZLE_COLUMN_TYPE_TINY;
         break;

=== modified file 'tests/include.am'
--- tests/include.am	2011-07-28 07:57:26 +0000
+++ tests/include.am	2011-08-07 13:22:33 +0000
@@ -23,7 +23,7 @@
 GENSCRIPTS =		tests/dtr tests/mtr tests/test-run tests/dbqp
 PRESCRIPTS =		tests/test-run.pl tests/stress-test.pl
 PLUGIN_TESTS =		$(pandora_plugin_test_list)
-NORMAL_TESTS =		main,bool_type,cast,ddl_transactions,execute,flush_tables,identifiers,jp,mysql_compatibility,regression,tamil,time_type,unsigned_integer_type,uuid_type,microtime_type,$(PLUGIN_TESTS)
+NORMAL_TESTS =		main,bool_type,cast,ddl_transactions,execute,flush_tables,identifiers,jp,mysql_compatibility,regression,tamil,time_type,unsigned_integer_type,ipv6_type,uuid_type,microtime_type,$(PLUGIN_TESTS)
 ALL_TESTS =		main,big,jp,tamil,regression,microtime_type,$(PLUGIN_TESTS)
 noinst_SCRIPTS =	$(GENSCRIPTS) $(PRESCRIPTS)
 CLEANFILES += 		$(GENSCRIPTS) tests/mtr

=== added directory 'tests/suite/ipv6_type'
=== added directory 'tests/suite/ipv6_type/r'
=== added file 'tests/suite/ipv6_type/r/alter_add_ipv6.result'
--- tests/suite/ipv6_type/r/alter_add_ipv6.result	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/r/alter_add_ipv6.result	2011-08-07 13:22:33 +0000
@@ -0,0 +1,44 @@
+CREATE TABLE t1 (A INT);
+SHOW CREATE TABLE t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `A` INT DEFAULT NULL
+) ENGINE=InnoDB COLLATE = utf8_general_ci
+ALTER TABLE t1 ADD COLUMN b IPV6 NOT NULL;
+SHOW CREATE TABLE t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `A` INT DEFAULT NULL,
+  `b` IPV6 NOT NULL
+) ENGINE=InnoDB COLLATE = utf8_general_ci
+DROP TABLE t1;
+CREATE TABLE t1 (A INT);
+SHOW CREATE TABLE t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `A` INT DEFAULT NULL
+) ENGINE=InnoDB COLLATE = utf8_general_ci
+INSERT INTO t1 VALUES (1), (2), (3);
+SELECT COUNT(*) = 3 FROM t1;
+COUNT(*) = 3
+1
+ALTER TABLE t1 ADD COLUMN b IPV6 NOT NULL;
+ERROR HY000: Either a DEFAULt value or NULL NULL description is required for a new column if table is not empty
+SHOW CREATE TABLE t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `A` INT DEFAULT NULL
+) ENGINE=InnoDB COLLATE = utf8_general_ci
+ALTER TABLE t1 ADD COLUMN b IPV6 DEFAULT NULL;
+SELECT A,B FROM t1;
+A	B
+1	NULL
+2	NULL
+3	NULL
+SHOW CREATE TABLE t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `A` INT DEFAULT NULL,
+  `b` IPV6 DEFAULT NULL
+) ENGINE=InnoDB COLLATE = utf8_general_ci
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/r/bad_conversions.result'
--- tests/suite/ipv6_type/r/bad_conversions.result	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/r/bad_conversions.result	2011-08-07 13:22:33 +0000
@@ -0,0 +1,24 @@
+CREATE TABLE t1 (a IPV6, PRIMARY KEY(a));
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` IPV6 NOT NULL,
+  PRIMARY KEY (`a`) USING BTREE
+) ENGINE=InnoDB COLLATE = utf8_general_ci
+INSERT INTO t1 VALUES ("10FB::C:ABC:1F0C:44DA");
+SELECT a FROM t1;
+a
+10fb:0000:0000:0000:000c:0abc:1f0c:44da
+CREATE TABLE t2 (a REAL);
+INSERT INTO t2 SELECT a FROM t1 LIMIT 1;
+ERROR 01000: Data truncated for column 'a' at row 1
+SELECT a FROM t2;
+a
+CREATE TABLE t3 (a REAL);
+INSERT INTO t3 SELECT a FROM t1 LIMIT 1;
+ERROR 01000: Data truncated for column 'a' at row 1
+SELECT a FROM t3;
+a
+DROP TABLE t3;
+DROP TABLE t2;
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/r/count.result'
--- tests/suite/ipv6_type/r/count.result	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/r/count.result	2011-08-07 13:22:33 +0000
@@ -0,0 +1,19 @@
+CREATE TABLE t1 (a IPV6);
+INSERT INTO t1 VALUES ("fe8::b3ff:fe1a:8329");
+INSERT INTO t1 VALUES ("::1");
+INSERT INTO t1 VALUES ("::192.168.100.10");
+INSERT INTO t1 VALUES ("2001:db8:85a3::8a2e:370:7334");
+SELECT a FROM t1;
+a
+0fe8:0000:0000:0000:0000:b3ff:fe1a:8329
+0000:0000:0000:0000:0000:0000:0000:0001
+000:000:000:000:000:000:192.168.100.010
+2001:0db8:85a3:0000:0000:8a2e:0370:7334
+SELECT count(a) FROM t1;
+count(a)
+4
+TRUNCATE t1;
+SELECT count(a) FROM t1;
+count(a)
+0
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/r/create.result'
--- tests/suite/ipv6_type/r/create.result	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/r/create.result	2011-08-07 13:22:33 +0000
@@ -0,0 +1,7 @@
+CREATE TABLE t1 (a IPV6);
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` IPV6 DEFAULT NULL
+) ENGINE=InnoDB COLLATE = utf8_general_ci
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/r/delete.result'
--- tests/suite/ipv6_type/r/delete.result	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/r/delete.result	2011-08-07 13:22:33 +0000
@@ -0,0 +1,23 @@
+CREATE TABLE t1 (a IPV6);
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` IPV6 DEFAULT NULL
+) ENGINE=InnoDB COLLATE = utf8_general_ci
+INSERT INTO t1 VALUES ("fe8::b3ff:fe1a:8329");
+INSERT INTO t1 VALUES ("::1");
+INSERT INTO t1 VALUES ("::192.168.100.10");
+INSERT INTO t1 VALUES ("2001:db8:85a3::8a2e:370:7334");
+SELECT a FROM t1;
+a
+0fe8:0000:0000:0000:0000:b3ff:fe1a:8329
+0000:0000:0000:0000:0000:0000:0000:0001
+000:000:000:000:000:000:192.168.100.010
+2001:0db8:85a3:0000:0000:8a2e:0370:7334
+DELETE FROM t1 WHERE a = "0000:0000:0000:0000:0000:0000:0000:0001";
+SELECT a FROM t1;
+a
+0fe8:0000:0000:0000:0000:b3ff:fe1a:8329
+000:000:000:000:000:000:192.168.100.010
+2001:0db8:85a3:0000:0000:8a2e:0370:7334
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/r/mixed.result'
--- tests/suite/ipv6_type/r/mixed.result	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/r/mixed.result	2011-08-07 13:22:33 +0000
@@ -0,0 +1,17 @@
+CREATE TABLE t1 (a IPV6);
+CREATE TABLE t2 (a VARCHAR(39));
+INSERT INTO t1 VALUES ("2001:db8:85a3::8a2e:370:7334");
+SELECT a FROM t1;
+a
+2001:0db8:85a3:0000:0000:8a2e:0370:7334
+INSERT INTO t2 SELECT a FROM t1;
+SELECT a FROM t2;
+a
+2001:0db8:85a3:0000:0000:8a2e:0370:7334
+TRUNCATE t1;
+INSERT INTO t1 SELECT a FROM t2;
+SELECT a FROM t2;
+a
+2001:0db8:85a3:0000:0000:8a2e:0370:7334
+DROP TABLE t2;
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/r/order_by.result'
--- tests/suite/ipv6_type/r/order_by.result	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/r/order_by.result	2011-08-07 13:22:33 +0000
@@ -0,0 +1,23 @@
+CREATE TABLE t1 (a IPV6);
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` IPV6 DEFAULT NULL
+) ENGINE=InnoDB COLLATE = utf8_general_ci
+INSERT INTO t1 VALUES ("fe8::b3ff:fe1a:8329");
+INSERT INTO t1 VALUES ("::1");
+INSERT INTO t1 VALUES ("::192.168.100.10");
+INSERT INTO t1 VALUES ("2001:db8:85a3::8a2e:370:7334");
+SELECT a FROM t1;
+a
+0fe8:0000:0000:0000:0000:b3ff:fe1a:8329
+0000:0000:0000:0000:0000:0000:0000:0001
+000:000:000:000:000:000:192.168.100.010
+2001:0db8:85a3:0000:0000:8a2e:0370:7334
+SELECT a FROM t1 ORDER BY a;
+a
+0000:0000:0000:0000:0000:0000:0000:0001
+000:000:000:000:000:000:192.168.100.010
+2001:0db8:85a3:0000:0000:8a2e:0370:7334
+0fe8:0000:0000:0000:0000:b3ff:fe1a:8329
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/r/primary_key.result'
--- tests/suite/ipv6_type/r/primary_key.result	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/r/primary_key.result	2011-08-07 13:22:33 +0000
@@ -0,0 +1,14 @@
+CREATE TABLE t1 (a IPV6, PRIMARY KEY(a));
+INSERT INTO t1 VALUES ("fe8::b3ff:fe1a:8329");
+INSERT INTO t1 VALUES ("::1");
+INSERT INTO t1 VALUES ("::192.168.100.10");
+INSERT INTO t1 VALUES ("2001:db8:85a3::8a2e:370:7334");
+INSERT INTO t1 VALUES ("2001:db8:85a3::8a2e:370:7334");
+ERROR 23000: Duplicate entry '2001:0db8:85a3:0000:0000:8a2e:0370:7334' for key 'PRIMARY'
+SELECT a FROM t1 ORDER BY a;
+a
+0000:0000:0000:0000:0000:0000:0000:0001
+000:000:000:000:000:000:192.168.100.010
+2001:0db8:85a3:0000:0000:8a2e:0370:7334
+0fe8:0000:0000:0000:0000:b3ff:fe1a:8329
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/r/select_like_no_key.result'
--- tests/suite/ipv6_type/r/select_like_no_key.result	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/r/select_like_no_key.result	2011-08-07 13:22:33 +0000
@@ -0,0 +1,18 @@
+CREATE TABLE t1 (a IPV6);
+INSERT INTO t1 VALUES ("fe8::b3ff:fe1a:8329");
+INSERT INTO t1 VALUES ("FD01::1F");
+INSERT INTO t1 VALUES ("::192.168.100.10");
+INSERT INTO t1 VALUES ("::1");
+SELECT a FROM t1;
+a
+0fe8:0000:0000:0000:0000:b3ff:fe1a:8329
+fd01:0000:0000:0000:0000:0000:0000:001f
+000:000:000:000:000:000:192.168.100.010
+0000:0000:0000:0000:0000:0000:0000:0001
+SELECT a FROM t1 WHERE a = "0fe8:0000:0000:0000:0000:b3ff:fe1a:8329";
+a
+0fe8:0000:0000:0000:0000:b3ff:fe1a:8329
+SELECT a FROM t1 WHERE a LIKE "000:000:000:000:000:000:192.168.100.010";
+a
+000:000:000:000:000:000:192.168.100.010
+DROP TABLE t1;

=== added directory 'tests/suite/ipv6_type/t'
=== added file 'tests/suite/ipv6_type/t/alter_add_ipv6.test'
--- tests/suite/ipv6_type/t/alter_add_ipv6.test	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/t/alter_add_ipv6.test	2011-08-07 13:22:33 +0000
@@ -0,0 +1,17 @@
+CREATE TABLE t1 (A INT);
+SHOW CREATE TABLE t1;
+ALTER TABLE t1 ADD COLUMN b IPV6 NOT NULL;
+SHOW CREATE TABLE t1;
+DROP TABLE t1;
+
+CREATE TABLE t1 (A INT);
+SHOW CREATE TABLE t1;
+INSERT INTO t1 VALUES (1), (2), (3);
+SELECT COUNT(*) = 3 FROM t1;
+--error ER_INVALID_ALTER_TABLE_FOR_NOT_NULL
+ALTER TABLE t1 ADD COLUMN b IPV6 NOT NULL;
+SHOW CREATE TABLE t1;
+ALTER TABLE t1 ADD COLUMN b IPV6 DEFAULT NULL;
+SELECT A,B FROM t1;
+SHOW CREATE TABLE t1;
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/t/bad_conversions.test'
--- tests/suite/ipv6_type/t/bad_conversions.test	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/t/bad_conversions.test	2011-08-07 13:22:33 +0000
@@ -0,0 +1,15 @@
+CREATE TABLE t1 (a IPV6, PRIMARY KEY(a));
+show create table t1;
+INSERT INTO t1 VALUES ("10FB::C:ABC:1F0C:44DA");
+SELECT a FROM t1;
+CREATE TABLE t2 (a REAL);
+--error ER_WARN_DATA_TRUNCATED
+INSERT INTO t2 SELECT a FROM t1 LIMIT 1;
+SELECT a FROM t2;
+CREATE TABLE t3 (a REAL);
+--error ER_WARN_DATA_TRUNCATED
+INSERT INTO t3 SELECT a FROM t1 LIMIT 1;
+SELECT a FROM t3;
+DROP TABLE t3;
+DROP TABLE t2;
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/t/count.test'
--- tests/suite/ipv6_type/t/count.test	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/t/count.test	2011-08-07 13:22:33 +0000
@@ -0,0 +1,10 @@
+CREATE TABLE t1 (a IPV6);
+INSERT INTO t1 VALUES ("fe8::b3ff:fe1a:8329");
+INSERT INTO t1 VALUES ("::1");
+INSERT INTO t1 VALUES ("::192.168.100.10");
+INSERT INTO t1 VALUES ("2001:db8:85a3::8a2e:370:7334");
+SELECT a FROM t1;
+SELECT count(a) FROM t1;
+TRUNCATE t1;
+SELECT count(a) FROM t1;
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/t/create.test'
--- tests/suite/ipv6_type/t/create.test	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/t/create.test	2011-08-07 13:22:33 +0000
@@ -0,0 +1,3 @@
+CREATE TABLE t1 (a IPV6);
+show create table t1;
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/t/delete.test'
--- tests/suite/ipv6_type/t/delete.test	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/t/delete.test	2011-08-07 13:22:33 +0000
@@ -0,0 +1,10 @@
+CREATE TABLE t1 (a IPV6);
+show create table t1;
+INSERT INTO t1 VALUES ("fe8::b3ff:fe1a:8329");
+INSERT INTO t1 VALUES ("::1");
+INSERT INTO t1 VALUES ("::192.168.100.10");
+INSERT INTO t1 VALUES ("2001:db8:85a3::8a2e:370:7334");
+SELECT a FROM t1;
+DELETE FROM t1 WHERE a = "0000:0000:0000:0000:0000:0000:0000:0001";
+SELECT a FROM t1;
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/t/mixed.test'
--- tests/suite/ipv6_type/t/mixed.test	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/t/mixed.test	2011-08-07 13:22:33 +0000
@@ -0,0 +1,11 @@
+CREATE TABLE t1 (a IPV6);
+CREATE TABLE t2 (a VARCHAR(39));
+INSERT INTO t1 VALUES ("2001:db8:85a3::8a2e:370:7334");
+SELECT a FROM t1;
+INSERT INTO t2 SELECT a FROM t1;
+SELECT a FROM t2;
+TRUNCATE t1;
+INSERT INTO t1 SELECT a FROM t2;
+SELECT a FROM t2;
+DROP TABLE t2;
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/t/order_by.test'
--- tests/suite/ipv6_type/t/order_by.test	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/t/order_by.test	2011-08-07 13:22:33 +0000
@@ -0,0 +1,9 @@
+CREATE TABLE t1 (a IPV6);
+show create table t1;
+INSERT INTO t1 VALUES ("fe8::b3ff:fe1a:8329");
+INSERT INTO t1 VALUES ("::1");
+INSERT INTO t1 VALUES ("::192.168.100.10");
+INSERT INTO t1 VALUES ("2001:db8:85a3::8a2e:370:7334");
+SELECT a FROM t1;
+SELECT a FROM t1 ORDER BY a;
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/t/primary_key.test'
--- tests/suite/ipv6_type/t/primary_key.test	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/t/primary_key.test	2011-08-07 13:22:33 +0000
@@ -0,0 +1,9 @@
+CREATE TABLE t1 (a IPV6, PRIMARY KEY(a));
+INSERT INTO t1 VALUES ("fe8::b3ff:fe1a:8329");
+INSERT INTO t1 VALUES ("::1");
+INSERT INTO t1 VALUES ("::192.168.100.10");
+INSERT INTO t1 VALUES ("2001:db8:85a3::8a2e:370:7334");
+--error ER_DUP_ENTRY
+INSERT INTO t1 VALUES ("2001:db8:85a3::8a2e:370:7334");
+SELECT a FROM t1 ORDER BY a;
+DROP TABLE t1;

=== added file 'tests/suite/ipv6_type/t/select_like_no_key.test'
--- tests/suite/ipv6_type/t/select_like_no_key.test	1970-01-01 00:00:00 +0000
+++ tests/suite/ipv6_type/t/select_like_no_key.test	2011-08-07 13:22:33 +0000
@@ -0,0 +1,9 @@
+CREATE TABLE t1 (a IPV6);
+INSERT INTO t1 VALUES ("fe8::b3ff:fe1a:8329");
+INSERT INTO t1 VALUES ("FD01::1F");
+INSERT INTO t1 VALUES ("::192.168.100.10");
+INSERT INTO t1 VALUES ("::1");
+SELECT a FROM t1;
+SELECT a FROM t1 WHERE a = "0fe8:0000:0000:0000:0000:b3ff:fe1a:8329";
+SELECT a FROM t1 WHERE a LIKE "000:000:000:000:000:000:192.168.100.010";
+DROP TABLE t1;