incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [36/50] [abbrv] Removed old Record and Row structs.
Date Wed, 07 Nov 2012 02:26:56 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/be602306/interface/gen-java/org/apache/blur/thrift/generated/TopFieldDocs.java
----------------------------------------------------------------------
diff --git a/interface/gen-java/org/apache/blur/thrift/generated/TopFieldDocs.java b/interface/gen-java/org/apache/blur/thrift/generated/TopFieldDocs.java
index c0f97e5..81e1f2b 100644
--- a/interface/gen-java/org/apache/blur/thrift/generated/TopFieldDocs.java
+++ b/interface/gen-java/org/apache/blur/thrift/generated/TopFieldDocs.java
@@ -694,14 +694,14 @@ public class TopFieldDocs implements org.apache.thrift.TBase<TopFieldDocs, TopFi
           case 3: // SCORE_DOCS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list200 = iprot.readListBegin();
-                struct.scoreDocs = new ArrayList<ScoreDoc>(_list200.size);
-                for (int _i201 = 0; _i201 < _list200.size; ++_i201)
+                org.apache.thrift.protocol.TList _list192 = iprot.readListBegin();
+                struct.scoreDocs = new ArrayList<ScoreDoc>(_list192.size);
+                for (int _i193 = 0; _i193 < _list192.size; ++_i193)
                 {
-                  ScoreDoc _elem202; // required
-                  _elem202 = new ScoreDoc();
-                  _elem202.read(iprot);
-                  struct.scoreDocs.add(_elem202);
+                  ScoreDoc _elem194; // required
+                  _elem194 = new ScoreDoc();
+                  _elem194.read(iprot);
+                  struct.scoreDocs.add(_elem194);
                 }
                 iprot.readListEnd();
               }
@@ -721,14 +721,14 @@ public class TopFieldDocs implements org.apache.thrift.TBase<TopFieldDocs, TopFi
           case 5: // FIELDS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list203 = iprot.readListBegin();
-                struct.fields = new ArrayList<SortField>(_list203.size);
-                for (int _i204 = 0; _i204 < _list203.size; ++_i204)
+                org.apache.thrift.protocol.TList _list195 = iprot.readListBegin();
+                struct.fields = new ArrayList<SortField>(_list195.size);
+                for (int _i196 = 0; _i196 < _list195.size; ++_i196)
                 {
-                  SortField _elem205; // required
-                  _elem205 = new SortField();
-                  _elem205.read(iprot);
-                  struct.fields.add(_elem205);
+                  SortField _elem197; // required
+                  _elem197 = new SortField();
+                  _elem197.read(iprot);
+                  struct.fields.add(_elem197);
                 }
                 iprot.readListEnd();
               }
@@ -762,9 +762,9 @@ public class TopFieldDocs implements org.apache.thrift.TBase<TopFieldDocs, TopFi
         oprot.writeFieldBegin(SCORE_DOCS_FIELD_DESC);
         {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.scoreDocs.size()));
-          for (ScoreDoc _iter206 : struct.scoreDocs)
+          for (ScoreDoc _iter198 : struct.scoreDocs)
           {
-            _iter206.write(oprot);
+            _iter198.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -777,9 +777,9 @@ public class TopFieldDocs implements org.apache.thrift.TBase<TopFieldDocs, TopFi
         oprot.writeFieldBegin(FIELDS_FIELD_DESC);
         {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.fields.size()));
-          for (SortField _iter207 : struct.fields)
+          for (SortField _iter199 : struct.fields)
           {
-            _iter207.write(oprot);
+            _iter199.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -828,9 +828,9 @@ public class TopFieldDocs implements org.apache.thrift.TBase<TopFieldDocs, TopFi
       if (struct.isSetScoreDocs()) {
         {
           oprot.writeI32(struct.scoreDocs.size());
-          for (ScoreDoc _iter208 : struct.scoreDocs)
+          for (ScoreDoc _iter200 : struct.scoreDocs)
           {
-            _iter208.write(oprot);
+            _iter200.write(oprot);
           }
         }
       }
@@ -840,9 +840,9 @@ public class TopFieldDocs implements org.apache.thrift.TBase<TopFieldDocs, TopFi
       if (struct.isSetFields()) {
         {
           oprot.writeI32(struct.fields.size());
-          for (SortField _iter209 : struct.fields)
+          for (SortField _iter201 : struct.fields)
           {
-            _iter209.write(oprot);
+            _iter201.write(oprot);
           }
         }
       }
@@ -862,14 +862,14 @@ public class TopFieldDocs implements org.apache.thrift.TBase<TopFieldDocs, TopFi
       }
       if (incoming.get(2)) {
         {
-          org.apache.thrift.protocol.TList _list210 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-          struct.scoreDocs = new ArrayList<ScoreDoc>(_list210.size);
-          for (int _i211 = 0; _i211 < _list210.size; ++_i211)
+          org.apache.thrift.protocol.TList _list202 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.scoreDocs = new ArrayList<ScoreDoc>(_list202.size);
+          for (int _i203 = 0; _i203 < _list202.size; ++_i203)
           {
-            ScoreDoc _elem212; // required
-            _elem212 = new ScoreDoc();
-            _elem212.read(iprot);
-            struct.scoreDocs.add(_elem212);
+            ScoreDoc _elem204; // required
+            _elem204 = new ScoreDoc();
+            _elem204.read(iprot);
+            struct.scoreDocs.add(_elem204);
           }
         }
         struct.setScoreDocsIsSet(true);
@@ -880,14 +880,14 @@ public class TopFieldDocs implements org.apache.thrift.TBase<TopFieldDocs, TopFi
       }
       if (incoming.get(4)) {
         {
-          org.apache.thrift.protocol.TList _list213 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-          struct.fields = new ArrayList<SortField>(_list213.size);
-          for (int _i214 = 0; _i214 < _list213.size; ++_i214)
+          org.apache.thrift.protocol.TList _list205 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.fields = new ArrayList<SortField>(_list205.size);
+          for (int _i206 = 0; _i206 < _list205.size; ++_i206)
           {
-            SortField _elem215; // required
-            _elem215 = new SortField();
-            _elem215.read(iprot);
-            struct.fields.add(_elem215);
+            SortField _elem207; // required
+            _elem207 = new SortField();
+            _elem207.read(iprot);
+            struct.fields.add(_elem207);
           }
         }
         struct.setFieldsIsSet(true);

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/be602306/interface/gen-java/org/apache/blur/thrift/generated/UpdatePackage.java
----------------------------------------------------------------------
diff --git a/interface/gen-java/org/apache/blur/thrift/generated/UpdatePackage.java b/interface/gen-java/org/apache/blur/thrift/generated/UpdatePackage.java
index a3d6b91..5c3eb7b 100644
--- a/interface/gen-java/org/apache/blur/thrift/generated/UpdatePackage.java
+++ b/interface/gen-java/org/apache/blur/thrift/generated/UpdatePackage.java
@@ -471,14 +471,14 @@ public class UpdatePackage implements org.apache.thrift.TBase<UpdatePackage, Upd
           case 2: // DOCUMENTS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list224 = iprot.readListBegin();
-                struct.documents = new ArrayList<Document>(_list224.size);
-                for (int _i225 = 0; _i225 < _list224.size; ++_i225)
+                org.apache.thrift.protocol.TList _list216 = iprot.readListBegin();
+                struct.documents = new ArrayList<Document>(_list216.size);
+                for (int _i217 = 0; _i217 < _list216.size; ++_i217)
                 {
-                  Document _elem226; // required
-                  _elem226 = new Document();
-                  _elem226.read(iprot);
-                  struct.documents.add(_elem226);
+                  Document _elem218; // required
+                  _elem218 = new Document();
+                  _elem218.read(iprot);
+                  struct.documents.add(_elem218);
                 }
                 iprot.readListEnd();
               }
@@ -511,9 +511,9 @@ public class UpdatePackage implements org.apache.thrift.TBase<UpdatePackage, Upd
         oprot.writeFieldBegin(DOCUMENTS_FIELD_DESC);
         {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.documents.size()));
-          for (Document _iter227 : struct.documents)
+          for (Document _iter219 : struct.documents)
           {
-            _iter227.write(oprot);
+            _iter219.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -550,9 +550,9 @@ public class UpdatePackage implements org.apache.thrift.TBase<UpdatePackage, Upd
       if (struct.isSetDocuments()) {
         {
           oprot.writeI32(struct.documents.size());
-          for (Document _iter228 : struct.documents)
+          for (Document _iter220 : struct.documents)
           {
-            _iter228.write(oprot);
+            _iter220.write(oprot);
           }
         }
       }
@@ -569,14 +569,14 @@ public class UpdatePackage implements org.apache.thrift.TBase<UpdatePackage, Upd
       }
       if (incoming.get(1)) {
         {
-          org.apache.thrift.protocol.TList _list229 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-          struct.documents = new ArrayList<Document>(_list229.size);
-          for (int _i230 = 0; _i230 < _list229.size; ++_i230)
+          org.apache.thrift.protocol.TList _list221 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.documents = new ArrayList<Document>(_list221.size);
+          for (int _i222 = 0; _i222 < _list221.size; ++_i222)
           {
-            Document _elem231; // required
-            _elem231 = new Document();
-            _elem231.read(iprot);
-            struct.documents.add(_elem231);
+            Document _elem223; // required
+            _elem223 = new Document();
+            _elem223.read(iprot);
+            struct.documents.add(_elem223);
           }
         }
         struct.setDocumentsIsSet(true);

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/be602306/interface/gen-perl/Blur/Blur.pm
----------------------------------------------------------------------
diff --git a/interface/gen-perl/Blur/Blur.pm b/interface/gen-perl/Blur/Blur.pm
index 8c21232..ba06e94 100644
--- a/interface/gen-perl/Blur/Blur.pm
+++ b/interface/gen-perl/Blur/Blur.pm
@@ -100,15 +100,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size205 = 0;
+          my $_size198 = 0;
           $self->{success} = [];
-          my $_etype208 = 0;
-          $xfer += $input->readListBegin(\$_etype208, \$_size205);
-          for (my $_i209 = 0; $_i209 < $_size205; ++$_i209)
+          my $_etype201 = 0;
+          $xfer += $input->readListBegin(\$_etype201, \$_size198);
+          for (my $_i202 = 0; $_i202 < $_size198; ++$_i202)
           {
-            my $elem210 = undef;
-            $xfer += $input->readString(\$elem210);
-            push(@{$self->{success}},$elem210);
+            my $elem203 = undef;
+            $xfer += $input->readString(\$elem203);
+            push(@{$self->{success}},$elem203);
           }
           $xfer += $input->readListEnd();
         }
@@ -140,9 +140,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter211 (@{$self->{success}}) 
+        foreach my $iter204 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter211);
+          $xfer += $output->writeString($iter204);
         }
       }
       $xfer += $output->writeListEnd();
@@ -265,15 +265,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size212 = 0;
+          my $_size205 = 0;
           $self->{success} = [];
-          my $_etype215 = 0;
-          $xfer += $input->readListBegin(\$_etype215, \$_size212);
-          for (my $_i216 = 0; $_i216 < $_size212; ++$_i216)
+          my $_etype208 = 0;
+          $xfer += $input->readListBegin(\$_etype208, \$_size205);
+          for (my $_i209 = 0; $_i209 < $_size205; ++$_i209)
           {
-            my $elem217 = undef;
-            $xfer += $input->readString(\$elem217);
-            push(@{$self->{success}},$elem217);
+            my $elem210 = undef;
+            $xfer += $input->readString(\$elem210);
+            push(@{$self->{success}},$elem210);
           }
           $xfer += $input->readListEnd();
         }
@@ -305,9 +305,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter218 (@{$self->{success}}) 
+        foreach my $iter211 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter218);
+          $xfer += $output->writeString($iter211);
         }
       }
       $xfer += $output->writeListEnd();
@@ -412,15 +412,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size219 = 0;
+          my $_size212 = 0;
           $self->{success} = [];
-          my $_etype222 = 0;
-          $xfer += $input->readListBegin(\$_etype222, \$_size219);
-          for (my $_i223 = 0; $_i223 < $_size219; ++$_i223)
+          my $_etype215 = 0;
+          $xfer += $input->readListBegin(\$_etype215, \$_size212);
+          for (my $_i216 = 0; $_i216 < $_size212; ++$_i216)
           {
-            my $elem224 = undef;
-            $xfer += $input->readString(\$elem224);
-            push(@{$self->{success}},$elem224);
+            my $elem217 = undef;
+            $xfer += $input->readString(\$elem217);
+            push(@{$self->{success}},$elem217);
           }
           $xfer += $input->readListEnd();
         }
@@ -452,9 +452,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter225 (@{$self->{success}}) 
+        foreach my $iter218 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter225);
+          $xfer += $output->writeString($iter218);
         }
       }
       $xfer += $output->writeListEnd();
@@ -577,18 +577,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size226 = 0;
+          my $_size219 = 0;
           $self->{success} = {};
-          my $_ktype227 = 0;
-          my $_vtype228 = 0;
-          $xfer += $input->readMapBegin(\$_ktype227, \$_vtype228, \$_size226);
-          for (my $_i230 = 0; $_i230 < $_size226; ++$_i230)
+          my $_ktype220 = 0;
+          my $_vtype221 = 0;
+          $xfer += $input->readMapBegin(\$_ktype220, \$_vtype221, \$_size219);
+          for (my $_i223 = 0; $_i223 < $_size219; ++$_i223)
           {
-            my $key231 = '';
-            my $val232 = '';
-            $xfer += $input->readString(\$key231);
-            $xfer += $input->readString(\$val232);
-            $self->{success}->{$key231} = $val232;
+            my $key224 = '';
+            my $val225 = '';
+            $xfer += $input->readString(\$key224);
+            $xfer += $input->readString(\$val225);
+            $self->{success}->{$key224} = $val225;
           }
           $xfer += $input->readMapEnd();
         }
@@ -620,10 +620,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter233,$viter234) = each %{$self->{success}}) 
+        while( my ($kiter226,$viter227) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter233);
-          $xfer += $output->writeString($viter234);
+          $xfer += $output->writeString($kiter226);
+          $xfer += $output->writeString($viter227);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -728,15 +728,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size235 = 0;
+          my $_size228 = 0;
           $self->{success} = [];
-          my $_etype238 = 0;
-          $xfer += $input->readListBegin(\$_etype238, \$_size235);
-          for (my $_i239 = 0; $_i239 < $_size235; ++$_i239)
+          my $_etype231 = 0;
+          $xfer += $input->readListBegin(\$_etype231, \$_size228);
+          for (my $_i232 = 0; $_i232 < $_size228; ++$_i232)
           {
-            my $elem240 = undef;
-            $xfer += $input->readString(\$elem240);
-            push(@{$self->{success}},$elem240);
+            my $elem233 = undef;
+            $xfer += $input->readString(\$elem233);
+            push(@{$self->{success}},$elem233);
           }
           $xfer += $input->readListEnd();
         }
@@ -768,9 +768,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter241 (@{$self->{success}}) 
+        foreach my $iter234 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter241);
+          $xfer += $output->writeString($iter234);
         }
       }
       $xfer += $output->writeListEnd();
@@ -893,15 +893,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size242 = 0;
+          my $_size235 = 0;
           $self->{success} = [];
-          my $_etype245 = 0;
-          $xfer += $input->readListBegin(\$_etype245, \$_size242);
-          for (my $_i246 = 0; $_i246 < $_size242; ++$_i246)
+          my $_etype238 = 0;
+          $xfer += $input->readListBegin(\$_etype238, \$_size235);
+          for (my $_i239 = 0; $_i239 < $_size235; ++$_i239)
           {
-            my $elem247 = undef;
-            $xfer += $input->readString(\$elem247);
-            push(@{$self->{success}},$elem247);
+            my $elem240 = undef;
+            $xfer += $input->readString(\$elem240);
+            push(@{$self->{success}},$elem240);
           }
           $xfer += $input->readListEnd();
         }
@@ -933,9 +933,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter248 (@{$self->{success}}) 
+        foreach my $iter241 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter248);
+          $xfer += $output->writeString($iter241);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1347,16 +1347,16 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size249 = 0;
+          my $_size242 = 0;
           $self->{success} = [];
-          my $_etype252 = 0;
-          $xfer += $input->readListBegin(\$_etype252, \$_size249);
-          for (my $_i253 = 0; $_i253 < $_size249; ++$_i253)
+          my $_etype245 = 0;
+          $xfer += $input->readListBegin(\$_etype245, \$_size242);
+          for (my $_i246 = 0; $_i246 < $_size242; ++$_i246)
           {
-            my $elem254 = undef;
-            $elem254 = new Blur::BlurQueryStatus();
-            $xfer += $elem254->read($input);
-            push(@{$self->{success}},$elem254);
+            my $elem247 = undef;
+            $elem247 = new Blur::BlurQueryStatus();
+            $xfer += $elem247->read($input);
+            push(@{$self->{success}},$elem247);
           }
           $xfer += $input->readListEnd();
         }
@@ -1388,9 +1388,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
       {
-        foreach my $iter255 (@{$self->{success}}) 
+        foreach my $iter248 (@{$self->{success}}) 
         {
-          $xfer += ${iter255}->write($output);
+          $xfer += ${iter248}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1513,15 +1513,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size256 = 0;
+          my $_size249 = 0;
           $self->{success} = [];
-          my $_etype259 = 0;
-          $xfer += $input->readListBegin(\$_etype259, \$_size256);
-          for (my $_i260 = 0; $_i260 < $_size256; ++$_i260)
+          my $_etype252 = 0;
+          $xfer += $input->readListBegin(\$_etype252, \$_size249);
+          for (my $_i253 = 0; $_i253 < $_size249; ++$_i253)
           {
-            my $elem261 = undef;
-            $xfer += $input->readI64(\$elem261);
-            push(@{$self->{success}},$elem261);
+            my $elem254 = undef;
+            $xfer += $input->readI64(\$elem254);
+            push(@{$self->{success}},$elem254);
           }
           $xfer += $input->readListEnd();
         }
@@ -1553,9 +1553,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{success}}));
       {
-        foreach my $iter262 (@{$self->{success}}) 
+        foreach my $iter255 (@{$self->{success}}) 
         {
-          $xfer += $output->writeI64($iter262);
+          $xfer += $output->writeI64($iter255);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3075,18 +3075,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size263 = 0;
+          my $_size256 = 0;
           $self->{success} = {};
-          my $_ktype264 = 0;
-          my $_vtype265 = 0;
-          $xfer += $input->readMapBegin(\$_ktype264, \$_vtype265, \$_size263);
-          for (my $_i267 = 0; $_i267 < $_size263; ++$_i267)
+          my $_ktype257 = 0;
+          my $_vtype258 = 0;
+          $xfer += $input->readMapBegin(\$_ktype257, \$_vtype258, \$_size256);
+          for (my $_i260 = 0; $_i260 < $_size256; ++$_i260)
           {
-            my $key268 = '';
-            my $val269 = '';
-            $xfer += $input->readString(\$key268);
-            $xfer += $input->readString(\$val269);
-            $self->{success}->{$key268} = $val269;
+            my $key261 = '';
+            my $val262 = '';
+            $xfer += $input->readString(\$key261);
+            $xfer += $input->readString(\$val262);
+            $self->{success}->{$key261} = $val262;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3118,10 +3118,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter270,$viter271) = each %{$self->{success}}) 
+        while( my ($kiter263,$viter264) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter270);
-          $xfer += $output->writeString($viter271);
+          $xfer += $output->writeString($kiter263);
+          $xfer += $output->writeString($viter264);
         }
       }
       $xfer += $output->writeMapEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/be602306/interface/gen-perl/Blur/ShardServer.pm
----------------------------------------------------------------------
diff --git a/interface/gen-perl/Blur/ShardServer.pm b/interface/gen-perl/Blur/ShardServer.pm
index d52aff1..e30026f 100644
--- a/interface/gen-perl/Blur/ShardServer.pm
+++ b/interface/gen-perl/Blur/ShardServer.pm
@@ -281,16 +281,16 @@ sub read {
       {
         /^0$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size272 = 0;
+            my $_size265 = 0;
             $self->{success} = [];
-            my $_etype275 = 0;
-            $xfer += $input->readListBegin(\$_etype275, \$_size272);
-            for (my $_i276 = 0; $_i276 < $_size272; ++$_i276)
+            my $_etype268 = 0;
+            $xfer += $input->readListBegin(\$_etype268, \$_size265);
+            for (my $_i269 = 0; $_i269 < $_size265; ++$_i269)
             {
-              my $elem277 = undef;
-              $elem277 = new Blur::TopFieldDocs();
-              $xfer += $elem277->read($input);
-              push(@{$self->{success}},$elem277);
+              my $elem270 = undef;
+              $elem270 = new Blur::TopFieldDocs();
+              $xfer += $elem270->read($input);
+              push(@{$self->{success}},$elem270);
             }
             $xfer += $input->readListEnd();
           }
@@ -322,9 +322,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
         {
-          foreach my $iter278 (@{$self->{success}}) 
+          foreach my $iter271 (@{$self->{success}}) 
           {
-            $xfer += ${iter278}->write($output);
+            $xfer += ${iter271}->write($output);
           }
         }
         $xfer += $output->writeListEnd();
@@ -394,16 +394,16 @@ sub read {
         last; };
         /^2$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size279 = 0;
+            my $_size272 = 0;
             $self->{docLocations} = [];
-            my $_etype282 = 0;
-            $xfer += $input->readListBegin(\$_etype282, \$_size279);
-            for (my $_i283 = 0; $_i283 < $_size279; ++$_i283)
+            my $_etype275 = 0;
+            $xfer += $input->readListBegin(\$_etype275, \$_size272);
+            for (my $_i276 = 0; $_i276 < $_size272; ++$_i276)
             {
-              my $elem284 = undef;
-              $elem284 = new Blur::DocLocation();
-              $xfer += $elem284->read($input);
-              push(@{$self->{docLocations}},$elem284);
+              my $elem277 = undef;
+              $elem277 = new Blur::DocLocation();
+              $xfer += $elem277->read($input);
+              push(@{$self->{docLocations}},$elem277);
             }
             $xfer += $input->readListEnd();
           }
@@ -413,15 +413,15 @@ sub read {
         last; };
         /^4$/ && do{        if ($ftype == TType::SET) {
           {
-            my $_size285 = 0;
+            my $_size278 = 0;
             $self->{fields} = {};
-            my $_etype288 = 0;
-            $xfer += $input->readSetBegin(\$_etype288, \$_size285);
-            for (my $_i289 = 0; $_i289 < $_size285; ++$_i289)
+            my $_etype281 = 0;
+            $xfer += $input->readSetBegin(\$_etype281, \$_size278);
+            for (my $_i282 = 0; $_i282 < $_size278; ++$_i282)
             {
-              my $elem290 = undef;
-              $xfer += $input->readString(\$elem290);
-              $self->{fields}->{$elem290} = 1;
+              my $elem283 = undef;
+              $xfer += $input->readString(\$elem283);
+              $self->{fields}->{$elem283} = 1;
             }
             $xfer += $input->readSetEnd();
           }
@@ -451,9 +451,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{docLocations}}));
         {
-          foreach my $iter291 (@{$self->{docLocations}}) 
+          foreach my $iter284 (@{$self->{docLocations}}) 
           {
-            $xfer += ${iter291}->write($output);
+            $xfer += ${iter284}->write($output);
           }
         }
         $xfer += $output->writeListEnd();
@@ -465,9 +465,9 @@ sub write {
       {
         $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{fields}}));
         {
-          foreach my $iter292 (@{$self->{fields}})
+          foreach my $iter285 (@{$self->{fields}})
           {
-            $xfer += $output->writeString($iter292);
+            $xfer += $output->writeString($iter285);
           }
         }
         $xfer += $output->writeSetEnd();
@@ -521,16 +521,16 @@ sub read {
       {
         /^0$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size293 = 0;
+            my $_size286 = 0;
             $self->{success} = [];
-            my $_etype296 = 0;
-            $xfer += $input->readListBegin(\$_etype296, \$_size293);
-            for (my $_i297 = 0; $_i297 < $_size293; ++$_i297)
+            my $_etype289 = 0;
+            $xfer += $input->readListBegin(\$_etype289, \$_size286);
+            for (my $_i290 = 0; $_i290 < $_size286; ++$_i290)
             {
-              my $elem298 = undef;
-              $elem298 = new Blur::Document();
-              $xfer += $elem298->read($input);
-              push(@{$self->{success}},$elem298);
+              my $elem291 = undef;
+              $elem291 = new Blur::Document();
+              $xfer += $elem291->read($input);
+              push(@{$self->{success}},$elem291);
             }
             $xfer += $input->readListEnd();
           }
@@ -562,9 +562,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
         {
-          foreach my $iter299 (@{$self->{success}}) 
+          foreach my $iter292 (@{$self->{success}}) 
           {
-            $xfer += ${iter299}->write($output);
+            $xfer += ${iter292}->write($output);
           }
         }
         $xfer += $output->writeListEnd();
@@ -760,16 +760,16 @@ sub read {
         last; };
         /^2$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size300 = 0;
+            my $_size293 = 0;
             $self->{documents} = [];
-            my $_etype303 = 0;
-            $xfer += $input->readListBegin(\$_etype303, \$_size300);
-            for (my $_i304 = 0; $_i304 < $_size300; ++$_i304)
+            my $_etype296 = 0;
+            $xfer += $input->readListBegin(\$_etype296, \$_size293);
+            for (my $_i297 = 0; $_i297 < $_size293; ++$_i297)
             {
-              my $elem305 = undef;
-              $elem305 = new Blur::Document();
-              $xfer += $elem305->read($input);
-              push(@{$self->{documents}},$elem305);
+              my $elem298 = undef;
+              $elem298 = new Blur::Document();
+              $xfer += $elem298->read($input);
+              push(@{$self->{documents}},$elem298);
             }
             $xfer += $input->readListEnd();
           }
@@ -799,9 +799,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{documents}}));
         {
-          foreach my $iter306 (@{$self->{documents}}) 
+          foreach my $iter299 (@{$self->{documents}}) 
           {
-            $xfer += ${iter306}->write($output);
+            $xfer += ${iter299}->write($output);
           }
         }
         $xfer += $output->writeListEnd();
@@ -927,15 +927,15 @@ sub read {
         last; };
         /^2$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size307 = 0;
+            my $_size300 = 0;
             $self->{queries} = [];
-            my $_etype310 = 0;
-            $xfer += $input->readListBegin(\$_etype310, \$_size307);
-            for (my $_i311 = 0; $_i311 < $_size307; ++$_i311)
+            my $_etype303 = 0;
+            $xfer += $input->readListBegin(\$_etype303, \$_size300);
+            for (my $_i304 = 0; $_i304 < $_size300; ++$_i304)
             {
-              my $elem312 = undef;
-              $xfer += $input->readString(\$elem312);
-              push(@{$self->{queries}},$elem312);
+              my $elem305 = undef;
+              $xfer += $input->readString(\$elem305);
+              push(@{$self->{queries}},$elem305);
             }
             $xfer += $input->readListEnd();
           }
@@ -965,9 +965,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{queries}}));
         {
-          foreach my $iter313 (@{$self->{queries}}) 
+          foreach my $iter306 (@{$self->{queries}}) 
           {
-            $xfer += $output->writeString($iter313);
+            $xfer += $output->writeString($iter306);
           }
         }
         $xfer += $output->writeListEnd();
@@ -1093,16 +1093,16 @@ sub read {
         last; };
         /^2$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size314 = 0;
+            my $_size307 = 0;
             $self->{terms} = [];
-            my $_etype317 = 0;
-            $xfer += $input->readListBegin(\$_etype317, \$_size314);
-            for (my $_i318 = 0; $_i318 < $_size314; ++$_i318)
+            my $_etype310 = 0;
+            $xfer += $input->readListBegin(\$_etype310, \$_size307);
+            for (my $_i311 = 0; $_i311 < $_size307; ++$_i311)
             {
-              my $elem319 = undef;
-              $elem319 = new Blur::Term();
-              $xfer += $elem319->read($input);
-              push(@{$self->{terms}},$elem319);
+              my $elem312 = undef;
+              $elem312 = new Blur::Term();
+              $xfer += $elem312->read($input);
+              push(@{$self->{terms}},$elem312);
             }
             $xfer += $input->readListEnd();
           }
@@ -1132,9 +1132,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{terms}}));
         {
-          foreach my $iter320 (@{$self->{terms}}) 
+          foreach my $iter313 (@{$self->{terms}}) 
           {
-            $xfer += ${iter320}->write($output);
+            $xfer += ${iter313}->write($output);
           }
         }
         $xfer += $output->writeListEnd();
@@ -1260,16 +1260,16 @@ sub read {
         last; };
         /^2$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size321 = 0;
+            my $_size314 = 0;
             $self->{updatePackages} = [];
-            my $_etype324 = 0;
-            $xfer += $input->readListBegin(\$_etype324, \$_size321);
-            for (my $_i325 = 0; $_i325 < $_size321; ++$_i325)
+            my $_etype317 = 0;
+            $xfer += $input->readListBegin(\$_etype317, \$_size314);
+            for (my $_i318 = 0; $_i318 < $_size314; ++$_i318)
             {
-              my $elem326 = undef;
-              $elem326 = new Blur::UpdatePackage();
-              $xfer += $elem326->read($input);
-              push(@{$self->{updatePackages}},$elem326);
+              my $elem319 = undef;
+              $elem319 = new Blur::UpdatePackage();
+              $xfer += $elem319->read($input);
+              push(@{$self->{updatePackages}},$elem319);
             }
             $xfer += $input->readListEnd();
           }
@@ -1299,9 +1299,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{updatePackages}}));
         {
-          foreach my $iter327 (@{$self->{updatePackages}}) 
+          foreach my $iter320 (@{$self->{updatePackages}}) 
           {
-            $xfer += ${iter327}->write($output);
+            $xfer += ${iter320}->write($output);
           }
         }
         $xfer += $output->writeListEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/be602306/interface/gen-perl/Blur/Types.pm
----------------------------------------------------------------------
diff --git a/interface/gen-perl/Blur/Types.pm b/interface/gen-perl/Blur/Types.pm
index 6bb1262..9c2c79f 100644
--- a/interface/gen-perl/Blur/Types.pm
+++ b/interface/gen-perl/Blur/Types.pm
@@ -1835,247 +1835,6 @@ sub write {
   return $xfer;
 }
 
-package Blur::RecordMutation;
-use base qw(Class::Accessor);
-Blur::RecordMutation->mk_accessors( qw( recordMutationType record ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{recordMutationType} = undef;
-  $self->{record} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{recordMutationType}) {
-      $self->{recordMutationType} = $vals->{recordMutationType};
-    }
-    if (defined $vals->{record}) {
-      $self->{record} = $vals->{record};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'RecordMutation';
-}
-
-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::I32) {
-        $xfer += $input->readI32(\$self->{recordMutationType});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{record} = new Blur::Record();
-        $xfer += $self->{record}->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('RecordMutation');
-  if (defined $self->{recordMutationType}) {
-    $xfer += $output->writeFieldBegin('recordMutationType', TType::I32, 1);
-    $xfer += $output->writeI32($self->{recordMutationType});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{record}) {
-    $xfer += $output->writeFieldBegin('record', TType::STRUCT, 2);
-    $xfer += $self->{record}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::RowMutation;
-use base qw(Class::Accessor);
-Blur::RowMutation->mk_accessors( qw( table rowId wal rowMutationType recordMutations waitToBeVisible ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{table} = undef;
-  $self->{rowId} = undef;
-  $self->{wal} = 1;
-  $self->{rowMutationType} = undef;
-  $self->{recordMutations} = undef;
-  $self->{waitToBeVisible} = 0;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{table}) {
-      $self->{table} = $vals->{table};
-    }
-    if (defined $vals->{rowId}) {
-      $self->{rowId} = $vals->{rowId};
-    }
-    if (defined $vals->{wal}) {
-      $self->{wal} = $vals->{wal};
-    }
-    if (defined $vals->{rowMutationType}) {
-      $self->{rowMutationType} = $vals->{rowMutationType};
-    }
-    if (defined $vals->{recordMutations}) {
-      $self->{recordMutations} = $vals->{recordMutations};
-    }
-    if (defined $vals->{waitToBeVisible}) {
-      $self->{waitToBeVisible} = $vals->{waitToBeVisible};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'RowMutation';
-}
-
-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->{rowId});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^3$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{wal});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^4$/ && do{      if ($ftype == TType::I32) {
-        $xfer += $input->readI32(\$self->{rowMutationType});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^5$/ && do{      if ($ftype == TType::LIST) {
-        {
-          my $_size74 = 0;
-          $self->{recordMutations} = [];
-          my $_etype77 = 0;
-          $xfer += $input->readListBegin(\$_etype77, \$_size74);
-          for (my $_i78 = 0; $_i78 < $_size74; ++$_i78)
-          {
-            my $elem79 = undef;
-            $elem79 = new Blur::RecordMutation();
-            $xfer += $elem79->read($input);
-            push(@{$self->{recordMutations}},$elem79);
-          }
-          $xfer += $input->readListEnd();
-        }
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^6$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{waitToBeVisible});
-      } 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('RowMutation');
-  if (defined $self->{table}) {
-    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
-    $xfer += $output->writeString($self->{table});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{rowId}) {
-    $xfer += $output->writeFieldBegin('rowId', TType::STRING, 2);
-    $xfer += $output->writeString($self->{rowId});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{wal}) {
-    $xfer += $output->writeFieldBegin('wal', TType::BOOL, 3);
-    $xfer += $output->writeBool($self->{wal});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{rowMutationType}) {
-    $xfer += $output->writeFieldBegin('rowMutationType', TType::I32, 4);
-    $xfer += $output->writeI32($self->{rowMutationType});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{recordMutations}) {
-    $xfer += $output->writeFieldBegin('recordMutations', TType::LIST, 5);
-    {
-      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{recordMutations}}));
-      {
-        foreach my $iter80 (@{$self->{recordMutations}}) 
-        {
-          $xfer += ${iter80}->write($output);
-        }
-      }
-      $xfer += $output->writeListEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{waitToBeVisible}) {
-    $xfer += $output->writeFieldBegin('waitToBeVisible', TType::BOOL, 6);
-    $xfer += $output->writeBool($self->{waitToBeVisible});
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
 package Blur::CpuTime;
 use base qw(Class::Accessor);
 Blur::CpuTime->mk_accessors( qw( cpuTime realTime ) );
@@ -2220,19 +1979,19 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size81 = 0;
+          my $_size74 = 0;
           $self->{cpuTimes} = {};
-          my $_ktype82 = 0;
-          my $_vtype83 = 0;
-          $xfer += $input->readMapBegin(\$_ktype82, \$_vtype83, \$_size81);
-          for (my $_i85 = 0; $_i85 < $_size81; ++$_i85)
+          my $_ktype75 = 0;
+          my $_vtype76 = 0;
+          $xfer += $input->readMapBegin(\$_ktype75, \$_vtype76, \$_size74);
+          for (my $_i78 = 0; $_i78 < $_size74; ++$_i78)
           {
-            my $key86 = '';
-            my $val87 = new Blur::CpuTime();
-            $xfer += $input->readString(\$key86);
-            $val87 = new Blur::CpuTime();
-            $xfer += $val87->read($input);
-            $self->{cpuTimes}->{$key86} = $val87;
+            my $key79 = '';
+            my $val80 = new Blur::CpuTime();
+            $xfer += $input->readString(\$key79);
+            $val80 = new Blur::CpuTime();
+            $xfer += $val80->read($input);
+            $self->{cpuTimes}->{$key79} = $val80;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2286,10 +2045,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{cpuTimes}}));
       {
-        while( my ($kiter88,$viter89) = each %{$self->{cpuTimes}}) 
+        while( my ($kiter81,$viter82) = each %{$self->{cpuTimes}}) 
         {
-          $xfer += $output->writeString($kiter88);
-          $xfer += ${viter89}->write($output);
+          $xfer += $output->writeString($kiter81);
+          $xfer += ${viter82}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -2493,30 +2252,30 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size90 = 0;
+          my $_size83 = 0;
           $self->{columnFamilies} = {};
-          my $_ktype91 = 0;
-          my $_vtype92 = 0;
-          $xfer += $input->readMapBegin(\$_ktype91, \$_vtype92, \$_size90);
-          for (my $_i94 = 0; $_i94 < $_size90; ++$_i94)
+          my $_ktype84 = 0;
+          my $_vtype85 = 0;
+          $xfer += $input->readMapBegin(\$_ktype84, \$_vtype85, \$_size83);
+          for (my $_i87 = 0; $_i87 < $_size83; ++$_i87)
           {
-            my $key95 = '';
-            my $val96 = [];
-            $xfer += $input->readString(\$key95);
+            my $key88 = '';
+            my $val89 = [];
+            $xfer += $input->readString(\$key88);
             {
-              my $_size97 = 0;
-              $val96 = {};
-              my $_etype100 = 0;
-              $xfer += $input->readSetBegin(\$_etype100, \$_size97);
-              for (my $_i101 = 0; $_i101 < $_size97; ++$_i101)
+              my $_size90 = 0;
+              $val89 = {};
+              my $_etype93 = 0;
+              $xfer += $input->readSetBegin(\$_etype93, \$_size90);
+              for (my $_i94 = 0; $_i94 < $_size90; ++$_i94)
               {
-                my $elem102 = undef;
-                $xfer += $input->readString(\$elem102);
-                $val96->{$elem102} = 1;
+                my $elem95 = undef;
+                $xfer += $input->readString(\$elem95);
+                $val89->{$elem95} = 1;
               }
               $xfer += $input->readSetEnd();
             }
-            $self->{columnFamilies}->{$key95} = $val96;
+            $self->{columnFamilies}->{$key88} = $val89;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2546,15 +2305,15 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::SET, scalar(keys %{$self->{columnFamilies}}));
       {
-        while( my ($kiter103,$viter104) = each %{$self->{columnFamilies}}) 
+        while( my ($kiter96,$viter97) = each %{$self->{columnFamilies}}) 
         {
-          $xfer += $output->writeString($kiter103);
+          $xfer += $output->writeString($kiter96);
           {
-            $xfer += $output->writeSetBegin(TType::STRING, scalar(@{${viter104}}));
+            $xfer += $output->writeSetBegin(TType::STRING, scalar(@{${viter97}}));
             {
-              foreach my $iter105 (@{${viter104}})
+              foreach my $iter98 (@{${viter97}})
               {
-                $xfer += $output->writeString($iter105);
+                $xfer += $output->writeString($iter98);
               }
             }
             $xfer += $output->writeSetEnd();
@@ -2692,19 +2451,19 @@ sub read {
       last; };
       /^3$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size106 = 0;
+          my $_size99 = 0;
           $self->{alternateColumnDefinitions} = {};
-          my $_ktype107 = 0;
-          my $_vtype108 = 0;
-          $xfer += $input->readMapBegin(\$_ktype107, \$_vtype108, \$_size106);
-          for (my $_i110 = 0; $_i110 < $_size106; ++$_i110)
+          my $_ktype100 = 0;
+          my $_vtype101 = 0;
+          $xfer += $input->readMapBegin(\$_ktype100, \$_vtype101, \$_size99);
+          for (my $_i103 = 0; $_i103 < $_size99; ++$_i103)
           {
-            my $key111 = '';
-            my $val112 = new Blur::AlternateColumnDefinition();
-            $xfer += $input->readString(\$key111);
-            $val112 = new Blur::AlternateColumnDefinition();
-            $xfer += $val112->read($input);
-            $self->{alternateColumnDefinitions}->{$key111} = $val112;
+            my $key104 = '';
+            my $val105 = new Blur::AlternateColumnDefinition();
+            $xfer += $input->readString(\$key104);
+            $val105 = new Blur::AlternateColumnDefinition();
+            $xfer += $val105->read($input);
+            $self->{alternateColumnDefinitions}->{$key104} = $val105;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2739,10 +2498,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{alternateColumnDefinitions}}));
       {
-        while( my ($kiter113,$viter114) = each %{$self->{alternateColumnDefinitions}}) 
+        while( my ($kiter106,$viter107) = each %{$self->{alternateColumnDefinitions}}) 
         {
-          $xfer += $output->writeString($kiter113);
-          $xfer += ${viter114}->write($output);
+          $xfer += $output->writeString($kiter106);
+          $xfer += ${viter107}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -2803,19 +2562,19 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size115 = 0;
+          my $_size108 = 0;
           $self->{columnDefinitions} = {};
-          my $_ktype116 = 0;
-          my $_vtype117 = 0;
-          $xfer += $input->readMapBegin(\$_ktype116, \$_vtype117, \$_size115);
-          for (my $_i119 = 0; $_i119 < $_size115; ++$_i119)
+          my $_ktype109 = 0;
+          my $_vtype110 = 0;
+          $xfer += $input->readMapBegin(\$_ktype109, \$_vtype110, \$_size108);
+          for (my $_i112 = 0; $_i112 < $_size108; ++$_i112)
           {
-            my $key120 = '';
-            my $val121 = new Blur::ColumnDefinition();
-            $xfer += $input->readString(\$key120);
-            $val121 = new Blur::ColumnDefinition();
-            $xfer += $val121->read($input);
-            $self->{columnDefinitions}->{$key120} = $val121;
+            my $key113 = '';
+            my $val114 = new Blur::ColumnDefinition();
+            $xfer += $input->readString(\$key113);
+            $val114 = new Blur::ColumnDefinition();
+            $xfer += $val114->read($input);
+            $self->{columnDefinitions}->{$key113} = $val114;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2845,10 +2604,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{columnDefinitions}}));
       {
-        while( my ($kiter122,$viter123) = each %{$self->{columnDefinitions}}) 
+        while( my ($kiter115,$viter116) = each %{$self->{columnDefinitions}}) 
         {
-          $xfer += $output->writeString($kiter122);
-          $xfer += ${viter123}->write($output);
+          $xfer += $output->writeString($kiter115);
+          $xfer += ${viter116}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -2919,19 +2678,19 @@ sub read {
       last; };
       /^3$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size124 = 0;
+          my $_size117 = 0;
           $self->{columnFamilyDefinitions} = {};
-          my $_ktype125 = 0;
-          my $_vtype126 = 0;
-          $xfer += $input->readMapBegin(\$_ktype125, \$_vtype126, \$_size124);
-          for (my $_i128 = 0; $_i128 < $_size124; ++$_i128)
+          my $_ktype118 = 0;
+          my $_vtype119 = 0;
+          $xfer += $input->readMapBegin(\$_ktype118, \$_vtype119, \$_size117);
+          for (my $_i121 = 0; $_i121 < $_size117; ++$_i121)
           {
-            my $key129 = '';
-            my $val130 = new Blur::ColumnFamilyDefinition();
-            $xfer += $input->readString(\$key129);
-            $val130 = new Blur::ColumnFamilyDefinition();
-            $xfer += $val130->read($input);
-            $self->{columnFamilyDefinitions}->{$key129} = $val130;
+            my $key122 = '';
+            my $val123 = new Blur::ColumnFamilyDefinition();
+            $xfer += $input->readString(\$key122);
+            $val123 = new Blur::ColumnFamilyDefinition();
+            $xfer += $val123->read($input);
+            $self->{columnFamilyDefinitions}->{$key122} = $val123;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2966,10 +2725,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{columnFamilyDefinitions}}));
       {
-        while( my ($kiter131,$viter132) = each %{$self->{columnFamilyDefinitions}}) 
+        while( my ($kiter124,$viter125) = each %{$self->{columnFamilyDefinitions}}) 
         {
-          $xfer += $output->writeString($kiter131);
-          $xfer += ${viter132}->write($output);
+          $xfer += $output->writeString($kiter124);
+          $xfer += ${viter125}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3019,15 +2778,15 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size133 = 0;
+          my $_size126 = 0;
           $self->{preCacheCols} = [];
-          my $_etype136 = 0;
-          $xfer += $input->readListBegin(\$_etype136, \$_size133);
-          for (my $_i137 = 0; $_i137 < $_size133; ++$_i137)
+          my $_etype129 = 0;
+          $xfer += $input->readListBegin(\$_etype129, \$_size126);
+          for (my $_i130 = 0; $_i130 < $_size126; ++$_i130)
           {
-            my $elem138 = undef;
-            $xfer += $input->readString(\$elem138);
-            push(@{$self->{preCacheCols}},$elem138);
+            my $elem131 = undef;
+            $xfer += $input->readString(\$elem131);
+            push(@{$self->{preCacheCols}},$elem131);
           }
           $xfer += $input->readListEnd();
         }
@@ -3052,9 +2811,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{preCacheCols}}));
       {
-        foreach my $iter139 (@{$self->{preCacheCols}}) 
+        foreach my $iter132 (@{$self->{preCacheCols}}) 
         {
-          $xfer += $output->writeString($iter139);
+          $xfer += $output->writeString($iter132);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3213,15 +2972,15 @@ sub read {
       last; };
       /^11$/ && do{      if ($ftype == TType::SET) {
         {
-          my $_size140 = 0;
+          my $_size133 = 0;
           $self->{blockCachingFileTypes} = {};
-          my $_etype143 = 0;
-          $xfer += $input->readSetBegin(\$_etype143, \$_size140);
-          for (my $_i144 = 0; $_i144 < $_size140; ++$_i144)
+          my $_etype136 = 0;
+          $xfer += $input->readSetBegin(\$_etype136, \$_size133);
+          for (my $_i137 = 0; $_i137 < $_size133; ++$_i137)
           {
-            my $elem145 = undef;
-            $xfer += $input->readString(\$elem145);
-            $self->{blockCachingFileTypes}->{$elem145} = 1;
+            my $elem138 = undef;
+            $xfer += $input->readString(\$elem138);
+            $self->{blockCachingFileTypes}->{$elem138} = 1;
           }
           $xfer += $input->readSetEnd();
         }
@@ -3309,9 +3068,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{blockCachingFileTypes}}));
       {
-        foreach my $iter146 (@{$self->{blockCachingFileTypes}})
+        foreach my $iter139 (@{$self->{blockCachingFileTypes}})
         {
-          $xfer += $output->writeString($iter146);
+          $xfer += $output->writeString($iter139);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -3475,18 +3234,18 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size147 = 0;
+          my $_size140 = 0;
           $self->{properties} = {};
-          my $_ktype148 = 0;
-          my $_vtype149 = 0;
-          $xfer += $input->readMapBegin(\$_ktype148, \$_vtype149, \$_size147);
-          for (my $_i151 = 0; $_i151 < $_size147; ++$_i151)
+          my $_ktype141 = 0;
+          my $_vtype142 = 0;
+          $xfer += $input->readMapBegin(\$_ktype141, \$_vtype142, \$_size140);
+          for (my $_i144 = 0; $_i144 < $_size140; ++$_i144)
           {
-            my $key152 = '';
-            my $val153 = '';
-            $xfer += $input->readString(\$key152);
-            $xfer += $input->readString(\$val153);
-            $self->{properties}->{$key152} = $val153;
+            my $key145 = '';
+            my $val146 = '';
+            $xfer += $input->readString(\$key145);
+            $xfer += $input->readString(\$val146);
+            $self->{properties}->{$key145} = $val146;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3516,10 +3275,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{properties}}));
       {
-        while( my ($kiter154,$viter155) = each %{$self->{properties}}) 
+        while( my ($kiter147,$viter148) = each %{$self->{properties}}) 
         {
-          $xfer += $output->writeString($kiter154);
-          $xfer += $output->writeString($viter155);
+          $xfer += $output->writeString($kiter147);
+          $xfer += $output->writeString($viter148);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3743,16 +3502,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size156 = 0;
+          my $_size149 = 0;
           $self->{fields} = [];
-          my $_etype159 = 0;
-          $xfer += $input->readListBegin(\$_etype159, \$_size156);
-          for (my $_i160 = 0; $_i160 < $_size156; ++$_i160)
+          my $_etype152 = 0;
+          $xfer += $input->readListBegin(\$_etype152, \$_size149);
+          for (my $_i153 = 0; $_i153 < $_size149; ++$_i153)
           {
-            my $elem161 = undef;
-            $elem161 = new Blur::SortField();
-            $xfer += $elem161->read($input);
-            push(@{$self->{fields}},$elem161);
+            my $elem154 = undef;
+            $elem154 = new Blur::SortField();
+            $xfer += $elem154->read($input);
+            push(@{$self->{fields}},$elem154);
           }
           $xfer += $input->readListEnd();
         }
@@ -3777,9 +3536,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{fields}}));
       {
-        foreach my $iter162 (@{$self->{fields}}) 
+        foreach my $iter155 (@{$self->{fields}}) 
         {
-          $xfer += ${iter162}->write($output);
+          $xfer += ${iter155}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3929,15 +3688,15 @@ sub read {
       last; };
       /^4$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size163 = 0;
+          my $_size156 = 0;
           $self->{fields} = [];
-          my $_etype166 = 0;
-          $xfer += $input->readListBegin(\$_etype166, \$_size163);
-          for (my $_i167 = 0; $_i167 < $_size163; ++$_i167)
+          my $_etype159 = 0;
+          $xfer += $input->readListBegin(\$_etype159, \$_size156);
+          for (my $_i160 = 0; $_i160 < $_size156; ++$_i160)
           {
-            my $elem168 = undef;
-            $xfer += $input->readString(\$elem168);
-            push(@{$self->{fields}},$elem168);
+            my $elem161 = undef;
+            $xfer += $input->readString(\$elem161);
+            push(@{$self->{fields}},$elem161);
           }
           $xfer += $input->readListEnd();
         }
@@ -3972,9 +3731,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{fields}}));
       {
-        foreach my $iter169 (@{$self->{fields}}) 
+        foreach my $iter162 (@{$self->{fields}}) 
         {
-          $xfer += $output->writeString($iter169);
+          $xfer += $output->writeString($iter162);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4096,15 +3855,15 @@ sub read {
       last; };
       /^8$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size170 = 0;
+          my $_size163 = 0;
           $self->{shardIndexes} = [];
-          my $_etype173 = 0;
-          $xfer += $input->readListBegin(\$_etype173, \$_size170);
-          for (my $_i174 = 0; $_i174 < $_size170; ++$_i174)
+          my $_etype166 = 0;
+          $xfer += $input->readListBegin(\$_etype166, \$_size163);
+          for (my $_i167 = 0; $_i167 < $_size163; ++$_i167)
           {
-            my $elem175 = undef;
-            $xfer += $input->readI32(\$elem175);
-            push(@{$self->{shardIndexes}},$elem175);
+            my $elem168 = undef;
+            $xfer += $input->readI32(\$elem168);
+            push(@{$self->{shardIndexes}},$elem168);
           }
           $xfer += $input->readListEnd();
         }
@@ -4164,9 +3923,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::I32, scalar(@{$self->{shardIndexes}}));
       {
-        foreach my $iter176 (@{$self->{shardIndexes}}) 
+        foreach my $iter169 (@{$self->{shardIndexes}}) 
         {
-          $xfer += $output->writeI32($iter176);
+          $xfer += $output->writeI32($iter169);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4244,16 +4003,16 @@ sub read {
       last; };
       /^3$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size177 = 0;
+          my $_size170 = 0;
           $self->{scoreDocs} = [];
-          my $_etype180 = 0;
-          $xfer += $input->readListBegin(\$_etype180, \$_size177);
-          for (my $_i181 = 0; $_i181 < $_size177; ++$_i181)
+          my $_etype173 = 0;
+          $xfer += $input->readListBegin(\$_etype173, \$_size170);
+          for (my $_i174 = 0; $_i174 < $_size170; ++$_i174)
           {
-            my $elem182 = undef;
-            $elem182 = new Blur::ScoreDoc();
-            $xfer += $elem182->read($input);
-            push(@{$self->{scoreDocs}},$elem182);
+            my $elem175 = undef;
+            $elem175 = new Blur::ScoreDoc();
+            $xfer += $elem175->read($input);
+            push(@{$self->{scoreDocs}},$elem175);
           }
           $xfer += $input->readListEnd();
         }
@@ -4269,16 +4028,16 @@ sub read {
       last; };
       /^5$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size183 = 0;
+          my $_size176 = 0;
           $self->{fields} = [];
-          my $_etype186 = 0;
-          $xfer += $input->readListBegin(\$_etype186, \$_size183);
-          for (my $_i187 = 0; $_i187 < $_size183; ++$_i187)
+          my $_etype179 = 0;
+          $xfer += $input->readListBegin(\$_etype179, \$_size176);
+          for (my $_i180 = 0; $_i180 < $_size176; ++$_i180)
           {
-            my $elem188 = undef;
-            $elem188 = new Blur::SortField();
-            $xfer += $elem188->read($input);
-            push(@{$self->{fields}},$elem188);
+            my $elem181 = undef;
+            $elem181 = new Blur::SortField();
+            $xfer += $elem181->read($input);
+            push(@{$self->{fields}},$elem181);
           }
           $xfer += $input->readListEnd();
         }
@@ -4313,9 +4072,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{scoreDocs}}));
       {
-        foreach my $iter189 (@{$self->{scoreDocs}}) 
+        foreach my $iter182 (@{$self->{scoreDocs}}) 
         {
-          $xfer += ${iter189}->write($output);
+          $xfer += ${iter182}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4332,9 +4091,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{fields}}));
       {
-        foreach my $iter190 (@{$self->{fields}}) 
+        foreach my $iter183 (@{$self->{fields}}) 
         {
-          $xfer += ${iter190}->write($output);
+          $xfer += ${iter183}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4493,16 +4252,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size191 = 0;
+          my $_size184 = 0;
           $self->{fields} = [];
-          my $_etype194 = 0;
-          $xfer += $input->readListBegin(\$_etype194, \$_size191);
-          for (my $_i195 = 0; $_i195 < $_size191; ++$_i195)
+          my $_etype187 = 0;
+          $xfer += $input->readListBegin(\$_etype187, \$_size184);
+          for (my $_i188 = 0; $_i188 < $_size184; ++$_i188)
           {
-            my $elem196 = undef;
-            $elem196 = new Blur::Field();
-            $xfer += $elem196->read($input);
-            push(@{$self->{fields}},$elem196);
+            my $elem189 = undef;
+            $elem189 = new Blur::Field();
+            $xfer += $elem189->read($input);
+            push(@{$self->{fields}},$elem189);
           }
           $xfer += $input->readListEnd();
         }
@@ -4527,9 +4286,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{fields}}));
       {
-        foreach my $iter197 (@{$self->{fields}}) 
+        foreach my $iter190 (@{$self->{fields}}) 
         {
-          $xfer += ${iter197}->write($output);
+          $xfer += ${iter190}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4778,16 +4537,16 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size198 = 0;
+          my $_size191 = 0;
           $self->{documents} = [];
-          my $_etype201 = 0;
-          $xfer += $input->readListBegin(\$_etype201, \$_size198);
-          for (my $_i202 = 0; $_i202 < $_size198; ++$_i202)
+          my $_etype194 = 0;
+          $xfer += $input->readListBegin(\$_etype194, \$_size191);
+          for (my $_i195 = 0; $_i195 < $_size191; ++$_i195)
           {
-            my $elem203 = undef;
-            $elem203 = new Blur::Document();
-            $xfer += $elem203->read($input);
-            push(@{$self->{documents}},$elem203);
+            my $elem196 = undef;
+            $elem196 = new Blur::Document();
+            $xfer += $elem196->read($input);
+            push(@{$self->{documents}},$elem196);
           }
           $xfer += $input->readListEnd();
         }
@@ -4817,9 +4576,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{documents}}));
       {
-        foreach my $iter204 (@{$self->{documents}}) 
+        foreach my $iter197 (@{$self->{documents}}) 
         {
-          $xfer += ${iter204}->write($output);
+          $xfer += ${iter197}->write($output);
         }
       }
       $xfer += $output->writeListEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/be602306/interface/gen-rb/blur_types.rb
----------------------------------------------------------------------
diff --git a/interface/gen-rb/blur_types.rb b/interface/gen-rb/blur_types.rb
index 912e155..6d2dfcd 100644
--- a/interface/gen-rb/blur_types.rb
+++ b/interface/gen-rb/blur_types.rb
@@ -481,64 +481,6 @@ module Blur
   end
 
   # 
-  class RecordMutation
-    include ::Thrift::Struct, ::Thrift::Struct_Union
-    RECORDMUTATIONTYPE = 1
-    RECORD = 2
-
-    FIELDS = {
-      # 
-      RECORDMUTATIONTYPE => {:type => ::Thrift::Types::I32, :name => 'recordMutationType', :enum_class => ::Blur::RecordMutationType},
-      # 
-      RECORD => {:type => ::Thrift::Types::STRUCT, :name => 'record', :class => ::Blur::Record}
-    }
-
-    def struct_fields; FIELDS; end
-
-    def validate
-      unless @recordMutationType.nil? || ::Blur::RecordMutationType::VALID_VALUES.include?(@recordMutationType)
-        raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field recordMutationType!')
-      end
-    end
-
-    ::Thrift::Struct.generate_accessors self
-  end
-
-  # 
-  class RowMutation
-    include ::Thrift::Struct, ::Thrift::Struct_Union
-    TABLE = 1
-    ROWID = 2
-    WAL = 3
-    ROWMUTATIONTYPE = 4
-    RECORDMUTATIONS = 5
-    WAITTOBEVISIBLE = 6
-
-    FIELDS = {
-      # The that that the row mutation is to act upon.
-      TABLE => {:type => ::Thrift::Types::STRING, :name => 'table'},
-      # The row id that the row mutation is to act upon.
-      ROWID => {:type => ::Thrift::Types::STRING, :name => 'rowId'},
-      # Write ahead log, by default all updates are written to a write ahead log before the update is applied.  That way if a failure occurs before the index is committed the WAL can be replayed to recover any data that could have been lost.
-      WAL => {:type => ::Thrift::Types::BOOL, :name => 'wal', :default => true},
-      ROWMUTATIONTYPE => {:type => ::Thrift::Types::I32, :name => 'rowMutationType', :enum_class => ::Blur::RowMutationType},
-      RECORDMUTATIONS => {:type => ::Thrift::Types::LIST, :name => 'recordMutations', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::RecordMutation}},
-      # On mutate waits for the mutation to be visible to queries and fetch requests.
-      WAITTOBEVISIBLE => {:type => ::Thrift::Types::BOOL, :name => 'waitToBeVisible', :default => false}
-    }
-
-    def struct_fields; FIELDS; end
-
-    def validate
-      unless @rowMutationType.nil? || ::Blur::RowMutationType::VALID_VALUES.include?(@rowMutationType)
-        raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field rowMutationType!')
-      end
-    end
-
-    ::Thrift::Struct.generate_accessors self
-  end
-
-  # 
   class CpuTime
     include ::Thrift::Struct, ::Thrift::Struct_Union
     CPUTIME = 1

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/be602306/src/blur-core/src/main/java/org/apache/blur/manager/IndexManager.java
----------------------------------------------------------------------
diff --git a/src/blur-core/src/main/java/org/apache/blur/manager/IndexManager.java b/src/blur-core/src/main/java/org/apache/blur/manager/IndexManager.java
index 8a6fca2..95c7db1 100644
--- a/src/blur-core/src/main/java/org/apache/blur/manager/IndexManager.java
+++ b/src/blur-core/src/main/java/org/apache/blur/manager/IndexManager.java
@@ -19,23 +19,18 @@ package org.apache.blur.manager;
 import static org.apache.blur.utils.BlurConstants.PRIME_DOC;
 import static org.apache.blur.utils.BlurConstants.RECORD_ID;
 import static org.apache.blur.utils.BlurConstants.ROW_ID;
-import static org.apache.blur.utils.BlurUtil.findRecordMutation;
 import static org.apache.blur.utils.RowDocumentUtil.getColumns;
 import static org.apache.blur.utils.RowDocumentUtil.getRow;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.TreeSet;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
@@ -56,20 +51,12 @@ import org.apache.blur.manager.writer.BlurIndex;
 import org.apache.blur.metrics.BlurMetrics;
 import org.apache.blur.metrics.QueryMetrics;
 import org.apache.blur.thrift.BException;
-import org.apache.blur.thrift.MutationHelper;
 import org.apache.blur.thrift.generated.BlurException;
 import org.apache.blur.thrift.generated.BlurQuery;
 import org.apache.blur.thrift.generated.BlurQueryStatus;
-import org.apache.blur.thrift.generated.Column;
 import org.apache.blur.thrift.generated.ExpertQuery;
 import org.apache.blur.thrift.generated.FetchResult;
 import org.apache.blur.thrift.generated.FetchRowResult;
-import org.apache.blur.thrift.generated.Record;
-import org.apache.blur.thrift.generated.RecordMutation;
-import org.apache.blur.thrift.generated.RecordMutationType;
-import org.apache.blur.thrift.generated.Row;
-import org.apache.blur.thrift.generated.RowMutation;
-import org.apache.blur.thrift.generated.RowMutationType;
 import org.apache.blur.thrift.generated.Schema;
 import org.apache.blur.thrift.generated.ScoreType;
 import org.apache.blur.thrift.generated.Selector;
@@ -223,7 +210,7 @@ public class IndexManager {
   private void populateSelector(String table, Selector selector) throws IOException, BlurException {
     String rowId = selector.rowId;
     String recordId = selector.recordId;
-    String shardName = MutationHelper.getShardName(table, rowId, getNumberOfShards(table), _blurPartitioner);
+    String shardName = null;//MutationHelper.getShardName(table, rowId, getNumberOfShards(table), _blurPartitioner);
     Map<String, BlurIndex> indexes = _indexServer.getIndexes(table);
     BlurIndex blurIndex = indexes.get(shardName);
     if (blurIndex == null) {
@@ -635,279 +622,7 @@ public class IndexManager {
     _statusManager.setStatusCleanupTimerDelay(delay);
   }
 
-  public void mutate(final RowMutation mutation) throws BlurException, IOException {
-    Future<Void> future = _mutateExecutor.submit(new Callable<Void>() {
-      @Override
-      public Void call() throws Exception {
-        doMutate(mutation);
-        return null;
-      }
-    });
-    try {
-      future.get();
-    } catch (InterruptedException e) {
-      throw new BException("Unknown error during mutation", e);
-    } catch (ExecutionException e) {
-      throw new BException("Unknown error during mutation", e.getCause());
-    }
-  }
-
-  public void mutate(final List<RowMutation> mutations) throws BlurException, IOException {
-    Future<Void> future = _mutateExecutor.submit(new Callable<Void>() {
-      @Override
-      public Void call() throws Exception {
-        long s = System.nanoTime();
-        doMutates(mutations);
-        long e = System.nanoTime();
-        LOG.debug("doMutates took [" + (e - s) / 1000000.0 + " ms] to complete");
-        return null;
-      }
-    });
-    try {
-      future.get();
-    } catch (InterruptedException e) {
-      throw new BException("Unknown error during mutation", e);
-    } catch (ExecutionException e) {
-      throw new BException("Unknown error during mutation", e.getCause());
-    }
-  }
-
-  private void doMutates(List<RowMutation> mutations) throws BlurException, IOException {
-    Map<String, List<RowMutation>> map = getMutatesPerTable(mutations);
-    for (Entry<String, List<RowMutation>> entry : map.entrySet()) {
-      doMutates(entry.getKey(), entry.getValue());
-    }
-  }
-
-  private void doMutates(final String table, List<RowMutation> mutations) throws IOException, BlurException {
-    final Map<String, BlurIndex> indexes = _indexServer.getIndexes(table);
-
-    Map<String, List<RowMutation>> mutationsByShard = new HashMap<String, List<RowMutation>>();
-
-    for (int i = 0; i < mutations.size(); i++) {
-      RowMutation mutation = mutations.get(i);
-      String shard = MutationHelper.getShardName(table, mutation.rowId, getNumberOfShards(table), _blurPartitioner);
-      List<RowMutation> list = mutationsByShard.get(shard);
-      if (list == null) {
-        list = new ArrayList<RowMutation>();
-        mutationsByShard.put(shard, list);
-      }
-      list.add(mutation);
-    }
-
-    List<Future<Void>> futures = new ArrayList<Future<Void>>();
-
-    for (Entry<String, List<RowMutation>> entry : mutationsByShard.entrySet()) {
-      final String shard = entry.getKey();
-      final List<RowMutation> value = entry.getValue();
-      futures.add(_mutateExecutor.submit(new Callable<Void>() {
-        @Override
-        public Void call() throws Exception {
-          executeMutates(table, shard, indexes, value);
-          return null;
-        }
-      }));
-    }
-
-    for (Future<Void> future : futures) {
-      try {
-        future.get();
-      } catch (InterruptedException e) {
-        throw new BException("Unknown error during mutation", e);
-      } catch (ExecutionException e) {
-        throw new BException("Unknown error during mutation", e.getCause());
-      }
-    }
-  }
-
-  private void executeMutates(String table, String shard, Map<String, BlurIndex> indexes, List<RowMutation> mutations) throws BlurException, IOException {
-    long s = System.nanoTime();
-    boolean waitToBeVisible = false;
-    for (int i = 0; i < mutations.size(); i++) {
-      RowMutation mutation = mutations.get(i);
-      if (mutation.waitToBeVisible) {
-        waitToBeVisible = true;
-      }
-      BlurIndex blurIndex = indexes.get(shard);
-      if (blurIndex == null) {
-        throw new BlurException("Shard [" + shard + "] in table [" + table + "] is not being served by this server.", null);
-      }
-
-      boolean waitVisiblity = false;
-      if (i + 1 == mutations.size()) {
-        waitVisiblity = waitToBeVisible;
-      }
-      RowMutationType type = mutation.rowMutationType;
-      long start = System.nanoTime();
-      switch (type) {
-      case REPLACE_ROW:
-        Row row = MutationHelper.getRowFromMutations(mutation.rowId, mutation.recordMutations);
-        blurIndex.replaceRow(waitVisiblity, mutation.wal, row);
-        _queryMetrics.recordDataMutate(System.nanoTime() - start, row.records.size());
-        break;
-      case UPDATE_ROW:
-        doUpdateRowMutation(mutation, blurIndex);
-        break;
-      case DELETE_ROW:
-        blurIndex.deleteRow(waitVisiblity, mutation.wal, mutation.rowId);
-        _queryMetrics.recordDataMutate(System.nanoTime() - start, 1);
-        break;
-      default:
-        throw new RuntimeException("Not supported [" + type + "]");
-      }
-    }
-    long e = System.nanoTime();
-    LOG.debug("executeMutates took [" + (e - s) / 1000000.0 + " ms] to complete");
-  }
-
-  private Map<String, List<RowMutation>> getMutatesPerTable(List<RowMutation> mutations) {
-    Map<String, List<RowMutation>> map = new HashMap<String, List<RowMutation>>();
-    for (RowMutation mutation : mutations) {
-      String table = mutation.table;
-      List<RowMutation> list = map.get(table);
-      if (list == null) {
-        list = new ArrayList<RowMutation>();
-        map.put(table, list);
-      }
-      list.add(mutation);
-    }
-    return map;
-  }
-
-  private void doMutate(RowMutation mutation) throws BlurException, IOException {
-    String table = mutation.table;
-    Map<String, BlurIndex> indexes = _indexServer.getIndexes(table);
-    MutationHelper.validateMutation(mutation);
-    String shard = MutationHelper.getShardName(table, mutation.rowId, getNumberOfShards(table), _blurPartitioner);
-    BlurIndex blurIndex = indexes.get(shard);
-    if (blurIndex == null) {
-      throw new BlurException("Shard [" + shard + "] in table [" + table + "] is not being served by this server.", null);
-    }
-
-    RowMutationType type = mutation.rowMutationType;
-    switch (type) {
-    case REPLACE_ROW:
-      Row row = MutationHelper.getRowFromMutations(mutation.rowId, mutation.recordMutations);
-      blurIndex.replaceRow(mutation.waitToBeVisible, mutation.wal, row);
-      break;
-    case UPDATE_ROW:
-      doUpdateRowMutation(mutation, blurIndex);
-      break;
-    case DELETE_ROW:
-      blurIndex.deleteRow(mutation.waitToBeVisible, mutation.wal, mutation.rowId);
-      break;
-    default:
-      throw new RuntimeException("Not supported [" + type + "]");
-    }
-  }
-
-  private void doUpdateRowMutation(RowMutation mutation, BlurIndex blurIndex) throws BlurException, IOException {
-    FetchResult fetchResult = new FetchResult();
-    Selector selector = new Selector();
-    selector.setAllowStaleDataIsSet(false);
-    selector.setRowId(mutation.rowId);
-    fetchRow(mutation.table, selector, fetchResult);
-    if (fetchResult.exists) {
-      // We will examine the contents of the existing row and add records
-      // onto a new replacement row based on the mutation we have been given.
-      Row existingRow = fetchResult.rowResult.row;
-      Row newRow = new Row().setId(existingRow.id);
-
-      // Create a local copy of the mutation we can modify
-      RowMutation mutationCopy = mutation.deepCopy();
-
-      // Match existing records against record mutations. Once a record
-      // mutation has been processed, remove it from our local copy.
-      for (Record existingRecord : existingRow.records) {
-        RecordMutation recordMutation = findRecordMutation(mutationCopy, existingRecord);
-        if (recordMutation != null) {
-          mutationCopy.recordMutations.remove(recordMutation);
-          doUpdateRecordMutation(recordMutation, existingRecord, newRow);
-        } else {
-          // Copy existing records over to the new row unmodified if there
-          // is no matching mutation.
-          newRow.addToRecords(existingRecord);
-        }
-      }
-
-      // Examine all remaining record mutations. For any record replacements
-      // we need to create a new record in the table even though an existing
-      // record did not match. Record deletions are also ok here since the
-      // record is effectively already deleted. Other record mutations are
-      // an error and should generate an exception.
-      for (RecordMutation recordMutation : mutationCopy.recordMutations) {
-        RecordMutationType type = recordMutation.recordMutationType;
-        switch (type) {
-        case DELETE_ENTIRE_RECORD:
-          // do nothing as missing record is already in desired state
-          break;
-        case APPEND_COLUMN_VALUES:
-          throw new BException("Mutation cannot append column values to non-existent record", recordMutation);
-        case REPLACE_ENTIRE_RECORD:
-          newRow.addToRecords(recordMutation.record);
-          break;
-        case REPLACE_COLUMNS:
-          throw new BException("Mutation cannot replace columns in non-existent record", recordMutation);
-        default:
-          throw new RuntimeException("Unsupported record mutation type [" + type + "]");
-        }
-      }
-
-      long s = System.nanoTime();
-      // Finally, replace the existing row with the new row we have built.
-      blurIndex.replaceRow(mutation.waitToBeVisible, mutation.wal, newRow);
-      if (newRow != null && newRow.records != null) {
-        _queryMetrics.recordDataMutate(System.nanoTime() - s, newRow.records.size());
-      }
-    } else {
-      throw new BException("Mutation cannot update row that does not exist.", mutation);
-    }
-  }
-
-  private static void doUpdateRecordMutation(RecordMutation recordMutation, Record existingRecord, Row newRow) {
-    Record mutationRecord = recordMutation.record;
-    switch (recordMutation.recordMutationType) {
-    case DELETE_ENTIRE_RECORD:
-      return;
-    case APPEND_COLUMN_VALUES:
-      for (Column column : mutationRecord.columns) {
-        existingRecord.addToColumns(column);
-      }
-      newRow.addToRecords(existingRecord);
-      break;
-    case REPLACE_ENTIRE_RECORD:
-      newRow.addToRecords(mutationRecord);
-      break;
-    case REPLACE_COLUMNS:
-      Set<String> columnNames = new HashSet<String>();
-      for (Column column : mutationRecord.columns) {
-        columnNames.add(column.name);
-      }
-
-      LOOP: for (Column column : existingRecord.columns) {
-        // skip columns in existing record that are contained in the mutation
-        // record
-        if (columnNames.contains(column.name)) {
-          continue LOOP;
-        }
-        mutationRecord.addToColumns(column);
-      }
-      newRow.addToRecords(mutationRecord);
-      break;
-    default:
-      break;
-    }
-  }
 
-  // private boolean isSameRecord(Record existingRecord, Record mutationRecord)
-  // {
-  // if (existingRecord.recordId.equals(mutationRecord.recordId)) {
-  // if (existingRecord.family.equals(mutationRecord.family)) {
-  // return true;
-  // }
-  // }
-  // return false;
-  // }
 
   private int getNumberOfShards(String table) {
     return _indexServer.getShardCount(table);

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/be602306/src/blur-core/src/main/java/org/apache/blur/thrift/BlurControllerServer.java
----------------------------------------------------------------------
diff --git a/src/blur-core/src/main/java/org/apache/blur/thrift/BlurControllerServer.java b/src/blur-core/src/main/java/org/apache/blur/thrift/BlurControllerServer.java
index e805888..856a8d7 100644
--- a/src/blur-core/src/main/java/org/apache/blur/thrift/BlurControllerServer.java
+++ b/src/blur-core/src/main/java/org/apache/blur/thrift/BlurControllerServer.java
@@ -49,7 +49,6 @@ import org.apache.blur.thrift.generated.Blur.Iface;
 import org.apache.blur.thrift.generated.BlurException;
 import org.apache.blur.thrift.generated.BlurQueryStatus;
 import org.apache.blur.thrift.generated.Schema;
-import org.apache.blur.thrift.generated.Selector;
 import org.apache.blur.thrift.generated.TableDescriptor;
 import org.apache.blur.thrift.generated.TableStats;
 import org.apache.blur.utils.BlurConstants;
@@ -414,22 +413,6 @@ public class BlurControllerServer extends TableAdmin implements Iface {
     }
   }
 
-
-  private String getNode(String table, Selector selector) throws BlurException, TException {
-    Map<String, String> layout = shardServerLayout(table);
-    String locationId = selector.locationId;
-    if (locationId != null) {
-      String shard = locationId.substring(0, locationId.indexOf('/'));
-      return layout.get(shard);
-    }
-    int numberOfShards = getShardCount(table);
-    if (selector.rowId != null) {
-      String shardName = MutationHelper.getShardName(table, selector.rowId, numberOfShards, _blurPartitioner);
-      return layout.get(shardName);
-    }
-    throw new BlurException("Selector is missing both a locationid and a rowid, one is needed.", null);
-  }
-
   private <R> R scatterGather(String cluster, final BlurCommand<R> command, Merger<R> merger) throws Exception {
     return ForkJoin.execute(_executor, _clusterStatus.getOnlineShardServers(true, cluster), new ParallelCall<String, R>() {
       @SuppressWarnings("unchecked")
@@ -476,17 +459,6 @@ public class BlurControllerServer extends TableAdmin implements Iface {
     return result;
   }
 
-
-  private int getShardCount(String table) throws BlurException, TException {
-    Integer numberOfShards = _tableShardCountMap.get(table);
-    if (numberOfShards == null) {
-      TableDescriptor descriptor = describe(table);
-      numberOfShards = descriptor.shardCount;
-      _tableShardCountMap.put(table, numberOfShards);
-    }
-    return numberOfShards;
-  }
-
   public void setNodeName(String nodeName) {
     _nodeName = nodeName;
   }


Mime
View raw message