incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [3/9] git commit: Adding generated thrift code from api change.
Date Thu, 18 Dec 2014 23:21:52 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/a0a7d7d7/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 742845c..0e6bf50 100644
--- a/distribution/src/main/scripts/interface/gen-js/Blur.js
+++ b/distribution/src/main/scripts/interface/gen-js/Blur.js
@@ -3987,6 +3987,427 @@ Blur_enqueueMutateBatch_result.prototype.write = function(output) {
   return;
 };
 
+Blur_bulkMutateStart_args = function(args) {
+  this.table = null;
+  this.bulkId = null;
+  if (args) {
+    if (args.table !== undefined) {
+      this.table = args.table;
+    }
+    if (args.bulkId !== undefined) {
+      this.bulkId = args.bulkId;
+    }
+  }
+};
+Blur_bulkMutateStart_args.prototype = {};
+Blur_bulkMutateStart_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.STRING) {
+        this.table = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.bulkId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_bulkMutateStart_args.prototype.write = function(output) {
+  output.writeStructBegin('Blur_bulkMutateStart_args');
+  if (this.table !== null && this.table !== undefined) {
+    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
+    output.writeString(this.table);
+    output.writeFieldEnd();
+  }
+  if (this.bulkId !== null && this.bulkId !== undefined) {
+    output.writeFieldBegin('bulkId', Thrift.Type.STRING, 2);
+    output.writeString(this.bulkId);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Blur_bulkMutateStart_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_bulkMutateStart_result.prototype = {};
+Blur_bulkMutateStart_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_bulkMutateStart_result.prototype.write = function(output) {
+  output.writeStructBegin('Blur_bulkMutateStart_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_bulkMutateAdd_args = function(args) {
+  this.table = null;
+  this.bulkId = null;
+  this.rowMutation = null;
+  if (args) {
+    if (args.table !== undefined) {
+      this.table = args.table;
+    }
+    if (args.bulkId !== undefined) {
+      this.bulkId = args.bulkId;
+    }
+    if (args.rowMutation !== undefined) {
+      this.rowMutation = args.rowMutation;
+    }
+  }
+};
+Blur_bulkMutateAdd_args.prototype = {};
+Blur_bulkMutateAdd_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.STRING) {
+        this.table = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.bulkId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.rowMutation = new RowMutation();
+        this.rowMutation.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_bulkMutateAdd_args.prototype.write = function(output) {
+  output.writeStructBegin('Blur_bulkMutateAdd_args');
+  if (this.table !== null && this.table !== undefined) {
+    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
+    output.writeString(this.table);
+    output.writeFieldEnd();
+  }
+  if (this.bulkId !== null && this.bulkId !== undefined) {
+    output.writeFieldBegin('bulkId', Thrift.Type.STRING, 2);
+    output.writeString(this.bulkId);
+    output.writeFieldEnd();
+  }
+  if (this.rowMutation !== null && this.rowMutation !== undefined) {
+    output.writeFieldBegin('rowMutation', Thrift.Type.STRUCT, 3);
+    this.rowMutation.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Blur_bulkMutateAdd_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_bulkMutateAdd_result.prototype = {};
+Blur_bulkMutateAdd_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_bulkMutateAdd_result.prototype.write = function(output) {
+  output.writeStructBegin('Blur_bulkMutateAdd_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_bulkMutateFinish_args = function(args) {
+  this.table = null;
+  this.bulkId = null;
+  this.apply = null;
+  this.blockUntilComplete = null;
+  if (args) {
+    if (args.table !== undefined) {
+      this.table = args.table;
+    }
+    if (args.bulkId !== undefined) {
+      this.bulkId = args.bulkId;
+    }
+    if (args.apply !== undefined) {
+      this.apply = args.apply;
+    }
+    if (args.blockUntilComplete !== undefined) {
+      this.blockUntilComplete = args.blockUntilComplete;
+    }
+  }
+};
+Blur_bulkMutateFinish_args.prototype = {};
+Blur_bulkMutateFinish_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.STRING) {
+        this.table = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRING) {
+        this.bulkId = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 3:
+      if (ftype == Thrift.Type.BOOL) {
+        this.apply = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 4:
+      if (ftype == Thrift.Type.BOOL) {
+        this.blockUntilComplete = input.readBool().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+Blur_bulkMutateFinish_args.prototype.write = function(output) {
+  output.writeStructBegin('Blur_bulkMutateFinish_args');
+  if (this.table !== null && this.table !== undefined) {
+    output.writeFieldBegin('table', Thrift.Type.STRING, 1);
+    output.writeString(this.table);
+    output.writeFieldEnd();
+  }
+  if (this.bulkId !== null && this.bulkId !== undefined) {
+    output.writeFieldBegin('bulkId', Thrift.Type.STRING, 2);
+    output.writeString(this.bulkId);
+    output.writeFieldEnd();
+  }
+  if (this.apply !== null && this.apply !== undefined) {
+    output.writeFieldBegin('apply', Thrift.Type.BOOL, 3);
+    output.writeBool(this.apply);
+    output.writeFieldEnd();
+  }
+  if (this.blockUntilComplete !== null && this.blockUntilComplete !== undefined) {
+    output.writeFieldBegin('blockUntilComplete', Thrift.Type.BOOL, 4);
+    output.writeBool(this.blockUntilComplete);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+Blur_bulkMutateFinish_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_bulkMutateFinish_result.prototype = {};
+Blur_bulkMutateFinish_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_bulkMutateFinish_result.prototype.write = function(output) {
+  output.writeStructBegin('Blur_bulkMutateFinish_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;
@@ -7892,6 +8313,114 @@ BlurClient.prototype.recv_enqueueMutateBatch = function() {
   }
   return;
 };
+BlurClient.prototype.bulkMutateStart = function(table, bulkId) {
+  this.send_bulkMutateStart(table, bulkId);
+  this.recv_bulkMutateStart();
+};
+
+BlurClient.prototype.send_bulkMutateStart = function(table, bulkId) {
+  this.output.writeMessageBegin('bulkMutateStart', Thrift.MessageType.CALL, this.seqid);
+  var args = new Blur_bulkMutateStart_args();
+  args.table = table;
+  args.bulkId = bulkId;
+  args.write(this.output);
+  this.output.writeMessageEnd();
+  return this.output.getTransport().flush();
+};
+
+BlurClient.prototype.recv_bulkMutateStart = 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_bulkMutateStart_result();
+  result.read(this.input);
+  this.input.readMessageEnd();
+
+  if (null !== result.ex) {
+    throw result.ex;
+  }
+  return;
+};
+BlurClient.prototype.bulkMutateAdd = function(table, bulkId, rowMutation) {
+  this.send_bulkMutateAdd(table, bulkId, rowMutation);
+  this.recv_bulkMutateAdd();
+};
+
+BlurClient.prototype.send_bulkMutateAdd = function(table, bulkId, rowMutation) {
+  this.output.writeMessageBegin('bulkMutateAdd', Thrift.MessageType.CALL, this.seqid);
+  var args = new Blur_bulkMutateAdd_args();
+  args.table = table;
+  args.bulkId = bulkId;
+  args.rowMutation = rowMutation;
+  args.write(this.output);
+  this.output.writeMessageEnd();
+  return this.output.getTransport().flush();
+};
+
+BlurClient.prototype.recv_bulkMutateAdd = 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_bulkMutateAdd_result();
+  result.read(this.input);
+  this.input.readMessageEnd();
+
+  if (null !== result.ex) {
+    throw result.ex;
+  }
+  return;
+};
+BlurClient.prototype.bulkMutateFinish = function(table, bulkId, apply, blockUntilComplete) {
+  this.send_bulkMutateFinish(table, bulkId, apply, blockUntilComplete);
+  this.recv_bulkMutateFinish();
+};
+
+BlurClient.prototype.send_bulkMutateFinish = function(table, bulkId, apply, blockUntilComplete) {
+  this.output.writeMessageBegin('bulkMutateFinish', Thrift.MessageType.CALL, this.seqid);
+  var args = new Blur_bulkMutateFinish_args();
+  args.table = table;
+  args.bulkId = bulkId;
+  args.apply = apply;
+  args.blockUntilComplete = blockUntilComplete;
+  args.write(this.output);
+  this.output.writeMessageEnd();
+  return this.output.getTransport().flush();
+};
+
+BlurClient.prototype.recv_bulkMutateFinish = 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_bulkMutateFinish_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/a0a7d7d7/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 eec4783..088af03 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
@@ -4622,6 +4622,484 @@ sub write {
   return $xfer;
 }
 
+package Blur::Blur_bulkMutateStart_args;
+use base qw(Class::Accessor);
+Blur::Blur_bulkMutateStart_args->mk_accessors( qw( table bulkId ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{table} = undef;
+  $self->{bulkId} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
+    }
+    if (defined $vals->{bulkId}) {
+      $self->{bulkId} = $vals->{bulkId};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_bulkMutateStart_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->{bulkId});
+      } 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_bulkMutateStart_args');
+  if (defined $self->{table}) {
+    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+    $xfer += $output->writeString($self->{table});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{bulkId}) {
+    $xfer += $output->writeFieldBegin('bulkId', TType::STRING, 2);
+    $xfer += $output->writeString($self->{bulkId});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_bulkMutateStart_result;
+use base qw(Class::Accessor);
+Blur::Blur_bulkMutateStart_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_bulkMutateStart_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_bulkMutateStart_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_bulkMutateAdd_args;
+use base qw(Class::Accessor);
+Blur::Blur_bulkMutateAdd_args->mk_accessors( qw( table bulkId rowMutation ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{table} = undef;
+  $self->{bulkId} = undef;
+  $self->{rowMutation} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
+    }
+    if (defined $vals->{bulkId}) {
+      $self->{bulkId} = $vals->{bulkId};
+    }
+    if (defined $vals->{rowMutation}) {
+      $self->{rowMutation} = $vals->{rowMutation};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_bulkMutateAdd_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->{bulkId});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{rowMutation} = new Blur::RowMutation();
+        $xfer += $self->{rowMutation}->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_bulkMutateAdd_args');
+  if (defined $self->{table}) {
+    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+    $xfer += $output->writeString($self->{table});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{bulkId}) {
+    $xfer += $output->writeFieldBegin('bulkId', TType::STRING, 2);
+    $xfer += $output->writeString($self->{bulkId});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{rowMutation}) {
+    $xfer += $output->writeFieldBegin('rowMutation', TType::STRUCT, 3);
+    $xfer += $self->{rowMutation}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_bulkMutateAdd_result;
+use base qw(Class::Accessor);
+Blur::Blur_bulkMutateAdd_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_bulkMutateAdd_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_bulkMutateAdd_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_bulkMutateFinish_args;
+use base qw(Class::Accessor);
+Blur::Blur_bulkMutateFinish_args->mk_accessors( qw( table bulkId apply blockUntilComplete ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{table} = undef;
+  $self->{bulkId} = undef;
+  $self->{apply} = undef;
+  $self->{blockUntilComplete} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
+    }
+    if (defined $vals->{bulkId}) {
+      $self->{bulkId} = $vals->{bulkId};
+    }
+    if (defined $vals->{apply}) {
+      $self->{apply} = $vals->{apply};
+    }
+    if (defined $vals->{blockUntilComplete}) {
+      $self->{blockUntilComplete} = $vals->{blockUntilComplete};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_bulkMutateFinish_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->{bulkId});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{apply});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{blockUntilComplete});
+      } 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_bulkMutateFinish_args');
+  if (defined $self->{table}) {
+    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+    $xfer += $output->writeString($self->{table});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{bulkId}) {
+    $xfer += $output->writeFieldBegin('bulkId', TType::STRING, 2);
+    $xfer += $output->writeString($self->{bulkId});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{apply}) {
+    $xfer += $output->writeFieldBegin('apply', TType::BOOL, 3);
+    $xfer += $output->writeBool($self->{apply});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{blockUntilComplete}) {
+    $xfer += $output->writeFieldBegin('blockUntilComplete', TType::BOOL, 4);
+    $xfer += $output->writeBool($self->{blockUntilComplete});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_bulkMutateFinish_result;
+use base qw(Class::Accessor);
+Blur::Blur_bulkMutateFinish_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_bulkMutateFinish_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_bulkMutateFinish_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 ) );
@@ -8117,6 +8595,33 @@ sub enqueueMutateBatch{
   die 'implement interface';
 }
 
+sub bulkMutateStart{
+  my $self = shift;
+  my $table = shift;
+  my $bulkId = shift;
+
+  die 'implement interface';
+}
+
+sub bulkMutateAdd{
+  my $self = shift;
+  my $table = shift;
+  my $bulkId = shift;
+  my $rowMutation = shift;
+
+  die 'implement interface';
+}
+
+sub bulkMutateFinish{
+  my $self = shift;
+  my $table = shift;
+  my $bulkId = shift;
+  my $apply = shift;
+  my $blockUntilComplete = shift;
+
+  die 'implement interface';
+}
+
 sub cancelQuery{
   my $self = shift;
   my $table = shift;
@@ -8509,6 +9014,33 @@ sub enqueueMutateBatch{
   return $self->{impl}->enqueueMutateBatch($mutations);
 }
 
+sub bulkMutateStart{
+  my ($self, $request) = @_;
+
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  my $bulkId = ($request->{'bulkId'}) ? $request->{'bulkId'} : undef;
+  return $self->{impl}->bulkMutateStart($table, $bulkId);
+}
+
+sub bulkMutateAdd{
+  my ($self, $request) = @_;
+
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  my $bulkId = ($request->{'bulkId'}) ? $request->{'bulkId'} : undef;
+  my $rowMutation = ($request->{'rowMutation'}) ? $request->{'rowMutation'} : undef;
+  return $self->{impl}->bulkMutateAdd($table, $bulkId, $rowMutation);
+}
+
+sub bulkMutateFinish{
+  my ($self, $request) = @_;
+
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  my $bulkId = ($request->{'bulkId'}) ? $request->{'bulkId'} : undef;
+  my $apply = ($request->{'apply'}) ? $request->{'apply'} : undef;
+  my $blockUntilComplete = ($request->{'blockUntilComplete'}) ? $request->{'blockUntilComplete'} : undef;
+  return $self->{impl}->bulkMutateFinish($table, $bulkId, $apply, $blockUntilComplete);
+}
+
 sub cancelQuery{
   my ($self, $request) = @_;
 
@@ -10042,6 +10574,153 @@ sub recv_enqueueMutateBatch{
   }
   return;
 }
+sub bulkMutateStart{
+  my $self = shift;
+  my $table = shift;
+  my $bulkId = shift;
+
+    $self->send_bulkMutateStart($table, $bulkId);
+  $self->recv_bulkMutateStart();
+}
+
+sub send_bulkMutateStart{
+  my $self = shift;
+  my $table = shift;
+  my $bulkId = shift;
+
+  $self->{output}->writeMessageBegin('bulkMutateStart', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_bulkMutateStart_args();
+  $args->{table} = $table;
+  $args->{bulkId} = $bulkId;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_bulkMutateStart{
+  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_bulkMutateStart_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  return;
+}
+sub bulkMutateAdd{
+  my $self = shift;
+  my $table = shift;
+  my $bulkId = shift;
+  my $rowMutation = shift;
+
+    $self->send_bulkMutateAdd($table, $bulkId, $rowMutation);
+  $self->recv_bulkMutateAdd();
+}
+
+sub send_bulkMutateAdd{
+  my $self = shift;
+  my $table = shift;
+  my $bulkId = shift;
+  my $rowMutation = shift;
+
+  $self->{output}->writeMessageBegin('bulkMutateAdd', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_bulkMutateAdd_args();
+  $args->{table} = $table;
+  $args->{bulkId} = $bulkId;
+  $args->{rowMutation} = $rowMutation;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_bulkMutateAdd{
+  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_bulkMutateAdd_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  return;
+}
+sub bulkMutateFinish{
+  my $self = shift;
+  my $table = shift;
+  my $bulkId = shift;
+  my $apply = shift;
+  my $blockUntilComplete = shift;
+
+    $self->send_bulkMutateFinish($table, $bulkId, $apply, $blockUntilComplete);
+  $self->recv_bulkMutateFinish();
+}
+
+sub send_bulkMutateFinish{
+  my $self = shift;
+  my $table = shift;
+  my $bulkId = shift;
+  my $apply = shift;
+  my $blockUntilComplete = shift;
+
+  $self->{output}->writeMessageBegin('bulkMutateFinish', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_bulkMutateFinish_args();
+  $args->{table} = $table;
+  $args->{bulkId} = $bulkId;
+  $args->{apply} = $apply;
+  $args->{blockUntilComplete} = $blockUntilComplete;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_bulkMutateFinish{
+  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_bulkMutateFinish_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  return;
+}
 sub cancelQuery{
   my $self = shift;
   my $table = shift;
@@ -11527,6 +12206,57 @@ sub process_enqueueMutateBatch {
     $output->getTransport()->flush();
 }
 
+sub process_bulkMutateStart {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_bulkMutateStart_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_bulkMutateStart_result();
+    eval {
+      $self->{handler}->bulkMutateStart($args->table, $args->bulkId);
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('bulkMutateStart', TMessageType::REPLY, $seqid);
+    $result->write($output);
+    $output->writeMessageEnd();
+    $output->getTransport()->flush();
+}
+
+sub process_bulkMutateAdd {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_bulkMutateAdd_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_bulkMutateAdd_result();
+    eval {
+      $self->{handler}->bulkMutateAdd($args->table, $args->bulkId, $args->rowMutation);
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('bulkMutateAdd', TMessageType::REPLY, $seqid);
+    $result->write($output);
+    $output->writeMessageEnd();
+    $output->getTransport()->flush();
+}
+
+sub process_bulkMutateFinish {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_bulkMutateFinish_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_bulkMutateFinish_result();
+    eval {
+      $self->{handler}->bulkMutateFinish($args->table, $args->bulkId, $args->apply, $args->blockUntilComplete);
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('bulkMutateFinish', 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/a0a7d7d7/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 124d1d5..3a4fc3a 100644
--- a/distribution/src/main/scripts/interface/gen-rb/blur.rb
+++ b/distribution/src/main/scripts/interface/gen-rb/blur.rb
@@ -479,6 +479,51 @@ module Blur
         return
       end
 
+      def bulkMutateStart(table, bulkId)
+        send_bulkMutateStart(table, bulkId)
+        recv_bulkMutateStart()
+      end
+
+      def send_bulkMutateStart(table, bulkId)
+        send_message('bulkMutateStart', BulkMutateStart_args, :table => table, :bulkId => bulkId)
+      end
+
+      def recv_bulkMutateStart()
+        result = receive_message(BulkMutateStart_result)
+        raise result.ex unless result.ex.nil?
+        return
+      end
+
+      def bulkMutateAdd(table, bulkId, rowMutation)
+        send_bulkMutateAdd(table, bulkId, rowMutation)
+        recv_bulkMutateAdd()
+      end
+
+      def send_bulkMutateAdd(table, bulkId, rowMutation)
+        send_message('bulkMutateAdd', BulkMutateAdd_args, :table => table, :bulkId => bulkId, :rowMutation => rowMutation)
+      end
+
+      def recv_bulkMutateAdd()
+        result = receive_message(BulkMutateAdd_result)
+        raise result.ex unless result.ex.nil?
+        return
+      end
+
+      def bulkMutateFinish(table, bulkId, apply, blockUntilComplete)
+        send_bulkMutateFinish(table, bulkId, apply, blockUntilComplete)
+        recv_bulkMutateFinish()
+      end
+
+      def send_bulkMutateFinish(table, bulkId, apply, blockUntilComplete)
+        send_message('bulkMutateFinish', BulkMutateFinish_args, :table => table, :bulkId => bulkId, :apply => apply, :blockUntilComplete => blockUntilComplete)
+      end
+
+      def recv_bulkMutateFinish()
+        result = receive_message(BulkMutateFinish_result)
+        raise result.ex unless result.ex.nil?
+        return
+      end
+
       def cancelQuery(table, uuid)
         send_cancelQuery(table, uuid)
         recv_cancelQuery()
@@ -1140,6 +1185,39 @@ module Blur
         write_result(result, oprot, 'enqueueMutateBatch', seqid)
       end
 
+      def process_bulkMutateStart(seqid, iprot, oprot)
+        args = read_args(iprot, BulkMutateStart_args)
+        result = BulkMutateStart_result.new()
+        begin
+          @handler.bulkMutateStart(args.table, args.bulkId)
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'bulkMutateStart', seqid)
+      end
+
+      def process_bulkMutateAdd(seqid, iprot, oprot)
+        args = read_args(iprot, BulkMutateAdd_args)
+        result = BulkMutateAdd_result.new()
+        begin
+          @handler.bulkMutateAdd(args.table, args.bulkId, args.rowMutation)
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'bulkMutateAdd', seqid)
+      end
+
+      def process_bulkMutateFinish(seqid, iprot, oprot)
+        args = read_args(iprot, BulkMutateFinish_args)
+        result = BulkMutateFinish_result.new()
+        begin
+          @handler.bulkMutateFinish(args.table, args.bulkId, args.apply, args.blockUntilComplete)
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'bulkMutateFinish', seqid)
+      end
+
       def process_cancelQuery(seqid, iprot, oprot)
         args = read_args(iprot, CancelQuery_args)
         result = CancelQuery_result.new()
@@ -2446,6 +2524,123 @@ module Blur
       ::Thrift::Struct.generate_accessors self
     end
 
+    class BulkMutateStart_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      TABLE = 1
+      BULKID = 2
+
+      FIELDS = {
+        # The table name.
+        TABLE => {:type => ::Thrift::Types::STRING, :name => 'table'},
+        # The bulk id.
+        BULKID => {:type => ::Thrift::Types::STRING, :name => 'bulkId'}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class BulkMutateStart_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 BulkMutateAdd_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      TABLE = 1
+      BULKID = 2
+      ROWMUTATION = 3
+
+      FIELDS = {
+        # The table name.
+        TABLE => {:type => ::Thrift::Types::STRING, :name => 'table'},
+        # The bulk id.
+        BULKID => {:type => ::Thrift::Types::STRING, :name => 'bulkId'},
+        # The row mutation.
+        ROWMUTATION => {:type => ::Thrift::Types::STRUCT, :name => 'rowMutation', :class => ::Blur::RowMutation}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class BulkMutateAdd_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 BulkMutateFinish_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      TABLE = 1
+      BULKID = 2
+      APPLY = 3
+      BLOCKUNTILCOMPLETE = 4
+
+      FIELDS = {
+        # The table name.
+        TABLE => {:type => ::Thrift::Types::STRING, :name => 'table'},
+        # The bulk id.
+        BULKID => {:type => ::Thrift::Types::STRING, :name => 'bulkId'},
+        # Apply the bulk mutate flag.
+        APPLY => {:type => ::Thrift::Types::BOOL, :name => 'apply'},
+        # If true this call will not block on bulk completion.  This may be required for loader bulk loads.
+        BLOCKUNTILCOMPLETE => {:type => ::Thrift::Types::BOOL, :name => 'blockUntilComplete'}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class BulkMutateFinish_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/a0a7d7d7/docs/Blur.html
----------------------------------------------------------------------
diff --git a/docs/Blur.html b/docs/Blur.html
index 68eb633..40c94c5 100644
--- a/docs/Blur.html
+++ b/docs/Blur.html
@@ -145,6 +145,9 @@ limitations under the License.
 <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_bulkMutateStart">&nbsp;&nbsp;bulkMutateStart</a></li>
+<li><a href="#Fn_Blur_bulkMutateAdd">&nbsp;&nbsp;bulkMutateAdd</a></li>
+<li><a href="#Fn_Blur_bulkMutateFinish">&nbsp;&nbsp;bulkMutateFinish</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>
@@ -961,6 +964,45 @@ throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
 <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_bulkMutateStart">Function: Blur.bulkMutateStart</h4></div><p class="lead">
+<pre><code>void</code> bulkMutateStart(<code>string</code> table,
+<code>string</code> bulkId)
+throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
+</pre>Starts a transaction for update (e.g. Mutate).  Returns a transaction id.
+<br/><br/><h4 id="Parameters_Blur_bulkMutateStart">Parameters</h4>
+<table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>table</td><td>The table name.
+</td></tr>
+<tr><td>bulkId</td><td>The bulk id.
+</td></tr>
+</table></p></section><section><div class="page-header"><h4 id="Fn_Blur_bulkMutateAdd">Function: Blur.bulkMutateAdd</h4></div><p class="lead">
+<pre><code>void</code> bulkMutateAdd(<code>string</code> table,
+<code>string</code> bulkId,
+<code><a href="Blur.html#Struct_RowMutation">RowMutation</a></code> rowMutation)
+throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
+</pre>Adds to the specified transaction.  The
+<br/><br/><h4 id="Parameters_Blur_bulkMutateAdd">Parameters</h4>
+<table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>table</td><td>The table name.
+</td></tr>
+<tr><td>bulkId</td><td>The bulk id.
+</td></tr>
+<tr><td>rowMutation</td><td>The row mutation.
+</td></tr>
+</table></p></section><section><div class="page-header"><h4 id="Fn_Blur_bulkMutateFinish">Function: Blur.bulkMutateFinish</h4></div><p class="lead">
+<pre><code>void</code> bulkMutateFinish(<code>string</code> table,
+<code>string</code> bulkId,
+<code>bool</code> apply,
+<code>bool</code> blockUntilComplete)
+throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code>
+</pre>Finishes the bulk mutate.  If apply is true the mutations are applied and committed.  If false the bulk mutate is deleted and not applied.
+<br/><br/><h4 id="Parameters_Blur_bulkMutateFinish">Parameters</h4>
+<table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>table</td><td>The table name.
+</td></tr>
+<tr><td>bulkId</td><td>The bulk id.
+</td></tr>
+<tr><td>apply</td><td>Apply the bulk mutate flag.
+</td></tr>
+<tr><td>blockUntilComplete</td><td>If true this call will not block on bulk completion.  This may be required for loader bulk loads.
+</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