[2/9] Initial commit of generic command execution on new blur platform.

[amccurry]

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/486d37b5/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 800a866..22a0ea8 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
@@ -9,6 +9,7 @@ use warnings;
 use Thrift;
 
 use Blur::Types;
+use Blur::BlurPlatform;
 
 # HELPER FUNCTIONS AND STRUCTURES
 
@@ -17,6687 +18,6687 @@ 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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_createTable_args';
-}
+    return 'Blur_createTable_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{tableDescriptor} = new Blur::TableDescriptor();
-        $xfer += $self->{tableDescriptor}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
+      }
+      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);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 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->writeFieldEnd();
+    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->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_createTable_result;
 use base qw(Class::Accessor);
 Blur::Blur_createTable_result->mk_accessors( qw( ) );
 
 sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{ex} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    my $classname = shift;
+    my $self      = {};
+    my $vals      = shift || {};
+    $self->{ex} = undef;
+    if (UNIVERSAL::isa($vals,'HASH')) {
+      if (defined $vals->{ex}) {
+        $self->{ex} = $vals->{ex};
+      }
     }
-  }
-  return bless ($self, $classname);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_createTable_result';
-}
+    return 'Blur_createTable_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
+      }
+      SWITCH: for($fid)
+      {
+        /^1$/ && do{        if ($ftype == TType::STRUCT) {
+          $self->{ex} = new Blur::BlurException();
+          $xfer += $self->{ex}->read($input);
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+          $xfer += $input->skip($ftype);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_createTable_result');
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_createTable_result');
+    if (defined $self->{ex}) {
+      $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+      $xfer += $self->{ex}->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_enableTable_args;
 use base qw(Class::Accessor);
 Blur::Blur_enableTable_args->mk_accessors( qw( table ) );
 
 sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{table} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_enableTable_args';
-}
+    return 'Blur_enableTable_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
+      $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);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_enableTable_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_enableTable_args');
+    if (defined $self->{table}) {
+      $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+      $xfer += $output->writeString($self->{table});
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_enableTable_result;
 use base qw(Class::Accessor);
 Blur::Blur_enableTable_result->mk_accessors( qw( ) );
 
 sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{ex} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    my $classname = shift;
+    my $self      = {};
+    my $vals      = shift || {};
+    $self->{ex} = undef;
+    if (UNIVERSAL::isa($vals,'HASH')) {
+      if (defined $vals->{ex}) {
+        $self->{ex} = $vals->{ex};
+      }
     }
-  }
-  return bless ($self, $classname);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_enableTable_result';
-}
+    return 'Blur_enableTable_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
+      }
+      SWITCH: for($fid)
+      {
+        /^1$/ && do{        if ($ftype == TType::STRUCT) {
+          $self->{ex} = new Blur::BlurException();
+          $xfer += $self->{ex}->read($input);
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+          $xfer += $input->skip($ftype);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 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();
+    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();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_disableTable_args';
-}
+    return 'Blur_disableTable_args';
+  }
 
 sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
+      $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);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_disableTable_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_disableTable_args');
+    if (defined $self->{table}) {
+      $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+      $xfer += $output->writeString($self->{table});
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_disableTable_result;
 use base qw(Class::Accessor);
 Blur::Blur_disableTable_result->mk_accessors( qw( ) );
 
 sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{ex} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    my $classname = shift;
+    my $self      = {};
+    my $vals      = shift || {};
+    $self->{ex} = undef;
+    if (UNIVERSAL::isa($vals,'HASH')) {
+      if (defined $vals->{ex}) {
+        $self->{ex} = $vals->{ex};
+      }
     }
-  }
-  return bless ($self, $classname);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_disableTable_result';
-}
+    return 'Blur_disableTable_result';
+  }
 
 sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
+      }
+      SWITCH: for($fid)
+      {
+        /^1$/ && do{        if ($ftype == TType::STRUCT) {
+          $self->{ex} = new Blur::BlurException();
+          $xfer += $self->{ex}->read($input);
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+          $xfer += $input->skip($ftype);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_disableTable_result');
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_disableTable_result');
+    if (defined $self->{ex}) {
+      $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+      $xfer += $self->{ex}->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_removeTable_args;
 use base qw(Class::Accessor);
 Blur::Blur_removeTable_args->mk_accessors( qw( table deleteIndexFiles ) );
 
 sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{table} = undef;
-  $self->{deleteIndexFiles} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
-    }
-    if (defined $vals->{deleteIndexFiles}) {
-      $self->{deleteIndexFiles} = $vals->{deleteIndexFiles};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_removeTable_args';
-}
+    return 'Blur_removeTable_args';
+  }
 
 sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
       }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{deleteIndexFiles});
-      } else {
-        $xfer += $input->skip($ftype);
+      SWITCH: for($fid)
+      {
+        /^1$/ && do{        if ($ftype == TType::STRING) {
+          $xfer += $input->readString(\$self->{table});
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+        /^2$/ && do{        if ($ftype == TType::BOOL) {
+          $xfer += $input->readBool(\$self->{deleteIndexFiles});
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+          $xfer += $input->skip($ftype);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_removeTable_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{deleteIndexFiles}) {
-    $xfer += $output->writeFieldBegin('deleteIndexFiles', TType::BOOL, 2);
-    $xfer += $output->writeBool($self->{deleteIndexFiles});
-    $xfer += $output->writeFieldEnd();
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_removeTable_args');
+    if (defined $self->{table}) {
+      $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+      $xfer += $output->writeString($self->{table});
+      $xfer += $output->writeFieldEnd();
+    }
+    if (defined $self->{deleteIndexFiles}) {
+      $xfer += $output->writeFieldBegin('deleteIndexFiles', TType::BOOL, 2);
+      $xfer += $output->writeBool($self->{deleteIndexFiles});
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_removeTable_result;
 use base qw(Class::Accessor);
 Blur::Blur_removeTable_result->mk_accessors( qw( ) );
 
 sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{ex} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    my $classname = shift;
+    my $self      = {};
+    my $vals      = shift || {};
+    $self->{ex} = undef;
+    if (UNIVERSAL::isa($vals,'HASH')) {
+      if (defined $vals->{ex}) {
+        $self->{ex} = $vals->{ex};
+      }
     }
-  }
-  return bless ($self, $classname);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_removeTable_result';
-}
+    return 'Blur_removeTable_result';
+  }
 
 sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
+      }
+      SWITCH: for($fid)
+      {
+        /^1$/ && do{        if ($ftype == TType::STRUCT) {
+          $self->{ex} = new Blur::BlurException();
+          $xfer += $self->{ex}->read($input);
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+          $xfer += $input->skip($ftype);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_removeTable_result');
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_removeTable_result');
+    if (defined $self->{ex}) {
+      $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+      $xfer += $self->{ex}->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_addColumnDefinition_args;
 use base qw(Class::Accessor);
 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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_addColumnDefinition_args';
-}
+    return 'Blur_addColumnDefinition_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
       }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{columnDefinition} = new Blur::ColumnDefinition();
-        $xfer += $self->{columnDefinition}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      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->{columnDefinition} = new Blur::ColumnDefinition();
+          $xfer += $self->{columnDefinition}->read($input);
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+          $xfer += $input->skip($ftype);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $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();
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $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;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_addColumnDefinition_result;
 use base qw(Class::Accessor);
 Blur::Blur_addColumnDefinition_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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_addColumnDefinition_result';
-}
+    return 'Blur_addColumnDefinition_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^0$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{success});
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
       }
-      last; };
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      SWITCH: for($fid)
+      {
+        /^0$/ && do{        if ($ftype == TType::BOOL) {
+          $xfer += $input->readBool(\$self->{success});
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+        /^1$/ && do{        if ($ftype == TType::STRUCT) {
+          $self->{ex} = new Blur::BlurException();
+          $xfer += $self->{ex}->read($input);
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+          $xfer += $input->skip($ftype);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_addColumnDefinition_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
-    $xfer += $output->writeBool($self->{success});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_addColumnDefinition_result');
+    if (defined $self->{success}) {
+      $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
+      $xfer += $output->writeBool($self->{success});
+      $xfer += $output->writeFieldEnd();
+    }
+    if (defined $self->{ex}) {
+      $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+      $xfer += $self->{ex}->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  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);
+    my $classname = shift;
+    my $self      = {};
+    my $vals      = shift || {};
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_tableList_args';
-}
+    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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
+      }
+      SWITCH: for($fid)
+      {
+          $xfer += $input->skip($ftype);
+      }
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $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;
-}
+    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;
 use base qw(Class::Accessor);
 Blur::Blur_tableList_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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_tableList_result';
-}
+    return 'Blur_tableList_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^0$/ && do{      if ($ftype == TType::LIST) {
-        {
-          my $_size206 = 0;
-          $self->{success} = [];
-          my $_etype209 = 0;
-          $xfer += $input->readListBegin(\$_etype209, \$_size206);
-          for (my $_i210 = 0; $_i210 < $_size206; ++$_i210)
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
+      }
+      SWITCH: for($fid)
+      {
+        /^0$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $elem211 = undef;
-            $xfer += $input->readString(\$elem211);
-            push(@{$self->{success}},$elem211);
+            my $_size236 = 0;
+            $self->{success} = [];
+            my $_etype239 = 0;
+            $xfer += $input->readListBegin(\$_etype239, \$_size236);
+            for (my $_i240 = 0; $_i240 < $_size236; ++$_i240)
+            {
+              my $elem241 = undef;
+              $xfer += $input->readString(\$elem241);
+              push(@{$self->{success}},$elem241);
+            }
+            $xfer += $input->readListEnd();
           }
-          $xfer += $input->readListEnd();
+        } else {
+          $xfer += $input->skip($ftype);
         }
-      } 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; };
+        /^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);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 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->writeListBegin(TType::STRING, 
scalar(@{$self->{success}}));
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_tableList_result');
+    if (defined $self->{success}) {
+      $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
       {
-        foreach my $iter212 (@{$self->{success}}) 
+        $xfer += $output->writeListBegin(TType::STRING, 
scalar(@{$self->{success}}));
         {
-          $xfer += $output->writeString($iter212);
+          foreach my $iter242 (@{$self->{success}}) 
+          {
+            $xfer += $output->writeString($iter242);
+          }
         }
+        $xfer += $output->writeListEnd();
       }
-      $xfer += $output->writeListEnd();
+      $xfer += $output->writeFieldEnd();
     }
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->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;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_tableListByCluster_args;
 use base qw(Class::Accessor);
 Blur::Blur_tableListByCluster_args->mk_accessors( qw( cluster ) );
 
 sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{cluster} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{cluster}) {
-      $self->{cluster} = $vals->{cluster};
+    my $classname = shift;
+    my $self      = {};
+    my $vals      = shift || {};
+    $self->{cluster} = undef;
+    if (UNIVERSAL::isa($vals,'HASH')) {
+      if (defined $vals->{cluster}) {
+        $self->{cluster} = $vals->{cluster};
+      }
     }
-  }
-  return bless ($self, $classname);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_tableListByCluster_args';
-}
+    return 'Blur_tableListByCluster_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{cluster});
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
+      }
+      SWITCH: for($fid)
+      {
+        /^1$/ && do{        if ($ftype == TType::STRING) {
+          $xfer += $input->readString(\$self->{cluster});
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+          $xfer += $input->skip($ftype);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 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->writeFieldEnd();
+    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->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_tableListByCluster_result;
 use base qw(Class::Accessor);
 Blur::Blur_tableListByCluster_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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_tableListByCluster_result';
-}
+    return 'Blur_tableListByCluster_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^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)
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
+      }
+      SWITCH: for($fid)
+      {
+        /^0$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $elem218 = undef;
-            $xfer += $input->readString(\$elem218);
-            push(@{$self->{success}},$elem218);
+            my $_size243 = 0;
+            $self->{success} = [];
+            my $_etype246 = 0;
+            $xfer += $input->readListBegin(\$_etype246, \$_size243);
+            for (my $_i247 = 0; $_i247 < $_size243; ++$_i247)
+            {
+              my $elem248 = undef;
+              $xfer += $input->readString(\$elem248);
+              push(@{$self->{success}},$elem248);
+            }
+            $xfer += $input->readListEnd();
           }
-          $xfer += $input->readListEnd();
+        } else {
+          $xfer += $input->skip($ftype);
         }
-      } 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; };
+        /^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);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 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->writeListBegin(TType::STRING, 
scalar(@{$self->{success}}));
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_tableListByCluster_result');
+    if (defined $self->{success}) {
+      $xfer += $output->writeFieldBegin('success', TType::LIST, 0);
       {
-        foreach my $iter219 (@{$self->{success}}) 
+        $xfer += $output->writeListBegin(TType::STRING, 
scalar(@{$self->{success}}));
         {
-          $xfer += $output->writeString($iter219);
+          foreach my $iter249 (@{$self->{success}}) 
+          {
+            $xfer += $output->writeString($iter249);
+          }
         }
+        $xfer += $output->writeListEnd();
       }
-      $xfer += $output->writeListEnd();
+      $xfer += $output->writeFieldEnd();
     }
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->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;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_describe_args;
 use base qw(Class::Accessor);
 Blur::Blur_describe_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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_describe_args';
-}
+    return 'Blur_describe_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      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->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 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->writeFieldEnd();
+    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->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_describe_result;
 use base qw(Class::Accessor);
 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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_describe_result';
-}
+    return 'Blur_describe_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^0$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{success} = new Blur::TableDescriptor();
-        $xfer += $self->{success}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
       }
-      last; };
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      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);
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+          $xfer += $input->skip($ftype);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 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->writeFieldEnd();
-  }
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
+    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->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;
   }
-  $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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_schema_args';
-}
+    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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      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->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $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();
+    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;
   }
-  $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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_schema_result';
-}
+    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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^0$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{success} = new Blur::Schema();
-        $xfer += $self->{success}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
       }
-      last; };
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      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);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $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();
+    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;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_parseQuery_args;
 use base qw(Class::Accessor);
 Blur::Blur_parseQuery_args->mk_accessors( qw( table query ) );
 
 sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{table} = undef;
-  $self->{query} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
-    }
-    if (defined $vals->{query}) {
-      $self->{query} = $vals->{query};
-    }
-  }
-  return bless ($self, $classname);
+    my $classname = shift;
+    my $self      = {};
+    my $vals      = shift || {};
+    $self->{table} = undef;
+    $self->{query} = undef;
+    if (UNIVERSAL::isa($vals,'HASH')) {
+      if (defined $vals->{table}) {
+        $self->{table} = $vals->{table};
+      }
+      if (defined $vals->{query}) {
+        $self->{query} = $vals->{query};
+      }
+    }
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_parseQuery_args';
-}
+    return 'Blur_parseQuery_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
       }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{query} = new Blur::Query();
-        $xfer += $self->{query}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      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->{query} = new Blur::Query();
+          $xfer += $self->{query}->read($input);
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+          $xfer += $input->skip($ftype);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_parseQuery_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{query}) {
-    $xfer += $output->writeFieldBegin('query', TType::STRUCT, 2);
-    $xfer += $self->{query}->write($output);
-    $xfer += $output->writeFieldEnd();
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_parseQuery_args');
+    if (defined $self->{table}) {
+      $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+      $xfer += $output->writeString($self->{table});
+      $xfer += $output->writeFieldEnd();
+    }
+    if (defined $self->{query}) {
+      $xfer += $output->writeFieldBegin('query', TType::STRUCT, 2);
+      $xfer += $self->{query}->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_parseQuery_result;
 use base qw(Class::Accessor);
 Blur::Blur_parseQuery_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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_parseQuery_result';
-}
+    return 'Blur_parseQuery_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^0$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{success});
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
       }
-      last; };
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      SWITCH: for($fid)
+      {
+        /^0$/ && do{        if ($ftype == TType::STRING) {
+          $xfer += $input->readString(\$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);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_parseQuery_result');
-  if (defined $self->{success}) {
-    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
-    $xfer += $output->writeString($self->{success});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_parseQuery_result');
+    if (defined $self->{success}) {
+      $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
+      $xfer += $output->writeString($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;
   }
-  $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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_tableStats_args';
-}
+    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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
+      $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);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $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();
+    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;
   }
-  $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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_tableStats_result';
-}
+    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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^0$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{success} = new Blur::TableStats();
-        $xfer += $self->{success}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
       }
-      last; };
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      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);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $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();
+    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;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_optimize_args;
 use base qw(Class::Accessor);
 Blur::Blur_optimize_args->mk_accessors( qw( table numberOfSegmentsPerShard ) );
 
 sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{table} = undef;
-  $self->{numberOfSegmentsPerShard} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
-    }
-    if (defined $vals->{numberOfSegmentsPerShard}) {
-      $self->{numberOfSegmentsPerShard} = $vals->{numberOfSegmentsPerShard};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_optimize_args';
-}
+    return 'Blur_optimize_args';
+  }
 
 sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
       }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::I32) {
-        $xfer += $input->readI32(\$self->{numberOfSegmentsPerShard});
-      } else {
-        $xfer += $input->skip($ftype);
+      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);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_optimize_args');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{numberOfSegmentsPerShard}) {
-    $xfer += $output->writeFieldBegin('numberOfSegmentsPerShard', TType::I32, 
2);
-    $xfer += $output->writeI32($self->{numberOfSegmentsPerShard});
-    $xfer += $output->writeFieldEnd();
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_optimize_args');
+    if (defined $self->{table}) {
+      $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+      $xfer += $output->writeString($self->{table});
+      $xfer += $output->writeFieldEnd();
+    }
+    if (defined $self->{numberOfSegmentsPerShard}) {
+      $xfer += $output->writeFieldBegin('numberOfSegmentsPerShard', 
TType::I32, 2);
+      $xfer += $output->writeI32($self->{numberOfSegmentsPerShard});
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_optimize_result;
 use base qw(Class::Accessor);
 Blur::Blur_optimize_result->mk_accessors( qw( ) );
 
 sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{ex} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{ex}) {
-      $self->{ex} = $vals->{ex};
+    my $classname = shift;
+    my $self      = {};
+    my $vals      = shift || {};
+    $self->{ex} = undef;
+    if (UNIVERSAL::isa($vals,'HASH')) {
+      if (defined $vals->{ex}) {
+        $self->{ex} = $vals->{ex};
+      }
     }
-  }
-  return bless ($self, $classname);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_optimize_result';
-}
+    return 'Blur_optimize_result';
+  }
 
 sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{ex} = new Blur::BlurException();
-        $xfer += $self->{ex}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
+      }
+      SWITCH: for($fid)
+      {
+        /^1$/ && do{        if ($ftype == TType::STRUCT) {
+          $self->{ex} = new Blur::BlurException();
+          $xfer += $self->{ex}->read($input);
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+          $xfer += $input->skip($ftype);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
 
 sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Blur_optimize_result');
-  if (defined $self->{ex}) {
-    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
-    $xfer += $self->{ex}->write($output);
-    $xfer += $output->writeFieldEnd();
+    my ($self, $output) = @_;
+    my $xfer   = 0;
+    $xfer += $output->writeStructBegin('Blur_optimize_result');
+    if (defined $self->{ex}) {
+      $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+      $xfer += $self->{ex}->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
   }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
 
 package Blur::Blur_createSnapshot_args;
 use base qw(Class::Accessor);
 Blur::Blur_createSnapshot_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};
+    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);
+    return bless ($self, $classname);
 }
 
 sub getName {
-  return 'Blur_createSnapshot_args';
-}
+    return 'Blur_createSnapshot_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)
+    my ($self, $input) = @_;
+    my $xfer  = 0;
+    my $fname;
+    my $ftype = 0;
+    my $fid   = 0;
+    $xfer += $input->readStructBegin(\$fname);
+    while (1) 
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{table});
-      } else {
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+      if ($ftype == TType::STOP) {
+        last;
       }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{name});
-      } else {
-        $xfer += $input->skip($ftype);
+      SWITCH: for($fid)
+      {
+        /^1$/ && do{        if ($ftype == TType::STRING) {
+          $xfer += $input->readString(\$self->{table});
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+        /^2$/ && do{        if ($ftype == TType::STRING) {
+          $xfer += $input->readString(\$self->{name});
+        } else {
+          $xfer += $input->skip($ftype);
+        }
+        last; };
+          $xfer += $input->skip($ftype);
       }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $input->readFieldEnd();
     }
-    $xfer += $input->readFieldEnd();
+    $xfer += $input->readStructEnd();
+    return $xfer;
   }
-  $xfer += $input->readStructEnd();
-  return

<TRUNCATED>