incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [12/50] [abbrv] Removal of Selector.
Date Wed, 07 Nov 2012 02:26:55 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/6577ca0c/interface/gen-java/org/apache/blur/thrift/generated/UpdatePackage.java
----------------------------------------------------------------------
diff --git a/interface/gen-java/org/apache/blur/thrift/generated/UpdatePackage.java b/interface/gen-java/org/apache/blur/thrift/generated/UpdatePackage.java
index 961932f..d26814b 100644
--- a/interface/gen-java/org/apache/blur/thrift/generated/UpdatePackage.java
+++ b/interface/gen-java/org/apache/blur/thrift/generated/UpdatePackage.java
@@ -471,14 +471,14 @@ public class UpdatePackage implements org.apache.thrift.TBase<UpdatePackage, Upd
           case 2: // DOCUMENTS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list174 = iprot.readListBegin();
-                struct.documents = new ArrayList<Document>(_list174.size);
-                for (int _i175 = 0; _i175 < _list174.size; ++_i175)
+                org.apache.thrift.protocol.TList _list148 = iprot.readListBegin();
+                struct.documents = new ArrayList<Document>(_list148.size);
+                for (int _i149 = 0; _i149 < _list148.size; ++_i149)
                 {
-                  Document _elem176; // required
-                  _elem176 = new Document();
-                  _elem176.read(iprot);
-                  struct.documents.add(_elem176);
+                  Document _elem150; // required
+                  _elem150 = new Document();
+                  _elem150.read(iprot);
+                  struct.documents.add(_elem150);
                 }
                 iprot.readListEnd();
               }
@@ -511,9 +511,9 @@ public class UpdatePackage implements org.apache.thrift.TBase<UpdatePackage, Upd
         oprot.writeFieldBegin(DOCUMENTS_FIELD_DESC);
         {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.documents.size()));
-          for (Document _iter177 : struct.documents)
+          for (Document _iter151 : struct.documents)
           {
-            _iter177.write(oprot);
+            _iter151.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -550,9 +550,9 @@ public class UpdatePackage implements org.apache.thrift.TBase<UpdatePackage, Upd
       if (struct.isSetDocuments()) {
         {
           oprot.writeI32(struct.documents.size());
-          for (Document _iter178 : struct.documents)
+          for (Document _iter152 : struct.documents)
           {
-            _iter178.write(oprot);
+            _iter152.write(oprot);
           }
         }
       }
@@ -569,14 +569,14 @@ public class UpdatePackage implements org.apache.thrift.TBase<UpdatePackage, Upd
       }
       if (incoming.get(1)) {
         {
-          org.apache.thrift.protocol.TList _list179 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-          struct.documents = new ArrayList<Document>(_list179.size);
-          for (int _i180 = 0; _i180 < _list179.size; ++_i180)
+          org.apache.thrift.protocol.TList _list153 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.documents = new ArrayList<Document>(_list153.size);
+          for (int _i154 = 0; _i154 < _list153.size; ++_i154)
           {
-            Document _elem181; // required
-            _elem181 = new Document();
-            _elem181.read(iprot);
-            struct.documents.add(_elem181);
+            Document _elem155; // required
+            _elem155 = new Document();
+            _elem155.read(iprot);
+            struct.documents.add(_elem155);
           }
         }
         struct.setDocumentsIsSet(true);

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/6577ca0c/interface/gen-perl/Blur/Blur.pm
----------------------------------------------------------------------
diff --git a/interface/gen-perl/Blur/Blur.pm b/interface/gen-perl/Blur/Blur.pm
index d747147..8ec7d33 100644
--- a/interface/gen-perl/Blur/Blur.pm
+++ b/interface/gen-perl/Blur/Blur.pm
@@ -100,15 +100,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size161 = 0;
+          my $_size138 = 0;
           $self->{success} = [];
-          my $_etype164 = 0;
-          $xfer += $input->readListBegin(\$_etype164, \$_size161);
-          for (my $_i165 = 0; $_i165 < $_size161; ++$_i165)
+          my $_etype141 = 0;
+          $xfer += $input->readListBegin(\$_etype141, \$_size138);
+          for (my $_i142 = 0; $_i142 < $_size138; ++$_i142)
           {
-            my $elem166 = undef;
-            $xfer += $input->readString(\$elem166);
-            push(@{$self->{success}},$elem166);
+            my $elem143 = undef;
+            $xfer += $input->readString(\$elem143);
+            push(@{$self->{success}},$elem143);
           }
           $xfer += $input->readListEnd();
         }
@@ -140,9 +140,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter167 (@{$self->{success}}) 
+        foreach my $iter144 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter167);
+          $xfer += $output->writeString($iter144);
         }
       }
       $xfer += $output->writeListEnd();
@@ -265,15 +265,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size168 = 0;
+          my $_size145 = 0;
           $self->{success} = [];
-          my $_etype171 = 0;
-          $xfer += $input->readListBegin(\$_etype171, \$_size168);
-          for (my $_i172 = 0; $_i172 < $_size168; ++$_i172)
+          my $_etype148 = 0;
+          $xfer += $input->readListBegin(\$_etype148, \$_size145);
+          for (my $_i149 = 0; $_i149 < $_size145; ++$_i149)
           {
-            my $elem173 = undef;
-            $xfer += $input->readString(\$elem173);
-            push(@{$self->{success}},$elem173);
+            my $elem150 = undef;
+            $xfer += $input->readString(\$elem150);
+            push(@{$self->{success}},$elem150);
           }
           $xfer += $input->readListEnd();
         }
@@ -305,9 +305,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter174 (@{$self->{success}}) 
+        foreach my $iter151 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter174);
+          $xfer += $output->writeString($iter151);
         }
       }
       $xfer += $output->writeListEnd();
@@ -412,15 +412,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size175 = 0;
+          my $_size152 = 0;
           $self->{success} = [];
-          my $_etype178 = 0;
-          $xfer += $input->readListBegin(\$_etype178, \$_size175);
-          for (my $_i179 = 0; $_i179 < $_size175; ++$_i179)
+          my $_etype155 = 0;
+          $xfer += $input->readListBegin(\$_etype155, \$_size152);
+          for (my $_i156 = 0; $_i156 < $_size152; ++$_i156)
           {
-            my $elem180 = undef;
-            $xfer += $input->readString(\$elem180);
-            push(@{$self->{success}},$elem180);
+            my $elem157 = undef;
+            $xfer += $input->readString(\$elem157);
+            push(@{$self->{success}},$elem157);
           }
           $xfer += $input->readListEnd();
         }
@@ -452,9 +452,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter181 (@{$self->{success}}) 
+        foreach my $iter158 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter181);
+          $xfer += $output->writeString($iter158);
         }
       }
       $xfer += $output->writeListEnd();
@@ -577,18 +577,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size182 = 0;
+          my $_size159 = 0;
           $self->{success} = {};
-          my $_ktype183 = 0;
-          my $_vtype184 = 0;
-          $xfer += $input->readMapBegin(\$_ktype183, \$_vtype184, \$_size182);
-          for (my $_i186 = 0; $_i186 < $_size182; ++$_i186)
+          my $_ktype160 = 0;
+          my $_vtype161 = 0;
+          $xfer += $input->readMapBegin(\$_ktype160, \$_vtype161, \$_size159);
+          for (my $_i163 = 0; $_i163 < $_size159; ++$_i163)
           {
-            my $key187 = '';
-            my $val188 = '';
-            $xfer += $input->readString(\$key187);
-            $xfer += $input->readString(\$val188);
-            $self->{success}->{$key187} = $val188;
+            my $key164 = '';
+            my $val165 = '';
+            $xfer += $input->readString(\$key164);
+            $xfer += $input->readString(\$val165);
+            $self->{success}->{$key164} = $val165;
           }
           $xfer += $input->readMapEnd();
         }
@@ -620,10 +620,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter189,$viter190) = each %{$self->{success}}) 
+        while( my ($kiter166,$viter167) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter189);
-          $xfer += $output->writeString($viter190);
+          $xfer += $output->writeString($kiter166);
+          $xfer += $output->writeString($viter167);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -728,15 +728,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size191 = 0;
+          my $_size168 = 0;
           $self->{success} = [];
-          my $_etype194 = 0;
-          $xfer += $input->readListBegin(\$_etype194, \$_size191);
-          for (my $_i195 = 0; $_i195 < $_size191; ++$_i195)
+          my $_etype171 = 0;
+          $xfer += $input->readListBegin(\$_etype171, \$_size168);
+          for (my $_i172 = 0; $_i172 < $_size168; ++$_i172)
           {
-            my $elem196 = undef;
-            $xfer += $input->readString(\$elem196);
-            push(@{$self->{success}},$elem196);
+            my $elem173 = undef;
+            $xfer += $input->readString(\$elem173);
+            push(@{$self->{success}},$elem173);
           }
           $xfer += $input->readListEnd();
         }
@@ -768,9 +768,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter197 (@{$self->{success}}) 
+        foreach my $iter174 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter197);
+          $xfer += $output->writeString($iter174);
         }
       }
       $xfer += $output->writeListEnd();
@@ -893,15 +893,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size198 = 0;
+          my $_size175 = 0;
           $self->{success} = [];
-          my $_etype201 = 0;
-          $xfer += $input->readListBegin(\$_etype201, \$_size198);
-          for (my $_i202 = 0; $_i202 < $_size198; ++$_i202)
+          my $_etype178 = 0;
+          $xfer += $input->readListBegin(\$_etype178, \$_size175);
+          for (my $_i179 = 0; $_i179 < $_size175; ++$_i179)
           {
-            my $elem203 = undef;
-            $xfer += $input->readString(\$elem203);
-            push(@{$self->{success}},$elem203);
+            my $elem180 = undef;
+            $xfer += $input->readString(\$elem180);
+            push(@{$self->{success}},$elem180);
           }
           $xfer += $input->readListEnd();
         }
@@ -933,9 +933,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter204 (@{$self->{success}}) 
+        foreach my $iter181 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter204);
+          $xfer += $output->writeString($iter181);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1347,16 +1347,16 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size205 = 0;
+          my $_size182 = 0;
           $self->{success} = [];
-          my $_etype208 = 0;
-          $xfer += $input->readListBegin(\$_etype208, \$_size205);
-          for (my $_i209 = 0; $_i209 < $_size205; ++$_i209)
+          my $_etype185 = 0;
+          $xfer += $input->readListBegin(\$_etype185, \$_size182);
+          for (my $_i186 = 0; $_i186 < $_size182; ++$_i186)
           {
-            my $elem210 = undef;
-            $elem210 = new Blur::BlurQueryStatus();
-            $xfer += $elem210->read($input);
-            push(@{$self->{success}},$elem210);
+            my $elem187 = undef;
+            $elem187 = new Blur::BlurQueryStatus();
+            $xfer += $elem187->read($input);
+            push(@{$self->{success}},$elem187);
           }
           $xfer += $input->readListEnd();
         }
@@ -1388,9 +1388,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
       {
-        foreach my $iter211 (@{$self->{success}}) 
+        foreach my $iter188 (@{$self->{success}}) 
         {
-          $xfer += ${iter211}->write($output);
+          $xfer += ${iter188}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1513,15 +1513,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size212 = 0;
+          my $_size189 = 0;
           $self->{success} = [];
-          my $_etype215 = 0;
-          $xfer += $input->readListBegin(\$_etype215, \$_size212);
-          for (my $_i216 = 0; $_i216 < $_size212; ++$_i216)
+          my $_etype192 = 0;
+          $xfer += $input->readListBegin(\$_etype192, \$_size189);
+          for (my $_i193 = 0; $_i193 < $_size189; ++$_i193)
           {
-            my $elem217 = undef;
-            $xfer += $input->readI64(\$elem217);
-            push(@{$self->{success}},$elem217);
+            my $elem194 = undef;
+            $xfer += $input->readI64(\$elem194);
+            push(@{$self->{success}},$elem194);
           }
           $xfer += $input->readListEnd();
         }
@@ -1553,9 +1553,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{success}}));
       {
-        foreach my $iter218 (@{$self->{success}}) 
+        foreach my $iter195 (@{$self->{success}}) 
         {
-          $xfer += $output->writeI64($iter218);
+          $xfer += $output->writeI64($iter195);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3075,18 +3075,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size219 = 0;
+          my $_size196 = 0;
           $self->{success} = {};
-          my $_ktype220 = 0;
-          my $_vtype221 = 0;
-          $xfer += $input->readMapBegin(\$_ktype220, \$_vtype221, \$_size219);
-          for (my $_i223 = 0; $_i223 < $_size219; ++$_i223)
+          my $_ktype197 = 0;
+          my $_vtype198 = 0;
+          $xfer += $input->readMapBegin(\$_ktype197, \$_vtype198, \$_size196);
+          for (my $_i200 = 0; $_i200 < $_size196; ++$_i200)
           {
-            my $key224 = '';
-            my $val225 = '';
-            $xfer += $input->readString(\$key224);
-            $xfer += $input->readString(\$val225);
-            $self->{success}->{$key224} = $val225;
+            my $key201 = '';
+            my $val202 = '';
+            $xfer += $input->readString(\$key201);
+            $xfer += $input->readString(\$val202);
+            $self->{success}->{$key201} = $val202;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3118,10 +3118,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter226,$viter227) = each %{$self->{success}}) 
+        while( my ($kiter203,$viter204) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter226);
-          $xfer += $output->writeString($viter227);
+          $xfer += $output->writeString($kiter203);
+          $xfer += $output->writeString($viter204);
         }
       }
       $xfer += $output->writeMapEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/6577ca0c/interface/gen-perl/Blur/ShardServer.pm
----------------------------------------------------------------------
diff --git a/interface/gen-perl/Blur/ShardServer.pm b/interface/gen-perl/Blur/ShardServer.pm
index e83f9b4..1653d00 100644
--- a/interface/gen-perl/Blur/ShardServer.pm
+++ b/interface/gen-perl/Blur/ShardServer.pm
@@ -281,16 +281,16 @@ sub read {
       {
         /^0$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size228 = 0;
+            my $_size205 = 0;
             $self->{success} = [];
-            my $_etype231 = 0;
-            $xfer += $input->readListBegin(\$_etype231, \$_size228);
-            for (my $_i232 = 0; $_i232 < $_size228; ++$_i232)
+            my $_etype208 = 0;
+            $xfer += $input->readListBegin(\$_etype208, \$_size205);
+            for (my $_i209 = 0; $_i209 < $_size205; ++$_i209)
             {
-              my $elem233 = undef;
-              $elem233 = new Blur::TopFieldDocs();
-              $xfer += $elem233->read($input);
-              push(@{$self->{success}},$elem233);
+              my $elem210 = undef;
+              $elem210 = new Blur::TopFieldDocs();
+              $xfer += $elem210->read($input);
+              push(@{$self->{success}},$elem210);
             }
             $xfer += $input->readListEnd();
           }
@@ -322,9 +322,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
         {
-          foreach my $iter234 (@{$self->{success}}) 
+          foreach my $iter211 (@{$self->{success}}) 
           {
-            $xfer += ${iter234}->write($output);
+            $xfer += ${iter211}->write($output);
           }
         }
         $xfer += $output->writeListEnd();
@@ -394,16 +394,16 @@ sub read {
         last; };
         /^2$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size235 = 0;
+            my $_size212 = 0;
             $self->{docLocations} = [];
-            my $_etype238 = 0;
-            $xfer += $input->readListBegin(\$_etype238, \$_size235);
-            for (my $_i239 = 0; $_i239 < $_size235; ++$_i239)
+            my $_etype215 = 0;
+            $xfer += $input->readListBegin(\$_etype215, \$_size212);
+            for (my $_i216 = 0; $_i216 < $_size212; ++$_i216)
             {
-              my $elem240 = undef;
-              $elem240 = new Blur::DocLocation();
-              $xfer += $elem240->read($input);
-              push(@{$self->{docLocations}},$elem240);
+              my $elem217 = undef;
+              $elem217 = new Blur::DocLocation();
+              $xfer += $elem217->read($input);
+              push(@{$self->{docLocations}},$elem217);
             }
             $xfer += $input->readListEnd();
           }
@@ -413,15 +413,15 @@ sub read {
         last; };
         /^4$/ && do{        if ($ftype == TType::SET) {
           {
-            my $_size241 = 0;
+            my $_size218 = 0;
             $self->{fields} = {};
-            my $_etype244 = 0;
-            $xfer += $input->readSetBegin(\$_etype244, \$_size241);
-            for (my $_i245 = 0; $_i245 < $_size241; ++$_i245)
+            my $_etype221 = 0;
+            $xfer += $input->readSetBegin(\$_etype221, \$_size218);
+            for (my $_i222 = 0; $_i222 < $_size218; ++$_i222)
             {
-              my $elem246 = undef;
-              $xfer += $input->readString(\$elem246);
-              $self->{fields}->{$elem246} = 1;
+              my $elem223 = undef;
+              $xfer += $input->readString(\$elem223);
+              $self->{fields}->{$elem223} = 1;
             }
             $xfer += $input->readSetEnd();
           }
@@ -451,9 +451,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{docLocations}}));
         {
-          foreach my $iter247 (@{$self->{docLocations}}) 
+          foreach my $iter224 (@{$self->{docLocations}}) 
           {
-            $xfer += ${iter247}->write($output);
+            $xfer += ${iter224}->write($output);
           }
         }
         $xfer += $output->writeListEnd();
@@ -465,9 +465,9 @@ sub write {
       {
         $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{fields}}));
         {
-          foreach my $iter248 (@{$self->{fields}})
+          foreach my $iter225 (@{$self->{fields}})
           {
-            $xfer += $output->writeString($iter248);
+            $xfer += $output->writeString($iter225);
           }
         }
         $xfer += $output->writeSetEnd();
@@ -521,16 +521,16 @@ sub read {
       {
         /^0$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size249 = 0;
+            my $_size226 = 0;
             $self->{success} = [];
-            my $_etype252 = 0;
-            $xfer += $input->readListBegin(\$_etype252, \$_size249);
-            for (my $_i253 = 0; $_i253 < $_size249; ++$_i253)
+            my $_etype229 = 0;
+            $xfer += $input->readListBegin(\$_etype229, \$_size226);
+            for (my $_i230 = 0; $_i230 < $_size226; ++$_i230)
             {
-              my $elem254 = undef;
-              $elem254 = new Blur::Document();
-              $xfer += $elem254->read($input);
-              push(@{$self->{success}},$elem254);
+              my $elem231 = undef;
+              $elem231 = new Blur::Document();
+              $xfer += $elem231->read($input);
+              push(@{$self->{success}},$elem231);
             }
             $xfer += $input->readListEnd();
           }
@@ -562,9 +562,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
         {
-          foreach my $iter255 (@{$self->{success}}) 
+          foreach my $iter232 (@{$self->{success}}) 
           {
-            $xfer += ${iter255}->write($output);
+            $xfer += ${iter232}->write($output);
           }
         }
         $xfer += $output->writeListEnd();
@@ -760,16 +760,16 @@ sub read {
         last; };
         /^2$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size256 = 0;
+            my $_size233 = 0;
             $self->{documents} = [];
-            my $_etype259 = 0;
-            $xfer += $input->readListBegin(\$_etype259, \$_size256);
-            for (my $_i260 = 0; $_i260 < $_size256; ++$_i260)
+            my $_etype236 = 0;
+            $xfer += $input->readListBegin(\$_etype236, \$_size233);
+            for (my $_i237 = 0; $_i237 < $_size233; ++$_i237)
             {
-              my $elem261 = undef;
-              $elem261 = new Blur::Document();
-              $xfer += $elem261->read($input);
-              push(@{$self->{documents}},$elem261);
+              my $elem238 = undef;
+              $elem238 = new Blur::Document();
+              $xfer += $elem238->read($input);
+              push(@{$self->{documents}},$elem238);
             }
             $xfer += $input->readListEnd();
           }
@@ -799,9 +799,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{documents}}));
         {
-          foreach my $iter262 (@{$self->{documents}}) 
+          foreach my $iter239 (@{$self->{documents}}) 
           {
-            $xfer += ${iter262}->write($output);
+            $xfer += ${iter239}->write($output);
           }
         }
         $xfer += $output->writeListEnd();
@@ -927,15 +927,15 @@ sub read {
         last; };
         /^2$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size263 = 0;
+            my $_size240 = 0;
             $self->{queries} = [];
-            my $_etype266 = 0;
-            $xfer += $input->readListBegin(\$_etype266, \$_size263);
-            for (my $_i267 = 0; $_i267 < $_size263; ++$_i267)
+            my $_etype243 = 0;
+            $xfer += $input->readListBegin(\$_etype243, \$_size240);
+            for (my $_i244 = 0; $_i244 < $_size240; ++$_i244)
             {
-              my $elem268 = undef;
-              $xfer += $input->readString(\$elem268);
-              push(@{$self->{queries}},$elem268);
+              my $elem245 = undef;
+              $xfer += $input->readString(\$elem245);
+              push(@{$self->{queries}},$elem245);
             }
             $xfer += $input->readListEnd();
           }
@@ -965,9 +965,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{queries}}));
         {
-          foreach my $iter269 (@{$self->{queries}}) 
+          foreach my $iter246 (@{$self->{queries}}) 
           {
-            $xfer += $output->writeString($iter269);
+            $xfer += $output->writeString($iter246);
           }
         }
         $xfer += $output->writeListEnd();
@@ -1093,16 +1093,16 @@ sub read {
         last; };
         /^2$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size270 = 0;
+            my $_size247 = 0;
             $self->{terms} = [];
-            my $_etype273 = 0;
-            $xfer += $input->readListBegin(\$_etype273, \$_size270);
-            for (my $_i274 = 0; $_i274 < $_size270; ++$_i274)
+            my $_etype250 = 0;
+            $xfer += $input->readListBegin(\$_etype250, \$_size247);
+            for (my $_i251 = 0; $_i251 < $_size247; ++$_i251)
             {
-              my $elem275 = undef;
-              $elem275 = new Blur::Term();
-              $xfer += $elem275->read($input);
-              push(@{$self->{terms}},$elem275);
+              my $elem252 = undef;
+              $elem252 = new Blur::Term();
+              $xfer += $elem252->read($input);
+              push(@{$self->{terms}},$elem252);
             }
             $xfer += $input->readListEnd();
           }
@@ -1132,9 +1132,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{terms}}));
         {
-          foreach my $iter276 (@{$self->{terms}}) 
+          foreach my $iter253 (@{$self->{terms}}) 
           {
-            $xfer += ${iter276}->write($output);
+            $xfer += ${iter253}->write($output);
           }
         }
         $xfer += $output->writeListEnd();
@@ -1260,16 +1260,16 @@ sub read {
         last; };
         /^2$/ && do{        if ($ftype == TType::LIST) {
           {
-            my $_size277 = 0;
+            my $_size254 = 0;
             $self->{updatePackages} = [];
-            my $_etype280 = 0;
-            $xfer += $input->readListBegin(\$_etype280, \$_size277);
-            for (my $_i281 = 0; $_i281 < $_size277; ++$_i281)
+            my $_etype257 = 0;
+            $xfer += $input->readListBegin(\$_etype257, \$_size254);
+            for (my $_i258 = 0; $_i258 < $_size254; ++$_i258)
             {
-              my $elem282 = undef;
-              $elem282 = new Blur::UpdatePackage();
-              $xfer += $elem282->read($input);
-              push(@{$self->{updatePackages}},$elem282);
+              my $elem259 = undef;
+              $elem259 = new Blur::UpdatePackage();
+              $xfer += $elem259->read($input);
+              push(@{$self->{updatePackages}},$elem259);
             }
             $xfer += $input->readListEnd();
           }
@@ -1299,9 +1299,9 @@ sub write {
       {
         $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{updatePackages}}));
         {
-          foreach my $iter283 (@{$self->{updatePackages}}) 
+          foreach my $iter260 (@{$self->{updatePackages}}) 
           {
-            $xfer += ${iter283}->write($output);
+            $xfer += ${iter260}->write($output);
           }
         }
         $xfer += $output->writeListEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/6577ca0c/interface/gen-perl/Blur/Types.pm
----------------------------------------------------------------------
diff --git a/interface/gen-perl/Blur/Types.pm b/interface/gen-perl/Blur/Types.pm
index ea2fc71..ff697a6 100644
--- a/interface/gen-perl/Blur/Types.pm
+++ b/interface/gen-perl/Blur/Types.pm
@@ -437,227 +437,6 @@ sub write {
   return $xfer;
 }
 
-package Blur::Selector;
-use base qw(Class::Accessor);
-Blur::Selector->mk_accessors( qw( recordOnly locationId rowId recordId columnFamiliesToFetch columnsToFetch allowStaleData ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{recordOnly} = undef;
-  $self->{locationId} = undef;
-  $self->{rowId} = undef;
-  $self->{recordId} = undef;
-  $self->{columnFamiliesToFetch} = undef;
-  $self->{columnsToFetch} = undef;
-  $self->{allowStaleData} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{recordOnly}) {
-      $self->{recordOnly} = $vals->{recordOnly};
-    }
-    if (defined $vals->{locationId}) {
-      $self->{locationId} = $vals->{locationId};
-    }
-    if (defined $vals->{rowId}) {
-      $self->{rowId} = $vals->{rowId};
-    }
-    if (defined $vals->{recordId}) {
-      $self->{recordId} = $vals->{recordId};
-    }
-    if (defined $vals->{columnFamiliesToFetch}) {
-      $self->{columnFamiliesToFetch} = $vals->{columnFamiliesToFetch};
-    }
-    if (defined $vals->{columnsToFetch}) {
-      $self->{columnsToFetch} = $vals->{columnsToFetch};
-    }
-    if (defined $vals->{allowStaleData}) {
-      $self->{allowStaleData} = $vals->{allowStaleData};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Selector';
-}
-
-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::BOOL) {
-        $xfer += $input->readBool(\$self->{recordOnly});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{locationId});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^3$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{rowId});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^4$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{recordId});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^5$/ && do{      if ($ftype == TType::SET) {
-        {
-          my $_size14 = 0;
-          $self->{columnFamiliesToFetch} = {};
-          my $_etype17 = 0;
-          $xfer += $input->readSetBegin(\$_etype17, \$_size14);
-          for (my $_i18 = 0; $_i18 < $_size14; ++$_i18)
-          {
-            my $elem19 = undef;
-            $xfer += $input->readString(\$elem19);
-            $self->{columnFamiliesToFetch}->{$elem19} = 1;
-          }
-          $xfer += $input->readSetEnd();
-        }
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^6$/ && do{      if ($ftype == TType::MAP) {
-        {
-          my $_size20 = 0;
-          $self->{columnsToFetch} = {};
-          my $_ktype21 = 0;
-          my $_vtype22 = 0;
-          $xfer += $input->readMapBegin(\$_ktype21, \$_vtype22, \$_size20);
-          for (my $_i24 = 0; $_i24 < $_size20; ++$_i24)
-          {
-            my $key25 = '';
-            my $val26 = [];
-            $xfer += $input->readString(\$key25);
-            {
-              my $_size27 = 0;
-              $val26 = {};
-              my $_etype30 = 0;
-              $xfer += $input->readSetBegin(\$_etype30, \$_size27);
-              for (my $_i31 = 0; $_i31 < $_size27; ++$_i31)
-              {
-                my $elem32 = undef;
-                $xfer += $input->readString(\$elem32);
-                $val26->{$elem32} = 1;
-              }
-              $xfer += $input->readSetEnd();
-            }
-            $self->{columnsToFetch}->{$key25} = $val26;
-          }
-          $xfer += $input->readMapEnd();
-        }
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^7$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{allowStaleData});
-      } 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('Selector');
-  if (defined $self->{recordOnly}) {
-    $xfer += $output->writeFieldBegin('recordOnly', TType::BOOL, 1);
-    $xfer += $output->writeBool($self->{recordOnly});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{locationId}) {
-    $xfer += $output->writeFieldBegin('locationId', TType::STRING, 2);
-    $xfer += $output->writeString($self->{locationId});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{rowId}) {
-    $xfer += $output->writeFieldBegin('rowId', TType::STRING, 3);
-    $xfer += $output->writeString($self->{rowId});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{recordId}) {
-    $xfer += $output->writeFieldBegin('recordId', TType::STRING, 4);
-    $xfer += $output->writeString($self->{recordId});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{columnFamiliesToFetch}) {
-    $xfer += $output->writeFieldBegin('columnFamiliesToFetch', TType::SET, 5);
-    {
-      $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{columnFamiliesToFetch}}));
-      {
-        foreach my $iter33 (@{$self->{columnFamiliesToFetch}})
-        {
-          $xfer += $output->writeString($iter33);
-        }
-      }
-      $xfer += $output->writeSetEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{columnsToFetch}) {
-    $xfer += $output->writeFieldBegin('columnsToFetch', TType::MAP, 6);
-    {
-      $xfer += $output->writeMapBegin(TType::STRING, TType::SET, scalar(keys %{$self->{columnsToFetch}}));
-      {
-        while( my ($kiter34,$viter35) = each %{$self->{columnsToFetch}}) 
-        {
-          $xfer += $output->writeString($kiter34);
-          {
-            $xfer += $output->writeSetBegin(TType::STRING, scalar(@{${viter35}}));
-            {
-              foreach my $iter36 (@{${viter35}})
-              {
-                $xfer += $output->writeString($iter36);
-              }
-            }
-            $xfer += $output->writeSetEnd();
-          }
-        }
-      }
-      $xfer += $output->writeMapEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{allowStaleData}) {
-    $xfer += $output->writeFieldBegin('allowStaleData', TType::BOOL, 7);
-    $xfer += $output->writeBool($self->{allowStaleData});
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
 package Blur::Facet;
 use base qw(Class::Accessor);
 Blur::Facet->mk_accessors( qw( queryStr minimumNumberOfBlurResults ) );
@@ -870,19 +649,19 @@ sub read {
     {
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size37 = 0;
+          my $_size14 = 0;
           $self->{cpuTimes} = {};
-          my $_ktype38 = 0;
-          my $_vtype39 = 0;
-          $xfer += $input->readMapBegin(\$_ktype38, \$_vtype39, \$_size37);
-          for (my $_i41 = 0; $_i41 < $_size37; ++$_i41)
+          my $_ktype15 = 0;
+          my $_vtype16 = 0;
+          $xfer += $input->readMapBegin(\$_ktype15, \$_vtype16, \$_size14);
+          for (my $_i18 = 0; $_i18 < $_size14; ++$_i18)
           {
-            my $key42 = '';
-            my $val43 = new Blur::CpuTime();
-            $xfer += $input->readString(\$key42);
-            $val43 = new Blur::CpuTime();
-            $xfer += $val43->read($input);
-            $self->{cpuTimes}->{$key42} = $val43;
+            my $key19 = '';
+            my $val20 = new Blur::CpuTime();
+            $xfer += $input->readString(\$key19);
+            $val20 = new Blur::CpuTime();
+            $xfer += $val20->read($input);
+            $self->{cpuTimes}->{$key19} = $val20;
           }
           $xfer += $input->readMapEnd();
         }
@@ -931,10 +710,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{cpuTimes}}));
       {
-        while( my ($kiter44,$viter45) = each %{$self->{cpuTimes}}) 
+        while( my ($kiter21,$viter22) = each %{$self->{cpuTimes}}) 
         {
-          $xfer += $output->writeString($kiter44);
-          $xfer += ${viter45}->write($output);
+          $xfer += $output->writeString($kiter21);
+          $xfer += ${viter22}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -1138,30 +917,30 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size46 = 0;
+          my $_size23 = 0;
           $self->{columnFamilies} = {};
-          my $_ktype47 = 0;
-          my $_vtype48 = 0;
-          $xfer += $input->readMapBegin(\$_ktype47, \$_vtype48, \$_size46);
-          for (my $_i50 = 0; $_i50 < $_size46; ++$_i50)
+          my $_ktype24 = 0;
+          my $_vtype25 = 0;
+          $xfer += $input->readMapBegin(\$_ktype24, \$_vtype25, \$_size23);
+          for (my $_i27 = 0; $_i27 < $_size23; ++$_i27)
           {
-            my $key51 = '';
-            my $val52 = [];
-            $xfer += $input->readString(\$key51);
+            my $key28 = '';
+            my $val29 = [];
+            $xfer += $input->readString(\$key28);
             {
-              my $_size53 = 0;
-              $val52 = {};
-              my $_etype56 = 0;
-              $xfer += $input->readSetBegin(\$_etype56, \$_size53);
-              for (my $_i57 = 0; $_i57 < $_size53; ++$_i57)
+              my $_size30 = 0;
+              $val29 = {};
+              my $_etype33 = 0;
+              $xfer += $input->readSetBegin(\$_etype33, \$_size30);
+              for (my $_i34 = 0; $_i34 < $_size30; ++$_i34)
               {
-                my $elem58 = undef;
-                $xfer += $input->readString(\$elem58);
-                $val52->{$elem58} = 1;
+                my $elem35 = undef;
+                $xfer += $input->readString(\$elem35);
+                $val29->{$elem35} = 1;
               }
               $xfer += $input->readSetEnd();
             }
-            $self->{columnFamilies}->{$key51} = $val52;
+            $self->{columnFamilies}->{$key28} = $val29;
           }
           $xfer += $input->readMapEnd();
         }
@@ -1191,15 +970,15 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::SET, scalar(keys %{$self->{columnFamilies}}));
       {
-        while( my ($kiter59,$viter60) = each %{$self->{columnFamilies}}) 
+        while( my ($kiter36,$viter37) = each %{$self->{columnFamilies}}) 
         {
-          $xfer += $output->writeString($kiter59);
+          $xfer += $output->writeString($kiter36);
           {
-            $xfer += $output->writeSetBegin(TType::STRING, scalar(@{${viter60}}));
+            $xfer += $output->writeSetBegin(TType::STRING, scalar(@{${viter37}}));
             {
-              foreach my $iter61 (@{${viter60}})
+              foreach my $iter38 (@{${viter37}})
               {
-                $xfer += $output->writeString($iter61);
+                $xfer += $output->writeString($iter38);
               }
             }
             $xfer += $output->writeSetEnd();
@@ -1337,19 +1116,19 @@ sub read {
       last; };
       /^3$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size62 = 0;
+          my $_size39 = 0;
           $self->{alternateColumnDefinitions} = {};
-          my $_ktype63 = 0;
-          my $_vtype64 = 0;
-          $xfer += $input->readMapBegin(\$_ktype63, \$_vtype64, \$_size62);
-          for (my $_i66 = 0; $_i66 < $_size62; ++$_i66)
+          my $_ktype40 = 0;
+          my $_vtype41 = 0;
+          $xfer += $input->readMapBegin(\$_ktype40, \$_vtype41, \$_size39);
+          for (my $_i43 = 0; $_i43 < $_size39; ++$_i43)
           {
-            my $key67 = '';
-            my $val68 = new Blur::AlternateColumnDefinition();
-            $xfer += $input->readString(\$key67);
-            $val68 = new Blur::AlternateColumnDefinition();
-            $xfer += $val68->read($input);
-            $self->{alternateColumnDefinitions}->{$key67} = $val68;
+            my $key44 = '';
+            my $val45 = new Blur::AlternateColumnDefinition();
+            $xfer += $input->readString(\$key44);
+            $val45 = new Blur::AlternateColumnDefinition();
+            $xfer += $val45->read($input);
+            $self->{alternateColumnDefinitions}->{$key44} = $val45;
           }
           $xfer += $input->readMapEnd();
         }
@@ -1384,10 +1163,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{alternateColumnDefinitions}}));
       {
-        while( my ($kiter69,$viter70) = each %{$self->{alternateColumnDefinitions}}) 
+        while( my ($kiter46,$viter47) = each %{$self->{alternateColumnDefinitions}}) 
         {
-          $xfer += $output->writeString($kiter69);
-          $xfer += ${viter70}->write($output);
+          $xfer += $output->writeString($kiter46);
+          $xfer += ${viter47}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -1448,19 +1227,19 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size71 = 0;
+          my $_size48 = 0;
           $self->{columnDefinitions} = {};
-          my $_ktype72 = 0;
-          my $_vtype73 = 0;
-          $xfer += $input->readMapBegin(\$_ktype72, \$_vtype73, \$_size71);
-          for (my $_i75 = 0; $_i75 < $_size71; ++$_i75)
+          my $_ktype49 = 0;
+          my $_vtype50 = 0;
+          $xfer += $input->readMapBegin(\$_ktype49, \$_vtype50, \$_size48);
+          for (my $_i52 = 0; $_i52 < $_size48; ++$_i52)
           {
-            my $key76 = '';
-            my $val77 = new Blur::ColumnDefinition();
-            $xfer += $input->readString(\$key76);
-            $val77 = new Blur::ColumnDefinition();
-            $xfer += $val77->read($input);
-            $self->{columnDefinitions}->{$key76} = $val77;
+            my $key53 = '';
+            my $val54 = new Blur::ColumnDefinition();
+            $xfer += $input->readString(\$key53);
+            $val54 = new Blur::ColumnDefinition();
+            $xfer += $val54->read($input);
+            $self->{columnDefinitions}->{$key53} = $val54;
           }
           $xfer += $input->readMapEnd();
         }
@@ -1490,10 +1269,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{columnDefinitions}}));
       {
-        while( my ($kiter78,$viter79) = each %{$self->{columnDefinitions}}) 
+        while( my ($kiter55,$viter56) = each %{$self->{columnDefinitions}}) 
         {
-          $xfer += $output->writeString($kiter78);
-          $xfer += ${viter79}->write($output);
+          $xfer += $output->writeString($kiter55);
+          $xfer += ${viter56}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -1564,19 +1343,19 @@ sub read {
       last; };
       /^3$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size80 = 0;
+          my $_size57 = 0;
           $self->{columnFamilyDefinitions} = {};
-          my $_ktype81 = 0;
-          my $_vtype82 = 0;
-          $xfer += $input->readMapBegin(\$_ktype81, \$_vtype82, \$_size80);
-          for (my $_i84 = 0; $_i84 < $_size80; ++$_i84)
+          my $_ktype58 = 0;
+          my $_vtype59 = 0;
+          $xfer += $input->readMapBegin(\$_ktype58, \$_vtype59, \$_size57);
+          for (my $_i61 = 0; $_i61 < $_size57; ++$_i61)
           {
-            my $key85 = '';
-            my $val86 = new Blur::ColumnFamilyDefinition();
-            $xfer += $input->readString(\$key85);
-            $val86 = new Blur::ColumnFamilyDefinition();
-            $xfer += $val86->read($input);
-            $self->{columnFamilyDefinitions}->{$key85} = $val86;
+            my $key62 = '';
+            my $val63 = new Blur::ColumnFamilyDefinition();
+            $xfer += $input->readString(\$key62);
+            $val63 = new Blur::ColumnFamilyDefinition();
+            $xfer += $val63->read($input);
+            $self->{columnFamilyDefinitions}->{$key62} = $val63;
           }
           $xfer += $input->readMapEnd();
         }
@@ -1611,10 +1390,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{columnFamilyDefinitions}}));
       {
-        while( my ($kiter87,$viter88) = each %{$self->{columnFamilyDefinitions}}) 
+        while( my ($kiter64,$viter65) = each %{$self->{columnFamilyDefinitions}}) 
         {
-          $xfer += $output->writeString($kiter87);
-          $xfer += ${viter88}->write($output);
+          $xfer += $output->writeString($kiter64);
+          $xfer += ${viter65}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -1664,15 +1443,15 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size89 = 0;
+          my $_size66 = 0;
           $self->{preCacheCols} = [];
-          my $_etype92 = 0;
-          $xfer += $input->readListBegin(\$_etype92, \$_size89);
-          for (my $_i93 = 0; $_i93 < $_size89; ++$_i93)
+          my $_etype69 = 0;
+          $xfer += $input->readListBegin(\$_etype69, \$_size66);
+          for (my $_i70 = 0; $_i70 < $_size66; ++$_i70)
           {
-            my $elem94 = undef;
-            $xfer += $input->readString(\$elem94);
-            push(@{$self->{preCacheCols}},$elem94);
+            my $elem71 = undef;
+            $xfer += $input->readString(\$elem71);
+            push(@{$self->{preCacheCols}},$elem71);
           }
           $xfer += $input->readListEnd();
         }
@@ -1697,9 +1476,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{preCacheCols}}));
       {
-        foreach my $iter95 (@{$self->{preCacheCols}}) 
+        foreach my $iter72 (@{$self->{preCacheCols}}) 
         {
-          $xfer += $output->writeString($iter95);
+          $xfer += $output->writeString($iter72);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1858,15 +1637,15 @@ sub read {
       last; };
       /^11$/ && do{      if ($ftype == TType::SET) {
         {
-          my $_size96 = 0;
+          my $_size73 = 0;
           $self->{blockCachingFileTypes} = {};
-          my $_etype99 = 0;
-          $xfer += $input->readSetBegin(\$_etype99, \$_size96);
-          for (my $_i100 = 0; $_i100 < $_size96; ++$_i100)
+          my $_etype76 = 0;
+          $xfer += $input->readSetBegin(\$_etype76, \$_size73);
+          for (my $_i77 = 0; $_i77 < $_size73; ++$_i77)
           {
-            my $elem101 = undef;
-            $xfer += $input->readString(\$elem101);
-            $self->{blockCachingFileTypes}->{$elem101} = 1;
+            my $elem78 = undef;
+            $xfer += $input->readString(\$elem78);
+            $self->{blockCachingFileTypes}->{$elem78} = 1;
           }
           $xfer += $input->readSetEnd();
         }
@@ -1954,9 +1733,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{blockCachingFileTypes}}));
       {
-        foreach my $iter102 (@{$self->{blockCachingFileTypes}})
+        foreach my $iter79 (@{$self->{blockCachingFileTypes}})
         {
-          $xfer += $output->writeString($iter102);
+          $xfer += $output->writeString($iter79);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -2120,18 +1899,18 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size103 = 0;
+          my $_size80 = 0;
           $self->{properties} = {};
-          my $_ktype104 = 0;
-          my $_vtype105 = 0;
-          $xfer += $input->readMapBegin(\$_ktype104, \$_vtype105, \$_size103);
-          for (my $_i107 = 0; $_i107 < $_size103; ++$_i107)
+          my $_ktype81 = 0;
+          my $_vtype82 = 0;
+          $xfer += $input->readMapBegin(\$_ktype81, \$_vtype82, \$_size80);
+          for (my $_i84 = 0; $_i84 < $_size80; ++$_i84)
           {
-            my $key108 = '';
-            my $val109 = '';
-            $xfer += $input->readString(\$key108);
-            $xfer += $input->readString(\$val109);
-            $self->{properties}->{$key108} = $val109;
+            my $key85 = '';
+            my $val86 = '';
+            $xfer += $input->readString(\$key85);
+            $xfer += $input->readString(\$val86);
+            $self->{properties}->{$key85} = $val86;
           }
           $xfer += $input->readMapEnd();
         }
@@ -2161,10 +1940,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{properties}}));
       {
-        while( my ($kiter110,$viter111) = each %{$self->{properties}}) 
+        while( my ($kiter87,$viter88) = each %{$self->{properties}}) 
         {
-          $xfer += $output->writeString($kiter110);
-          $xfer += $output->writeString($viter111);
+          $xfer += $output->writeString($kiter87);
+          $xfer += $output->writeString($viter88);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -2388,16 +2167,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size112 = 0;
+          my $_size89 = 0;
           $self->{fields} = [];
-          my $_etype115 = 0;
-          $xfer += $input->readListBegin(\$_etype115, \$_size112);
-          for (my $_i116 = 0; $_i116 < $_size112; ++$_i116)
+          my $_etype92 = 0;
+          $xfer += $input->readListBegin(\$_etype92, \$_size89);
+          for (my $_i93 = 0; $_i93 < $_size89; ++$_i93)
           {
-            my $elem117 = undef;
-            $elem117 = new Blur::SortField();
-            $xfer += $elem117->read($input);
-            push(@{$self->{fields}},$elem117);
+            my $elem94 = undef;
+            $elem94 = new Blur::SortField();
+            $xfer += $elem94->read($input);
+            push(@{$self->{fields}},$elem94);
           }
           $xfer += $input->readListEnd();
         }
@@ -2422,9 +2201,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{fields}}));
       {
-        foreach my $iter118 (@{$self->{fields}}) 
+        foreach my $iter95 (@{$self->{fields}}) 
         {
-          $xfer += ${iter118}->write($output);
+          $xfer += ${iter95}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2574,15 +2353,15 @@ sub read {
       last; };
       /^4$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size119 = 0;
+          my $_size96 = 0;
           $self->{fields} = [];
-          my $_etype122 = 0;
-          $xfer += $input->readListBegin(\$_etype122, \$_size119);
-          for (my $_i123 = 0; $_i123 < $_size119; ++$_i123)
+          my $_etype99 = 0;
+          $xfer += $input->readListBegin(\$_etype99, \$_size96);
+          for (my $_i100 = 0; $_i100 < $_size96; ++$_i100)
           {
-            my $elem124 = undef;
-            $xfer += $input->readString(\$elem124);
-            push(@{$self->{fields}},$elem124);
+            my $elem101 = undef;
+            $xfer += $input->readString(\$elem101);
+            push(@{$self->{fields}},$elem101);
           }
           $xfer += $input->readListEnd();
         }
@@ -2617,9 +2396,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{fields}}));
       {
-        foreach my $iter125 (@{$self->{fields}}) 
+        foreach my $iter102 (@{$self->{fields}}) 
         {
-          $xfer += $output->writeString($iter125);
+          $xfer += $output->writeString($iter102);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2741,15 +2520,15 @@ sub read {
       last; };
       /^8$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size126 = 0;
+          my $_size103 = 0;
           $self->{shardIndexes} = [];
-          my $_etype129 = 0;
-          $xfer += $input->readListBegin(\$_etype129, \$_size126);
-          for (my $_i130 = 0; $_i130 < $_size126; ++$_i130)
+          my $_etype106 = 0;
+          $xfer += $input->readListBegin(\$_etype106, \$_size103);
+          for (my $_i107 = 0; $_i107 < $_size103; ++$_i107)
           {
-            my $elem131 = undef;
-            $xfer += $input->readI32(\$elem131);
-            push(@{$self->{shardIndexes}},$elem131);
+            my $elem108 = undef;
+            $xfer += $input->readI32(\$elem108);
+            push(@{$self->{shardIndexes}},$elem108);
           }
           $xfer += $input->readListEnd();
         }
@@ -2809,9 +2588,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::I32, scalar(@{$self->{shardIndexes}}));
       {
-        foreach my $iter132 (@{$self->{shardIndexes}}) 
+        foreach my $iter109 (@{$self->{shardIndexes}}) 
         {
-          $xfer += $output->writeI32($iter132);
+          $xfer += $output->writeI32($iter109);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2889,16 +2668,16 @@ sub read {
       last; };
       /^3$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size133 = 0;
+          my $_size110 = 0;
           $self->{scoreDocs} = [];
-          my $_etype136 = 0;
-          $xfer += $input->readListBegin(\$_etype136, \$_size133);
-          for (my $_i137 = 0; $_i137 < $_size133; ++$_i137)
+          my $_etype113 = 0;
+          $xfer += $input->readListBegin(\$_etype113, \$_size110);
+          for (my $_i114 = 0; $_i114 < $_size110; ++$_i114)
           {
-            my $elem138 = undef;
-            $elem138 = new Blur::ScoreDoc();
-            $xfer += $elem138->read($input);
-            push(@{$self->{scoreDocs}},$elem138);
+            my $elem115 = undef;
+            $elem115 = new Blur::ScoreDoc();
+            $xfer += $elem115->read($input);
+            push(@{$self->{scoreDocs}},$elem115);
           }
           $xfer += $input->readListEnd();
         }
@@ -2914,16 +2693,16 @@ sub read {
       last; };
       /^5$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size139 = 0;
+          my $_size116 = 0;
           $self->{fields} = [];
-          my $_etype142 = 0;
-          $xfer += $input->readListBegin(\$_etype142, \$_size139);
-          for (my $_i143 = 0; $_i143 < $_size139; ++$_i143)
+          my $_etype119 = 0;
+          $xfer += $input->readListBegin(\$_etype119, \$_size116);
+          for (my $_i120 = 0; $_i120 < $_size116; ++$_i120)
           {
-            my $elem144 = undef;
-            $elem144 = new Blur::SortField();
-            $xfer += $elem144->read($input);
-            push(@{$self->{fields}},$elem144);
+            my $elem121 = undef;
+            $elem121 = new Blur::SortField();
+            $xfer += $elem121->read($input);
+            push(@{$self->{fields}},$elem121);
           }
           $xfer += $input->readListEnd();
         }
@@ -2958,9 +2737,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{scoreDocs}}));
       {
-        foreach my $iter145 (@{$self->{scoreDocs}}) 
+        foreach my $iter122 (@{$self->{scoreDocs}}) 
         {
-          $xfer += ${iter145}->write($output);
+          $xfer += ${iter122}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2977,9 +2756,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{fields}}));
       {
-        foreach my $iter146 (@{$self->{fields}}) 
+        foreach my $iter123 (@{$self->{fields}}) 
         {
-          $xfer += ${iter146}->write($output);
+          $xfer += ${iter123}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3138,16 +2917,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size147 = 0;
+          my $_size124 = 0;
           $self->{fields} = [];
-          my $_etype150 = 0;
-          $xfer += $input->readListBegin(\$_etype150, \$_size147);
-          for (my $_i151 = 0; $_i151 < $_size147; ++$_i151)
+          my $_etype127 = 0;
+          $xfer += $input->readListBegin(\$_etype127, \$_size124);
+          for (my $_i128 = 0; $_i128 < $_size124; ++$_i128)
           {
-            my $elem152 = undef;
-            $elem152 = new Blur::Field();
-            $xfer += $elem152->read($input);
-            push(@{$self->{fields}},$elem152);
+            my $elem129 = undef;
+            $elem129 = new Blur::Field();
+            $xfer += $elem129->read($input);
+            push(@{$self->{fields}},$elem129);
           }
           $xfer += $input->readListEnd();
         }
@@ -3172,9 +2951,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{fields}}));
       {
-        foreach my $iter153 (@{$self->{fields}}) 
+        foreach my $iter130 (@{$self->{fields}}) 
         {
-          $xfer += ${iter153}->write($output);
+          $xfer += ${iter130}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3423,16 +3202,16 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size154 = 0;
+          my $_size131 = 0;
           $self->{documents} = [];
-          my $_etype157 = 0;
-          $xfer += $input->readListBegin(\$_etype157, \$_size154);
-          for (my $_i158 = 0; $_i158 < $_size154; ++$_i158)
+          my $_etype134 = 0;
+          $xfer += $input->readListBegin(\$_etype134, \$_size131);
+          for (my $_i135 = 0; $_i135 < $_size131; ++$_i135)
           {
-            my $elem159 = undef;
-            $elem159 = new Blur::Document();
-            $xfer += $elem159->read($input);
-            push(@{$self->{documents}},$elem159);
+            my $elem136 = undef;
+            $elem136 = new Blur::Document();
+            $xfer += $elem136->read($input);
+            push(@{$self->{documents}},$elem136);
           }
           $xfer += $input->readListEnd();
         }
@@ -3462,9 +3241,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{documents}}));
       {
-        foreach my $iter160 (@{$self->{documents}}) 
+        foreach my $iter137 (@{$self->{documents}}) 
         {
-          $xfer += ${iter160}->write($output);
+          $xfer += ${iter137}->write($output);
         }
       }
       $xfer += $output->writeListEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/6577ca0c/interface/gen-rb/blur_types.rb
----------------------------------------------------------------------
diff --git a/interface/gen-rb/blur_types.rb b/interface/gen-rb/blur_types.rb
index fa4c694..2c0d5b0 100644
--- a/interface/gen-rb/blur_types.rb
+++ b/interface/gen-rb/blur_types.rb
@@ -185,42 +185,6 @@ module Blur
     ::Thrift::Struct.generate_accessors self
   end
 
-  # Select carries the request for information to be retrieved from the stored columns.
-  class Selector
-    include ::Thrift::Struct, ::Thrift::Struct_Union
-    RECORDONLY = 1
-    LOCATIONID = 2
-    ROWID = 3
-    RECORDID = 4
-    COLUMNFAMILIESTOFETCH = 5
-    COLUMNSTOFETCH = 6
-    ALLOWSTALEDATA = 7
-
-    FIELDS = {
-      # Fetch the Record only, not the entire Row.
-      RECORDONLY => {:type => ::Thrift::Types::BOOL, :name => 'recordOnly'},
-      # The location id of the Record or Row to be fetched.
-      LOCATIONID => {:type => ::Thrift::Types::STRING, :name => 'locationId'},
-      # The row id of the Row to be fetched, not to be used with location id.
-      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::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}}},
-      # @deprecated This value is no longer used.  This allows the fetch to see the most current data that has been added to the table.
-      ALLOWSTALEDATA => {:type => ::Thrift::Types::BOOL, :name => 'allowStaleData'}
-    }
-
-    def struct_fields; FIELDS; end
-
-    def validate
-    end
-
-    ::Thrift::Struct.generate_accessors self
-  end
-
   # Blur facet.
   class Facet
     include ::Thrift::Struct, ::Thrift::Struct_Union

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/6577ca0c/src/blur-core/src/main/java/org/apache/blur/manager/IndexManager.java
----------------------------------------------------------------------
diff --git a/src/blur-core/src/main/java/org/apache/blur/manager/IndexManager.java b/src/blur-core/src/main/java/org/apache/blur/manager/IndexManager.java
index 56446d9..4ac059b 100644
--- a/src/blur-core/src/main/java/org/apache/blur/manager/IndexManager.java
+++ b/src/blur-core/src/main/java/org/apache/blur/manager/IndexManager.java
@@ -16,8 +16,6 @@ package org.apache.blur.manager;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import static org.apache.blur.utils.BlurConstants.PRIME_DOC;
-import static org.apache.blur.utils.BlurConstants.RECORD_ID;
 import static org.apache.blur.utils.BlurConstants.ROW_ID;
 
 import java.io.IOException;
@@ -43,14 +41,11 @@ import org.apache.blur.thrift.BException;
 import org.apache.blur.thrift.generated.BlurException;
 import org.apache.blur.thrift.generated.Schema;
 import org.apache.blur.thrift.generated.ScoreType;
-import org.apache.blur.thrift.generated.Selector;
-import org.apache.blur.utils.BlurConstants;
 import org.apache.blur.utils.BlurExecutorCompletionService;
 import org.apache.blur.utils.BlurUtil;
 import org.apache.blur.utils.ForkJoin;
 import org.apache.blur.utils.ForkJoin.Merger;
 import org.apache.blur.utils.ForkJoin.ParallelCall;
-import org.apache.blur.utils.ResetableDocumentStoredFieldVisitor;
 import org.apache.hadoop.io.BytesWritable;
 import org.apache.lucene.index.AtomicReader;
 import org.apache.lucene.index.CorruptIndexException;
@@ -62,11 +57,7 @@ import org.apache.lucene.index.StoredFieldVisitor;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.Terms;
 import org.apache.lucene.index.TermsEnum;
-import org.apache.lucene.search.BooleanClause.Occur;
 import org.apache.lucene.search.BooleanQuery;
-import org.apache.lucene.search.IndexSearcher;
-import org.apache.lucene.search.TermQuery;
-import org.apache.lucene.search.TopDocs;
 import org.apache.lucene.util.BytesRef;
 
 public class IndexManager {
@@ -106,73 +97,6 @@ public class IndexManager {
     }
   }
 
-  private void populateSelector(String table, Selector selector) throws IOException, BlurException {
-    String rowId = selector.rowId;
-    String recordId = selector.recordId;
-    String shardName = null;// MutationHelper.getShardName(table, rowId,
-                            // getNumberOfShards(table), _blurPartitioner);
-    Map<String, BlurIndex> indexes = _indexServer.getIndexes(table);
-    BlurIndex blurIndex = indexes.get(shardName);
-    if (blurIndex == null) {
-      throw new BlurException("Shard [" + shardName + "] is not being servered by this shardserver.", null);
-    }
-    IndexReader reader = blurIndex.getIndexReader();
-    try {
-      IndexSearcher searcher = new IndexSearcher(reader);
-      BooleanQuery query = new BooleanQuery();
-      if (selector.recordOnly) {
-        query.add(new TermQuery(new Term(RECORD_ID, recordId)), Occur.MUST);
-        query.add(new TermQuery(new Term(ROW_ID, rowId)), Occur.MUST);
-      } else {
-        query.add(new TermQuery(new Term(ROW_ID, rowId)), Occur.MUST);
-        query.add(new TermQuery(BlurConstants.PRIME_DOC_TERM), Occur.MUST);
-      }
-      TopDocs topDocs = searcher.search(query, 1);
-      if (topDocs.totalHits > 1) {
-        if (selector.recordOnly) {
-          LOG.warn("Rowid [" + rowId + "], recordId [" + recordId + "] has more than one prime doc that is not deleted.");
-        } else {
-          LOG.warn("Rowid [" + rowId + "] has more than one prime doc that is not deleted.");
-        }
-      }
-      if (topDocs.totalHits == 1) {
-        selector.setLocationId(shardName + "/" + topDocs.scoreDocs[0].doc);
-      } else {
-        selector.setLocationId(NOT_FOUND);
-      }
-    } finally {
-      // this will allow for closing of index
-      reader.decRef();
-    }
-  }
-
-  public static void validSelector(Selector selector) throws BlurException {
-    String locationId = selector.locationId;
-    String rowId = selector.rowId;
-    String recordId = selector.recordId;
-    boolean recordOnly = selector.recordOnly;
-
-    if (locationId != null) {
-      if (recordId != null && rowId != null) {
-        throw new BlurException("Invalid selector locationId [" + locationId + "] and recordId [" + recordId + "] and rowId [" + rowId
-            + "] are set, if using locationId, then rowId and recordId are not needed.", null);
-      } else if (recordId != null) {
-        throw new BlurException("Invalid selector locationId [" + locationId + "] and recordId [" + recordId + "] sre set, if using locationId recordId is not needed.", null);
-      } else if (rowId != null) {
-        throw new BlurException("Invalid selector locationId [" + locationId + "] and rowId [" + rowId + "] are set, if using locationId rowId is not needed.", null);
-      }
-    } else {
-      if (rowId != null && recordId != null) {
-        if (!recordOnly) {
-          throw new BlurException("Invalid both rowid [" + rowId + "] and recordId [" + recordId + "] are set, and recordOnly is set to [false].  "
-              + "If you want entire row, then remove recordId, if you want record only set recordOnly to [true].", null);
-        }
-      } else if (recordId != null) {
-        throw new BlurException("Invalid recordId [" + recordId + "] is set but rowId is not set.  If rowId is not known then a query will be required.", null);
-      }
-    }
-  }
-
   /**
    * Location id format is <shard>/luceneid.
    * 
@@ -216,41 +140,6 @@ public class IndexManager {
     return fieldName.substring(0, fieldName.lastIndexOf('.'));
   }
 
-  public static ResetableDocumentStoredFieldVisitor getFieldSelector(final Selector selector) {
-    return new ResetableDocumentStoredFieldVisitor() {
-      @Override
-      public Status needsField(FieldInfo fieldInfo) throws IOException {
-        if (ROW_ID.equals(fieldInfo.name)) {
-          return StoredFieldVisitor.Status.YES;
-        }
-        if (RECORD_ID.equals(fieldInfo.name)) {
-          return StoredFieldVisitor.Status.YES;
-        }
-        if (PRIME_DOC.equals(fieldInfo.name)) {
-          return StoredFieldVisitor.Status.NO;
-        }
-        if (selector.columnFamiliesToFetch == null && selector.columnsToFetch == null) {
-          return StoredFieldVisitor.Status.YES;
-        }
-        String columnFamily = getColumnFamily(fieldInfo.name);
-        if (selector.columnFamiliesToFetch != null) {
-          if (selector.columnFamiliesToFetch.contains(columnFamily)) {
-            return StoredFieldVisitor.Status.YES;
-          }
-        }
-        String columnName = getColumnName(fieldInfo.name);
-        if (selector.columnsToFetch != null) {
-          Set<String> columns = selector.columnsToFetch.get(columnFamily);
-          if (columns != null && columns.contains(columnName)) {
-            return StoredFieldVisitor.Status.YES;
-          }
-        }
-        return StoredFieldVisitor.Status.NO;
-      }
-
-    };
-  }
-
   public IndexServer getIndexServer() {
     return _indexServer;
   }

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/6577ca0c/src/blur-core/src/main/java/org/apache/blur/utils/BlurUtil.java
----------------------------------------------------------------------
diff --git a/src/blur-core/src/main/java/org/apache/blur/utils/BlurUtil.java b/src/blur-core/src/main/java/org/apache/blur/utils/BlurUtil.java
index 3fe4f70..d15f56a 100644
--- a/src/blur-core/src/main/java/org/apache/blur/utils/BlurUtil.java
+++ b/src/blur-core/src/main/java/org/apache/blur/utils/BlurUtil.java
@@ -46,7 +46,6 @@ import org.apache.blur.thrift.generated.Blur.Iface;
 import org.apache.blur.thrift.generated.Column;
 import org.apache.blur.thrift.generated.Record;
 import org.apache.blur.thrift.generated.Row;
-import org.apache.blur.thrift.generated.Selector;
 import org.apache.hadoop.conf.Configurable;
 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.fs.FileStatus;
@@ -177,12 +176,6 @@ public class BlurUtil {
     }
   }
 
-  public static Selector newSelector(String locationId) {
-    Selector selector = new Selector();
-    selector.locationId = locationId;
-    return selector;
-  }
-
   public static boolean match(Record left, Record right) {
     return left.recordId.equals(right.recordId) && left.family.equals(right.family);
   }

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/6577ca0c/src/blur-thrift/src/main/java/org/apache/blur/thrift/generated/AnalyzerDefinition.java
----------------------------------------------------------------------
diff --git a/src/blur-thrift/src/main/java/org/apache/blur/thrift/generated/AnalyzerDefinition.java b/src/blur-thrift/src/main/java/org/apache/blur/thrift/generated/AnalyzerDefinition.java
index 9739ad4..b416b43 100644
--- a/src/blur-thrift/src/main/java/org/apache/blur/thrift/generated/AnalyzerDefinition.java
+++ b/src/blur-thrift/src/main/java/org/apache/blur/thrift/generated/AnalyzerDefinition.java
@@ -579,16 +579,16 @@ public class AnalyzerDefinition implements org.apache.thrift.TBase<AnalyzerDefin
           case 3: // COLUMN_FAMILY_DEFINITIONS
             if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
               {
-                org.apache.thrift.protocol.TMap _map90 = iprot.readMapBegin();
-                struct.columnFamilyDefinitions = new HashMap<String,ColumnFamilyDefinition>(2*_map90.size);
-                for (int _i91 = 0; _i91 < _map90.size; ++_i91)
+                org.apache.thrift.protocol.TMap _map64 = iprot.readMapBegin();
+                struct.columnFamilyDefinitions = new HashMap<String,ColumnFamilyDefinition>(2*_map64.size);
+                for (int _i65 = 0; _i65 < _map64.size; ++_i65)
                 {
-                  String _key92; // required
-                  ColumnFamilyDefinition _val93; // optional
-                  _key92 = iprot.readString();
-                  _val93 = new ColumnFamilyDefinition();
-                  _val93.read(iprot);
-                  struct.columnFamilyDefinitions.put(_key92, _val93);
+                  String _key66; // required
+                  ColumnFamilyDefinition _val67; // optional
+                  _key66 = iprot.readString();
+                  _val67 = new ColumnFamilyDefinition();
+                  _val67.read(iprot);
+                  struct.columnFamilyDefinitions.put(_key66, _val67);
                 }
                 iprot.readMapEnd();
               }
@@ -626,10 +626,10 @@ public class AnalyzerDefinition implements org.apache.thrift.TBase<AnalyzerDefin
         oprot.writeFieldBegin(COLUMN_FAMILY_DEFINITIONS_FIELD_DESC);
         {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.columnFamilyDefinitions.size()));
-          for (Map.Entry<String, ColumnFamilyDefinition> _iter94 : struct.columnFamilyDefinitions.entrySet())
+          for (Map.Entry<String, ColumnFamilyDefinition> _iter68 : struct.columnFamilyDefinitions.entrySet())
           {
-            oprot.writeString(_iter94.getKey());
-            _iter94.getValue().write(oprot);
+            oprot.writeString(_iter68.getKey());
+            _iter68.getValue().write(oprot);
           }
           oprot.writeMapEnd();
         }
@@ -672,10 +672,10 @@ public class AnalyzerDefinition implements org.apache.thrift.TBase<AnalyzerDefin
       if (struct.isSetColumnFamilyDefinitions()) {
         {
           oprot.writeI32(struct.columnFamilyDefinitions.size());
-          for (Map.Entry<String, ColumnFamilyDefinition> _iter95 : struct.columnFamilyDefinitions.entrySet())
+          for (Map.Entry<String, ColumnFamilyDefinition> _iter69 : struct.columnFamilyDefinitions.entrySet())
           {
-            oprot.writeString(_iter95.getKey());
-            _iter95.getValue().write(oprot);
+            oprot.writeString(_iter69.getKey());
+            _iter69.getValue().write(oprot);
           }
         }
       }
@@ -696,16 +696,16 @@ public class AnalyzerDefinition implements org.apache.thrift.TBase<AnalyzerDefin
       }
       if (incoming.get(2)) {
         {
-          org.apache.thrift.protocol.TMap _map96 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-          struct.columnFamilyDefinitions = new HashMap<String,ColumnFamilyDefinition>(2*_map96.size);
-          for (int _i97 = 0; _i97 < _map96.size; ++_i97)
+          org.apache.thrift.protocol.TMap _map70 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.columnFamilyDefinitions = new HashMap<String,ColumnFamilyDefinition>(2*_map70.size);
+          for (int _i71 = 0; _i71 < _map70.size; ++_i71)
           {
-            String _key98; // required
-            ColumnFamilyDefinition _val99; // optional
-            _key98 = iprot.readString();
-            _val99 = new ColumnFamilyDefinition();
-            _val99.read(iprot);
-            struct.columnFamilyDefinitions.put(_key98, _val99);
+            String _key72; // required
+            ColumnFamilyDefinition _val73; // optional
+            _key72 = iprot.readString();
+            _val73 = new ColumnFamilyDefinition();
+            _val73.read(iprot);
+            struct.columnFamilyDefinitions.put(_key72, _val73);
           }
         }
         struct.setColumnFamilyDefinitionsIsSet(true);


Mime
View raw message