incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [03/14] Made some small API changes to the Row (removed recordCount because it did not work as documented). Added totalRecords to FetchRowResult that will take the place of recordCount in Row. Also removed the WAL and wait for visibility on the row mut
Date Wed, 15 Jan 2014 22:03:50 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/c98be3e2/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 7d170c9..89f89db 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
@@ -792,15 +792,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size185 = 0;
+          my $_size192 = 0;
           $self->{success} = [];
-          my $_etype188 = 0;
-          $xfer += $input->readListBegin(\$_etype188, \$_size185);
-          for (my $_i189 = 0; $_i189 < $_size185; ++$_i189)
+          my $_etype195 = 0;
+          $xfer += $input->readListBegin(\$_etype195, \$_size192);
+          for (my $_i196 = 0; $_i196 < $_size192; ++$_i196)
           {
-            my $elem190 = undef;
-            $xfer += $input->readString(\$elem190);
-            push(@{$self->{success}},$elem190);
+            my $elem197 = undef;
+            $xfer += $input->readString(\$elem197);
+            push(@{$self->{success}},$elem197);
           }
           $xfer += $input->readListEnd();
         }
@@ -832,9 +832,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter191 (@{$self->{success}}) 
+        foreach my $iter198 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter191);
+          $xfer += $output->writeString($iter198);
         }
       }
       $xfer += $output->writeListEnd();
@@ -957,15 +957,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size192 = 0;
+          my $_size199 = 0;
           $self->{success} = [];
-          my $_etype195 = 0;
-          $xfer += $input->readListBegin(\$_etype195, \$_size192);
-          for (my $_i196 = 0; $_i196 < $_size192; ++$_i196)
+          my $_etype202 = 0;
+          $xfer += $input->readListBegin(\$_etype202, \$_size199);
+          for (my $_i203 = 0; $_i203 < $_size199; ++$_i203)
           {
-            my $elem197 = undef;
-            $xfer += $input->readString(\$elem197);
-            push(@{$self->{success}},$elem197);
+            my $elem204 = undef;
+            $xfer += $input->readString(\$elem204);
+            push(@{$self->{success}},$elem204);
           }
           $xfer += $input->readListEnd();
         }
@@ -997,9 +997,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter198 (@{$self->{success}}) 
+        foreach my $iter205 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter198);
+          $xfer += $output->writeString($iter205);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2149,30 +2149,30 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size199 = 0;
+          my $_size206 = 0;
           $self->{success} = {};
-          my $_ktype200 = 0;
-          my $_vtype201 = 0;
-          $xfer += $input->readMapBegin(\$_ktype200, \$_vtype201, \$_size199);
-          for (my $_i203 = 0; $_i203 < $_size199; ++$_i203)
+          my $_ktype207 = 0;
+          my $_vtype208 = 0;
+          $xfer += $input->readMapBegin(\$_ktype207, \$_vtype208, \$_size206);
+          for (my $_i210 = 0; $_i210 < $_size206; ++$_i210)
           {
-            my $key204 = '';
-            my $val205 = [];
-            $xfer += $input->readString(\$key204);
+            my $key211 = '';
+            my $val212 = [];
+            $xfer += $input->readString(\$key211);
             {
-              my $_size206 = 0;
-              $val205 = [];
-              my $_etype209 = 0;
-              $xfer += $input->readListBegin(\$_etype209, \$_size206);
-              for (my $_i210 = 0; $_i210 < $_size206; ++$_i210)
+              my $_size213 = 0;
+              $val212 = [];
+              my $_etype216 = 0;
+              $xfer += $input->readListBegin(\$_etype216, \$_size213);
+              for (my $_i217 = 0; $_i217 < $_size213; ++$_i217)
               {
-                my $elem211 = undef;
-                $xfer += $input->readString(\$elem211);
-                push(@{$val205},$elem211);
+                my $elem218 = undef;
+                $xfer += $input->readString(\$elem218);
+                push(@{$val212},$elem218);
               }
               $xfer += $input->readListEnd();
             }
-            $self->{success}->{$key204} = $val205;
+            $self->{success}->{$key211} = $val212;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2204,15 +2204,15 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::LIST, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter212,$viter213) = each %{$self->{success}}) 
+        while( my ($kiter219,$viter220) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter212);
+          $xfer += $output->writeString($kiter219);
           {
-            $xfer += $output->writeListBegin(TType::STRING, scalar(@{${viter213}}));
+            $xfer += $output->writeListBegin(TType::STRING, scalar(@{${viter220}}));
             {
-              foreach my $iter214 (@{${viter213}}) 
+              foreach my $iter221 (@{${viter220}}) 
               {
-                $xfer += $output->writeString($iter214);
+                $xfer += $output->writeString($iter221);
               }
             }
             $xfer += $output->writeListEnd();
@@ -2714,16 +2714,16 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size215 = 0;
+          my $_size222 = 0;
           $self->{selectors} = [];
-          my $_etype218 = 0;
-          $xfer += $input->readListBegin(\$_etype218, \$_size215);
-          for (my $_i219 = 0; $_i219 < $_size215; ++$_i219)
+          my $_etype225 = 0;
+          $xfer += $input->readListBegin(\$_etype225, \$_size222);
+          for (my $_i226 = 0; $_i226 < $_size222; ++$_i226)
           {
-            my $elem220 = undef;
-            $elem220 = new Blur::Selector();
-            $xfer += $elem220->read($input);
-            push(@{$self->{selectors}},$elem220);
+            my $elem227 = undef;
+            $elem227 = new Blur::Selector();
+            $xfer += $elem227->read($input);
+            push(@{$self->{selectors}},$elem227);
           }
           $xfer += $input->readListEnd();
         }
@@ -2753,9 +2753,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{selectors}}));
       {
-        foreach my $iter221 (@{$self->{selectors}}) 
+        foreach my $iter228 (@{$self->{selectors}}) 
         {
-          $xfer += ${iter221}->write($output);
+          $xfer += ${iter228}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2809,16 +2809,16 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size222 = 0;
+          my $_size229 = 0;
           $self->{success} = [];
-          my $_etype225 = 0;
-          $xfer += $input->readListBegin(\$_etype225, \$_size222);
-          for (my $_i226 = 0; $_i226 < $_size222; ++$_i226)
+          my $_etype232 = 0;
+          $xfer += $input->readListBegin(\$_etype232, \$_size229);
+          for (my $_i233 = 0; $_i233 < $_size229; ++$_i233)
           {
-            my $elem227 = undef;
-            $elem227 = new Blur::FetchResult();
-            $xfer += $elem227->read($input);
-            push(@{$self->{success}},$elem227);
+            my $elem234 = undef;
+            $elem234 = new Blur::FetchResult();
+            $xfer += $elem234->read($input);
+            push(@{$self->{success}},$elem234);
           }
           $xfer += $input->readListEnd();
         }
@@ -2850,9 +2850,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
       {
-        foreach my $iter228 (@{$self->{success}}) 
+        foreach my $iter235 (@{$self->{success}}) 
         {
-          $xfer += ${iter228}->write($output);
+          $xfer += ${iter235}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3037,16 +3037,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size229 = 0;
+          my $_size236 = 0;
           $self->{mutations} = [];
-          my $_etype232 = 0;
-          $xfer += $input->readListBegin(\$_etype232, \$_size229);
-          for (my $_i233 = 0; $_i233 < $_size229; ++$_i233)
+          my $_etype239 = 0;
+          $xfer += $input->readListBegin(\$_etype239, \$_size236);
+          for (my $_i240 = 0; $_i240 < $_size236; ++$_i240)
           {
-            my $elem234 = undef;
-            $elem234 = new Blur::RowMutation();
-            $xfer += $elem234->read($input);
-            push(@{$self->{mutations}},$elem234);
+            my $elem241 = undef;
+            $elem241 = new Blur::RowMutation();
+            $xfer += $elem241->read($input);
+            push(@{$self->{mutations}},$elem241);
           }
           $xfer += $input->readListEnd();
         }
@@ -3071,9 +3071,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{mutations}}));
       {
-        foreach my $iter235 (@{$self->{mutations}}) 
+        foreach my $iter242 (@{$self->{mutations}}) 
         {
-          $xfer += ${iter235}->write($output);
+          $xfer += ${iter242}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3400,15 +3400,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size236 = 0;
+          my $_size243 = 0;
           $self->{success} = [];
-          my $_etype239 = 0;
-          $xfer += $input->readListBegin(\$_etype239, \$_size236);
-          for (my $_i240 = 0; $_i240 < $_size236; ++$_i240)
+          my $_etype246 = 0;
+          $xfer += $input->readListBegin(\$_etype246, \$_size243);
+          for (my $_i247 = 0; $_i247 < $_size243; ++$_i247)
           {
-            my $elem241 = undef;
-            $xfer += $input->readString(\$elem241);
-            push(@{$self->{success}},$elem241);
+            my $elem248 = undef;
+            $xfer += $input->readString(\$elem248);
+            push(@{$self->{success}},$elem248);
           }
           $xfer += $input->readListEnd();
         }
@@ -3440,9 +3440,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter242 (@{$self->{success}}) 
+        foreach my $iter249 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter242);
+          $xfer += $output->writeString($iter249);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3785,15 +3785,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size243 = 0;
+          my $_size250 = 0;
           $self->{success} = [];
-          my $_etype246 = 0;
-          $xfer += $input->readListBegin(\$_etype246, \$_size243);
-          for (my $_i247 = 0; $_i247 < $_size243; ++$_i247)
+          my $_etype253 = 0;
+          $xfer += $input->readListBegin(\$_etype253, \$_size250);
+          for (my $_i254 = 0; $_i254 < $_size250; ++$_i254)
           {
-            my $elem248 = undef;
-            $xfer += $input->readString(\$elem248);
-            push(@{$self->{success}},$elem248);
+            my $elem255 = undef;
+            $xfer += $input->readString(\$elem255);
+            push(@{$self->{success}},$elem255);
           }
           $xfer += $input->readListEnd();
         }
@@ -3825,9 +3825,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter249 (@{$self->{success}}) 
+        foreach my $iter256 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter249);
+          $xfer += $output->writeString($iter256);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4121,15 +4121,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size250 = 0;
+          my $_size257 = 0;
           $self->{success} = [];
-          my $_etype253 = 0;
-          $xfer += $input->readListBegin(\$_etype253, \$_size250);
-          for (my $_i254 = 0; $_i254 < $_size250; ++$_i254)
+          my $_etype260 = 0;
+          $xfer += $input->readListBegin(\$_etype260, \$_size257);
+          for (my $_i261 = 0; $_i261 < $_size257; ++$_i261)
           {
-            my $elem255 = undef;
-            $xfer += $input->readString(\$elem255);
-            push(@{$self->{success}},$elem255);
+            my $elem262 = undef;
+            $xfer += $input->readString(\$elem262);
+            push(@{$self->{success}},$elem262);
           }
           $xfer += $input->readListEnd();
         }
@@ -4161,9 +4161,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter256 (@{$self->{success}}) 
+        foreach my $iter263 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter256);
+          $xfer += $output->writeString($iter263);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4286,15 +4286,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size257 = 0;
+          my $_size264 = 0;
           $self->{success} = [];
-          my $_etype260 = 0;
-          $xfer += $input->readListBegin(\$_etype260, \$_size257);
-          for (my $_i261 = 0; $_i261 < $_size257; ++$_i261)
+          my $_etype267 = 0;
+          $xfer += $input->readListBegin(\$_etype267, \$_size264);
+          for (my $_i268 = 0; $_i268 < $_size264; ++$_i268)
           {
-            my $elem262 = undef;
-            $xfer += $input->readString(\$elem262);
-            push(@{$self->{success}},$elem262);
+            my $elem269 = undef;
+            $xfer += $input->readString(\$elem269);
+            push(@{$self->{success}},$elem269);
           }
           $xfer += $input->readListEnd();
         }
@@ -4326,9 +4326,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter263 (@{$self->{success}}) 
+        foreach my $iter270 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter263);
+          $xfer += $output->writeString($iter270);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4433,15 +4433,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size264 = 0;
+          my $_size271 = 0;
           $self->{success} = [];
-          my $_etype267 = 0;
-          $xfer += $input->readListBegin(\$_etype267, \$_size264);
-          for (my $_i268 = 0; $_i268 < $_size264; ++$_i268)
+          my $_etype274 = 0;
+          $xfer += $input->readListBegin(\$_etype274, \$_size271);
+          for (my $_i275 = 0; $_i275 < $_size271; ++$_i275)
           {
-            my $elem269 = undef;
-            $xfer += $input->readString(\$elem269);
-            push(@{$self->{success}},$elem269);
+            my $elem276 = undef;
+            $xfer += $input->readString(\$elem276);
+            push(@{$self->{success}},$elem276);
           }
           $xfer += $input->readListEnd();
         }
@@ -4473,9 +4473,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter270 (@{$self->{success}}) 
+        foreach my $iter277 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter270);
+          $xfer += $output->writeString($iter277);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4598,18 +4598,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size271 = 0;
+          my $_size278 = 0;
           $self->{success} = {};
-          my $_ktype272 = 0;
-          my $_vtype273 = 0;
-          $xfer += $input->readMapBegin(\$_ktype272, \$_vtype273, \$_size271);
-          for (my $_i275 = 0; $_i275 < $_size271; ++$_i275)
+          my $_ktype279 = 0;
+          my $_vtype280 = 0;
+          $xfer += $input->readMapBegin(\$_ktype279, \$_vtype280, \$_size278);
+          for (my $_i282 = 0; $_i282 < $_size278; ++$_i282)
           {
-            my $key276 = '';
-            my $val277 = '';
-            $xfer += $input->readString(\$key276);
-            $xfer += $input->readString(\$val277);
-            $self->{success}->{$key276} = $val277;
+            my $key283 = '';
+            my $val284 = '';
+            $xfer += $input->readString(\$key283);
+            $xfer += $input->readString(\$val284);
+            $self->{success}->{$key283} = $val284;
           }
           $xfer += $input->readMapEnd();
         }
@@ -4641,10 +4641,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter278,$viter279) = each %{$self->{success}}) 
+        while( my ($kiter285,$viter286) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter278);
-          $xfer += $output->writeString($viter279);
+          $xfer += $output->writeString($kiter285);
+          $xfer += $output->writeString($viter286);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -4767,33 +4767,33 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size280 = 0;
+          my $_size287 = 0;
           $self->{success} = {};
-          my $_ktype281 = 0;
-          my $_vtype282 = 0;
-          $xfer += $input->readMapBegin(\$_ktype281, \$_vtype282, \$_size280);
-          for (my $_i284 = 0; $_i284 < $_size280; ++$_i284)
+          my $_ktype288 = 0;
+          my $_vtype289 = 0;
+          $xfer += $input->readMapBegin(\$_ktype288, \$_vtype289, \$_size287);
+          for (my $_i291 = 0; $_i291 < $_size287; ++$_i291)
           {
-            my $key285 = '';
-            my $val286 = [];
-            $xfer += $input->readString(\$key285);
+            my $key292 = '';
+            my $val293 = [];
+            $xfer += $input->readString(\$key292);
             {
-              my $_size287 = 0;
-              $val286 = {};
-              my $_ktype288 = 0;
-              my $_vtype289 = 0;
-              $xfer += $input->readMapBegin(\$_ktype288, \$_vtype289, \$_size287);
-              for (my $_i291 = 0; $_i291 < $_size287; ++$_i291)
+              my $_size294 = 0;
+              $val293 = {};
+              my $_ktype295 = 0;
+              my $_vtype296 = 0;
+              $xfer += $input->readMapBegin(\$_ktype295, \$_vtype296, \$_size294);
+              for (my $_i298 = 0; $_i298 < $_size294; ++$_i298)
               {
-                my $key292 = '';
-                my $val293 = 0;
-                $xfer += $input->readString(\$key292);
-                $xfer += $input->readI32(\$val293);
-                $val286->{$key292} = $val293;
+                my $key299 = '';
+                my $val300 = 0;
+                $xfer += $input->readString(\$key299);
+                $xfer += $input->readI32(\$val300);
+                $val293->{$key299} = $val300;
               }
               $xfer += $input->readMapEnd();
             }
-            $self->{success}->{$key285} = $val286;
+            $self->{success}->{$key292} = $val293;
           }
           $xfer += $input->readMapEnd();
         }
@@ -4825,16 +4825,16 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::MAP, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter294,$viter295) = each %{$self->{success}}) 
+        while( my ($kiter301,$viter302) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter294);
+          $xfer += $output->writeString($kiter301);
           {
-            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter295}}));
+            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter302}}));
             {
-              while( my ($kiter296,$viter297) = each %{${viter295}}) 
+              while( my ($kiter303,$viter304) = each %{${viter302}}) 
               {
-                $xfer += $output->writeString($kiter296);
-                $xfer += $output->writeI32($viter297);
+                $xfer += $output->writeString($kiter303);
+                $xfer += $output->writeI32($viter304);
               }
             }
             $xfer += $output->writeMapEnd();
@@ -5087,18 +5087,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size298 = 0;
+          my $_size305 = 0;
           $self->{success} = {};
-          my $_ktype299 = 0;
-          my $_vtype300 = 0;
-          $xfer += $input->readMapBegin(\$_ktype299, \$_vtype300, \$_size298);
-          for (my $_i302 = 0; $_i302 < $_size298; ++$_i302)
+          my $_ktype306 = 0;
+          my $_vtype307 = 0;
+          $xfer += $input->readMapBegin(\$_ktype306, \$_vtype307, \$_size305);
+          for (my $_i309 = 0; $_i309 < $_size305; ++$_i309)
           {
-            my $key303 = '';
-            my $val304 = '';
-            $xfer += $input->readString(\$key303);
-            $xfer += $input->readString(\$val304);
-            $self->{success}->{$key303} = $val304;
+            my $key310 = '';
+            my $val311 = '';
+            $xfer += $input->readString(\$key310);
+            $xfer += $input->readString(\$val311);
+            $self->{success}->{$key310} = $val311;
           }
           $xfer += $input->readMapEnd();
         }
@@ -5130,10 +5130,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter305,$viter306) = each %{$self->{success}}) 
+        while( my ($kiter312,$viter313) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter305);
-          $xfer += $output->writeString($viter306);
+          $xfer += $output->writeString($kiter312);
+          $xfer += $output->writeString($viter313);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -5188,15 +5188,15 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::SET) {
         {
-          my $_size307 = 0;
+          my $_size314 = 0;
           $self->{metrics} = {};
-          my $_etype310 = 0;
-          $xfer += $input->readSetBegin(\$_etype310, \$_size307);
-          for (my $_i311 = 0; $_i311 < $_size307; ++$_i311)
+          my $_etype317 = 0;
+          $xfer += $input->readSetBegin(\$_etype317, \$_size314);
+          for (my $_i318 = 0; $_i318 < $_size314; ++$_i318)
           {
-            my $elem312 = undef;
-            $xfer += $input->readString(\$elem312);
-            $self->{metrics}->{$elem312} = 1;
+            my $elem319 = undef;
+            $xfer += $input->readString(\$elem319);
+            $self->{metrics}->{$elem319} = 1;
           }
           $xfer += $input->readSetEnd();
         }
@@ -5221,9 +5221,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{metrics}}));
       {
-        foreach my $iter313 (@{$self->{metrics}})
+        foreach my $iter320 (@{$self->{metrics}})
         {
-          $xfer += $output->writeString($iter313);
+          $xfer += $output->writeString($iter320);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -5277,19 +5277,19 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size314 = 0;
+          my $_size321 = 0;
           $self->{success} = {};
-          my $_ktype315 = 0;
-          my $_vtype316 = 0;
-          $xfer += $input->readMapBegin(\$_ktype315, \$_vtype316, \$_size314);
-          for (my $_i318 = 0; $_i318 < $_size314; ++$_i318)
+          my $_ktype322 = 0;
+          my $_vtype323 = 0;
+          $xfer += $input->readMapBegin(\$_ktype322, \$_vtype323, \$_size321);
+          for (my $_i325 = 0; $_i325 < $_size321; ++$_i325)
           {
-            my $key319 = '';
-            my $val320 = new Blur::Metric();
-            $xfer += $input->readString(\$key319);
-            $val320 = new Blur::Metric();
-            $xfer += $val320->read($input);
-            $self->{success}->{$key319} = $val320;
+            my $key326 = '';
+            my $val327 = new Blur::Metric();
+            $xfer += $input->readString(\$key326);
+            $val327 = new Blur::Metric();
+            $xfer += $val327->read($input);
+            $self->{success}->{$key326} = $val327;
           }
           $xfer += $input->readMapEnd();
         }
@@ -5321,10 +5321,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter321,$viter322) = each %{$self->{success}}) 
+        while( my ($kiter328,$viter329) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter321);
-          $xfer += ${viter322}->write($output);
+          $xfer += $output->writeString($kiter328);
+          $xfer += ${viter329}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -5554,15 +5554,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size323 = 0;
+          my $_size330 = 0;
           $self->{success} = [];
-          my $_etype326 = 0;
-          $xfer += $input->readListBegin(\$_etype326, \$_size323);
-          for (my $_i327 = 0; $_i327 < $_size323; ++$_i327)
+          my $_etype333 = 0;
+          $xfer += $input->readListBegin(\$_etype333, \$_size330);
+          for (my $_i334 = 0; $_i334 < $_size330; ++$_i334)
           {
-            my $elem328 = undef;
-            $xfer += $input->readString(\$elem328);
-            push(@{$self->{success}},$elem328);
+            my $elem335 = undef;
+            $xfer += $input->readString(\$elem335);
+            push(@{$self->{success}},$elem335);
           }
           $xfer += $input->readListEnd();
         }
@@ -5594,9 +5594,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter329 (@{$self->{success}}) 
+        foreach my $iter336 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter329);
+          $xfer += $output->writeString($iter336);
         }
       }
       $xfer += $output->writeListEnd();
@@ -5719,15 +5719,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size330 = 0;
+          my $_size337 = 0;
           $self->{success} = [];
-          my $_etype333 = 0;
-          $xfer += $input->readListBegin(\$_etype333, \$_size330);
-          for (my $_i334 = 0; $_i334 < $_size330; ++$_i334)
+          my $_etype340 = 0;
+          $xfer += $input->readListBegin(\$_etype340, \$_size337);
+          for (my $_i341 = 0; $_i341 < $_size337; ++$_i341)
           {
-            my $elem335 = undef;
-            $xfer += $input->readString(\$elem335);
-            push(@{$self->{success}},$elem335);
+            my $elem342 = undef;
+            $xfer += $input->readString(\$elem342);
+            push(@{$self->{success}},$elem342);
           }
           $xfer += $input->readListEnd();
         }
@@ -5759,9 +5759,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter336 (@{$self->{success}}) 
+        foreach my $iter343 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter336);
+          $xfer += $output->writeString($iter343);
         }
       }
       $xfer += $output->writeListEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/c98be3e2/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm b/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
index 03799b7..0fb4e14 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
@@ -335,7 +335,7 @@ sub write {
 
 package Blur::Row;
 use base qw(Class::Accessor);
-Blur::Row->mk_accessors( qw( id records recordCount ) );
+Blur::Row->mk_accessors( qw( id records ) );
 
 sub new {
   my $classname = shift;
@@ -343,7 +343,6 @@ sub new {
   my $vals      = shift || {};
   $self->{id} = undef;
   $self->{records} = undef;
-  $self->{recordCount} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{id}) {
       $self->{id} = $vals->{id};
@@ -351,9 +350,6 @@ sub new {
     if (defined $vals->{records}) {
       $self->{records} = $vals->{records};
     }
-    if (defined $vals->{recordCount}) {
-      $self->{recordCount} = $vals->{recordCount};
-    }
   }
   return bless ($self, $classname);
 }
@@ -402,12 +398,6 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^3$/ && do{      if ($ftype == TType::I32) {
-        $xfer += $input->readI32(\$self->{recordCount});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -439,11 +429,6 @@ sub write {
     }
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{recordCount}) {
-    $xfer += $output->writeFieldBegin('recordCount', TType::I32, 3);
-    $xfer += $output->writeI32($self->{recordCount});
-    $xfer += $output->writeFieldEnd();
-  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
@@ -670,7 +655,7 @@ sub write {
 
 package Blur::Selector;
 use base qw(Class::Accessor);
-Blur::Selector->mk_accessors( qw( recordOnly locationId rowId recordId columnFamiliesToFetch columnsToFetch startRecord maxRecordsToFetch highlightOptions ) );
+Blur::Selector->mk_accessors( qw( recordOnly locationId rowId recordId columnFamiliesToFetch columnsToFetch startRecord maxRecordsToFetch highlightOptions orderOfFamiliesToFetch ) );
 
 sub new {
   my $classname = shift;
@@ -685,6 +670,7 @@ sub new {
   $self->{startRecord} = 0;
   $self->{maxRecordsToFetch} = 1000;
   $self->{highlightOptions} = undef;
+  $self->{orderOfFamiliesToFetch} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{recordOnly}) {
       $self->{recordOnly} = $vals->{recordOnly};
@@ -713,6 +699,9 @@ sub new {
     if (defined $vals->{highlightOptions}) {
       $self->{highlightOptions} = $vals->{highlightOptions};
     }
+    if (defined $vals->{orderOfFamiliesToFetch}) {
+      $self->{orderOfFamiliesToFetch} = $vals->{orderOfFamiliesToFetch};
+    }
   }
   return bless ($self, $classname);
 }
@@ -760,19 +749,19 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^5$/ && do{      if ($ftype == TType::LIST) {
+      /^5$/ && do{      if ($ftype == TType::SET) {
         {
           my $_size14 = 0;
-          $self->{columnFamiliesToFetch} = [];
+          $self->{columnFamiliesToFetch} = {};
           my $_etype17 = 0;
-          $xfer += $input->readListBegin(\$_etype17, \$_size14);
+          $xfer += $input->readSetBegin(\$_etype17, \$_size14);
           for (my $_i18 = 0; $_i18 < $_size14; ++$_i18)
           {
             my $elem19 = undef;
             $xfer += $input->readString(\$elem19);
-            push(@{$self->{columnFamiliesToFetch}},$elem19);
+            $self->{columnFamiliesToFetch}->{$elem19} = 1;
           }
-          $xfer += $input->readListEnd();
+          $xfer += $input->readSetEnd();
         }
       } else {
         $xfer += $input->skip($ftype);
@@ -830,6 +819,24 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
+      /^11$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size33 = 0;
+          $self->{orderOfFamiliesToFetch} = [];
+          my $_etype36 = 0;
+          $xfer += $input->readListBegin(\$_etype36, \$_size33);
+          for (my $_i37 = 0; $_i37 < $_size33; ++$_i37)
+          {
+            my $elem38 = undef;
+            $xfer += $input->readString(\$elem38);
+            push(@{$self->{orderOfFamiliesToFetch}},$elem38);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -863,16 +870,16 @@ sub write {
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{columnFamiliesToFetch}) {
-    $xfer += $output->writeFieldBegin('columnFamiliesToFetch', TType::LIST, 5);
+    $xfer += $output->writeFieldBegin('columnFamiliesToFetch', TType::SET, 5);
     {
-      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{columnFamiliesToFetch}}));
+      $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{columnFamiliesToFetch}}));
       {
-        foreach my $iter33 (@{$self->{columnFamiliesToFetch}}) 
+        foreach my $iter39 (@{$self->{columnFamiliesToFetch}})
         {
-          $xfer += $output->writeString($iter33);
+          $xfer += $output->writeString($iter39);
         }
       }
-      $xfer += $output->writeListEnd();
+      $xfer += $output->writeSetEnd();
     }
     $xfer += $output->writeFieldEnd();
   }
@@ -881,15 +888,15 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::SET, scalar(keys %{$self->{columnsToFetch}}));
       {
-        while( my ($kiter34,$viter35) = each %{$self->{columnsToFetch}}) 
+        while( my ($kiter40,$viter41) = each %{$self->{columnsToFetch}}) 
         {
-          $xfer += $output->writeString($kiter34);
+          $xfer += $output->writeString($kiter40);
           {
-            $xfer += $output->writeSetBegin(TType::STRING, scalar(@{${viter35}}));
+            $xfer += $output->writeSetBegin(TType::STRING, scalar(@{${viter41}}));
             {
-              foreach my $iter36 (@{${viter35}})
+              foreach my $iter42 (@{${viter41}})
               {
-                $xfer += $output->writeString($iter36);
+                $xfer += $output->writeString($iter42);
               }
             }
             $xfer += $output->writeSetEnd();
@@ -915,6 +922,20 @@ sub write {
     $xfer += $self->{highlightOptions}->write($output);
     $xfer += $output->writeFieldEnd();
   }
+  if (defined $self->{orderOfFamiliesToFetch}) {
+    $xfer += $output->writeFieldBegin('orderOfFamiliesToFetch', TType::LIST, 11);
+    {
+      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{orderOfFamiliesToFetch}}));
+      {
+        foreach my $iter43 (@{$self->{orderOfFamiliesToFetch}}) 
+        {
+          $xfer += $output->writeString($iter43);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
@@ -922,7 +943,7 @@ sub write {
 
 package Blur::FetchRowResult;
 use base qw(Class::Accessor);
-Blur::FetchRowResult->mk_accessors( qw( row startRecord maxRecordsToFetch moreRecordsToFetch ) );
+Blur::FetchRowResult->mk_accessors( qw( row startRecord maxRecordsToFetch moreRecordsToFetch totalRecords ) );
 
 sub new {
   my $classname = shift;
@@ -932,6 +953,7 @@ sub new {
   $self->{startRecord} = -1;
   $self->{maxRecordsToFetch} = -1;
   $self->{moreRecordsToFetch} = 0;
+  $self->{totalRecords} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{row}) {
       $self->{row} = $vals->{row};
@@ -945,6 +967,9 @@ sub new {
     if (defined $vals->{moreRecordsToFetch}) {
       $self->{moreRecordsToFetch} = $vals->{moreRecordsToFetch};
     }
+    if (defined $vals->{totalRecords}) {
+      $self->{totalRecords} = $vals->{totalRecords};
+    }
   }
   return bless ($self, $classname);
 }
@@ -993,6 +1018,12 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
+      /^5$/ && do{      if ($ftype == TType::I32) {
+        $xfer += $input->readI32(\$self->{totalRecords});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -1025,6 +1056,11 @@ sub write {
     $xfer += $output->writeBool($self->{moreRecordsToFetch});
     $xfer += $output->writeFieldEnd();
   }
+  if (defined $self->{totalRecords}) {
+    $xfer += $output->writeFieldBegin('totalRecords', TType::I32, 5);
+    $xfer += $output->writeI32($self->{totalRecords});
+    $xfer += $output->writeFieldEnd();
+  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
@@ -1404,16 +1440,16 @@ sub read {
       last; };
       /^3$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size37 = 0;
+          my $_size44 = 0;
           $self->{facets} = [];
-          my $_etype40 = 0;
-          $xfer += $input->readListBegin(\$_etype40, \$_size37);
-          for (my $_i41 = 0; $_i41 < $_size37; ++$_i41)
+          my $_etype47 = 0;
+          $xfer += $input->readListBegin(\$_etype47, \$_size44);
+          for (my $_i48 = 0; $_i48 < $_size44; ++$_i48)
           {
-            my $elem42 = undef;
-            $elem42 = new Blur::Facet();
-            $xfer += $elem42->read($input);
-            push(@{$self->{facets}},$elem42);
+            my $elem49 = undef;
+            $elem49 = new Blur::Facet();
+            $xfer += $elem49->read($input);
+            push(@{$self->{facets}},$elem49);
           }
           $xfer += $input->readListEnd();
         }
@@ -1504,9 +1540,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{facets}}));
       {
-        foreach my $iter43 (@{$self->{facets}}) 
+        foreach my $iter50 (@{$self->{facets}}) 
         {
-          $xfer += ${iter43}->write($output);
+          $xfer += ${iter50}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1727,18 +1763,18 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size44 = 0;
+          my $_size51 = 0;
           $self->{shardInfo} = {};
-          my $_ktype45 = 0;
-          my $_vtype46 = 0;
-          $xfer += $input->readMapBegin(\$_ktype45, \$_vtype46, \$_size44);
-          for (my $_i48 = 0; $_i48 < $_size44; ++$_i48)
+          my $_ktype52 = 0;
+          my $_vtype53 = 0;
+          $xfer += $input->readMapBegin(\$_ktype52, \$_vtype53, \$_size51);
+          for (my $_i55 = 0; $_i55 < $_size51; ++$_i55)
           {
-            my $key49 = '';
-            my $val50 = 0;
-            $xfer += $input->readString(\$key49);
-            $xfer += $input->readI64(\$val50);
-            $self->{shardInfo}->{$key49} = $val50;
+            my $key56 = '';
+            my $val57 = 0;
+            $xfer += $input->readString(\$key56);
+            $xfer += $input->readI64(\$val57);
+            $self->{shardInfo}->{$key56} = $val57;
           }
           $xfer += $input->readMapEnd();
         }
@@ -1748,16 +1784,16 @@ sub read {
       last; };
       /^3$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size51 = 0;
+          my $_size58 = 0;
           $self->{results} = [];
-          my $_etype54 = 0;
-          $xfer += $input->readListBegin(\$_etype54, \$_size51);
-          for (my $_i55 = 0; $_i55 < $_size51; ++$_i55)
+          my $_etype61 = 0;
+          $xfer += $input->readListBegin(\$_etype61, \$_size58);
+          for (my $_i62 = 0; $_i62 < $_size58; ++$_i62)
           {
-            my $elem56 = undef;
-            $elem56 = new Blur::BlurResult();
-            $xfer += $elem56->read($input);
-            push(@{$self->{results}},$elem56);
+            my $elem63 = undef;
+            $elem63 = new Blur::BlurResult();
+            $xfer += $elem63->read($input);
+            push(@{$self->{results}},$elem63);
           }
           $xfer += $input->readListEnd();
         }
@@ -1767,15 +1803,15 @@ sub read {
       last; };
       /^4$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size57 = 0;
+          my $_size64 = 0;
           $self->{facetCounts} = [];
-          my $_etype60 = 0;
-          $xfer += $input->readListBegin(\$_etype60, \$_size57);
-          for (my $_i61 = 0; $_i61 < $_size57; ++$_i61)
+          my $_etype67 = 0;
+          $xfer += $input->readListBegin(\$_etype67, \$_size64);
+          for (my $_i68 = 0; $_i68 < $_size64; ++$_i68)
           {
-            my $elem62 = undef;
-            $xfer += $input->readI64(\$elem62);
-            push(@{$self->{facetCounts}},$elem62);
+            my $elem69 = undef;
+            $xfer += $input->readI64(\$elem69);
+            push(@{$self->{facetCounts}},$elem69);
           }
           $xfer += $input->readListEnd();
         }
@@ -1785,16 +1821,16 @@ sub read {
       last; };
       /^5$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size63 = 0;
+          my $_size70 = 0;
           $self->{exceptions} = [];
-          my $_etype66 = 0;
-          $xfer += $input->readListBegin(\$_etype66, \$_size63);
-          for (my $_i67 = 0; $_i67 < $_size63; ++$_i67)
+          my $_etype73 = 0;
+          $xfer += $input->readListBegin(\$_etype73, \$_size70);
+          for (my $_i74 = 0; $_i74 < $_size70; ++$_i74)
           {
-            my $elem68 = undef;
-            $elem68 = new Blur::BlurException();
-            $xfer += $elem68->read($input);
-            push(@{$self->{exceptions}},$elem68);
+            my $elem75 = undef;
+            $elem75 = new Blur::BlurException();
+            $xfer += $elem75->read($input);
+            push(@{$self->{exceptions}},$elem75);
           }
           $xfer += $input->readListEnd();
         }
@@ -1831,10 +1867,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::I64, scalar(keys %{$self->{shardInfo}}));
       {
-        while( my ($kiter69,$viter70) = each %{$self->{shardInfo}}) 
+        while( my ($kiter76,$viter77) = each %{$self->{shardInfo}}) 
         {
-          $xfer += $output->writeString($kiter69);
-          $xfer += $output->writeI64($viter70);
+          $xfer += $output->writeString($kiter76);
+          $xfer += $output->writeI64($viter77);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -1846,9 +1882,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{results}}));
       {
-        foreach my $iter71 (@{$self->{results}}) 
+        foreach my $iter78 (@{$self->{results}}) 
         {
-          $xfer += ${iter71}->write($output);
+          $xfer += ${iter78}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1860,9 +1896,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{facetCounts}}));
       {
-        foreach my $iter72 (@{$self->{facetCounts}}) 
+        foreach my $iter79 (@{$self->{facetCounts}}) 
         {
-          $xfer += $output->writeI64($iter72);
+          $xfer += $output->writeI64($iter79);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1874,9 +1910,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{exceptions}}));
       {
-        foreach my $iter73 (@{$self->{exceptions}}) 
+        foreach my $iter80 (@{$self->{exceptions}}) 
         {
-          $xfer += ${iter73}->write($output);
+          $xfer += ${iter80}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1975,7 +2011,7 @@ sub write {
 
 package Blur::RowMutation;
 use base qw(Class::Accessor);
-Blur::RowMutation->mk_accessors( qw( table rowId wal rowMutationType recordMutations waitToBeVisible ) );
+Blur::RowMutation->mk_accessors( qw( table rowId rowMutationType recordMutations ) );
 
 sub new {
   my $classname = shift;
@@ -1983,10 +2019,8 @@ sub new {
   my $vals      = shift || {};
   $self->{table} = undef;
   $self->{rowId} = undef;
-  $self->{wal} = 1;
   $self->{rowMutationType} = 1;
   $self->{recordMutations} = undef;
-  $self->{waitToBeVisible} = 0;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{table}) {
       $self->{table} = $vals->{table};
@@ -1994,18 +2028,12 @@ sub new {
     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);
 }
@@ -2041,12 +2069,6 @@ sub read {
         $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 {
@@ -2055,16 +2077,16 @@ sub read {
       last; };
       /^5$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size74 = 0;
+          my $_size81 = 0;
           $self->{recordMutations} = [];
-          my $_etype77 = 0;
-          $xfer += $input->readListBegin(\$_etype77, \$_size74);
-          for (my $_i78 = 0; $_i78 < $_size74; ++$_i78)
+          my $_etype84 = 0;
+          $xfer += $input->readListBegin(\$_etype84, \$_size81);
+          for (my $_i85 = 0; $_i85 < $_size81; ++$_i85)
           {
-            my $elem79 = undef;
-            $elem79 = new Blur::RecordMutation();
-            $xfer += $elem79->read($input);
-            push(@{$self->{recordMutations}},$elem79);
+            my $elem86 = undef;
+            $elem86 = new Blur::RecordMutation();
+            $xfer += $elem86->read($input);
+            push(@{$self->{recordMutations}},$elem86);
           }
           $xfer += $input->readListEnd();
         }
@@ -2072,12 +2094,6 @@ sub read {
         $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();
@@ -2100,11 +2116,6 @@ sub write {
     $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});
@@ -2115,20 +2126,15 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{recordMutations}}));
       {
-        foreach my $iter80 (@{$self->{recordMutations}}) 
+        foreach my $iter87 (@{$self->{recordMutations}}) 
         {
-          $xfer += ${iter80}->write($output);
+          $xfer += ${iter87}->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;
@@ -2282,19 +2288,19 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size81 = 0;
+          my $_size88 = 0;
           $self->{cpuTimes} = {};
-          my $_ktype82 = 0;
-          my $_vtype83 = 0;
-          $xfer += $input->readMapBegin(\$_ktype82, \$_vtype83, \$_size81);
-          for (my $_i85 = 0; $_i85 < $_size81; ++$_i85)
+          my $_ktype89 = 0;
+          my $_vtype90 = 0;
+          $xfer += $input->readMapBegin(\$_ktype89, \$_vtype90, \$_size88);
+          for (my $_i92 = 0; $_i92 < $_size88; ++$_i92)
           {
-            my $key86 = '';
-            my $val87 = new Blur::CpuTime();
-            $xfer += $input->readString(\$key86);
-            $val87 = new Blur::CpuTime();
-            $xfer += $val87->read($input);
-            $self->{cpuTimes}->{$key86} = $val87;
+            my $key93 = '';
+            my $val94 = new Blur::CpuTime();
+            $xfer += $input->readString(\$key93);
+            $val94 = new Blur::CpuTime();
+            $xfer += $val94->read($input);
+            $self->{cpuTimes}->{$key93} = $val94;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2354,10 +2360,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{cpuTimes}}));
       {
-        while( my ($kiter88,$viter89) = each %{$self->{cpuTimes}}) 
+        while( my ($kiter95,$viter96) = each %{$self->{cpuTimes}}) 
         {
-          $xfer += $output->writeString($kiter88);
-          $xfer += ${viter89}->write($output);
+          $xfer += $output->writeString($kiter95);
+          $xfer += ${viter96}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -2591,18 +2597,18 @@ sub read {
       last; };
       /^6$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size90 = 0;
+          my $_size97 = 0;
           $self->{properties} = {};
-          my $_ktype91 = 0;
-          my $_vtype92 = 0;
-          $xfer += $input->readMapBegin(\$_ktype91, \$_vtype92, \$_size90);
-          for (my $_i94 = 0; $_i94 < $_size90; ++$_i94)
+          my $_ktype98 = 0;
+          my $_vtype99 = 0;
+          $xfer += $input->readMapBegin(\$_ktype98, \$_vtype99, \$_size97);
+          for (my $_i101 = 0; $_i101 < $_size97; ++$_i101)
           {
-            my $key95 = '';
-            my $val96 = '';
-            $xfer += $input->readString(\$key95);
-            $xfer += $input->readString(\$val96);
-            $self->{properties}->{$key95} = $val96;
+            my $key102 = '';
+            my $val103 = '';
+            $xfer += $input->readString(\$key102);
+            $xfer += $input->readString(\$val103);
+            $self->{properties}->{$key102} = $val103;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2652,10 +2658,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{properties}}));
       {
-        while( my ($kiter97,$viter98) = each %{$self->{properties}}) 
+        while( my ($kiter104,$viter105) = each %{$self->{properties}}) 
         {
-          $xfer += $output->writeString($kiter97);
-          $xfer += $output->writeString($viter98);
+          $xfer += $output->writeString($kiter104);
+          $xfer += $output->writeString($viter105);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -2715,34 +2721,34 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size99 = 0;
+          my $_size106 = 0;
           $self->{families} = {};
-          my $_ktype100 = 0;
-          my $_vtype101 = 0;
-          $xfer += $input->readMapBegin(\$_ktype100, \$_vtype101, \$_size99);
-          for (my $_i103 = 0; $_i103 < $_size99; ++$_i103)
+          my $_ktype107 = 0;
+          my $_vtype108 = 0;
+          $xfer += $input->readMapBegin(\$_ktype107, \$_vtype108, \$_size106);
+          for (my $_i110 = 0; $_i110 < $_size106; ++$_i110)
           {
-            my $key104 = '';
-            my $val105 = [];
-            $xfer += $input->readString(\$key104);
+            my $key111 = '';
+            my $val112 = [];
+            $xfer += $input->readString(\$key111);
             {
-              my $_size106 = 0;
-              $val105 = {};
-              my $_ktype107 = 0;
-              my $_vtype108 = 0;
-              $xfer += $input->readMapBegin(\$_ktype107, \$_vtype108, \$_size106);
-              for (my $_i110 = 0; $_i110 < $_size106; ++$_i110)
+              my $_size113 = 0;
+              $val112 = {};
+              my $_ktype114 = 0;
+              my $_vtype115 = 0;
+              $xfer += $input->readMapBegin(\$_ktype114, \$_vtype115, \$_size113);
+              for (my $_i117 = 0; $_i117 < $_size113; ++$_i117)
               {
-                my $key111 = '';
-                my $val112 = new Blur::ColumnDefinition();
-                $xfer += $input->readString(\$key111);
-                $val112 = new Blur::ColumnDefinition();
-                $xfer += $val112->read($input);
-                $val105->{$key111} = $val112;
+                my $key118 = '';
+                my $val119 = new Blur::ColumnDefinition();
+                $xfer += $input->readString(\$key118);
+                $val119 = new Blur::ColumnDefinition();
+                $xfer += $val119->read($input);
+                $val112->{$key118} = $val119;
               }
               $xfer += $input->readMapEnd();
             }
-            $self->{families}->{$key104} = $val105;
+            $self->{families}->{$key111} = $val112;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2772,16 +2778,16 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::MAP, scalar(keys %{$self->{families}}));
       {
-        while( my ($kiter113,$viter114) = each %{$self->{families}}) 
+        while( my ($kiter120,$viter121) = each %{$self->{families}}) 
         {
-          $xfer += $output->writeString($kiter113);
+          $xfer += $output->writeString($kiter120);
           {
-            $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{${viter114}}));
+            $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{${viter121}}));
             {
-              while( my ($kiter115,$viter116) = each %{${viter114}}) 
+              while( my ($kiter122,$viter123) = each %{${viter121}}) 
               {
-                $xfer += $output->writeString($kiter115);
-                $xfer += ${viter116}->write($output);
+                $xfer += $output->writeString($kiter122);
+                $xfer += ${viter123}->write($output);
               }
             }
             $xfer += $output->writeMapEnd();
@@ -2933,15 +2939,15 @@ sub read {
       last; };
       /^11$/ && do{      if ($ftype == TType::SET) {
         {
-          my $_size117 = 0;
+          my $_size124 = 0;
           $self->{blockCachingFileTypes} = {};
-          my $_etype120 = 0;
-          $xfer += $input->readSetBegin(\$_etype120, \$_size117);
-          for (my $_i121 = 0; $_i121 < $_size117; ++$_i121)
+          my $_etype127 = 0;
+          $xfer += $input->readSetBegin(\$_etype127, \$_size124);
+          for (my $_i128 = 0; $_i128 < $_size124; ++$_i128)
           {
-            my $elem122 = undef;
-            $xfer += $input->readString(\$elem122);
-            $self->{blockCachingFileTypes}->{$elem122} = 1;
+            my $elem129 = undef;
+            $xfer += $input->readString(\$elem129);
+            $self->{blockCachingFileTypes}->{$elem129} = 1;
           }
           $xfer += $input->readSetEnd();
         }
@@ -2957,15 +2963,15 @@ sub read {
       last; };
       /^13$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size123 = 0;
+          my $_size130 = 0;
           $self->{preCacheCols} = [];
-          my $_etype126 = 0;
-          $xfer += $input->readListBegin(\$_etype126, \$_size123);
-          for (my $_i127 = 0; $_i127 < $_size123; ++$_i127)
+          my $_etype133 = 0;
+          $xfer += $input->readListBegin(\$_etype133, \$_size130);
+          for (my $_i134 = 0; $_i134 < $_size130; ++$_i134)
           {
-            my $elem128 = undef;
-            $xfer += $input->readString(\$elem128);
-            push(@{$self->{preCacheCols}},$elem128);
+            my $elem135 = undef;
+            $xfer += $input->readString(\$elem135);
+            push(@{$self->{preCacheCols}},$elem135);
           }
           $xfer += $input->readListEnd();
         }
@@ -2975,18 +2981,18 @@ sub read {
       last; };
       /^14$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size129 = 0;
+          my $_size136 = 0;
           $self->{tableProperties} = {};
-          my $_ktype130 = 0;
-          my $_vtype131 = 0;
-          $xfer += $input->readMapBegin(\$_ktype130, \$_vtype131, \$_size129);
-          for (my $_i133 = 0; $_i133 < $_size129; ++$_i133)
+          my $_ktype137 = 0;
+          my $_vtype138 = 0;
+          $xfer += $input->readMapBegin(\$_ktype137, \$_vtype138, \$_size136);
+          for (my $_i140 = 0; $_i140 < $_size136; ++$_i140)
           {
-            my $key134 = '';
-            my $val135 = '';
-            $xfer += $input->readString(\$key134);
-            $xfer += $input->readString(\$val135);
-            $self->{tableProperties}->{$key134} = $val135;
+            my $key141 = '';
+            my $val142 = '';
+            $xfer += $input->readString(\$key141);
+            $xfer += $input->readString(\$val142);
+            $self->{tableProperties}->{$key141} = $val142;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3014,18 +3020,18 @@ sub read {
       last; };
       /^18$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size136 = 0;
+          my $_size143 = 0;
           $self->{defaultMissingFieldProps} = {};
-          my $_ktype137 = 0;
-          my $_vtype138 = 0;
-          $xfer += $input->readMapBegin(\$_ktype137, \$_vtype138, \$_size136);
-          for (my $_i140 = 0; $_i140 < $_size136; ++$_i140)
+          my $_ktype144 = 0;
+          my $_vtype145 = 0;
+          $xfer += $input->readMapBegin(\$_ktype144, \$_vtype145, \$_size143);
+          for (my $_i147 = 0; $_i147 < $_size143; ++$_i147)
           {
-            my $key141 = '';
-            my $val142 = '';
-            $xfer += $input->readString(\$key141);
-            $xfer += $input->readString(\$val142);
-            $self->{defaultMissingFieldProps}->{$key141} = $val142;
+            my $key148 = '';
+            my $val149 = '';
+            $xfer += $input->readString(\$key148);
+            $xfer += $input->readString(\$val149);
+            $self->{defaultMissingFieldProps}->{$key148} = $val149;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3085,9 +3091,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{blockCachingFileTypes}}));
       {
-        foreach my $iter143 (@{$self->{blockCachingFileTypes}})
+        foreach my $iter150 (@{$self->{blockCachingFileTypes}})
         {
-          $xfer += $output->writeString($iter143);
+          $xfer += $output->writeString($iter150);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -3104,9 +3110,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{preCacheCols}}));
       {
-        foreach my $iter144 (@{$self->{preCacheCols}}) 
+        foreach my $iter151 (@{$self->{preCacheCols}}) 
         {
-          $xfer += $output->writeString($iter144);
+          $xfer += $output->writeString($iter151);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3118,10 +3124,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{tableProperties}}));
       {
-        while( my ($kiter145,$viter146) = each %{$self->{tableProperties}}) 
+        while( my ($kiter152,$viter153) = each %{$self->{tableProperties}}) 
         {
-          $xfer += $output->writeString($kiter145);
-          $xfer += $output->writeString($viter146);
+          $xfer += $output->writeString($kiter152);
+          $xfer += $output->writeString($viter153);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3148,10 +3154,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{defaultMissingFieldProps}}));
       {
-        while( my ($kiter147,$viter148) = each %{$self->{defaultMissingFieldProps}}) 
+        while( my ($kiter154,$viter155) = each %{$self->{defaultMissingFieldProps}}) 
         {
-          $xfer += $output->writeString($kiter147);
-          $xfer += $output->writeString($viter148);
+          $xfer += $output->writeString($kiter154);
+          $xfer += $output->writeString($viter155);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3219,39 +3225,18 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size149 = 0;
-          $self->{strMap} = {};
-          my $_ktype150 = 0;
-          my $_vtype151 = 0;
-          $xfer += $input->readMapBegin(\$_ktype150, \$_vtype151, \$_size149);
-          for (my $_i153 = 0; $_i153 < $_size149; ++$_i153)
-          {
-            my $key154 = '';
-            my $val155 = '';
-            $xfer += $input->readString(\$key154);
-            $xfer += $input->readString(\$val155);
-            $self->{strMap}->{$key154} = $val155;
-          }
-          $xfer += $input->readMapEnd();
-        }
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^3$/ && do{      if ($ftype == TType::MAP) {
-        {
           my $_size156 = 0;
-          $self->{longMap} = {};
+          $self->{strMap} = {};
           my $_ktype157 = 0;
           my $_vtype158 = 0;
           $xfer += $input->readMapBegin(\$_ktype157, \$_vtype158, \$_size156);
           for (my $_i160 = 0; $_i160 < $_size156; ++$_i160)
           {
             my $key161 = '';
-            my $val162 = 0;
+            my $val162 = '';
             $xfer += $input->readString(\$key161);
-            $xfer += $input->readI64(\$val162);
-            $self->{longMap}->{$key161} = $val162;
+            $xfer += $input->readString(\$val162);
+            $self->{strMap}->{$key161} = $val162;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3259,20 +3244,41 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^4$/ && do{      if ($ftype == TType::MAP) {
+      /^3$/ && do{      if ($ftype == TType::MAP) {
         {
           my $_size163 = 0;
-          $self->{doubleMap} = {};
+          $self->{longMap} = {};
           my $_ktype164 = 0;
           my $_vtype165 = 0;
           $xfer += $input->readMapBegin(\$_ktype164, \$_vtype165, \$_size163);
           for (my $_i167 = 0; $_i167 < $_size163; ++$_i167)
           {
             my $key168 = '';
-            my $val169 = 0.0;
+            my $val169 = 0;
             $xfer += $input->readString(\$key168);
-            $xfer += $input->readDouble(\$val169);
-            $self->{doubleMap}->{$key168} = $val169;
+            $xfer += $input->readI64(\$val169);
+            $self->{longMap}->{$key168} = $val169;
+          }
+          $xfer += $input->readMapEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::MAP) {
+        {
+          my $_size170 = 0;
+          $self->{doubleMap} = {};
+          my $_ktype171 = 0;
+          my $_vtype172 = 0;
+          $xfer += $input->readMapBegin(\$_ktype171, \$_vtype172, \$_size170);
+          for (my $_i174 = 0; $_i174 < $_size170; ++$_i174)
+          {
+            my $key175 = '';
+            my $val176 = 0.0;
+            $xfer += $input->readString(\$key175);
+            $xfer += $input->readDouble(\$val176);
+            $self->{doubleMap}->{$key175} = $val176;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3302,10 +3308,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{strMap}}));
       {
-        while( my ($kiter170,$viter171) = each %{$self->{strMap}}) 
+        while( my ($kiter177,$viter178) = each %{$self->{strMap}}) 
         {
-          $xfer += $output->writeString($kiter170);
-          $xfer += $output->writeString($viter171);
+          $xfer += $output->writeString($kiter177);
+          $xfer += $output->writeString($viter178);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3317,10 +3323,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::I64, scalar(keys %{$self->{longMap}}));
       {
-        while( my ($kiter172,$viter173) = each %{$self->{longMap}}) 
+        while( my ($kiter179,$viter180) = each %{$self->{longMap}}) 
         {
-          $xfer += $output->writeString($kiter172);
-          $xfer += $output->writeI64($viter173);
+          $xfer += $output->writeString($kiter179);
+          $xfer += $output->writeI64($viter180);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3332,10 +3338,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::DOUBLE, scalar(keys %{$self->{doubleMap}}));
       {
-        while( my ($kiter174,$viter175) = each %{$self->{doubleMap}}) 
+        while( my ($kiter181,$viter182) = each %{$self->{doubleMap}}) 
         {
-          $xfer += $output->writeString($kiter174);
-          $xfer += $output->writeDouble($viter175);
+          $xfer += $output->writeString($kiter181);
+          $xfer += $output->writeDouble($viter182);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3395,18 +3401,18 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size176 = 0;
+          my $_size183 = 0;
           $self->{attributes} = {};
-          my $_ktype177 = 0;
-          my $_vtype178 = 0;
-          $xfer += $input->readMapBegin(\$_ktype177, \$_vtype178, \$_size176);
-          for (my $_i180 = 0; $_i180 < $_size176; ++$_i180)
+          my $_ktype184 = 0;
+          my $_vtype185 = 0;
+          $xfer += $input->readMapBegin(\$_ktype184, \$_vtype185, \$_size183);
+          for (my $_i187 = 0; $_i187 < $_size183; ++$_i187)
           {
-            my $key181 = '';
-            my $val182 = '';
-            $xfer += $input->readString(\$key181);
-            $xfer += $input->readString(\$val182);
-            $self->{attributes}->{$key181} = $val182;
+            my $key188 = '';
+            my $val189 = '';
+            $xfer += $input->readString(\$key188);
+            $xfer += $input->readString(\$val189);
+            $self->{attributes}->{$key188} = $val189;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3436,10 +3442,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{attributes}}));
       {
-        while( my ($kiter183,$viter184) = each %{$self->{attributes}}) 
+        while( my ($kiter190,$viter191) = each %{$self->{attributes}}) 
         {
-          $xfer += $output->writeString($kiter183);
-          $xfer += $output->writeString($viter184);
+          $xfer += $output->writeString($kiter190);
+          $xfer += $output->writeString($viter191);
         }
       }
       $xfer += $output->writeMapEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/c98be3e2/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-rb/blur_types.rb b/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
index b4bcae4..033dff8 100644
--- a/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
+++ b/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
@@ -147,17 +147,13 @@ module Blur
     include ::Thrift::Struct, ::Thrift::Struct_Union
     ID = 1
     RECORDS = 2
-    RECORDCOUNT = 3
 
     FIELDS = {
       # The row id.
       ID => {:type => ::Thrift::Types::STRING, :name => 'id'},
       # The list records within the row.  If paging is used this list will only
 # reflect the paged records from the selector.
-      RECORDS => {:type => ::Thrift::Types::LIST, :name => 'records', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::Record}},
-      # The total record count for the row.  If paging is used in a selector to page
-# through records of a row, this count will reflect the entire row.
-      RECORDCOUNT => {:type => ::Thrift::Types::I32, :name => 'recordCount'}
+      RECORDS => {:type => ::Thrift::Types::LIST, :name => 'records', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::Record}}
     }
 
     def struct_fields; FIELDS; end
@@ -246,6 +242,7 @@ module Blur
     STARTRECORD = 8
     MAXRECORDSTOFETCH = 9
     HIGHLIGHTOPTIONS = 10
+    ORDEROFFAMILIESTOFETCH = 11
 
     FIELDS = {
       # Fetch the Record only, not the entire Row.
@@ -257,9 +254,9 @@ module Blur
       ROWID => {:type => ::Thrift::Types::STRING, :name => 'rowId'},
       # The record id of the Record to be fetched, not to be used with location id.  However the row id needs to be provided to locate the correct Row with the requested Record.
       RECORDID => {:type => ::Thrift::Types::STRING, :name => 'recordId'},
-      # The column families to fetch.  If null, fetch all.  If empty, fetch none.
-      COLUMNFAMILIESTOFETCH => {:type => ::Thrift::Types::LIST, :name => 'columnFamiliesToFetch', :element => {:type => ::Thrift::Types::STRING}},
-      # The columns in the families to fetch.  If null, fetch all.  If empty, fetch none.
+      # The column families to fetch. If null, fetch all. If empty, fetch none.
+      COLUMNFAMILIESTOFETCH => {:type => ::Thrift::Types::SET, :name => 'columnFamiliesToFetch', :element => {:type => ::Thrift::Types::STRING}},
+      # The columns in the families to fetch. If null, fetch all. If empty, fetch none.
       COLUMNSTOFETCH => {:type => ::Thrift::Types::MAP, :name => 'columnsToFetch', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::SET, :element => {:type => ::Thrift::Types::STRING}}},
       # Only valid for Row fetches, the record in the row to start fetching.  If the row contains 1000
 # records and you want the first 100, then this value is 0.  If you want records 300-400 then this
@@ -272,7 +269,9 @@ module Blur
 # 1000 records of the row.
       MAXRECORDSTOFETCH => {:type => ::Thrift::Types::I32, :name => 'maxRecordsToFetch', :default => 1000},
       # The HighlightOptions object controls how the data is highlighted.  If null no highlighting will occur.
-      HIGHLIGHTOPTIONS => {:type => ::Thrift::Types::STRUCT, :name => 'highlightOptions', :class => ::Blur::HighlightOptions}
+      HIGHLIGHTOPTIONS => {:type => ::Thrift::Types::STRUCT, :name => 'highlightOptions', :class => ::Blur::HighlightOptions},
+      # Can be null, if provided the provided family order will be the order in which the families are returned.
+      ORDEROFFAMILIESTOFETCH => {:type => ::Thrift::Types::LIST, :name => 'orderOfFamiliesToFetch', :element => {:type => ::Thrift::Types::STRING}}
     }
 
     def struct_fields; FIELDS; end
@@ -290,6 +289,7 @@ module Blur
     STARTRECORD = 2
     MAXRECORDSTOFETCH = 3
     MORERECORDSTOFETCH = 4
+    TOTALRECORDS = 5
 
     FIELDS = {
       # The row fetched.
@@ -299,7 +299,9 @@ module Blur
       # See Selector maxRecordsToFetch.
       MAXRECORDSTOFETCH => {:type => ::Thrift::Types::I32, :name => 'maxRecordsToFetch', :default => -1},
       # Are there more Records to fetch based on the Selector provided.
-      MORERECORDSTOFETCH => {:type => ::Thrift::Types::BOOL, :name => 'moreRecordsToFetch', :default => false}
+      MORERECORDSTOFETCH => {:type => ::Thrift::Types::BOOL, :name => 'moreRecordsToFetch', :default => false},
+      # The total number of records the Selector found.
+      TOTALRECORDS => {:type => ::Thrift::Types::I32, :name => 'totalRecords'}
     }
 
     def struct_fields; FIELDS; end
@@ -528,24 +530,18 @@ module Blur
     include ::Thrift::Struct, ::Thrift::Struct_Union
     TABLE = 1
     ROWID = 2
-    WAL = 3
     ROWMUTATIONTYPE = 4
     RECORDMUTATIONS = 5
-    WAITTOBEVISIBLE = 6
 
     FIELDS = {
       # The table 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},
       # The RowMutationType to define how to mutate the given Row.
       ROWMUTATIONTYPE => {:type => ::Thrift::Types::I32, :name => 'rowMutationType', :default =>       1, :enum_class => ::Blur::RowMutationType},
       # The RecordMutations if any for this Row.
-      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}
+      RECORDMUTATIONS => {:type => ::Thrift::Types::LIST, :name => 'recordMutations', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::RecordMutation}}
     }
 
     def struct_fields; FIELDS; end

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/c98be3e2/docs/Blur.html
----------------------------------------------------------------------
diff --git a/docs/Blur.html b/docs/Blur.html
index 58dcc13..cd636bd 100644
--- a/docs/Blur.html
+++ b/docs/Blur.html
@@ -276,9 +276,6 @@ trace (if any).
 <tr><td>2</td><td>records</td><td><code>list&lt;<code><a href="Blur.html#Struct_Record">Record</a></code>&gt;</code></td><td>The list records within the row.  If paging is used this list will only
 reflect the paged records from the selector.
 </td><td>default</td><td></td></tr>
-<tr><td>3</td><td>recordCount</td><td><code>i32</code></td><td>The total record count for the row.  If paging is used in a selector to page
-through records of a row, this count will reflect the entire row.
-</td><td>default</td><td></td></tr>
 </table><br/>Rows contain a list of records.
 <br/></p></section><section><div class="page-header"><h3 id="Struct_Query">Struct: Query</h3></div><p class="lead">
 <table class="table-bordered table-striped table-condensed"><thead><th>Key</th><th>Field</th><th>Type</th><th>Description</th><th>Requiredness</th><th>Default value</th></thead>
@@ -322,9 +319,9 @@ The location id of the Record or Row to be fetched.
 </td><td>default</td><td></td></tr>
 <tr><td>4</td><td>recordId</td><td><code>string</code></td><td>The record id of the Record to be fetched, not to be used with location id.  However the row id needs to be provided to locate the correct Row with the requested Record.
 </td><td>default</td><td></td></tr>
-<tr><td>5</td><td>columnFamiliesToFetch</td><td><code>list&lt;<code>string</code>&gt;</code></td><td>The column families to fetch.  If null, fetch all.  If empty, fetch none.
+<tr><td>5</td><td>columnFamiliesToFetch</td><td><code>set&lt;<code>string</code>&gt;</code></td><td>The column families to fetch. If null, fetch all. If empty, fetch none.
 </td><td>default</td><td></td></tr>
-<tr><td>6</td><td>columnsToFetch</td><td><code>map&lt;<code>string</code>, <code>set&lt;<code>string</code>&gt;</code>&gt;</code></td><td>The columns in the families to fetch.  If null, fetch all.  If empty, fetch none.
+<tr><td>6</td><td>columnsToFetch</td><td><code>map&lt;<code>string</code>, <code>set&lt;<code>string</code>&gt;</code>&gt;</code></td><td>The columns in the families to fetch. If null, fetch all. If empty, fetch none.
 </td><td>default</td><td></td></tr>
 <tr><td>8</td><td>startRecord</td><td><code>i32</code></td><td>Only valid for Row fetches, the record in the row to start fetching.  If the row contains 1000
 records and you want the first 100, then this value is 0.  If you want records 300-400 then this
@@ -338,6 +335,8 @@ would be 100.  Used in conjunction with startRecord. By default this will fetch
 </td><td>default</td><td>1000</td></tr>
 <tr><td>10</td><td>highlightOptions</td><td><code><a href="Blur.html#Struct_HighlightOptions">HighlightOptions</a></code></td><td>The HighlightOptions object controls how the data is highlighted.  If null no highlighting will occur.
 </td><td>default</td><td></td></tr>
+<tr><td>11</td><td>orderOfFamiliesToFetch</td><td><code>list&lt;<code>string</code>&gt;</code></td><td>Can be null, if provided the provided family order will be the order in which the families are returned.
+</td><td>default</td><td></td></tr>
 </table><br/>Select carries the request for information to be retrieved from the stored columns.
 <br/></p></section><section><div class="page-header"><h3 id="Struct_FetchRowResult">Struct: FetchRowResult</h3></div><p class="lead">
 <table class="table-bordered table-striped table-condensed"><thead><th>Key</th><th>Field</th><th>Type</th><th>Description</th><th>Requiredness</th><th>Default value</th></thead>
@@ -349,6 +348,8 @@ would be 100.  Used in conjunction with startRecord. By default this will fetch
 </td><td>default</td><td>-1</td></tr>
 <tr><td>4</td><td>moreRecordsToFetch</td><td><code>bool</code></td><td>Are there more Records to fetch based on the Selector provided.
 </td><td>default</td><td>0</td></tr>
+<tr><td>5</td><td>totalRecords</td><td><code>i32</code></td><td>The total number of records the Selector found.
+</td><td>default</td><td></td></tr>
 </table><br/>FetchRowResult contains row result from a fetch.
 <br/></p></section><section><div class="page-header"><h3 id="Struct_FetchRecordResult">Struct: FetchRecordResult</h3></div><p class="lead">
 <table class="table-bordered table-striped table-condensed"><thead><th>Key</th><th>Field</th><th>Type</th><th>Description</th><th>Requiredness</th><th>Default value</th></thead>
@@ -450,14 +451,10 @@ with the query options.
 </td><td>default</td><td></td></tr>
 <tr><td>2</td><td>rowId</td><td><code>string</code></td><td>The row id that the row mutation is to act upon.
 </td><td>default</td><td></td></tr>
-<tr><td>3</td><td>wal</td><td><code>bool</code></td><td>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.
-</td><td>default</td><td>1</td></tr>
 <tr><td>4</td><td>rowMutationType</td><td><code><a href="Blur.html#Enum_RowMutationType">RowMutationType</a></code></td><td>The RowMutationType to define how to mutate the given Row.
 </td><td>default</td><td>UNKNOWN</td></tr>
 <tr><td>5</td><td>recordMutations</td><td><code>list&lt;<code><a href="Blur.html#Struct_RecordMutation">RecordMutation</a></code>&gt;</code></td><td>The RecordMutations if any for this Row.
 </td><td>default</td><td></td></tr>
-<tr><td>6</td><td>waitToBeVisible</td><td><code>bool</code></td><td>On mutate waits for the mutation to be visible to queries and fetch requests.
-</td><td>default</td><td>0</td></tr>
 </table><br/>The RowMutation defines how the given Row is to be mutated.
 <br/></p></section><section><div class="page-header"><h3 id="Struct_CpuTime">Struct: CpuTime</h3></div><p class="lead">
 <table class="table-bordered table-striped table-condensed"><thead><th>Key</th><th>Field</th><th>Type</th><th>Description</th><th>Requiredness</th><th>Default value</th></thead>


Mime
View raw message