incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [43/50] [abbrv] Blur-core compiling but several other projects are still broken.
Date Wed, 07 Nov 2012 02:26:56 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/83aa59f5/interface/gen-perl/Blur/Blur.pm
----------------------------------------------------------------------
diff --git a/interface/gen-perl/Blur/Blur.pm b/interface/gen-perl/Blur/Blur.pm
index f7cda9d..8c21232 100644
--- a/interface/gen-perl/Blur/Blur.pm
+++ b/interface/gen-perl/Blur/Blur.pm
@@ -1097,167 +1097,6 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_query_args;
-use base qw(Class::Accessor);
-Blur::Blur_query_args->mk_accessors( qw( table blurQuery ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{table} = undef;
-  $self->{blurQuery} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
-    }
-    if (defined $vals->{blurQuery}) {
-      $self->{blurQuery} = $vals->{blurQuery};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Blur_query_args';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{blurQuery} = new Blur::BlurQuery();
-        $xfer += $self->{blurQuery}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-        $xfer += $input->skip($ftype);
-    }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_query_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{blurQuery}) {
-    $xfer += $output->writeFieldBegin('blurQuery', TType::STRUCT, 2);
-    $xfer += $self->{blurQuery}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Blur_query_result;
-use base qw(Class::Accessor);
-Blur::Blur_query_result->mk_accessors( qw( success ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{success} = undef;
-  $self->{ex} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{success}) {
-      $self->{success} = $vals->{success};
-    }
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Blur_query_result';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^0$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{success} = new Blur::BlurResults();
-        $xfer += $self->{success}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-        $xfer += $input->skip($ftype);
-    }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_query_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
-    $xfer += $self->{success}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
 package Blur::Blur_cancelQuery_args;
 use base qw(Class::Accessor);
 Blur::Blur_cancelQuery_args->mk_accessors( qw( table uuid ) );
@@ -2328,41 +2167,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_terms_args;
+package Blur::Blur_createTable_args;
 use base qw(Class::Accessor);
-Blur::Blur_terms_args->mk_accessors( qw( table columnFamily columnName startWith size ) );
+Blur::Blur_createTable_args->mk_accessors( qw( tableDescriptor ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{table} = undef;
-  $self->{columnFamily} = undef;
-  $self->{columnName} = undef;
-  $self->{startWith} = undef;
-  $self->{size} = undef;
+  $self->{tableDescriptor} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
-    }
-    if (defined $vals->{columnFamily}) {
-      $self->{columnFamily} = $vals->{columnFamily};
-    }
-    if (defined $vals->{columnName}) {
-      $self->{columnName} = $vals->{columnName};
-    }
-    if (defined $vals->{startWith}) {
-      $self->{startWith} = $vals->{startWith};
-    }
-    if (defined $vals->{size}) {
-      $self->{size} = $vals->{size};
+    if (defined $vals->{tableDescriptor}) {
+      $self->{tableDescriptor} = $vals->{tableDescriptor};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_terms_args';
+  return 'Blur_createTable_args';
 }
 
 sub read {
@@ -2380,32 +2203,9 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{columnFamily});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^3$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{columnName});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^4$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{startWith});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^5$/ && do{      if ($ftype == TType::I16) {
-        $xfer += $input->readI16(\$self->{size});
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{tableDescriptor} = new Blur::TableDescriptor();
+        $xfer += $self->{tableDescriptor}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -2421,30 +2221,10 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_terms_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{columnFamily}) {
-    $xfer += $output->writeFieldBegin('columnFamily', TType::STRING, 2);
-    $xfer += $output->writeString($self->{columnFamily});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{columnName}) {
-    $xfer += $output->writeFieldBegin('columnName', TType::STRING, 3);
-    $xfer += $output->writeString($self->{columnName});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{startWith}) {
-    $xfer += $output->writeFieldBegin('startWith', TType::STRING, 4);
-    $xfer += $output->writeString($self->{startWith});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{size}) {
-    $xfer += $output->writeFieldBegin('size', TType::I16, 5);
-    $xfer += $output->writeI16($self->{size});
+  $xfer += $output->writeStructBegin('Blur_createTable_args');
+  if (defined $self->{tableDescriptor}) {
+    $xfer += $output->writeFieldBegin('tableDescriptor', TType::STRUCT, 1);
+    $xfer += $self->{tableDescriptor}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -2452,20 +2232,16 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_terms_result;
+package Blur::Blur_createTable_result;
 use base qw(Class::Accessor);
-Blur::Blur_terms_result->mk_accessors( qw( success ) );
+Blur::Blur_createTable_result->mk_accessors( qw( ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{success} = undef;
   $self->{ex} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{success}) {
-      $self->{success} = $vals->{success};
-    }
     if (defined $vals->{ex}) {
       $self->{ex} = $vals->{ex};
     }
@@ -2474,7 +2250,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_terms_result';
+  return 'Blur_createTable_result';
 }
 
 sub read {
@@ -2492,24 +2268,6 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::LIST) {
-        {
-          my $_size263 = 0;
-          $self->{success} = [];
-          my $_etype266 = 0;
-          $xfer += $input->readListBegin(\$_etype266, \$_size263);
-          for (my $_i267 = 0; $_i267 < $_size263; ++$_i267)
-          {
-            my $elem268 = undef;
-            $xfer += $input->readString(\$elem268);
-            push(@{$self->{success}},$elem268);
-          }
-          $xfer += $input->readListEnd();
-        }
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
       /^1$/ && do{      if ($ftype == TType::STRUCT) {
         $self->{ex} = new Blur::BlurException();
         $xfer += $self->{ex}->read($input);
@@ -2528,21 +2286,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_terms_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
-    {
-      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
-      {
-        foreach my $iter269 (@{$self->{success}}) 
-        {
-          $xfer += $output->writeString($iter269);
-        }
-      }
-      $xfer += $output->writeListEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
+  $xfer += $output->writeStructBegin('Blur_createTable_result');
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -2553,37 +2297,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_recordFrequency_args;
+package Blur::Blur_enableTable_args;
 use base qw(Class::Accessor);
-Blur::Blur_recordFrequency_args->mk_accessors( qw( table columnFamily columnName value ) );
+Blur::Blur_enableTable_args->mk_accessors( qw( table ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{table} = undef;
-  $self->{columnFamily} = undef;
-  $self->{columnName} = undef;
-  $self->{value} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{table}) {
       $self->{table} = $vals->{table};
     }
-    if (defined $vals->{columnFamily}) {
-      $self->{columnFamily} = $vals->{columnFamily};
-    }
-    if (defined $vals->{columnName}) {
-      $self->{columnName} = $vals->{columnName};
-    }
-    if (defined $vals->{value}) {
-      $self->{value} = $vals->{value};
-    }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_recordFrequency_args';
+  return 'Blur_enableTable_args';
 }
 
 sub read {
@@ -2607,24 +2339,6 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^2$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{columnFamily});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^3$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{columnName});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^4$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{value});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -2636,46 +2350,27 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_recordFrequency_args');
+  $xfer += $output->writeStructBegin('Blur_enableTable_args');
   if (defined $self->{table}) {
     $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
     $xfer += $output->writeString($self->{table});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{columnFamily}) {
-    $xfer += $output->writeFieldBegin('columnFamily', TType::STRING, 2);
-    $xfer += $output->writeString($self->{columnFamily});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{columnName}) {
-    $xfer += $output->writeFieldBegin('columnName', TType::STRING, 3);
-    $xfer += $output->writeString($self->{columnName});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{value}) {
-    $xfer += $output->writeFieldBegin('value', TType::STRING, 4);
-    $xfer += $output->writeString($self->{value});
-    $xfer += $output->writeFieldEnd();
-  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_recordFrequency_result;
+package Blur::Blur_enableTable_result;
 use base qw(Class::Accessor);
-Blur::Blur_recordFrequency_result->mk_accessors( qw( success ) );
+Blur::Blur_enableTable_result->mk_accessors( qw( ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{success} = undef;
   $self->{ex} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{success}) {
-      $self->{success} = $vals->{success};
-    }
     if (defined $vals->{ex}) {
       $self->{ex} = $vals->{ex};
     }
@@ -2684,7 +2379,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_recordFrequency_result';
+  return 'Blur_enableTable_result';
 }
 
 sub read {
@@ -2702,12 +2397,6 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::I64) {
-        $xfer += $input->readI64(\$self->{success});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
       /^1$/ && do{      if ($ftype == TType::STRUCT) {
         $self->{ex} = new Blur::BlurException();
         $xfer += $self->{ex}->read($input);
@@ -2726,12 +2415,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_recordFrequency_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::I64, 0);
-    $xfer += $output->writeI64($self->{success});
-    $xfer += $output->writeFieldEnd();
-  }
+  $xfer += $output->writeStructBegin('Blur_enableTable_result');
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -2742,29 +2426,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_fetchRow_args;
+package Blur::Blur_disableTable_args;
 use base qw(Class::Accessor);
-Blur::Blur_fetchRow_args->mk_accessors( qw( table selector ) );
+Blur::Blur_disableTable_args->mk_accessors( qw( table ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{table} = undef;
-  $self->{selector} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{table}) {
       $self->{table} = $vals->{table};
     }
-    if (defined $vals->{selector}) {
-      $self->{selector} = $vals->{selector};
-    }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_fetchRow_args';
+  return 'Blur_disableTable_args';
 }
 
 sub read {
@@ -2788,13 +2468,6 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^2$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{selector} = new Blur::Selector();
-        $xfer += $self->{selector}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -2806,36 +2479,27 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_fetchRow_args');
+  $xfer += $output->writeStructBegin('Blur_disableTable_args');
   if (defined $self->{table}) {
     $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
     $xfer += $output->writeString($self->{table});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{selector}) {
-    $xfer += $output->writeFieldBegin('selector', TType::STRUCT, 2);
-    $xfer += $self->{selector}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_fetchRow_result;
+package Blur::Blur_disableTable_result;
 use base qw(Class::Accessor);
-Blur::Blur_fetchRow_result->mk_accessors( qw( success ) );
+Blur::Blur_disableTable_result->mk_accessors( qw( ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{success} = undef;
   $self->{ex} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{success}) {
-      $self->{success} = $vals->{success};
-    }
     if (defined $vals->{ex}) {
       $self->{ex} = $vals->{ex};
     }
@@ -2844,7 +2508,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_fetchRow_result';
+  return 'Blur_disableTable_result';
 }
 
 sub read {
@@ -2862,13 +2526,6 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{success} = new Blur::FetchResult();
-        $xfer += $self->{success}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
       /^1$/ && do{      if ($ftype == TType::STRUCT) {
         $self->{ex} = new Blur::BlurException();
         $xfer += $self->{ex}->read($input);
@@ -2887,12 +2544,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_fetchRow_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
-    $xfer += $self->{success}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
+  $xfer += $output->writeStructBegin('Blur_disableTable_result');
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -2903,25 +2555,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_mutate_args;
+package Blur::Blur_removeTable_args;
 use base qw(Class::Accessor);
-Blur::Blur_mutate_args->mk_accessors( qw( mutation ) );
+Blur::Blur_removeTable_args->mk_accessors( qw( table deleteIndexFiles ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{mutation} = undef;
+  $self->{table} = undef;
+  $self->{deleteIndexFiles} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{mutation}) {
-      $self->{mutation} = $vals->{mutation};
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
+    }
+    if (defined $vals->{deleteIndexFiles}) {
+      $self->{deleteIndexFiles} = $vals->{deleteIndexFiles};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_mutate_args';
+  return 'Blur_removeTable_args';
 }
 
 sub read {
@@ -2939,9 +2595,14 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{mutation} = new Blur::RowMutation();
-        $xfer += $self->{mutation}->read($input);
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{table});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{deleteIndexFiles});
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -2957,10 +2618,15 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_mutate_args');
-  if (defined $self->{mutation}) {
-    $xfer += $output->writeFieldBegin('mutation', TType::STRUCT, 1);
-    $xfer += $self->{mutation}->write($output);
+  $xfer += $output->writeStructBegin('Blur_removeTable_args');
+  if (defined $self->{table}) {
+    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+    $xfer += $output->writeString($self->{table});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{deleteIndexFiles}) {
+    $xfer += $output->writeFieldBegin('deleteIndexFiles', TType::BOOL, 2);
+    $xfer += $output->writeBool($self->{deleteIndexFiles});
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -2968,9 +2634,9 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_mutate_result;
+package Blur::Blur_removeTable_result;
 use base qw(Class::Accessor);
-Blur::Blur_mutate_result->mk_accessors( qw( ) );
+Blur::Blur_removeTable_result->mk_accessors( qw( ) );
 
 sub new {
   my $classname = shift;
@@ -2986,7 +2652,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_mutate_result';
+  return 'Blur_removeTable_result';
 }
 
 sub read {
@@ -3022,7 +2688,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_mutate_result');
+  $xfer += $output->writeStructBegin('Blur_removeTable_result');
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -3033,25 +2699,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_mutateBatch_args;
+package Blur::Blur_optimize_args;
 use base qw(Class::Accessor);
-Blur::Blur_mutateBatch_args->mk_accessors( qw( mutations ) );
+Blur::Blur_optimize_args->mk_accessors( qw( table numberOfSegmentsPerShard ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{mutations} = undef;
+  $self->{table} = undef;
+  $self->{numberOfSegmentsPerShard} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{mutations}) {
-      $self->{mutations} = $vals->{mutations};
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
+    }
+    if (defined $vals->{numberOfSegmentsPerShard}) {
+      $self->{numberOfSegmentsPerShard} = $vals->{numberOfSegmentsPerShard};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_mutateBatch_args';
+  return 'Blur_optimize_args';
 }
 
 sub read {
@@ -3069,21 +2739,14 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::LIST) {
-        {
-          my $_size270 = 0;
-          $self->{mutations} = [];
-          my $_etype273 = 0;
-          $xfer += $input->readListBegin(\$_etype273, \$_size270);
-          for (my $_i274 = 0; $_i274 < $_size270; ++$_i274)
-          {
-            my $elem275 = undef;
-            $elem275 = new Blur::RowMutation();
-            $xfer += $elem275->read($input);
-            push(@{$self->{mutations}},$elem275);
-          }
-          $xfer += $input->readListEnd();
-        }
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{table});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::I32) {
+        $xfer += $input->readI32(\$self->{numberOfSegmentsPerShard});
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -3099,19 +2762,15 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_mutateBatch_args');
-  if (defined $self->{mutations}) {
-    $xfer += $output->writeFieldBegin('mutations', TType::LIST, 1);
-    {
-      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{mutations}}));
-      {
-        foreach my $iter276 (@{$self->{mutations}}) 
-        {
-          $xfer += ${iter276}->write($output);
-        }
-      }
-      $xfer += $output->writeListEnd();
-    }
+  $xfer += $output->writeStructBegin('Blur_optimize_args');
+  if (defined $self->{table}) {
+    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+    $xfer += $output->writeString($self->{table});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{numberOfSegmentsPerShard}) {
+    $xfer += $output->writeFieldBegin('numberOfSegmentsPerShard', TType::I32, 2);
+    $xfer += $output->writeI32($self->{numberOfSegmentsPerShard});
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -3119,9 +2778,9 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_mutateBatch_result;
+package Blur::Blur_optimize_result;
 use base qw(Class::Accessor);
-Blur::Blur_mutateBatch_result->mk_accessors( qw( ) );
+Blur::Blur_optimize_result->mk_accessors( qw( ) );
 
 sub new {
   my $classname = shift;
@@ -3137,7 +2796,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_mutateBatch_result';
+  return 'Blur_optimize_result';
 }
 
 sub read {
@@ -3173,7 +2832,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_mutateBatch_result');
+  $xfer += $output->writeStructBegin('Blur_optimize_result');
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -3184,25 +2843,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_createTable_args;
+package Blur::Blur_isInSafeMode_args;
 use base qw(Class::Accessor);
-Blur::Blur_createTable_args->mk_accessors( qw( tableDescriptor ) );
+Blur::Blur_isInSafeMode_args->mk_accessors( qw( cluster ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{tableDescriptor} = undef;
+  $self->{cluster} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{tableDescriptor}) {
-      $self->{tableDescriptor} = $vals->{tableDescriptor};
+    if (defined $vals->{cluster}) {
+      $self->{cluster} = $vals->{cluster};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_createTable_args';
+  return 'Blur_isInSafeMode_args';
 }
 
 sub read {
@@ -3220,9 +2879,8 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{tableDescriptor} = new Blur::TableDescriptor();
-        $xfer += $self->{tableDescriptor}->read($input);
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{cluster});
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -3238,10 +2896,10 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_createTable_args');
-  if (defined $self->{tableDescriptor}) {
-    $xfer += $output->writeFieldBegin('tableDescriptor', TType::STRUCT, 1);
-    $xfer += $self->{tableDescriptor}->write($output);
+  $xfer += $output->writeStructBegin('Blur_isInSafeMode_args');
+  if (defined $self->{cluster}) {
+    $xfer += $output->writeFieldBegin('cluster', TType::STRING, 1);
+    $xfer += $output->writeString($self->{cluster});
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -3249,16 +2907,20 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_createTable_result;
+package Blur::Blur_isInSafeMode_result;
 use base qw(Class::Accessor);
-Blur::Blur_createTable_result->mk_accessors( qw( ) );
+Blur::Blur_isInSafeMode_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
+  $self->{success} = undef;
   $self->{ex} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{success}) {
+      $self->{success} = $vals->{success};
+    }
     if (defined $vals->{ex}) {
       $self->{ex} = $vals->{ex};
     }
@@ -3267,7 +2929,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_createTable_result';
+  return 'Blur_isInSafeMode_result';
 }
 
 sub read {
@@ -3285,6 +2947,12 @@ sub read {
     }
     SWITCH: for($fid)
     {
+      /^0$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{success});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
       /^1$/ && do{      if ($ftype == TType::STRUCT) {
         $self->{ex} = new Blur::BlurException();
         $xfer += $self->{ex}->read($input);
@@ -3303,7 +2971,12 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_createTable_result');
+  $xfer += $output->writeStructBegin('Blur_isInSafeMode_result');
+  if (defined $self->{success}) {
+    $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
+    $xfer += $output->writeBool($self->{success});
+    $xfer += $output->writeFieldEnd();
+  }
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -3314,25 +2987,18 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_enableTable_args;
+package Blur::Blur_configuration_args;
 use base qw(Class::Accessor);
-Blur::Blur_enableTable_args->mk_accessors( qw( table ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{table} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
-    }
-  }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_enableTable_args';
+  return 'Blur_configuration_args';
 }
 
 sub read {
@@ -3350,12 +3016,6 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -3367,27 +3027,26 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_enableTable_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
-  }
+  $xfer += $output->writeStructBegin('Blur_configuration_args');
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_enableTable_result;
+package Blur::Blur_configuration_result;
 use base qw(Class::Accessor);
-Blur::Blur_enableTable_result->mk_accessors( qw( ) );
+Blur::Blur_configuration_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
+  $self->{success} = undef;
   $self->{ex} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{success}) {
+      $self->{success} = $vals->{success};
+    }
     if (defined $vals->{ex}) {
       $self->{ex} = $vals->{ex};
     }
@@ -3396,7 +3055,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_enableTable_result';
+  return 'Blur_configuration_result';
 }
 
 sub read {
@@ -3414,6 +3073,27 @@ sub read {
     }
     SWITCH: for($fid)
     {
+      /^0$/ && do{      if ($ftype == TType::MAP) {
+        {
+          my $_size263 = 0;
+          $self->{success} = {};
+          my $_ktype264 = 0;
+          my $_vtype265 = 0;
+          $xfer += $input->readMapBegin(\$_ktype264, \$_vtype265, \$_size263);
+          for (my $_i267 = 0; $_i267 < $_size263; ++$_i267)
+          {
+            my $key268 = '';
+            my $val269 = '';
+            $xfer += $input->readString(\$key268);
+            $xfer += $input->readString(\$val269);
+            $self->{success}->{$key268} = $val269;
+          }
+          $xfer += $input->readMapEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
       /^1$/ && do{      if ($ftype == TType::STRUCT) {
         $self->{ex} = new Blur::BlurException();
         $xfer += $self->{ex}->read($input);
@@ -3432,7 +3112,22 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_enableTable_result');
+  $xfer += $output->writeStructBegin('Blur_configuration_result');
+  if (defined $self->{success}) {
+    $xfer += $output->writeFieldBegin('success', TType::MAP, 0);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
+      {
+        while( my ($kiter270,$viter271) = each %{$self->{success}}) 
+        {
+          $xfer += $output->writeString($kiter270);
+          $xfer += $output->writeString($viter271);
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -3443,734 +3138,22 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_disableTable_args;
-use base qw(Class::Accessor);
-Blur::Blur_disableTable_args->mk_accessors( qw( table ) );
+package Blur::BlurIf;
 
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{table} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
-    }
-  }
-  return bless ($self, $classname);
+use strict;
+
+
+sub shardClusterList{
+  my $self = shift;
+
+  die 'implement interface';
 }
 
-sub getName {
-  return 'Blur_disableTable_args';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-        $xfer += $input->skip($ftype);
-    }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_disableTable_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Blur_disableTable_result;
-use base qw(Class::Accessor);
-Blur::Blur_disableTable_result->mk_accessors( qw( ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{ex} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Blur_disableTable_result';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-        $xfer += $input->skip($ftype);
-    }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_disableTable_result');
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Blur_removeTable_args;
-use base qw(Class::Accessor);
-Blur::Blur_removeTable_args->mk_accessors( qw( table deleteIndexFiles ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{table} = undef;
-  $self->{deleteIndexFiles} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
-    }
-    if (defined $vals->{deleteIndexFiles}) {
-      $self->{deleteIndexFiles} = $vals->{deleteIndexFiles};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Blur_removeTable_args';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{deleteIndexFiles});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-        $xfer += $input->skip($ftype);
-    }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_removeTable_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{deleteIndexFiles}) {
-    $xfer += $output->writeFieldBegin('deleteIndexFiles', TType::BOOL, 2);
-    $xfer += $output->writeBool($self->{deleteIndexFiles});
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Blur_removeTable_result;
-use base qw(Class::Accessor);
-Blur::Blur_removeTable_result->mk_accessors( qw( ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{ex} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Blur_removeTable_result';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-        $xfer += $input->skip($ftype);
-    }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_removeTable_result');
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Blur_optimize_args;
-use base qw(Class::Accessor);
-Blur::Blur_optimize_args->mk_accessors( qw( table numberOfSegmentsPerShard ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{table} = undef;
-  $self->{numberOfSegmentsPerShard} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
-    }
-    if (defined $vals->{numberOfSegmentsPerShard}) {
-      $self->{numberOfSegmentsPerShard} = $vals->{numberOfSegmentsPerShard};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Blur_optimize_args';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::I32) {
-        $xfer += $input->readI32(\$self->{numberOfSegmentsPerShard});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-        $xfer += $input->skip($ftype);
-    }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_optimize_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{numberOfSegmentsPerShard}) {
-    $xfer += $output->writeFieldBegin('numberOfSegmentsPerShard', TType::I32, 2);
-    $xfer += $output->writeI32($self->{numberOfSegmentsPerShard});
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Blur_optimize_result;
-use base qw(Class::Accessor);
-Blur::Blur_optimize_result->mk_accessors( qw( ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{ex} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Blur_optimize_result';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-        $xfer += $input->skip($ftype);
-    }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_optimize_result');
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Blur_isInSafeMode_args;
-use base qw(Class::Accessor);
-Blur::Blur_isInSafeMode_args->mk_accessors( qw( cluster ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{cluster} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{cluster}) {
-      $self->{cluster} = $vals->{cluster};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Blur_isInSafeMode_args';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{cluster});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-        $xfer += $input->skip($ftype);
-    }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_isInSafeMode_args');
-  if (defined $self->{cluster}) {
-    $xfer += $output->writeFieldBegin('cluster', TType::STRING, 1);
-    $xfer += $output->writeString($self->{cluster});
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Blur_isInSafeMode_result;
-use base qw(Class::Accessor);
-Blur::Blur_isInSafeMode_result->mk_accessors( qw( success ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{success} = undef;
-  $self->{ex} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{success}) {
-      $self->{success} = $vals->{success};
-    }
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Blur_isInSafeMode_result';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^0$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{success});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-        $xfer += $input->skip($ftype);
-    }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_isInSafeMode_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
-    $xfer += $output->writeBool($self->{success});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Blur_configuration_args;
-use base qw(Class::Accessor);
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Blur_configuration_args';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-        $xfer += $input->skip($ftype);
-    }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_configuration_args');
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Blur_configuration_result;
-use base qw(Class::Accessor);
-Blur::Blur_configuration_result->mk_accessors( qw( success ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{success} = undef;
-  $self->{ex} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{success}) {
-      $self->{success} = $vals->{success};
-    }
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Blur_configuration_result';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^0$/ && do{      if ($ftype == TType::MAP) {
-        {
-          my $_size277 = 0;
-          $self->{success} = {};
-          my $_ktype278 = 0;
-          my $_vtype279 = 0;
-          $xfer += $input->readMapBegin(\$_ktype278, \$_vtype279, \$_size277);
-          for (my $_i281 = 0; $_i281 < $_size277; ++$_i281)
-          {
-            my $key282 = '';
-            my $val283 = '';
-            $xfer += $input->readString(\$key282);
-            $xfer += $input->readString(\$val283);
-            $self->{success}->{$key282} = $val283;
-          }
-          $xfer += $input->readMapEnd();
-        }
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-        $xfer += $input->skip($ftype);
-    }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_configuration_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::MAP, 0);
-    {
-      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
-      {
-        while( my ($kiter284,$viter285) = each %{$self->{success}}) 
-        {
-          $xfer += $output->writeString($kiter284);
-          $xfer += $output->writeString($viter285);
-        }
-      }
-      $xfer += $output->writeMapEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::BlurIf;
-
-use strict;
-
-
-sub shardClusterList{
-  my $self = shift;
-
-  die 'implement interface';
-}
-
-sub shardServerList{
-  my $self = shift;
-  my $cluster = shift;
-
-  die 'implement interface';
+sub shardServerList{
+  my $self = shift;
+  my $cluster = shift;
+
+  die 'implement interface';
 }
 
 sub controllerServerList{
@@ -4194,116 +3177,65 @@ sub tableList{
 
 sub tableListByCluster{
   my $self = shift;
-  my $cluster = shift;
-
-  die 'implement interface';
-}
-
-sub describe{
-  my $self = shift;
-  my $table = shift;
-
-  die 'implement interface';
-}
-
-sub query{
-  my $self = shift;
-  my $table = shift;
-  my $blurQuery = shift;
-
-  die 'implement interface';
-}
-
-sub cancelQuery{
-  my $self = shift;
-  my $table = shift;
-  my $uuid = shift;
-
-  die 'implement interface';
-}
-
-sub currentQueries{
-  my $self = shift;
-  my $table = shift;
-
-  die 'implement interface';
-}
-
-sub queryStatusIdList{
-  my $self = shift;
-  my $table = shift;
-
-  die 'implement interface';
-}
-
-sub queryStatusById{
-  my $self = shift;
-  my $table = shift;
-  my $uuid = shift;
+  my $cluster = shift;
 
   die 'implement interface';
 }
 
-sub schema{
+sub describe{
   my $self = shift;
   my $table = shift;
 
   die 'implement interface';
 }
 
-sub getTableStats{
+sub cancelQuery{
   my $self = shift;
   my $table = shift;
+  my $uuid = shift;
 
   die 'implement interface';
 }
 
-sub tableStats{
+sub currentQueries{
   my $self = shift;
   my $table = shift;
 
   die 'implement interface';
 }
 
-sub terms{
+sub queryStatusIdList{
   my $self = shift;
   my $table = shift;
-  my $columnFamily = shift;
-  my $columnName = shift;
-  my $startWith = shift;
-  my $size = shift;
 
   die 'implement interface';
 }
 
-sub recordFrequency{
+sub queryStatusById{
   my $self = shift;
   my $table = shift;
-  my $columnFamily = shift;
-  my $columnName = shift;
-  my $value = shift;
+  my $uuid = shift;
 
   die 'implement interface';
 }
 
-sub fetchRow{
+sub schema{
   my $self = shift;
   my $table = shift;
-  my $selector = shift;
 
   die 'implement interface';
 }
 
-sub mutate{
+sub getTableStats{
   my $self = shift;
-  my $mutation = shift;
+  my $table = shift;
 
   die 'implement interface';
 }
 
-sub mutateBatch{
+sub tableStats{
   my $self = shift;
-  my $mutations = shift;
+  my $table = shift;
 
   die 'implement interface';
 }
@@ -4416,14 +3348,6 @@ sub describe{
   return $self->{impl}->describe($table);
 }
 
-sub query{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  my $blurQuery = ($request->{'blurQuery'}) ? $request->{'blurQuery'} : undef;
-  return $self->{impl}->query($table, $blurQuery);
-}
-
 sub cancelQuery{
   my ($self, $request) = @_;
 
@@ -4439,436 +3363,123 @@ sub currentQueries{
   return $self->{impl}->currentQueries($table);
 }
 
-sub queryStatusIdList{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  return $self->{impl}->queryStatusIdList($table);
-}
-
-sub queryStatusById{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  my $uuid = ($request->{'uuid'}) ? $request->{'uuid'} : undef;
-  return $self->{impl}->queryStatusById($table, $uuid);
-}
-
-sub schema{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  return $self->{impl}->schema($table);
-}
-
-sub getTableStats{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  return $self->{impl}->getTableStats($table);
-}
-
-sub tableStats{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  return $self->{impl}->tableStats($table);
-}
-
-sub terms{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  my $columnFamily = ($request->{'columnFamily'}) ? $request->{'columnFamily'} : undef;
-  my $columnName = ($request->{'columnName'}) ? $request->{'columnName'} : undef;
-  my $startWith = ($request->{'startWith'}) ? $request->{'startWith'} : undef;
-  my $size = ($request->{'size'}) ? $request->{'size'} : undef;
-  return $self->{impl}->terms($table, $columnFamily, $columnName, $startWith, $size);
-}
-
-sub recordFrequency{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  my $columnFamily = ($request->{'columnFamily'}) ? $request->{'columnFamily'} : undef;
-  my $columnName = ($request->{'columnName'}) ? $request->{'columnName'} : undef;
-  my $value = ($request->{'value'}) ? $request->{'value'} : undef;
-  return $self->{impl}->recordFrequency($table, $columnFamily, $columnName, $value);
-}
-
-sub fetchRow{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  my $selector = ($request->{'selector'}) ? $request->{'selector'} : undef;
-  return $self->{impl}->fetchRow($table, $selector);
-}
-
-sub mutate{
-  my ($self, $request) = @_;
-
-  my $mutation = ($request->{'mutation'}) ? $request->{'mutation'} : undef;
-  return $self->{impl}->mutate($mutation);
-}
-
-sub mutateBatch{
-  my ($self, $request) = @_;
-
-  my $mutations = ($request->{'mutations'}) ? $request->{'mutations'} : undef;
-  return $self->{impl}->mutateBatch($mutations);
-}
-
-sub createTable{
-  my ($self, $request) = @_;
-
-  my $tableDescriptor = ($request->{'tableDescriptor'}) ? $request->{'tableDescriptor'} : undef;
-  return $self->{impl}->createTable($tableDescriptor);
-}
-
-sub enableTable{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  return $self->{impl}->enableTable($table);
-}
-
-sub disableTable{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  return $self->{impl}->disableTable($table);
-}
-
-sub removeTable{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  my $deleteIndexFiles = ($request->{'deleteIndexFiles'}) ? $request->{'deleteIndexFiles'} : undef;
-  return $self->{impl}->removeTable($table, $deleteIndexFiles);
-}
-
-sub optimize{
-  my ($self, $request) = @_;
-
-  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
-  my $numberOfSegmentsPerShard = ($request->{'numberOfSegmentsPerShard'}) ? $request->{'numberOfSegmentsPerShard'} : undef;
-  return $self->{impl}->optimize($table, $numberOfSegmentsPerShard);
-}
-
-sub isInSafeMode{
-  my ($self, $request) = @_;
-
-  my $cluster = ($request->{'cluster'}) ? $request->{'cluster'} : undef;
-  return $self->{impl}->isInSafeMode($cluster);
-}
-
-sub configuration{
-  my ($self, $request) = @_;
-
-  return $self->{impl}->configuration();
-}
-
-package Blur::BlurClient;
-
-
-use base qw(Blur::BlurIf);
-sub new {
-  my ($classname, $input, $output) = @_;
-  my $self      = {};
-  $self->{input}  = $input;
-  $self->{output} = defined $output ? $output : $input;
-  $self->{seqid}  = 0;
-  return bless($self,$classname);
-}
-
-sub shardClusterList{
-  my $self = shift;
-
-    $self->send_shardClusterList();
-  return $self->recv_shardClusterList();
-}
-
-sub send_shardClusterList{
-  my $self = shift;
-
-  $self->{output}->writeMessageBegin('shardClusterList', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_shardClusterList_args();
-  $args->write($self->{output});
-  $self->{output}->writeMessageEnd();
-  $self->{output}->getTransport()->flush();
-}
-
-sub recv_shardClusterList{
-  my $self = shift;
-
-  my $rseqid = 0;
-  my $fname;
-  my $mtype = 0;
-
-  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
-  if ($mtype == TMessageType::EXCEPTION) {
-    my $x = new TApplicationException();
-    $x->read($self->{input});
-    $self->{input}->readMessageEnd();
-    die $x;
-  }
-  my $result = new Blur::Blur_shardClusterList_result();
-  $result->read($self->{input});
-  $self->{input}->readMessageEnd();
-
-  if (defined $result->{success} ) {
-    return $result->{success};
-  }
-  if (defined $result->{ex}) {
-    die $result->{ex};
-  }
-  die "shardClusterList failed: unknown result";
-}
-sub shardServerList{
-  my $self = shift;
-  my $cluster = shift;
-
-    $self->send_shardServerList($cluster);
-  return $self->recv_shardServerList();
-}
-
-sub send_shardServerList{
-  my $self = shift;
-  my $cluster = shift;
-
-  $self->{output}->writeMessageBegin('shardServerList', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_shardServerList_args();
-  $args->{cluster} = $cluster;
-  $args->write($self->{output});
-  $self->{output}->writeMessageEnd();
-  $self->{output}->getTransport()->flush();
-}
-
-sub recv_shardServerList{
-  my $self = shift;
-
-  my $rseqid = 0;
-  my $fname;
-  my $mtype = 0;
-
-  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
-  if ($mtype == TMessageType::EXCEPTION) {
-    my $x = new TApplicationException();
-    $x->read($self->{input});
-    $self->{input}->readMessageEnd();
-    die $x;
-  }
-  my $result = new Blur::Blur_shardServerList_result();
-  $result->read($self->{input});
-  $self->{input}->readMessageEnd();
-
-  if (defined $result->{success} ) {
-    return $result->{success};
-  }
-  if (defined $result->{ex}) {
-    die $result->{ex};
-  }
-  die "shardServerList failed: unknown result";
-}
-sub controllerServerList{
-  my $self = shift;
-
-    $self->send_controllerServerList();
-  return $self->recv_controllerServerList();
-}
-
-sub send_controllerServerList{
-  my $self = shift;
-
-  $self->{output}->writeMessageBegin('controllerServerList', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_controllerServerList_args();
-  $args->write($self->{output});
-  $self->{output}->writeMessageEnd();
-  $self->{output}->getTransport()->flush();
-}
-
-sub recv_controllerServerList{
-  my $self = shift;
-
-  my $rseqid = 0;
-  my $fname;
-  my $mtype = 0;
-
-  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
-  if ($mtype == TMessageType::EXCEPTION) {
-    my $x = new TApplicationException();
-    $x->read($self->{input});
-    $self->{input}->readMessageEnd();
-    die $x;
-  }
-  my $result = new Blur::Blur_controllerServerList_result();
-  $result->read($self->{input});
-  $self->{input}->readMessageEnd();
+sub queryStatusIdList{
+  my ($self, $request) = @_;
 
-  if (defined $result->{success} ) {
-    return $result->{success};
-  }
-  if (defined $result->{ex}) {
-    die $result->{ex};
-  }
-  die "controllerServerList failed: unknown result";
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  return $self->{impl}->queryStatusIdList($table);
 }
-sub shardServerLayout{
-  my $self = shift;
-  my $table = shift;
 
-    $self->send_shardServerLayout($table);
-  return $self->recv_shardServerLayout();
+sub queryStatusById{
+  my ($self, $request) = @_;
+
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  my $uuid = ($request->{'uuid'}) ? $request->{'uuid'} : undef;
+  return $self->{impl}->queryStatusById($table, $uuid);
 }
 
-sub send_shardServerLayout{
-  my $self = shift;
-  my $table = shift;
+sub schema{
+  my ($self, $request) = @_;
 
-  $self->{output}->writeMessageBegin('shardServerLayout', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_shardServerLayout_args();
-  $args->{table} = $table;
-  $args->write($self->{output});
-  $self->{output}->writeMessageEnd();
-  $self->{output}->getTransport()->flush();
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  return $self->{impl}->schema($table);
 }
 
-sub recv_shardServerLayout{
-  my $self = shift;
+sub getTableStats{
+  my ($self, $request) = @_;
 
-  my $rseqid = 0;
-  my $fname;
-  my $mtype = 0;
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  return $self->{impl}->getTableStats($table);
+}
 
-  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
-  if ($mtype == TMessageType::EXCEPTION) {
-    my $x = new TApplicationException();
-    $x->read($self->{input});
-    $self->{input}->readMessageEnd();
-    die $x;
-  }
-  my $result = new Blur::Blur_shardServerLayout_result();
-  $result->read($self->{input});
-  $self->{input}->readMessageEnd();
+sub tableStats{
+  my ($self, $request) = @_;
 
-  if (defined $result->{success} ) {
-    return $result->{success};
-  }
-  if (defined $result->{ex}) {
-    die $result->{ex};
-  }
-  die "shardServerLayout failed: unknown result";
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  return $self->{impl}->tableStats($table);
 }
-sub tableList{
-  my $self = shift;
 
-    $self->send_tableList();
-  return $self->recv_tableList();
+sub createTable{
+  my ($self, $request) = @_;
+
+  my $tableDescriptor = ($request->{'tableDescriptor'}) ? $request->{'tableDescriptor'} : undef;
+  return $self->{impl}->createTable($tableDescriptor);
 }
 
-sub send_tableList{
-  my $self = shift;
+sub enableTable{
+  my ($self, $request) = @_;
 
-  $self->{output}->writeMessageBegin('tableList', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_tableList_args();
-  $args->write($self->{output});
-  $self->{output}->writeMessageEnd();
-  $self->{output}->getTransport()->flush();
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  return $self->{impl}->enableTable($table);
 }
 
-sub recv_tableList{
-  my $self = shift;
+sub disableTable{
+  my ($self, $request) = @_;
 
-  my $rseqid = 0;
-  my $fname;
-  my $mtype = 0;
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  return $self->{impl}->disableTable($table);
+}
 
-  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
-  if ($mtype == TMessageType::EXCEPTION) {
-    my $x = new TApplicationException();
-    $x->read($self->{input});
-    $self->{input}->readMessageEnd();
-    die $x;
-  }
-  my $result = new Blur::Blur_tableList_result();
-  $result->read($self->{input});
-  $self->{input}->readMessageEnd();
+sub removeTable{
+  my ($self, $request) = @_;
 
-  if (defined $result->{success} ) {
-    return $result->{success};
-  }
-  if (defined $result->{ex}) {
-    die $result->{ex};
-  }
-  die "tableList failed: unknown result";
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  my $deleteIndexFiles = ($request->{'deleteIndexFiles'}) ? $request->{'deleteIndexFiles'} : undef;
+  return $self->{impl}->removeTable($table, $deleteIndexFiles);
 }
-sub tableListByCluster{
-  my $self = shift;
-  my $cluster = shift;
 
-    $self->send_tableListByCluster($cluster);
-  return $self->recv_tableListByCluster();
+sub optimize{
+  my ($self, $request) = @_;
+
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  my $numberOfSegmentsPerShard = ($request->{'numberOfSegmentsPerShard'}) ? $request->{'numberOfSegmentsPerShard'} : undef;
+  return $self->{impl}->optimize($table, $numberOfSegmentsPerShard);
 }
 
-sub send_tableListByCluster{
-  my $self = shift;
-  my $cluster = shift;
+sub isInSafeMode{
+  my ($self, $request) = @_;
 
-  $self->{output}->writeMessageBegin('tableListByCluster', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_tableListByCluster_args();
-  $args->{cluster} = $cluster;
-  $args->write($self->{output});
-  $self->{output}->writeMessageEnd();
-  $self->{output}->getTransport()->flush();
+  my $cluster = ($request->{'cluster'}) ? $request->{'cluster'} : undef;
+  return $self->{impl}->isInSafeMode($cluster);
 }
 
-sub recv_tableListByCluster{
-  my $self = shift;
+sub configuration{
+  my ($self, $request) = @_;
 
-  my $rseqid = 0;
-  my $fname;
-  my $mtype = 0;
+  return $self->{impl}->configuration();
+}
 
-  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
-  if ($mtype == TMessageType::EXCEPTION) {
-    my $x = new TApplicationException();
-    $x->read($self->{input});
-    $self->{input}->readMessageEnd();
-    die $x;
-  }
-  my $result = new Blur::Blur_tableListByCluster_result();
-  $result->read($self->{input});
-  $self->{input}->readMessageEnd();
+package Blur::BlurClient;
 
-  if (defined $result->{success} ) {
-    return $result->{success};
-  }
-  if (defined $result->{ex}) {
-    die $result->{ex};
-  }
-  die "tableListByCluster failed: unknown result";
+
+use base qw(Blur::BlurIf);
+sub new {
+  my ($classname, $input, $output) = @_;
+  my $self      = {};
+  $self->{input}  = $input;
+  $self->{output} = defined $output ? $output : $input;
+  $self->{seqid}  = 0;
+  return bless($self,$classname);
 }
-sub describe{
+
+sub shardClusterList{
   my $self = shift;
-  my $table = shift;
 
-    $self->send_describe($table);
-  return $self->recv_describe();
+    $self->send_shardClusterList();
+  return $self->recv_shardClusterList();
 }
 
-sub send_describe{
+sub send_shardClusterList{
   my $self = shift;
-  my $table = shift;
 
-  $self->{output}->writeMessageBegin('describe', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_describe_args();
-  $args->{table} = $table;
+  $self->{output}->writeMessageBegin('shardClusterList', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_shardClusterList_args();
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_describe{
+sub recv_shardClusterList{
   my $self = shift;
 
   my $rseqid = 0;
@@ -4882,7 +3493,7 @@ sub recv_describe{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_describe_result();
+  my $result = new Blur::Blur_shardClusterList_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
@@ -4892,32 +3503,29 @@ sub recv_describe{
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  die "describe failed: unknown result";
+  die "shardClusterList failed: unknown result";
 }
-sub query{
+sub shardServerList{
   my $self = shift;
-  my $table = shift;
-  my $blurQuery = shift;
+  my $cluster = shift;
 
-    $self->send_query($table, $blurQuery);
-  return $self->recv_query();
+    $self->send_shardServerList($cluster);
+  return $self->recv_shardServerList();
 }
 
-sub send_query{
+sub send_shardServerList{
   my $self = shift;
-  my $table = shift;
-  my $blurQuery = shift;
+  my $cluster = shift;
 
-  $self->{output}->writeMessageBegin('query', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_query_args();
-  $args->{table} = $table;
-  $args->{blurQuery} = $blurQuery;
+  $self->{output}->writeMessageBegin('shardServerList', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_shardServerList_args();
+  $args->{cluster} = $cluster;
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_query{
+sub recv_shardServerList{
   my $self = shift;
 
   my $rseqid = 0;
@@ -4931,7 +3539,7 @@ sub recv_query{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_query_result();
+  my $result = new Blur::Blur_shardServerList_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
@@ -4941,32 +3549,26 @@ sub recv_query{
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  die "query failed: unknown result";
+  die "shardServerList failed: unknown result";
 }
-sub cancelQuery{
+sub controllerServerList{
   my $self = shift;
-  my $table = shift;
-  my $uuid = shift;
 
-    $self->send_cancelQuery($table, $uuid);
-  $self->recv_cancelQuery();
+    $self->send_controllerServerList();
+  return $self->recv_controllerServerList();
 }
 
-sub send_cancelQuery{
+sub send_controllerServerList{
   my $self = shift;
-  my $table = shift;
-  my $uuid = shift;
 
-  $self->{output}->writeMessageBegin('cancelQuery', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_cancelQuery_args();
-  $args->{table} = $table;
-  $args->{uuid} = $uuid;
+  $self->{output}->writeMessageBegin('controllerServerList', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_controllerServerList_args();
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_cancelQuery{
+sub recv_controllerServerList{
   my $self = shift;
 
   my $rseqid = 0;
@@ -4980,36 +3582,39 @@ sub recv_cancelQuery{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_cancelQuery_result();
+  my $result = new Blur::Blur_controllerServerList_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
+  if (defined $result->{success} ) {
+    return $result->{success};
+  }
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  return;
+  die "controllerServerList failed: unknown result";
 }
-sub currentQueries{
+sub shardServerLayout{
   my $self = shift;
   my $table = shift;
 
-    $self->send_currentQueries($table);
-  return $self->recv_currentQueries();
+    $self->send_shardServerLayout($table);
+  return $self->recv_shardServerLayout();
 }
 
-sub send_currentQueries{
+sub send_shardServerLayout{
   my $self = shift;
   my $table = shift;
 
-  $self->{output}->writeMessageBegin('currentQueries', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_currentQueries_args();
+  $self->{output}->writeMessageBegin('shardServerLayout', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_shardServerLayout_args();
   $args->{table} = $table;
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_currentQueries{
+sub recv_shardServerLayout{
   my $self = shift;
 
   my $rseqid = 0;
@@ -5023,7 +3628,7 @@ sub recv_currentQueries{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_currentQueries_result();
+  my $result = new Blur::Blur_shardServerLayout_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
@@ -5033,29 +3638,26 @@ sub recv_currentQueries{
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  die "currentQueries failed: unknown result";
+  die "shardServerLayout failed: unknown result";
 }
-sub queryStatusIdList{
+sub tableList{
   my $self = shift;
-  my $table = shift;
 
-    $self->send_queryStatusIdList($table);
-  return $self->recv_queryStatusIdList();
+    $self->send_tableList();
+  return $self->recv_tableList();
 }
 
-sub send_queryStatusIdList{
+sub send_tableList{
   my $self = shift;
-  my $table = shift;
 
-  $self->{output}->writeMessageBegin('queryStatusIdList', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_queryStatusIdList_args();
-  $args->{table} = $table;
+  $self->{output}->writeMessageBegin('tableList', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_tableList_args();
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_queryStatusIdList{
+sub recv_tableList{
   my $self = shift;
 
   my $rseqid = 0;
@@ -5069,7 +3671,7 @@ sub recv_queryStatusIdList{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_queryStatusIdList_result();
+  my $result = new Blur::Blur_tableList_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
@@ -5079,32 +3681,29 @@ sub recv_queryStatusIdList{
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  die "queryStatusIdList failed: unknown result";
+  die "tableList failed: unknown result";
 }
-sub queryStatusById{
+sub tableListByCluster{
   my $self = shift;
-  my $table = shift;
-  my $uuid = shift;
+  my $cluster = shift;
 
-    $self->send_queryStatusById($table, $uuid);
-  return $self->recv_queryStatusById();
+    $self->send_tableListByCluster($cluster);
+  return $self->recv_tableListByCluster();
 }
 
-sub send_queryStatusById{
+sub send_tableListByCluster{
   my $self = shift;
-  my $table = shift;
-  my $uuid = shift;
+  my $cluster = shift;
 
-  $self->{output}->writeMessageBegin('queryStatusById', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_queryStatusById_args();
-  $args->{table} = $table;
-  $args->{uuid} = $uuid;
+  $self->{output}->writeMessageBegin('tableListByCluster', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_tableListByCluster_args();
+  $args->{cluster} = $cluster;
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_queryStatusById{
+sub recv_tableListByCluster{
   my $self = shift;
 
   my $rseqid = 0;
@@ -5118,7 +3717,7 @@ sub recv_queryStatusById{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_queryStatusById_result();
+  my $result = new Blur::Blur_tableListByCluster_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
@@ -5128,29 +3727,29 @@ sub recv_queryStatusById{
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  die "queryStatusById failed: unknown result";
+  die "tableListByCluster failed: unknown result";
 }
-sub schema{
+sub describe{
   my $self = shift;
   my $table = shift;
 
-    $self->send_schema($table);
-  return $self->recv_schema();
+    $self->send_describe($table);
+  return $self->recv_describe();
 }
 
-sub send_schema{
+sub send_describe{
   my $self = shift;
   my $table = shift;
 
-  $self->{output}->writeMessageBegin('schema', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_schema_args();
+  $self->{output}->writeMessageBegin('describe', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_describe_args();
   $args->{table} = $table;
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_schema{
+sub recv_describe{
   my $self = shift;
 
   my $rseqid = 0;
@@ -5164,7 +3763,7 @@ sub recv_schema{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_schema_result();
+  my $result = new Blur::Blur_describe_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
@@ -5174,29 +3773,32 @@ sub recv_schema{
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  die "schema failed: unknown result";
+  die "describe failed: unknown result";
 }
-sub getTableStats{
+sub cancelQuery{
   my $self = shift;
   my $table = shift;
+  my $uuid = shift;
 
-    $self->send_getTableStats($table);
-  return $self->recv_getTableStats();
+    $self->send_cancelQuery($table, $uuid);
+  $self->recv_cancelQuery();
 }
 
-sub send_getTableStats{
+sub send_cancelQuery{
   my $self = shift;
   my $table = shift;
+  my $uuid = shift;
 
-  $self->{output}->writeMessageBegin('getTableStats', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_getTableStats_args();
+  $self->{output}->writeMessageBegin('cancelQuery', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_cancelQuery_args();
   $args->{table} = $table;
+  $args->{uuid} = $uuid;
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_getTableStats{
+sub recv_cancelQuery{
   my $self = shift;
 
   my $rseqid = 0;
@@ -5210,39 +3812,36 @@ sub recv_getTableStats{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_getTableStats_result();
+  my $result = new Blur::Blur_cancelQuery_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
-  if (defined $result->{success} ) {
-    return $result->{success};
-  }
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  die "getTableStats failed: unknown result";
+  return;
 }
-sub tableStats{
+sub currentQueries{
   my $self = shift;
   my $table = shift;
 
-    $self->send_tableStats($table);
-  return $self->recv_tableStats();
+    $self->send_currentQueries($table);
+  return $self->recv_currentQueries();
 }
 
-sub send_tableStats{
+sub send_currentQueries{
   my $self = shift;
   my $table = shift;
 
-  $self->{output}->writeMessageBegin('tableStats', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_tableStats_args();
+  $self->{output}->writeMessageBegin('currentQueries', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_currentQueries_args();
   $args->{table} = $table;
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_tableStats{
+sub recv_currentQueries{
   my $self = shift;
 
   my $rseqid = 0;
@@ -5256,7 +3855,7 @@ sub recv_tableStats{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_tableStats_result();
+  my $result = new Blur::Blur_currentQueries_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
@@ -5266,41 +3865,29 @@ sub recv_tableStats{
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  die "tableStats failed: unknown result";
+  die "currentQueries failed: unknown result";
 }
-sub terms{
+sub queryStatusIdList{
   my $self = shift;
   my $table = shift;
-  my $columnFamily = shift;
-  my $columnName = shift;
-  my $startWith = shift;
-  my $size = shift;
 
-    $self->send_terms($table, $columnFamily, $columnName, $startWith, $size);
-  return $self->recv_terms();
+    $self->send_queryStatusIdList($table);
+  return $self->recv_queryStatusIdList();
 }
 
-sub send_terms{
+sub send_queryStatusIdList{
   my $self = shift;
   my $table = shift;
-  my $columnFamily = shift;
-  my $columnName = shift;
-  my $startWith = shift;
-  my $size = shift;
 
-  $self->{output}->writeMessageBegin('terms', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_terms_args();
+  $self->{output}->writeMessageBegin('queryStatusIdList', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_queryStatusIdList_args();
   $args->{table} = $table;
-  $args->{columnFamily} = $columnFamily;
-  $args->{columnName} = $columnName;
-  $args->{startWith} = $startWith;
-  $args->{size} = $size;
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_terms{
+sub recv_queryStatusIdList{
   my $self = shift;
 
   my $rseqid = 0;
@@ -5314,7 +3901,7 @@ sub recv_terms{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_terms_result();
+  my $result = new Blur::Blur_queryStatusIdList_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
@@ -5324,38 +3911,32 @@ sub recv_terms{
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  die "terms failed: unknown result";
+  die "queryStatusIdList failed: unknown result";
 }
-sub recordFrequency{
+sub queryStatusById{
   my $self = shift;
   my $table = shift;
-  my $columnFamily = shift;
-  my $columnName = shift;
-  my $value = shift;
+  my $uuid = shift;
 
-    $self->send_recordFrequency($table, $columnFamily, $columnName, $value);
-  return $self->recv_recordFrequency();
+    $self->send_queryStatusById($table, $uuid);
+  return $self->recv_queryStatusById();
 }
 
-sub send_recordFrequency{
+sub send_queryStatusById{
   my $self = shift;
   my $table = shift;
-  my $columnFamily = shift;
-  my $columnName = shift;
-  my $value = shift;
+  my $uuid = shift;
 
-  $self->{output}->writeMessageBegin('recordFrequency', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_recordFrequency_args();
+  $self->{output}->writeMessageBegin('queryStatusById', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_queryStatusById_args();
   $args->{table} = $table;
-  $args->{columnFamily} = $columnFamily;
-  $args->{columnName} = $columnName;
-  $args->{value} = $value;
+  $args->{uuid} = $uuid;
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_recordFrequency{
+sub recv_queryStatusById{
   my $self = shift;
 
   my $rseqid = 0;
@@ -5369,7 +3950,7 @@ sub recv_recordFrequency{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_recordFrequency_result();
+  my $result = new Blur::Blur_queryStatusById_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
@@ -5379,32 +3960,29 @@ sub recv_recordFrequency{
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  die "recordFrequency failed: unknown result";
+  die "queryStatusById failed: unknown result";
 }
-sub fetchRow{
+sub schema{
   my $self = shift;
   my $table = shift;
-  my $selector = shift;
 
-    $self->send_fetchRow($table, $selector);
-  return $self->recv_fetchRow();
+    $self->send_schema($table);
+  return $self->recv_schema();
 }
 
-sub send_fetchRow{
+sub send_schema{
   my $self = shift;
   my $table = shift;
-  my $selector = shift;
 
-  $self->{output}->writeMessageBegin('fetchRow', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_fetchRow_args();
+  $self->{output}->writeMessageBegin('schema', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_schema_args();
   $args->{table} = $table;
-  $args->{selector} = $selector;
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_fetchRow{
+sub recv_schema{
   my $self = shift;
 
   my $rseqid = 0;
@@ -5418,7 +3996,7 @@ sub recv_fetchRow{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_fetchRow_result();
+  my $result = new Blur::Blur_schema_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
@@ -5428,29 +4006,29 @@ sub recv_fetchRow{
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  die "fetchRow failed: unknown result";
+  die "schema failed: unknown result";
 }
-sub mutate{
+sub getTableStats{
   my $self = shift;
-  my $mutation = shift;
+  my $table = shift;
 
-    $self->send_mutate($mutation);
-  $self->recv_mutate();
+    $self->send_getTableStats($table);
+  return $self->recv_getTableStats();
 }
 
-sub send_mutate{
+sub send_getTableStats{
   my $self = shift;
-  my $mutation = shift;
+  my $table = shift;
 
-  $self->{output}->writeMessageBegin('mutate', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_mutate_args();
-  $args->{mutation} = $mutation;
+  $self->{output}->writeMessageBegin('getTableStats', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_getTableStats_args();
+  $args->{table} = $table;
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_mutate{
+sub recv_getTableStats{
   my $self = shift;
 
   my $rseqid = 0;
@@ -5464,36 +4042,39 @@ sub recv_mutate{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_mutate_result();
+  my $result = new Blur::Blur_getTableStats_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
+  if (defined $result->{success} ) {
+    return $result->{success};
+  }
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  return;
+  die "getTableStats failed: unknown result";
 }
-sub mutateBatch{
+sub tableStats{
   my $self = shift;
-  my $mutations = shift;
+  my $table = shift;
 
-    $self->send_mutateBatch($mutations);
-  $self->recv_mutateBatch();
+    $self->send_tableStats($table);
+  return $self->recv_tableStats();
 }
 
-sub send_mutateBatch{
+sub send_tableStats{
   my $self = shift;
-  my $mutations = shift;
+  my $table = shift;
 
-  $self->{output}->writeMessageBegin('mutateBatch', TMessageType::CALL, $self->{seqid});
-  my $args = new Blur::Blur_mutateBatch_args();
-  $args->{mutations} = $mutations;
+  $self->{output}->writeMessageBegin('tableStats', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_tableStats_args();
+  $args->{table} = $table;
   $args->write($self->{output});
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
 
-sub recv_mutateBatch{
+sub recv_tableStats{
   my $self = shift;
 
   my $rseqid = 0;
@@ -5507,14 +4088,17 @@ sub recv_mutateBatch{
     $self->{input}->readMessageEnd();
     die $x;
   }
-  my $result = new Blur::Blur_mutateBatch_result();
+  my $result = new Blur::Blur_tableStats_result();
   $result->read($self->{input});
   $self->{input}->readMessageEnd();
 
+  if (defined $result->{success} ) {
+    return $result->{success};
+  }
   if (defined $result->{ex}) {
     die $result->{ex};
   }
-  return;
+  die "tableStats failed: unknown re

<TRUNCATED>

Mime
View raw message