incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [1/9] Sorting feature is now implemented for String type, no integration tests yet. Still need to implement sorting on other types.
Date Wed, 29 Jan 2014 04:08:59 GMT
Updated Branches:
  refs/heads/apache-blur-0.2 3280f7268 -> 5e4956712


http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/5e495671/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 6ac887d..0f1f87b 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 $_size199 = 0;
+          my $_size206 = 0;
           $self->{success} = [];
-          my $_etype202 = 0;
-          $xfer += $input->readListBegin(\$_etype202, \$_size199);
-          for (my $_i203 = 0; $_i203 < $_size199; ++$_i203)
+          my $_etype209 = 0;
+          $xfer += $input->readListBegin(\$_etype209, \$_size206);
+          for (my $_i210 = 0; $_i210 < $_size206; ++$_i210)
           {
-            my $elem204 = undef;
-            $xfer += $input->readString(\$elem204);
-            push(@{$self->{success}},$elem204);
+            my $elem211 = undef;
+            $xfer += $input->readString(\$elem211);
+            push(@{$self->{success}},$elem211);
           }
           $xfer += $input->readListEnd();
         }
@@ -832,9 +832,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter205 (@{$self->{success}}) 
+        foreach my $iter212 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter205);
+          $xfer += $output->writeString($iter212);
         }
       }
       $xfer += $output->writeListEnd();
@@ -957,15 +957,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size206 = 0;
+          my $_size213 = 0;
           $self->{success} = [];
-          my $_etype209 = 0;
-          $xfer += $input->readListBegin(\$_etype209, \$_size206);
-          for (my $_i210 = 0; $_i210 < $_size206; ++$_i210)
+          my $_etype216 = 0;
+          $xfer += $input->readListBegin(\$_etype216, \$_size213);
+          for (my $_i217 = 0; $_i217 < $_size213; ++$_i217)
           {
-            my $elem211 = undef;
-            $xfer += $input->readString(\$elem211);
-            push(@{$self->{success}},$elem211);
+            my $elem218 = undef;
+            $xfer += $input->readString(\$elem218);
+            push(@{$self->{success}},$elem218);
           }
           $xfer += $input->readListEnd();
         }
@@ -997,9 +997,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter212 (@{$self->{success}}) 
+        foreach my $iter219 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter212);
+          $xfer += $output->writeString($iter219);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2149,30 +2149,30 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size213 = 0;
+          my $_size220 = 0;
           $self->{success} = {};
-          my $_ktype214 = 0;
-          my $_vtype215 = 0;
-          $xfer += $input->readMapBegin(\$_ktype214, \$_vtype215, \$_size213);
-          for (my $_i217 = 0; $_i217 < $_size213; ++$_i217)
+          my $_ktype221 = 0;
+          my $_vtype222 = 0;
+          $xfer += $input->readMapBegin(\$_ktype221, \$_vtype222, \$_size220);
+          for (my $_i224 = 0; $_i224 < $_size220; ++$_i224)
           {
-            my $key218 = '';
-            my $val219 = [];
-            $xfer += $input->readString(\$key218);
+            my $key225 = '';
+            my $val226 = [];
+            $xfer += $input->readString(\$key225);
             {
-              my $_size220 = 0;
-              $val219 = [];
-              my $_etype223 = 0;
-              $xfer += $input->readListBegin(\$_etype223, \$_size220);
-              for (my $_i224 = 0; $_i224 < $_size220; ++$_i224)
+              my $_size227 = 0;
+              $val226 = [];
+              my $_etype230 = 0;
+              $xfer += $input->readListBegin(\$_etype230, \$_size227);
+              for (my $_i231 = 0; $_i231 < $_size227; ++$_i231)
               {
-                my $elem225 = undef;
-                $xfer += $input->readString(\$elem225);
-                push(@{$val219},$elem225);
+                my $elem232 = undef;
+                $xfer += $input->readString(\$elem232);
+                push(@{$val226},$elem232);
               }
               $xfer += $input->readListEnd();
             }
-            $self->{success}->{$key218} = $val219;
+            $self->{success}->{$key225} = $val226;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2204,15 +2204,15 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::LIST, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter226,$viter227) = each %{$self->{success}}) 
+        while( my ($kiter233,$viter234) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter226);
+          $xfer += $output->writeString($kiter233);
           {
-            $xfer += $output->writeListBegin(TType::STRING, scalar(@{${viter227}}));
+            $xfer += $output->writeListBegin(TType::STRING, scalar(@{${viter234}}));
             {
-              foreach my $iter228 (@{${viter227}}) 
+              foreach my $iter235 (@{${viter234}}) 
               {
-                $xfer += $output->writeString($iter228);
+                $xfer += $output->writeString($iter235);
               }
             }
             $xfer += $output->writeListEnd();
@@ -2714,16 +2714,16 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size229 = 0;
+          my $_size236 = 0;
           $self->{selectors} = [];
-          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::Selector();
-            $xfer += $elem234->read($input);
-            push(@{$self->{selectors}},$elem234);
+            my $elem241 = undef;
+            $elem241 = new Blur::Selector();
+            $xfer += $elem241->read($input);
+            push(@{$self->{selectors}},$elem241);
           }
           $xfer += $input->readListEnd();
         }
@@ -2753,9 +2753,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{selectors}}));
       {
-        foreach my $iter235 (@{$self->{selectors}}) 
+        foreach my $iter242 (@{$self->{selectors}}) 
         {
-          $xfer += ${iter235}->write($output);
+          $xfer += ${iter242}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2809,16 +2809,16 @@ 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;
-            $elem241 = new Blur::FetchResult();
-            $xfer += $elem241->read($input);
-            push(@{$self->{success}},$elem241);
+            my $elem248 = undef;
+            $elem248 = new Blur::FetchResult();
+            $xfer += $elem248->read($input);
+            push(@{$self->{success}},$elem248);
           }
           $xfer += $input->readListEnd();
         }
@@ -2850,9 +2850,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
       {
-        foreach my $iter242 (@{$self->{success}}) 
+        foreach my $iter249 (@{$self->{success}}) 
         {
-          $xfer += ${iter242}->write($output);
+          $xfer += ${iter249}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3037,16 +3037,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size243 = 0;
+          my $_size250 = 0;
           $self->{mutations} = [];
-          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;
-            $elem248 = new Blur::RowMutation();
-            $xfer += $elem248->read($input);
-            push(@{$self->{mutations}},$elem248);
+            my $elem255 = undef;
+            $elem255 = new Blur::RowMutation();
+            $xfer += $elem255->read($input);
+            push(@{$self->{mutations}},$elem255);
           }
           $xfer += $input->readListEnd();
         }
@@ -3071,9 +3071,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{mutations}}));
       {
-        foreach my $iter249 (@{$self->{mutations}}) 
+        foreach my $iter256 (@{$self->{mutations}}) 
         {
-          $xfer += ${iter249}->write($output);
+          $xfer += ${iter256}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3400,15 +3400,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();
         }
@@ -3440,9 +3440,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();
@@ -3785,15 +3785,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();
         }
@@ -3825,9 +3825,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();
@@ -4121,15 +4121,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();
         }
@@ -4161,9 +4161,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();
@@ -4286,15 +4286,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size271 = 0;
+          my $_size278 = 0;
           $self->{success} = [];
-          my $_etype274 = 0;
-          $xfer += $input->readListBegin(\$_etype274, \$_size271);
-          for (my $_i275 = 0; $_i275 < $_size271; ++$_i275)
+          my $_etype281 = 0;
+          $xfer += $input->readListBegin(\$_etype281, \$_size278);
+          for (my $_i282 = 0; $_i282 < $_size278; ++$_i282)
           {
-            my $elem276 = undef;
-            $xfer += $input->readString(\$elem276);
-            push(@{$self->{success}},$elem276);
+            my $elem283 = undef;
+            $xfer += $input->readString(\$elem283);
+            push(@{$self->{success}},$elem283);
           }
           $xfer += $input->readListEnd();
         }
@@ -4326,9 +4326,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter277 (@{$self->{success}}) 
+        foreach my $iter284 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter277);
+          $xfer += $output->writeString($iter284);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4433,15 +4433,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size278 = 0;
+          my $_size285 = 0;
           $self->{success} = [];
-          my $_etype281 = 0;
-          $xfer += $input->readListBegin(\$_etype281, \$_size278);
-          for (my $_i282 = 0; $_i282 < $_size278; ++$_i282)
+          my $_etype288 = 0;
+          $xfer += $input->readListBegin(\$_etype288, \$_size285);
+          for (my $_i289 = 0; $_i289 < $_size285; ++$_i289)
           {
-            my $elem283 = undef;
-            $xfer += $input->readString(\$elem283);
-            push(@{$self->{success}},$elem283);
+            my $elem290 = undef;
+            $xfer += $input->readString(\$elem290);
+            push(@{$self->{success}},$elem290);
           }
           $xfer += $input->readListEnd();
         }
@@ -4473,9 +4473,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter284 (@{$self->{success}}) 
+        foreach my $iter291 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter284);
+          $xfer += $output->writeString($iter291);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4598,18 +4598,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size285 = 0;
+          my $_size292 = 0;
           $self->{success} = {};
-          my $_ktype286 = 0;
-          my $_vtype287 = 0;
-          $xfer += $input->readMapBegin(\$_ktype286, \$_vtype287, \$_size285);
-          for (my $_i289 = 0; $_i289 < $_size285; ++$_i289)
+          my $_ktype293 = 0;
+          my $_vtype294 = 0;
+          $xfer += $input->readMapBegin(\$_ktype293, \$_vtype294, \$_size292);
+          for (my $_i296 = 0; $_i296 < $_size292; ++$_i296)
           {
-            my $key290 = '';
-            my $val291 = '';
-            $xfer += $input->readString(\$key290);
-            $xfer += $input->readString(\$val291);
-            $self->{success}->{$key290} = $val291;
+            my $key297 = '';
+            my $val298 = '';
+            $xfer += $input->readString(\$key297);
+            $xfer += $input->readString(\$val298);
+            $self->{success}->{$key297} = $val298;
           }
           $xfer += $input->readMapEnd();
         }
@@ -4641,10 +4641,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter292,$viter293) = each %{$self->{success}}) 
+        while( my ($kiter299,$viter300) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter292);
-          $xfer += $output->writeString($viter293);
+          $xfer += $output->writeString($kiter299);
+          $xfer += $output->writeString($viter300);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -4767,33 +4767,33 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size294 = 0;
+          my $_size301 = 0;
           $self->{success} = {};
-          my $_ktype295 = 0;
-          my $_vtype296 = 0;
-          $xfer += $input->readMapBegin(\$_ktype295, \$_vtype296, \$_size294);
-          for (my $_i298 = 0; $_i298 < $_size294; ++$_i298)
+          my $_ktype302 = 0;
+          my $_vtype303 = 0;
+          $xfer += $input->readMapBegin(\$_ktype302, \$_vtype303, \$_size301);
+          for (my $_i305 = 0; $_i305 < $_size301; ++$_i305)
           {
-            my $key299 = '';
-            my $val300 = [];
-            $xfer += $input->readString(\$key299);
+            my $key306 = '';
+            my $val307 = [];
+            $xfer += $input->readString(\$key306);
             {
-              my $_size301 = 0;
-              $val300 = {};
-              my $_ktype302 = 0;
-              my $_vtype303 = 0;
-              $xfer += $input->readMapBegin(\$_ktype302, \$_vtype303, \$_size301);
-              for (my $_i305 = 0; $_i305 < $_size301; ++$_i305)
+              my $_size308 = 0;
+              $val307 = {};
+              my $_ktype309 = 0;
+              my $_vtype310 = 0;
+              $xfer += $input->readMapBegin(\$_ktype309, \$_vtype310, \$_size308);
+              for (my $_i312 = 0; $_i312 < $_size308; ++$_i312)
               {
-                my $key306 = '';
-                my $val307 = 0;
-                $xfer += $input->readString(\$key306);
-                $xfer += $input->readI32(\$val307);
-                $val300->{$key306} = $val307;
+                my $key313 = '';
+                my $val314 = 0;
+                $xfer += $input->readString(\$key313);
+                $xfer += $input->readI32(\$val314);
+                $val307->{$key313} = $val314;
               }
               $xfer += $input->readMapEnd();
             }
-            $self->{success}->{$key299} = $val300;
+            $self->{success}->{$key306} = $val307;
           }
           $xfer += $input->readMapEnd();
         }
@@ -4825,16 +4825,16 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::MAP, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter308,$viter309) = each %{$self->{success}}) 
+        while( my ($kiter315,$viter316) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter308);
+          $xfer += $output->writeString($kiter315);
           {
-            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter309}}));
+            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter316}}));
             {
-              while( my ($kiter310,$viter311) = each %{${viter309}}) 
+              while( my ($kiter317,$viter318) = each %{${viter316}}) 
               {
-                $xfer += $output->writeString($kiter310);
-                $xfer += $output->writeI32($viter311);
+                $xfer += $output->writeString($kiter317);
+                $xfer += $output->writeI32($viter318);
               }
             }
             $xfer += $output->writeMapEnd();
@@ -5087,18 +5087,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size312 = 0;
+          my $_size319 = 0;
           $self->{success} = {};
-          my $_ktype313 = 0;
-          my $_vtype314 = 0;
-          $xfer += $input->readMapBegin(\$_ktype313, \$_vtype314, \$_size312);
-          for (my $_i316 = 0; $_i316 < $_size312; ++$_i316)
+          my $_ktype320 = 0;
+          my $_vtype321 = 0;
+          $xfer += $input->readMapBegin(\$_ktype320, \$_vtype321, \$_size319);
+          for (my $_i323 = 0; $_i323 < $_size319; ++$_i323)
           {
-            my $key317 = '';
-            my $val318 = '';
-            $xfer += $input->readString(\$key317);
-            $xfer += $input->readString(\$val318);
-            $self->{success}->{$key317} = $val318;
+            my $key324 = '';
+            my $val325 = '';
+            $xfer += $input->readString(\$key324);
+            $xfer += $input->readString(\$val325);
+            $self->{success}->{$key324} = $val325;
           }
           $xfer += $input->readMapEnd();
         }
@@ -5130,10 +5130,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter319,$viter320) = each %{$self->{success}}) 
+        while( my ($kiter326,$viter327) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter319);
-          $xfer += $output->writeString($viter320);
+          $xfer += $output->writeString($kiter326);
+          $xfer += $output->writeString($viter327);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -5188,15 +5188,15 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::SET) {
         {
-          my $_size321 = 0;
+          my $_size328 = 0;
           $self->{metrics} = {};
-          my $_etype324 = 0;
-          $xfer += $input->readSetBegin(\$_etype324, \$_size321);
-          for (my $_i325 = 0; $_i325 < $_size321; ++$_i325)
+          my $_etype331 = 0;
+          $xfer += $input->readSetBegin(\$_etype331, \$_size328);
+          for (my $_i332 = 0; $_i332 < $_size328; ++$_i332)
           {
-            my $elem326 = undef;
-            $xfer += $input->readString(\$elem326);
-            $self->{metrics}->{$elem326} = 1;
+            my $elem333 = undef;
+            $xfer += $input->readString(\$elem333);
+            $self->{metrics}->{$elem333} = 1;
           }
           $xfer += $input->readSetEnd();
         }
@@ -5221,9 +5221,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{metrics}}));
       {
-        foreach my $iter327 (@{$self->{metrics}})
+        foreach my $iter334 (@{$self->{metrics}})
         {
-          $xfer += $output->writeString($iter327);
+          $xfer += $output->writeString($iter334);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -5277,19 +5277,19 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size328 = 0;
+          my $_size335 = 0;
           $self->{success} = {};
-          my $_ktype329 = 0;
-          my $_vtype330 = 0;
-          $xfer += $input->readMapBegin(\$_ktype329, \$_vtype330, \$_size328);
-          for (my $_i332 = 0; $_i332 < $_size328; ++$_i332)
+          my $_ktype336 = 0;
+          my $_vtype337 = 0;
+          $xfer += $input->readMapBegin(\$_ktype336, \$_vtype337, \$_size335);
+          for (my $_i339 = 0; $_i339 < $_size335; ++$_i339)
           {
-            my $key333 = '';
-            my $val334 = new Blur::Metric();
-            $xfer += $input->readString(\$key333);
-            $val334 = new Blur::Metric();
-            $xfer += $val334->read($input);
-            $self->{success}->{$key333} = $val334;
+            my $key340 = '';
+            my $val341 = new Blur::Metric();
+            $xfer += $input->readString(\$key340);
+            $val341 = new Blur::Metric();
+            $xfer += $val341->read($input);
+            $self->{success}->{$key340} = $val341;
           }
           $xfer += $input->readMapEnd();
         }
@@ -5321,10 +5321,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter335,$viter336) = each %{$self->{success}}) 
+        while( my ($kiter342,$viter343) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter335);
-          $xfer += ${viter336}->write($output);
+          $xfer += $output->writeString($kiter342);
+          $xfer += ${viter343}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -5554,15 +5554,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size337 = 0;
+          my $_size344 = 0;
           $self->{success} = [];
-          my $_etype340 = 0;
-          $xfer += $input->readListBegin(\$_etype340, \$_size337);
-          for (my $_i341 = 0; $_i341 < $_size337; ++$_i341)
+          my $_etype347 = 0;
+          $xfer += $input->readListBegin(\$_etype347, \$_size344);
+          for (my $_i348 = 0; $_i348 < $_size344; ++$_i348)
           {
-            my $elem342 = undef;
-            $xfer += $input->readString(\$elem342);
-            push(@{$self->{success}},$elem342);
+            my $elem349 = undef;
+            $xfer += $input->readString(\$elem349);
+            push(@{$self->{success}},$elem349);
           }
           $xfer += $input->readListEnd();
         }
@@ -5594,9 +5594,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter343 (@{$self->{success}}) 
+        foreach my $iter350 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter343);
+          $xfer += $output->writeString($iter350);
         }
       }
       $xfer += $output->writeListEnd();
@@ -5719,15 +5719,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size344 = 0;
+          my $_size351 = 0;
           $self->{success} = [];
-          my $_etype347 = 0;
-          $xfer += $input->readListBegin(\$_etype347, \$_size344);
-          for (my $_i348 = 0; $_i348 < $_size344; ++$_i348)
+          my $_etype354 = 0;
+          $xfer += $input->readListBegin(\$_etype354, \$_size351);
+          for (my $_i355 = 0; $_i355 < $_size351; ++$_i355)
           {
-            my $elem349 = undef;
-            $xfer += $input->readString(\$elem349);
-            push(@{$self->{success}},$elem349);
+            my $elem356 = undef;
+            $xfer += $input->readString(\$elem356);
+            push(@{$self->{success}},$elem356);
           }
           $xfer += $input->readListEnd();
         }
@@ -5759,9 +5759,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter350 (@{$self->{success}}) 
+        foreach my $iter357 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter350);
+          $xfer += $output->writeString($iter357);
         }
       }
       $xfer += $output->writeListEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/5e495671/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 a75ec9f..1a16302 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
@@ -1351,9 +1351,103 @@ sub write {
   return $xfer;
 }
 
+package Blur::SortField;
+use base qw(Class::Accessor);
+Blur::SortField->mk_accessors( qw( family column reverse ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{family} = undef;
+  $self->{column} = undef;
+  $self->{reverse} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{family}) {
+      $self->{family} = $vals->{family};
+    }
+    if (defined $vals->{column}) {
+      $self->{column} = $vals->{column};
+    }
+    if (defined $vals->{reverse}) {
+      $self->{reverse} = $vals->{reverse};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'SortField';
+}
+
+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->{family});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{column});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{reverse});
+      } 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('SortField');
+  if (defined $self->{family}) {
+    $xfer += $output->writeFieldBegin('family', TType::STRING, 1);
+    $xfer += $output->writeString($self->{family});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{column}) {
+    $xfer += $output->writeFieldBegin('column', TType::STRING, 2);
+    $xfer += $output->writeString($self->{column});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{reverse}) {
+    $xfer += $output->writeFieldBegin('reverse', TType::BOOL, 3);
+    $xfer += $output->writeBool($self->{reverse});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
 package Blur::BlurQuery;
 use base qw(Class::Accessor);
-Blur::BlurQuery->mk_accessors( qw( query facets selector useCacheIfPresent start fetch minimumNumberOfResults maxQueryTime uuid userContext cacheResult startTime ) );
+Blur::BlurQuery->mk_accessors( qw( query facets selector useCacheIfPresent start fetch minimumNumberOfResults maxQueryTime uuid userContext cacheResult startTime sortFields ) );
 
 sub new {
   my $classname = shift;
@@ -1371,6 +1465,7 @@ sub new {
   $self->{userContext} = undef;
   $self->{cacheResult} = 1;
   $self->{startTime} = 0;
+  $self->{sortFields} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{query}) {
       $self->{query} = $vals->{query};
@@ -1408,6 +1503,9 @@ sub new {
     if (defined $vals->{startTime}) {
       $self->{startTime} = $vals->{startTime};
     }
+    if (defined $vals->{sortFields}) {
+      $self->{sortFields} = $vals->{sortFields};
+    }
   }
   return bless ($self, $classname);
 }
@@ -1518,6 +1616,25 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
+      /^15$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size50 = 0;
+          $self->{sortFields} = [];
+          my $_etype53 = 0;
+          $xfer += $input->readListBegin(\$_etype53, \$_size50);
+          for (my $_i54 = 0; $_i54 < $_size50; ++$_i54)
+          {
+            my $elem55 = undef;
+            $elem55 = new Blur::SortField();
+            $xfer += $elem55->read($input);
+            push(@{$self->{sortFields}},$elem55);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -1540,9 +1657,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{facets}}));
       {
-        foreach my $iter50 (@{$self->{facets}}) 
+        foreach my $iter56 (@{$self->{facets}}) 
         {
-          $xfer += ${iter50}->write($output);
+          $xfer += ${iter56}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1599,14 +1716,28 @@ sub write {
     $xfer += $output->writeI64($self->{startTime});
     $xfer += $output->writeFieldEnd();
   }
+  if (defined $self->{sortFields}) {
+    $xfer += $output->writeFieldBegin('sortFields', TType::LIST, 15);
+    {
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{sortFields}}));
+      {
+        foreach my $iter57 (@{$self->{sortFields}}) 
+        {
+          $xfer += ${iter57}->write($output);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
 }
 
-package Blur::SortField;
+package Blur::SortFieldResult;
 use base qw(Class::Accessor);
-Blur::SortField->mk_accessors( qw( nullValue stringValue intValue longValue doubleValue binaryValue ) );
+Blur::SortFieldResult->mk_accessors( qw( nullValue stringValue intValue longValue doubleValue binaryValue ) );
 
 sub new {
   my $classname = shift;
@@ -1642,7 +1773,7 @@ sub new {
 }
 
 sub getName {
-  return 'SortField';
+  return 'SortFieldResult';
 }
 
 sub read {
@@ -1707,7 +1838,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('SortField');
+  $xfer += $output->writeStructBegin('SortFieldResult');
   if (defined $self->{nullValue}) {
     $xfer += $output->writeFieldBegin('nullValue', TType::BOOL, 1);
     $xfer += $output->writeBool($self->{nullValue});
@@ -1745,7 +1876,7 @@ sub write {
 
 package Blur::BlurResult;
 use base qw(Class::Accessor);
-Blur::BlurResult->mk_accessors( qw( locationId score fetchResult sortFields ) );
+Blur::BlurResult->mk_accessors( qw( locationId score fetchResult sortFieldResults ) );
 
 sub new {
   my $classname = shift;
@@ -1754,7 +1885,7 @@ sub new {
   $self->{locationId} = undef;
   $self->{score} = undef;
   $self->{fetchResult} = undef;
-  $self->{sortFields} = undef;
+  $self->{sortFieldResults} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{locationId}) {
       $self->{locationId} = $vals->{locationId};
@@ -1765,8 +1896,8 @@ sub new {
     if (defined $vals->{fetchResult}) {
       $self->{fetchResult} = $vals->{fetchResult};
     }
-    if (defined $vals->{sortFields}) {
-      $self->{sortFields} = $vals->{sortFields};
+    if (defined $vals->{sortFieldResults}) {
+      $self->{sortFieldResults} = $vals->{sortFieldResults};
     }
   }
   return bless ($self, $classname);
@@ -1812,16 +1943,16 @@ sub read {
       last; };
       /^4$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size51 = 0;
-          $self->{sortFields} = [];
-          my $_etype54 = 0;
-          $xfer += $input->readListBegin(\$_etype54, \$_size51);
-          for (my $_i55 = 0; $_i55 < $_size51; ++$_i55)
+          my $_size58 = 0;
+          $self->{sortFieldResults} = [];
+          my $_etype61 = 0;
+          $xfer += $input->readListBegin(\$_etype61, \$_size58);
+          for (my $_i62 = 0; $_i62 < $_size58; ++$_i62)
           {
-            my $elem56 = undef;
-            $elem56 = new Blur::SortField();
-            $xfer += $elem56->read($input);
-            push(@{$self->{sortFields}},$elem56);
+            my $elem63 = undef;
+            $elem63 = new Blur::SortFieldResult();
+            $xfer += $elem63->read($input);
+            push(@{$self->{sortFieldResults}},$elem63);
           }
           $xfer += $input->readListEnd();
         }
@@ -1856,14 +1987,14 @@ sub write {
     $xfer += $self->{fetchResult}->write($output);
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{sortFields}) {
-    $xfer += $output->writeFieldBegin('sortFields', TType::LIST, 4);
+  if (defined $self->{sortFieldResults}) {
+    $xfer += $output->writeFieldBegin('sortFieldResults', TType::LIST, 4);
     {
-      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{sortFields}}));
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{sortFieldResults}}));
       {
-        foreach my $iter57 (@{$self->{sortFields}}) 
+        foreach my $iter64 (@{$self->{sortFieldResults}}) 
         {
-          $xfer += ${iter57}->write($output);
+          $xfer += ${iter64}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1939,18 +2070,18 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size58 = 0;
+          my $_size65 = 0;
           $self->{shardInfo} = {};
-          my $_ktype59 = 0;
-          my $_vtype60 = 0;
-          $xfer += $input->readMapBegin(\$_ktype59, \$_vtype60, \$_size58);
-          for (my $_i62 = 0; $_i62 < $_size58; ++$_i62)
+          my $_ktype66 = 0;
+          my $_vtype67 = 0;
+          $xfer += $input->readMapBegin(\$_ktype66, \$_vtype67, \$_size65);
+          for (my $_i69 = 0; $_i69 < $_size65; ++$_i69)
           {
-            my $key63 = '';
-            my $val64 = 0;
-            $xfer += $input->readString(\$key63);
-            $xfer += $input->readI64(\$val64);
-            $self->{shardInfo}->{$key63} = $val64;
+            my $key70 = '';
+            my $val71 = 0;
+            $xfer += $input->readString(\$key70);
+            $xfer += $input->readI64(\$val71);
+            $self->{shardInfo}->{$key70} = $val71;
           }
           $xfer += $input->readMapEnd();
         }
@@ -1960,16 +2091,16 @@ sub read {
       last; };
       /^3$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size65 = 0;
+          my $_size72 = 0;
           $self->{results} = [];
-          my $_etype68 = 0;
-          $xfer += $input->readListBegin(\$_etype68, \$_size65);
-          for (my $_i69 = 0; $_i69 < $_size65; ++$_i69)
+          my $_etype75 = 0;
+          $xfer += $input->readListBegin(\$_etype75, \$_size72);
+          for (my $_i76 = 0; $_i76 < $_size72; ++$_i76)
           {
-            my $elem70 = undef;
-            $elem70 = new Blur::BlurResult();
-            $xfer += $elem70->read($input);
-            push(@{$self->{results}},$elem70);
+            my $elem77 = undef;
+            $elem77 = new Blur::BlurResult();
+            $xfer += $elem77->read($input);
+            push(@{$self->{results}},$elem77);
           }
           $xfer += $input->readListEnd();
         }
@@ -1979,15 +2110,15 @@ sub read {
       last; };
       /^4$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size71 = 0;
+          my $_size78 = 0;
           $self->{facetCounts} = [];
-          my $_etype74 = 0;
-          $xfer += $input->readListBegin(\$_etype74, \$_size71);
-          for (my $_i75 = 0; $_i75 < $_size71; ++$_i75)
+          my $_etype81 = 0;
+          $xfer += $input->readListBegin(\$_etype81, \$_size78);
+          for (my $_i82 = 0; $_i82 < $_size78; ++$_i82)
           {
-            my $elem76 = undef;
-            $xfer += $input->readI64(\$elem76);
-            push(@{$self->{facetCounts}},$elem76);
+            my $elem83 = undef;
+            $xfer += $input->readI64(\$elem83);
+            push(@{$self->{facetCounts}},$elem83);
           }
           $xfer += $input->readListEnd();
         }
@@ -1997,16 +2128,16 @@ sub read {
       last; };
       /^5$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size77 = 0;
+          my $_size84 = 0;
           $self->{exceptions} = [];
-          my $_etype80 = 0;
-          $xfer += $input->readListBegin(\$_etype80, \$_size77);
-          for (my $_i81 = 0; $_i81 < $_size77; ++$_i81)
+          my $_etype87 = 0;
+          $xfer += $input->readListBegin(\$_etype87, \$_size84);
+          for (my $_i88 = 0; $_i88 < $_size84; ++$_i88)
           {
-            my $elem82 = undef;
-            $elem82 = new Blur::BlurException();
-            $xfer += $elem82->read($input);
-            push(@{$self->{exceptions}},$elem82);
+            my $elem89 = undef;
+            $elem89 = new Blur::BlurException();
+            $xfer += $elem89->read($input);
+            push(@{$self->{exceptions}},$elem89);
           }
           $xfer += $input->readListEnd();
         }
@@ -2043,10 +2174,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::I64, scalar(keys %{$self->{shardInfo}}));
       {
-        while( my ($kiter83,$viter84) = each %{$self->{shardInfo}}) 
+        while( my ($kiter90,$viter91) = each %{$self->{shardInfo}}) 
         {
-          $xfer += $output->writeString($kiter83);
-          $xfer += $output->writeI64($viter84);
+          $xfer += $output->writeString($kiter90);
+          $xfer += $output->writeI64($viter91);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -2058,9 +2189,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{results}}));
       {
-        foreach my $iter85 (@{$self->{results}}) 
+        foreach my $iter92 (@{$self->{results}}) 
         {
-          $xfer += ${iter85}->write($output);
+          $xfer += ${iter92}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2072,9 +2203,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{facetCounts}}));
       {
-        foreach my $iter86 (@{$self->{facetCounts}}) 
+        foreach my $iter93 (@{$self->{facetCounts}}) 
         {
-          $xfer += $output->writeI64($iter86);
+          $xfer += $output->writeI64($iter93);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2086,9 +2217,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{exceptions}}));
       {
-        foreach my $iter87 (@{$self->{exceptions}}) 
+        foreach my $iter94 (@{$self->{exceptions}}) 
         {
-          $xfer += ${iter87}->write($output);
+          $xfer += ${iter94}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2253,16 +2384,16 @@ sub read {
       last; };
       /^5$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size88 = 0;
+          my $_size95 = 0;
           $self->{recordMutations} = [];
-          my $_etype91 = 0;
-          $xfer += $input->readListBegin(\$_etype91, \$_size88);
-          for (my $_i92 = 0; $_i92 < $_size88; ++$_i92)
+          my $_etype98 = 0;
+          $xfer += $input->readListBegin(\$_etype98, \$_size95);
+          for (my $_i99 = 0; $_i99 < $_size95; ++$_i99)
           {
-            my $elem93 = undef;
-            $elem93 = new Blur::RecordMutation();
-            $xfer += $elem93->read($input);
-            push(@{$self->{recordMutations}},$elem93);
+            my $elem100 = undef;
+            $elem100 = new Blur::RecordMutation();
+            $xfer += $elem100->read($input);
+            push(@{$self->{recordMutations}},$elem100);
           }
           $xfer += $input->readListEnd();
         }
@@ -2302,9 +2433,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{recordMutations}}));
       {
-        foreach my $iter94 (@{$self->{recordMutations}}) 
+        foreach my $iter101 (@{$self->{recordMutations}}) 
         {
-          $xfer += ${iter94}->write($output);
+          $xfer += ${iter101}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2464,19 +2595,19 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size95 = 0;
+          my $_size102 = 0;
           $self->{cpuTimes} = {};
-          my $_ktype96 = 0;
-          my $_vtype97 = 0;
-          $xfer += $input->readMapBegin(\$_ktype96, \$_vtype97, \$_size95);
-          for (my $_i99 = 0; $_i99 < $_size95; ++$_i99)
+          my $_ktype103 = 0;
+          my $_vtype104 = 0;
+          $xfer += $input->readMapBegin(\$_ktype103, \$_vtype104, \$_size102);
+          for (my $_i106 = 0; $_i106 < $_size102; ++$_i106)
           {
-            my $key100 = '';
-            my $val101 = new Blur::CpuTime();
-            $xfer += $input->readString(\$key100);
-            $val101 = new Blur::CpuTime();
-            $xfer += $val101->read($input);
-            $self->{cpuTimes}->{$key100} = $val101;
+            my $key107 = '';
+            my $val108 = new Blur::CpuTime();
+            $xfer += $input->readString(\$key107);
+            $val108 = new Blur::CpuTime();
+            $xfer += $val108->read($input);
+            $self->{cpuTimes}->{$key107} = $val108;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2536,10 +2667,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{cpuTimes}}));
       {
-        while( my ($kiter102,$viter103) = each %{$self->{cpuTimes}}) 
+        while( my ($kiter109,$viter110) = each %{$self->{cpuTimes}}) 
         {
-          $xfer += $output->writeString($kiter102);
-          $xfer += ${viter103}->write($output);
+          $xfer += $output->writeString($kiter109);
+          $xfer += ${viter110}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -2687,7 +2818,7 @@ sub write {
 
 package Blur::ColumnDefinition;
 use base qw(Class::Accessor);
-Blur::ColumnDefinition->mk_accessors( qw( family columnName subColumnName fieldLessIndexed fieldType properties ) );
+Blur::ColumnDefinition->mk_accessors( qw( family columnName subColumnName fieldLessIndexed fieldType properties sortable ) );
 
 sub new {
   my $classname = shift;
@@ -2699,6 +2830,7 @@ sub new {
   $self->{fieldLessIndexed} = undef;
   $self->{fieldType} = undef;
   $self->{properties} = undef;
+  $self->{sortable} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{family}) {
       $self->{family} = $vals->{family};
@@ -2718,6 +2850,9 @@ sub new {
     if (defined $vals->{properties}) {
       $self->{properties} = $vals->{properties};
     }
+    if (defined $vals->{sortable}) {
+      $self->{sortable} = $vals->{sortable};
+    }
   }
   return bless ($self, $classname);
 }
@@ -2773,18 +2908,18 @@ sub read {
       last; };
       /^6$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size104 = 0;
+          my $_size111 = 0;
           $self->{properties} = {};
-          my $_ktype105 = 0;
-          my $_vtype106 = 0;
-          $xfer += $input->readMapBegin(\$_ktype105, \$_vtype106, \$_size104);
-          for (my $_i108 = 0; $_i108 < $_size104; ++$_i108)
+          my $_ktype112 = 0;
+          my $_vtype113 = 0;
+          $xfer += $input->readMapBegin(\$_ktype112, \$_vtype113, \$_size111);
+          for (my $_i115 = 0; $_i115 < $_size111; ++$_i115)
           {
-            my $key109 = '';
-            my $val110 = '';
-            $xfer += $input->readString(\$key109);
-            $xfer += $input->readString(\$val110);
-            $self->{properties}->{$key109} = $val110;
+            my $key116 = '';
+            my $val117 = '';
+            $xfer += $input->readString(\$key116);
+            $xfer += $input->readString(\$val117);
+            $self->{properties}->{$key116} = $val117;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2792,6 +2927,12 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
+      /^7$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{sortable});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -2834,16 +2975,21 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{properties}}));
       {
-        while( my ($kiter111,$viter112) = each %{$self->{properties}}) 
+        while( my ($kiter118,$viter119) = each %{$self->{properties}}) 
         {
-          $xfer += $output->writeString($kiter111);
-          $xfer += $output->writeString($viter112);
+          $xfer += $output->writeString($kiter118);
+          $xfer += $output->writeString($viter119);
         }
       }
       $xfer += $output->writeMapEnd();
     }
     $xfer += $output->writeFieldEnd();
   }
+  if (defined $self->{sortable}) {
+    $xfer += $output->writeFieldBegin('sortable', TType::BOOL, 7);
+    $xfer += $output->writeBool($self->{sortable});
+    $xfer += $output->writeFieldEnd();
+  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
@@ -2897,34 +3043,34 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size113 = 0;
+          my $_size120 = 0;
           $self->{families} = {};
-          my $_ktype114 = 0;
-          my $_vtype115 = 0;
-          $xfer += $input->readMapBegin(\$_ktype114, \$_vtype115, \$_size113);
-          for (my $_i117 = 0; $_i117 < $_size113; ++$_i117)
+          my $_ktype121 = 0;
+          my $_vtype122 = 0;
+          $xfer += $input->readMapBegin(\$_ktype121, \$_vtype122, \$_size120);
+          for (my $_i124 = 0; $_i124 < $_size120; ++$_i124)
           {
-            my $key118 = '';
-            my $val119 = [];
-            $xfer += $input->readString(\$key118);
+            my $key125 = '';
+            my $val126 = [];
+            $xfer += $input->readString(\$key125);
             {
-              my $_size120 = 0;
-              $val119 = {};
-              my $_ktype121 = 0;
-              my $_vtype122 = 0;
-              $xfer += $input->readMapBegin(\$_ktype121, \$_vtype122, \$_size120);
-              for (my $_i124 = 0; $_i124 < $_size120; ++$_i124)
+              my $_size127 = 0;
+              $val126 = {};
+              my $_ktype128 = 0;
+              my $_vtype129 = 0;
+              $xfer += $input->readMapBegin(\$_ktype128, \$_vtype129, \$_size127);
+              for (my $_i131 = 0; $_i131 < $_size127; ++$_i131)
               {
-                my $key125 = '';
-                my $val126 = new Blur::ColumnDefinition();
-                $xfer += $input->readString(\$key125);
-                $val126 = new Blur::ColumnDefinition();
-                $xfer += $val126->read($input);
-                $val119->{$key125} = $val126;
+                my $key132 = '';
+                my $val133 = new Blur::ColumnDefinition();
+                $xfer += $input->readString(\$key132);
+                $val133 = new Blur::ColumnDefinition();
+                $xfer += $val133->read($input);
+                $val126->{$key132} = $val133;
               }
               $xfer += $input->readMapEnd();
             }
-            $self->{families}->{$key118} = $val119;
+            $self->{families}->{$key125} = $val126;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2954,16 +3100,16 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::MAP, scalar(keys %{$self->{families}}));
       {
-        while( my ($kiter127,$viter128) = each %{$self->{families}}) 
+        while( my ($kiter134,$viter135) = each %{$self->{families}}) 
         {
-          $xfer += $output->writeString($kiter127);
+          $xfer += $output->writeString($kiter134);
           {
-            $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{${viter128}}));
+            $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{${viter135}}));
             {
-              while( my ($kiter129,$viter130) = each %{${viter128}}) 
+              while( my ($kiter136,$viter137) = each %{${viter135}}) 
               {
-                $xfer += $output->writeString($kiter129);
-                $xfer += ${viter130}->write($output);
+                $xfer += $output->writeString($kiter136);
+                $xfer += ${viter137}->write($output);
               }
             }
             $xfer += $output->writeMapEnd();
@@ -3115,15 +3261,15 @@ sub read {
       last; };
       /^11$/ && do{      if ($ftype == TType::SET) {
         {
-          my $_size131 = 0;
+          my $_size138 = 0;
           $self->{blockCachingFileTypes} = {};
-          my $_etype134 = 0;
-          $xfer += $input->readSetBegin(\$_etype134, \$_size131);
-          for (my $_i135 = 0; $_i135 < $_size131; ++$_i135)
+          my $_etype141 = 0;
+          $xfer += $input->readSetBegin(\$_etype141, \$_size138);
+          for (my $_i142 = 0; $_i142 < $_size138; ++$_i142)
           {
-            my $elem136 = undef;
-            $xfer += $input->readString(\$elem136);
-            $self->{blockCachingFileTypes}->{$elem136} = 1;
+            my $elem143 = undef;
+            $xfer += $input->readString(\$elem143);
+            $self->{blockCachingFileTypes}->{$elem143} = 1;
           }
           $xfer += $input->readSetEnd();
         }
@@ -3139,15 +3285,15 @@ sub read {
       last; };
       /^13$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size137 = 0;
+          my $_size144 = 0;
           $self->{preCacheCols} = [];
-          my $_etype140 = 0;
-          $xfer += $input->readListBegin(\$_etype140, \$_size137);
-          for (my $_i141 = 0; $_i141 < $_size137; ++$_i141)
+          my $_etype147 = 0;
+          $xfer += $input->readListBegin(\$_etype147, \$_size144);
+          for (my $_i148 = 0; $_i148 < $_size144; ++$_i148)
           {
-            my $elem142 = undef;
-            $xfer += $input->readString(\$elem142);
-            push(@{$self->{preCacheCols}},$elem142);
+            my $elem149 = undef;
+            $xfer += $input->readString(\$elem149);
+            push(@{$self->{preCacheCols}},$elem149);
           }
           $xfer += $input->readListEnd();
         }
@@ -3157,18 +3303,18 @@ sub read {
       last; };
       /^14$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size143 = 0;
+          my $_size150 = 0;
           $self->{tableProperties} = {};
-          my $_ktype144 = 0;
-          my $_vtype145 = 0;
-          $xfer += $input->readMapBegin(\$_ktype144, \$_vtype145, \$_size143);
-          for (my $_i147 = 0; $_i147 < $_size143; ++$_i147)
+          my $_ktype151 = 0;
+          my $_vtype152 = 0;
+          $xfer += $input->readMapBegin(\$_ktype151, \$_vtype152, \$_size150);
+          for (my $_i154 = 0; $_i154 < $_size150; ++$_i154)
           {
-            my $key148 = '';
-            my $val149 = '';
-            $xfer += $input->readString(\$key148);
-            $xfer += $input->readString(\$val149);
-            $self->{tableProperties}->{$key148} = $val149;
+            my $key155 = '';
+            my $val156 = '';
+            $xfer += $input->readString(\$key155);
+            $xfer += $input->readString(\$val156);
+            $self->{tableProperties}->{$key155} = $val156;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3196,18 +3342,18 @@ sub read {
       last; };
       /^18$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size150 = 0;
+          my $_size157 = 0;
           $self->{defaultMissingFieldProps} = {};
-          my $_ktype151 = 0;
-          my $_vtype152 = 0;
-          $xfer += $input->readMapBegin(\$_ktype151, \$_vtype152, \$_size150);
-          for (my $_i154 = 0; $_i154 < $_size150; ++$_i154)
+          my $_ktype158 = 0;
+          my $_vtype159 = 0;
+          $xfer += $input->readMapBegin(\$_ktype158, \$_vtype159, \$_size157);
+          for (my $_i161 = 0; $_i161 < $_size157; ++$_i161)
           {
-            my $key155 = '';
-            my $val156 = '';
-            $xfer += $input->readString(\$key155);
-            $xfer += $input->readString(\$val156);
-            $self->{defaultMissingFieldProps}->{$key155} = $val156;
+            my $key162 = '';
+            my $val163 = '';
+            $xfer += $input->readString(\$key162);
+            $xfer += $input->readString(\$val163);
+            $self->{defaultMissingFieldProps}->{$key162} = $val163;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3267,9 +3413,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{blockCachingFileTypes}}));
       {
-        foreach my $iter157 (@{$self->{blockCachingFileTypes}})
+        foreach my $iter164 (@{$self->{blockCachingFileTypes}})
         {
-          $xfer += $output->writeString($iter157);
+          $xfer += $output->writeString($iter164);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -3286,9 +3432,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{preCacheCols}}));
       {
-        foreach my $iter158 (@{$self->{preCacheCols}}) 
+        foreach my $iter165 (@{$self->{preCacheCols}}) 
         {
-          $xfer += $output->writeString($iter158);
+          $xfer += $output->writeString($iter165);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3300,10 +3446,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{tableProperties}}));
       {
-        while( my ($kiter159,$viter160) = each %{$self->{tableProperties}}) 
+        while( my ($kiter166,$viter167) = each %{$self->{tableProperties}}) 
         {
-          $xfer += $output->writeString($kiter159);
-          $xfer += $output->writeString($viter160);
+          $xfer += $output->writeString($kiter166);
+          $xfer += $output->writeString($viter167);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3330,10 +3476,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{defaultMissingFieldProps}}));
       {
-        while( my ($kiter161,$viter162) = each %{$self->{defaultMissingFieldProps}}) 
+        while( my ($kiter168,$viter169) = each %{$self->{defaultMissingFieldProps}}) 
         {
-          $xfer += $output->writeString($kiter161);
-          $xfer += $output->writeString($viter162);
+          $xfer += $output->writeString($kiter168);
+          $xfer += $output->writeString($viter169);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3401,39 +3547,18 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size163 = 0;
-          $self->{strMap} = {};
-          my $_ktype164 = 0;
-          my $_vtype165 = 0;
-          $xfer += $input->readMapBegin(\$_ktype164, \$_vtype165, \$_size163);
-          for (my $_i167 = 0; $_i167 < $_size163; ++$_i167)
-          {
-            my $key168 = '';
-            my $val169 = '';
-            $xfer += $input->readString(\$key168);
-            $xfer += $input->readString(\$val169);
-            $self->{strMap}->{$key168} = $val169;
-          }
-          $xfer += $input->readMapEnd();
-        }
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^3$/ && do{      if ($ftype == TType::MAP) {
-        {
           my $_size170 = 0;
-          $self->{longMap} = {};
+          $self->{strMap} = {};
           my $_ktype171 = 0;
           my $_vtype172 = 0;
           $xfer += $input->readMapBegin(\$_ktype171, \$_vtype172, \$_size170);
           for (my $_i174 = 0; $_i174 < $_size170; ++$_i174)
           {
             my $key175 = '';
-            my $val176 = 0;
+            my $val176 = '';
             $xfer += $input->readString(\$key175);
-            $xfer += $input->readI64(\$val176);
-            $self->{longMap}->{$key175} = $val176;
+            $xfer += $input->readString(\$val176);
+            $self->{strMap}->{$key175} = $val176;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3441,20 +3566,41 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^4$/ && do{      if ($ftype == TType::MAP) {
+      /^3$/ && do{      if ($ftype == TType::MAP) {
         {
           my $_size177 = 0;
-          $self->{doubleMap} = {};
+          $self->{longMap} = {};
           my $_ktype178 = 0;
           my $_vtype179 = 0;
           $xfer += $input->readMapBegin(\$_ktype178, \$_vtype179, \$_size177);
           for (my $_i181 = 0; $_i181 < $_size177; ++$_i181)
           {
             my $key182 = '';
-            my $val183 = 0.0;
+            my $val183 = 0;
             $xfer += $input->readString(\$key182);
-            $xfer += $input->readDouble(\$val183);
-            $self->{doubleMap}->{$key182} = $val183;
+            $xfer += $input->readI64(\$val183);
+            $self->{longMap}->{$key182} = $val183;
+          }
+          $xfer += $input->readMapEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::MAP) {
+        {
+          my $_size184 = 0;
+          $self->{doubleMap} = {};
+          my $_ktype185 = 0;
+          my $_vtype186 = 0;
+          $xfer += $input->readMapBegin(\$_ktype185, \$_vtype186, \$_size184);
+          for (my $_i188 = 0; $_i188 < $_size184; ++$_i188)
+          {
+            my $key189 = '';
+            my $val190 = 0.0;
+            $xfer += $input->readString(\$key189);
+            $xfer += $input->readDouble(\$val190);
+            $self->{doubleMap}->{$key189} = $val190;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3484,10 +3630,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{strMap}}));
       {
-        while( my ($kiter184,$viter185) = each %{$self->{strMap}}) 
+        while( my ($kiter191,$viter192) = each %{$self->{strMap}}) 
         {
-          $xfer += $output->writeString($kiter184);
-          $xfer += $output->writeString($viter185);
+          $xfer += $output->writeString($kiter191);
+          $xfer += $output->writeString($viter192);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3499,10 +3645,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::I64, scalar(keys %{$self->{longMap}}));
       {
-        while( my ($kiter186,$viter187) = each %{$self->{longMap}}) 
+        while( my ($kiter193,$viter194) = each %{$self->{longMap}}) 
         {
-          $xfer += $output->writeString($kiter186);
-          $xfer += $output->writeI64($viter187);
+          $xfer += $output->writeString($kiter193);
+          $xfer += $output->writeI64($viter194);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3514,10 +3660,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::DOUBLE, scalar(keys %{$self->{doubleMap}}));
       {
-        while( my ($kiter188,$viter189) = each %{$self->{doubleMap}}) 
+        while( my ($kiter195,$viter196) = each %{$self->{doubleMap}}) 
         {
-          $xfer += $output->writeString($kiter188);
-          $xfer += $output->writeDouble($viter189);
+          $xfer += $output->writeString($kiter195);
+          $xfer += $output->writeDouble($viter196);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3577,18 +3723,18 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size190 = 0;
+          my $_size197 = 0;
           $self->{attributes} = {};
-          my $_ktype191 = 0;
-          my $_vtype192 = 0;
-          $xfer += $input->readMapBegin(\$_ktype191, \$_vtype192, \$_size190);
-          for (my $_i194 = 0; $_i194 < $_size190; ++$_i194)
+          my $_ktype198 = 0;
+          my $_vtype199 = 0;
+          $xfer += $input->readMapBegin(\$_ktype198, \$_vtype199, \$_size197);
+          for (my $_i201 = 0; $_i201 < $_size197; ++$_i201)
           {
-            my $key195 = '';
-            my $val196 = '';
-            $xfer += $input->readString(\$key195);
-            $xfer += $input->readString(\$val196);
-            $self->{attributes}->{$key195} = $val196;
+            my $key202 = '';
+            my $val203 = '';
+            $xfer += $input->readString(\$key202);
+            $xfer += $input->readString(\$val203);
+            $self->{attributes}->{$key202} = $val203;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3618,10 +3764,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{attributes}}));
       {
-        while( my ($kiter197,$viter198) = each %{$self->{attributes}}) 
+        while( my ($kiter204,$viter205) = each %{$self->{attributes}}) 
         {
-          $xfer += $output->writeString($kiter197);
-          $xfer += $output->writeString($viter198);
+          $xfer += $output->writeString($kiter204);
+          $xfer += $output->writeString($viter205);
         }
       }
       $xfer += $output->writeMapEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/5e495671/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 4cc1348..48cc80d 100644
--- a/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
+++ b/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
@@ -390,6 +390,26 @@ module Blur
     ::Thrift::Struct.generate_accessors self
   end
 
+  class SortField
+    include ::Thrift::Struct, ::Thrift::Struct_Union
+    FAMILY = 1
+    COLUMN = 2
+    REVERSE = 3
+
+    FIELDS = {
+      FAMILY => {:type => ::Thrift::Types::STRING, :name => 'family'},
+      COLUMN => {:type => ::Thrift::Types::STRING, :name => 'column'},
+      REVERSE => {:type => ::Thrift::Types::BOOL, :name => 'reverse'}
+    }
+
+    def struct_fields; FIELDS; end
+
+    def validate
+    end
+
+    ::Thrift::Struct.generate_accessors self
+  end
+
   # The Blur Query object that contains the query that needs to be executed along
 # with the query options.
   class BlurQuery
@@ -406,6 +426,7 @@ module Blur
     USERCONTEXT = 12
     CACHERESULT = 13
     STARTTIME = 14
+    SORTFIELDS = 15
 
     FIELDS = {
       # The query information.
@@ -433,7 +454,8 @@ module Blur
       # Enabled by default to cache this result.  False would not cache the result.
       CACHERESULT => {:type => ::Thrift::Types::BOOL, :name => 'cacheResult', :default => true},
       # Sets the start time, if 0 the controller sets the time.
-      STARTTIME => {:type => ::Thrift::Types::I64, :name => 'startTime', :default => 0}
+      STARTTIME => {:type => ::Thrift::Types::I64, :name => 'startTime', :default => 0},
+      SORTFIELDS => {:type => ::Thrift::Types::LIST, :name => 'sortFields', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::SortField}}
     }
 
     def struct_fields; FIELDS; end
@@ -444,31 +466,32 @@ module Blur
     ::Thrift::Struct.generate_accessors self
   end
 
-  class SortField < ::Thrift::Union
+  # Carries the one value from the sort that allows the merging of results.
+  class SortFieldResult < ::Thrift::Union
     include ::Thrift::Struct_Union
     class << self
       def nullValue(val)
-        SortField.new(:nullValue, val)
+        SortFieldResult.new(:nullValue, val)
       end
 
       def stringValue(val)
-        SortField.new(:stringValue, val)
+        SortFieldResult.new(:stringValue, val)
       end
 
       def intValue(val)
-        SortField.new(:intValue, val)
+        SortFieldResult.new(:intValue, val)
       end
 
       def longValue(val)
-        SortField.new(:longValue, val)
+        SortFieldResult.new(:longValue, val)
       end
 
       def doubleValue(val)
-        SortField.new(:doubleValue, val)
+        SortFieldResult.new(:doubleValue, val)
       end
 
       def binaryValue(val)
-        SortField.new(:binaryValue, val)
+        SortFieldResult.new(:binaryValue, val)
       end
     end
 
@@ -480,11 +503,17 @@ module Blur
     BINARYVALUE = 6
 
     FIELDS = {
+      # Carries the null boolean incase the field is null.
       NULLVALUE => {:type => ::Thrift::Types::BOOL, :name => 'nullValue'},
+      # The string value.
       STRINGVALUE => {:type => ::Thrift::Types::STRING, :name => 'stringValue'},
+      # The integer value.
       INTVALUE => {:type => ::Thrift::Types::I32, :name => 'intValue'},
+      # The long value.
       LONGVALUE => {:type => ::Thrift::Types::I64, :name => 'longValue'},
+      # The double value.
       DOUBLEVALUE => {:type => ::Thrift::Types::DOUBLE, :name => 'doubleValue'},
+      # The binary value.
       BINARYVALUE => {:type => ::Thrift::Types::STRING, :name => 'binaryValue', :binary => true}
     }
 
@@ -503,7 +532,7 @@ module Blur
     LOCATIONID = 1
     SCORE = 2
     FETCHRESULT = 3
-    SORTFIELDS = 4
+    SORTFIELDRESULTS = 4
 
     FIELDS = {
       # WARNING: This is an internal only attribute and is not intended for use by clients.
@@ -513,7 +542,7 @@ module Blur
       # The fetched result if any.
       FETCHRESULT => {:type => ::Thrift::Types::STRUCT, :name => 'fetchResult', :class => ::Blur::FetchResult},
       # The fields used for sorting.
-      SORTFIELDS => {:type => ::Thrift::Types::LIST, :name => 'sortFields', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::SortField}}
+      SORTFIELDRESULTS => {:type => ::Thrift::Types::LIST, :name => 'sortFieldResults', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::SortFieldResult}}
     }
 
     def struct_fields; FIELDS; end
@@ -716,6 +745,7 @@ module Blur
     FIELDLESSINDEXED = 4
     FIELDTYPE = 5
     PROPERTIES = 6
+    SORTABLE = 7
 
     FIELDS = {
       # Required. The family that this column exists within.
@@ -739,7 +769,9 @@ module Blur
 # </ul>
       FIELDTYPE => {:type => ::Thrift::Types::STRING, :name => 'fieldType'},
       # For any custom field types, you can pass in configuration properties.
-      PROPERTIES => {:type => ::Thrift::Types::MAP, :name => 'properties', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}}
+      PROPERTIES => {:type => ::Thrift::Types::MAP, :name => 'properties', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}},
+      # This will attempt to enable sorting for this column, if the type does not support sorting then an exception will be thrown.
+      SORTABLE => {:type => ::Thrift::Types::BOOL, :name => 'sortable'}
     }
 
     def struct_fields; FIELDS; end

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/5e495671/docs/Blur.html
----------------------------------------------------------------------
diff --git a/docs/Blur.html b/docs/Blur.html
index 2fdec80..7f4ae2b 100644
--- a/docs/Blur.html
+++ b/docs/Blur.html
@@ -77,8 +77,9 @@ limitations under the License.
 <li><a href="#Struct_FetchRecordResult">FetchRecordResult</a></li>
 <li><a href="#Struct_FetchResult">FetchResult</a></li>
 <li><a href="#Struct_Facet">Facet</a></li>
-<li><a href="#Struct_BlurQuery">BlurQuery</a></li>
 <li><a href="#Struct_SortField">SortField</a></li>
+<li><a href="#Struct_BlurQuery">BlurQuery</a></li>
+<li><a href="#Struct_SortFieldResult">SortFieldResult</a></li>
 <li><a href="#Struct_BlurResult">BlurResult</a></li>
 <li><a href="#Struct_BlurResults">BlurResults</a></li>
 <li><a href="#Struct_RecordMutation">RecordMutation</a></li>
@@ -385,7 +386,12 @@ the shard server level the controller will likely return more than the minimum
 because it sums the answers from the shard servers.
 </td><td>default</td><td>9223372036854775807</td></tr>
 </table><br/>Blur facet.
-<br/></p></section><section><div class="page-header"><h3 id="Struct_BlurQuery">Struct: BlurQuery</h3></div><p class="lead">
+<br/></p></section><section><div class="page-header"><h3 id="Struct_SortField">Struct: SortField</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>
+<tr><td>1</td><td>family</td><td><code>string</code></td><td></td><td>default</td><td></td></tr>
+<tr><td>2</td><td>column</td><td><code>string</code></td><td></td><td>default</td><td></td></tr>
+<tr><td>3</td><td>reverse</td><td><code>bool</code></td><td></td><td>default</td><td></td></tr>
+</table><br/></p></section><section><div class="page-header"><h3 id="Struct_BlurQuery">Struct: BlurQuery</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>
 <tr><td>1</td><td>query</td><td><code><a href="Blur.html#Struct_Query">Query</a></code></td><td>The query information.
 </td><td>default</td><td></td></tr>
@@ -413,17 +419,25 @@ of a running query can be found or the query can be canceled.
 </td><td>default</td><td>1</td></tr>
 <tr><td>14</td><td>startTime</td><td><code>i64</code></td><td>Sets the start time, if 0 the controller sets the time.
 </td><td>default</td><td>0</td></tr>
+<tr><td>15</td><td>sortFields</td><td><code>list&lt;<code><a href="Blur.html#Struct_SortField">SortField</a></code>&gt;</code></td><td></td><td>default</td><td></td></tr>
 </table><br/>The Blur Query object that contains the query that needs to be executed along
 with the query options.
-<br/></p></section><section><div class="page-header"><h3 id="Struct_SortField">Struct: SortField</h3></div><p class="lead">
+<br/></p></section><section><div class="page-header"><h3 id="Struct_SortFieldResult">Struct: SortFieldResult</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>
-<tr><td>1</td><td>nullValue</td><td><code>bool</code></td><td></td><td>default</td><td></td></tr>
-<tr><td>2</td><td>stringValue</td><td><code>string</code></td><td></td><td>default</td><td></td></tr>
-<tr><td>3</td><td>intValue</td><td><code>i32</code></td><td></td><td>default</td><td></td></tr>
-<tr><td>4</td><td>longValue</td><td><code>i64</code></td><td></td><td>default</td><td></td></tr>
-<tr><td>5</td><td>doubleValue</td><td><code>double</code></td><td></td><td>default</td><td></td></tr>
-<tr><td>6</td><td>binaryValue</td><td><code>binary</code></td><td></td><td>default</td><td></td></tr>
-</table><br/></p></section><section><div class="page-header"><h3 id="Struct_BlurResult">Struct: BlurResult</h3></div><p class="lead">
+<tr><td>1</td><td>nullValue</td><td><code>bool</code></td><td>Carries the null boolean incase the field is null.
+</td><td>default</td><td></td></tr>
+<tr><td>2</td><td>stringValue</td><td><code>string</code></td><td>The string value.
+</td><td>default</td><td></td></tr>
+<tr><td>3</td><td>intValue</td><td><code>i32</code></td><td>The integer value.
+</td><td>default</td><td></td></tr>
+<tr><td>4</td><td>longValue</td><td><code>i64</code></td><td>The long value.
+</td><td>default</td><td></td></tr>
+<tr><td>5</td><td>doubleValue</td><td><code>double</code></td><td>The double value.
+</td><td>default</td><td></td></tr>
+<tr><td>6</td><td>binaryValue</td><td><code>binary</code></td><td>The binary value.
+</td><td>default</td><td></td></tr>
+</table><br/>Carries the one value from the sort that allows the merging of results.
+<br/></p></section><section><div class="page-header"><h3 id="Struct_BlurResult">Struct: BlurResult</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>
 <tr><td>1</td><td>locationId</td><td><code>string</code></td><td>WARNING: This is an internal only attribute and is not intended for use by clients.
 </td><td>default</td><td></td></tr>
@@ -431,7 +445,7 @@ with the query options.
 </td><td>default</td><td></td></tr>
 <tr><td>3</td><td>fetchResult</td><td><code><a href="Blur.html#Struct_FetchResult">FetchResult</a></code></td><td>The fetched result if any.
 </td><td>default</td><td></td></tr>
-<tr><td>4</td><td>sortFields</td><td><code>list&lt;<code><a href="Blur.html#Struct_SortField">SortField</a></code>&gt;</code></td><td>The fields used for sorting.
+<tr><td>4</td><td>sortFieldResults</td><td><code>list&lt;<code><a href="Blur.html#Struct_SortFieldResult">SortFieldResult</a></code>&gt;</code></td><td>The fields used for sorting.
 </td><td>default</td><td></td></tr>
 </table><br/>The BlurResult carries the score, the location id and the fetched result (if any) form each query.
 <br/></p></section><section><div class="page-header"><h3 id="Struct_BlurResults">Struct: BlurResults</h3></div><p class="lead">
@@ -532,6 +546,8 @@ NOTE: This will index the column as a full text field in a default field, so tha
 </td><td>default</td><td></td></tr>
 <tr><td>6</td><td>properties</td><td><code>map&lt;<code>string</code>, <code>string</code>&gt;</code></td><td>For any custom field types, you can pass in configuration properties.
 </td><td>default</td><td></td></tr>
+<tr><td>7</td><td>sortable</td><td><code>bool</code></td><td>This will attempt to enable sorting for this column, if the type does not support sorting then an exception will be thrown.
+</td><td>default</td><td></td></tr>
 </table><br/>The ColumnDefinition defines how a given Column should be interpreted (indexed/stored)
 <br/></p></section><section><div class="page-header"><h3 id="Struct_Schema">Struct: Schema</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