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"> enqueueMutate</a></li> <li><a href="#Fn_Blur_mutateBatch"> mutateBatch</a></li> <li><a href="#Fn_Blur_enqueueMutateBatch"> enqueueMutateBatch</a></li> +<li><a href="#Fn_Blur_bulkMutateStart"> bulkMutateStart</a></li> +<li><a href="#Fn_Blur_bulkMutateAdd"> bulkMutateAdd</a></li> +<li><a href="#Fn_Blur_bulkMutateFinish"> bulkMutateFinish</a></li> <li><a href="#Fn_Blur_cancelQuery"> cancelQuery</a></li> <li><a href="#Fn_Blur_queryStatusIdList"> queryStatusIdList</a></li> <li><a href="#Fn_Blur_queryStatusById"> 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)
