diff -ur DBD-drizzle-0.003.orig/dbdimp.c DBD-drizzle-0.003/dbdimp.c
--- DBD-drizzle-0.003.orig/dbdimp.c	2009-01-12 17:59:10.000000000 -0800
+++ DBD-drizzle-0.003/dbdimp.c	2009-02-24 09:27:36.000000000 -0800
@@ -342,7 +342,7 @@
             if (!is_num)
             {
               *ptr++ = '\'';
-              ptr += drizzle_escape_string(ptr, valbuf, vallen);
+              ptr += drizzleclient_escape_string(ptr, valbuf, vallen);
               *ptr++ = '\'';
             }
             else
@@ -868,7 +868,7 @@
 #else
   client_flag = CLIENT_FOUND_ROWS;
 #endif
-  drizzle_create(con);
+  drizzleclient_create(con);
 
   if (imp_dbh)
   {
@@ -884,27 +884,27 @@
       if ((svp = hv_fetch(hv, "drizzle_compression", 17, FALSE))  &&
           *svp && SvTRUE(*svp))
       {
-        drizzle_options(con, DRIZZLE_OPT_COMPRESS, NULL);
+        drizzleclient_options(con, DRIZZLE_OPT_COMPRESS, NULL);
       }
       if ((svp = hv_fetch(hv, "drizzle_connect_timeout", 21, FALSE))
           &&  *svp  &&  SvTRUE(*svp))
       {
         int to = SvIV(*svp);
-        drizzle_options(con, DRIZZLE_OPT_CONNECT_TIMEOUT,
+        drizzleclient_options(con, DRIZZLE_OPT_CONNECT_TIMEOUT,
                         (const char *)&to);
       }
       if ((svp = hv_fetch(hv, "drizzle_read_default_file", 23, FALSE)) &&
           *svp  &&  SvTRUE(*svp))
       {
         char* df = SvPV(*svp, lna);
-        drizzle_options(con, DRIZZLE_READ_DEFAULT_FILE, df);
+        drizzleclient_options(con, DRIZZLE_READ_DEFAULT_FILE, df);
       }
       if ((svp = hv_fetch(hv, "drizzle_read_default_group", 24,
                           FALSE))  &&
           *svp  &&  SvTRUE(*svp)) {
         char* gr = SvPV(*svp, lna);
 
-        drizzle_options(con, DRIZZLE_READ_DEFAULT_GROUP, gr);
+        drizzleclient_options(con, DRIZZLE_READ_DEFAULT_GROUP, gr);
       }
       if ((svp = hv_fetch(hv,
                           "drizzle_client_found_rows", 23, FALSE)) && *svp)
@@ -915,7 +915,7 @@
           client_flag &= ~CLIENT_FOUND_ROWS;
       }
       if ((svp = hv_fetch(hv, "drizzle_use_result", 16, FALSE)) && *svp)
-        imp_dbh->use_drizzle_use_result = SvTRUE(*svp);
+        imp_dbh->use_drizzleclient_use_result = SvTRUE(*svp);
 
 #if defined(CLIENT_MULTI_STATEMENTS)
       if ((svp = hv_fetch(hv, "drizzle_multi_statements", 22, FALSE)) && *svp)
@@ -974,10 +974,10 @@
               *svp)
             cipher = SvPV(*svp, lna);
 
-          drizzle_ssl_set(con, client_key, client_cert, ca_file,
+          drizzleclient_ssl_set(con, client_key, client_cert, ca_file,
                           ca_path, cipher);
 
-          drizzle_options(con,
+          drizzleclient_options(con,
                           DRIZZLE_OPT_SSL_VERIFY_SERVER_CERT,
                           &ssl_verify_true);
 
@@ -993,14 +993,14 @@
           PerlIO_printf(DBILOGFP,
                         "imp_dbh->drizzle_dr_connect: Using" \
                         " local infile %u.\n", flag);
-        drizzle_options(con, DRIZZLE_OPT_LOCAL_INFILE, (const char *) &flag);
+        drizzleclient_options(con, DRIZZLE_OPT_LOCAL_INFILE, (const char *) &flag);
       }
     }
   }
 
   client_flag|= CLIENT_MULTI_RESULTS;
 
-  result = drizzle_connect(con, host, user, password, dbname,
+  result = drizzleclient_connect(con, host, user, password, dbname,
                                 portNr, drizzle_socket, client_flag);
 
   if (result)
@@ -1154,8 +1154,8 @@
 
   if (!my_login(dbh, imp_dbh))
   {
-    do_error(dbh, drizzle_errno(imp_dbh->pdrizzle),
-             drizzle_error(imp_dbh->pdrizzle) ,drizzle_sqlstate(imp_dbh->pdrizzle));
+    do_error(dbh, drizzleclient_errno(imp_dbh->pdrizzle),
+             drizzleclient_error(imp_dbh->pdrizzle) ,drizzleclient_sqlstate(imp_dbh->pdrizzle));
     return FALSE;
   }
 
@@ -1194,10 +1194,10 @@
 
   if (imp_dbh->has_transactions)
   {
-    if (drizzle_commit(imp_dbh->pdrizzle))
+    if (drizzleclient_commit(imp_dbh->pdrizzle))
     {
-      do_error(dbh, drizzle_errno(imp_dbh->pdrizzle), drizzle_error(imp_dbh->pdrizzle)
-               ,drizzle_sqlstate(imp_dbh->pdrizzle));
+      do_error(dbh, drizzleclient_errno(imp_dbh->pdrizzle), drizzleclient_error(imp_dbh->pdrizzle)
+               ,drizzleclient_sqlstate(imp_dbh->pdrizzle));
       return FALSE;
     }
   }
@@ -1217,11 +1217,11 @@
 
   if (imp_dbh->has_transactions)
   {
-    if (drizzle_rollback(imp_dbh->pdrizzle))
+    if (drizzleclient_rollback(imp_dbh->pdrizzle))
     {
-      do_error(dbh, drizzle_errno(imp_dbh->pdrizzle),
-               drizzle_error(imp_dbh->pdrizzle),
-               drizzle_sqlstate(imp_dbh->pdrizzle));
+      do_error(dbh, drizzleclient_errno(imp_dbh->pdrizzle),
+               drizzleclient_error(imp_dbh->pdrizzle),
+               drizzleclient_sqlstate(imp_dbh->pdrizzle));
       return FALSE;
     }
   }
@@ -1259,7 +1259,7 @@
     if (DBIc_TRACE_LEVEL(imp_xxh) >= 2)
         PerlIO_printf(DBILOGFP, "imp_dbh->pdrizzle: %lx\n",
 		      (long) imp_dbh->pdrizzle);
-    drizzle_close(imp_dbh->pdrizzle );
+    drizzleclient_close(imp_dbh->pdrizzle );
 
     /* We don't free imp_dbh since a reference still exists    */
     /* The DESTROY method is the only one to 'free' memory.    */
@@ -1324,7 +1324,7 @@
     if (imp_dbh->has_transactions)
     {
       if (!DBIc_has(imp_dbh, DBIcf_AutoCommit))
-        if (drizzle_rollback(imp_dbh->pdrizzle))
+        if (drizzleclient_rollback(imp_dbh->pdrizzle))
             do_error(dbh, TX_ERR_ROLLBACK,"ROLLBACK failed" ,NULL);
     }
     dbd_db_disconnect(dbh, imp_dbh);
@@ -1374,7 +1374,7 @@
       if (bool_value == oldval)
         return TRUE;
 
-      if (drizzle_autocommit(imp_dbh->pdrizzle, bool_value))
+      if (drizzleclient_autocommit(imp_dbh->pdrizzle, bool_value))
       {
         do_error(dbh, TX_ERR_AUTOCOMMIT,
                  bool_value ?
@@ -1400,7 +1400,7 @@
     }
   }
   else if (kl == 16 && strEQ(key,"drizzle_use_result"))
-    imp_dbh->use_drizzle_use_result = bool_value;
+    imp_dbh->use_drizzleclient_use_result = bool_value;
   else if (kl == 20 && strEQ(key,"drizzle_auto_reconnect"))
     imp_dbh->auto_reconnect = bool_value;
 
@@ -1489,11 +1489,11 @@
     break;
   case 'e':
     if (strEQ(key, "errno"))
-      result= sv_2mortal(newSViv((IV)drizzle_errno(imp_dbh->pdrizzle)));
+      result= sv_2mortal(newSViv((IV)drizzleclient_errno(imp_dbh->pdrizzle)));
     else if ( strEQ(key, "error") || strEQ(key, "errmsg"))
     {
     /* Note that errmsg is obsolete, as of 2.09! */
-      const char* msg = drizzle_error(imp_dbh->pdrizzle);
+      const char* msg = drizzleclient_error(imp_dbh->pdrizzle);
       result= sv_2mortal(newSVpv(msg, strlen(msg)));
     }
     /* HELMUT */
@@ -1528,7 +1528,7 @@
   case 'h':
     if (strEQ(key, "hostinfo"))
     {
-      const char* hostinfo = drizzle_get_host_info(imp_dbh->pdrizzle);
+      const char* hostinfo = drizzleclient_get_host_info(imp_dbh->pdrizzle);
       result= hostinfo ?
         sv_2mortal(newSVpv(hostinfo, strlen(hostinfo))) : &sv_undef;
     }
@@ -1537,23 +1537,23 @@
   case 'i':
     if (strEQ(key, "info"))
     {
-      const char* info = drizzle_info(imp_dbh->pdrizzle);
+      const char* info = drizzleclient_info(imp_dbh->pdrizzle);
       result= info ? sv_2mortal(newSVpv(info, strlen(info))) : &sv_undef;
     }
     else if (kl == 8  &&  strEQ(key, "insertid"))
       /* We cannot return an IV, because the insertid is a long. */
-      result= sv_2mortal(my_ulonglong2str(drizzle_insert_id(imp_dbh->pdrizzle)));
+      result= sv_2mortal(my_ulonglong2str(drizzleclient_insert_id(imp_dbh->pdrizzle)));
     break;
 
   case 'p':
     if (kl == 9  &&  strEQ(key, "protoinfo"))
-      result= sv_2mortal(newSViv(drizzle_get_proto_info(imp_dbh->pdrizzle)));
+      result= sv_2mortal(newSViv(drizzleclient_get_proto_info(imp_dbh->pdrizzle)));
     break;
 
   case 's':
     if (kl == 10  &&  strEQ(key, "serverinfo"))
     {
-      const char* serverinfo = drizzle_get_server_info(imp_dbh->pdrizzle);
+      const char* serverinfo = drizzleclient_get_server_info(imp_dbh->pdrizzle);
       result= serverinfo ?
         sv_2mortal(newSVpv(serverinfo, strlen(serverinfo))) : &sv_undef;
     }
@@ -1579,7 +1579,7 @@
 #endif
   case 't':
     if (kl == 9  &&  strEQ(key, "thread_id"))
-      result= sv_2mortal(newSViv(drizzle_thread_id(imp_dbh->pdrizzle)));
+      result= sv_2mortal(newSViv(drizzleclient_thread_id(imp_dbh->pdrizzle)));
     break;
   }
 
@@ -1627,8 +1627,8 @@
 
   /* Set default value of 'drizzle_use_result' attribute for sth from dbh */
   svp= DBD_ATTRIB_GET_SVP(attribs, "drizzle_use_result", 16);
-  imp_sth->use_drizzle_use_result= svp ?
-    SvTRUE(*svp) : imp_dbh->use_drizzle_use_result;
+  imp_sth->use_drizzleclient_use_result= svp ?
+    SvTRUE(*svp) : imp_dbh->use_drizzleclient_use_result;
 
   for (i= 0; i < AV_ATTRIB_LAST; i++)
     imp_sth->av_attr[i]= Nullav;
@@ -1677,36 +1677,36 @@
 
     if (next_result_rc == 0)
     {
-      if (!(imp_sth->result = drizzle_use_result(imp_dbh->pdrizzle)))
+      if (!(imp_sth->result = drizzleclient_use_result(imp_dbh->pdrizzle)))
       {
         /* Check for possible error */
-        if (drizzle_field_count(imp_dbh->pdrizzle))
+        if (drizzleclient_field_count(imp_dbh->pdrizzle))
         {
           if (DBIc_TRACE_LEVEL(imp_xxh) >= 2)
           PerlIO_printf(DBILOGFP, "\t<- dbd_st_free_result_sets ERROR: %s\n",
-                                  drizzle_error(imp_dbh->pdrizzle));
+                                  drizzleclient_error(imp_dbh->pdrizzle));
 
-          do_error(sth, drizzle_errno(imp_dbh->pdrizzle), drizzle_error(imp_dbh->pdrizzle),
-                   drizzle_sqlstate(imp_dbh->pdrizzle));
+          do_error(sth, drizzleclient_errno(imp_dbh->pdrizzle), drizzleclient_error(imp_dbh->pdrizzle),
+                   drizzleclient_sqlstate(imp_dbh->pdrizzle));
           return 0;
         }
       }
     }
     if (imp_sth->result)
     {
-      drizzle_free_result(imp_sth->result);
+      drizzleclient_free_result(imp_sth->result);
       imp_sth->result=NULL;
     }
-  } while ((next_result_rc= drizzle_next_result(imp_dbh->pdrizzle))==0);
+  } while ((next_result_rc= drizzleclient_next_result(imp_dbh->pdrizzle))==0);
 
   if (next_result_rc > 0)
   {
     if (DBIc_TRACE_LEVEL(imp_xxh) >= 2)
       PerlIO_printf(DBILOGFP, "\t<- dbd_st_free_result_sets: Error while processing multi-result set: %s\n",
-                    drizzle_error(imp_dbh->pdrizzle));
+                    drizzleclient_error(imp_dbh->pdrizzle));
 
-    do_error(sth, drizzle_errno(imp_dbh->pdrizzle), drizzle_error(imp_dbh->pdrizzle),
-             drizzle_sqlstate(imp_dbh->pdrizzle));
+    do_error(sth, drizzleclient_errno(imp_dbh->pdrizzle), drizzleclient_error(imp_dbh->pdrizzle),
+             drizzleclient_sqlstate(imp_dbh->pdrizzle));
   }
 
 
@@ -1734,14 +1734,14 @@
   D_imp_dbh_from_sth;
   D_imp_xxh(sth);
 
-  int use_drizzle_use_result=imp_sth->use_drizzle_use_result;
+  int use_drizzleclient_use_result=imp_sth->use_drizzleclient_use_result;
   int next_result_return_code, i;
   DRIZZLE* con= imp_dbh->pdrizzle;
 
   if (!SvROK(sth) || SvTYPE(SvRV(sth)) != SVt_PVHV)
     croak("Expected hash array");
 
-  if (!drizzle_more_results(con))
+  if (!drizzleclient_more_results(con))
   {
     /* No more pending result set(s)*/
     if (DBIc_TRACE_LEVEL(imp_xxh) >= 2)
@@ -1764,12 +1764,12 @@
 
   /* Release previous MySQL result*/
   if (imp_sth->result)
-    drizzle_free_result(imp_sth->result);
+    drizzleclient_free_result(imp_sth->result);
 
   if (DBIc_ACTIVE(imp_sth))
     DBIc_ACTIVE_off(imp_sth);
 
-  next_result_return_code= drizzle_next_result(con);
+  next_result_return_code= drizzleclient_next_result(con);
 
   /*
     drizzle_next_result returns
@@ -1779,19 +1779,19 @@
    */
   if (next_result_return_code > 0)
   {
-    do_error(sth, drizzle_errno(con), drizzle_error(con),
-             drizzle_sqlstate(con));
+    do_error(sth, drizzleclient_errno(con), drizzleclient_error(con),
+             drizzleclient_sqlstate(con));
     return 0;
   }
   else
   {
     /* Store the result from the Query */
-    imp_sth->result = use_drizzle_use_result ?
-     drizzle_use_result(con) : drizzle_store_result(con);
+    imp_sth->result = use_drizzleclient_use_result ?
+     drizzleclient_use_result(con) : drizzleclient_store_result(con);
 
-    if (drizzle_errno(con))
-      do_error(sth, drizzle_errno(con), drizzle_error(con),
-               drizzle_sqlstate(con));
+    if (drizzleclient_errno(con))
+      do_error(sth, drizzleclient_errno(con), drizzleclient_error(con),
+               drizzleclient_sqlstate(con));
 
     if (imp_sth->result == NULL)
     {
@@ -1828,7 +1828,7 @@
       /* Adjust NUM_OF_FIELDS - which also adjusts the row buffer size */
       DBIc_NUM_FIELDS(imp_sth)= 0; /* for DBI <= 1.53 */
       DBIS->set_attr_k(sth, sv_2mortal(newSVpvn("NUM_OF_FIELDS",13)), 0,
-          sv_2mortal(newSViv(drizzle_num_fields(imp_sth->result)))
+          sv_2mortal(newSViv(drizzleclient_num_fields(imp_sth->result)))
       );
 
       DBIc_ACTIVE_on(imp_sth);
@@ -1865,7 +1865,7 @@
                                        imp_sth_ph_t *params,
                                        DRIZZLE_RES **result,
                                        DRIZZLE *con,
-                                       int use_drizzle_use_result
+                                       int use_drizzleclient_use_result
                                       )
 {
   bool bind_type_guessing;
@@ -1953,27 +1953,27 @@
     }
     *sbuf++= '\0';
 
-    *result= drizzle_list_fields(con, table, NULL);
+    *result= drizzleclient_list_fields(con, table, NULL);
 
     free(table);
 
     if (!(*result))
     {
-      do_error(h, drizzle_errno(con), drizzle_error(con)
-               ,drizzle_sqlstate(con));
+      do_error(h, drizzleclient_errno(con), drizzleclient_error(con)
+               ,drizzleclient_sqlstate(con));
       return -2;
     }
 
     return 0;
   }
 
-  if ((drizzle_real_query(con, sbuf, slen))  &&
+  if ((drizzleclient_real_query(con, sbuf, slen))  &&
       (!drizzle_db_reconnect(h)  ||
-       (drizzle_real_query(con, sbuf, slen))))
+       (drizzleclient_real_query(con, sbuf, slen))))
   {
     Safefree(salloc);
-    do_error(h, drizzle_errno(con), drizzle_error(con),
-             drizzle_sqlstate(con));
+    do_error(h, drizzleclient_errno(con), drizzleclient_error(con),
+             drizzleclient_sqlstate(con));
     if (DBIc_TRACE_LEVEL(imp_xxh) >= 2)
       PerlIO_printf(DBILOGFP, "IGNORING ERROR errno %d\n", errno);
     return -2;
@@ -1981,17 +1981,17 @@
   Safefree(salloc);
 
   /** Store the result from the Query */
-  *result= use_drizzle_use_result ?
-    drizzle_use_result(con) : drizzle_store_result(con);
+  *result= use_drizzleclient_use_result ?
+    drizzleclient_use_result(con) : drizzleclient_store_result(con);
 
-  if (drizzle_errno(con))
-    do_error(h, drizzle_errno(con), drizzle_error(con)
-             ,drizzle_sqlstate(con));
+  if (drizzleclient_errno(con))
+    do_error(h, drizzleclient_errno(con), drizzleclient_error(con)
+             ,drizzleclient_sqlstate(con));
 
   if (!*result)
-    rows= drizzle_affected_rows(con);
+    rows= drizzleclient_affected_rows(con);
   else
-    rows= drizzle_num_rows(*result);
+    rows= drizzleclient_num_rows(*result);
 
   return(rows);
 }
@@ -2055,24 +2055,24 @@
                                                 imp_sth->params,
                                                 &imp_sth->result,
                                                 imp_dbh->pdrizzle,
-                                                imp_sth->use_drizzle_use_result
+                                                imp_sth->use_drizzleclient_use_result
                                                );
 
   if (imp_sth->row_num+1 != (uint64_t )-1)
   {
     if (!imp_sth->result)
-      imp_sth->insertid= drizzle_insert_id(imp_dbh->pdrizzle);
+      imp_sth->insertid= drizzleclient_insert_id(imp_dbh->pdrizzle);
     else
     {
       /** Store the result in the current statement handle */
-      DBIc_NUM_FIELDS(imp_sth)= drizzle_num_fields(imp_sth->result);
+      DBIc_NUM_FIELDS(imp_sth)= drizzleclient_num_fields(imp_sth->result);
       DBIc_ACTIVE_on(imp_sth);
       imp_sth->done_desc= 0;
       imp_sth->fetch_done= 0;
     }
   }
 
-  imp_sth->warning_count = drizzle_warning_count(imp_dbh->pdrizzle);
+  imp_sth->warning_count = drizzleclient_warning_count(imp_dbh->pdrizzle);
 
   if (DBIc_TRACE_LEVEL(imp_xxh) >= 2)
   {
@@ -2169,36 +2169,36 @@
   {
     PerlIO_printf(DBILOGFP, "\tdbd_st_fetch result set details\n");
     PerlIO_printf(DBILOGFP, "\timp_sth->result=%08lx\n",imp_sth->result);
-    PerlIO_printf(DBILOGFP, "\tdrizzle_num_fields=%llu\n",
-                  drizzle_num_fields(imp_sth->result));
+    PerlIO_printf(DBILOGFP, "\tdrizzleclient_num_fields=%llu\n",
+                  drizzleclient_num_fields(imp_sth->result));
     PerlIO_printf(DBILOGFP, "\tdrizzle_num_rows=%llu\n",
-                  drizzle_num_rows(imp_sth->result));
+                  drizzleclient_num_rows(imp_sth->result));
     PerlIO_printf(DBILOGFP, "\tdrizzle_affected_rows=%llu\n",
-                  drizzle_affected_rows(imp_dbh->pdrizzle));
+                  drizzleclient_affected_rows(imp_dbh->pdrizzle));
     PerlIO_printf(DBILOGFP, "\tdbd_st_fetch for %08lx, currow= %d\n",
                   (u_long) sth,imp_sth->currow);
   }
 
-  if (!(cols= drizzle_fetch_row(imp_sth->result)))
+  if (!(cols= drizzleclient_fetch_row(imp_sth->result)))
   {
     if (DBIc_TRACE_LEVEL(imp_xxh) >= 2)
     {
       PerlIO_printf(DBILOGFP, "\tdbd_st_fetch, no more rows to fetch");
     }
-    if (drizzle_errno(imp_dbh->pdrizzle))
-      do_error(sth, drizzle_errno(imp_dbh->pdrizzle),
-               drizzle_error(imp_dbh->pdrizzle),
-               drizzle_sqlstate(imp_dbh->pdrizzle));
+    if (drizzleclient_errno(imp_dbh->pdrizzle))
+      do_error(sth, drizzleclient_errno(imp_dbh->pdrizzle),
+               drizzleclient_error(imp_dbh->pdrizzle),
+               drizzleclient_sqlstate(imp_dbh->pdrizzle));
 
 
-    if (!drizzle_more_results(con))
+    if (!drizzleclient_more_results(con))
       dbd_st_finish(sth, imp_sth);
     return Nullav;
   }
 
-  num_fields= drizzle_num_fields(imp_sth->result);
-  fields= drizzle_fetch_fields(imp_sth->result);
-  lengths= drizzle_fetch_lengths(imp_sth->result);
+  num_fields= drizzleclient_num_fields(imp_sth->result);
+  fields= drizzleclient_fetch_fields(imp_sth->result);
+  lengths= drizzleclient_fetch_lengths(imp_sth->result);
 
   if ((av= DBIc_FIELDS_AV(imp_sth)) != Nullav)
   {
@@ -2397,7 +2397,7 @@
 
   if (strEQ(key, "drizzle_use_result"))
   {
-    imp_sth->use_drizzle_use_result= SvTRUE(valuesv);
+    imp_sth->use_drizzleclient_use_result= SvTRUE(valuesv);
   }
 
   if (DBIc_TRACE_LEVEL(imp_xxh) >= 2)
@@ -2469,8 +2469,8 @@
   else
   {
     av= newAV();
-    drizzle_field_seek(res, 0);
-    while ((curField= drizzle_fetch_field(res)))
+    drizzleclient_field_seek(res, 0);
+    while ((curField= drizzleclient_fetch_field(res)))
     {
       SV *sv;
 
@@ -2682,7 +2682,7 @@
       else if (strEQ(key, "drizzle_max_length"))
         retsv= ST_FETCH_AV(AV_ATTRIB_MAX_LENGTH);
       else if (strEQ(key, "drizzle_use_result"))
-        retsv= boolSV(imp_sth->use_drizzle_use_result);
+        retsv= boolSV(imp_sth->use_drizzleclient_use_result);
       break;
     case 19:
       if (strEQ(key, "drizzle_warning_count"))
@@ -2844,7 +2844,7 @@
   else
     imp_dbh= (imp_dbh_t*) imp_xxh;
 
-  if (drizzle_errno(imp_dbh->pdrizzle) != CR_SERVER_GONE_ERROR)
+  if (drizzleclient_errno(imp_dbh->pdrizzle) != CR_SERVER_GONE_ERROR)
     /* Other error */
     return FALSE;
 
@@ -2868,8 +2868,8 @@
 
   if (!my_login(h, imp_dbh))
   {
-    do_error(h, drizzle_errno(imp_dbh->pdrizzle), drizzle_error(imp_dbh->pdrizzle),
-             drizzle_sqlstate(imp_dbh->pdrizzle));
+    do_error(h, drizzleclient_errno(imp_dbh->pdrizzle), drizzleclient_error(imp_dbh->pdrizzle),
+             drizzleclient_sqlstate(imp_dbh->pdrizzle));
     memcpy (imp_dbh->pdrizzle, &con, sizeof(con));
     ++imp_dbh->stats.auto_reconnects_failed;
     return FALSE;
@@ -3034,7 +3034,7 @@
     sptr= SvPVX(result);
 
     *sptr++ = '\'';
-    sptr+= drizzle_escape_string(sptr,
+    sptr+= drizzleclient_escape_string(sptr,
                                      ptr, len);
     *sptr++= '\'';
     SvPOK_on(result);
@@ -3057,7 +3057,7 @@
   table= table;
   field= field;
   attr= attr;
-  return sv_2mortal(my_ulonglong2str(drizzle_insert_id(imp_dbh->pdrizzle)));
+  return sv_2mortal(my_ulonglong2str(drizzleclient_insert_id(imp_dbh->pdrizzle)));
 }
 #endif
 
diff -ur DBD-drizzle-0.003.orig/dbdimp.h DBD-drizzle-0.003/dbdimp.h
--- DBD-drizzle-0.003.orig/dbdimp.h	2009-01-15 11:11:47.000000000 -0800
+++ DBD-drizzle-0.003/dbdimp.h	2009-02-24 00:12:47.000000000 -0800
@@ -16,11 +16,12 @@
  *  Header files we use
  */
 #include <DBIXS.h>  /* installed by the DBI module                        */
-#include <libdrizzle/drizzle.h>
+#include <libdrizzleclient/drizzle.h>
 #include <drizzled/common.h>  
 #include <drizzled/error.h>  
 
-#include <libdrizzle/errmsg.h> 
+#include <libdrizzleclient/errmsg.h> 
+#include <libdrizzleclient/libdrizzle.h>
 
 /*
   Drizzle team yanked these out of drizzle.h. I'll put them
@@ -116,7 +117,7 @@
 	    unsigned int auto_reconnects_failed;
     } stats;
     unsigned short int  bind_type_guessing;
-    int use_drizzle_use_result; /* TRUE if execute should use
+    int use_drizzleclient_use_result; /* TRUE if execute should use
                                * drizzle_use_result rather than
                                * drizzle_store_result
                                */
@@ -198,7 +199,7 @@
     int   warning_count;  /* Number of warnings after execute()     */
     imp_sth_ph_t* params; /* Pointer to parameter array             */
     AV* av_attr[AV_ATTRIB_LAST];/*  For caching array attributes        */
-    int   use_drizzle_use_result;  /*  TRUE if execute should use     */
+    int   use_drizzleclient_use_result;  /*  TRUE if execute should use     */
                           /* drizzle_use_result rather than           */
                           /* drizzle_store_result */
 };
diff -ur DBD-drizzle-0.003.orig/drizzle.xs DBD-drizzle-0.003/drizzle.xs
--- DBD-drizzle-0.003.orig/drizzle.xs	2009-01-12 17:54:48.000000000 -0800
+++ DBD-drizzle-0.003/drizzle.xs	2009-02-24 09:20:22.000000000 -0800
@@ -49,24 +49,24 @@
     DRIZZLE_ROW cur;
     DRIZZLE_RES* res;
 
-    if (drizzle_query(con,"SHOW DATABASES"))
-      do_error(drh, drizzle_errno(con), drizzle_error(con), drizzle_sqlstate(con));
+    if (drizzleclient_query(con,"SHOW DATABASES"))
+      do_error(drh, drizzleclient_errno(con), drizzleclient_error(con), drizzleclient_sqlstate(con));
 
-    res= drizzle_store_result(con);
+    res= drizzleclient_store_result(con);
     if (!res)
     {
-      do_error(drh, drizzle_errno(con), drizzle_error(con), drizzle_sqlstate(con));
+      do_error(drh, drizzleclient_errno(con), drizzleclient_error(con), drizzleclient_sqlstate(con));
     }
     else
     {
-      EXTEND(sp, drizzle_num_rows(res));
-      while ((cur = drizzle_fetch_row(res)))
+      EXTEND(sp, drizzleclient_num_rows(res));
+      while ((cur = drizzleclient_fetch_row(res)))
       {
         PUSHs(sv_2mortal((SV*)newSVpv(cur[0], strlen(cur[0]))));
       }
-      drizzle_free_result(res);
+      drizzleclient_free_result(res);
     }
-    drizzle_close(con);
+    drizzleclient_close(con);
   }
 }
 
@@ -98,16 +98,16 @@
     con= drizzle_dr_connect(drh, &drizzle, NULL, host, port, user,  password, NULL, NULL);
     if (con == NULL)
     {
-      do_error(drh, drizzle_errno(&drizzle), drizzle_error(&drizzle),
-               drizzle_sqlstate(&drizzle));
+      do_error(drh, drizzleclient_errno(&drizzle), drizzleclient_error(&drizzle),
+               drizzleclient_sqlstate(&drizzle));
       XSRETURN_NO;
     }
   }
 
   if (strEQ(command, "shutdown"))
-    retval = drizzle_shutdown(con);
+    retval = drizzleclient_shutdown(con);
   else if (strEQ(command, "refresh"))
-    retval = drizzle_refresh(con, REFRESH_LOG);
+    retval = drizzleclient_refresh(con, REFRESH_LOG);
   else if (strEQ(command, "createdb"))
   {
     char* buffer = malloc(strlen(dbname)+50);
@@ -120,7 +120,7 @@
     {
       strcpy(buffer, "CREATE DATABASE ");
       strcat(buffer, dbname);
-      retval = drizzle_real_query(con, buffer, strlen(buffer));
+      retval = drizzleclient_real_query(con, buffer, strlen(buffer));
       free(buffer);
     }
   }
@@ -136,7 +136,7 @@
     {
       strcpy(buffer, "DROP DATABASE ");
       strcat(buffer, dbname);
-      retval = drizzle_real_query(con, buffer, strlen(buffer));
+      retval = drizzleclient_real_query(con, buffer, strlen(buffer));
       free(buffer);
     }
   }
@@ -146,13 +146,13 @@
   }
   if (retval)
   {
-    do_error(SvOK(dbh) ? dbh : drh, drizzle_errno(con),
-             drizzle_error(con) ,drizzle_sqlstate(con));
+    do_error(SvOK(dbh) ? dbh : drh, drizzleclient_errno(con),
+             drizzleclient_error(con) ,drizzleclient_sqlstate(con));
   }
 
   if (SvOK(dbh))
   {
-    drizzle_close(con);
+    drizzleclient_close(con);
   }
   if (retval)
     XSRETURN_NO;
@@ -191,25 +191,25 @@
   D_imp_dbh(dbh);
   DRIZZLE_RES* res;
   DRIZZLE_ROW cur;
-  if (drizzle_query(imp_dbh->pdrizzle,"SHOW DATABASES"))
+  if (drizzleclient_query(imp_dbh->pdrizzle,"SHOW DATABASES"))
   do_error(dbh,
-            drizzle_errno(imp_dbh->pdrizzle),
-            drizzle_error(imp_dbh->pdrizzle),
-            drizzle_sqlstate(imp_dbh->pdrizzle));
-  res= drizzle_store_result(imp_dbh->pdrizzle);
+            drizzleclient_errno(imp_dbh->pdrizzle),
+            drizzleclient_error(imp_dbh->pdrizzle),
+            drizzleclient_sqlstate(imp_dbh->pdrizzle));
+  res= drizzleclient_store_result(imp_dbh->pdrizzle);
   if (!res  && (!drizzle_db_reconnect(dbh)))
   {
-  do_error(dbh, drizzle_errno(imp_dbh->pdrizzle),
-  drizzle_error(imp_dbh->pdrizzle), drizzle_sqlstate(imp_dbh->pdrizzle));
+  do_error(dbh, drizzleclient_errno(imp_dbh->pdrizzle),
+  drizzleclient_error(imp_dbh->pdrizzle), drizzleclient_sqlstate(imp_dbh->pdrizzle));
   }
   else
   {
-  EXTEND(sp, drizzle_num_rows(res));
-  while ((cur = drizzle_fetch_row(res)))
+  EXTEND(sp, drizzleclient_num_rows(res));
+  while ((cur = drizzleclient_fetch_row(res)))
   {
     PUSHs(sv_2mortal((SV*)newSVpv(cur[0], strlen(cur[0]))));
   }
-  drizzle_free_result(res);
+  drizzleclient_free_result(res);
 }
 
 
@@ -246,7 +246,7 @@
 
   if (result)
   {
-    drizzle_free_result(result);
+    drizzleclient_free_result(result);
     result= 0;
   }
   /* remember that dbd_st_execute must return <= -2 for error	*/
@@ -267,10 +267,10 @@
     {
       int retval;
       D_imp_dbh(dbh);
-      retval = (drizzle_ping(imp_dbh->pdrizzle) == 0);
+      retval = (drizzleclient_ping(imp_dbh->pdrizzle) == 0);
       if (!retval) {
 	if (drizzle_db_reconnect(dbh)) {
-	  retval = (drizzle_ping(imp_dbh->pdrizzle) == 0);
+	  retval = (drizzleclient_ping(imp_dbh->pdrizzle) == 0);
 	}
       }
       RETVAL = boolSV(retval);
@@ -324,7 +324,7 @@
 {
   D_imp_sth(sth);
   if (imp_sth->result) {
-    drizzle_data_seek(imp_sth->result, pos);
+    drizzleclient_data_seek(imp_sth->result, pos);
     RETVAL = 1;
   } else {
     RETVAL = 0;
@@ -342,7 +342,7 @@
     char buf[64];
   /* fix to make rows able to handle errors and handle max value from 
      affected rows.
-     if drizzle_affected_row returns an error, it's value is 18446744073709551614,
+     if drizzleclient_affected_row returns an error, it's value is 18446744073709551614,
      while a (uint64_t)-1 is  18446744073709551615, so we have to add 1 to
      imp_sth->row_num to know if there's an error
   */
Only in DBD-drizzle-0.003: Makefile.old
diff -ur DBD-drizzle-0.003.orig/Makefile.PL DBD-drizzle-0.003/Makefile.PL
--- DBD-drizzle-0.003.orig/Makefile.PL	2009-01-15 11:05:14.000000000 -0800
+++ DBD-drizzle-0.003/Makefile.PL	2009-02-24 00:10:52.000000000 -0800
@@ -216,8 +216,8 @@
 not present on the command line, then pkg-config is called (if
 it can be found):
 
-  pkg-config --cflags libdrizzle
-  pkg-config --libs libdrizzle
+  pkg-config --cflags libdrizzleclient
+  pkg-config --libs libdrizzleclient
 
 and so on. See the INSTALL.html file for details.
 USAGE
@@ -256,7 +256,7 @@
   {
     # First try to get options values from pkg-config
       unless ($param eq '--libs' && $param eq '--cflags') {
-          my $command = $opt->{'pkg-config'} . " --$param libdrizzle" unless $param eq '--libs' && $param eq '--cflags';
+          my $command = $opt->{'pkg-config'} . " --$param libdrizzleclient" unless $param eq '--libs' && $param eq '--cflags';
           eval 
           {
               print "running $command\n";
@@ -326,7 +326,7 @@
     my @files=();
     my $default_libs;
     $default_libs= "-ldrizzle -lz -lm -lcrypt -lnsl";
-    @files = qw(libdrizzle.a libdrizzle.so);
+    @files = qw(libdrizzleclient.a libdrizzleclient.so);
 
     my $dir = SearchFor('lib', @files);
 
Only in DBD-drizzle-0.003/t: drizzle.mtest