incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [02/12] Adding the column definition method to Thrift and the Shell.
Date Mon, 12 Aug 2013 15:14:17 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/d0b113eb/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 d14caa4..68e686f 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 $_size192 = 0;
+          my $_size174 = 0;
           $self->{success} = [];
-          my $_etype195 = 0;
-          $xfer += $input->readListBegin(\$_etype195, \$_size192);
-          for (my $_i196 = 0; $_i196 < $_size192; ++$_i196)
+          my $_etype177 = 0;
+          $xfer += $input->readListBegin(\$_etype177, \$_size174);
+          for (my $_i178 = 0; $_i178 < $_size174; ++$_i178)
           {
-            my $elem197 = undef;
-            $xfer += $input->readString(\$elem197);
-            push(@{$self->{success}},$elem197);
+            my $elem179 = undef;
+            $xfer += $input->readString(\$elem179);
+            push(@{$self->{success}},$elem179);
           }
           $xfer += $input->readListEnd();
         }
@@ -140,9 +140,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter198 (@{$self->{success}}) 
+        foreach my $iter180 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter198);
+          $xfer += $output->writeString($iter180);
         }
       }
       $xfer += $output->writeListEnd();
@@ -265,15 +265,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size199 = 0;
+          my $_size181 = 0;
           $self->{success} = [];
-          my $_etype202 = 0;
-          $xfer += $input->readListBegin(\$_etype202, \$_size199);
-          for (my $_i203 = 0; $_i203 < $_size199; ++$_i203)
+          my $_etype184 = 0;
+          $xfer += $input->readListBegin(\$_etype184, \$_size181);
+          for (my $_i185 = 0; $_i185 < $_size181; ++$_i185)
           {
-            my $elem204 = undef;
-            $xfer += $input->readString(\$elem204);
-            push(@{$self->{success}},$elem204);
+            my $elem186 = undef;
+            $xfer += $input->readString(\$elem186);
+            push(@{$self->{success}},$elem186);
           }
           $xfer += $input->readListEnd();
         }
@@ -305,9 +305,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter205 (@{$self->{success}}) 
+        foreach my $iter187 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter205);
+          $xfer += $output->writeString($iter187);
         }
       }
       $xfer += $output->writeListEnd();
@@ -412,15 +412,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size206 = 0;
+          my $_size188 = 0;
           $self->{success} = [];
-          my $_etype209 = 0;
-          $xfer += $input->readListBegin(\$_etype209, \$_size206);
-          for (my $_i210 = 0; $_i210 < $_size206; ++$_i210)
+          my $_etype191 = 0;
+          $xfer += $input->readListBegin(\$_etype191, \$_size188);
+          for (my $_i192 = 0; $_i192 < $_size188; ++$_i192)
           {
-            my $elem211 = undef;
-            $xfer += $input->readString(\$elem211);
-            push(@{$self->{success}},$elem211);
+            my $elem193 = undef;
+            $xfer += $input->readString(\$elem193);
+            push(@{$self->{success}},$elem193);
           }
           $xfer += $input->readListEnd();
         }
@@ -452,9 +452,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter212 (@{$self->{success}}) 
+        foreach my $iter194 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter212);
+          $xfer += $output->writeString($iter194);
         }
       }
       $xfer += $output->writeListEnd();
@@ -577,18 +577,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size213 = 0;
+          my $_size195 = 0;
           $self->{success} = {};
-          my $_ktype214 = 0;
-          my $_vtype215 = 0;
-          $xfer += $input->readMapBegin(\$_ktype214, \$_vtype215, \$_size213);
-          for (my $_i217 = 0; $_i217 < $_size213; ++$_i217)
+          my $_ktype196 = 0;
+          my $_vtype197 = 0;
+          $xfer += $input->readMapBegin(\$_ktype196, \$_vtype197, \$_size195);
+          for (my $_i199 = 0; $_i199 < $_size195; ++$_i199)
           {
-            my $key218 = '';
-            my $val219 = '';
-            $xfer += $input->readString(\$key218);
-            $xfer += $input->readString(\$val219);
-            $self->{success}->{$key218} = $val219;
+            my $key200 = '';
+            my $val201 = '';
+            $xfer += $input->readString(\$key200);
+            $xfer += $input->readString(\$val201);
+            $self->{success}->{$key200} = $val201;
           }
           $xfer += $input->readMapEnd();
         }
@@ -620,10 +620,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter220,$viter221) = each %{$self->{success}}) 
+        while( my ($kiter202,$viter203) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter220);
-          $xfer += $output->writeString($viter221);
+          $xfer += $output->writeString($kiter202);
+          $xfer += $output->writeString($viter203);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -746,33 +746,33 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size222 = 0;
+          my $_size204 = 0;
           $self->{success} = {};
-          my $_ktype223 = 0;
-          my $_vtype224 = 0;
-          $xfer += $input->readMapBegin(\$_ktype223, \$_vtype224, \$_size222);
-          for (my $_i226 = 0; $_i226 < $_size222; ++$_i226)
+          my $_ktype205 = 0;
+          my $_vtype206 = 0;
+          $xfer += $input->readMapBegin(\$_ktype205, \$_vtype206, \$_size204);
+          for (my $_i208 = 0; $_i208 < $_size204; ++$_i208)
           {
-            my $key227 = '';
-            my $val228 = [];
-            $xfer += $input->readString(\$key227);
+            my $key209 = '';
+            my $val210 = [];
+            $xfer += $input->readString(\$key209);
             {
-              my $_size229 = 0;
-              $val228 = {};
-              my $_ktype230 = 0;
-              my $_vtype231 = 0;
-              $xfer += $input->readMapBegin(\$_ktype230, \$_vtype231, \$_size229);
-              for (my $_i233 = 0; $_i233 < $_size229; ++$_i233)
+              my $_size211 = 0;
+              $val210 = {};
+              my $_ktype212 = 0;
+              my $_vtype213 = 0;
+              $xfer += $input->readMapBegin(\$_ktype212, \$_vtype213, \$_size211);
+              for (my $_i215 = 0; $_i215 < $_size211; ++$_i215)
               {
-                my $key234 = '';
-                my $val235 = 0;
-                $xfer += $input->readString(\$key234);
-                $xfer += $input->readI32(\$val235);
-                $val228->{$key234} = $val235;
+                my $key216 = '';
+                my $val217 = 0;
+                $xfer += $input->readString(\$key216);
+                $xfer += $input->readI32(\$val217);
+                $val210->{$key216} = $val217;
               }
               $xfer += $input->readMapEnd();
             }
-            $self->{success}->{$key227} = $val228;
+            $self->{success}->{$key209} = $val210;
           }
           $xfer += $input->readMapEnd();
         }
@@ -804,16 +804,16 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::MAP, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter236,$viter237) = each %{$self->{success}}) 
+        while( my ($kiter218,$viter219) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter236);
+          $xfer += $output->writeString($kiter218);
           {
-            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter237}}));
+            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter219}}));
             {
-              while( my ($kiter238,$viter239) = each %{${viter237}}) 
+              while( my ($kiter220,$viter221) = each %{${viter219}}) 
               {
-                $xfer += $output->writeString($kiter238);
-                $xfer += $output->writeI32($viter239);
+                $xfer += $output->writeString($kiter220);
+                $xfer += $output->writeI32($viter221);
               }
             }
             $xfer += $output->writeMapEnd();
@@ -922,15 +922,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size240 = 0;
+          my $_size222 = 0;
           $self->{success} = [];
-          my $_etype243 = 0;
-          $xfer += $input->readListBegin(\$_etype243, \$_size240);
-          for (my $_i244 = 0; $_i244 < $_size240; ++$_i244)
+          my $_etype225 = 0;
+          $xfer += $input->readListBegin(\$_etype225, \$_size222);
+          for (my $_i226 = 0; $_i226 < $_size222; ++$_i226)
           {
-            my $elem245 = undef;
-            $xfer += $input->readString(\$elem245);
-            push(@{$self->{success}},$elem245);
+            my $elem227 = undef;
+            $xfer += $input->readString(\$elem227);
+            push(@{$self->{success}},$elem227);
           }
           $xfer += $input->readListEnd();
         }
@@ -962,9 +962,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter246 (@{$self->{success}}) 
+        foreach my $iter228 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter246);
+          $xfer += $output->writeString($iter228);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1087,15 +1087,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size247 = 0;
+          my $_size229 = 0;
           $self->{success} = [];
-          my $_etype250 = 0;
-          $xfer += $input->readListBegin(\$_etype250, \$_size247);
-          for (my $_i251 = 0; $_i251 < $_size247; ++$_i251)
+          my $_etype232 = 0;
+          $xfer += $input->readListBegin(\$_etype232, \$_size229);
+          for (my $_i233 = 0; $_i233 < $_size229; ++$_i233)
           {
-            my $elem252 = undef;
-            $xfer += $input->readString(\$elem252);
-            push(@{$self->{success}},$elem252);
+            my $elem234 = undef;
+            $xfer += $input->readString(\$elem234);
+            push(@{$self->{success}},$elem234);
           }
           $xfer += $input->readListEnd();
         }
@@ -1127,9 +1127,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter253 (@{$self->{success}}) 
+        foreach my $iter235 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter253);
+          $xfer += $output->writeString($iter235);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1862,16 +1862,16 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size254 = 0;
+          my $_size236 = 0;
           $self->{success} = [];
-          my $_etype257 = 0;
-          $xfer += $input->readListBegin(\$_etype257, \$_size254);
-          for (my $_i258 = 0; $_i258 < $_size254; ++$_i258)
+          my $_etype239 = 0;
+          $xfer += $input->readListBegin(\$_etype239, \$_size236);
+          for (my $_i240 = 0; $_i240 < $_size236; ++$_i240)
           {
-            my $elem259 = undef;
-            $elem259 = new Blur::BlurQueryStatus();
-            $xfer += $elem259->read($input);
-            push(@{$self->{success}},$elem259);
+            my $elem241 = undef;
+            $elem241 = new Blur::BlurQueryStatus();
+            $xfer += $elem241->read($input);
+            push(@{$self->{success}},$elem241);
           }
           $xfer += $input->readListEnd();
         }
@@ -1903,9 +1903,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
       {
-        foreach my $iter260 (@{$self->{success}}) 
+        foreach my $iter242 (@{$self->{success}}) 
         {
-          $xfer += ${iter260}->write($output);
+          $xfer += ${iter242}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2028,15 +2028,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size261 = 0;
+          my $_size243 = 0;
           $self->{success} = [];
-          my $_etype264 = 0;
-          $xfer += $input->readListBegin(\$_etype264, \$_size261);
-          for (my $_i265 = 0; $_i265 < $_size261; ++$_i265)
+          my $_etype246 = 0;
+          $xfer += $input->readListBegin(\$_etype246, \$_size243);
+          for (my $_i247 = 0; $_i247 < $_size243; ++$_i247)
           {
-            my $elem266 = undef;
-            $xfer += $input->readI64(\$elem266);
-            push(@{$self->{success}},$elem266);
+            my $elem248 = undef;
+            $xfer += $input->readI64(\$elem248);
+            push(@{$self->{success}},$elem248);
           }
           $xfer += $input->readListEnd();
         }
@@ -2068,9 +2068,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{success}}));
       {
-        foreach my $iter267 (@{$self->{success}}) 
+        foreach my $iter249 (@{$self->{success}}) 
         {
-          $xfer += $output->writeI64($iter267);
+          $xfer += $output->writeI64($iter249);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2848,15 +2848,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size268 = 0;
+          my $_size250 = 0;
           $self->{success} = [];
-          my $_etype271 = 0;
-          $xfer += $input->readListBegin(\$_etype271, \$_size268);
-          for (my $_i272 = 0; $_i272 < $_size268; ++$_i272)
+          my $_etype253 = 0;
+          $xfer += $input->readListBegin(\$_etype253, \$_size250);
+          for (my $_i254 = 0; $_i254 < $_size250; ++$_i254)
           {
-            my $elem273 = undef;
-            $xfer += $input->readString(\$elem273);
-            push(@{$self->{success}},$elem273);
+            my $elem255 = undef;
+            $xfer += $input->readString(\$elem255);
+            push(@{$self->{success}},$elem255);
           }
           $xfer += $input->readListEnd();
         }
@@ -2888,9 +2888,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter274 (@{$self->{success}}) 
+        foreach my $iter256 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter274);
+          $xfer += $output->writeString($iter256);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3425,16 +3425,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size275 = 0;
+          my $_size257 = 0;
           $self->{mutations} = [];
-          my $_etype278 = 0;
-          $xfer += $input->readListBegin(\$_etype278, \$_size275);
-          for (my $_i279 = 0; $_i279 < $_size275; ++$_i279)
+          my $_etype260 = 0;
+          $xfer += $input->readListBegin(\$_etype260, \$_size257);
+          for (my $_i261 = 0; $_i261 < $_size257; ++$_i261)
           {
-            my $elem280 = undef;
-            $elem280 = new Blur::RowMutation();
-            $xfer += $elem280->read($input);
-            push(@{$self->{mutations}},$elem280);
+            my $elem262 = undef;
+            $elem262 = new Blur::RowMutation();
+            $xfer += $elem262->read($input);
+            push(@{$self->{mutations}},$elem262);
           }
           $xfer += $input->readListEnd();
         }
@@ -3459,9 +3459,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{mutations}}));
       {
-        foreach my $iter281 (@{$self->{mutations}}) 
+        foreach my $iter263 (@{$self->{mutations}}) 
         {
-          $xfer += ${iter281}->write($output);
+          $xfer += ${iter263}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4070,6 +4070,166 @@ sub write {
   return $xfer;
 }
 
+package Blur::Blur_addColumnDefinition_args;
+use base qw(Class::Accessor);
+Blur::Blur_addColumnDefinition_args->mk_accessors( qw( table columnDefinition ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{table} = undef;
+  $self->{columnDefinition} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
+    }
+    if (defined $vals->{columnDefinition}) {
+      $self->{columnDefinition} = $vals->{columnDefinition};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_addColumnDefinition_args';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{table});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{columnDefinition} = new Blur::ColumnDefinition();
+        $xfer += $self->{columnDefinition}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_addColumnDefinition_args');
+  if (defined $self->{table}) {
+    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+    $xfer += $output->writeString($self->{table});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{columnDefinition}) {
+    $xfer += $output->writeFieldBegin('columnDefinition', TType::STRUCT, 2);
+    $xfer += $self->{columnDefinition}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_addColumnDefinition_result;
+use base qw(Class::Accessor);
+Blur::Blur_addColumnDefinition_result->mk_accessors( qw( success ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{success} = undef;
+  $self->{ex} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{success}) {
+      $self->{success} = $vals->{success};
+    }
+    if (defined $vals->{ex}) {
+      $self->{ex} = $vals->{ex};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_addColumnDefinition_result';
+}
+
+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)
+    {
+      /^0$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{success});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{ex} = new Blur::BlurException();
+        $xfer += $self->{ex}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_addColumnDefinition_result');
+  if (defined $self->{success}) {
+    $xfer += $output->writeFieldBegin('success', TType::BOOL, 0);
+    $xfer += $output->writeBool($self->{success});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{ex}) {
+    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+    $xfer += $self->{ex}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
 package Blur::Blur_optimize_args;
 use base qw(Class::Accessor);
 Blur::Blur_optimize_args->mk_accessors( qw( table numberOfSegmentsPerShard ) );
@@ -4446,18 +4606,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size282 = 0;
+          my $_size264 = 0;
           $self->{success} = {};
-          my $_ktype283 = 0;
-          my $_vtype284 = 0;
-          $xfer += $input->readMapBegin(\$_ktype283, \$_vtype284, \$_size282);
-          for (my $_i286 = 0; $_i286 < $_size282; ++$_i286)
+          my $_ktype265 = 0;
+          my $_vtype266 = 0;
+          $xfer += $input->readMapBegin(\$_ktype265, \$_vtype266, \$_size264);
+          for (my $_i268 = 0; $_i268 < $_size264; ++$_i268)
           {
-            my $key287 = '';
-            my $val288 = '';
-            $xfer += $input->readString(\$key287);
-            $xfer += $input->readString(\$val288);
-            $self->{success}->{$key287} = $val288;
+            my $key269 = '';
+            my $val270 = '';
+            $xfer += $input->readString(\$key269);
+            $xfer += $input->readString(\$val270);
+            $self->{success}->{$key269} = $val270;
           }
           $xfer += $input->readMapEnd();
         }
@@ -4489,10 +4649,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter289,$viter290) = each %{$self->{success}}) 
+        while( my ($kiter271,$viter272) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter289);
-          $xfer += $output->writeString($viter290);
+          $xfer += $output->writeString($kiter271);
+          $xfer += $output->writeString($viter272);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -4547,15 +4707,15 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::SET) {
         {
-          my $_size291 = 0;
+          my $_size273 = 0;
           $self->{metrics} = {};
-          my $_etype294 = 0;
-          $xfer += $input->readSetBegin(\$_etype294, \$_size291);
-          for (my $_i295 = 0; $_i295 < $_size291; ++$_i295)
+          my $_etype276 = 0;
+          $xfer += $input->readSetBegin(\$_etype276, \$_size273);
+          for (my $_i277 = 0; $_i277 < $_size273; ++$_i277)
           {
-            my $elem296 = undef;
-            $xfer += $input->readString(\$elem296);
-            $self->{metrics}->{$elem296} = 1;
+            my $elem278 = undef;
+            $xfer += $input->readString(\$elem278);
+            $self->{metrics}->{$elem278} = 1;
           }
           $xfer += $input->readSetEnd();
         }
@@ -4580,9 +4740,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{metrics}}));
       {
-        foreach my $iter297 (@{$self->{metrics}})
+        foreach my $iter279 (@{$self->{metrics}})
         {
-          $xfer += $output->writeString($iter297);
+          $xfer += $output->writeString($iter279);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -4636,19 +4796,19 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size298 = 0;
+          my $_size280 = 0;
           $self->{success} = {};
-          my $_ktype299 = 0;
-          my $_vtype300 = 0;
-          $xfer += $input->readMapBegin(\$_ktype299, \$_vtype300, \$_size298);
-          for (my $_i302 = 0; $_i302 < $_size298; ++$_i302)
+          my $_ktype281 = 0;
+          my $_vtype282 = 0;
+          $xfer += $input->readMapBegin(\$_ktype281, \$_vtype282, \$_size280);
+          for (my $_i284 = 0; $_i284 < $_size280; ++$_i284)
           {
-            my $key303 = '';
-            my $val304 = new Blur::Metric();
-            $xfer += $input->readString(\$key303);
-            $val304 = new Blur::Metric();
-            $xfer += $val304->read($input);
-            $self->{success}->{$key303} = $val304;
+            my $key285 = '';
+            my $val286 = new Blur::Metric();
+            $xfer += $input->readString(\$key285);
+            $val286 = new Blur::Metric();
+            $xfer += $val286->read($input);
+            $self->{success}->{$key285} = $val286;
           }
           $xfer += $input->readMapEnd();
         }
@@ -4680,10 +4840,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter305,$viter306) = each %{$self->{success}}) 
+        while( my ($kiter287,$viter288) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter305);
-          $xfer += ${viter306}->write($output);
+          $xfer += $output->writeString($kiter287);
+          $xfer += ${viter288}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -4897,6 +5057,14 @@ sub removeTable{
   die 'implement interface';
 }
 
+sub addColumnDefinition{
+  my $self = shift;
+  my $table = shift;
+  my $columnDefinition = shift;
+
+  die 'implement interface';
+}
+
 sub optimize{
   my $self = shift;
   my $table = shift;
@@ -5129,6 +5297,14 @@ sub removeTable{
   return $self->{impl}->removeTable($table, $deleteIndexFiles);
 }
 
+sub addColumnDefinition{
+  my ($self, $request) = @_;
+
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  my $columnDefinition = ($request->{'columnDefinition'}) ? $request->{'columnDefinition'} : undef;
+  return $self->{impl}->addColumnDefinition($table, $columnDefinition);
+}
+
 sub optimize{
   my ($self, $request) = @_;
 
@@ -6375,6 +6551,55 @@ sub recv_removeTable{
   }
   return;
 }
+sub addColumnDefinition{
+  my $self = shift;
+  my $table = shift;
+  my $columnDefinition = shift;
+
+    $self->send_addColumnDefinition($table, $columnDefinition);
+  return $self->recv_addColumnDefinition();
+}
+
+sub send_addColumnDefinition{
+  my $self = shift;
+  my $table = shift;
+  my $columnDefinition = shift;
+
+  $self->{output}->writeMessageBegin('addColumnDefinition', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_addColumnDefinition_args();
+  $args->{table} = $table;
+  $args->{columnDefinition} = $columnDefinition;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_addColumnDefinition{
+  my $self = shift;
+
+  my $rseqid = 0;
+  my $fname;
+  my $mtype = 0;
+
+  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
+  if ($mtype == TMessageType::EXCEPTION) {
+    my $x = new TApplicationException();
+    $x->read($self->{input});
+    $self->{input}->readMessageEnd();
+    die $x;
+  }
+  my $result = new Blur::Blur_addColumnDefinition_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{success} ) {
+    return $result->{success};
+  }
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  die "addColumnDefinition failed: unknown result";
+}
 sub optimize{
   my $self = shift;
   my $table = shift;
@@ -7032,6 +7257,23 @@ sub process_removeTable {
     $output->getTransport()->flush();
 }
 
+sub process_addColumnDefinition {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_addColumnDefinition_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_addColumnDefinition_result();
+    eval {
+      $result->{success} = $self->{handler}->addColumnDefinition($args->table, $args->columnDefinition);
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('addColumnDefinition', TMessageType::REPLY, $seqid);
+    $result->write($output);
+    $output->writeMessageEnd();
+    $output->getTransport()->flush();
+}
+
 sub process_optimize {
     my ($self, $seqid, $input, $output) = @_;
     my $args = new Blur::Blur_optimize_args();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/d0b113eb/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 82653fb..4bb3c39 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
@@ -2737,417 +2737,6 @@ sub write {
   return $xfer;
 }
 
-package Blur::AlternateColumnDefinition;
-use base qw(Class::Accessor);
-Blur::AlternateColumnDefinition->mk_accessors( qw( analyzerClassName ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{analyzerClassName} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{analyzerClassName}) {
-      $self->{analyzerClassName} = $vals->{analyzerClassName};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'AlternateColumnDefinition';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{analyzerClassName});
-      } 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('AlternateColumnDefinition');
-  if (defined $self->{analyzerClassName}) {
-    $xfer += $output->writeFieldBegin('analyzerClassName', TType::STRING, 1);
-    $xfer += $output->writeString($self->{analyzerClassName});
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::ColumnDefinition;
-use base qw(Class::Accessor);
-Blur::ColumnDefinition->mk_accessors( qw( analyzerClassName fullTextIndex alternateColumnDefinitions ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{analyzerClassName} = "org.apache.blur.analysis.NoStopWordStandardAnalyzer";
-  $self->{fullTextIndex} = undef;
-  $self->{alternateColumnDefinitions} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{analyzerClassName}) {
-      $self->{analyzerClassName} = $vals->{analyzerClassName};
-    }
-    if (defined $vals->{fullTextIndex}) {
-      $self->{fullTextIndex} = $vals->{fullTextIndex};
-    }
-    if (defined $vals->{alternateColumnDefinitions}) {
-      $self->{alternateColumnDefinitions} = $vals->{alternateColumnDefinitions};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'ColumnDefinition';
-}
-
-sub read {
-  my ($self, $input) = @_;
-  my $xfer  = 0;
-  my $fname;
-  my $ftype = 0;
-  my $fid   = 0;
-  $xfer += $input->readStructBegin(\$fname);
-  while (1) 
-  {
-    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
-    if ($ftype == TType::STOP) {
-      last;
-    }
-    SWITCH: for($fid)
-    {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{analyzerClassName});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{fullTextIndex});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^3$/ && do{      if ($ftype == TType::MAP) {
-        {
-          my $_size106 = 0;
-          $self->{alternateColumnDefinitions} = {};
-          my $_ktype107 = 0;
-          my $_vtype108 = 0;
-          $xfer += $input->readMapBegin(\$_ktype107, \$_vtype108, \$_size106);
-          for (my $_i110 = 0; $_i110 < $_size106; ++$_i110)
-          {
-            my $key111 = '';
-            my $val112 = new Blur::AlternateColumnDefinition();
-            $xfer += $input->readString(\$key111);
-            $val112 = new Blur::AlternateColumnDefinition();
-            $xfer += $val112->read($input);
-            $self->{alternateColumnDefinitions}->{$key111} = $val112;
-          }
-          $xfer += $input->readMapEnd();
-        }
-      } 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('ColumnDefinition');
-  if (defined $self->{analyzerClassName}) {
-    $xfer += $output->writeFieldBegin('analyzerClassName', TType::STRING, 1);
-    $xfer += $output->writeString($self->{analyzerClassName});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{fullTextIndex}) {
-    $xfer += $output->writeFieldBegin('fullTextIndex', TType::BOOL, 2);
-    $xfer += $output->writeBool($self->{fullTextIndex});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{alternateColumnDefinitions}) {
-    $xfer += $output->writeFieldBegin('alternateColumnDefinitions', TType::MAP, 3);
-    {
-      $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{alternateColumnDefinitions}}));
-      {
-        while( my ($kiter113,$viter114) = each %{$self->{alternateColumnDefinitions}}) 
-        {
-          $xfer += $output->writeString($kiter113);
-          $xfer += ${viter114}->write($output);
-        }
-      }
-      $xfer += $output->writeMapEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::ColumnFamilyDefinition;
-use base qw(Class::Accessor);
-Blur::ColumnFamilyDefinition->mk_accessors( qw( defaultDefinition columnDefinitions ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{defaultDefinition} = undef;
-  $self->{columnDefinitions} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{defaultDefinition}) {
-      $self->{defaultDefinition} = $vals->{defaultDefinition};
-    }
-    if (defined $vals->{columnDefinitions}) {
-      $self->{columnDefinitions} = $vals->{columnDefinitions};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'ColumnFamilyDefinition';
-}
-
-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::STRUCT) {
-        $self->{defaultDefinition} = new Blur::ColumnDefinition();
-        $xfer += $self->{defaultDefinition}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::MAP) {
-        {
-          my $_size115 = 0;
-          $self->{columnDefinitions} = {};
-          my $_ktype116 = 0;
-          my $_vtype117 = 0;
-          $xfer += $input->readMapBegin(\$_ktype116, \$_vtype117, \$_size115);
-          for (my $_i119 = 0; $_i119 < $_size115; ++$_i119)
-          {
-            my $key120 = '';
-            my $val121 = new Blur::ColumnDefinition();
-            $xfer += $input->readString(\$key120);
-            $val121 = new Blur::ColumnDefinition();
-            $xfer += $val121->read($input);
-            $self->{columnDefinitions}->{$key120} = $val121;
-          }
-          $xfer += $input->readMapEnd();
-        }
-      } 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('ColumnFamilyDefinition');
-  if (defined $self->{defaultDefinition}) {
-    $xfer += $output->writeFieldBegin('defaultDefinition', TType::STRUCT, 1);
-    $xfer += $self->{defaultDefinition}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{columnDefinitions}) {
-    $xfer += $output->writeFieldBegin('columnDefinitions', TType::MAP, 2);
-    {
-      $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{columnDefinitions}}));
-      {
-        while( my ($kiter122,$viter123) = each %{$self->{columnDefinitions}}) 
-        {
-          $xfer += $output->writeString($kiter122);
-          $xfer += ${viter123}->write($output);
-        }
-      }
-      $xfer += $output->writeMapEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::AnalyzerDefinition;
-use base qw(Class::Accessor);
-Blur::AnalyzerDefinition->mk_accessors( qw( defaultDefinition fullTextAnalyzerClassName columnFamilyDefinitions ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{defaultDefinition} = undef;
-  $self->{fullTextAnalyzerClassName} = "org.apache.blur.analysis.NoStopWordStandardAnalyzer";
-  $self->{columnFamilyDefinitions} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{defaultDefinition}) {
-      $self->{defaultDefinition} = $vals->{defaultDefinition};
-    }
-    if (defined $vals->{fullTextAnalyzerClassName}) {
-      $self->{fullTextAnalyzerClassName} = $vals->{fullTextAnalyzerClassName};
-    }
-    if (defined $vals->{columnFamilyDefinitions}) {
-      $self->{columnFamilyDefinitions} = $vals->{columnFamilyDefinitions};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'AnalyzerDefinition';
-}
-
-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::STRUCT) {
-        $self->{defaultDefinition} = new Blur::ColumnDefinition();
-        $xfer += $self->{defaultDefinition}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{fullTextAnalyzerClassName});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^3$/ && do{      if ($ftype == TType::MAP) {
-        {
-          my $_size124 = 0;
-          $self->{columnFamilyDefinitions} = {};
-          my $_ktype125 = 0;
-          my $_vtype126 = 0;
-          $xfer += $input->readMapBegin(\$_ktype125, \$_vtype126, \$_size124);
-          for (my $_i128 = 0; $_i128 < $_size124; ++$_i128)
-          {
-            my $key129 = '';
-            my $val130 = new Blur::ColumnFamilyDefinition();
-            $xfer += $input->readString(\$key129);
-            $val130 = new Blur::ColumnFamilyDefinition();
-            $xfer += $val130->read($input);
-            $self->{columnFamilyDefinitions}->{$key129} = $val130;
-          }
-          $xfer += $input->readMapEnd();
-        }
-      } 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('AnalyzerDefinition');
-  if (defined $self->{defaultDefinition}) {
-    $xfer += $output->writeFieldBegin('defaultDefinition', TType::STRUCT, 1);
-    $xfer += $self->{defaultDefinition}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{fullTextAnalyzerClassName}) {
-    $xfer += $output->writeFieldBegin('fullTextAnalyzerClassName', TType::STRING, 2);
-    $xfer += $output->writeString($self->{fullTextAnalyzerClassName});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{columnFamilyDefinitions}) {
-    $xfer += $output->writeFieldBegin('columnFamilyDefinitions', TType::MAP, 3);
-    {
-      $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{columnFamilyDefinitions}}));
-      {
-        while( my ($kiter131,$viter132) = each %{$self->{columnFamilyDefinitions}}) 
-        {
-          $xfer += $output->writeString($kiter131);
-          $xfer += ${viter132}->write($output);
-        }
-      }
-      $xfer += $output->writeMapEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
 package Blur::ColumnPreCache;
 use base qw(Class::Accessor);
 Blur::ColumnPreCache->mk_accessors( qw( preCacheCols ) );
@@ -3186,15 +2775,15 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size133 = 0;
+          my $_size106 = 0;
           $self->{preCacheCols} = [];
-          my $_etype136 = 0;
-          $xfer += $input->readListBegin(\$_etype136, \$_size133);
-          for (my $_i137 = 0; $_i137 < $_size133; ++$_i137)
+          my $_etype109 = 0;
+          $xfer += $input->readListBegin(\$_etype109, \$_size106);
+          for (my $_i110 = 0; $_i110 < $_size106; ++$_i110)
           {
-            my $elem138 = undef;
-            $xfer += $input->readString(\$elem138);
-            push(@{$self->{preCacheCols}},$elem138);
+            my $elem111 = undef;
+            $xfer += $input->readString(\$elem111);
+            push(@{$self->{preCacheCols}},$elem111);
           }
           $xfer += $input->readListEnd();
         }
@@ -3219,9 +2808,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{preCacheCols}}));
       {
-        foreach my $iter139 (@{$self->{preCacheCols}}) 
+        foreach my $iter112 (@{$self->{preCacheCols}}) 
         {
-          $xfer += $output->writeString($iter139);
+          $xfer += $output->writeString($iter112);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3369,15 +2958,15 @@ sub read {
       last; };
       /^11$/ && do{      if ($ftype == TType::SET) {
         {
-          my $_size140 = 0;
+          my $_size113 = 0;
           $self->{blockCachingFileTypes} = {};
-          my $_etype143 = 0;
-          $xfer += $input->readSetBegin(\$_etype143, \$_size140);
-          for (my $_i144 = 0; $_i144 < $_size140; ++$_i144)
+          my $_etype116 = 0;
+          $xfer += $input->readSetBegin(\$_etype116, \$_size113);
+          for (my $_i117 = 0; $_i117 < $_size113; ++$_i117)
           {
-            my $elem145 = undef;
-            $xfer += $input->readString(\$elem145);
-            $self->{blockCachingFileTypes}->{$elem145} = 1;
+            my $elem118 = undef;
+            $xfer += $input->readString(\$elem118);
+            $self->{blockCachingFileTypes}->{$elem118} = 1;
           }
           $xfer += $input->readSetEnd();
         }
@@ -3400,18 +2989,18 @@ sub read {
       last; };
       /^14$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size146 = 0;
+          my $_size119 = 0;
           $self->{tableProperties} = {};
-          my $_ktype147 = 0;
-          my $_vtype148 = 0;
-          $xfer += $input->readMapBegin(\$_ktype147, \$_vtype148, \$_size146);
-          for (my $_i150 = 0; $_i150 < $_size146; ++$_i150)
+          my $_ktype120 = 0;
+          my $_vtype121 = 0;
+          $xfer += $input->readMapBegin(\$_ktype120, \$_vtype121, \$_size119);
+          for (my $_i123 = 0; $_i123 < $_size119; ++$_i123)
           {
-            my $key151 = '';
-            my $val152 = '';
-            $xfer += $input->readString(\$key151);
-            $xfer += $input->readString(\$val152);
-            $self->{tableProperties}->{$key151} = $val152;
+            my $key124 = '';
+            my $val125 = '';
+            $xfer += $input->readString(\$key124);
+            $xfer += $input->readString(\$val125);
+            $self->{tableProperties}->{$key124} = $val125;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3439,18 +3028,18 @@ sub read {
       last; };
       /^18$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size153 = 0;
+          my $_size126 = 0;
           $self->{defaultMissingFieldProps} = {};
-          my $_ktype154 = 0;
-          my $_vtype155 = 0;
-          $xfer += $input->readMapBegin(\$_ktype154, \$_vtype155, \$_size153);
-          for (my $_i157 = 0; $_i157 < $_size153; ++$_i157)
+          my $_ktype127 = 0;
+          my $_vtype128 = 0;
+          $xfer += $input->readMapBegin(\$_ktype127, \$_vtype128, \$_size126);
+          for (my $_i130 = 0; $_i130 < $_size126; ++$_i130)
           {
-            my $key158 = '';
-            my $val159 = '';
-            $xfer += $input->readString(\$key158);
-            $xfer += $input->readString(\$val159);
-            $self->{defaultMissingFieldProps}->{$key158} = $val159;
+            my $key131 = '';
+            my $val132 = '';
+            $xfer += $input->readString(\$key131);
+            $xfer += $input->readString(\$val132);
+            $self->{defaultMissingFieldProps}->{$key131} = $val132;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3510,9 +3099,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{blockCachingFileTypes}}));
       {
-        foreach my $iter160 (@{$self->{blockCachingFileTypes}})
+        foreach my $iter133 (@{$self->{blockCachingFileTypes}})
         {
-          $xfer += $output->writeString($iter160);
+          $xfer += $output->writeString($iter133);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -3534,10 +3123,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{tableProperties}}));
       {
-        while( my ($kiter161,$viter162) = each %{$self->{tableProperties}}) 
+        while( my ($kiter134,$viter135) = each %{$self->{tableProperties}}) 
         {
-          $xfer += $output->writeString($kiter161);
-          $xfer += $output->writeString($viter162);
+          $xfer += $output->writeString($kiter134);
+          $xfer += $output->writeString($viter135);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3564,10 +3153,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{defaultMissingFieldProps}}));
       {
-        while( my ($kiter163,$viter164) = each %{$self->{defaultMissingFieldProps}}) 
+        while( my ($kiter136,$viter137) = each %{$self->{defaultMissingFieldProps}}) 
         {
-          $xfer += $output->writeString($kiter163);
-          $xfer += $output->writeString($viter164);
+          $xfer += $output->writeString($kiter136);
+          $xfer += $output->writeString($viter137);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3635,18 +3224,18 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size165 = 0;
+          my $_size138 = 0;
           $self->{strMap} = {};
-          my $_ktype166 = 0;
-          my $_vtype167 = 0;
-          $xfer += $input->readMapBegin(\$_ktype166, \$_vtype167, \$_size165);
-          for (my $_i169 = 0; $_i169 < $_size165; ++$_i169)
+          my $_ktype139 = 0;
+          my $_vtype140 = 0;
+          $xfer += $input->readMapBegin(\$_ktype139, \$_vtype140, \$_size138);
+          for (my $_i142 = 0; $_i142 < $_size138; ++$_i142)
           {
-            my $key170 = '';
-            my $val171 = '';
-            $xfer += $input->readString(\$key170);
-            $xfer += $input->readString(\$val171);
-            $self->{strMap}->{$key170} = $val171;
+            my $key143 = '';
+            my $val144 = '';
+            $xfer += $input->readString(\$key143);
+            $xfer += $input->readString(\$val144);
+            $self->{strMap}->{$key143} = $val144;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3656,18 +3245,18 @@ sub read {
       last; };
       /^3$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size172 = 0;
+          my $_size145 = 0;
           $self->{longMap} = {};
-          my $_ktype173 = 0;
-          my $_vtype174 = 0;
-          $xfer += $input->readMapBegin(\$_ktype173, \$_vtype174, \$_size172);
-          for (my $_i176 = 0; $_i176 < $_size172; ++$_i176)
+          my $_ktype146 = 0;
+          my $_vtype147 = 0;
+          $xfer += $input->readMapBegin(\$_ktype146, \$_vtype147, \$_size145);
+          for (my $_i149 = 0; $_i149 < $_size145; ++$_i149)
           {
-            my $key177 = '';
-            my $val178 = 0;
-            $xfer += $input->readString(\$key177);
-            $xfer += $input->readI64(\$val178);
-            $self->{longMap}->{$key177} = $val178;
+            my $key150 = '';
+            my $val151 = 0;
+            $xfer += $input->readString(\$key150);
+            $xfer += $input->readI64(\$val151);
+            $self->{longMap}->{$key150} = $val151;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3677,18 +3266,18 @@ sub read {
       last; };
       /^4$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size179 = 0;
+          my $_size152 = 0;
           $self->{doubleMap} = {};
-          my $_ktype180 = 0;
-          my $_vtype181 = 0;
-          $xfer += $input->readMapBegin(\$_ktype180, \$_vtype181, \$_size179);
-          for (my $_i183 = 0; $_i183 < $_size179; ++$_i183)
+          my $_ktype153 = 0;
+          my $_vtype154 = 0;
+          $xfer += $input->readMapBegin(\$_ktype153, \$_vtype154, \$_size152);
+          for (my $_i156 = 0; $_i156 < $_size152; ++$_i156)
           {
-            my $key184 = '';
-            my $val185 = 0.0;
-            $xfer += $input->readString(\$key184);
-            $xfer += $input->readDouble(\$val185);
-            $self->{doubleMap}->{$key184} = $val185;
+            my $key157 = '';
+            my $val158 = 0.0;
+            $xfer += $input->readString(\$key157);
+            $xfer += $input->readDouble(\$val158);
+            $self->{doubleMap}->{$key157} = $val158;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3718,10 +3307,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{strMap}}));
       {
-        while( my ($kiter186,$viter187) = each %{$self->{strMap}}) 
+        while( my ($kiter159,$viter160) = each %{$self->{strMap}}) 
         {
-          $xfer += $output->writeString($kiter186);
-          $xfer += $output->writeString($viter187);
+          $xfer += $output->writeString($kiter159);
+          $xfer += $output->writeString($viter160);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3733,10 +3322,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::I64, scalar(keys %{$self->{longMap}}));
       {
-        while( my ($kiter188,$viter189) = each %{$self->{longMap}}) 
+        while( my ($kiter161,$viter162) = each %{$self->{longMap}}) 
         {
-          $xfer += $output->writeString($kiter188);
-          $xfer += $output->writeI64($viter189);
+          $xfer += $output->writeString($kiter161);
+          $xfer += $output->writeI64($viter162);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -3748,10 +3337,174 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::DOUBLE, scalar(keys %{$self->{doubleMap}}));
       {
-        while( my ($kiter190,$viter191) = each %{$self->{doubleMap}}) 
+        while( my ($kiter163,$viter164) = each %{$self->{doubleMap}}) 
+        {
+          $xfer += $output->writeString($kiter163);
+          $xfer += $output->writeDouble($viter164);
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::ColumnDefinition;
+use base qw(Class::Accessor);
+Blur::ColumnDefinition->mk_accessors( qw( family columnName subColumnName fieldLessIndexing fieldType properties ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{family} = undef;
+  $self->{columnName} = undef;
+  $self->{subColumnName} = undef;
+  $self->{fieldLessIndexing} = undef;
+  $self->{fieldType} = undef;
+  $self->{properties} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{family}) {
+      $self->{family} = $vals->{family};
+    }
+    if (defined $vals->{columnName}) {
+      $self->{columnName} = $vals->{columnName};
+    }
+    if (defined $vals->{subColumnName}) {
+      $self->{subColumnName} = $vals->{subColumnName};
+    }
+    if (defined $vals->{fieldLessIndexing}) {
+      $self->{fieldLessIndexing} = $vals->{fieldLessIndexing};
+    }
+    if (defined $vals->{fieldType}) {
+      $self->{fieldType} = $vals->{fieldType};
+    }
+    if (defined $vals->{properties}) {
+      $self->{properties} = $vals->{properties};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'ColumnDefinition';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{family});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{columnName});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{subColumnName});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{fieldLessIndexing});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^5$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{fieldType});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^6$/ && do{      if ($ftype == TType::MAP) {
+        {
+          my $_size165 = 0;
+          $self->{properties} = {};
+          my $_ktype166 = 0;
+          my $_vtype167 = 0;
+          $xfer += $input->readMapBegin(\$_ktype166, \$_vtype167, \$_size165);
+          for (my $_i169 = 0; $_i169 < $_size165; ++$_i169)
+          {
+            my $key170 = '';
+            my $val171 = '';
+            $xfer += $input->readString(\$key170);
+            $xfer += $input->readString(\$val171);
+            $self->{properties}->{$key170} = $val171;
+          }
+          $xfer += $input->readMapEnd();
+        }
+      } 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('ColumnDefinition');
+  if (defined $self->{family}) {
+    $xfer += $output->writeFieldBegin('family', TType::STRING, 1);
+    $xfer += $output->writeString($self->{family});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{columnName}) {
+    $xfer += $output->writeFieldBegin('columnName', TType::STRING, 2);
+    $xfer += $output->writeString($self->{columnName});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{subColumnName}) {
+    $xfer += $output->writeFieldBegin('subColumnName', TType::STRING, 3);
+    $xfer += $output->writeString($self->{subColumnName});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{fieldLessIndexing}) {
+    $xfer += $output->writeFieldBegin('fieldLessIndexing', TType::BOOL, 4);
+    $xfer += $output->writeBool($self->{fieldLessIndexing});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{fieldType}) {
+    $xfer += $output->writeFieldBegin('fieldType', TType::STRING, 5);
+    $xfer += $output->writeString($self->{fieldType});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{properties}) {
+    $xfer += $output->writeFieldBegin('properties', TType::MAP, 6);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{properties}}));
+      {
+        while( my ($kiter172,$viter173) = each %{$self->{properties}}) 
         {
-          $xfer += $output->writeString($kiter190);
-          $xfer += $output->writeDouble($viter191);
+          $xfer += $output->writeString($kiter172);
+          $xfer += $output->writeString($viter173);
         }
       }
       $xfer += $output->writeMapEnd();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/d0b113eb/distribution/src/main/scripts/interface/gen-rb/blur.rb
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-rb/blur.rb b/distribution/src/main/scripts/interface/gen-rb/blur.rb
index 2a277c7..31cf300 100644
--- a/distribution/src/main/scripts/interface/gen-rb/blur.rb
+++ b/distribution/src/main/scripts/interface/gen-rb/blur.rb
@@ -421,6 +421,22 @@ module Blur
         return
       end
 
+      def addColumnDefinition(table, columnDefinition)
+        send_addColumnDefinition(table, columnDefinition)
+        return recv_addColumnDefinition()
+      end
+
+      def send_addColumnDefinition(table, columnDefinition)
+        send_message('addColumnDefinition', AddColumnDefinition_args, :table => table, :columnDefinition => columnDefinition)
+      end
+
+      def recv_addColumnDefinition()
+        result = receive_message(AddColumnDefinition_result)
+        return result.success unless result.success.nil?
+        raise result.ex unless result.ex.nil?
+        raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'addColumnDefinition failed: unknown result')
+      end
+
       def optimize(table, numberOfSegmentsPerShard)
         send_optimize(table, numberOfSegmentsPerShard)
         recv_optimize()
@@ -775,6 +791,17 @@ module Blur
         write_result(result, oprot, 'removeTable', seqid)
       end
 
+      def process_addColumnDefinition(seqid, iprot, oprot)
+        args = read_args(iprot, AddColumnDefinition_args)
+        result = AddColumnDefinition_result.new()
+        begin
+          result.success = @handler.addColumnDefinition(args.table, args.columnDefinition)
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'addColumnDefinition', seqid)
+      end
+
       def process_optimize(seqid, iprot, oprot)
         args = read_args(iprot, Optimize_args)
         result = Optimize_result.new()
@@ -1716,6 +1743,42 @@ module Blur
       ::Thrift::Struct.generate_accessors self
     end
 
+    class AddColumnDefinition_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      TABLE = 1
+      COLUMNDEFINITION = 2
+
+      FIELDS = {
+        TABLE => {:type => ::Thrift::Types::STRING, :name => 'table'},
+        COLUMNDEFINITION => {:type => ::Thrift::Types::STRUCT, :name => 'columnDefinition', :class => ::Blur::ColumnDefinition}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class AddColumnDefinition_result
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      SUCCESS = 0
+      EX = 1
+
+      FIELDS = {
+        SUCCESS => {:type => ::Thrift::Types::BOOL, :name => 'success'},
+        EX => {:type => ::Thrift::Types::STRUCT, :name => 'ex', :class => ::Blur::BlurException}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
     class Optimize_args
       include ::Thrift::Struct, ::Thrift::Struct_Union
       TABLE = 1

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/d0b113eb/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 92e7f29..432f73d 100644
--- a/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
+++ b/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
@@ -685,90 +685,6 @@ module Blur
   end
 
   # 
-  class AlternateColumnDefinition
-    include ::Thrift::Struct, ::Thrift::Struct_Union
-    ANALYZERCLASSNAME = 1
-
-    FIELDS = {
-      # 
-      ANALYZERCLASSNAME => {:type => ::Thrift::Types::STRING, :name => 'analyzerClassName'}
-    }
-
-    def struct_fields; FIELDS; end
-
-    def validate
-    end
-
-    ::Thrift::Struct.generate_accessors self
-  end
-
-  # 
-  class ColumnDefinition
-    include ::Thrift::Struct, ::Thrift::Struct_Union
-    ANALYZERCLASSNAME = 1
-    FULLTEXTINDEX = 2
-    ALTERNATECOLUMNDEFINITIONS = 3
-
-    FIELDS = {
-      ANALYZERCLASSNAME => {:type => ::Thrift::Types::STRING, :name => 'analyzerClassName', :default => %q"org.apache.blur.analysis.NoStopWordStandardAnalyzer"},
-      FULLTEXTINDEX => {:type => ::Thrift::Types::BOOL, :name => 'fullTextIndex'},
-      ALTERNATECOLUMNDEFINITIONS => {:type => ::Thrift::Types::MAP, :name => 'alternateColumnDefinitions', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::AlternateColumnDefinition}}
-    }
-
-    def struct_fields; FIELDS; end
-
-    def validate
-    end
-
-    ::Thrift::Struct.generate_accessors self
-  end
-
-  # 
-  class ColumnFamilyDefinition
-    include ::Thrift::Struct, ::Thrift::Struct_Union
-    DEFAULTDEFINITION = 1
-    COLUMNDEFINITIONS = 2
-
-    FIELDS = {
-      # 
-      DEFAULTDEFINITION => {:type => ::Thrift::Types::STRUCT, :name => 'defaultDefinition', :class => ::Blur::ColumnDefinition},
-      # 
-      COLUMNDEFINITIONS => {:type => ::Thrift::Types::MAP, :name => 'columnDefinitions', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::ColumnDefinition}}
-    }
-
-    def struct_fields; FIELDS; end
-
-    def validate
-    end
-
-    ::Thrift::Struct.generate_accessors self
-  end
-
-  # 
-  class AnalyzerDefinition
-    include ::Thrift::Struct, ::Thrift::Struct_Union
-    DEFAULTDEFINITION = 1
-    FULLTEXTANALYZERCLASSNAME = 2
-    COLUMNFAMILYDEFINITIONS = 3
-
-    FIELDS = {
-      # 
-      DEFAULTDEFINITION => {:type => ::Thrift::Types::STRUCT, :name => 'defaultDefinition', :class => ::Blur::ColumnDefinition},
-      # 
-      FULLTEXTANALYZERCLASSNAME => {:type => ::Thrift::Types::STRING, :name => 'fullTextAnalyzerClassName', :default => %q"org.apache.blur.analysis.NoStopWordStandardAnalyzer"},
-      # 
-      COLUMNFAMILYDEFINITIONS => {:type => ::Thrift::Types::MAP, :name => 'columnFamilyDefinitions', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRUCT, :class => ::Blur::ColumnFamilyDefinition}}
-    }
-
-    def struct_fields; FIELDS; end
-
-    def validate
-    end
-
-    ::Thrift::Struct.generate_accessors self
-  end
-
-  # 
   class ColumnPreCache
     include ::Thrift::Struct, ::Thrift::Struct_Union
     PRECACHECOLS = 1
@@ -869,4 +785,46 @@ module Blur
     ::Thrift::Struct.generate_accessors self
   end
 
+  class ColumnDefinition
+    include ::Thrift::Struct, ::Thrift::Struct_Union
+    FAMILY = 1
+    COLUMNNAME = 2
+    SUBCOLUMNNAME = 3
+    FIELDLESSINDEXING = 4
+    FIELDTYPE = 5
+    PROPERTIES = 6
+
+    FIELDS = {
+      # Required. The family the this column existing within.
+      FAMILY => {:type => ::Thrift::Types::STRING, :name => 'family'},
+      # Required. The column name.
+      COLUMNNAME => {:type => ::Thrift::Types::STRING, :name => 'columnName'},
+      # If this column definition is for a sub column then provide the sub column name.  Otherwise leave this field null.
+      SUBCOLUMNNAME => {:type => ::Thrift::Types::STRING, :name => 'subColumnName'},
+      # If this column should be searchable without having to specify the name of the column in the query.
+# NOTE: This will index the column as a full text field in a default field, so that means it's going to be indexed twice.
+      FIELDLESSINDEXING => {:type => ::Thrift::Types::BOOL, :name => 'fieldLessIndexing'},
+      # The field type for the column.  The built in types are:
+# <ul>
+# <li>text - Full text indexing.</li>
+# <li>string - Indexed string literal</li>
+# <li>int - Converted to an integer and indexed numerically.</li>
+# <li>long - Converted to an long and indexed numerically.</li>
+# <li>float - Converted to an float and indexed numerically.</li>
+# <li>double - Converted to an double and indexed numerically.</li>
+# <li>stored - Not indexed, only stored.</li>
+# </ul>
+      FIELDTYPE => {:type => ::Thrift::Types::STRING, :name => 'fieldType'},
+      # For any custom field types, you can pass in configuration properties.
+      PROPERTIES => {:type => ::Thrift::Types::MAP, :name => 'properties', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}}
+    }
+
+    def struct_fields; FIELDS; end
+
+    def validate
+    end
+
+    ::Thrift::Struct.generate_accessors self
+  end
+
 end


Mime
View raw message