incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [22/27] Final changes to get the project running again with types. All unit tests pass but I still need to add external type additions and cluster lock on adding fields via ZooKeeper so that read write contention against HDFS is lowered during high fiel
Date Fri, 09 Aug 2013 17:24:27 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/2378815f/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 225d00e..d14caa4 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
@@ -100,15 +100,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size183 = 0;
+          my $_size192 = 0;
           $self->{success} = [];
-          my $_etype186 = 0;
-          $xfer += $input->readListBegin(\$_etype186, \$_size183);
-          for (my $_i187 = 0; $_i187 < $_size183; ++$_i187)
+          my $_etype195 = 0;
+          $xfer += $input->readListBegin(\$_etype195, \$_size192);
+          for (my $_i196 = 0; $_i196 < $_size192; ++$_i196)
           {
-            my $elem188 = undef;
-            $xfer += $input->readString(\$elem188);
-            push(@{$self->{success}},$elem188);
+            my $elem197 = undef;
+            $xfer += $input->readString(\$elem197);
+            push(@{$self->{success}},$elem197);
           }
           $xfer += $input->readListEnd();
         }
@@ -140,9 +140,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter189 (@{$self->{success}}) 
+        foreach my $iter198 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter189);
+          $xfer += $output->writeString($iter198);
         }
       }
       $xfer += $output->writeListEnd();
@@ -265,15 +265,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size190 = 0;
+          my $_size199 = 0;
           $self->{success} = [];
-          my $_etype193 = 0;
-          $xfer += $input->readListBegin(\$_etype193, \$_size190);
-          for (my $_i194 = 0; $_i194 < $_size190; ++$_i194)
+          my $_etype202 = 0;
+          $xfer += $input->readListBegin(\$_etype202, \$_size199);
+          for (my $_i203 = 0; $_i203 < $_size199; ++$_i203)
           {
-            my $elem195 = undef;
-            $xfer += $input->readString(\$elem195);
-            push(@{$self->{success}},$elem195);
+            my $elem204 = undef;
+            $xfer += $input->readString(\$elem204);
+            push(@{$self->{success}},$elem204);
           }
           $xfer += $input->readListEnd();
         }
@@ -305,9 +305,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter196 (@{$self->{success}}) 
+        foreach my $iter205 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter196);
+          $xfer += $output->writeString($iter205);
         }
       }
       $xfer += $output->writeListEnd();
@@ -412,15 +412,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size197 = 0;
+          my $_size206 = 0;
           $self->{success} = [];
-          my $_etype200 = 0;
-          $xfer += $input->readListBegin(\$_etype200, \$_size197);
-          for (my $_i201 = 0; $_i201 < $_size197; ++$_i201)
+          my $_etype209 = 0;
+          $xfer += $input->readListBegin(\$_etype209, \$_size206);
+          for (my $_i210 = 0; $_i210 < $_size206; ++$_i210)
           {
-            my $elem202 = undef;
-            $xfer += $input->readString(\$elem202);
-            push(@{$self->{success}},$elem202);
+            my $elem211 = undef;
+            $xfer += $input->readString(\$elem211);
+            push(@{$self->{success}},$elem211);
           }
           $xfer += $input->readListEnd();
         }
@@ -452,9 +452,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter203 (@{$self->{success}}) 
+        foreach my $iter212 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter203);
+          $xfer += $output->writeString($iter212);
         }
       }
       $xfer += $output->writeListEnd();
@@ -577,18 +577,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size204 = 0;
+          my $_size213 = 0;
           $self->{success} = {};
-          my $_ktype205 = 0;
-          my $_vtype206 = 0;
-          $xfer += $input->readMapBegin(\$_ktype205, \$_vtype206, \$_size204);
-          for (my $_i208 = 0; $_i208 < $_size204; ++$_i208)
+          my $_ktype214 = 0;
+          my $_vtype215 = 0;
+          $xfer += $input->readMapBegin(\$_ktype214, \$_vtype215, \$_size213);
+          for (my $_i217 = 0; $_i217 < $_size213; ++$_i217)
           {
-            my $key209 = '';
-            my $val210 = '';
-            $xfer += $input->readString(\$key209);
-            $xfer += $input->readString(\$val210);
-            $self->{success}->{$key209} = $val210;
+            my $key218 = '';
+            my $val219 = '';
+            $xfer += $input->readString(\$key218);
+            $xfer += $input->readString(\$val219);
+            $self->{success}->{$key218} = $val219;
           }
           $xfer += $input->readMapEnd();
         }
@@ -620,10 +620,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter211,$viter212) = each %{$self->{success}}) 
+        while( my ($kiter220,$viter221) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter211);
-          $xfer += $output->writeString($viter212);
+          $xfer += $output->writeString($kiter220);
+          $xfer += $output->writeString($viter221);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -746,33 +746,33 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size213 = 0;
+          my $_size222 = 0;
           $self->{success} = {};
-          my $_ktype214 = 0;
-          my $_vtype215 = 0;
-          $xfer += $input->readMapBegin(\$_ktype214, \$_vtype215, \$_size213);
-          for (my $_i217 = 0; $_i217 < $_size213; ++$_i217)
+          my $_ktype223 = 0;
+          my $_vtype224 = 0;
+          $xfer += $input->readMapBegin(\$_ktype223, \$_vtype224, \$_size222);
+          for (my $_i226 = 0; $_i226 < $_size222; ++$_i226)
           {
-            my $key218 = '';
-            my $val219 = [];
-            $xfer += $input->readString(\$key218);
+            my $key227 = '';
+            my $val228 = [];
+            $xfer += $input->readString(\$key227);
             {
-              my $_size220 = 0;
-              $val219 = {};
-              my $_ktype221 = 0;
-              my $_vtype222 = 0;
-              $xfer += $input->readMapBegin(\$_ktype221, \$_vtype222, \$_size220);
-              for (my $_i224 = 0; $_i224 < $_size220; ++$_i224)
+              my $_size229 = 0;
+              $val228 = {};
+              my $_ktype230 = 0;
+              my $_vtype231 = 0;
+              $xfer += $input->readMapBegin(\$_ktype230, \$_vtype231, \$_size229);
+              for (my $_i233 = 0; $_i233 < $_size229; ++$_i233)
               {
-                my $key225 = '';
-                my $val226 = 0;
-                $xfer += $input->readString(\$key225);
-                $xfer += $input->readI32(\$val226);
-                $val219->{$key225} = $val226;
+                my $key234 = '';
+                my $val235 = 0;
+                $xfer += $input->readString(\$key234);
+                $xfer += $input->readI32(\$val235);
+                $val228->{$key234} = $val235;
               }
               $xfer += $input->readMapEnd();
             }
-            $self->{success}->{$key218} = $val219;
+            $self->{success}->{$key227} = $val228;
           }
           $xfer += $input->readMapEnd();
         }
@@ -804,16 +804,16 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::MAP, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter227,$viter228) = each %{$self->{success}}) 
+        while( my ($kiter236,$viter237) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter227);
+          $xfer += $output->writeString($kiter236);
           {
-            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter228}}));
+            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter237}}));
             {
-              while( my ($kiter229,$viter230) = each %{${viter228}}) 
+              while( my ($kiter238,$viter239) = each %{${viter237}}) 
               {
-                $xfer += $output->writeString($kiter229);
-                $xfer += $output->writeI32($viter230);
+                $xfer += $output->writeString($kiter238);
+                $xfer += $output->writeI32($viter239);
               }
             }
             $xfer += $output->writeMapEnd();
@@ -922,15 +922,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size231 = 0;
+          my $_size240 = 0;
           $self->{success} = [];
-          my $_etype234 = 0;
-          $xfer += $input->readListBegin(\$_etype234, \$_size231);
-          for (my $_i235 = 0; $_i235 < $_size231; ++$_i235)
+          my $_etype243 = 0;
+          $xfer += $input->readListBegin(\$_etype243, \$_size240);
+          for (my $_i244 = 0; $_i244 < $_size240; ++$_i244)
           {
-            my $elem236 = undef;
-            $xfer += $input->readString(\$elem236);
-            push(@{$self->{success}},$elem236);
+            my $elem245 = undef;
+            $xfer += $input->readString(\$elem245);
+            push(@{$self->{success}},$elem245);
           }
           $xfer += $input->readListEnd();
         }
@@ -962,9 +962,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter237 (@{$self->{success}}) 
+        foreach my $iter246 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter237);
+          $xfer += $output->writeString($iter246);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1087,15 +1087,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size238 = 0;
+          my $_size247 = 0;
           $self->{success} = [];
-          my $_etype241 = 0;
-          $xfer += $input->readListBegin(\$_etype241, \$_size238);
-          for (my $_i242 = 0; $_i242 < $_size238; ++$_i242)
+          my $_etype250 = 0;
+          $xfer += $input->readListBegin(\$_etype250, \$_size247);
+          for (my $_i251 = 0; $_i251 < $_size247; ++$_i251)
           {
-            my $elem243 = undef;
-            $xfer += $input->readString(\$elem243);
-            push(@{$self->{success}},$elem243);
+            my $elem252 = undef;
+            $xfer += $input->readString(\$elem252);
+            push(@{$self->{success}},$elem252);
           }
           $xfer += $input->readListEnd();
         }
@@ -1127,9 +1127,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter244 (@{$self->{success}}) 
+        foreach my $iter253 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter244);
+          $xfer += $output->writeString($iter253);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1862,16 +1862,16 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size245 = 0;
+          my $_size254 = 0;
           $self->{success} = [];
-          my $_etype248 = 0;
-          $xfer += $input->readListBegin(\$_etype248, \$_size245);
-          for (my $_i249 = 0; $_i249 < $_size245; ++$_i249)
+          my $_etype257 = 0;
+          $xfer += $input->readListBegin(\$_etype257, \$_size254);
+          for (my $_i258 = 0; $_i258 < $_size254; ++$_i258)
           {
-            my $elem250 = undef;
-            $elem250 = new Blur::BlurQueryStatus();
-            $xfer += $elem250->read($input);
-            push(@{$self->{success}},$elem250);
+            my $elem259 = undef;
+            $elem259 = new Blur::BlurQueryStatus();
+            $xfer += $elem259->read($input);
+            push(@{$self->{success}},$elem259);
           }
           $xfer += $input->readListEnd();
         }
@@ -1903,9 +1903,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
       {
-        foreach my $iter251 (@{$self->{success}}) 
+        foreach my $iter260 (@{$self->{success}}) 
         {
-          $xfer += ${iter251}->write($output);
+          $xfer += ${iter260}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2028,15 +2028,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size252 = 0;
+          my $_size261 = 0;
           $self->{success} = [];
-          my $_etype255 = 0;
-          $xfer += $input->readListBegin(\$_etype255, \$_size252);
-          for (my $_i256 = 0; $_i256 < $_size252; ++$_i256)
+          my $_etype264 = 0;
+          $xfer += $input->readListBegin(\$_etype264, \$_size261);
+          for (my $_i265 = 0; $_i265 < $_size261; ++$_i265)
           {
-            my $elem257 = undef;
-            $xfer += $input->readI64(\$elem257);
-            push(@{$self->{success}},$elem257);
+            my $elem266 = undef;
+            $xfer += $input->readI64(\$elem266);
+            push(@{$self->{success}},$elem266);
           }
           $xfer += $input->readListEnd();
         }
@@ -2068,9 +2068,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{success}}));
       {
-        foreach my $iter258 (@{$self->{success}}) 
+        foreach my $iter267 (@{$self->{success}}) 
         {
-          $xfer += $output->writeI64($iter258);
+          $xfer += $output->writeI64($iter267);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2848,15 +2848,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size259 = 0;
+          my $_size268 = 0;
           $self->{success} = [];
-          my $_etype262 = 0;
-          $xfer += $input->readListBegin(\$_etype262, \$_size259);
-          for (my $_i263 = 0; $_i263 < $_size259; ++$_i263)
+          my $_etype271 = 0;
+          $xfer += $input->readListBegin(\$_etype271, \$_size268);
+          for (my $_i272 = 0; $_i272 < $_size268; ++$_i272)
           {
-            my $elem264 = undef;
-            $xfer += $input->readString(\$elem264);
-            push(@{$self->{success}},$elem264);
+            my $elem273 = undef;
+            $xfer += $input->readString(\$elem273);
+            push(@{$self->{success}},$elem273);
           }
           $xfer += $input->readListEnd();
         }
@@ -2888,9 +2888,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter265 (@{$self->{success}}) 
+        foreach my $iter274 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter265);
+          $xfer += $output->writeString($iter274);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3425,16 +3425,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size266 = 0;
+          my $_size275 = 0;
           $self->{mutations} = [];
-          my $_etype269 = 0;
-          $xfer += $input->readListBegin(\$_etype269, \$_size266);
-          for (my $_i270 = 0; $_i270 < $_size266; ++$_i270)
+          my $_etype278 = 0;
+          $xfer += $input->readListBegin(\$_etype278, \$_size275);
+          for (my $_i279 = 0; $_i279 < $_size275; ++$_i279)
           {
-            my $elem271 = undef;
-            $elem271 = new Blur::RowMutation();
-            $xfer += $elem271->read($input);
-            push(@{$self->{mutations}},$elem271);
+            my $elem280 = undef;
+            $elem280 = new Blur::RowMutation();
+            $xfer += $elem280->read($input);
+            push(@{$self->{mutations}},$elem280);
           }
           $xfer += $input->readListEnd();
         }
@@ -3459,9 +3459,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{mutations}}));
       {
-        foreach my $iter272 (@{$self->{mutations}}) 
+        foreach my $iter281 (@{$self->{mutations}}) 
         {
-          $xfer += ${iter272}->write($output);
+          $xfer += ${iter281}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4446,18 +4446,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size273 = 0;
+          my $_size282 = 0;
           $self->{success} = {};
-          my $_ktype274 = 0;
-          my $_vtype275 = 0;
-          $xfer += $input->readMapBegin(\$_ktype274, \$_vtype275, \$_size273);
-          for (my $_i277 = 0; $_i277 < $_size273; ++$_i277)
+          my $_ktype283 = 0;
+          my $_vtype284 = 0;
+          $xfer += $input->readMapBegin(\$_ktype283, \$_vtype284, \$_size282);
+          for (my $_i286 = 0; $_i286 < $_size282; ++$_i286)
           {
-            my $key278 = '';
-            my $val279 = '';
-            $xfer += $input->readString(\$key278);
-            $xfer += $input->readString(\$val279);
-            $self->{success}->{$key278} = $val279;
+            my $key287 = '';
+            my $val288 = '';
+            $xfer += $input->readString(\$key287);
+            $xfer += $input->readString(\$val288);
+            $self->{success}->{$key287} = $val288;
           }
           $xfer += $input->readMapEnd();
         }
@@ -4489,10 +4489,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter280,$viter281) = each %{$self->{success}}) 
+        while( my ($kiter289,$viter290) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter280);
-          $xfer += $output->writeString($viter281);
+          $xfer += $output->writeString($kiter289);
+          $xfer += $output->writeString($viter290);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -4547,15 +4547,15 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::SET) {
         {
-          my $_size282 = 0;
+          my $_size291 = 0;
           $self->{metrics} = {};
-          my $_etype285 = 0;
-          $xfer += $input->readSetBegin(\$_etype285, \$_size282);
-          for (my $_i286 = 0; $_i286 < $_size282; ++$_i286)
+          my $_etype294 = 0;
+          $xfer += $input->readSetBegin(\$_etype294, \$_size291);
+          for (my $_i295 = 0; $_i295 < $_size291; ++$_i295)
           {
-            my $elem287 = undef;
-            $xfer += $input->readString(\$elem287);
-            $self->{metrics}->{$elem287} = 1;
+            my $elem296 = undef;
+            $xfer += $input->readString(\$elem296);
+            $self->{metrics}->{$elem296} = 1;
           }
           $xfer += $input->readSetEnd();
         }
@@ -4580,9 +4580,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{metrics}}));
       {
-        foreach my $iter288 (@{$self->{metrics}})
+        foreach my $iter297 (@{$self->{metrics}})
         {
-          $xfer += $output->writeString($iter288);
+          $xfer += $output->writeString($iter297);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -4636,19 +4636,19 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size289 = 0;
+          my $_size298 = 0;
           $self->{success} = {};
-          my $_ktype290 = 0;
-          my $_vtype291 = 0;
-          $xfer += $input->readMapBegin(\$_ktype290, \$_vtype291, \$_size289);
-          for (my $_i293 = 0; $_i293 < $_size289; ++$_i293)
+          my $_ktype299 = 0;
+          my $_vtype300 = 0;
+          $xfer += $input->readMapBegin(\$_ktype299, \$_vtype300, \$_size298);
+          for (my $_i302 = 0; $_i302 < $_size298; ++$_i302)
           {
-            my $key294 = '';
-            my $val295 = new Blur::Metric();
-            $xfer += $input->readString(\$key294);
-            $val295 = new Blur::Metric();
-            $xfer += $val295->read($input);
-            $self->{success}->{$key294} = $val295;
+            my $key303 = '';
+            my $val304 = new Blur::Metric();
+            $xfer += $input->readString(\$key303);
+            $val304 = new Blur::Metric();
+            $xfer += $val304->read($input);
+            $self->{success}->{$key303} = $val304;
           }
           $xfer += $input->readMapEnd();
         }
@@ -4680,10 +4680,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter296,$viter297) = each %{$self->{success}}) 
+        while( my ($kiter305,$viter306) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter296);
-          $xfer += ${viter297}->write($output);
+          $xfer += $output->writeString($kiter305);
+          $xfer += ${viter306}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/2378815f/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 c70cd43..82653fb 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
@@ -3235,7 +3235,7 @@ sub write {
 
 package Blur::TableDescriptor;
 use base qw(Class::Accessor);
-Blur::TableDescriptor->mk_accessors( qw( isEnabled shardCount tableUri cluster name similarityClass
blockCaching blockCachingFileTypes readOnly columnPreCache tableProperties ) );
+Blur::TableDescriptor->mk_accessors( qw( isEnabled shardCount tableUri cluster name similarityClass
blockCaching blockCachingFileTypes readOnly columnPreCache tableProperties strictTypes defaultMissingFieldType
defaultMissingFieldLessIndexing defaultMissingFieldProps ) );
 
 sub new {
   my $classname = shift;
@@ -3252,6 +3252,10 @@ sub new {
   $self->{readOnly} = 0;
   $self->{columnPreCache} = undef;
   $self->{tableProperties} = undef;
+  $self->{strictTypes} = 0;
+  $self->{defaultMissingFieldType} = "text";
+  $self->{defaultMissingFieldLessIndexing} = 1;
+  $self->{defaultMissingFieldProps} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{isEnabled}) {
       $self->{isEnabled} = $vals->{isEnabled};
@@ -3286,6 +3290,18 @@ sub new {
     if (defined $vals->{tableProperties}) {
       $self->{tableProperties} = $vals->{tableProperties};
     }
+    if (defined $vals->{strictTypes}) {
+      $self->{strictTypes} = $vals->{strictTypes};
+    }
+    if (defined $vals->{defaultMissingFieldType}) {
+      $self->{defaultMissingFieldType} = $vals->{defaultMissingFieldType};
+    }
+    if (defined $vals->{defaultMissingFieldLessIndexing}) {
+      $self->{defaultMissingFieldLessIndexing} = $vals->{defaultMissingFieldLessIndexing};
+    }
+    if (defined $vals->{defaultMissingFieldProps}) {
+      $self->{defaultMissingFieldProps} = $vals->{defaultMissingFieldProps};
+    }
   }
   return bless ($self, $classname);
 }
@@ -3403,6 +3419,45 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
+      /^15$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{strictTypes});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^16$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{defaultMissingFieldType});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^17$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{defaultMissingFieldLessIndexing});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^18$/ && do{      if ($ftype == TType::MAP) {
+        {
+          my $_size153 = 0;
+          $self->{defaultMissingFieldProps} = {};
+          my $_ktype154 = 0;
+          my $_vtype155 = 0;
+          $xfer += $input->readMapBegin(\$_ktype154, \$_vtype155, \$_size153);
+          for (my $_i157 = 0; $_i157 < $_size153; ++$_i157)
+          {
+            my $key158 = '';
+            my $val159 = '';
+            $xfer += $input->readString(\$key158);
+            $xfer += $input->readString(\$val159);
+            $self->{defaultMissingFieldProps}->{$key158} = $val159;
+          }
+          $xfer += $input->readMapEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -3455,9 +3510,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{blockCachingFileTypes}}));
       {
-        foreach my $iter153 (@{$self->{blockCachingFileTypes}})
+        foreach my $iter160 (@{$self->{blockCachingFileTypes}})
         {
-          $xfer += $output->writeString($iter153);
+          $xfer += $output->writeString($iter160);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -3479,10 +3534,40 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{tableProperties}}));
       {
-        while( my ($kiter154,$viter155) = each %{$self->{tableProperties}}) 
+        while( my ($kiter161,$viter162) = each %{$self->{tableProperties}}) 
+        {
+          $xfer += $output->writeString($kiter161);
+          $xfer += $output->writeString($viter162);
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{strictTypes}) {
+    $xfer += $output->writeFieldBegin('strictTypes', TType::BOOL, 15);
+    $xfer += $output->writeBool($self->{strictTypes});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{defaultMissingFieldType}) {
+    $xfer += $output->writeFieldBegin('defaultMissingFieldType', TType::STRING, 16);
+    $xfer += $output->writeString($self->{defaultMissingFieldType});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{defaultMissingFieldLessIndexing}) {
+    $xfer += $output->writeFieldBegin('defaultMissingFieldLessIndexing', TType::BOOL,
17);
+    $xfer += $output->writeBool($self->{defaultMissingFieldLessIndexing});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{defaultMissingFieldProps}) {
+    $xfer += $output->writeFieldBegin('defaultMissingFieldProps', TType::MAP, 18);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{defaultMissingFieldProps}}));
+      {
+        while( my ($kiter163,$viter164) = each %{$self->{defaultMissingFieldProps}}) 
         {
-          $xfer += $output->writeString($kiter154);
-          $xfer += $output->writeString($viter155);
+          $xfer += $output->writeString($kiter163);
+          $xfer += $output->writeString($viter164);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3550,18 +3635,18 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size156 = 0;
+          my $_size165 = 0;
           $self->{strMap} = {};
-          my $_ktype157 = 0;
-          my $_vtype158 = 0;
-          $xfer += $input->readMapBegin(\$_ktype157, \$_vtype158, \$_size156);
-          for (my $_i160 = 0; $_i160 < $_size156; ++$_i160)
+          my $_ktype166 = 0;
+          my $_vtype167 = 0;
+          $xfer += $input->readMapBegin(\$_ktype166, \$_vtype167, \$_size165);
+          for (my $_i169 = 0; $_i169 < $_size165; ++$_i169)
           {
-            my $key161 = '';
-            my $val162 = '';
-            $xfer += $input->readString(\$key161);
-            $xfer += $input->readString(\$val162);
-            $self->{strMap}->{$key161} = $val162;
+            my $key170 = '';
+            my $val171 = '';
+            $xfer += $input->readString(\$key170);
+            $xfer += $input->readString(\$val171);
+            $self->{strMap}->{$key170} = $val171;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3571,18 +3656,18 @@ sub read {
       last; };
       /^3$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size163 = 0;
+          my $_size172 = 0;
           $self->{longMap} = {};
-          my $_ktype164 = 0;
-          my $_vtype165 = 0;
-          $xfer += $input->readMapBegin(\$_ktype164, \$_vtype165, \$_size163);
-          for (my $_i167 = 0; $_i167 < $_size163; ++$_i167)
+          my $_ktype173 = 0;
+          my $_vtype174 = 0;
+          $xfer += $input->readMapBegin(\$_ktype173, \$_vtype174, \$_size172);
+          for (my $_i176 = 0; $_i176 < $_size172; ++$_i176)
           {
-            my $key168 = '';
-            my $val169 = 0;
-            $xfer += $input->readString(\$key168);
-            $xfer += $input->readI64(\$val169);
-            $self->{longMap}->{$key168} = $val169;
+            my $key177 = '';
+            my $val178 = 0;
+            $xfer += $input->readString(\$key177);
+            $xfer += $input->readI64(\$val178);
+            $self->{longMap}->{$key177} = $val178;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3592,18 +3677,18 @@ sub read {
       last; };
       /^4$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size170 = 0;
+          my $_size179 = 0;
           $self->{doubleMap} = {};
-          my $_ktype171 = 0;
-          my $_vtype172 = 0;
-          $xfer += $input->readMapBegin(\$_ktype171, \$_vtype172, \$_size170);
-          for (my $_i174 = 0; $_i174 < $_size170; ++$_i174)
+          my $_ktype180 = 0;
+          my $_vtype181 = 0;
+          $xfer += $input->readMapBegin(\$_ktype180, \$_vtype181, \$_size179);
+          for (my $_i183 = 0; $_i183 < $_size179; ++$_i183)
           {
-            my $key175 = '';
-            my $val176 = 0.0;
-            $xfer += $input->readString(\$key175);
-            $xfer += $input->readDouble(\$val176);
-            $self->{doubleMap}->{$key175} = $val176;
+            my $key184 = '';
+            my $val185 = 0.0;
+            $xfer += $input->readString(\$key184);
+            $xfer += $input->readDouble(\$val185);
+            $self->{doubleMap}->{$key184} = $val185;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3633,10 +3718,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{strMap}}));
       {
-        while( my ($kiter177,$viter178) = each %{$self->{strMap}}) 
+        while( my ($kiter186,$viter187) = each %{$self->{strMap}}) 
         {
-          $xfer += $output->writeString($kiter177);
-          $xfer += $output->writeString($viter178);
+          $xfer += $output->writeString($kiter186);
+          $xfer += $output->writeString($viter187);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3648,10 +3733,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::I64, scalar(keys %{$self->{longMap}}));
       {
-        while( my ($kiter179,$viter180) = each %{$self->{longMap}}) 
+        while( my ($kiter188,$viter189) = each %{$self->{longMap}}) 
         {
-          $xfer += $output->writeString($kiter179);
-          $xfer += $output->writeI64($viter180);
+          $xfer += $output->writeString($kiter188);
+          $xfer += $output->writeI64($viter189);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3663,10 +3748,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::DOUBLE, scalar(keys %{$self->{doubleMap}}));
       {
-        while( my ($kiter181,$viter182) = each %{$self->{doubleMap}}) 
+        while( my ($kiter190,$viter191) = each %{$self->{doubleMap}}) 
         {
-          $xfer += $output->writeString($kiter181);
-          $xfer += $output->writeDouble($viter182);
+          $xfer += $output->writeString($kiter190);
+          $xfer += $output->writeDouble($viter191);
         }
       }
       $xfer += $output->writeMapEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/2378815f/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 17ec707..92e7f29 100644
--- a/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
+++ b/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
@@ -800,6 +800,10 @@ module Blur
     READONLY = 12
     COLUMNPRECACHE = 13
     TABLEPROPERTIES = 14
+    STRICTTYPES = 15
+    DEFAULTMISSINGFIELDTYPE = 16
+    DEFAULTMISSINGFIELDLESSINDEXING = 17
+    DEFAULTMISSINGFIELDPROPS = 18
 
     FIELDS = {
       # Is the table enabled or not, enabled by default.
@@ -823,7 +827,16 @@ module Blur
       READONLY => {:type => ::Thrift::Types::BOOL, :name => 'readOnly', :default
=> false},
       # Sets what column families and columns to prefetch into block cache on shard open.
       COLUMNPRECACHE => {:type => ::Thrift::Types::STRUCT, :name => 'columnPreCache',
:class => ::Blur::ColumnPreCache},
-      TABLEPROPERTIES => {:type => ::Thrift::Types::MAP, :name => 'tableProperties',
:key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}}
+      # The table properties that can modify the default behavior of the table.  TODO: Document
all options.
+      TABLEPROPERTIES => {:type => ::Thrift::Types::MAP, :name => 'tableProperties',
:key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}},
+      # Whether strict types are enabled or not (default).  If they are enabled no column
can be added without first having it's type defined.
+      STRICTTYPES => {:type => ::Thrift::Types::BOOL, :name => 'strictTypes', :default
=> false},
+      # If strict is not enabled, the default field type.
+      DEFAULTMISSINGFIELDTYPE => {:type => ::Thrift::Types::STRING, :name => 'defaultMissingFieldType',
:default => %q"text"},
+      # If strict is not enabled, defines whether or not field less indexing is enabled on
the newly created fields.
+      DEFAULTMISSINGFIELDLESSINDEXING => {:type => ::Thrift::Types::BOOL, :name =>
'defaultMissingFieldLessIndexing', :default => true},
+      # If strict is not enabled, defines the properties to be used in the new field creation.
+      DEFAULTMISSINGFIELDPROPS => {:type => ::Thrift::Types::MAP, :name => 'defaultMissingFieldProps',
:key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}}
     }
 
     def struct_fields; FIELDS; end


Mime
View raw message