incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [03/10] More documentation.
Date Sun, 18 Aug 2013 00:15:09 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/d05d4ba2/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
index 68f08fc..0ba66b6 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
@@ -12,18 +12,25 @@ use Blur::Types;
 
 # HELPER FUNCTIONS AND STRUCTURES
 
-package Blur::Blur_shardClusterList_args;
+package Blur::Blur_createTable_args;
 use base qw(Class::Accessor);
+Blur::Blur_createTable_args->mk_accessors( qw( tableDescriptor ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
+  $self->{tableDescriptor} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{tableDescriptor}) {
+      $self->{tableDescriptor} = $vals->{tableDescriptor};
+    }
+  }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_shardClusterList_args';
+  return 'Blur_createTable_args';
 }
 
 sub read {
@@ -41,6 +48,13 @@ sub read {
     }
     SWITCH: for($fid)
     {
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{tableDescriptor} = new Blur::TableDescriptor();
+        $xfer += $self->{tableDescriptor}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -52,26 +66,27 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_shardClusterList_args');
+  $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();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_shardClusterList_result;
+package Blur::Blur_createTable_result;
 use base qw(Class::Accessor);
-Blur::Blur_shardClusterList_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};
     }
@@ -80,7 +95,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_shardClusterList_result';
+  return 'Blur_createTable_result';
 }
 
 sub read {
@@ -98,24 +113,6 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::LIST) {
-        {
-          my $_size176 = 0;
-          $self->{success} = [];
-          my $_etype179 = 0;
-          $xfer += $input->readListBegin(\$_etype179, \$_size176);
-          for (my $_i180 = 0; $_i180 < $_size176; ++$_i180)
-          {
-            my $elem181 = undef;
-            $xfer += $input->readString(\$elem181);
-            push(@{$self->{success}},$elem181);
-          }
-          $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);
@@ -134,21 +131,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_shardClusterList_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
-    {
-      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
-      {
-        foreach my $iter182 (@{$self->{success}}) 
-        {
-          $xfer += $output->writeString($iter182);
-        }
-      }
-      $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);
@@ -159,25 +142,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_shardServerList_args;
+package Blur::Blur_enableTable_args;
 use base qw(Class::Accessor);
-Blur::Blur_shardServerList_args->mk_accessors( qw( cluster ) );
+Blur::Blur_enableTable_args->mk_accessors( qw( table ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{cluster} = undef;
+  $self->{table} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{cluster}) {
-      $self->{cluster} = $vals->{cluster};
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_shardServerList_args';
+  return 'Blur_enableTable_args';
 }
 
 sub read {
@@ -196,7 +179,7 @@ sub read {
     SWITCH: for($fid)
     {
       /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{cluster});
+        $xfer += $input->readString(\$self->{table});
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -212,10 +195,10 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_shardServerList_args');
-  if (defined $self->{cluster}) {
-    $xfer += $output->writeFieldBegin('cluster', TType::STRING, 1);
-    $xfer += $output->writeString($self->{cluster});
+  $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->writeFieldStop();
@@ -223,20 +206,16 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_shardServerList_result;
+package Blur::Blur_enableTable_result;
 use base qw(Class::Accessor);
-Blur::Blur_shardServerList_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};
     }
@@ -245,7 +224,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_shardServerList_result';
+  return 'Blur_enableTable_result';
 }
 
 sub read {
@@ -263,24 +242,6 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::LIST) {
-        {
-          my $_size183 = 0;
-          $self->{success} = [];
-          my $_etype186 = 0;
-          $xfer += $input->readListBegin(\$_etype186, \$_size183);
-          for (my $_i187 = 0; $_i187 < $_size183; ++$_i187)
-          {
-            my $elem188 = undef;
-            $xfer += $input->readString(\$elem188);
-            push(@{$self->{success}},$elem188);
-          }
-          $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);
@@ -299,21 +260,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_shardServerList_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
-    {
-      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
-      {
-        foreach my $iter189 (@{$self->{success}}) 
-        {
-          $xfer += $output->writeString($iter189);
-        }
-      }
-      $xfer += $output->writeListEnd();
-    }
-    $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);
@@ -324,18 +271,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_controllerServerList_args;
+package Blur::Blur_disableTable_args;
 use base qw(Class::Accessor);
+Blur::Blur_disableTable_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_controllerServerList_args';
+  return 'Blur_disableTable_args';
 }
 
 sub read {
@@ -353,6 +307,12 @@ 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();
@@ -364,26 +324,27 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_controllerServerList_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();
+  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_controllerServerList_result;
+package Blur::Blur_disableTable_result;
 use base qw(Class::Accessor);
-Blur::Blur_controllerServerList_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};
     }
@@ -392,7 +353,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_controllerServerList_result';
+  return 'Blur_disableTable_result';
 }
 
 sub read {
@@ -410,24 +371,6 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::LIST) {
-        {
-          my $_size190 = 0;
-          $self->{success} = [];
-          my $_etype193 = 0;
-          $xfer += $input->readListBegin(\$_etype193, \$_size190);
-          for (my $_i194 = 0; $_i194 < $_size190; ++$_i194)
-          {
-            my $elem195 = undef;
-            $xfer += $input->readString(\$elem195);
-            push(@{$self->{success}},$elem195);
-          }
-          $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);
@@ -446,21 +389,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_controllerServerList_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
-    {
-      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
-      {
-        foreach my $iter196 (@{$self->{success}}) 
-        {
-          $xfer += $output->writeString($iter196);
-        }
-      }
-      $xfer += $output->writeListEnd();
-    }
-    $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);
@@ -471,25 +400,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_shardServerLayout_args;
+package Blur::Blur_removeTable_args;
 use base qw(Class::Accessor);
-Blur::Blur_shardServerLayout_args->mk_accessors( qw( table ) );
+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_shardServerLayout_args';
+  return 'Blur_removeTable_args';
 }
 
 sub read {
@@ -513,6 +446,12 @@ sub read {
         $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();
@@ -524,31 +463,32 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_shardServerLayout_args');
+  $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_shardServerLayout_result;
+package Blur::Blur_removeTable_result;
 use base qw(Class::Accessor);
-Blur::Blur_shardServerLayout_result->mk_accessors( qw( success ) );
+Blur::Blur_removeTable_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};
     }
@@ -557,7 +497,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_shardServerLayout_result';
+  return 'Blur_removeTable_result';
 }
 
 sub read {
@@ -575,27 +515,6 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::MAP) {
-        {
-          my $_size197 = 0;
-          $self->{success} = {};
-          my $_ktype198 = 0;
-          my $_vtype199 = 0;
-          $xfer += $input->readMapBegin(\$_ktype198, \$_vtype199, \$_size197);
-          for (my $_i201 = 0; $_i201 < $_size197; ++$_i201)
-          {
-            my $key202 = '';
-            my $val203 = '';
-            $xfer += $input->readString(\$key202);
-            $xfer += $input->readString(\$val203);
-            $self->{success}->{$key202} = $val203;
-          }
-          $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);
@@ -614,22 +533,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_shardServerLayout_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 ($kiter204,$viter205) = each %{$self->{success}}) 
-        {
-          $xfer += $output->writeString($kiter204);
-          $xfer += $output->writeString($viter205);
-        }
-      }
-      $xfer += $output->writeMapEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
+  $xfer += $output->writeStructBegin('Blur_removeTable_result');
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -640,25 +544,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_shardServerLayoutState_args;
+package Blur::Blur_addColumnDefinition_args;
 use base qw(Class::Accessor);
-Blur::Blur_shardServerLayoutState_args->mk_accessors( qw( table ) );
+Blur::Blur_addColumnDefinition_args->mk_accessors( qw( table columnDefinition ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{table} = undef;
+  $self->{columnDefinition} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{table}) {
       $self->{table} = $vals->{table};
     }
+    if (defined $vals->{columnDefinition}) {
+      $self->{columnDefinition} = $vals->{columnDefinition};
+    }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_shardServerLayoutState_args';
+  return 'Blur_addColumnDefinition_args';
 }
 
 sub read {
@@ -682,6 +590,13 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{columnDefinition} = new Blur::ColumnDefinition();
+        $xfer += $self->{columnDefinition}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -693,20 +608,25 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_shardServerLayoutState_args');
+  $xfer += $output->writeStructBegin('Blur_addColumnDefinition_args');
   if (defined $self->{table}) {
     $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
     $xfer += $output->writeString($self->{table});
     $xfer += $output->writeFieldEnd();
   }
+  if (defined $self->{columnDefinition}) {
+    $xfer += $output->writeFieldBegin('columnDefinition', TType::STRUCT, 2);
+    $xfer += $self->{columnDefinition}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_shardServerLayoutState_result;
+package Blur::Blur_addColumnDefinition_result;
 use base qw(Class::Accessor);
-Blur::Blur_shardServerLayoutState_result->mk_accessors( qw( success ) );
+Blur::Blur_addColumnDefinition_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
@@ -726,7 +646,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_shardServerLayoutState_result';
+  return 'Blur_addColumnDefinition_result';
 }
 
 sub read {
@@ -744,38 +664,8 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::MAP) {
-        {
-          my $_size206 = 0;
-          $self->{success} = {};
-          my $_ktype207 = 0;
-          my $_vtype208 = 0;
-          $xfer += $input->readMapBegin(\$_ktype207, \$_vtype208, \$_size206);
-          for (my $_i210 = 0; $_i210 < $_size206; ++$_i210)
-          {
-            my $key211 = '';
-            my $val212 = [];
-            $xfer += $input->readString(\$key211);
-            {
-              my $_size213 = 0;
-              $val212 = {};
-              my $_ktype214 = 0;
-              my $_vtype215 = 0;
-              $xfer += $input->readMapBegin(\$_ktype214, \$_vtype215, \$_size213);
-              for (my $_i217 = 0; $_i217 < $_size213; ++$_i217)
-              {
-                my $key218 = '';
-                my $val219 = 0;
-                $xfer += $input->readString(\$key218);
-                $xfer += $input->readI32(\$val219);
-                $val212->{$key218} = $val219;
-              }
-              $xfer += $input->readMapEnd();
-            }
-            $self->{success}->{$key211} = $val212;
-          }
-          $xfer += $input->readMapEnd();
-        }
+      /^0$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{success});
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -798,30 +688,10 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_shardServerLayoutState_result');
+  $xfer += $output->writeStructBegin('Blur_addColumnDefinition_result');
   if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::MAP, 0);
-    {
-      $xfer += $output->writeMapBegin(TType::STRING, TType::MAP, scalar(keys %{$self->{success}}));
-      {
-        while( my ($kiter220,$viter221) = each %{$self->{success}}) 
-        {
-          $xfer += $output->writeString($kiter220);
-          {
-            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter221}}));
-            {
-              while( my ($kiter222,$viter223) = each %{${viter221}}) 
-              {
-                $xfer += $output->writeString($kiter222);
-                $xfer += $output->writeI32($viter223);
-              }
-            }
-            $xfer += $output->writeMapEnd();
-          }
-        }
-      }
-      $xfer += $output->writeMapEnd();
-    }
+    $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
+    $xfer += $output->writeBool($self->{success});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{ex}) {
@@ -922,15 +792,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size224 = 0;
+          my $_size176 = 0;
           $self->{success} = [];
-          my $_etype227 = 0;
-          $xfer += $input->readListBegin(\$_etype227, \$_size224);
-          for (my $_i228 = 0; $_i228 < $_size224; ++$_i228)
+          my $_etype179 = 0;
+          $xfer += $input->readListBegin(\$_etype179, \$_size176);
+          for (my $_i180 = 0; $_i180 < $_size176; ++$_i180)
           {
-            my $elem229 = undef;
-            $xfer += $input->readString(\$elem229);
-            push(@{$self->{success}},$elem229);
+            my $elem181 = undef;
+            $xfer += $input->readString(\$elem181);
+            push(@{$self->{success}},$elem181);
           }
           $xfer += $input->readListEnd();
         }
@@ -962,9 +832,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter230 (@{$self->{success}}) 
+        foreach my $iter182 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter230);
+          $xfer += $output->writeString($iter182);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1087,15 +957,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size231 = 0;
+          my $_size183 = 0;
           $self->{success} = [];
-          my $_etype234 = 0;
-          $xfer += $input->readListBegin(\$_etype234, \$_size231);
-          for (my $_i235 = 0; $_i235 < $_size231; ++$_i235)
+          my $_etype186 = 0;
+          $xfer += $input->readListBegin(\$_etype186, \$_size183);
+          for (my $_i187 = 0; $_i187 < $_size183; ++$_i187)
           {
-            my $elem236 = undef;
-            $xfer += $input->readString(\$elem236);
-            push(@{$self->{success}},$elem236);
+            my $elem188 = undef;
+            $xfer += $input->readString(\$elem188);
+            push(@{$self->{success}},$elem188);
           }
           $xfer += $input->readListEnd();
         }
@@ -1127,9 +997,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter237 (@{$self->{success}}) 
+        foreach my $iter189 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter237);
+          $xfer += $output->writeString($iter189);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1291,29 +1161,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_query_args;
+package Blur::Blur_schema_args;
 use base qw(Class::Accessor);
-Blur::Blur_query_args->mk_accessors( qw( table blurQuery ) );
+Blur::Blur_schema_args->mk_accessors( qw( table ) );
 
 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';
+  return 'Blur_schema_args';
 }
 
 sub read {
@@ -1337,13 +1203,6 @@ sub read {
         $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();
@@ -1355,25 +1214,20 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_query_args');
+  $xfer += $output->writeStructBegin('Blur_schema_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;
+package Blur::Blur_schema_result;
 use base qw(Class::Accessor);
-Blur::Blur_query_result->mk_accessors( qw( success ) );
+Blur::Blur_schema_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
@@ -1393,7 +1247,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_query_result';
+  return 'Blur_schema_result';
 }
 
 sub read {
@@ -1412,7 +1266,7 @@ sub read {
     SWITCH: for($fid)
     {
       /^0$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{success} = new Blur::BlurResults();
+        $self->{success} = new Blur::Schema();
         $xfer += $self->{success}->read($input);
       } else {
         $xfer += $input->skip($ftype);
@@ -1436,7 +1290,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_query_result');
+  $xfer += $output->writeStructBegin('Blur_schema_result');
   if (defined $self->{success}) {
     $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
     $xfer += $self->{success}->write($output);
@@ -1612,29 +1466,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_cancelQuery_args;
+package Blur::Blur_tableStats_args;
 use base qw(Class::Accessor);
-Blur::Blur_cancelQuery_args->mk_accessors( qw( table uuid ) );
+Blur::Blur_tableStats_args->mk_accessors( qw( table ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{table} = undef;
-  $self->{uuid} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{table}) {
       $self->{table} = $vals->{table};
     }
-    if (defined $vals->{uuid}) {
-      $self->{uuid} = $vals->{uuid};
-    }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_cancelQuery_args';
+  return 'Blur_tableStats_args';
 }
 
 sub read {
@@ -1658,12 +1508,6 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^2$/ && do{      if ($ftype == TType::I64) {
-        $xfer += $input->readI64(\$self->{uuid});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -1675,32 +1519,31 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_cancelQuery_args');
+  $xfer += $output->writeStructBegin('Blur_tableStats_args');
   if (defined $self->{table}) {
     $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
     $xfer += $output->writeString($self->{table});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{uuid}) {
-    $xfer += $output->writeFieldBegin('uuid', TType::I64, 2);
-    $xfer += $output->writeI64($self->{uuid});
-    $xfer += $output->writeFieldEnd();
-  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_cancelQuery_result;
+package Blur::Blur_tableStats_result;
 use base qw(Class::Accessor);
-Blur::Blur_cancelQuery_result->mk_accessors( qw( ) );
+Blur::Blur_tableStats_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};
     }
@@ -1709,7 +1552,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_cancelQuery_result';
+  return 'Blur_tableStats_result';
 }
 
 sub read {
@@ -1727,6 +1570,13 @@ sub read {
     }
     SWITCH: for($fid)
     {
+      /^0$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{success} = new Blur::TableStats();
+        $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);
@@ -1745,7 +1595,12 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_cancelQuery_result');
+  $xfer += $output->writeStructBegin('Blur_tableStats_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);
@@ -1756,25 +1611,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_queryStatusIdList_args;
+package Blur::Blur_optimize_args;
 use base qw(Class::Accessor);
-Blur::Blur_queryStatusIdList_args->mk_accessors( qw( table ) );
+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_queryStatusIdList_args';
+  return 'Blur_optimize_args';
 }
 
 sub read {
@@ -1798,6 +1657,12 @@ sub read {
         $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();
@@ -1809,31 +1674,32 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_queryStatusIdList_args');
+  $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_queryStatusIdList_result;
+package Blur::Blur_optimize_result;
 use base qw(Class::Accessor);
-Blur::Blur_queryStatusIdList_result->mk_accessors( qw( success ) );
+Blur::Blur_optimize_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};
     }
@@ -1842,7 +1708,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_queryStatusIdList_result';
+  return 'Blur_optimize_result';
 }
 
 sub read {
@@ -1860,24 +1726,6 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::LIST) {
-        {
-          my $_size238 = 0;
-          $self->{success} = [];
-          my $_etype241 = 0;
-          $xfer += $input->readListBegin(\$_etype241, \$_size238);
-          for (my $_i242 = 0; $_i242 < $_size238; ++$_i242)
-          {
-            my $elem243 = undef;
-            $xfer += $input->readI64(\$elem243);
-            push(@{$self->{success}},$elem243);
-          }
-          $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);
@@ -1896,21 +1744,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_queryStatusIdList_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
-    {
-      $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{success}}));
-      {
-        foreach my $iter244 (@{$self->{success}}) 
-        {
-          $xfer += $output->writeI64($iter244);
-        }
-      }
-      $xfer += $output->writeListEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
+  $xfer += $output->writeStructBegin('Blur_optimize_result');
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -1921,29 +1755,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_queryStatusById_args;
+package Blur::Blur_createSnapshot_args;
 use base qw(Class::Accessor);
-Blur::Blur_queryStatusById_args->mk_accessors( qw( table uuid ) );
+Blur::Blur_createSnapshot_args->mk_accessors( qw( table name ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{table} = undef;
-  $self->{uuid} = undef;
+  $self->{name} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{table}) {
       $self->{table} = $vals->{table};
     }
-    if (defined $vals->{uuid}) {
-      $self->{uuid} = $vals->{uuid};
+    if (defined $vals->{name}) {
+      $self->{name} = $vals->{name};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_queryStatusById_args';
+  return 'Blur_createSnapshot_args';
 }
 
 sub read {
@@ -1967,8 +1801,8 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^2$/ && do{      if ($ftype == TType::I64) {
-        $xfer += $input->readI64(\$self->{uuid});
+      /^2$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{name});
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -1984,15 +1818,15 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_queryStatusById_args');
+  $xfer += $output->writeStructBegin('Blur_createSnapshot_args');
   if (defined $self->{table}) {
     $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
     $xfer += $output->writeString($self->{table});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{uuid}) {
-    $xfer += $output->writeFieldBegin('uuid', TType::I64, 2);
-    $xfer += $output->writeI64($self->{uuid});
+  if (defined $self->{name}) {
+    $xfer += $output->writeFieldBegin('name', TType::STRING, 2);
+    $xfer += $output->writeString($self->{name});
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -2000,20 +1834,16 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_queryStatusById_result;
+package Blur::Blur_createSnapshot_result;
 use base qw(Class::Accessor);
-Blur::Blur_queryStatusById_result->mk_accessors( qw( success ) );
+Blur::Blur_createSnapshot_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};
     }
@@ -2022,7 +1852,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_queryStatusById_result';
+  return 'Blur_createSnapshot_result';
 }
 
 sub read {
@@ -2040,13 +1870,6 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{success} = new Blur::BlurQueryStatus();
-        $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);
@@ -2065,12 +1888,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_queryStatusById_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
-    $xfer += $self->{success}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
+  $xfer += $output->writeStructBegin('Blur_createSnapshot_result');
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -2081,25 +1899,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_schema_args;
+package Blur::Blur_removeSnapshot_args;
 use base qw(Class::Accessor);
-Blur::Blur_schema_args->mk_accessors( qw( table ) );
+Blur::Blur_removeSnapshot_args->mk_accessors( qw( table name ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{table} = undef;
+  $self->{name} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{table}) {
       $self->{table} = $vals->{table};
     }
+    if (defined $vals->{name}) {
+      $self->{name} = $vals->{name};
+    }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_schema_args';
+  return 'Blur_removeSnapshot_args';
 }
 
 sub read {
@@ -2123,6 +1945,12 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
+      /^2$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{name});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -2134,31 +1962,32 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_schema_args');
+  $xfer += $output->writeStructBegin('Blur_removeSnapshot_args');
   if (defined $self->{table}) {
     $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
     $xfer += $output->writeString($self->{table});
     $xfer += $output->writeFieldEnd();
   }
+  if (defined $self->{name}) {
+    $xfer += $output->writeFieldBegin('name', TType::STRING, 2);
+    $xfer += $output->writeString($self->{name});
+    $xfer += $output->writeFieldEnd();
+  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_schema_result;
+package Blur::Blur_removeSnapshot_result;
 use base qw(Class::Accessor);
-Blur::Blur_schema_result->mk_accessors( qw( success ) );
+Blur::Blur_removeSnapshot_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};
     }
@@ -2167,7 +1996,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_schema_result';
+  return 'Blur_removeSnapshot_result';
 }
 
 sub read {
@@ -2185,13 +2014,6 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{success} = new Blur::Schema();
-        $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);
@@ -2210,12 +2032,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_schema_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
-    $xfer += $self->{success}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
+  $xfer += $output->writeStructBegin('Blur_removeSnapshot_result');
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -2226,9 +2043,9 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_tableStats_args;
+package Blur::Blur_listSnapshots_args;
 use base qw(Class::Accessor);
-Blur::Blur_tableStats_args->mk_accessors( qw( table ) );
+Blur::Blur_listSnapshots_args->mk_accessors( qw( table ) );
 
 sub new {
   my $classname = shift;
@@ -2244,7 +2061,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_tableStats_args';
+  return 'Blur_listSnapshots_args';
 }
 
 sub read {
@@ -2279,7 +2096,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_tableStats_args');
+  $xfer += $output->writeStructBegin('Blur_listSnapshots_args');
   if (defined $self->{table}) {
     $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
     $xfer += $output->writeString($self->{table});
@@ -2290,9 +2107,9 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_tableStats_result;
+package Blur::Blur_listSnapshots_result;
 use base qw(Class::Accessor);
-Blur::Blur_tableStats_result->mk_accessors( qw( success ) );
+Blur::Blur_listSnapshots_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
@@ -2312,7 +2129,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_tableStats_result';
+  return 'Blur_listSnapshots_result';
 }
 
 sub read {
@@ -2330,9 +2147,35 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{success} = new Blur::TableStats();
-        $xfer += $self->{success}->read($input);
+      /^0$/ && do{      if ($ftype == TType::MAP) {
+        {
+          my $_size190 = 0;
+          $self->{success} = {};
+          my $_ktype191 = 0;
+          my $_vtype192 = 0;
+          $xfer += $input->readMapBegin(\$_ktype191, \$_vtype192, \$_size190);
+          for (my $_i194 = 0; $_i194 < $_size190; ++$_i194)
+          {
+            my $key195 = '';
+            my $val196 = [];
+            $xfer += $input->readString(\$key195);
+            {
+              my $_size197 = 0;
+              $val196 = [];
+              my $_etype200 = 0;
+              $xfer += $input->readListBegin(\$_etype200, \$_size197);
+              for (my $_i201 = 0; $_i201 < $_size197; ++$_i201)
+              {
+                my $elem202 = undef;
+                $xfer += $input->readString(\$elem202);
+                push(@{$val196},$elem202);
+              }
+              $xfer += $input->readListEnd();
+            }
+            $self->{success}->{$key195} = $val196;
+          }
+          $xfer += $input->readMapEnd();
+        }
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -2355,10 +2198,29 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_tableStats_result');
+  $xfer += $output->writeStructBegin('Blur_listSnapshots_result');
   if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
-    $xfer += $self->{success}->write($output);
+    $xfer += $output->writeFieldBegin('success', TType::MAP, 0);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::LIST, scalar(keys %{$self->{success}}));
+      {
+        while( my ($kiter203,$viter204) = each %{$self->{success}}) 
+        {
+          $xfer += $output->writeString($kiter203);
+          {
+            $xfer += $output->writeListBegin(TType::STRING, scalar(@{${viter204}}));
+            {
+              foreach my $iter205 (@{${viter204}}) 
+              {
+                $xfer += $output->writeString($iter205);
+              }
+            }
+            $xfer += $output->writeListEnd();
+          }
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{ex}) {
@@ -2371,41 +2233,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_terms_args;
+package Blur::Blur_query_args;
 use base qw(Class::Accessor);
-Blur::Blur_terms_args->mk_accessors( qw( table columnFamily columnName startWith size ) );
+Blur::Blur_query_args->mk_accessors( qw( table blurQuery ) );
 
 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->{blurQuery} = 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->{blurQuery}) {
+      $self->{blurQuery} = $vals->{blurQuery};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_terms_args';
+  return 'Blur_query_args';
 }
 
 sub read {
@@ -2429,26 +2279,9 @@ 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->{startWith});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^5$/ && do{      if ($ftype == TType::I16) {
-        $xfer += $input->readI16(\$self->{size});
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{blurQuery} = new Blur::BlurQuery();
+        $xfer += $self->{blurQuery}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -2464,30 +2297,15 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_terms_args');
+  $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->{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});
+  if (defined $self->{blurQuery}) {
+    $xfer += $output->writeFieldBegin('blurQuery', TType::STRUCT, 2);
+    $xfer += $self->{blurQuery}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -2495,9 +2313,9 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_terms_result;
+package Blur::Blur_query_result;
 use base qw(Class::Accessor);
-Blur::Blur_terms_result->mk_accessors( qw( success ) );
+Blur::Blur_query_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
@@ -2517,7 +2335,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_terms_result';
+  return 'Blur_query_result';
 }
 
 sub read {
@@ -2535,20 +2353,9 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::LIST) {
-        {
-          my $_size245 = 0;
-          $self->{success} = [];
-          my $_etype248 = 0;
-          $xfer += $input->readListBegin(\$_etype248, \$_size245);
-          for (my $_i249 = 0; $_i249 < $_size245; ++$_i249)
-          {
-            my $elem250 = undef;
-            $xfer += $input->readString(\$elem250);
-            push(@{$self->{success}},$elem250);
-          }
-          $xfer += $input->readListEnd();
-        }
+      /^0$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{success} = new Blur::BlurResults();
+        $xfer += $self->{success}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -2571,19 +2378,10 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_terms_result');
+  $xfer += $output->writeStructBegin('Blur_query_result');
   if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
-    {
-      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
-      {
-        foreach my $iter251 (@{$self->{success}}) 
-        {
-          $xfer += $output->writeString($iter251);
-        }
-      }
-      $xfer += $output->writeListEnd();
-    }
+    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
+    $xfer += $self->{success}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{ex}) {
@@ -2596,37 +2394,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_recordFrequency_args;
+package Blur::Blur_fetchRow_args;
 use base qw(Class::Accessor);
-Blur::Blur_recordFrequency_args->mk_accessors( qw( table columnFamily columnName value ) );
+Blur::Blur_fetchRow_args->mk_accessors( qw( table selector ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{table} = undef;
-  $self->{columnFamily} = undef;
-  $self->{columnName} = undef;
-  $self->{value} = undef;
+  $self->{selector} = 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};
+    if (defined $vals->{selector}) {
+      $self->{selector} = $vals->{selector};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_recordFrequency_args';
+  return 'Blur_fetchRow_args';
 }
 
 sub read {
@@ -2650,20 +2440,9 @@ 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});
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{selector} = new Blur::Selector();
+        $xfer += $self->{selector}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -2679,185 +2458,15 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_recordFrequency_args');
+  $xfer += $output->writeStructBegin('Blur_fetchRow_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;
-use base qw(Class::Accessor);
-Blur::Blur_recordFrequency_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_recordFrequency_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::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);
-      } 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_recordFrequency_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::I64, 0);
-    $xfer += $output->writeI64($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_fetchRow_args;
-use base qw(Class::Accessor);
-Blur::Blur_fetchRow_args->mk_accessors( qw( table selector ) );
-
-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';
-}
-
-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->{selector} = new Blur::Selector();
-        $xfer += $self->{selector}->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_fetchRow_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);
+  if (defined $self->{selector}) {
+    $xfer += $output->writeFieldBegin('selector', TType::STRUCT, 2);
+    $xfer += $self->{selector}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -3114,16 +2723,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size252 = 0;
+          my $_size206 = 0;
           $self->{mutations} = [];
-          my $_etype255 = 0;
-          $xfer += $input->readListBegin(\$_etype255, \$_size252);
-          for (my $_i256 = 0; $_i256 < $_size252; ++$_i256)
+          my $_etype209 = 0;
+          $xfer += $input->readListBegin(\$_etype209, \$_size206);
+          for (my $_i210 = 0; $_i210 < $_size206; ++$_i210)
           {
-            my $elem257 = undef;
-            $elem257 = new Blur::RowMutation();
-            $xfer += $elem257->read($input);
-            push(@{$self->{mutations}},$elem257);
+            my $elem211 = undef;
+            $elem211 = new Blur::RowMutation();
+            $xfer += $elem211->read($input);
+            push(@{$self->{mutations}},$elem211);
           }
           $xfer += $input->readListEnd();
         }
@@ -3148,9 +2757,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{mutations}}));
       {
-        foreach my $iter258 (@{$self->{mutations}}) 
+        foreach my $iter212 (@{$self->{mutations}}) 
         {
-          $xfer += ${iter258}->write($output);
+          $xfer += ${iter212}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3227,25 +2836,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_createTable_args;
+package Blur::Blur_cancelQuery_args;
 use base qw(Class::Accessor);
-Blur::Blur_createTable_args->mk_accessors( qw( tableDescriptor ) );
+Blur::Blur_cancelQuery_args->mk_accessors( qw( table uuid ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{tableDescriptor} = undef;
+  $self->{table} = undef;
+  $self->{uuid} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{tableDescriptor}) {
-      $self->{tableDescriptor} = $vals->{tableDescriptor};
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
+    }
+    if (defined $vals->{uuid}) {
+      $self->{uuid} = $vals->{uuid};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_createTable_args';
+  return 'Blur_cancelQuery_args';
 }
 
 sub read {
@@ -3263,9 +2876,14 @@ 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->{table});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{uuid});
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -3281,10 +2899,15 @@ 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_cancelQuery_args');
+  if (defined $self->{table}) {
+    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+    $xfer += $output->writeString($self->{table});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{uuid}) {
+    $xfer += $output->writeFieldBegin('uuid', TType::I64, 2);
+    $xfer += $output->writeI64($self->{uuid});
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -3292,9 +2915,9 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_createTable_result;
+package Blur::Blur_cancelQuery_result;
 use base qw(Class::Accessor);
-Blur::Blur_createTable_result->mk_accessors( qw( ) );
+Blur::Blur_cancelQuery_result->mk_accessors( qw( ) );
 
 sub new {
   my $classname = shift;
@@ -3310,7 +2933,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_createTable_result';
+  return 'Blur_cancelQuery_result';
 }
 
 sub read {
@@ -3346,7 +2969,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_createTable_result');
+  $xfer += $output->writeStructBegin('Blur_cancelQuery_result');
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -3357,9 +2980,9 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_enableTable_args;
+package Blur::Blur_queryStatusIdList_args;
 use base qw(Class::Accessor);
-Blur::Blur_enableTable_args->mk_accessors( qw( table ) );
+Blur::Blur_queryStatusIdList_args->mk_accessors( qw( table ) );
 
 sub new {
   my $classname = shift;
@@ -3375,7 +2998,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_enableTable_args';
+  return 'Blur_queryStatusIdList_args';
 }
 
 sub read {
@@ -3410,7 +3033,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_enableTable_args');
+  $xfer += $output->writeStructBegin('Blur_queryStatusIdList_args');
   if (defined $self->{table}) {
     $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
     $xfer += $output->writeString($self->{table});
@@ -3421,16 +3044,20 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_enableTable_result;
+package Blur::Blur_queryStatusIdList_result;
 use base qw(Class::Accessor);
-Blur::Blur_enableTable_result->mk_accessors( qw( ) );
+Blur::Blur_queryStatusIdList_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};
     }
@@ -3439,7 +3066,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_enableTable_result';
+  return 'Blur_queryStatusIdList_result';
 }
 
 sub read {
@@ -3457,6 +3084,24 @@ sub read {
     }
     SWITCH: for($fid)
     {
+      /^0$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size213 = 0;
+          $self->{success} = [];
+          my $_etype216 = 0;
+          $xfer += $input->readListBegin(\$_etype216, \$_size213);
+          for (my $_i217 = 0; $_i217 < $_size213; ++$_i217)
+          {
+            my $elem218 = undef;
+            $xfer += $input->readI64(\$elem218);
+            push(@{$self->{success}},$elem218);
+          }
+          $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);
@@ -3475,36 +3120,54 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_enableTable_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();
+  $xfer += $output->writeStructBegin('Blur_queryStatusIdList_result');
+  if (defined $self->{success}) {
+    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
+    {
+      $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{success}}));
+      {
+        foreach my $iter219 (@{$self->{success}}) 
+        {
+          $xfer += $output->writeI64($iter219);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $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_disableTable_args;
+package Blur::Blur_queryStatusById_args;
 use base qw(Class::Accessor);
-Blur::Blur_disableTable_args->mk_accessors( qw( table ) );
+Blur::Blur_queryStatusById_args->mk_accessors( qw( table uuid ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{table} = undef;
+  $self->{uuid} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{table}) {
       $self->{table} = $vals->{table};
     }
+    if (defined $vals->{uuid}) {
+      $self->{uuid} = $vals->{uuid};
+    }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_disableTable_args';
+  return 'Blur_queryStatusById_args';
 }
 
 sub read {
@@ -3528,6 +3191,12 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
+      /^2$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{uuid});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -3539,27 +3208,36 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_disableTable_args');
+  $xfer += $output->writeStructBegin('Blur_queryStatusById_args');
   if (defined $self->{table}) {
     $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
     $xfer += $output->writeString($self->{table});
     $xfer += $output->writeFieldEnd();
   }
+  if (defined $self->{uuid}) {
+    $xfer += $output->writeFieldBegin('uuid', TType::I64, 2);
+    $xfer += $output->writeI64($self->{uuid});
+    $xfer += $output->writeFieldEnd();
+  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_disableTable_result;
+package Blur::Blur_queryStatusById_result;
 use base qw(Class::Accessor);
-Blur::Blur_disableTable_result->mk_accessors( qw( ) );
+Blur::Blur_queryStatusById_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};
     }
@@ -3568,7 +3246,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_disableTable_result';
+  return 'Blur_queryStatusById_result';
 }
 
 sub read {
@@ -3586,6 +3264,13 @@ sub read {
     }
     SWITCH: for($fid)
     {
+      /^0$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{success} = new Blur::BlurQueryStatus();
+        $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);
@@ -3604,7 +3289,12 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_disableTable_result');
+  $xfer += $output->writeStructBegin('Blur_queryStatusById_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);
@@ -3615,29 +3305,41 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_removeTable_args;
+package Blur::Blur_terms_args;
 use base qw(Class::Accessor);
-Blur::Blur_removeTable_args->mk_accessors( qw( table deleteIndexFiles ) );
+Blur::Blur_terms_args->mk_accessors( qw( table columnFamily columnName startWith size ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{table} = undef;
-  $self->{deleteIndexFiles} = undef;
+  $self->{columnFamily} = undef;
+  $self->{columnName} = undef;
+  $self->{startWith} = undef;
+  $self->{size} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{table}) {
       $self->{table} = $vals->{table};
     }
-    if (defined $vals->{deleteIndexFiles}) {
-      $self->{deleteIndexFiles} = $vals->{deleteIndexFiles};
+    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};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_removeTable_args';
+  return 'Blur_terms_args';
 }
 
 sub read {
@@ -3661,8 +3363,26 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^2$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{deleteIndexFiles});
+      /^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});
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -3678,15 +3398,30 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_removeTable_args');
+  $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->{deleteIndexFiles}) {
-    $xfer += $output->writeFieldBegin('deleteIndexFiles', TType::BOOL, 2);
-    $xfer += $output->writeBool($self->{deleteIndexFiles});
+  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->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -3694,16 +3429,20 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_removeTable_result;
+package Blur::Blur_terms_result;
 use base qw(Class::Accessor);
-Blur::Blur_removeTable_result->mk_accessors( qw( ) );
+Blur::Blur_terms_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};
     }
@@ -3712,7 +3451,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_removeTable_result';
+  return 'Blur_terms_result';
 }
 
 sub read {
@@ -3730,6 +3469,24 @@ sub read {
     }
     SWITCH: for($fid)
     {
+      /^0$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size220 = 0;
+          $self->{success} = [];
+          my $_etype223 = 0;
+          $xfer += $input->readListBegin(\$_etype223, \$_size220);
+          for (my $_i224 = 0; $_i224 < $_size220; ++$_i224)
+          {
+            my $elem225 = undef;
+            $xfer += $input->readString(\$elem225);
+            push(@{$self->{success}},$elem225);
+          }
+          $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);
@@ -3748,7 +3505,21 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_removeTable_result');
+  $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 $iter226 (@{$self->{success}}) 
+        {
+          $xfer += $output->writeString($iter226);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -3759,29 +3530,37 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_addColumnDefinition_args;
+package Blur::Blur_recordFrequency_args;
 use base qw(Class::Accessor);
-Blur::Blur_addColumnDefinition_args->mk_accessors( qw( table columnDefinition ) );
+Blur::Blur_recordFrequency_args->mk_accessors( qw( table columnFamily columnName value ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{table} = undef;
-  $self->{columnDefinition} = 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->{columnDefinition}) {
-      $self->{columnDefinition} = $vals->{columnDefinition};
+    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_addColumnDefinition_args';
+  return 'Blur_recordFrequency_args';
 }
 
 sub read {
@@ -3805,9 +3584,20 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^2$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{columnDefinition} = new Blur::ColumnDefinition();
-        $xfer += $self->{columnDefinition}->read($input);
+      /^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);
       }
@@ -3823,15 +3613,25 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_addColumnDefinition_args');
+  $xfer += $output->writeStructBegin('Blur_recordFrequency_args');
   if (defined $self->{table}) {
     $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
     $xfer += $output->writeString($self->{table});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{columnDefinition}) {
-    $xfer += $output->writeFieldBegin('columnDefinition', TType::STRUCT, 2);
-    $xfer += $self->{columnDefinition}->write($output);
+  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();
@@ -3839,9 +3639,9 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_addColumnDefinition_result;
+package Blur::Blur_recordFrequency_result;
 use base qw(Class::Accessor);
-Blur::Blur_addColumnDefinition_result->mk_accessors( qw( success ) );
+Blur::Blur_recordFrequency_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
@@ -3861,7 +3661,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_addColumnDefinition_result';
+  return 'Blur_recordFrequency_result';
 }
 
 sub read {
@@ -3879,8 +3679,8 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{success});
+      /^0$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{success});
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -3903,10 +3703,10 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_addColumnDefinition_result');
+  $xfer += $output->writeStructBegin('Blur_recordFrequency_result');
   if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
-    $xfer += $output->writeBool($self->{success});
+    $xfer += $output->writeFieldBegin('success', TType::I64, 0);
+    $xfer += $output->writeI64($self->{success});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{ex}) {
@@ -3919,29 +3719,18 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_optimize_args;
+package Blur::Blur_shardClusterList_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';
+  return 'Blur_shardClusterList_args';
 }
 
 sub read {
@@ -3959,18 +3748,6 @@ 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::I32) {
-        $xfer += $input->readI32(\$self->{numberOfSegmentsPerShard});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -3982,32 +3759,26 @@ sub read {
 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->writeStructBegin('Blur_shardClusterList_args');
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_optimize_result;
+package Blur::Blur_shardClusterList_result;
 use base qw(Class::Accessor);
-Blur::Blur_optimize_result->mk_accessors( qw( ) );
+Blur::Blur_shardClusterList_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};
     }
@@ -4016,7 +3787,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_optimize_result';
+  return 'Blur_shardClusterList_result';
 }
 
 sub read {
@@ -4034,6 +3805,24 @@ sub read {
     }
     SWITCH: for($fid)
     {
+      /^0$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size227 = 0;
+          $self->{success} = [];
+          my $_etype230 = 0;
+          $xfer += $input->readListBegin(\$_etype230, \$_size227);
+          for (my $_i231 = 0; $_i231 < $_size227; ++$_i231)
+          {
+            my $elem232 = undef;
+            $xfer += $input->readString(\$elem232);
+            push(@{$self->{success}},$elem232);
+          }
+          $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);
@@ -4052,7 +3841,21 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_optimize_result');
+  $xfer += $output->writeStructBegin('Blur_shardClusterList_result');
+  if (defined $self->{success}) {
+    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
+    {
+      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
+      {
+        foreach my $iter233 (@{$self->{success}}) 
+        {
+          $xfer += $output->writeString($iter233);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -4063,9 +3866,9 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_isInSafeMode_args;
+package Blur::Blur_shardServerList_args;
 use base qw(Class::Accessor);
-Blur::Blur_isInSafeMode_args->mk_accessors( qw( cluster ) );
+Blur::Blur_shardServerList_args->mk_accessors( qw( cluster ) );
 
 sub new {
   my $classname = shift;
@@ -4081,7 +3884,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_isInSafeMode_args';
+  return 'Blur_shardServerList_args';
 }
 
 sub read {
@@ -4116,7 +3919,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_isInSafeMode_args');
+  $xfer += $output->writeStructBegin('Blur_shardServerList_args');
   if (defined $self->{cluster}) {
     $xfer += $output->writeFieldBegin('cluster', TType::STRING, 1);
     $xfer += $output->writeString($self->{cluster});
@@ -4127,9 +3930,9 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_isInSafeMode_result;
+package Blur::Blur_shardServerList_result;
 use base qw(Class::Accessor);
-Blur::Blur_isInSafeMode_result->mk_accessors( qw( success ) );
+Blur::Blur_shardServerList_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
@@ -4149,7 +3952,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_isInSafeMode_result';
+  return 'Blur_shardServerList_result';
 }
 
 sub read {
@@ -4167,8 +3970,20 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{success});
+      /^0$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size234 = 0;
+          $self->{success} = [];
+          my $_etype237 = 0;
+          $xfer += $input->readListBegin(\$_etype237, \$_size234);
+      

<TRUNCATED>

Mime
View raw message