incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [1/6] Adding the the enqueueMutate method through the Blur API stack. Still need to finish the TableQueueReader running in the controller for listening to logical queues.
Date Thu, 06 Mar 2014 21:40:41 GMT
Repository: incubator-blur
Updated Branches:
  refs/heads/apache-blur-0.2 6a517a81c -> d166c5b32


http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/8de60c97/distribution/src/main/scripts/interface/gen-js/Blur.js
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-js/Blur.js b/distribution/src/main/scripts/interface/gen-js/Blur.js
index 33059e4..123bb10 100644
--- a/distribution/src/main/scripts/interface/gen-js/Blur.js
+++ b/distribution/src/main/scripts/interface/gen-js/Blur.js
@@ -2588,6 +2588,118 @@ Blur_mutate_result.prototype.write = function(output) {
   return;
 };
 
+Blur_enqueueMutate_args = function(args) {
+  this.mutation = null;
+  if (args) {
+    if (args.mutation !== undefined) {
+      this.mutation = args.mutation;
+    }
+  }
+};
+Blur_enqueueMutate_args.prototype = {};
+Blur_enqueueMutate_args.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.mutation = new RowMutation();
+        this.mutation.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 0:
+        input.skip(ftype);
+        break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_enqueueMutate_args.prototype.write = function(output) {
+  output.writeStructBegin('Blur_enqueueMutate_args');
+  if (this.mutation !== null && this.mutation !== undefined) {
+    output.writeFieldBegin('mutation', Thrift.Type.STRUCT, 1);
+    this.mutation.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Blur_enqueueMutate_result = function(args) {
+  this.ex = null;
+  if (args instanceof BlurException) {
+    this.ex = args;
+    return;
+  }
+  if (args) {
+    if (args.ex !== undefined) {
+      this.ex = args.ex;
+    }
+  }
+};
+Blur_enqueueMutate_result.prototype = {};
+Blur_enqueueMutate_result.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.ex = new BlurException();
+        this.ex.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 0:
+        input.skip(ftype);
+        break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_enqueueMutate_result.prototype.write = function(output) {
+  output.writeStructBegin('Blur_enqueueMutate_result');
+  if (this.ex !== null && this.ex !== undefined) {
+    output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
+    this.ex.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
 Blur_mutateBatch_args = function(args) {
   this.mutations = null;
   if (args) {
@@ -2722,6 +2834,140 @@ Blur_mutateBatch_result.prototype.write = function(output) {
   return;
 };
 
+Blur_enqueueMutateBatch_args = function(args) {
+  this.mutations = null;
+  if (args) {
+    if (args.mutations !== undefined) {
+      this.mutations = args.mutations;
+    }
+  }
+};
+Blur_enqueueMutateBatch_args.prototype = {};
+Blur_enqueueMutateBatch_args.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.LIST) {
+        var _size290 = 0;
+        var _rtmp3294;
+        this.mutations = [];
+        var _etype293 = 0;
+        _rtmp3294 = input.readListBegin();
+        _etype293 = _rtmp3294.etype;
+        _size290 = _rtmp3294.size;
+        for (var _i295 = 0; _i295 < _size290; ++_i295)
+        {
+          var elem296 = null;
+          elem296 = new RowMutation();
+          elem296.read(input);
+          this.mutations.push(elem296);
+        }
+        input.readListEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 0:
+        input.skip(ftype);
+        break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_enqueueMutateBatch_args.prototype.write = function(output) {
+  output.writeStructBegin('Blur_enqueueMutateBatch_args');
+  if (this.mutations !== null && this.mutations !== undefined) {
+    output.writeFieldBegin('mutations', Thrift.Type.LIST, 1);
+    output.writeListBegin(Thrift.Type.STRUCT, this.mutations.length);
+    for (var iter297 in this.mutations)
+    {
+      if (this.mutations.hasOwnProperty(iter297))
+      {
+        iter297 = this.mutations[iter297];
+        iter297.write(output);
+      }
+    }
+    output.writeListEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Blur_enqueueMutateBatch_result = function(args) {
+  this.ex = null;
+  if (args instanceof BlurException) {
+    this.ex = args;
+    return;
+  }
+  if (args) {
+    if (args.ex !== undefined) {
+      this.ex = args.ex;
+    }
+  }
+};
+Blur_enqueueMutateBatch_result.prototype = {};
+Blur_enqueueMutateBatch_result.prototype.read = function(input) {
+  input.readStructBegin();
+  while (true)
+  {
+    var ret = input.readFieldBegin();
+    var fname = ret.fname;
+    var ftype = ret.ftype;
+    var fid = ret.fid;
+    if (ftype == Thrift.Type.STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.ex = new BlurException();
+        this.ex.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 0:
+        input.skip(ftype);
+        break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_enqueueMutateBatch_result.prototype.write = function(output) {
+  output.writeStructBegin('Blur_enqueueMutateBatch_result');
+  if (this.ex !== null && this.ex !== undefined) {
+    output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
+    this.ex.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
 Blur_cancelQuery_args = function(args) {
   this.table = null;
   this.uuid = null;
@@ -2931,18 +3177,18 @@ Blur_queryStatusIdList_result.prototype.read = function(input) {
     {
       case 0:
       if (ftype == Thrift.Type.LIST) {
-        var _size290 = 0;
-        var _rtmp3294;
+        var _size298 = 0;
+        var _rtmp3302;
         this.success = [];
-        var _etype293 = 0;
-        _rtmp3294 = input.readListBegin();
-        _etype293 = _rtmp3294.etype;
-        _size290 = _rtmp3294.size;
-        for (var _i295 = 0; _i295 < _size290; ++_i295)
+        var _etype301 = 0;
+        _rtmp3302 = input.readListBegin();
+        _etype301 = _rtmp3302.etype;
+        _size298 = _rtmp3302.size;
+        for (var _i303 = 0; _i303 < _size298; ++_i303)
         {
-          var elem296 = null;
-          elem296 = input.readString().value;
-          this.success.push(elem296);
+          var elem304 = null;
+          elem304 = input.readString().value;
+          this.success.push(elem304);
         }
         input.readListEnd();
       } else {
@@ -2971,12 +3217,12 @@ Blur_queryStatusIdList_result.prototype.write = function(output) {
   if (this.success !== null && this.success !== undefined) {
     output.writeFieldBegin('success', Thrift.Type.LIST, 0);
     output.writeListBegin(Thrift.Type.STRING, this.success.length);
-    for (var iter297 in this.success)
+    for (var iter305 in this.success)
     {
-      if (this.success.hasOwnProperty(iter297))
+      if (this.success.hasOwnProperty(iter305))
       {
-        iter297 = this.success[iter297];
-        output.writeString(iter297);
+        iter305 = this.success[iter305];
+        output.writeString(iter305);
       }
     }
     output.writeListEnd();
@@ -3276,18 +3522,18 @@ Blur_terms_result.prototype.read = function(input) {
     {
       case 0:
       if (ftype == Thrift.Type.LIST) {
-        var _size298 = 0;
-        var _rtmp3302;
+        var _size306 = 0;
+        var _rtmp3310;
         this.success = [];
-        var _etype301 = 0;
-        _rtmp3302 = input.readListBegin();
-        _etype301 = _rtmp3302.etype;
-        _size298 = _rtmp3302.size;
-        for (var _i303 = 0; _i303 < _size298; ++_i303)
+        var _etype309 = 0;
+        _rtmp3310 = input.readListBegin();
+        _etype309 = _rtmp3310.etype;
+        _size306 = _rtmp3310.size;
+        for (var _i311 = 0; _i311 < _size306; ++_i311)
         {
-          var elem304 = null;
-          elem304 = input.readString().value;
-          this.success.push(elem304);
+          var elem312 = null;
+          elem312 = input.readString().value;
+          this.success.push(elem312);
         }
         input.readListEnd();
       } else {
@@ -3316,12 +3562,12 @@ Blur_terms_result.prototype.write = function(output) {
   if (this.success !== null && this.success !== undefined) {
     output.writeFieldBegin('success', Thrift.Type.LIST, 0);
     output.writeListBegin(Thrift.Type.STRING, this.success.length);
-    for (var iter305 in this.success)
+    for (var iter313 in this.success)
     {
-      if (this.success.hasOwnProperty(iter305))
+      if (this.success.hasOwnProperty(iter313))
       {
-        iter305 = this.success[iter305];
-        output.writeString(iter305);
+        iter313 = this.success[iter313];
+        output.writeString(iter313);
       }
     }
     output.writeListEnd();
@@ -3566,18 +3812,18 @@ Blur_shardClusterList_result.prototype.read = function(input) {
     {
       case 0:
       if (ftype == Thrift.Type.LIST) {
-        var _size306 = 0;
-        var _rtmp3310;
+        var _size314 = 0;
+        var _rtmp3318;
         this.success = [];
-        var _etype309 = 0;
-        _rtmp3310 = input.readListBegin();
-        _etype309 = _rtmp3310.etype;
-        _size306 = _rtmp3310.size;
-        for (var _i311 = 0; _i311 < _size306; ++_i311)
+        var _etype317 = 0;
+        _rtmp3318 = input.readListBegin();
+        _etype317 = _rtmp3318.etype;
+        _size314 = _rtmp3318.size;
+        for (var _i319 = 0; _i319 < _size314; ++_i319)
         {
-          var elem312 = null;
-          elem312 = input.readString().value;
-          this.success.push(elem312);
+          var elem320 = null;
+          elem320 = input.readString().value;
+          this.success.push(elem320);
         }
         input.readListEnd();
       } else {
@@ -3606,12 +3852,12 @@ Blur_shardClusterList_result.prototype.write = function(output) {
   if (this.success !== null && this.success !== undefined) {
     output.writeFieldBegin('success', Thrift.Type.LIST, 0);
     output.writeListBegin(Thrift.Type.STRING, this.success.length);
-    for (var iter313 in this.success)
+    for (var iter321 in this.success)
     {
-      if (this.success.hasOwnProperty(iter313))
+      if (this.success.hasOwnProperty(iter321))
       {
-        iter313 = this.success[iter313];
-        output.writeString(iter313);
+        iter321 = this.success[iter321];
+        output.writeString(iter321);
       }
     }
     output.writeListEnd();
@@ -3712,18 +3958,18 @@ Blur_shardServerList_result.prototype.read = function(input) {
     {
       case 0:
       if (ftype == Thrift.Type.LIST) {
-        var _size314 = 0;
-        var _rtmp3318;
+        var _size322 = 0;
+        var _rtmp3326;
         this.success = [];
-        var _etype317 = 0;
-        _rtmp3318 = input.readListBegin();
-        _etype317 = _rtmp3318.etype;
-        _size314 = _rtmp3318.size;
-        for (var _i319 = 0; _i319 < _size314; ++_i319)
+        var _etype325 = 0;
+        _rtmp3326 = input.readListBegin();
+        _etype325 = _rtmp3326.etype;
+        _size322 = _rtmp3326.size;
+        for (var _i327 = 0; _i327 < _size322; ++_i327)
         {
-          var elem320 = null;
-          elem320 = input.readString().value;
-          this.success.push(elem320);
+          var elem328 = null;
+          elem328 = input.readString().value;
+          this.success.push(elem328);
         }
         input.readListEnd();
       } else {
@@ -3752,12 +3998,12 @@ Blur_shardServerList_result.prototype.write = function(output) {
   if (this.success !== null && this.success !== undefined) {
     output.writeFieldBegin('success', Thrift.Type.LIST, 0);
     output.writeListBegin(Thrift.Type.STRING, this.success.length);
-    for (var iter321 in this.success)
+    for (var iter329 in this.success)
     {
-      if (this.success.hasOwnProperty(iter321))
+      if (this.success.hasOwnProperty(iter329))
       {
-        iter321 = this.success[iter321];
-        output.writeString(iter321);
+        iter329 = this.success[iter329];
+        output.writeString(iter329);
       }
     }
     output.writeListEnd();
@@ -3833,18 +4079,18 @@ Blur_controllerServerList_result.prototype.read = function(input) {
     {
       case 0:
       if (ftype == Thrift.Type.LIST) {
-        var _size322 = 0;
-        var _rtmp3326;
+        var _size330 = 0;
+        var _rtmp3334;
         this.success = [];
-        var _etype325 = 0;
-        _rtmp3326 = input.readListBegin();
-        _etype325 = _rtmp3326.etype;
-        _size322 = _rtmp3326.size;
-        for (var _i327 = 0; _i327 < _size322; ++_i327)
+        var _etype333 = 0;
+        _rtmp3334 = input.readListBegin();
+        _etype333 = _rtmp3334.etype;
+        _size330 = _rtmp3334.size;
+        for (var _i335 = 0; _i335 < _size330; ++_i335)
         {
-          var elem328 = null;
-          elem328 = input.readString().value;
-          this.success.push(elem328);
+          var elem336 = null;
+          elem336 = input.readString().value;
+          this.success.push(elem336);
         }
         input.readListEnd();
       } else {
@@ -3873,12 +4119,12 @@ Blur_controllerServerList_result.prototype.write = function(output) {
   if (this.success !== null && this.success !== undefined) {
     output.writeFieldBegin('success', Thrift.Type.LIST, 0);
     output.writeListBegin(Thrift.Type.STRING, this.success.length);
-    for (var iter329 in this.success)
+    for (var iter337 in this.success)
     {
-      if (this.success.hasOwnProperty(iter329))
+      if (this.success.hasOwnProperty(iter337))
       {
-        iter329 = this.success[iter329];
-        output.writeString(iter329);
+        iter337 = this.success[iter337];
+        output.writeString(iter337);
       }
     }
     output.writeListEnd();
@@ -3979,27 +4225,27 @@ Blur_shardServerLayout_result.prototype.read = function(input) {
     {
       case 0:
       if (ftype == Thrift.Type.MAP) {
-        var _size330 = 0;
-        var _rtmp3334;
+        var _size338 = 0;
+        var _rtmp3342;
         this.success = {};
-        var _ktype331 = 0;
-        var _vtype332 = 0;
-        _rtmp3334 = input.readMapBegin();
-        _ktype331 = _rtmp3334.ktype;
-        _vtype332 = _rtmp3334.vtype;
-        _size330 = _rtmp3334.size;
-        for (var _i335 = 0; _i335 < _size330; ++_i335)
+        var _ktype339 = 0;
+        var _vtype340 = 0;
+        _rtmp3342 = input.readMapBegin();
+        _ktype339 = _rtmp3342.ktype;
+        _vtype340 = _rtmp3342.vtype;
+        _size338 = _rtmp3342.size;
+        for (var _i343 = 0; _i343 < _size338; ++_i343)
         {
-          if (_i335 > 0 ) {
+          if (_i343 > 0 ) {
             if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
               input.rstack.pop();
             }
           }
-          var key336 = null;
-          var val337 = null;
-          key336 = input.readString().value;
-          val337 = input.readString().value;
-          this.success[key336] = val337;
+          var key344 = null;
+          var val345 = null;
+          key344 = input.readString().value;
+          val345 = input.readString().value;
+          this.success[key344] = val345;
         }
         input.readMapEnd();
       } else {
@@ -4028,13 +4274,13 @@ Blur_shardServerLayout_result.prototype.write = function(output) {
   if (this.success !== null && this.success !== undefined) {
     output.writeFieldBegin('success', Thrift.Type.MAP, 0);
     output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(this.success));
-    for (var kiter338 in this.success)
+    for (var kiter346 in this.success)
     {
-      if (this.success.hasOwnProperty(kiter338))
+      if (this.success.hasOwnProperty(kiter346))
       {
-        var viter339 = this.success[kiter338];
-        output.writeString(kiter338);
-        output.writeString(viter339);
+        var viter347 = this.success[kiter346];
+        output.writeString(kiter346);
+        output.writeString(viter347);
       }
     }
     output.writeMapEnd();
@@ -4135,49 +4381,49 @@ Blur_shardServerLayoutState_result.prototype.read = function(input) {
     {
       case 0:
       if (ftype == Thrift.Type.MAP) {
-        var _size340 = 0;
-        var _rtmp3344;
+        var _size348 = 0;
+        var _rtmp3352;
         this.success = {};
-        var _ktype341 = 0;
-        var _vtype342 = 0;
-        _rtmp3344 = input.readMapBegin();
-        _ktype341 = _rtmp3344.ktype;
-        _vtype342 = _rtmp3344.vtype;
-        _size340 = _rtmp3344.size;
-        for (var _i345 = 0; _i345 < _size340; ++_i345)
+        var _ktype349 = 0;
+        var _vtype350 = 0;
+        _rtmp3352 = input.readMapBegin();
+        _ktype349 = _rtmp3352.ktype;
+        _vtype350 = _rtmp3352.vtype;
+        _size348 = _rtmp3352.size;
+        for (var _i353 = 0; _i353 < _size348; ++_i353)
         {
-          if (_i345 > 0 ) {
+          if (_i353 > 0 ) {
             if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
               input.rstack.pop();
             }
           }
-          var key346 = null;
-          var val347 = null;
-          key346 = input.readString().value;
-          var _size348 = 0;
-          var _rtmp3352;
-          val347 = {};
-          var _ktype349 = 0;
-          var _vtype350 = 0;
-          _rtmp3352 = input.readMapBegin();
-          _ktype349 = _rtmp3352.ktype;
-          _vtype350 = _rtmp3352.vtype;
-          _size348 = _rtmp3352.size;
-          for (var _i353 = 0; _i353 < _size348; ++_i353)
+          var key354 = null;
+          var val355 = null;
+          key354 = input.readString().value;
+          var _size356 = 0;
+          var _rtmp3360;
+          val355 = {};
+          var _ktype357 = 0;
+          var _vtype358 = 0;
+          _rtmp3360 = input.readMapBegin();
+          _ktype357 = _rtmp3360.ktype;
+          _vtype358 = _rtmp3360.vtype;
+          _size356 = _rtmp3360.size;
+          for (var _i361 = 0; _i361 < _size356; ++_i361)
           {
-            if (_i353 > 0 ) {
+            if (_i361 > 0 ) {
               if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
                 input.rstack.pop();
               }
             }
-            var key354 = null;
-            var val355 = null;
-            key354 = input.readString().value;
-            val355 = input.readI32().value;
-            val347[key354] = val355;
+            var key362 = null;
+            var val363 = null;
+            key362 = input.readString().value;
+            val363 = input.readI32().value;
+            val355[key362] = val363;
           }
           input.readMapEnd();
-          this.success[key346] = val347;
+          this.success[key354] = val355;
         }
         input.readMapEnd();
       } else {
@@ -4206,20 +4452,20 @@ Blur_shardServerLayoutState_result.prototype.write = function(output) {
   if (this.success !== null && this.success !== undefined) {
     output.writeFieldBegin('success', Thrift.Type.MAP, 0);
     output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.MAP, Thrift.objectLength(this.success));
-    for (var kiter356 in this.success)
+    for (var kiter364 in this.success)
     {
-      if (this.success.hasOwnProperty(kiter356))
+      if (this.success.hasOwnProperty(kiter364))
       {
-        var viter357 = this.success[kiter356];
-        output.writeString(kiter356);
-        output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.I32, Thrift.objectLength(viter357));
-        for (var kiter358 in viter357)
+        var viter365 = this.success[kiter364];
+        output.writeString(kiter364);
+        output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.I32, Thrift.objectLength(viter365));
+        for (var kiter366 in viter365)
         {
-          if (viter357.hasOwnProperty(kiter358))
+          if (viter365.hasOwnProperty(kiter366))
           {
-            var viter359 = viter357[kiter358];
-            output.writeString(kiter358);
-            output.writeI32(viter359);
+            var viter367 = viter365[kiter366];
+            output.writeString(kiter366);
+            output.writeI32(viter367);
           }
         }
         output.writeMapEnd();
@@ -4422,27 +4668,27 @@ Blur_configuration_result.prototype.read = function(input) {
     {
       case 0:
       if (ftype == Thrift.Type.MAP) {
-        var _size360 = 0;
-        var _rtmp3364;
+        var _size368 = 0;
+        var _rtmp3372;
         this.success = {};
-        var _ktype361 = 0;
-        var _vtype362 = 0;
-        _rtmp3364 = input.readMapBegin();
-        _ktype361 = _rtmp3364.ktype;
-        _vtype362 = _rtmp3364.vtype;
-        _size360 = _rtmp3364.size;
-        for (var _i365 = 0; _i365 < _size360; ++_i365)
+        var _ktype369 = 0;
+        var _vtype370 = 0;
+        _rtmp3372 = input.readMapBegin();
+        _ktype369 = _rtmp3372.ktype;
+        _vtype370 = _rtmp3372.vtype;
+        _size368 = _rtmp3372.size;
+        for (var _i373 = 0; _i373 < _size368; ++_i373)
         {
-          if (_i365 > 0 ) {
+          if (_i373 > 0 ) {
             if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
               input.rstack.pop();
             }
           }
-          var key366 = null;
-          var val367 = null;
-          key366 = input.readString().value;
-          val367 = input.readString().value;
-          this.success[key366] = val367;
+          var key374 = null;
+          var val375 = null;
+          key374 = input.readString().value;
+          val375 = input.readString().value;
+          this.success[key374] = val375;
         }
         input.readMapEnd();
       } else {
@@ -4471,13 +4717,13 @@ Blur_configuration_result.prototype.write = function(output) {
   if (this.success !== null && this.success !== undefined) {
     output.writeFieldBegin('success', Thrift.Type.MAP, 0);
     output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(this.success));
-    for (var kiter368 in this.success)
+    for (var kiter376 in this.success)
     {
-      if (this.success.hasOwnProperty(kiter368))
+      if (this.success.hasOwnProperty(kiter376))
       {
-        var viter369 = this.success[kiter368];
-        output.writeString(kiter368);
-        output.writeString(viter369);
+        var viter377 = this.success[kiter376];
+        output.writeString(kiter376);
+        output.writeString(viter377);
       }
     }
     output.writeMapEnd();
@@ -4517,18 +4763,18 @@ Blur_metrics_args.prototype.read = function(input) {
     {
       case 1:
       if (ftype == Thrift.Type.SET) {
-        var _size370 = 0;
-        var _rtmp3374;
+        var _size378 = 0;
+        var _rtmp3382;
         this.metrics = [];
-        var _etype373 = 0;
-        _rtmp3374 = input.readSetBegin();
-        _etype373 = _rtmp3374.etype;
-        _size370 = _rtmp3374.size;
-        for (var _i375 = 0; _i375 < _size370; ++_i375)
+        var _etype381 = 0;
+        _rtmp3382 = input.readSetBegin();
+        _etype381 = _rtmp3382.etype;
+        _size378 = _rtmp3382.size;
+        for (var _i383 = 0; _i383 < _size378; ++_i383)
         {
-          var elem376 = null;
-          elem376 = input.readString().value;
-          this.metrics.push(elem376);
+          var elem384 = null;
+          elem384 = input.readString().value;
+          this.metrics.push(elem384);
         }
         input.readSetEnd();
       } else {
@@ -4552,12 +4798,12 @@ Blur_metrics_args.prototype.write = function(output) {
   if (this.metrics !== null && this.metrics !== undefined) {
     output.writeFieldBegin('metrics', Thrift.Type.SET, 1);
     output.writeSetBegin(Thrift.Type.STRING, this.metrics.length);
-    for (var iter377 in this.metrics)
+    for (var iter385 in this.metrics)
     {
-      if (this.metrics.hasOwnProperty(iter377))
+      if (this.metrics.hasOwnProperty(iter385))
       {
-        iter377 = this.metrics[iter377];
-        output.writeString(iter377);
+        iter385 = this.metrics[iter385];
+        output.writeString(iter385);
       }
     }
     output.writeSetEnd();
@@ -4600,28 +4846,28 @@ Blur_metrics_result.prototype.read = function(input) {
     {
       case 0:
       if (ftype == Thrift.Type.MAP) {
-        var _size378 = 0;
-        var _rtmp3382;
+        var _size386 = 0;
+        var _rtmp3390;
         this.success = {};
-        var _ktype379 = 0;
-        var _vtype380 = 0;
-        _rtmp3382 = input.readMapBegin();
-        _ktype379 = _rtmp3382.ktype;
-        _vtype380 = _rtmp3382.vtype;
-        _size378 = _rtmp3382.size;
-        for (var _i383 = 0; _i383 < _size378; ++_i383)
+        var _ktype387 = 0;
+        var _vtype388 = 0;
+        _rtmp3390 = input.readMapBegin();
+        _ktype387 = _rtmp3390.ktype;
+        _vtype388 = _rtmp3390.vtype;
+        _size386 = _rtmp3390.size;
+        for (var _i391 = 0; _i391 < _size386; ++_i391)
         {
-          if (_i383 > 0 ) {
+          if (_i391 > 0 ) {
             if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
               input.rstack.pop();
             }
           }
-          var key384 = null;
-          var val385 = null;
-          key384 = input.readString().value;
-          val385 = new Metric();
-          val385.read(input);
-          this.success[key384] = val385;
+          var key392 = null;
+          var val393 = null;
+          key392 = input.readString().value;
+          val393 = new Metric();
+          val393.read(input);
+          this.success[key392] = val393;
         }
         input.readMapEnd();
       } else {
@@ -4650,13 +4896,13 @@ Blur_metrics_result.prototype.write = function(output) {
   if (this.success !== null && this.success !== undefined) {
     output.writeFieldBegin('success', Thrift.Type.MAP, 0);
     output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRUCT, Thrift.objectLength(this.success));
-    for (var kiter386 in this.success)
+    for (var kiter394 in this.success)
     {
-      if (this.success.hasOwnProperty(kiter386))
+      if (this.success.hasOwnProperty(kiter394))
       {
-        var viter387 = this.success[kiter386];
-        output.writeString(kiter386);
-        viter387.write(output);
+        var viter395 = this.success[kiter394];
+        output.writeString(kiter394);
+        viter395.write(output);
       }
     }
     output.writeMapEnd();
@@ -4826,18 +5072,18 @@ Blur_traceList_result.prototype.read = function(input) {
     {
       case 0:
       if (ftype == Thrift.Type.LIST) {
-        var _size388 = 0;
-        var _rtmp3392;
+        var _size396 = 0;
+        var _rtmp3400;
         this.success = [];
-        var _etype391 = 0;
-        _rtmp3392 = input.readListBegin();
-        _etype391 = _rtmp3392.etype;
-        _size388 = _rtmp3392.size;
-        for (var _i393 = 0; _i393 < _size388; ++_i393)
+        var _etype399 = 0;
+        _rtmp3400 = input.readListBegin();
+        _etype399 = _rtmp3400.etype;
+        _size396 = _rtmp3400.size;
+        for (var _i401 = 0; _i401 < _size396; ++_i401)
         {
-          var elem394 = null;
-          elem394 = input.readString().value;
-          this.success.push(elem394);
+          var elem402 = null;
+          elem402 = input.readString().value;
+          this.success.push(elem402);
         }
         input.readListEnd();
       } else {
@@ -4866,12 +5112,12 @@ Blur_traceList_result.prototype.write = function(output) {
   if (this.success !== null && this.success !== undefined) {
     output.writeFieldBegin('success', Thrift.Type.LIST, 0);
     output.writeListBegin(Thrift.Type.STRING, this.success.length);
-    for (var iter395 in this.success)
+    for (var iter403 in this.success)
     {
-      if (this.success.hasOwnProperty(iter395))
+      if (this.success.hasOwnProperty(iter403))
       {
-        iter395 = this.success[iter395];
-        output.writeString(iter395);
+        iter403 = this.success[iter403];
+        output.writeString(iter403);
       }
     }
     output.writeListEnd();
@@ -4972,18 +5218,18 @@ Blur_traceRequestList_result.prototype.read = function(input) {
     {
       case 0:
       if (ftype == Thrift.Type.LIST) {
-        var _size396 = 0;
-        var _rtmp3400;
+        var _size404 = 0;
+        var _rtmp3408;
         this.success = [];
-        var _etype399 = 0;
-        _rtmp3400 = input.readListBegin();
-        _etype399 = _rtmp3400.etype;
-        _size396 = _rtmp3400.size;
-        for (var _i401 = 0; _i401 < _size396; ++_i401)
+        var _etype407 = 0;
+        _rtmp3408 = input.readListBegin();
+        _etype407 = _rtmp3408.etype;
+        _size404 = _rtmp3408.size;
+        for (var _i409 = 0; _i409 < _size404; ++_i409)
         {
-          var elem402 = null;
-          elem402 = input.readString().value;
-          this.success.push(elem402);
+          var elem410 = null;
+          elem410 = input.readString().value;
+          this.success.push(elem410);
         }
         input.readListEnd();
       } else {
@@ -5012,12 +5258,12 @@ Blur_traceRequestList_result.prototype.write = function(output) {
   if (this.success !== null && this.success !== undefined) {
     output.writeFieldBegin('success', Thrift.Type.LIST, 0);
     output.writeListBegin(Thrift.Type.STRING, this.success.length);
-    for (var iter403 in this.success)
+    for (var iter411 in this.success)
     {
-      if (this.success.hasOwnProperty(iter403))
+      if (this.success.hasOwnProperty(iter411))
       {
-        iter403 = this.success[iter403];
-        output.writeString(iter403);
+        iter411 = this.success[iter411];
+        output.writeString(iter411);
       }
     }
     output.writeListEnd();
@@ -6252,6 +6498,40 @@ BlurClient.prototype.recv_mutate = function() {
   }
   return;
 };
+BlurClient.prototype.enqueueMutate = function(mutation) {
+  this.send_enqueueMutate(mutation);
+  this.recv_enqueueMutate();
+};
+
+BlurClient.prototype.send_enqueueMutate = function(mutation) {
+  this.output.writeMessageBegin('enqueueMutate', Thrift.MessageType.CALL, this.seqid);
+  var args = new Blur_enqueueMutate_args();
+  args.mutation = mutation;
+  args.write(this.output);
+  this.output.writeMessageEnd();
+  return this.output.getTransport().flush();
+};
+
+BlurClient.prototype.recv_enqueueMutate = function() {
+  var ret = this.input.readMessageBegin();
+  var fname = ret.fname;
+  var mtype = ret.mtype;
+  var rseqid = ret.rseqid;
+  if (mtype == Thrift.MessageType.EXCEPTION) {
+    var x = new Thrift.TApplicationException();
+    x.read(this.input);
+    this.input.readMessageEnd();
+    throw x;
+  }
+  var result = new Blur_enqueueMutate_result();
+  result.read(this.input);
+  this.input.readMessageEnd();
+
+  if (null !== result.ex) {
+    throw result.ex;
+  }
+  return;
+};
 BlurClient.prototype.mutateBatch = function(mutations) {
   this.send_mutateBatch(mutations);
   this.recv_mutateBatch();
@@ -6286,6 +6566,40 @@ BlurClient.prototype.recv_mutateBatch = function() {
   }
   return;
 };
+BlurClient.prototype.enqueueMutateBatch = function(mutations) {
+  this.send_enqueueMutateBatch(mutations);
+  this.recv_enqueueMutateBatch();
+};
+
+BlurClient.prototype.send_enqueueMutateBatch = function(mutations) {
+  this.output.writeMessageBegin('enqueueMutateBatch', Thrift.MessageType.CALL, this.seqid);
+  var args = new Blur_enqueueMutateBatch_args();
+  args.mutations = mutations;
+  args.write(this.output);
+  this.output.writeMessageEnd();
+  return this.output.getTransport().flush();
+};
+
+BlurClient.prototype.recv_enqueueMutateBatch = function() {
+  var ret = this.input.readMessageBegin();
+  var fname = ret.fname;
+  var mtype = ret.mtype;
+  var rseqid = ret.rseqid;
+  if (mtype == Thrift.MessageType.EXCEPTION) {
+    var x = new Thrift.TApplicationException();
+    x.read(this.input);
+    this.input.readMessageEnd();
+    throw x;
+  }
+  var result = new Blur_enqueueMutateBatch_result();
+  result.read(this.input);
+  this.input.readMessageEnd();
+
+  if (null !== result.ex) {
+    throw result.ex;
+  }
+  return;
+};
 BlurClient.prototype.cancelQuery = function(table, uuid) {
   this.send_cancelQuery(table, uuid);
   this.recv_cancelQuery();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/8de60c97/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 b46a420..800a866 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
@@ -2999,6 +2999,136 @@ sub write {
   return $xfer;
 }
 
+package Blur::Blur_enqueueMutate_args;
+use base qw(Class::Accessor);
+Blur::Blur_enqueueMutate_args->mk_accessors( qw( mutation ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{mutation} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{mutation}) {
+      $self->{mutation} = $vals->{mutation};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_enqueueMutate_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::STRUCT) {
+        $self->{mutation} = new Blur::RowMutation();
+        $xfer += $self->{mutation}->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_enqueueMutate_args');
+  if (defined $self->{mutation}) {
+    $xfer += $output->writeFieldBegin('mutation', TType::STRUCT, 1);
+    $xfer += $self->{mutation}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_enqueueMutate_result;
+use base qw(Class::Accessor);
+Blur::Blur_enqueueMutate_result->mk_accessors( qw( ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{ex} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{ex}) {
+      $self->{ex} = $vals->{ex};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_enqueueMutate_result';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{ex} = new Blur::BlurException();
+        $xfer += $self->{ex}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_enqueueMutate_result');
+  if (defined $self->{ex}) {
+    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+    $xfer += $self->{ex}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
 package Blur::Blur_mutateBatch_args;
 use base qw(Class::Accessor);
 Blur::Blur_mutateBatch_args->mk_accessors( qw( mutations ) );
@@ -3150,6 +3280,157 @@ sub write {
   return $xfer;
 }
 
+package Blur::Blur_enqueueMutateBatch_args;
+use base qw(Class::Accessor);
+Blur::Blur_enqueueMutateBatch_args->mk_accessors( qw( mutations ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{mutations} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{mutations}) {
+      $self->{mutations} = $vals->{mutations};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_enqueueMutateBatch_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::LIST) {
+        {
+          my $_size257 = 0;
+          $self->{mutations} = [];
+          my $_etype260 = 0;
+          $xfer += $input->readListBegin(\$_etype260, \$_size257);
+          for (my $_i261 = 0; $_i261 < $_size257; ++$_i261)
+          {
+            my $elem262 = undef;
+            $elem262 = new Blur::RowMutation();
+            $xfer += $elem262->read($input);
+            push(@{$self->{mutations}},$elem262);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } 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_enqueueMutateBatch_args');
+  if (defined $self->{mutations}) {
+    $xfer += $output->writeFieldBegin('mutations', TType::LIST, 1);
+    {
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{mutations}}));
+      {
+        foreach my $iter263 (@{$self->{mutations}}) 
+        {
+          $xfer += ${iter263}->write($output);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_enqueueMutateBatch_result;
+use base qw(Class::Accessor);
+Blur::Blur_enqueueMutateBatch_result->mk_accessors( qw( ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{ex} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{ex}) {
+      $self->{ex} = $vals->{ex};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_enqueueMutateBatch_result';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{ex} = new Blur::BlurException();
+        $xfer += $self->{ex}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_enqueueMutateBatch_result');
+  if (defined $self->{ex}) {
+    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+    $xfer += $self->{ex}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
 package Blur::Blur_cancelQuery_args;
 use base qw(Class::Accessor);
 Blur::Blur_cancelQuery_args->mk_accessors( qw( table uuid ) );
@@ -3400,15 +3681,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size257 = 0;
+          my $_size264 = 0;
           $self->{success} = [];
-          my $_etype260 = 0;
-          $xfer += $input->readListBegin(\$_etype260, \$_size257);
-          for (my $_i261 = 0; $_i261 < $_size257; ++$_i261)
+          my $_etype267 = 0;
+          $xfer += $input->readListBegin(\$_etype267, \$_size264);
+          for (my $_i268 = 0; $_i268 < $_size264; ++$_i268)
           {
-            my $elem262 = undef;
-            $xfer += $input->readString(\$elem262);
-            push(@{$self->{success}},$elem262);
+            my $elem269 = undef;
+            $xfer += $input->readString(\$elem269);
+            push(@{$self->{success}},$elem269);
           }
           $xfer += $input->readListEnd();
         }
@@ -3440,9 +3721,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter263 (@{$self->{success}}) 
+        foreach my $iter270 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter263);
+          $xfer += $output->writeString($iter270);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3785,15 +4066,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size264 = 0;
+          my $_size271 = 0;
           $self->{success} = [];
-          my $_etype267 = 0;
-          $xfer += $input->readListBegin(\$_etype267, \$_size264);
-          for (my $_i268 = 0; $_i268 < $_size264; ++$_i268)
+          my $_etype274 = 0;
+          $xfer += $input->readListBegin(\$_etype274, \$_size271);
+          for (my $_i275 = 0; $_i275 < $_size271; ++$_i275)
           {
-            my $elem269 = undef;
-            $xfer += $input->readString(\$elem269);
-            push(@{$self->{success}},$elem269);
+            my $elem276 = undef;
+            $xfer += $input->readString(\$elem276);
+            push(@{$self->{success}},$elem276);
           }
           $xfer += $input->readListEnd();
         }
@@ -3825,9 +4106,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter270 (@{$self->{success}}) 
+        foreach my $iter277 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter270);
+          $xfer += $output->writeString($iter277);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4121,15 +4402,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size271 = 0;
+          my $_size278 = 0;
           $self->{success} = [];
-          my $_etype274 = 0;
-          $xfer += $input->readListBegin(\$_etype274, \$_size271);
-          for (my $_i275 = 0; $_i275 < $_size271; ++$_i275)
+          my $_etype281 = 0;
+          $xfer += $input->readListBegin(\$_etype281, \$_size278);
+          for (my $_i282 = 0; $_i282 < $_size278; ++$_i282)
           {
-            my $elem276 = undef;
-            $xfer += $input->readString(\$elem276);
-            push(@{$self->{success}},$elem276);
+            my $elem283 = undef;
+            $xfer += $input->readString(\$elem283);
+            push(@{$self->{success}},$elem283);
           }
           $xfer += $input->readListEnd();
         }
@@ -4161,9 +4442,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter277 (@{$self->{success}}) 
+        foreach my $iter284 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter277);
+          $xfer += $output->writeString($iter284);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4286,15 +4567,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size278 = 0;
+          my $_size285 = 0;
           $self->{success} = [];
-          my $_etype281 = 0;
-          $xfer += $input->readListBegin(\$_etype281, \$_size278);
-          for (my $_i282 = 0; $_i282 < $_size278; ++$_i282)
+          my $_etype288 = 0;
+          $xfer += $input->readListBegin(\$_etype288, \$_size285);
+          for (my $_i289 = 0; $_i289 < $_size285; ++$_i289)
           {
-            my $elem283 = undef;
-            $xfer += $input->readString(\$elem283);
-            push(@{$self->{success}},$elem283);
+            my $elem290 = undef;
+            $xfer += $input->readString(\$elem290);
+            push(@{$self->{success}},$elem290);
           }
           $xfer += $input->readListEnd();
         }
@@ -4326,9 +4607,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter284 (@{$self->{success}}) 
+        foreach my $iter291 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter284);
+          $xfer += $output->writeString($iter291);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4433,15 +4714,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size285 = 0;
+          my $_size292 = 0;
           $self->{success} = [];
-          my $_etype288 = 0;
-          $xfer += $input->readListBegin(\$_etype288, \$_size285);
-          for (my $_i289 = 0; $_i289 < $_size285; ++$_i289)
+          my $_etype295 = 0;
+          $xfer += $input->readListBegin(\$_etype295, \$_size292);
+          for (my $_i296 = 0; $_i296 < $_size292; ++$_i296)
           {
-            my $elem290 = undef;
-            $xfer += $input->readString(\$elem290);
-            push(@{$self->{success}},$elem290);
+            my $elem297 = undef;
+            $xfer += $input->readString(\$elem297);
+            push(@{$self->{success}},$elem297);
           }
           $xfer += $input->readListEnd();
         }
@@ -4473,9 +4754,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter291 (@{$self->{success}}) 
+        foreach my $iter298 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter291);
+          $xfer += $output->writeString($iter298);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4598,18 +4879,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size292 = 0;
+          my $_size299 = 0;
           $self->{success} = {};
-          my $_ktype293 = 0;
-          my $_vtype294 = 0;
-          $xfer += $input->readMapBegin(\$_ktype293, \$_vtype294, \$_size292);
-          for (my $_i296 = 0; $_i296 < $_size292; ++$_i296)
+          my $_ktype300 = 0;
+          my $_vtype301 = 0;
+          $xfer += $input->readMapBegin(\$_ktype300, \$_vtype301, \$_size299);
+          for (my $_i303 = 0; $_i303 < $_size299; ++$_i303)
           {
-            my $key297 = '';
-            my $val298 = '';
-            $xfer += $input->readString(\$key297);
-            $xfer += $input->readString(\$val298);
-            $self->{success}->{$key297} = $val298;
+            my $key304 = '';
+            my $val305 = '';
+            $xfer += $input->readString(\$key304);
+            $xfer += $input->readString(\$val305);
+            $self->{success}->{$key304} = $val305;
           }
           $xfer += $input->readMapEnd();
         }
@@ -4641,10 +4922,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter299,$viter300) = each %{$self->{success}}) 
+        while( my ($kiter306,$viter307) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter299);
-          $xfer += $output->writeString($viter300);
+          $xfer += $output->writeString($kiter306);
+          $xfer += $output->writeString($viter307);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -4767,33 +5048,33 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size301 = 0;
+          my $_size308 = 0;
           $self->{success} = {};
-          my $_ktype302 = 0;
-          my $_vtype303 = 0;
-          $xfer += $input->readMapBegin(\$_ktype302, \$_vtype303, \$_size301);
-          for (my $_i305 = 0; $_i305 < $_size301; ++$_i305)
+          my $_ktype309 = 0;
+          my $_vtype310 = 0;
+          $xfer += $input->readMapBegin(\$_ktype309, \$_vtype310, \$_size308);
+          for (my $_i312 = 0; $_i312 < $_size308; ++$_i312)
           {
-            my $key306 = '';
-            my $val307 = [];
-            $xfer += $input->readString(\$key306);
+            my $key313 = '';
+            my $val314 = [];
+            $xfer += $input->readString(\$key313);
             {
-              my $_size308 = 0;
-              $val307 = {};
-              my $_ktype309 = 0;
-              my $_vtype310 = 0;
-              $xfer += $input->readMapBegin(\$_ktype309, \$_vtype310, \$_size308);
-              for (my $_i312 = 0; $_i312 < $_size308; ++$_i312)
+              my $_size315 = 0;
+              $val314 = {};
+              my $_ktype316 = 0;
+              my $_vtype317 = 0;
+              $xfer += $input->readMapBegin(\$_ktype316, \$_vtype317, \$_size315);
+              for (my $_i319 = 0; $_i319 < $_size315; ++$_i319)
               {
-                my $key313 = '';
-                my $val314 = 0;
-                $xfer += $input->readString(\$key313);
-                $xfer += $input->readI32(\$val314);
-                $val307->{$key313} = $val314;
+                my $key320 = '';
+                my $val321 = 0;
+                $xfer += $input->readString(\$key320);
+                $xfer += $input->readI32(\$val321);
+                $val314->{$key320} = $val321;
               }
               $xfer += $input->readMapEnd();
             }
-            $self->{success}->{$key306} = $val307;
+            $self->{success}->{$key313} = $val314;
           }
           $xfer += $input->readMapEnd();
         }
@@ -4825,16 +5106,16 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::MAP, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter315,$viter316) = each %{$self->{success}}) 
+        while( my ($kiter322,$viter323) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter315);
+          $xfer += $output->writeString($kiter322);
           {
-            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter316}}));
+            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter323}}));
             {
-              while( my ($kiter317,$viter318) = each %{${viter316}}) 
+              while( my ($kiter324,$viter325) = each %{${viter323}}) 
               {
-                $xfer += $output->writeString($kiter317);
-                $xfer += $output->writeI32($viter318);
+                $xfer += $output->writeString($kiter324);
+                $xfer += $output->writeI32($viter325);
               }
             }
             $xfer += $output->writeMapEnd();
@@ -5087,18 +5368,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size319 = 0;
+          my $_size326 = 0;
           $self->{success} = {};
-          my $_ktype320 = 0;
-          my $_vtype321 = 0;
-          $xfer += $input->readMapBegin(\$_ktype320, \$_vtype321, \$_size319);
-          for (my $_i323 = 0; $_i323 < $_size319; ++$_i323)
+          my $_ktype327 = 0;
+          my $_vtype328 = 0;
+          $xfer += $input->readMapBegin(\$_ktype327, \$_vtype328, \$_size326);
+          for (my $_i330 = 0; $_i330 < $_size326; ++$_i330)
           {
-            my $key324 = '';
-            my $val325 = '';
-            $xfer += $input->readString(\$key324);
-            $xfer += $input->readString(\$val325);
-            $self->{success}->{$key324} = $val325;
+            my $key331 = '';
+            my $val332 = '';
+            $xfer += $input->readString(\$key331);
+            $xfer += $input->readString(\$val332);
+            $self->{success}->{$key331} = $val332;
           }
           $xfer += $input->readMapEnd();
         }
@@ -5130,10 +5411,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter326,$viter327) = each %{$self->{success}}) 
+        while( my ($kiter333,$viter334) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter326);
-          $xfer += $output->writeString($viter327);
+          $xfer += $output->writeString($kiter333);
+          $xfer += $output->writeString($viter334);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -5188,15 +5469,15 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::SET) {
         {
-          my $_size328 = 0;
+          my $_size335 = 0;
           $self->{metrics} = {};
-          my $_etype331 = 0;
-          $xfer += $input->readSetBegin(\$_etype331, \$_size328);
-          for (my $_i332 = 0; $_i332 < $_size328; ++$_i332)
+          my $_etype338 = 0;
+          $xfer += $input->readSetBegin(\$_etype338, \$_size335);
+          for (my $_i339 = 0; $_i339 < $_size335; ++$_i339)
           {
-            my $elem333 = undef;
-            $xfer += $input->readString(\$elem333);
-            $self->{metrics}->{$elem333} = 1;
+            my $elem340 = undef;
+            $xfer += $input->readString(\$elem340);
+            $self->{metrics}->{$elem340} = 1;
           }
           $xfer += $input->readSetEnd();
         }
@@ -5221,9 +5502,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{metrics}}));
       {
-        foreach my $iter334 (@{$self->{metrics}})
+        foreach my $iter341 (@{$self->{metrics}})
         {
-          $xfer += $output->writeString($iter334);
+          $xfer += $output->writeString($iter341);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -5277,19 +5558,19 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size335 = 0;
+          my $_size342 = 0;
           $self->{success} = {};
-          my $_ktype336 = 0;
-          my $_vtype337 = 0;
-          $xfer += $input->readMapBegin(\$_ktype336, \$_vtype337, \$_size335);
-          for (my $_i339 = 0; $_i339 < $_size335; ++$_i339)
+          my $_ktype343 = 0;
+          my $_vtype344 = 0;
+          $xfer += $input->readMapBegin(\$_ktype343, \$_vtype344, \$_size342);
+          for (my $_i346 = 0; $_i346 < $_size342; ++$_i346)
           {
-            my $key340 = '';
-            my $val341 = new Blur::Metric();
-            $xfer += $input->readString(\$key340);
-            $val341 = new Blur::Metric();
-            $xfer += $val341->read($input);
-            $self->{success}->{$key340} = $val341;
+            my $key347 = '';
+            my $val348 = new Blur::Metric();
+            $xfer += $input->readString(\$key347);
+            $val348 = new Blur::Metric();
+            $xfer += $val348->read($input);
+            $self->{success}->{$key347} = $val348;
           }
           $xfer += $input->readMapEnd();
         }
@@ -5321,10 +5602,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter342,$viter343) = each %{$self->{success}}) 
+        while( my ($kiter349,$viter350) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter342);
-          $xfer += ${viter343}->write($output);
+          $xfer += $output->writeString($kiter349);
+          $xfer += ${viter350}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -5554,15 +5835,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size344 = 0;
+          my $_size351 = 0;
           $self->{success} = [];
-          my $_etype347 = 0;
-          $xfer += $input->readListBegin(\$_etype347, \$_size344);
-          for (my $_i348 = 0; $_i348 < $_size344; ++$_i348)
+          my $_etype354 = 0;
+          $xfer += $input->readListBegin(\$_etype354, \$_size351);
+          for (my $_i355 = 0; $_i355 < $_size351; ++$_i355)
           {
-            my $elem349 = undef;
-            $xfer += $input->readString(\$elem349);
-            push(@{$self->{success}},$elem349);
+            my $elem356 = undef;
+            $xfer += $input->readString(\$elem356);
+            push(@{$self->{success}},$elem356);
           }
           $xfer += $input->readListEnd();
         }
@@ -5594,9 +5875,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter350 (@{$self->{success}}) 
+        foreach my $iter357 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter350);
+          $xfer += $output->writeString($iter357);
         }
       }
       $xfer += $output->writeListEnd();
@@ -5719,15 +6000,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size351 = 0;
+          my $_size358 = 0;
           $self->{success} = [];
-          my $_etype354 = 0;
-          $xfer += $input->readListBegin(\$_etype354, \$_size351);
-          for (my $_i355 = 0; $_i355 < $_size351; ++$_i355)
+          my $_etype361 = 0;
+          $xfer += $input->readListBegin(\$_etype361, \$_size358);
+          for (my $_i362 = 0; $_i362 < $_size358; ++$_i362)
           {
-            my $elem356 = undef;
-            $xfer += $input->readString(\$elem356);
-            push(@{$self->{success}},$elem356);
+            my $elem363 = undef;
+            $xfer += $input->readString(\$elem363);
+            push(@{$self->{success}},$elem363);
           }
           $xfer += $input->readListEnd();
         }
@@ -5759,9 +6040,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter357 (@{$self->{success}}) 
+        foreach my $iter364 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter357);
+          $xfer += $output->writeString($iter364);
         }
       }
       $xfer += $output->writeListEnd();
@@ -6566,6 +6847,13 @@ sub mutate{
   die 'implement interface';
 }
 
+sub enqueueMutate{
+  my $self = shift;
+  my $mutation = shift;
+
+  die 'implement interface';
+}
+
 sub mutateBatch{
   my $self = shift;
   my $mutations = shift;
@@ -6573,6 +6861,13 @@ sub mutateBatch{
   die 'implement interface';
 }
 
+sub enqueueMutateBatch{
+  my $self = shift;
+  my $mutations = shift;
+
+  die 'implement interface';
+}
+
 sub cancelQuery{
   my $self = shift;
   my $table = shift;
@@ -6886,6 +7181,13 @@ sub mutate{
   return $self->{impl}->mutate($mutation);
 }
 
+sub enqueueMutate{
+  my ($self, $request) = @_;
+
+  my $mutation = ($request->{'mutation'}) ? $request->{'mutation'} : undef;
+  return $self->{impl}->enqueueMutate($mutation);
+}
+
 sub mutateBatch{
   my ($self, $request) = @_;
 
@@ -6893,6 +7195,13 @@ sub mutateBatch{
   return $self->{impl}->mutateBatch($mutations);
 }
 
+sub enqueueMutateBatch{
+  my ($self, $request) = @_;
+
+  my $mutations = ($request->{'mutations'}) ? $request->{'mutations'} : undef;
+  return $self->{impl}->enqueueMutateBatch($mutations);
+}
+
 sub cancelQuery{
   my ($self, $request) = @_;
 
@@ -7951,6 +8260,49 @@ sub recv_mutate{
   }
   return;
 }
+sub enqueueMutate{
+  my $self = shift;
+  my $mutation = shift;
+
+    $self->send_enqueueMutate($mutation);
+  $self->recv_enqueueMutate();
+}
+
+sub send_enqueueMutate{
+  my $self = shift;
+  my $mutation = shift;
+
+  $self->{output}->writeMessageBegin('enqueueMutate', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_enqueueMutate_args();
+  $args->{mutation} = $mutation;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_enqueueMutate{
+  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_enqueueMutate_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  return;
+}
 sub mutateBatch{
   my $self = shift;
   my $mutations = shift;
@@ -7994,6 +8346,49 @@ sub recv_mutateBatch{
   }
   return;
 }
+sub enqueueMutateBatch{
+  my $self = shift;
+  my $mutations = shift;
+
+    $self->send_enqueueMutateBatch($mutations);
+  $self->recv_enqueueMutateBatch();
+}
+
+sub send_enqueueMutateBatch{
+  my $self = shift;
+  my $mutations = shift;
+
+  $self->{output}->writeMessageBegin('enqueueMutateBatch', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_enqueueMutateBatch_args();
+  $args->{mutations} = $mutations;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_enqueueMutateBatch{
+  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_enqueueMutateBatch_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  return;
+}
 sub cancelQuery{
   my $self = shift;
   my $table = shift;
@@ -9297,6 +9692,23 @@ sub process_mutate {
     $output->getTransport()->flush();
 }
 
+sub process_enqueueMutate {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_enqueueMutate_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_enqueueMutate_result();
+    eval {
+      $self->{handler}->enqueueMutate($args->mutation);
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('enqueueMutate', TMessageType::REPLY, $seqid);
+    $result->write($output);
+    $output->writeMessageEnd();
+    $output->getTransport()->flush();
+}
+
 sub process_mutateBatch {
     my ($self, $seqid, $input, $output) = @_;
     my $args = new Blur::Blur_mutateBatch_args();
@@ -9314,6 +9726,23 @@ sub process_mutateBatch {
     $output->getTransport()->flush();
 }
 
+sub process_enqueueMutateBatch {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_enqueueMutateBatch_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_enqueueMutateBatch_result();
+    eval {
+      $self->{handler}->enqueueMutateBatch($args->mutations);
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('enqueueMutateBatch', TMessageType::REPLY, $seqid);
+    $result->write($output);
+    $output->writeMessageEnd();
+    $output->getTransport()->flush();
+}
+
 sub process_cancelQuery {
     my ($self, $seqid, $input, $output) = @_;
     my $args = new Blur::Blur_cancelQuery_args();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/8de60c97/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 9658594..5de32dd 100644
--- a/distribution/src/main/scripts/interface/gen-rb/blur.rb
+++ b/distribution/src/main/scripts/interface/gen-rb/blur.rb
@@ -315,6 +315,21 @@ module Blur
         return
       end
 
+      def enqueueMutate(mutation)
+        send_enqueueMutate(mutation)
+        recv_enqueueMutate()
+      end
+
+      def send_enqueueMutate(mutation)
+        send_message('enqueueMutate', EnqueueMutate_args, :mutation => mutation)
+      end
+
+      def recv_enqueueMutate()
+        result = receive_message(EnqueueMutate_result)
+        raise result.ex unless result.ex.nil?
+        return
+      end
+
       def mutateBatch(mutations)
         send_mutateBatch(mutations)
         recv_mutateBatch()
@@ -330,6 +345,21 @@ module Blur
         return
       end
 
+      def enqueueMutateBatch(mutations)
+        send_enqueueMutateBatch(mutations)
+        recv_enqueueMutateBatch()
+      end
+
+      def send_enqueueMutateBatch(mutations)
+        send_message('enqueueMutateBatch', EnqueueMutateBatch_args, :mutations => mutations)
+      end
+
+      def recv_enqueueMutateBatch()
+        result = receive_message(EnqueueMutateBatch_result)
+        raise result.ex unless result.ex.nil?
+        return
+      end
+
       def cancelQuery(table, uuid)
         send_cancelQuery(table, uuid)
         recv_cancelQuery()
@@ -871,6 +901,17 @@ module Blur
         write_result(result, oprot, 'mutate', seqid)
       end
 
+      def process_enqueueMutate(seqid, iprot, oprot)
+        args = read_args(iprot, EnqueueMutate_args)
+        result = EnqueueMutate_result.new()
+        begin
+          @handler.enqueueMutate(args.mutation)
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'enqueueMutate', seqid)
+      end
+
       def process_mutateBatch(seqid, iprot, oprot)
         args = read_args(iprot, MutateBatch_args)
         result = MutateBatch_result.new()
@@ -882,6 +923,17 @@ module Blur
         write_result(result, oprot, 'mutateBatch', seqid)
       end
 
+      def process_enqueueMutateBatch(seqid, iprot, oprot)
+        args = read_args(iprot, EnqueueMutateBatch_args)
+        result = EnqueueMutateBatch_result.new()
+        begin
+          @handler.enqueueMutateBatch(args.mutations)
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'enqueueMutateBatch', seqid)
+      end
+
       def process_cancelQuery(seqid, iprot, oprot)
         args = read_args(iprot, CancelQuery_args)
         result = CancelQuery_result.new()
@@ -1809,6 +1861,39 @@ module Blur
       ::Thrift::Struct.generate_accessors self
     end
 
+    class EnqueueMutate_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      MUTATION = 1
+
+      FIELDS = {
+        # the RowMutation.
+        MUTATION => {:type => ::Thrift::Types::STRUCT, :name => 'mutation', :class => ::Blur::RowMutation}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class EnqueueMutate_result
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      EX = 1
+
+      FIELDS = {
+        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 MutateBatch_args
       include ::Thrift::Struct, ::Thrift::Struct_Union
       MUTATIONS = 1
@@ -1842,6 +1927,39 @@ module Blur
       ::Thrift::Struct.generate_accessors self
     end
 
+    class EnqueueMutateBatch_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      MUTATIONS = 1
+
+      FIELDS = {
+        # the batch of RowMutations.
+        MUTATIONS => {:type => ::Thrift::Types::LIST, :name => 'mutations', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::RowMutation}}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class EnqueueMutateBatch_result
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      EX = 1
+
+      FIELDS = {
+        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 CancelQuery_args
       include ::Thrift::Struct, ::Thrift::Struct_Union
       TABLE = 1

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/8de60c97/docs/Blur.html
----------------------------------------------------------------------
diff --git a/docs/Blur.html b/docs/Blur.html
index 37567f2..eca2c8f 100644
--- a/docs/Blur.html
+++ b/docs/Blur.html
@@ -120,7 +120,9 @@ limitations under the License.
 <li><a href="#Fn_Blur_fetchRow">&nbsp;&nbsp;fetchRow</a></li>
 <li><a href="#Fn_Blur_fetchRowBatch">&nbsp;&nbsp;fetchRowBatch</a></li>
 <li><a href="#Fn_Blur_mutate">&nbsp;&nbsp;mutate</a></li>
+<li><a href="#Fn_Blur_enqueueMutate">&nbsp;&nbsp;enqueueMutate</a></li>
 <li><a href="#Fn_Blur_mutateBatch">&nbsp;&nbsp;mutateBatch</a></li>
+<li><a href="#Fn_Blur_enqueueMutateBatch">&nbsp;&nbsp;enqueueMutateBatch</a></li>
 <li><a href="#Fn_Blur_cancelQuery">&nbsp;&nbsp;cancelQuery</a></li>
 <li><a href="#Fn_Blur_queryStatusIdList">&nbsp;&nbsp;queryStatusIdList</a></li>
 <li><a href="#Fn_Blur_queryStatusById">&nbsp;&nbsp;queryStatusById</a></li>
@@ -796,6 +798,13 @@ throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
 <br/><br/><h4 id="Parameters_Blur_mutate">Parameters</h4>
 <table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>mutation</td><td>the RowMutation.
 </td></tr>
+</table></p></section><section><div class="page-header"><h4 id="Fn_Blur_enqueueMutate">Function: Blur.enqueueMutate</h4></div><p class="lead">
+<pre><code>void</code> enqueueMutate(<code><a href="Blur.html#Struct_RowMutation">RowMutation</a></code> mutation)
+throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
+</pre>Enqueue a RowMutation. Note that the effect of the RowMutation will occur at some point in the future, volume and load will play a role in how much time will pass before the mutation goes into effect.
+<br/><br/><h4 id="Parameters_Blur_enqueueMutate">Parameters</h4>
+<table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>mutation</td><td>the RowMutation.
+</td></tr>
 </table></p></section><section><div class="page-header"><h4 id="Fn_Blur_mutateBatch">Function: Blur.mutateBatch</h4></div><p class="lead">
 <pre><code>void</code> mutateBatch(<code>list&lt;<code><a href="Blur.html#Struct_RowMutation">RowMutation</a></code>&gt;</code> mutations)
 throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
@@ -803,6 +812,13 @@ throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
 <br/><br/><h4 id="Parameters_Blur_mutateBatch">Parameters</h4>
 <table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>mutations</td><td>the batch of RowMutations.
 </td></tr>
+</table></p></section><section><div class="page-header"><h4 id="Fn_Blur_enqueueMutateBatch">Function: Blur.enqueueMutateBatch</h4></div><p class="lead">
+<pre><code>void</code> enqueueMutateBatch(<code>list&lt;<code><a href="Blur.html#Struct_RowMutation">RowMutation</a></code>&gt;</code> mutations)
+throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
+</pre>Enqueue a batch of RowMutations. Note that the effect of the RowMutation will occur at some point in the future, volume and load will play a role in how much time will pass before the mutation goes into effect.
+<br/><br/><h4 id="Parameters_Blur_enqueueMutateBatch">Parameters</h4>
+<table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>mutations</td><td>the batch of RowMutations.
+</td></tr>
 </table></p></section><section><div class="page-header"><h4 id="Fn_Blur_cancelQuery">Function: Blur.cancelQuery</h4></div><p class="lead">
 <pre><code>void</code> cancelQuery(<code>string</code> table,
 <code>string</code> uuid)


Mime
View raw message