incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [12/27] Massive changes to the the thrift API. Getting closer to the final version, this commit also removes the controller from the architecture.
Date Sun, 18 Nov 2012 00:52:58 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/aee531c2/interface/gen-perl/Blur/Blur.pm
----------------------------------------------------------------------
diff --git a/interface/gen-perl/Blur/Blur.pm b/interface/gen-perl/Blur/Blur.pm
index 7209ff1..43954b8 100644
--- a/interface/gen-perl/Blur/Blur.pm
+++ b/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_openReadSession_args;
 use base qw(Class::Accessor);
+Blur::Blur_openReadSession_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_shardClusterList_args';
+  return 'Blur_openReadSession_args';
 }
 
 sub read {
@@ -41,6 +48,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();
@@ -52,35 +65,40 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_shardClusterList_args');
+  $xfer += $output->writeStructBegin('Blur_openReadSession_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_shardClusterList_result;
+package Blur::Blur_openReadSession_result;
 use base qw(Class::Accessor);
-Blur::Blur_shardClusterList_result->mk_accessors( qw( success ) );
+Blur::Blur_openReadSession_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{success} = undef;
-  $self->{ex} = undef;
+  $self->{e} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{success}) {
       $self->{success} = $vals->{success};
     }
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    if (defined $vals->{e}) {
+      $self->{e} = $vals->{e};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_shardClusterList_result';
+  return 'Blur_openReadSession_result';
 }
 
 sub read {
@@ -98,27 +116,16 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::LIST) {
-        {
-          my $_size124 = 0;
-          $self->{success} = [];
-          my $_etype127 = 0;
-          $xfer += $input->readListBegin(\$_etype127, \$_size124);
-          for (my $_i128 = 0; $_i128 < $_size124; ++$_i128)
-          {
-            my $elem129 = undef;
-            $xfer += $input->readString(\$elem129);
-            push(@{$self->{success}},$elem129);
-          }
-          $xfer += $input->readListEnd();
-        }
+      /^0$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{success} = new Blur::Session();
+        $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);
+        $self->{e} = new Blur::BlurException();
+        $xfer += $self->{e}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -134,24 +141,15 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_shardClusterList_result');
+  $xfer += $output->writeStructBegin('Blur_openReadSession_result');
   if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
-    {
-      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
-      {
-        foreach my $iter130 (@{$self->{success}}) 
-        {
-          $xfer += $output->writeString($iter130);
-        }
-      }
-      $xfer += $output->writeListEnd();
-    }
+    $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);
+  if (defined $self->{e}) {
+    $xfer += $output->writeFieldBegin('e', TType::STRUCT, 1);
+    $xfer += $self->{e}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -159,25 +157,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_shardServerList_args;
+package Blur::Blur_search_args;
 use base qw(Class::Accessor);
-Blur::Blur_shardServerList_args->mk_accessors( qw( cluster ) );
+Blur::Blur_search_args->mk_accessors( qw( session queryArgs ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{cluster} = undef;
+  $self->{session} = undef;
+  $self->{queryArgs} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{cluster}) {
-      $self->{cluster} = $vals->{cluster};
+    if (defined $vals->{session}) {
+      $self->{session} = $vals->{session};
+    }
+    if (defined $vals->{queryArgs}) {
+      $self->{queryArgs} = $vals->{queryArgs};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_shardServerList_args';
+  return 'Blur_search_args';
 }
 
 sub read {
@@ -195,8 +197,16 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{cluster});
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{session} = new Blur::Session();
+        $xfer += $self->{session}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{queryArgs} = new Blur::QueryArgs();
+        $xfer += $self->{queryArgs}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -212,10 +222,15 @@ 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_search_args');
+  if (defined $self->{session}) {
+    $xfer += $output->writeFieldBegin('session', TType::STRUCT, 1);
+    $xfer += $self->{session}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{queryArgs}) {
+    $xfer += $output->writeFieldBegin('queryArgs', TType::STRUCT, 2);
+    $xfer += $self->{queryArgs}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -223,29 +238,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_shardServerList_result;
+package Blur::Blur_search_result;
 use base qw(Class::Accessor);
-Blur::Blur_shardServerList_result->mk_accessors( qw( success ) );
+Blur::Blur_search_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{success} = undef;
-  $self->{ex} = undef;
+  $self->{e} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{success}) {
       $self->{success} = $vals->{success};
     }
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    if (defined $vals->{e}) {
+      $self->{e} = $vals->{e};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_shardServerList_result';
+  return 'Blur_search_result';
 }
 
 sub read {
@@ -265,15 +280,16 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size131 = 0;
+          my $_size106 = 0;
           $self->{success} = [];
-          my $_etype134 = 0;
-          $xfer += $input->readListBegin(\$_etype134, \$_size131);
-          for (my $_i135 = 0; $_i135 < $_size131; ++$_i135)
+          my $_etype109 = 0;
+          $xfer += $input->readListBegin(\$_etype109, \$_size106);
+          for (my $_i110 = 0; $_i110 < $_size106; ++$_i110)
           {
-            my $elem136 = undef;
-            $xfer += $input->readString(\$elem136);
-            push(@{$self->{success}},$elem136);
+            my $elem111 = undef;
+            $elem111 = new Blur::TopFieldDocs();
+            $xfer += $elem111->read($input);
+            push(@{$self->{success}},$elem111);
           }
           $xfer += $input->readListEnd();
         }
@@ -282,8 +298,8 @@ sub read {
       }
       last; };
       /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
+        $self->{e} = new Blur::BlurException();
+        $xfer += $self->{e}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -299,24 +315,24 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_shardServerList_result');
+  $xfer += $output->writeStructBegin('Blur_search_result');
   if (defined $self->{success}) {
     $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
     {
-      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
       {
-        foreach my $iter137 (@{$self->{success}}) 
+        foreach my $iter112 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter137);
+          $xfer += ${iter112}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
     }
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
+  if (defined $self->{e}) {
+    $xfer += $output->writeFieldBegin('e', TType::STRUCT, 1);
+    $xfer += $self->{e}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -324,18 +340,33 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_controllerServerList_args;
+package Blur::Blur_doc_args;
 use base qw(Class::Accessor);
+Blur::Blur_doc_args->mk_accessors( qw( session docLocations fields ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
+  $self->{session} = undef;
+  $self->{docLocations} = undef;
+  $self->{fields} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{session}) {
+      $self->{session} = $vals->{session};
+    }
+    if (defined $vals->{docLocations}) {
+      $self->{docLocations} = $vals->{docLocations};
+    }
+    if (defined $vals->{fields}) {
+      $self->{fields} = $vals->{fields};
+    }
+  }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_controllerServerList_args';
+  return 'Blur_doc_args';
 }
 
 sub read {
@@ -353,6 +384,49 @@ sub read {
     }
     SWITCH: for($fid)
     {
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{session} = new Blur::Session();
+        $xfer += $self->{session}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size113 = 0;
+          $self->{docLocations} = [];
+          my $_etype116 = 0;
+          $xfer += $input->readListBegin(\$_etype116, \$_size113);
+          for (my $_i117 = 0; $_i117 < $_size113; ++$_i117)
+          {
+            my $elem118 = undef;
+            $xfer += $input->readI64(\$elem118);
+            push(@{$self->{docLocations}},$elem118);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::SET) {
+        {
+          my $_size119 = 0;
+          $self->{fields} = {};
+          my $_etype122 = 0;
+          $xfer += $input->readSetBegin(\$_etype122, \$_size119);
+          for (my $_i123 = 0; $_i123 < $_size119; ++$_i123)
+          {
+            my $elem124 = undef;
+            $xfer += $input->readString(\$elem124);
+            $self->{fields}->{$elem124} = 1;
+          }
+          $xfer += $input->readSetEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -364,35 +438,68 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_controllerServerList_args');
+  $xfer += $output->writeStructBegin('Blur_doc_args');
+  if (defined $self->{session}) {
+    $xfer += $output->writeFieldBegin('session', TType::STRUCT, 1);
+    $xfer += $self->{session}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{docLocations}) {
+    $xfer += $output->writeFieldBegin('docLocations', TType::LIST, 2);
+    {
+      $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{docLocations}}));
+      {
+        foreach my $iter125 (@{$self->{docLocations}}) 
+        {
+          $xfer += $output->writeI64($iter125);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{fields}) {
+    $xfer += $output->writeFieldBegin('fields', TType::SET, 4);
+    {
+      $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{fields}}));
+      {
+        foreach my $iter126 (@{$self->{fields}})
+        {
+          $xfer += $output->writeString($iter126);
+        }
+      }
+      $xfer += $output->writeSetEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_controllerServerList_result;
+package Blur::Blur_doc_result;
 use base qw(Class::Accessor);
-Blur::Blur_controllerServerList_result->mk_accessors( qw( success ) );
+Blur::Blur_doc_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{success} = undef;
-  $self->{ex} = undef;
+  $self->{e} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{success}) {
       $self->{success} = $vals->{success};
     }
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    if (defined $vals->{e}) {
+      $self->{e} = $vals->{e};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_controllerServerList_result';
+  return 'Blur_doc_result';
 }
 
 sub read {
@@ -412,15 +519,16 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size138 = 0;
+          my $_size127 = 0;
           $self->{success} = [];
-          my $_etype141 = 0;
-          $xfer += $input->readListBegin(\$_etype141, \$_size138);
-          for (my $_i142 = 0; $_i142 < $_size138; ++$_i142)
+          my $_etype130 = 0;
+          $xfer += $input->readListBegin(\$_etype130, \$_size127);
+          for (my $_i131 = 0; $_i131 < $_size127; ++$_i131)
           {
-            my $elem143 = undef;
-            $xfer += $input->readString(\$elem143);
-            push(@{$self->{success}},$elem143);
+            my $elem132 = undef;
+            $elem132 = new Blur::Document();
+            $xfer += $elem132->read($input);
+            push(@{$self->{success}},$elem132);
           }
           $xfer += $input->readListEnd();
         }
@@ -429,8 +537,8 @@ sub read {
       }
       last; };
       /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
+        $self->{e} = new Blur::BlurException();
+        $xfer += $self->{e}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -446,24 +554,24 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_controllerServerList_result');
+  $xfer += $output->writeStructBegin('Blur_doc_result');
   if (defined $self->{success}) {
     $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
     {
-      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
       {
-        foreach my $iter144 (@{$self->{success}}) 
+        foreach my $iter133 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter144);
+          $xfer += ${iter133}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
     }
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
+  if (defined $self->{e}) {
+    $xfer += $output->writeFieldBegin('e', TType::STRUCT, 1);
+    $xfer += $self->{e}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -471,25 +579,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_shardServerLayout_args;
+package Blur::Blur_closeReadSession_args;
 use base qw(Class::Accessor);
-Blur::Blur_shardServerLayout_args->mk_accessors( qw( table ) );
+Blur::Blur_closeReadSession_args->mk_accessors( qw( session ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{table} = undef;
+  $self->{session} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
+    if (defined $vals->{session}) {
+      $self->{session} = $vals->{session};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_shardServerLayout_args';
+  return 'Blur_closeReadSession_args';
 }
 
 sub read {
@@ -507,8 +615,9 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{session} = new Blur::Session();
+        $xfer += $self->{session}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -524,10 +633,10 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_shardServerLayout_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
+  $xfer += $output->writeStructBegin('Blur_closeReadSession_args');
+  if (defined $self->{session}) {
+    $xfer += $output->writeFieldBegin('session', TType::STRUCT, 1);
+    $xfer += $self->{session}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -535,29 +644,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_shardServerLayout_result;
+package Blur::Blur_closeReadSession_result;
 use base qw(Class::Accessor);
-Blur::Blur_shardServerLayout_result->mk_accessors( qw( success ) );
+Blur::Blur_closeReadSession_result->mk_accessors( qw( ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{success} = undef;
-  $self->{ex} = undef;
+  $self->{e} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{success}) {
-      $self->{success} = $vals->{success};
-    }
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    if (defined $vals->{e}) {
+      $self->{e} = $vals->{e};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_shardServerLayout_result';
+  return 'Blur_closeReadSession_result';
 }
 
 sub read {
@@ -575,30 +680,9 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::MAP) {
-        {
-          my $_size145 = 0;
-          $self->{success} = {};
-          my $_ktype146 = 0;
-          my $_vtype147 = 0;
-          $xfer += $input->readMapBegin(\$_ktype146, \$_vtype147, \$_size145);
-          for (my $_i149 = 0; $_i149 < $_size145; ++$_i149)
-          {
-            my $key150 = '';
-            my $val151 = '';
-            $xfer += $input->readString(\$key150);
-            $xfer += $input->readString(\$val151);
-            $self->{success}->{$key150} = $val151;
-          }
-          $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);
+        $self->{e} = new Blur::BlurException();
+        $xfer += $self->{e}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -614,25 +698,10 @@ 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 ($kiter152,$viter153) = each %{$self->{success}}) 
-        {
-          $xfer += $output->writeString($kiter152);
-          $xfer += $output->writeString($viter153);
-        }
-      }
-      $xfer += $output->writeMapEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
+  $xfer += $output->writeStructBegin('Blur_closeReadSession_result');
+  if (defined $self->{e}) {
+    $xfer += $output->writeFieldBegin('e', TType::STRUCT, 1);
+    $xfer += $self->{e}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -640,75 +709,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_tableList_args;
-use base qw(Class::Accessor);
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Blur_tableList_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_tableList_args');
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Blur_tableList_result;
+package Blur::Blur_addDocuments_args;
 use base qw(Class::Accessor);
-Blur::Blur_tableList_result->mk_accessors( qw( success ) );
+Blur::Blur_addDocuments_args->mk_accessors( qw( options documents ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{success} = undef;
-  $self->{ex} = undef;
+  $self->{options} = undef;
+  $self->{documents} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{success}) {
-      $self->{success} = $vals->{success};
+    if (defined $vals->{options}) {
+      $self->{options} = $vals->{options};
     }
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    if (defined $vals->{documents}) {
+      $self->{documents} = $vals->{documents};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_tableList_result';
+  return 'Blur_addDocuments_args';
 }
 
 sub read {
@@ -726,17 +749,25 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::LIST) {
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{options} = new Blur::MutateOptions();
+        $xfer += $self->{options}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size154 = 0;
-          $self->{success} = [];
-          my $_etype157 = 0;
-          $xfer += $input->readListBegin(\$_etype157, \$_size154);
-          for (my $_i158 = 0; $_i158 < $_size154; ++$_i158)
+          my $_size134 = 0;
+          $self->{documents} = [];
+          my $_etype137 = 0;
+          $xfer += $input->readListBegin(\$_etype137, \$_size134);
+          for (my $_i138 = 0; $_i138 < $_size134; ++$_i138)
           {
-            my $elem159 = undef;
-            $xfer += $input->readString(\$elem159);
-            push(@{$self->{success}},$elem159);
+            my $elem139 = undef;
+            $elem139 = new Blur::Document();
+            $xfer += $elem139->read($input);
+            push(@{$self->{documents}},$elem139);
           }
           $xfer += $input->readListEnd();
         }
@@ -744,13 +775,6 @@ sub read {
         $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();
@@ -762,50 +786,50 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_tableList_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
+  $xfer += $output->writeStructBegin('Blur_addDocuments_args');
+  if (defined $self->{options}) {
+    $xfer += $output->writeFieldBegin('options', TType::STRUCT, 1);
+    $xfer += $self->{options}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{documents}) {
+    $xfer += $output->writeFieldBegin('documents', TType::LIST, 2);
     {
-      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{documents}}));
       {
-        foreach my $iter160 (@{$self->{success}}) 
+        foreach my $iter140 (@{$self->{documents}}) 
         {
-          $xfer += $output->writeString($iter160);
+          $xfer += ${iter140}->write($output);
         }
       }
       $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_tableListByCluster_args;
+package Blur::Blur_addDocuments_result;
 use base qw(Class::Accessor);
-Blur::Blur_tableListByCluster_args->mk_accessors( qw( cluster ) );
+Blur::Blur_addDocuments_result->mk_accessors( qw( ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{cluster} = undef;
+  $self->{e} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{cluster}) {
-      $self->{cluster} = $vals->{cluster};
+    if (defined $vals->{e}) {
+      $self->{e} = $vals->{e};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_tableListByCluster_args';
+  return 'Blur_addDocuments_result';
 }
 
 sub read {
@@ -823,8 +847,9 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{cluster});
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{e} = new Blur::BlurException();
+        $xfer += $self->{e}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -840,10 +865,10 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_tableListByCluster_args');
-  if (defined $self->{cluster}) {
-    $xfer += $output->writeFieldBegin('cluster', TType::STRING, 1);
-    $xfer += $output->writeString($self->{cluster});
+  $xfer += $output->writeStructBegin('Blur_addDocuments_result');
+  if (defined $self->{e}) {
+    $xfer += $output->writeFieldBegin('e', TType::STRUCT, 1);
+    $xfer += $self->{e}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -851,29 +876,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_tableListByCluster_result;
+package Blur::Blur_deleteDocumentsByQueries_args;
 use base qw(Class::Accessor);
-Blur::Blur_tableListByCluster_result->mk_accessors( qw( success ) );
+Blur::Blur_deleteDocumentsByQueries_args->mk_accessors( qw( options queries ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{success} = undef;
-  $self->{ex} = undef;
+  $self->{options} = undef;
+  $self->{queries} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{success}) {
-      $self->{success} = $vals->{success};
+    if (defined $vals->{options}) {
+      $self->{options} = $vals->{options};
     }
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    if (defined $vals->{queries}) {
+      $self->{queries} = $vals->{queries};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_tableListByCluster_result';
+  return 'Blur_deleteDocumentsByQueries_args';
 }
 
 sub read {
@@ -891,17 +916,24 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::LIST) {
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{options} = new Blur::MutateOptions();
+        $xfer += $self->{options}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size161 = 0;
-          $self->{success} = [];
-          my $_etype164 = 0;
-          $xfer += $input->readListBegin(\$_etype164, \$_size161);
-          for (my $_i165 = 0; $_i165 < $_size161; ++$_i165)
+          my $_size141 = 0;
+          $self->{queries} = [];
+          my $_etype144 = 0;
+          $xfer += $input->readListBegin(\$_etype144, \$_size141);
+          for (my $_i145 = 0; $_i145 < $_size141; ++$_i145)
           {
-            my $elem166 = undef;
-            $xfer += $input->readString(\$elem166);
-            push(@{$self->{success}},$elem166);
+            my $elem146 = undef;
+            $xfer += $input->readString(\$elem146);
+            push(@{$self->{queries}},$elem146);
           }
           $xfer += $input->readListEnd();
         }
@@ -909,13 +941,6 @@ sub read {
         $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();
@@ -927,50 +952,50 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_tableListByCluster_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
+  $xfer += $output->writeStructBegin('Blur_deleteDocumentsByQueries_args');
+  if (defined $self->{options}) {
+    $xfer += $output->writeFieldBegin('options', TType::STRUCT, 1);
+    $xfer += $self->{options}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{queries}) {
+    $xfer += $output->writeFieldBegin('queries', TType::LIST, 2);
     {
-      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
+      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{queries}}));
       {
-        foreach my $iter167 (@{$self->{success}}) 
+        foreach my $iter147 (@{$self->{queries}}) 
         {
-          $xfer += $output->writeString($iter167);
+          $xfer += $output->writeString($iter147);
         }
       }
       $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_describe_args;
+package Blur::Blur_deleteDocumentsByQueries_result;
 use base qw(Class::Accessor);
-Blur::Blur_describe_args->mk_accessors( qw( table ) );
+Blur::Blur_deleteDocumentsByQueries_result->mk_accessors( qw( ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{table} = undef;
+  $self->{e} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
+    if (defined $vals->{e}) {
+      $self->{e} = $vals->{e};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_describe_args';
+  return 'Blur_deleteDocumentsByQueries_result';
 }
 
 sub read {
@@ -988,8 +1013,9 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{e} = new Blur::BlurException();
+        $xfer += $self->{e}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -1005,10 +1031,10 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_describe_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
+  $xfer += $output->writeStructBegin('Blur_deleteDocumentsByQueries_result');
+  if (defined $self->{e}) {
+    $xfer += $output->writeFieldBegin('e', TType::STRUCT, 1);
+    $xfer += $self->{e}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -1016,29 +1042,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_describe_result;
+package Blur::Blur_deleteDocuments_args;
 use base qw(Class::Accessor);
-Blur::Blur_describe_result->mk_accessors( qw( success ) );
+Blur::Blur_deleteDocuments_args->mk_accessors( qw( options terms ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{success} = undef;
-  $self->{ex} = undef;
+  $self->{options} = undef;
+  $self->{terms} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{success}) {
-      $self->{success} = $vals->{success};
+    if (defined $vals->{options}) {
+      $self->{options} = $vals->{options};
     }
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    if (defined $vals->{terms}) {
+      $self->{terms} = $vals->{terms};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_describe_result';
+  return 'Blur_deleteDocuments_args';
 }
 
 sub read {
@@ -1056,16 +1082,28 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{success} = new Blur::TableDescriptor();
-        $xfer += $self->{success}->read($input);
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{options} = new Blur::MutateOptions();
+        $xfer += $self->{options}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
+      /^2$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size148 = 0;
+          $self->{terms} = [];
+          my $_etype151 = 0;
+          $xfer += $input->readListBegin(\$_etype151, \$_size148);
+          for (my $_i152 = 0; $_i152 < $_size148; ++$_i152)
+          {
+            my $elem153 = undef;
+            $elem153 = new Blur::Term();
+            $xfer += $elem153->read($input);
+            push(@{$self->{terms}},$elem153);
+          }
+          $xfer += $input->readListEnd();
+        }
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -1081,15 +1119,24 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_describe_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
-    $xfer += $self->{success}->write($output);
+  $xfer += $output->writeStructBegin('Blur_deleteDocuments_args');
+  if (defined $self->{options}) {
+    $xfer += $output->writeFieldBegin('options', TType::STRUCT, 1);
+    $xfer += $self->{options}->write($output);
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
+  if (defined $self->{terms}) {
+    $xfer += $output->writeFieldBegin('terms', TType::LIST, 2);
+    {
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{terms}}));
+      {
+        foreach my $iter154 (@{$self->{terms}}) 
+        {
+          $xfer += ${iter154}->write($output);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -1097,29 +1144,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_cancelQuery_args;
+package Blur::Blur_deleteDocuments_result;
 use base qw(Class::Accessor);
-Blur::Blur_cancelQuery_args->mk_accessors( qw( table uuid ) );
+Blur::Blur_deleteDocuments_result->mk_accessors( qw( ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{table} = undef;
-  $self->{uuid} = undef;
+  $self->{e} = 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->{e}) {
+      $self->{e} = $vals->{e};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_cancelQuery_args';
+  return 'Blur_deleteDocuments_result';
 }
 
 sub read {
@@ -1137,14 +1180,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::I64) {
-        $xfer += $input->readI64(\$self->{uuid});
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{e} = new Blur::BlurException();
+        $xfer += $self->{e}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -1160,15 +1198,10 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $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->writeStructBegin('Blur_deleteDocuments_result');
+  if (defined $self->{e}) {
+    $xfer += $output->writeFieldBegin('e', TType::STRUCT, 1);
+    $xfer += $self->{e}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -1176,25 +1209,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_cancelQuery_result;
+package Blur::Blur_updateDocuments_args;
 use base qw(Class::Accessor);
-Blur::Blur_cancelQuery_result->mk_accessors( qw( ) );
+Blur::Blur_updateDocuments_args->mk_accessors( qw( options updatePackages ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{ex} = undef;
+  $self->{options} = undef;
+  $self->{updatePackages} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    if (defined $vals->{options}) {
+      $self->{options} = $vals->{options};
+    }
+    if (defined $vals->{updatePackages}) {
+      $self->{updatePackages} = $vals->{updatePackages};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_cancelQuery_result';
+  return 'Blur_updateDocuments_args';
 }
 
 sub read {
@@ -1213,8 +1250,27 @@ sub read {
     SWITCH: for($fid)
     {
       /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
+        $self->{options} = new Blur::MutateOptions();
+        $xfer += $self->{options}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size155 = 0;
+          $self->{updatePackages} = [];
+          my $_etype158 = 0;
+          $xfer += $input->readListBegin(\$_etype158, \$_size155);
+          for (my $_i159 = 0; $_i159 < $_size155; ++$_i159)
+          {
+            my $elem160 = undef;
+            $elem160 = new Blur::UpdatePackage();
+            $xfer += $elem160->read($input);
+            push(@{$self->{updatePackages}},$elem160);
+          }
+          $xfer += $input->readListEnd();
+        }
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -1230,10 +1286,24 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_cancelQuery_result');
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
+  $xfer += $output->writeStructBegin('Blur_updateDocuments_args');
+  if (defined $self->{options}) {
+    $xfer += $output->writeFieldBegin('options', TType::STRUCT, 1);
+    $xfer += $self->{options}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{updatePackages}) {
+    $xfer += $output->writeFieldBegin('updatePackages', TType::LIST, 2);
+    {
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{updatePackages}}));
+      {
+        foreach my $iter161 (@{$self->{updatePackages}}) 
+        {
+          $xfer += ${iter161}->write($output);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -1241,25 +1311,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_currentQueries_args;
+package Blur::Blur_updateDocuments_result;
 use base qw(Class::Accessor);
-Blur::Blur_currentQueries_args->mk_accessors( qw( table ) );
+Blur::Blur_updateDocuments_result->mk_accessors( qw( ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{table} = undef;
+  $self->{e} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
+    if (defined $vals->{e}) {
+      $self->{e} = $vals->{e};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_currentQueries_args';
+  return 'Blur_updateDocuments_result';
 }
 
 sub read {
@@ -1277,8 +1347,9 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{e} = new Blur::BlurException();
+        $xfer += $self->{e}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -1294,10 +1365,10 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_currentQueries_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
+  $xfer += $output->writeStructBegin('Blur_updateDocuments_result');
+  if (defined $self->{e}) {
+    $xfer += $output->writeFieldBegin('e', TType::STRUCT, 1);
+    $xfer += $self->{e}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -1305,9 +1376,55 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_currentQueries_result;
+package Blur::Blur_serverList_args;
+use base qw(Class::Accessor);
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_serverList_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_serverList_args');
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_serverList_result;
 use base qw(Class::Accessor);
-Blur::Blur_currentQueries_result->mk_accessors( qw( success ) );
+Blur::Blur_serverList_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
@@ -1327,7 +1444,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_currentQueries_result';
+  return 'Blur_serverList_result';
 }
 
 sub read {
@@ -1347,16 +1464,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size168 = 0;
+          my $_size162 = 0;
           $self->{success} = [];
-          my $_etype171 = 0;
-          $xfer += $input->readListBegin(\$_etype171, \$_size168);
-          for (my $_i172 = 0; $_i172 < $_size168; ++$_i172)
+          my $_etype165 = 0;
+          $xfer += $input->readListBegin(\$_etype165, \$_size162);
+          for (my $_i166 = 0; $_i166 < $_size162; ++$_i166)
           {
-            my $elem173 = undef;
-            $elem173 = new Blur::BlurQueryStatus();
-            $xfer += $elem173->read($input);
-            push(@{$self->{success}},$elem173);
+            my $elem167 = undef;
+            $xfer += $input->readString(\$elem167);
+            push(@{$self->{success}},$elem167);
           }
           $xfer += $input->readListEnd();
         }
@@ -1382,15 +1498,15 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_currentQueries_result');
+  $xfer += $output->writeStructBegin('Blur_serverList_result');
   if (defined $self->{success}) {
     $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
     {
-      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
+      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter174 (@{$self->{success}}) 
+        foreach my $iter168 (@{$self->{success}}) 
         {
-          $xfer += ${iter174}->write($output);
+          $xfer += $output->writeString($iter168);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1407,25 +1523,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_queryStatusIdList_args;
+package Blur::Blur_serverLayout_args;
 use base qw(Class::Accessor);
-Blur::Blur_queryStatusIdList_args->mk_accessors( qw( table ) );
+Blur::Blur_serverLayout_args->mk_accessors( qw( table server ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{table} = undef;
+  $self->{server} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{table}) {
       $self->{table} = $vals->{table};
     }
+    if (defined $vals->{server}) {
+      $self->{server} = $vals->{server};
+    }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_queryStatusIdList_args';
+  return 'Blur_serverLayout_args';
 }
 
 sub read {
@@ -1449,6 +1569,12 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
+      /^2$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{server});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -1460,20 +1586,25 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_queryStatusIdList_args');
+  $xfer += $output->writeStructBegin('Blur_serverLayout_args');
   if (defined $self->{table}) {
     $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
     $xfer += $output->writeString($self->{table});
     $xfer += $output->writeFieldEnd();
   }
+  if (defined $self->{server}) {
+    $xfer += $output->writeFieldBegin('server', TType::STRING, 2);
+    $xfer += $output->writeString($self->{server});
+    $xfer += $output->writeFieldEnd();
+  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_queryStatusIdList_result;
+package Blur::Blur_serverLayout_result;
 use base qw(Class::Accessor);
-Blur::Blur_queryStatusIdList_result->mk_accessors( qw( success ) );
+Blur::Blur_serverLayout_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
@@ -1493,7 +1624,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_queryStatusIdList_result';
+  return 'Blur_serverLayout_result';
 }
 
 sub read {
@@ -1513,15 +1644,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size175 = 0;
+          my $_size169 = 0;
           $self->{success} = [];
-          my $_etype178 = 0;
-          $xfer += $input->readListBegin(\$_etype178, \$_size175);
-          for (my $_i179 = 0; $_i179 < $_size175; ++$_i179)
+          my $_etype172 = 0;
+          $xfer += $input->readListBegin(\$_etype172, \$_size169);
+          for (my $_i173 = 0; $_i173 < $_size169; ++$_i173)
           {
-            my $elem180 = undef;
-            $xfer += $input->readI64(\$elem180);
-            push(@{$self->{success}},$elem180);
+            my $elem174 = undef;
+            $xfer += $input->readI32(\$elem174);
+            push(@{$self->{success}},$elem174);
           }
           $xfer += $input->readListEnd();
         }
@@ -1547,15 +1678,15 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_queryStatusIdList_result');
+  $xfer += $output->writeStructBegin('Blur_serverLayout_result');
   if (defined $self->{success}) {
     $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
     {
-      $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{success}}));
+      $xfer += $output->writeListBegin(TType::I32, scalar(@{$self->{success}}));
       {
-        foreach my $iter181 (@{$self->{success}}) 
+        foreach my $iter175 (@{$self->{success}}) 
         {
-          $xfer += $output->writeI64($iter181);
+          $xfer += $output->writeI32($iter175);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1572,29 +1703,18 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_queryStatusById_args;
+package Blur::Blur_tableList_args;
 use base qw(Class::Accessor);
-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_queryStatusById_args';
+  return 'Blur_tableList_args';
 }
 
 sub read {
@@ -1612,18 +1732,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::I64) {
-        $xfer += $input->readI64(\$self->{uuid});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -1635,25 +1743,15 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $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->writeStructBegin('Blur_tableList_args');
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_queryStatusById_result;
+package Blur::Blur_tableList_result;
 use base qw(Class::Accessor);
-Blur::Blur_queryStatusById_result->mk_accessors( qw( success ) );
+Blur::Blur_tableList_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
@@ -1673,7 +1771,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_queryStatusById_result';
+  return 'Blur_tableList_result';
 }
 
 sub read {
@@ -1691,9 +1789,20 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{success} = new Blur::BlurQueryStatus();
-        $xfer += $self->{success}->read($input);
+      /^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);
       }
@@ -1716,10 +1825,19 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_queryStatusById_result');
+  $xfer += $output->writeStructBegin('Blur_tableList_result');
   if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
-    $xfer += $self->{success}->write($output);
+    $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();
   }
   if (defined $self->{ex}) {
@@ -1732,25 +1850,18 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_schema_args;
+package Blur::Blur_isInSafeMode_args;
 use base qw(Class::Accessor);
-Blur::Blur_schema_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_schema_args';
+  return 'Blur_isInSafeMode_args';
 }
 
 sub read {
@@ -1768,12 +1879,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();
@@ -1785,165 +1890,15 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $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();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Blur_schema_result;
-use base qw(Class::Accessor);
-Blur::Blur_schema_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_schema_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::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);
-      } 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_schema_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_tableStats_args;
-use base qw(Class::Accessor);
-Blur::Blur_tableStats_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_tableStats_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_tableStats_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
-  }
+  $xfer += $output->writeStructBegin('Blur_isInSafeMode_args');
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_tableStats_result;
+package Blur::Blur_isInSafeMode_result;
 use base qw(Class::Accessor);
-Blur::Blur_tableStats_result->mk_accessors( qw( success ) );
+Blur::Blur_isInSafeMode_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
@@ -1963,7 +1918,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_tableStats_result';
+  return 'Blur_isInSafeMode_result';
 }
 
 sub read {
@@ -1981,9 +1936,8 @@ 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::BOOL) {
+        $xfer += $input->readBool(\$self->{success});
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -2006,10 +1960,10 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_tableStats_result');
+  $xfer += $output->writeStructBegin('Blur_isInSafeMode_result');
   if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
-    $xfer += $self->{success}->write($output);
+    $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
+    $xfer += $output->writeBool($self->{success});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{ex}) {
@@ -2554,29 +2508,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_optimize_args;
+package Blur::Blur_describe_args;
 use base qw(Class::Accessor);
-Blur::Blur_optimize_args->mk_accessors( qw( table numberOfSegmentsPerShard ) );
+Blur::Blur_describe_args->mk_accessors( qw( table ) );
 
 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_describe_args';
 }
 
 sub read {
@@ -2600,12 +2550,6 @@ 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();
@@ -2617,32 +2561,31 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_optimize_args');
+  $xfer += $output->writeStructBegin('Blur_describe_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;
+package Blur::Blur_describe_result;
 use base qw(Class::Accessor);
-Blur::Blur_optimize_result->mk_accessors( qw( ) );
+Blur::Blur_describe_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};
     }
@@ -2651,7 +2594,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_optimize_result';
+  return 'Blur_describe_result';
 }
 
 sub read {
@@ -2669,6 +2612,13 @@ sub read {
     }
     SWITCH: for($fid)
     {
+      /^0$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{success} = new Blur::TableDescriptor();
+        $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);
@@ -2687,7 +2637,12 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_optimize_result');
+  $xfer += $output->writeStructBegin('Blur_describe_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);
@@ -2698,25 +2653,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_isInSafeMode_args;
+package Blur::Blur_cancelQuery_args;
 use base qw(Class::Accessor);
-Blur::Blur_isInSafeMode_args->mk_accessors( qw( cluster ) );
+Blur::Blur_cancelQuery_args->mk_accessors( qw( session id ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{cluster} = undef;
+  $self->{session} = undef;
+  $self->{id} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{cluster}) {
-      $self->{cluster} = $vals->{cluster};
+    if (defined $vals->{session}) {
+      $self->{session} = $vals->{session};
+    }
+    if (defined $vals->{id}) {
+      $self->{id} = $vals->{id};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_isInSafeMode_args';
+  return 'Blur_cancelQuery_args';
 }
 
 sub read {
@@ -2734,8 +2693,15 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{cluster});
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{session} = new Blur::Session();
+        $xfer += $self->{session}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{id});
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -2751,10 +2717,15 @@ sub read {
 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->writeStructBegin('Blur_cancelQuery_args');
+  if (defined $self->{session}) {
+    $xfer += $output->writeFieldBegin('session', TType::STRUCT, 1);
+    $xfer += $self->{session}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{id}) {
+    $xfer += $output->writeFieldBegin('id', TType::I64, 2);
+    $xfer += $output->writeI64($self->{id});
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -2762,20 +2733,16 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_isInSafeMode_result;
+package Blur::Blur_cancelQuery_result;
 use base qw(Class::Accessor);
-Blur::Blur_isInSafeMode_result->mk_accessors( qw( success ) );
+Blur::Blur_cancelQuery_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};
     }
@@ -2784,7 +2751,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_isInSafeMode_result';
+  return 'Blur_cancelQuery_result';
 }
 
 sub read {
@@ -2802,12 +2769,6 @@ 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);
@@ -2826,12 +2787,7 @@ sub read {
 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();
-  }
+  $xfer += $output->writeStructBegin('Blur_cancelQuery_result');
   if (defined $self->{ex}) {
     $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
     $xfer += $self->{ex}->write($output);
@@ -2842,18 +2798,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::Blur_configuration_args;
+package Blur::Blur_queryStatusIdList_args;
 use base qw(Class::Accessor);
+Blur::Blur_queryStatusIdList_args->mk_accessors( qw( session ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
+  $self->{session} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{session}) {
+      $self->{session} = $vals->{session};
+    }
+  }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_configuration_args';
+  return 'Blur_queryStatusIdList_args';
 }
 
 sub read {
@@ -2871,6 +2834,13 @@ sub read {
     }
     SWITCH: for($fid)
     {
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{session} = new Blur::Session();
+        $xfer += $self->{session}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -2882,15 +2852,20 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_configuration_args');
+  $xfer += $output->writeStructBegin('Blur_queryStatusIdList_args');
+  if (defined $self->{session}) {
+    $xfer += $output->writeFieldBegin('session', TType::STRUCT, 1);
+    $xfer += $self->{session}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::Blur_configuration_result;
+package Blur::Blur_queryStatusIdList_result;
 use base qw(Class::Accessor);
-Blur::Blur_configuration_result->mk_accessors( qw( success ) );
+Blur::Blur_queryStatusIdList_result->mk_accessors( qw( success ) );
 
 sub new {
   my $classname = shift;
@@ -2910,7 +2885,7 @@ sub new {
 }
 
 sub getName {
-  return 'Blur_configuration_result';
+  return 'Blur_queryStatusIdList_result';
 }
 
 sub read {
@@ -2928,22 +2903,19 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^0$/ && do{      if ($ftype == TType::MAP) {
+      /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size182 = 0;
-          $self->{success} = {};
-          my $_ktype183 = 0;
-          my $_vtype184 = 0;
-          $xfer += $input->readMapBegin(\$_ktype183, \$_vtype184, \$_size182);
-          for (my $_i186 = 0; $_i186 < $_size182; ++$_i186)
+          my $_size183 = 0;
+          $self->{success} = [];
+          my $_etype186 = 0;
+          $xfer += $input->readListBegin(\$_etype186, \$_size183);
+          for (my $_i187 = 0; $_i187 < $_size183; ++$_i187)
           {
-            my $key187 = '';
-            my $val188 = '';
-            $xfer += $input->readString(\$key187);
-            $xfer += $input->readString(\$val188);
-            $self->{success}->{$key187} = $val188;
+            my $elem188 = undef;
+            $xfer += $input->readI64(\$elem188);
+            push(@{$self->{success}},$elem188);
           }
-          $xfer += $input->readMapEnd();
+          $xfer += $input->readListEnd();
         }
       } else {
         $xfer += $input->skip($ftype);
@@ -2967,19 +2939,18 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_configuration_result');
+  $xfer += $output->writeStructBegin('Blur_queryStatusIdList_result');
   if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::MAP, 0);
+    $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
     {
-      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
+      $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{success}}));
       {
-        while( my ($kiter189,$viter190) = each %{$self->{success}}) 
+        foreach my $iter189 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter189);
-          $xfer += $output->writeString($viter190);
+          $xfer += $output->writeI64($iter189);
         }
       }
-      $xfer += $output->writeMapEnd();
+      $xfer += $output->writeListEnd();
     }
     $xfer += $output->writeFieldEnd();
   }
@@ -2993,97 +2964,547 @@ sub write {
   return $xfer;
 }
 
-package Blur::BlurIf;
+package Blur::Blur_queryStatus_args;
+use base qw(Class::Accessor);
+Blur::Blur_queryStatus_args->mk_accessors( qw( session id ) );
 
-use strict;
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{session} = undef;
+  $self->{id} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{session}) {
+      $self->{session} = $vals->{session};
+    }
+    if (defined $vals->{id}) {
+      $self->{id} = $vals->{id};
+    }
+  }
+  return bless ($self, $classname);
+}
 
+sub getName {
+  return 'Blur_queryStatus_args';
+}
 
-sub shardClusterList{
-  my $self = shift;
+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->{session} = new Blur::Session();
+        $xfer += $self->{session}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{id});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
 
-  die 'implement interface';
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_queryStatus_args');
+  if (defined $self->{session}) {
+    $xfer += $output->writeFieldBegin('session', TType::STRUCT, 1);
+    $xfer += $self->{session}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{id}) {
+    $xfer += $output->writeFieldBegin('id', TType::I64, 2);
+    $xfer += $output->writeI64($self->{id});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_queryStatus_result;
+use base qw(Class::Accessor);
+Blur::Blur_queryStatus_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_queryStatus_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::QueryStatus();
+        $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_queryStatus_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_schema_args;
+use base qw(Class::Accessor);
+Blur::Blur_schema_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_schema_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_schema_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_schema_result;
+use base qw(Class::Accessor);
+Blur::Blur_schema_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 shardServerList{
+sub getName {
+  return 'Blur_schema_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::LiveSchema();
+        $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_schema_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_tableStats_args;
+use base qw(Class::Accessor);
+Blur::Blur_tableStats_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_tableStats_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_tableStats_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_tableStats_result;
+use base qw(Class::Accessor);
+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};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_tableStats_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::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);
+      } 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_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);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::BlurIf;
+
+use strict;
+
+
+sub openReadSession{
   my $self = shift;
-  my $cluster = shift;
+  my $table = shift;
 
   die 'implement interface';
 }
 
-sub controllerServerList{
+sub search{
   my $self = shift;
+  my $session = shift;
+  my $queryArgs = shift;
 
   die 'implement interface';
 }
 
-sub shardServerLayout{
+sub doc{
   my $self = shift;
-  my $table = shift;
+  my $session = shift;
+  my $docLocations = shift;
+  my $fields = shift;
 
   die 'implement interface';
 }
 
-sub tableList{
+sub closeReadSession{
   my $self = shift;
+  my $session = shift;
 
   die 'implement interface';
 }
 
-sub tableListByCluster{
+sub addDocuments{
   my $self = shift;
-  my $cluster = shift;
+  my $options = shift;
+  my $documents = shift;
 
   die 'implement interface';
 }
 
-sub describe{
+sub deleteDocumentsByQueries{
   my $self = shift;
-  my $table = shift;
+  my $options = shift;
+  my $queries = shift;
 
   die 'implement interface';
 }
 
-sub cancelQuery{
+sub deleteDocuments{
   my $self = shift;
-  my $table = shift;
-  my $uuid = shift;
+  my $options = shift;
+  my $terms = shift;
 
   die 'implement interface';
 }
 
-sub currentQueries{
+sub updateDocuments{
   my $self = shift;
-  my $table = shift;
+  my $options = shift;
+  my $updatePackages = shift;
 
   die 'implement interface';
 }
 
-sub queryStatusIdList{
+sub serverList{
   my $self = shift;
-  my $table = shift;
 
   die 'implement interface';
 }
 
-sub queryStatusById{
+sub serverLayout{
   my $self = shift;
   my $table = shift;
-  my $uuid = shift;
+  my $server = shift;
 
   die 'implement interface';
 }
 
-sub schema{
+sub tableList{
   my $self = shift;
-  my $table = shift;
 
   die 'implement interface';
 }
 
-sub tableStats{
+sub isInSafeMode{
   my $self = shift;
-  my $table = shift;
 
   die 'implement interface';
 }
@@ -3117,23 +3538,46 @@ sub removeTable{
   die 'implement interface';
 }
 
-sub optimize{
+sub describe{
   my $self = shift;
   my $table = shift;
-  my $numberOfSegmentsPerShard = shift;
 
   die 'implement interf

<TRUNCATED>

Mime
View raw message