incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [1/9] Initial commit for the new platform work. This commit only contains working shard server logic and two primitive command implementations. DocumentCount and DocumentCountAggregator.
Date Wed, 27 Aug 2014 13:01:05 GMT
Repository: incubator-blur
Updated Branches:
  refs/heads/master b1d1baa85 -> 00821b81c


http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/94d579dd/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..2063cb0 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
@@ -12,6 +12,182 @@ use Blur::Types;
 
 # HELPER FUNCTIONS AND STRUCTURES
 
+package Blur::Blur_execute_args;
+use base qw(Class::Accessor);
+Blur::Blur_execute_args->mk_accessors( qw( table commandName arguments ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{table} = undef;
+  $self->{commandName} = undef;
+  $self->{arguments} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
+    }
+    if (defined $vals->{commandName}) {
+      $self->{commandName} = $vals->{commandName};
+    }
+    if (defined $vals->{arguments}) {
+      $self->{arguments} = $vals->{arguments};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_execute_args';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{table});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{commandName});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{arguments} = new Blur::Arguments();
+        $xfer += $self->{arguments}->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_execute_args');
+  if (defined $self->{table}) {
+    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+    $xfer += $output->writeString($self->{table});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{commandName}) {
+    $xfer += $output->writeFieldBegin('commandName', TType::STRING, 2);
+    $xfer += $output->writeString($self->{commandName});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{arguments}) {
+    $xfer += $output->writeFieldBegin('arguments', TType::STRUCT, 3);
+    $xfer += $self->{arguments}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_execute_result;
+use base qw(Class::Accessor);
+Blur::Blur_execute_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_execute_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::Response();
+        $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_execute_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_createTable_args;
 use base qw(Class::Accessor);
 Blur::Blur_createTable_args->mk_accessors( qw( tableDescriptor ) );
@@ -792,15 +968,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size206 = 0;
+          my $_size224 = 0;
           $self->{success} = [];
-          my $_etype209 = 0;
-          $xfer += $input->readListBegin(\$_etype209, \$_size206);
-          for (my $_i210 = 0; $_i210 < $_size206; ++$_i210)
+          my $_etype227 = 0;
+          $xfer += $input->readListBegin(\$_etype227, \$_size224);
+          for (my $_i228 = 0; $_i228 < $_size224; ++$_i228)
           {
-            my $elem211 = undef;
-            $xfer += $input->readString(\$elem211);
-            push(@{$self->{success}},$elem211);
+            my $elem229 = undef;
+            $xfer += $input->readString(\$elem229);
+            push(@{$self->{success}},$elem229);
           }
           $xfer += $input->readListEnd();
         }
@@ -832,9 +1008,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter212 (@{$self->{success}}) 
+        foreach my $iter230 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter212);
+          $xfer += $output->writeString($iter230);
         }
       }
       $xfer += $output->writeListEnd();
@@ -957,15 +1133,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size213 = 0;
+          my $_size231 = 0;
           $self->{success} = [];
-          my $_etype216 = 0;
-          $xfer += $input->readListBegin(\$_etype216, \$_size213);
-          for (my $_i217 = 0; $_i217 < $_size213; ++$_i217)
+          my $_etype234 = 0;
+          $xfer += $input->readListBegin(\$_etype234, \$_size231);
+          for (my $_i235 = 0; $_i235 < $_size231; ++$_i235)
           {
-            my $elem218 = undef;
-            $xfer += $input->readString(\$elem218);
-            push(@{$self->{success}},$elem218);
+            my $elem236 = undef;
+            $xfer += $input->readString(\$elem236);
+            push(@{$self->{success}},$elem236);
           }
           $xfer += $input->readListEnd();
         }
@@ -997,9 +1173,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter219 (@{$self->{success}}) 
+        foreach my $iter237 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter219);
+          $xfer += $output->writeString($iter237);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2149,30 +2325,30 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size220 = 0;
+          my $_size238 = 0;
           $self->{success} = {};
-          my $_ktype221 = 0;
-          my $_vtype222 = 0;
-          $xfer += $input->readMapBegin(\$_ktype221, \$_vtype222, \$_size220);
-          for (my $_i224 = 0; $_i224 < $_size220; ++$_i224)
+          my $_ktype239 = 0;
+          my $_vtype240 = 0;
+          $xfer += $input->readMapBegin(\$_ktype239, \$_vtype240, \$_size238);
+          for (my $_i242 = 0; $_i242 < $_size238; ++$_i242)
           {
-            my $key225 = '';
-            my $val226 = [];
-            $xfer += $input->readString(\$key225);
+            my $key243 = '';
+            my $val244 = [];
+            $xfer += $input->readString(\$key243);
             {
-              my $_size227 = 0;
-              $val226 = [];
-              my $_etype230 = 0;
-              $xfer += $input->readListBegin(\$_etype230, \$_size227);
-              for (my $_i231 = 0; $_i231 < $_size227; ++$_i231)
+              my $_size245 = 0;
+              $val244 = [];
+              my $_etype248 = 0;
+              $xfer += $input->readListBegin(\$_etype248, \$_size245);
+              for (my $_i249 = 0; $_i249 < $_size245; ++$_i249)
               {
-                my $elem232 = undef;
-                $xfer += $input->readString(\$elem232);
-                push(@{$val226},$elem232);
+                my $elem250 = undef;
+                $xfer += $input->readString(\$elem250);
+                push(@{$val244},$elem250);
               }
               $xfer += $input->readListEnd();
             }
-            $self->{success}->{$key225} = $val226;
+            $self->{success}->{$key243} = $val244;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2204,15 +2380,15 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::LIST, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter233,$viter234) = each %{$self->{success}}) 
+        while( my ($kiter251,$viter252) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter233);
+          $xfer += $output->writeString($kiter251);
           {
-            $xfer += $output->writeListBegin(TType::STRING, scalar(@{${viter234}}));
+            $xfer += $output->writeListBegin(TType::STRING, scalar(@{${viter252}}));
             {
-              foreach my $iter235 (@{${viter234}}) 
+              foreach my $iter253 (@{${viter252}}) 
               {
-                $xfer += $output->writeString($iter235);
+                $xfer += $output->writeString($iter253);
               }
             }
             $xfer += $output->writeListEnd();
@@ -2714,16 +2890,16 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size236 = 0;
+          my $_size254 = 0;
           $self->{selectors} = [];
-          my $_etype239 = 0;
-          $xfer += $input->readListBegin(\$_etype239, \$_size236);
-          for (my $_i240 = 0; $_i240 < $_size236; ++$_i240)
+          my $_etype257 = 0;
+          $xfer += $input->readListBegin(\$_etype257, \$_size254);
+          for (my $_i258 = 0; $_i258 < $_size254; ++$_i258)
           {
-            my $elem241 = undef;
-            $elem241 = new Blur::Selector();
-            $xfer += $elem241->read($input);
-            push(@{$self->{selectors}},$elem241);
+            my $elem259 = undef;
+            $elem259 = new Blur::Selector();
+            $xfer += $elem259->read($input);
+            push(@{$self->{selectors}},$elem259);
           }
           $xfer += $input->readListEnd();
         }
@@ -2753,9 +2929,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{selectors}}));
       {
-        foreach my $iter242 (@{$self->{selectors}}) 
+        foreach my $iter260 (@{$self->{selectors}}) 
         {
-          $xfer += ${iter242}->write($output);
+          $xfer += ${iter260}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2809,16 +2985,16 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size243 = 0;
+          my $_size261 = 0;
           $self->{success} = [];
-          my $_etype246 = 0;
-          $xfer += $input->readListBegin(\$_etype246, \$_size243);
-          for (my $_i247 = 0; $_i247 < $_size243; ++$_i247)
+          my $_etype264 = 0;
+          $xfer += $input->readListBegin(\$_etype264, \$_size261);
+          for (my $_i265 = 0; $_i265 < $_size261; ++$_i265)
           {
-            my $elem248 = undef;
-            $elem248 = new Blur::FetchResult();
-            $xfer += $elem248->read($input);
-            push(@{$self->{success}},$elem248);
+            my $elem266 = undef;
+            $elem266 = new Blur::FetchResult();
+            $xfer += $elem266->read($input);
+            push(@{$self->{success}},$elem266);
           }
           $xfer += $input->readListEnd();
         }
@@ -2850,9 +3026,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
       {
-        foreach my $iter249 (@{$self->{success}}) 
+        foreach my $iter267 (@{$self->{success}}) 
         {
-          $xfer += ${iter249}->write($output);
+          $xfer += ${iter267}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3167,16 +3343,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size250 = 0;
+          my $_size268 = 0;
           $self->{mutations} = [];
-          my $_etype253 = 0;
-          $xfer += $input->readListBegin(\$_etype253, \$_size250);
-          for (my $_i254 = 0; $_i254 < $_size250; ++$_i254)
+          my $_etype271 = 0;
+          $xfer += $input->readListBegin(\$_etype271, \$_size268);
+          for (my $_i272 = 0; $_i272 < $_size268; ++$_i272)
           {
-            my $elem255 = undef;
-            $elem255 = new Blur::RowMutation();
-            $xfer += $elem255->read($input);
-            push(@{$self->{mutations}},$elem255);
+            my $elem273 = undef;
+            $elem273 = new Blur::RowMutation();
+            $xfer += $elem273->read($input);
+            push(@{$self->{mutations}},$elem273);
           }
           $xfer += $input->readListEnd();
         }
@@ -3201,9 +3377,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{mutations}}));
       {
-        foreach my $iter256 (@{$self->{mutations}}) 
+        foreach my $iter274 (@{$self->{mutations}}) 
         {
-          $xfer += ${iter256}->write($output);
+          $xfer += ${iter274}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3318,16 +3494,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size257 = 0;
+          my $_size275 = 0;
           $self->{mutations} = [];
-          my $_etype260 = 0;
-          $xfer += $input->readListBegin(\$_etype260, \$_size257);
-          for (my $_i261 = 0; $_i261 < $_size257; ++$_i261)
+          my $_etype278 = 0;
+          $xfer += $input->readListBegin(\$_etype278, \$_size275);
+          for (my $_i279 = 0; $_i279 < $_size275; ++$_i279)
           {
-            my $elem262 = undef;
-            $elem262 = new Blur::RowMutation();
-            $xfer += $elem262->read($input);
-            push(@{$self->{mutations}},$elem262);
+            my $elem280 = undef;
+            $elem280 = new Blur::RowMutation();
+            $xfer += $elem280->read($input);
+            push(@{$self->{mutations}},$elem280);
           }
           $xfer += $input->readListEnd();
         }
@@ -3352,9 +3528,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{mutations}}));
       {
-        foreach my $iter263 (@{$self->{mutations}}) 
+        foreach my $iter281 (@{$self->{mutations}}) 
         {
-          $xfer += ${iter263}->write($output);
+          $xfer += ${iter281}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3681,15 +3857,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size264 = 0;
+          my $_size282 = 0;
           $self->{success} = [];
-          my $_etype267 = 0;
-          $xfer += $input->readListBegin(\$_etype267, \$_size264);
-          for (my $_i268 = 0; $_i268 < $_size264; ++$_i268)
+          my $_etype285 = 0;
+          $xfer += $input->readListBegin(\$_etype285, \$_size282);
+          for (my $_i286 = 0; $_i286 < $_size282; ++$_i286)
           {
-            my $elem269 = undef;
-            $xfer += $input->readString(\$elem269);
-            push(@{$self->{success}},$elem269);
+            my $elem287 = undef;
+            $xfer += $input->readString(\$elem287);
+            push(@{$self->{success}},$elem287);
           }
           $xfer += $input->readListEnd();
         }
@@ -3721,9 +3897,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter270 (@{$self->{success}}) 
+        foreach my $iter288 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter270);
+          $xfer += $output->writeString($iter288);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4066,15 +4242,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size271 = 0;
+          my $_size289 = 0;
           $self->{success} = [];
-          my $_etype274 = 0;
-          $xfer += $input->readListBegin(\$_etype274, \$_size271);
-          for (my $_i275 = 0; $_i275 < $_size271; ++$_i275)
+          my $_etype292 = 0;
+          $xfer += $input->readListBegin(\$_etype292, \$_size289);
+          for (my $_i293 = 0; $_i293 < $_size289; ++$_i293)
           {
-            my $elem276 = undef;
-            $xfer += $input->readString(\$elem276);
-            push(@{$self->{success}},$elem276);
+            my $elem294 = undef;
+            $xfer += $input->readString(\$elem294);
+            push(@{$self->{success}},$elem294);
           }
           $xfer += $input->readListEnd();
         }
@@ -4106,9 +4282,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter277 (@{$self->{success}}) 
+        foreach my $iter295 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter277);
+          $xfer += $output->writeString($iter295);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4402,15 +4578,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size278 = 0;
+          my $_size296 = 0;
           $self->{success} = [];
-          my $_etype281 = 0;
-          $xfer += $input->readListBegin(\$_etype281, \$_size278);
-          for (my $_i282 = 0; $_i282 < $_size278; ++$_i282)
+          my $_etype299 = 0;
+          $xfer += $input->readListBegin(\$_etype299, \$_size296);
+          for (my $_i300 = 0; $_i300 < $_size296; ++$_i300)
           {
-            my $elem283 = undef;
-            $xfer += $input->readString(\$elem283);
-            push(@{$self->{success}},$elem283);
+            my $elem301 = undef;
+            $xfer += $input->readString(\$elem301);
+            push(@{$self->{success}},$elem301);
           }
           $xfer += $input->readListEnd();
         }
@@ -4442,9 +4618,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter284 (@{$self->{success}}) 
+        foreach my $iter302 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter284);
+          $xfer += $output->writeString($iter302);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4567,15 +4743,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size285 = 0;
+          my $_size303 = 0;
           $self->{success} = [];
-          my $_etype288 = 0;
-          $xfer += $input->readListBegin(\$_etype288, \$_size285);
-          for (my $_i289 = 0; $_i289 < $_size285; ++$_i289)
+          my $_etype306 = 0;
+          $xfer += $input->readListBegin(\$_etype306, \$_size303);
+          for (my $_i307 = 0; $_i307 < $_size303; ++$_i307)
           {
-            my $elem290 = undef;
-            $xfer += $input->readString(\$elem290);
-            push(@{$self->{success}},$elem290);
+            my $elem308 = undef;
+            $xfer += $input->readString(\$elem308);
+            push(@{$self->{success}},$elem308);
           }
           $xfer += $input->readListEnd();
         }
@@ -4607,9 +4783,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter291 (@{$self->{success}}) 
+        foreach my $iter309 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter291);
+          $xfer += $output->writeString($iter309);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4714,15 +4890,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size292 = 0;
+          my $_size310 = 0;
           $self->{success} = [];
-          my $_etype295 = 0;
-          $xfer += $input->readListBegin(\$_etype295, \$_size292);
-          for (my $_i296 = 0; $_i296 < $_size292; ++$_i296)
+          my $_etype313 = 0;
+          $xfer += $input->readListBegin(\$_etype313, \$_size310);
+          for (my $_i314 = 0; $_i314 < $_size310; ++$_i314)
           {
-            my $elem297 = undef;
-            $xfer += $input->readString(\$elem297);
-            push(@{$self->{success}},$elem297);
+            my $elem315 = undef;
+            $xfer += $input->readString(\$elem315);
+            push(@{$self->{success}},$elem315);
           }
           $xfer += $input->readListEnd();
         }
@@ -4754,9 +4930,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter298 (@{$self->{success}}) 
+        foreach my $iter316 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter298);
+          $xfer += $output->writeString($iter316);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4879,18 +5055,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size299 = 0;
+          my $_size317 = 0;
           $self->{success} = {};
-          my $_ktype300 = 0;
-          my $_vtype301 = 0;
-          $xfer += $input->readMapBegin(\$_ktype300, \$_vtype301, \$_size299);
-          for (my $_i303 = 0; $_i303 < $_size299; ++$_i303)
+          my $_ktype318 = 0;
+          my $_vtype319 = 0;
+          $xfer += $input->readMapBegin(\$_ktype318, \$_vtype319, \$_size317);
+          for (my $_i321 = 0; $_i321 < $_size317; ++$_i321)
           {
-            my $key304 = '';
-            my $val305 = '';
-            $xfer += $input->readString(\$key304);
-            $xfer += $input->readString(\$val305);
-            $self->{success}->{$key304} = $val305;
+            my $key322 = '';
+            my $val323 = '';
+            $xfer += $input->readString(\$key322);
+            $xfer += $input->readString(\$val323);
+            $self->{success}->{$key322} = $val323;
           }
           $xfer += $input->readMapEnd();
         }
@@ -4922,10 +5098,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter306,$viter307) = each %{$self->{success}}) 
+        while( my ($kiter324,$viter325) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter306);
-          $xfer += $output->writeString($viter307);
+          $xfer += $output->writeString($kiter324);
+          $xfer += $output->writeString($viter325);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -5048,33 +5224,33 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size308 = 0;
+          my $_size326 = 0;
           $self->{success} = {};
-          my $_ktype309 = 0;
-          my $_vtype310 = 0;
-          $xfer += $input->readMapBegin(\$_ktype309, \$_vtype310, \$_size308);
-          for (my $_i312 = 0; $_i312 < $_size308; ++$_i312)
+          my $_ktype327 = 0;
+          my $_vtype328 = 0;
+          $xfer += $input->readMapBegin(\$_ktype327, \$_vtype328, \$_size326);
+          for (my $_i330 = 0; $_i330 < $_size326; ++$_i330)
           {
-            my $key313 = '';
-            my $val314 = [];
-            $xfer += $input->readString(\$key313);
+            my $key331 = '';
+            my $val332 = [];
+            $xfer += $input->readString(\$key331);
             {
-              my $_size315 = 0;
-              $val314 = {};
-              my $_ktype316 = 0;
-              my $_vtype317 = 0;
-              $xfer += $input->readMapBegin(\$_ktype316, \$_vtype317, \$_size315);
-              for (my $_i319 = 0; $_i319 < $_size315; ++$_i319)
+              my $_size333 = 0;
+              $val332 = {};
+              my $_ktype334 = 0;
+              my $_vtype335 = 0;
+              $xfer += $input->readMapBegin(\$_ktype334, \$_vtype335, \$_size333);
+              for (my $_i337 = 0; $_i337 < $_size333; ++$_i337)
               {
-                my $key320 = '';
-                my $val321 = 0;
-                $xfer += $input->readString(\$key320);
-                $xfer += $input->readI32(\$val321);
-                $val314->{$key320} = $val321;
+                my $key338 = '';
+                my $val339 = 0;
+                $xfer += $input->readString(\$key338);
+                $xfer += $input->readI32(\$val339);
+                $val332->{$key338} = $val339;
               }
               $xfer += $input->readMapEnd();
             }
-            $self->{success}->{$key313} = $val314;
+            $self->{success}->{$key331} = $val332;
           }
           $xfer += $input->readMapEnd();
         }
@@ -5106,16 +5282,16 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::MAP, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter322,$viter323) = each %{$self->{success}}) 
+        while( my ($kiter340,$viter341) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter322);
+          $xfer += $output->writeString($kiter340);
           {
-            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter323}}));
+            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter341}}));
             {
-              while( my ($kiter324,$viter325) = each %{${viter323}}) 
+              while( my ($kiter342,$viter343) = each %{${viter341}}) 
               {
-                $xfer += $output->writeString($kiter324);
-                $xfer += $output->writeI32($viter325);
+                $xfer += $output->writeString($kiter342);
+                $xfer += $output->writeI32($viter343);
               }
             }
             $xfer += $output->writeMapEnd();
@@ -5368,18 +5544,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size326 = 0;
+          my $_size344 = 0;
           $self->{success} = {};
-          my $_ktype327 = 0;
-          my $_vtype328 = 0;
-          $xfer += $input->readMapBegin(\$_ktype327, \$_vtype328, \$_size326);
-          for (my $_i330 = 0; $_i330 < $_size326; ++$_i330)
+          my $_ktype345 = 0;
+          my $_vtype346 = 0;
+          $xfer += $input->readMapBegin(\$_ktype345, \$_vtype346, \$_size344);
+          for (my $_i348 = 0; $_i348 < $_size344; ++$_i348)
           {
-            my $key331 = '';
-            my $val332 = '';
-            $xfer += $input->readString(\$key331);
-            $xfer += $input->readString(\$val332);
-            $self->{success}->{$key331} = $val332;
+            my $key349 = '';
+            my $val350 = '';
+            $xfer += $input->readString(\$key349);
+            $xfer += $input->readString(\$val350);
+            $self->{success}->{$key349} = $val350;
           }
           $xfer += $input->readMapEnd();
         }
@@ -5411,10 +5587,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter333,$viter334) = each %{$self->{success}}) 
+        while( my ($kiter351,$viter352) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter333);
-          $xfer += $output->writeString($viter334);
+          $xfer += $output->writeString($kiter351);
+          $xfer += $output->writeString($viter352);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -5469,15 +5645,15 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::SET) {
         {
-          my $_size335 = 0;
+          my $_size353 = 0;
           $self->{metrics} = {};
-          my $_etype338 = 0;
-          $xfer += $input->readSetBegin(\$_etype338, \$_size335);
-          for (my $_i339 = 0; $_i339 < $_size335; ++$_i339)
+          my $_etype356 = 0;
+          $xfer += $input->readSetBegin(\$_etype356, \$_size353);
+          for (my $_i357 = 0; $_i357 < $_size353; ++$_i357)
           {
-            my $elem340 = undef;
-            $xfer += $input->readString(\$elem340);
-            $self->{metrics}->{$elem340} = 1;
+            my $elem358 = undef;
+            $xfer += $input->readString(\$elem358);
+            $self->{metrics}->{$elem358} = 1;
           }
           $xfer += $input->readSetEnd();
         }
@@ -5502,9 +5678,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{metrics}}));
       {
-        foreach my $iter341 (@{$self->{metrics}})
+        foreach my $iter359 (@{$self->{metrics}})
         {
-          $xfer += $output->writeString($iter341);
+          $xfer += $output->writeString($iter359);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -5558,19 +5734,19 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size342 = 0;
+          my $_size360 = 0;
           $self->{success} = {};
-          my $_ktype343 = 0;
-          my $_vtype344 = 0;
-          $xfer += $input->readMapBegin(\$_ktype343, \$_vtype344, \$_size342);
-          for (my $_i346 = 0; $_i346 < $_size342; ++$_i346)
+          my $_ktype361 = 0;
+          my $_vtype362 = 0;
+          $xfer += $input->readMapBegin(\$_ktype361, \$_vtype362, \$_size360);
+          for (my $_i364 = 0; $_i364 < $_size360; ++$_i364)
           {
-            my $key347 = '';
-            my $val348 = new Blur::Metric();
-            $xfer += $input->readString(\$key347);
-            $val348 = new Blur::Metric();
-            $xfer += $val348->read($input);
-            $self->{success}->{$key347} = $val348;
+            my $key365 = '';
+            my $val366 = new Blur::Metric();
+            $xfer += $input->readString(\$key365);
+            $val366 = new Blur::Metric();
+            $xfer += $val366->read($input);
+            $self->{success}->{$key365} = $val366;
           }
           $xfer += $input->readMapEnd();
         }
@@ -5602,10 +5778,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter349,$viter350) = each %{$self->{success}}) 
+        while( my ($kiter367,$viter368) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter349);
-          $xfer += ${viter350}->write($output);
+          $xfer += $output->writeString($kiter367);
+          $xfer += ${viter368}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -5835,15 +6011,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size351 = 0;
+          my $_size369 = 0;
           $self->{success} = [];
-          my $_etype354 = 0;
-          $xfer += $input->readListBegin(\$_etype354, \$_size351);
-          for (my $_i355 = 0; $_i355 < $_size351; ++$_i355)
+          my $_etype372 = 0;
+          $xfer += $input->readListBegin(\$_etype372, \$_size369);
+          for (my $_i373 = 0; $_i373 < $_size369; ++$_i373)
           {
-            my $elem356 = undef;
-            $xfer += $input->readString(\$elem356);
-            push(@{$self->{success}},$elem356);
+            my $elem374 = undef;
+            $xfer += $input->readString(\$elem374);
+            push(@{$self->{success}},$elem374);
           }
           $xfer += $input->readListEnd();
         }
@@ -5875,9 +6051,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter357 (@{$self->{success}}) 
+        foreach my $iter375 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter357);
+          $xfer += $output->writeString($iter375);
         }
       }
       $xfer += $output->writeListEnd();
@@ -6000,15 +6176,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size358 = 0;
+          my $_size376 = 0;
           $self->{success} = [];
-          my $_etype361 = 0;
-          $xfer += $input->readListBegin(\$_etype361, \$_size358);
-          for (my $_i362 = 0; $_i362 < $_size358; ++$_i362)
+          my $_etype379 = 0;
+          $xfer += $input->readListBegin(\$_etype379, \$_size376);
+          for (my $_i380 = 0; $_i380 < $_size376; ++$_i380)
           {
-            my $elem363 = undef;
-            $xfer += $input->readString(\$elem363);
-            push(@{$self->{success}},$elem363);
+            my $elem381 = undef;
+            $xfer += $input->readString(\$elem381);
+            push(@{$self->{success}},$elem381);
           }
           $xfer += $input->readListEnd();
         }
@@ -6040,9 +6216,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter364 (@{$self->{success}}) 
+        foreach my $iter382 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter364);
+          $xfer += $output->writeString($iter382);
         }
       }
       $xfer += $output->writeListEnd();
@@ -6699,6 +6875,15 @@ package Blur::BlurIf;
 use strict;
 
 
+sub execute{
+  my $self = shift;
+  my $table = shift;
+  my $commandName = shift;
+  my $arguments = shift;
+
+  die 'implement interface';
+}
+
 sub createTable{
   my $self = shift;
   my $tableDescriptor = shift;
@@ -7033,6 +7218,15 @@ sub new {
   return bless($self,$classname);
 }
 
+sub execute{
+  my ($self, $request) = @_;
+
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  my $commandName = ($request->{'commandName'}) ? $request->{'commandName'} : undef;
+  my $arguments = ($request->{'arguments'}) ? $request->{'arguments'} : undef;
+  return $self->{impl}->execute($table, $commandName, $arguments);
+}
+
 sub createTable{
   my ($self, $request) = @_;
 
@@ -7368,6 +7562,58 @@ sub new {
   return bless($self,$classname);
 }
 
+sub execute{
+  my $self = shift;
+  my $table = shift;
+  my $commandName = shift;
+  my $arguments = shift;
+
+    $self->send_execute($table, $commandName, $arguments);
+  return $self->recv_execute();
+}
+
+sub send_execute{
+  my $self = shift;
+  my $table = shift;
+  my $commandName = shift;
+  my $arguments = shift;
+
+  $self->{output}->writeMessageBegin('execute', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_execute_args();
+  $args->{table} = $table;
+  $args->{commandName} = $commandName;
+  $args->{arguments} = $arguments;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_execute{
+  my $self = shift;
+
+  my $rseqid = 0;
+  my $fname;
+  my $mtype = 0;
+
+  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
+  if ($mtype == TMessageType::EXCEPTION) {
+    my $x = new TApplicationException();
+    $x->read($self->{input});
+    $self->{input}->readMessageEnd();
+    die $x;
+  }
+  my $result = new Blur::Blur_execute_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{success} ) {
+    return $result->{success};
+  }
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  die "execute failed: unknown result";
+}
 sub createTable{
   my $self = shift;
   my $tableDescriptor = shift;
@@ -9361,6 +9607,23 @@ sub process {
     return 1;
 }
 
+sub process_execute {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_execute_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_execute_result();
+    eval {
+      $result->{success} = $self->{handler}->execute($args->table, $args->commandName, $args->arguments);
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('execute', TMessageType::REPLY, $seqid);
+    $result->write($output);
+    $output->writeMessageEnd();
+    $output->getTransport()->flush();
+}
+
 sub process_createTable {
     my ($self, $seqid, $input, $output) = @_;
     my $args = new Blur::Blur_createTable_args();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/94d579dd/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm b/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
index 741f89d..da2b9d0 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
@@ -3819,4 +3819,384 @@ sub write {
   return $xfer;
 }
 
+package Blur::Value;
+use base qw(Class::Accessor);
+Blur::Value->mk_accessors( qw( stringValue intValue shortValue longValue doubleValue floatValue binaryValue booleanValue nullValue ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{stringValue} = undef;
+  $self->{intValue} = undef;
+  $self->{shortValue} = undef;
+  $self->{longValue} = undef;
+  $self->{doubleValue} = undef;
+  $self->{floatValue} = undef;
+  $self->{binaryValue} = undef;
+  $self->{booleanValue} = undef;
+  $self->{nullValue} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{stringValue}) {
+      $self->{stringValue} = $vals->{stringValue};
+    }
+    if (defined $vals->{intValue}) {
+      $self->{intValue} = $vals->{intValue};
+    }
+    if (defined $vals->{shortValue}) {
+      $self->{shortValue} = $vals->{shortValue};
+    }
+    if (defined $vals->{longValue}) {
+      $self->{longValue} = $vals->{longValue};
+    }
+    if (defined $vals->{doubleValue}) {
+      $self->{doubleValue} = $vals->{doubleValue};
+    }
+    if (defined $vals->{floatValue}) {
+      $self->{floatValue} = $vals->{floatValue};
+    }
+    if (defined $vals->{binaryValue}) {
+      $self->{binaryValue} = $vals->{binaryValue};
+    }
+    if (defined $vals->{booleanValue}) {
+      $self->{booleanValue} = $vals->{booleanValue};
+    }
+    if (defined $vals->{nullValue}) {
+      $self->{nullValue} = $vals->{nullValue};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Value';
+}
+
+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->{stringValue});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::I32) {
+        $xfer += $input->readI32(\$self->{intValue});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::I16) {
+        $xfer += $input->readI16(\$self->{shortValue});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{longValue});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^5$/ && do{      if ($ftype == TType::DOUBLE) {
+        $xfer += $input->readDouble(\$self->{doubleValue});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^6$/ && do{      if ($ftype == TType::DOUBLE) {
+        $xfer += $input->readDouble(\$self->{floatValue});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^7$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{binaryValue});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^8$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{booleanValue});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^9$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{nullValue});
+      } 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('Value');
+  if (defined $self->{stringValue}) {
+    $xfer += $output->writeFieldBegin('stringValue', TType::STRING, 1);
+    $xfer += $output->writeString($self->{stringValue});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{intValue}) {
+    $xfer += $output->writeFieldBegin('intValue', TType::I32, 2);
+    $xfer += $output->writeI32($self->{intValue});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{shortValue}) {
+    $xfer += $output->writeFieldBegin('shortValue', TType::I16, 3);
+    $xfer += $output->writeI16($self->{shortValue});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{longValue}) {
+    $xfer += $output->writeFieldBegin('longValue', TType::I64, 4);
+    $xfer += $output->writeI64($self->{longValue});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{doubleValue}) {
+    $xfer += $output->writeFieldBegin('doubleValue', TType::DOUBLE, 5);
+    $xfer += $output->writeDouble($self->{doubleValue});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{floatValue}) {
+    $xfer += $output->writeFieldBegin('floatValue', TType::DOUBLE, 6);
+    $xfer += $output->writeDouble($self->{floatValue});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{binaryValue}) {
+    $xfer += $output->writeFieldBegin('binaryValue', TType::STRING, 7);
+    $xfer += $output->writeString($self->{binaryValue});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{booleanValue}) {
+    $xfer += $output->writeFieldBegin('booleanValue', TType::BOOL, 8);
+    $xfer += $output->writeBool($self->{booleanValue});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{nullValue}) {
+    $xfer += $output->writeFieldBegin('nullValue', TType::BOOL, 9);
+    $xfer += $output->writeBool($self->{nullValue});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Response;
+use base qw(Class::Accessor);
+Blur::Response->mk_accessors( qw( shardToValue value ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{shardToValue} = undef;
+  $self->{value} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{shardToValue}) {
+      $self->{shardToValue} = $vals->{shardToValue};
+    }
+    if (defined $vals->{value}) {
+      $self->{value} = $vals->{value};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Response';
+}
+
+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::MAP) {
+        {
+          my $_size206 = 0;
+          $self->{shardToValue} = {};
+          my $_ktype207 = 0;
+          my $_vtype208 = 0;
+          $xfer += $input->readMapBegin(\$_ktype207, \$_vtype208, \$_size206);
+          for (my $_i210 = 0; $_i210 < $_size206; ++$_i210)
+          {
+            my $key211 = '';
+            my $val212 = new Blur::Value();
+            $xfer += $input->readString(\$key211);
+            $val212 = new Blur::Value();
+            $xfer += $val212->read($input);
+            $self->{shardToValue}->{$key211} = $val212;
+          }
+          $xfer += $input->readMapEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{value} = new Blur::Value();
+        $xfer += $self->{value}->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('Response');
+  if (defined $self->{shardToValue}) {
+    $xfer += $output->writeFieldBegin('shardToValue', TType::MAP, 1);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{shardToValue}}));
+      {
+        while( my ($kiter213,$viter214) = each %{$self->{shardToValue}}) 
+        {
+          $xfer += $output->writeString($kiter213);
+          $xfer += ${viter214}->write($output);
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{value}) {
+    $xfer += $output->writeFieldBegin('value', TType::STRUCT, 2);
+    $xfer += $self->{value}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Arguments;
+use base qw(Class::Accessor);
+Blur::Arguments->mk_accessors( qw( values ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{values} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{values}) {
+      $self->{values} = $vals->{values};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Arguments';
+}
+
+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::MAP) {
+        {
+          my $_size215 = 0;
+          $self->{values} = {};
+          my $_ktype216 = 0;
+          my $_vtype217 = 0;
+          $xfer += $input->readMapBegin(\$_ktype216, \$_vtype217, \$_size215);
+          for (my $_i219 = 0; $_i219 < $_size215; ++$_i219)
+          {
+            my $key220 = '';
+            my $val221 = new Blur::Value();
+            $xfer += $input->readString(\$key220);
+            $val221 = new Blur::Value();
+            $xfer += $val221->read($input);
+            $self->{values}->{$key220} = $val221;
+          }
+          $xfer += $input->readMapEnd();
+        }
+      } 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('Arguments');
+  if (defined $self->{values}) {
+    $xfer += $output->writeFieldBegin('values', TType::MAP, 1);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{values}}));
+      {
+        while( my ($kiter222,$viter223) = each %{$self->{values}}) 
+        {
+          $xfer += $output->writeString($kiter222);
+          $xfer += ${viter223}->write($output);
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
 1;

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/94d579dd/distribution/src/main/scripts/interface/gen-rb/blur.rb
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-rb/blur.rb b/distribution/src/main/scripts/interface/gen-rb/blur.rb
index 5de32dd..06d8ff5 100644
--- a/distribution/src/main/scripts/interface/gen-rb/blur.rb
+++ b/distribution/src/main/scripts/interface/gen-rb/blur.rb
@@ -12,6 +12,22 @@ module Blur
     class Client
       include ::Thrift::Client
 
+      def execute(table, commandName, arguments)
+        send_execute(table, commandName, arguments)
+        return recv_execute()
+      end
+
+      def send_execute(table, commandName, arguments)
+        send_message('execute', Execute_args, :table => table, :commandName => commandName, :arguments => arguments)
+      end
+
+      def recv_execute()
+        result = receive_message(Execute_result)
+        return result.success unless result.success.nil?
+        raise result.ex unless result.ex.nil?
+        raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'execute failed: unknown result')
+      end
+
       def createTable(tableDescriptor)
         send_createTable(tableDescriptor)
         recv_createTable()
@@ -686,6 +702,17 @@ module Blur
     class Processor
       include ::Thrift::Processor
 
+      def process_execute(seqid, iprot, oprot)
+        args = read_args(iprot, Execute_args)
+        result = Execute_result.new()
+        begin
+          result.success = @handler.execute(args.table, args.commandName, args.arguments)
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'execute', seqid)
+      end
+
       def process_createTable(seqid, iprot, oprot)
         args = read_args(iprot, CreateTable_args)
         result = CreateTable_result.new()
@@ -1160,6 +1187,44 @@ module Blur
 
     # HELPER FUNCTIONS AND STRUCTURES
 
+    class Execute_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      TABLE = 1
+      COMMANDNAME = 2
+      ARGUMENTS = 3
+
+      FIELDS = {
+        TABLE => {:type => ::Thrift::Types::STRING, :name => 'table'},
+        COMMANDNAME => {:type => ::Thrift::Types::STRING, :name => 'commandName'},
+        ARGUMENTS => {:type => ::Thrift::Types::STRUCT, :name => 'arguments', :class => ::Blur::Arguments}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class Execute_result
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      SUCCESS = 0
+      EX = 1
+
+      FIELDS = {
+        SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::Blur::Response},
+        EX => {:type => ::Thrift::Types::STRUCT, :name => 'ex', :class => ::Blur::BlurException}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
     class CreateTable_args
       include ::Thrift::Struct, ::Thrift::Struct_Union
       TABLEDESCRIPTOR = 1

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/94d579dd/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-rb/blur_types.rb b/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
index f7d65ea..f8a7a23 100644
--- a/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
+++ b/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
@@ -935,4 +935,120 @@ module Blur
     ::Thrift::Struct.generate_accessors self
   end
 
+  class Value < ::Thrift::Union
+    include ::Thrift::Struct_Union
+    class << self
+      def stringValue(val)
+        Value.new(:stringValue, val)
+      end
+
+      def intValue(val)
+        Value.new(:intValue, val)
+      end
+
+      def shortValue(val)
+        Value.new(:shortValue, val)
+      end
+
+      def longValue(val)
+        Value.new(:longValue, val)
+      end
+
+      def doubleValue(val)
+        Value.new(:doubleValue, val)
+      end
+
+      def floatValue(val)
+        Value.new(:floatValue, val)
+      end
+
+      def binaryValue(val)
+        Value.new(:binaryValue, val)
+      end
+
+      def booleanValue(val)
+        Value.new(:booleanValue, val)
+      end
+
+      def nullValue(val)
+        Value.new(:nullValue, val)
+      end
+    end
+
+    STRINGVALUE = 1
+    INTVALUE = 2
+    SHORTVALUE = 3
+    LONGVALUE = 4
+    DOUBLEVALUE = 5
+    FLOATVALUE = 6
+    BINARYVALUE = 7
+    BOOLEANVALUE = 8
+    NULLVALUE = 9
+
+    FIELDS = {
+      STRINGVALUE => {:type => ::Thrift::Types::STRING, :name => 'stringValue'},
+      INTVALUE => {:type => ::Thrift::Types::I32, :name => 'intValue'},
+      SHORTVALUE => {:type => ::Thrift::Types::I16, :name => 'shortValue'},
+      LONGVALUE => {:type => ::Thrift::Types::I64, :name => 'longValue'},
+      DOUBLEVALUE => {:type => ::Thrift::Types::DOUBLE, :name => 'doubleValue'},
+      FLOATVALUE => {:type => ::Thrift::Types::DOUBLE, :name => 'floatValue'},
+      BINARYVALUE => {:type => ::Thrift::Types::STRING, :name => 'binaryValue', :binary => true},
+      BOOLEANVALUE => {:type => ::Thrift::Types::BOOL, :name => 'booleanValue'},
+      NULLVALUE => {:type => ::Thrift::Types::BOOL, :name => 'nullValue'}
+    }
+
+    def struct_fields; FIELDS; end
+
+    def validate
+      raise(StandardError, 'Union fields are not set.') if get_set_field.nil? || get_value.nil?
+    end
+
+    ::Thrift::Union.generate_accessors self
+  end
+
+  class Response < ::Thrift::Union
+    include ::Thrift::Struct_Union
+    class << self
+      def shardToValue(val)
+        Response.new(:shardToValue, val)
+      end
+
+      def value(val)
+        Response.new(:value, val)
+      end
+    end
+
+    SHARDTOVALUE = 1
+    VALUE = 2
+
+    FIELDS = {
+      SHARDTOVALUE => {:type => ::Thrift::Types::MAP, :name => 'shardToValue', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::Value}},
+      VALUE => {:type => ::Thrift::Types::STRUCT, :name => 'value', :class => ::Blur::Value}
+    }
+
+    def struct_fields; FIELDS; end
+
+    def validate
+      raise(StandardError, 'Union fields are not set.') if get_set_field.nil? || get_value.nil?
+    end
+
+    ::Thrift::Union.generate_accessors self
+  end
+
+  class Arguments
+    include ::Thrift::Struct, ::Thrift::Struct_Union
+    VALUES = 1
+
+    FIELDS = {
+      VALUES => {:type => ::Thrift::Types::MAP, :name => 'values', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::Value}}
+    }
+
+    def struct_fields; FIELDS; end
+
+    def validate
+    end
+
+    ::Thrift::Struct.generate_accessors self
+  end
+
 end

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/94d579dd/docs/Blur.html
----------------------------------------------------------------------
diff --git a/docs/Blur.html b/docs/Blur.html
index 5e7d5a5..421abec 100644
--- a/docs/Blur.html
+++ b/docs/Blur.html
@@ -42,6 +42,7 @@ limitations under the License.
 <li><a href="cluster-setup.html">Cluster Setup</a></li>
 <li><a href="using-blur.html">Using Blur</a></li>
 <li class="active"><a href="Blur.html">Blur API</a></li>
+<li><a href="console.html">Console</a></li>
 <li><a href="site/index.html" target="_blank">Maven Site</a></li>
 <li><a href="site/apidocs/index.html" target="_blank">Javadocs</a></li>
 </ul>
@@ -93,11 +94,15 @@ limitations under the License.
 <li><a href="#Struct_Schema">Schema</a></li>
 <li><a href="#Struct_TableDescriptor">TableDescriptor</a></li>
 <li><a href="#Struct_Metric">Metric</a></li>
+<li><a href="#Struct_Value">Value</a></li>
+<li><a href="#Struct_Response">Response</a></li>
+<li><a href="#Struct_Arguments">Arguments</a></li>
 </ul>
 </li>
 <li><a href="#Svc_Blur">Service</a>
 <ul class="nav">
-<li><a href="#Fn_Blur_createTable">Table Methods</a><ul class="nav">
+<li><a href="#Fn_Blur_execute">Table Methods</a><ul class="nav">
+<li><a href="#Fn_Blur_execute">&nbsp;&nbsp;execute</a></li>
 <li><a href="#Fn_Blur_createTable">&nbsp;&nbsp;createTable</a></li>
 <li><a href="#Fn_Blur_enableTable">&nbsp;&nbsp;enableTable</a></li>
 <li><a href="#Fn_Blur_disableTable">&nbsp;&nbsp;disableTable</a></li>
@@ -633,11 +638,34 @@ be family dot column, "family.column".
 <tr><td>4</td><td>doubleMap</td><td><code>map&lt;<code>string</code>, <code>double</code>&gt;</code></td><td>map of double values emitted by the Metric.
 </td><td>default</td><td></td></tr>
 </table><br/>The Metric will hold all the information for a given Metric.
-<br/></p></section><hr/><h2 id="Services">Services</h2>
+<br/></p></section><section><div class="page-header"><h3 id="Struct_Value">Struct: Value</h3></div><p class="lead">
+<table class="table-bordered table-striped table-condensed"><thead><th>Key</th><th>Field</th><th>Type</th><th>Description</th><th>Requiredness</th><th>Default value</th></thead>
+<tr><td>1</td><td>stringValue</td><td><code>string</code></td><td></td><td>default</td><td></td></tr>
+<tr><td>2</td><td>intValue</td><td><code>i32</code></td><td></td><td>default</td><td></td></tr>
+<tr><td>3</td><td>shortValue</td><td><code>i16</code></td><td></td><td>default</td><td></td></tr>
+<tr><td>4</td><td>longValue</td><td><code>i64</code></td><td></td><td>default</td><td></td></tr>
+<tr><td>5</td><td>doubleValue</td><td><code>double</code></td><td></td><td>default</td><td></td></tr>
+<tr><td>6</td><td>floatValue</td><td><code>double</code></td><td></td><td>default</td><td></td></tr>
+<tr><td>7</td><td>binaryValue</td><td><code>binary</code></td><td></td><td>default</td><td></td></tr>
+<tr><td>8</td><td>booleanValue</td><td><code>bool</code></td><td></td><td>default</td><td></td></tr>
+<tr><td>9</td><td>nullValue</td><td><code>bool</code></td><td></td><td>default</td><td></td></tr>
+</table><br/></p></section><section><div class="page-header"><h3 id="Struct_Response">Struct: Response</h3></div><p class="lead">
+<table class="table-bordered table-striped table-condensed"><thead><th>Key</th><th>Field</th><th>Type</th><th>Description</th><th>Requiredness</th><th>Default value</th></thead>
+<tr><td>1</td><td>shardToValue</td><td><code>map&lt;<code>string</code>, <code><a href="Blur.html#Struct_Value">Value</a></code>&gt;</code></td><td></td><td>default</td><td></td></tr>
+<tr><td>2</td><td>value</td><td><code><a href="Blur.html#Struct_Value">Value</a></code></td><td></td><td>default</td><td></td></tr>
+</table><br/></p></section><section><div class="page-header"><h3 id="Struct_Arguments">Struct: Arguments</h3></div><p class="lead">
+<table class="table-bordered table-striped table-condensed"><thead><th>Key</th><th>Field</th><th>Type</th><th>Description</th><th>Requiredness</th><th>Default value</th></thead>
+<tr><td>1</td><td>values</td><td><code>map&lt;<code>string</code>, <code><a href="Blur.html#Struct_Value">Value</a></code>&gt;</code></td><td></td><td>default</td><td></td></tr>
+</table><br/></p></section><hr/><h2 id="Services">Services</h2>
 <h3 id="Svc_Blur">Service: Blur</h3>
 The Blur service API.  This API is the same for both controller servers as well as
 shards servers.  Each of the methods are documented.
-<br/><section><div class="page-header"><h4 id="Fn_Blur_createTable">Function: Blur.createTable</h4></div><p class="lead">
+<br/><section><div class="page-header"><h4 id="Fn_Blur_execute">Function: Blur.execute</h4></div><p class="lead">
+<pre><code><a href="Blur.html#Struct_Response">Response</a></code> execute(<code>string</code> table,
+<code>string</code> commandName,
+<code><a href="Blur.html#Struct_Arguments">Arguments</a></code> arguments)
+throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
+</pre></p></section><section><div class="page-header"><h4 id="Fn_Blur_createTable">Function: Blur.createTable</h4></div><p class="lead">
 <pre><code>void</code> createTable(<code><a href="Blur.html#Struct_TableDescriptor">TableDescriptor</a></code> tableDescriptor)
 throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
 </pre>Creates a table with the given TableDescriptor.


Mime
View raw message