Merge lp:~olafvdspek/drizzle/rf1 into lp:drizzle

[Olaf van der Spek]

[Brian Aker (brianaker)]

Style-wise, we use {} in all cases. This patch removes that in a few cases.

This is for readability.

[Olaf van der Spek (olafvdspek)]

Do we? Coding standards doesn't mention it. It even contains a few examples that don't.

[Brian Aker (brianaker)]

This is something that Trond slipped up on at one point. I thought we had updated the style guide for this.

[Olaf van der Spek (olafvdspek)]

Where did I remove the braces?

[Olaf van der Spek (olafvdspek)]

Ah, I found one if statement. Do you want me to update the patch?

--
Olaf

Unmerged revisions

2579. By Olaf van der Spek on 2012-08-04

Refactor

=== modified file 'drizzled/error/sql_state.cc'
--- drizzled/error/sql_state.cc	2011-02-17 00:14:13 +0000
+++ drizzled/error/sql_state.cc	2012-08-04 14:50:32 +0000
@@ -28,15 +28,12 @@
 
 using namespace std;
 
-namespace drizzled
-{
-
-namespace error
-{
+namespace drizzled {
+namespace error {
 
 struct sql_state_t
 {
-  drizzled::error_t drizzle_errno;
+  error_t drizzle_errno;
   const char *odbc_state;
   const char *jdbc_state;
 };
@@ -171,15 +168,13 @@
   { ER_DUP_ENTRY_WITH_KEY_NAME              ,"23000", "S1009" },
 };
 
-static bool compare_errno_map(sql_state_t a,
-                              sql_state_t b)
+static bool compare_errno_map(sql_state_t a, sql_state_t b)
 {
   return (a.drizzle_errno < b.drizzle_errno);
 }
 
 const char *convert_to_sqlstate(drizzled::error_t drizzle_errno)
 {
-
   sql_state_t drizzle_err_state= {drizzle_errno, NULL, NULL};
   sql_state_t* result=
     lower_bound(&sqlstate_map[0],
 
=== modified file 'drizzled/error/sql_state.h'
--- drizzled/error/sql_state.h	2011-03-14 05:40:28 +0000
+++ drizzled/error/sql_state.h	2012-08-04 14:50:32 +0000
@@ -19,12 +19,10 @@
 
 #pragma once
 
-namespace drizzled
-{
-namespace error
-{
+namespace drizzled {
+namespace error {
 
-const char *convert_to_sqlstate(drizzled::error_t drizzle_errno);
+const char* convert_to_sqlstate(error_t);
 
 } /* namespace error */
 } /* namespace drizzled */
 
=== modified file 'drizzled/table/instance/base.cc'
--- drizzled/table/instance/base.cc	2012-07-11 14:06:00 +0000
+++ drizzled/table/instance/base.cc	2012-08-04 14:50:32 +0000
@@ -34,7 +34,6 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 
-
 #include <cassert>
 
 #include <drizzled/error.h>
@@ -147,7 +146,7 @@
   abort();
 }
 
-static Item* default_value_item(enum_field_types field_type, const charset_info_st& charset, bool default_null, 
+static Item* default_value_item(enum_field_types field_type, const charset_info_st& charset, bool default_null,
   const string& default_value, const string& default_bin_value)
 {
   if (default_null)
@@ -498,7 +497,7 @@
   normalized_path= str_ref(new_path);
 }
 
-TableShare::~TableShare() 
+TableShare::~TableShare()
 {
   storage_engine= NULL;
   delete table_identifier;
@@ -676,15 +675,11 @@
       if (table.field(part.fieldnr()).type() == message::Table::Field::VARCHAR
           || table.field(part.fieldnr()).type() == message::Table::Field::BLOB)
       {
-        uint32_t collation_id;
-
-        if (table.field(part.fieldnr()).string_options().has_collation_id())
-          collation_id= table.field(part.fieldnr()).string_options().collation_id();
-        else
-          collation_id= table.options().collation_id();
+        uint32_t collation_id= table.field(part.fieldnr()).string_options().has_collation_id()
+        	? table.field(part.fieldnr()).string_options().collation_id()
+        	: table.options().collation_id();
 
         const charset_info_st *cs= get_charset(collation_id);
-
         mbmaxlen= cs->mbmaxlen;
       }
       key_part->length*= mbmaxlen;
@@ -872,7 +867,7 @@
     {
       t->type_names[n]= mem().strdup(field_options.field_value(n));
 
-      /* 
+      /*
        * Go ask the charset what the length is as for "" length=1
        * and there's stripping spaces or some other crack going on.
      */
@@ -911,7 +906,7 @@
       {
         unireg_type= Field::TIMESTAMP_DNUN_FIELD;
       }
-      else if (! pfield.options().has_update_expression())
+      else if (not pfield.options().has_update_expression())
       {
         unireg_type= Field::TIMESTAMP_DN_FIELD;
       }
@@ -1010,10 +1005,9 @@
       {
         message::Table::Field::StringFieldOptions field_options= pfield.string_options();
 
-        charset= get_charset(field_options.has_collation_id() ?
-                             field_options.collation_id() : 0);
+        charset= get_charset(field_options.has_collation_id() ? field_options.collation_id() : 0);
 
-        if (! charset)
+        if (not charset)
           charset= default_charset_info;
 
         field_length= field_options.length() * charset->mbmaxlen;
@@ -1043,8 +1037,7 @@
       {
         message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
 
-        field_length= class_decimal_precision_to_length(fo.precision(), fo.scale(),
-                                                     false);
+        field_length= class_decimal_precision_to_length(fo.precision(), fo.scale(), false);
         break;
       }
     case DRIZZLE_TYPE_DATETIME:
@@ -1106,16 +1099,7 @@
       abort(); // Programming error
     }
 
-    bool is_not_null= false;
-
-    if (not pfield.constraints().is_nullable())
-    {
-      is_not_null= true;
-    }
-    else if (pfield.constraints().is_notnull())
-    {
-      is_not_null= true;
-    }
+    bool is_not_null= not pfield.constraints().is_nullable() || pfield.constraints().is_notnull();
 
     Field* f= make_field(pfield,
                          record + field_offsets[fieldnr] + data_offset,
@@ -1212,8 +1196,7 @@
 
     if (use_hash) /* supposedly this never fails... but comments lie */
     {
-      const char *local_field_name= _fields[fieldnr]->field_name;
-      name_hash.insert(make_pair(local_field_name, &(_fields[fieldnr])));
+      name_hash.insert(make_pair(_fields[fieldnr]->field_name, &(_fields[fieldnr])));
     }
   }
 
@@ -1226,7 +1209,7 @@
          partnr < keyinfo->key_parts;
          partnr++, key_part++)
     {
-      /* 
+      /*
        * Fix up key_part->offset by adding data_offset.
        * We really should compute offset as well.
        * But at least this way we are a little better.
@@ -1359,8 +1342,7 @@
         set_if_bigger(max_unique_length,keyinfo->key_length);
       }
     }
-    if (local_primary_key < MAX_KEY &&
-        (keys_in_use.test(local_primary_key)))
+    if (local_primary_key < MAX_KEY && keys_in_use.test(local_primary_key))
     {
       primary_key= local_primary_key;
       /*
@@ -1373,8 +1355,7 @@
         if (local_field && local_field->result_type() == INT_RESULT)
         {
           /* note that fieldnr here (and rowid_field_offset) starts from 1 */
-          rowid_field_offset= (key_info[local_primary_key].key_part[0].
-                                      fieldnr);
+          rowid_field_offset= (key_info[local_primary_key].key_part[0].fieldnr);
         }
       }
     }
@@ -1597,8 +1578,7 @@
   *field_ptr= 0;                              // End marker
 
   if (found_next_number_field)
-    outparam.found_next_number_field=
-      outparam.getField(positionFields(found_next_number_field));
+    outparam.found_next_number_field= outparam.getField(positionFields(found_next_number_field));
   if (timestamp_field)
     outparam.timestamp_field= (field::Epoch*) outparam.getField(timestamp_field->position());
 
@@ -1655,11 +1635,9 @@
   if (db_stat)
   {
     assert(!(db_stat & HA_WAIT_IF_LOCKED));
-    int ha_err;
-
-    if ((ha_err= (outparam.cursor->ha_open(identifier,
-                                           (db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
-                                           (db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE : HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
+    if (int ha_err= (outparam.cursor->ha_open(identifier,
+      (db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
+      (db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE : HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags)))
     {
       switch (ha_err)
       {
@@ -1699,7 +1677,8 @@
   char buff[FN_REFLEN];
   myf errortype= ME_ERROR+ME_WAITTANG;
 
-  switch (pass_error) {
+  switch (pass_error)
+  {
   case 7:
   case 1:
     if (db_errno == ENOENT)
@@ -1722,7 +1701,7 @@
     {
       const char *csname= get_charset_name((uint32_t) pass_errarg);
       char tmp[10];
-      if (!csname || csname[0] =='?')
+      if (not csname || csname[0] =='?')
       {
         snprintf(tmp, sizeof(tmp), "#%d", pass_errarg);
         csname= tmp;
@@ -1784,120 +1763,48 @@
                               const charset_info_st * field_charset,
                               Field::utype unireg_check,
                               TYPELIB *interval,
-                              const char *field_name, 
+                              const char *field_name,
                               bool is_unsigned)
 {
-  if (! is_nullable)
+  if (is_nullable)
+  {
+    null_bit= ((unsigned char) 1) << null_bit;
+  }
+  else
   {
     null_pos=0;
     null_bit=0;
   }
-  else
-  {
-    null_bit= ((unsigned char) 1) << null_bit;
-  }
 
   switch (field_type)
   {
   case DRIZZLE_TYPE_ENUM:
-    return new (&mem_root) Field_enum(ptr,
-                                      field_length,
-                                      null_pos,
-                                      null_bit,
-                                      field_name,
-                                      interval,
-                                      field_charset);
+    return new (&mem_root) Field_enum(ptr, field_length, null_pos, null_bit, field_name, interval, field_charset);
   case DRIZZLE_TYPE_VARCHAR:
     setVariableWidth();
-    return new (&mem_root) Field_varstring(ptr,field_length,
-                                      ha_varchar_packlength(field_length),
-                                      null_pos,null_bit,
-                                      field_name,
-                                      field_charset);
+    return new (&mem_root) Field_varstring(ptr,field_length, ha_varchar_packlength(field_length), null_pos,null_bit, field_name, field_charset);
   case DRIZZLE_TYPE_BLOB:
-    return new (&mem_root) Field_blob(ptr,
-                                      null_pos,
-                                      null_bit,
-                                      field_name,
-                                      this,
-                                      field_charset);
+    return new (&mem_root) Field_blob(ptr, null_pos, null_bit, field_name, this, field_charset);
   case DRIZZLE_TYPE_DECIMAL:
-    return new (&mem_root) Field_decimal(ptr,
-                                         field_length,
-                                         null_pos,
-                                         null_bit,
-                                         unireg_check,
-                                         field_name,
-                                         decimals);
+    return new (&mem_root) Field_decimal(ptr, field_length, null_pos, null_bit, unireg_check, field_name, decimals);
   case DRIZZLE_TYPE_DOUBLE:
-    return new (&mem_root) Field_double(ptr,
-                                   field_length,
-                                   null_pos,
-                                   null_bit,
-                                   unireg_check,
-                                   field_name,
-                                   decimals,
-                                   false,
-                                   false /* is_unsigned */);
+    return new (&mem_root) Field_double(ptr, field_length, null_pos, null_bit, unireg_check, field_name, decimals, false, false /* is_unsigned */);
   case DRIZZLE_TYPE_UUID:
-    return new (&mem_root) field::Uuid(ptr,
-                                       field_length,
-                                       null_pos,
-                                       null_bit,
-                                       field_name);
+    return new (&mem_root) field::Uuid(ptr, field_length, 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);
+    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,
-                                          null_pos,
-                                          null_bit,
-                                          field_name,
-                                          is_unsigned);
+    return new (&mem_root) field::Boolean(ptr, field_length, null_pos, null_bit, field_name, is_unsigned);
   case DRIZZLE_TYPE_LONG:
-    return new (&mem_root) field::Int32(ptr,
-                                        field_length,
-                                        null_pos,
-                                        null_bit,
-                                        unireg_check,
-                                        field_name);
+    return new (&mem_root) field::Int32(ptr, field_length, null_pos, null_bit, unireg_check, field_name);
   case DRIZZLE_TYPE_LONGLONG:
-    {
-      if (is_unsigned)
-      {
-        return new (&mem_root) field::Size(ptr,
-                                           field_length,
-                                           null_pos,
-                                           null_bit,
-                                           unireg_check,
-                                           field_name);
-      }
-
-      return new (&mem_root) field::Int64(ptr,
-                                          field_length,
-                                          null_pos,
-                                          null_bit,
-                                          unireg_check,
-                                          field_name);
-    }
+    if (is_unsigned)
+      return new (&mem_root) field::Size(ptr, field_length, null_pos, null_bit, unireg_check, field_name);
+    return new (&mem_root) field::Int64(ptr, field_length, null_pos, null_bit, unireg_check, field_name);
   case DRIZZLE_TYPE_MICROTIME:
-    return new (&mem_root) field::Microtime(ptr,
-                                            null_pos,
-                                            null_bit,
-                                            unireg_check,
-                                            field_name,
-                                            this);
+    return new (&mem_root) field::Microtime(ptr, null_pos, null_bit, unireg_check, field_name, this);
   case DRIZZLE_TYPE_TIMESTAMP:
-    return new (&mem_root) field::Epoch(ptr,
-                                        null_pos,
-                                        null_bit,
-                                        unireg_check,
-                                        field_name,
-                                        this);
+    return new (&mem_root) field::Epoch(ptr, null_pos, null_bit, unireg_check, field_name, this);
   case DRIZZLE_TYPE_TIME:
     return new (&mem_root) field::Time(ptr, field_length, null_pos, null_bit, field_name);
   case DRIZZLE_TYPE_DATE:
@@ -1916,5 +1823,4 @@
   version= g_refresh_version;
 }
 
-
 } /* namespace drizzled */