incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [38/51] [abbrv] Massive changes to the the thrift API. Getting closer to the final version, this commit also removes the controller from the architecture.
Date Tue, 11 Dec 2012 02:21:00 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/aee531c2/interface/gen-perl/Blur/Types.pm
----------------------------------------------------------------------
diff --git a/interface/gen-perl/Blur/Types.pm b/interface/gen-perl/Blur/Types.pm
index 0acfab7..d234563 100644
--- a/interface/gen-perl/Blur/Types.pm
+++ b/interface/gen-perl/Blur/Types.pm
@@ -8,11 +8,6 @@ use strict;
 use warnings;
 use Thrift;
 
-package Blur::ScoreType;
-use constant SUPER => 0;
-use constant AGGREGATE => 1;
-use constant BEST => 2;
-use constant CONSTANT => 3;
 package Blur::QueryState;
 use constant RUNNING => 0;
 use constant INTERRUPTED => 1;
@@ -196,9 +191,9 @@ sub write {
   return $xfer;
 }
 
-package Blur::BlurQueryStatus;
+package Blur::QueryStatus;
 use base qw(Class::Accessor);
-Blur::BlurQueryStatus->mk_accessors( qw( cpuTimes completeShards totalShards state uuid ) );
+Blur::QueryStatus->mk_accessors( qw( cpuTimes completeShards totalShards state ) );
 
 sub new {
   my $classname = shift;
@@ -208,7 +203,6 @@ sub new {
   $self->{completeShards} = undef;
   $self->{totalShards} = undef;
   $self->{state} = undef;
-  $self->{uuid} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{cpuTimes}) {
       $self->{cpuTimes} = $vals->{cpuTimes};
@@ -222,15 +216,12 @@ sub new {
     if (defined $vals->{state}) {
       $self->{state} = $vals->{state};
     }
-    if (defined $vals->{uuid}) {
-      $self->{uuid} = $vals->{uuid};
-    }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'BlurQueryStatus';
+  return 'QueryStatus';
 }
 
 sub read {
@@ -248,7 +239,7 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^2$/ && do{      if ($ftype == TType::MAP) {
+      /^1$/ && do{      if ($ftype == TType::MAP) {
         {
           my $_size0 = 0;
           $self->{cpuTimes} = {};
@@ -270,30 +261,24 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^3$/ && do{      if ($ftype == TType::I32) {
+      /^2$/ && do{      if ($ftype == TType::I32) {
         $xfer += $input->readI32(\$self->{completeShards});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^4$/ && do{      if ($ftype == TType::I32) {
+      /^3$/ && do{      if ($ftype == TType::I32) {
         $xfer += $input->readI32(\$self->{totalShards});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^5$/ && do{      if ($ftype == TType::I32) {
+      /^4$/ && do{      if ($ftype == TType::I32) {
         $xfer += $input->readI32(\$self->{state});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^6$/ && do{      if ($ftype == TType::I64) {
-        $xfer += $input->readI64(\$self->{uuid});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -305,9 +290,9 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('BlurQueryStatus');
+  $xfer += $output->writeStructBegin('QueryStatus');
   if (defined $self->{cpuTimes}) {
-    $xfer += $output->writeFieldBegin('cpuTimes', TType::MAP, 2);
+    $xfer += $output->writeFieldBegin('cpuTimes', TType::MAP, 1);
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{cpuTimes}}));
       {
@@ -322,25 +307,20 @@ sub write {
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{completeShards}) {
-    $xfer += $output->writeFieldBegin('completeShards', TType::I32, 3);
+    $xfer += $output->writeFieldBegin('completeShards', TType::I32, 2);
     $xfer += $output->writeI32($self->{completeShards});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{totalShards}) {
-    $xfer += $output->writeFieldBegin('totalShards', TType::I32, 4);
+    $xfer += $output->writeFieldBegin('totalShards', TType::I32, 3);
     $xfer += $output->writeI32($self->{totalShards});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{state}) {
-    $xfer += $output->writeFieldBegin('state', TType::I32, 5);
+    $xfer += $output->writeFieldBegin('state', TType::I32, 4);
     $xfer += $output->writeI32($self->{state});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{uuid}) {
-    $xfer += $output->writeFieldBegin('uuid', TType::I64, 6);
-    $xfer += $output->writeI64($self->{uuid});
-    $xfer += $output->writeFieldEnd();
-  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
@@ -348,29 +328,21 @@ sub write {
 
 package Blur::TableStats;
 use base qw(Class::Accessor);
-Blur::TableStats->mk_accessors( qw( tableName bytes recordCount rowCount queries ) );
+Blur::TableStats->mk_accessors( qw( bytes documentCount queries ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{tableName} = undef;
   $self->{bytes} = undef;
-  $self->{recordCount} = undef;
-  $self->{rowCount} = undef;
+  $self->{documentCount} = undef;
   $self->{queries} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{tableName}) {
-      $self->{tableName} = $vals->{tableName};
-    }
     if (defined $vals->{bytes}) {
       $self->{bytes} = $vals->{bytes};
     }
-    if (defined $vals->{recordCount}) {
-      $self->{recordCount} = $vals->{recordCount};
-    }
-    if (defined $vals->{rowCount}) {
-      $self->{rowCount} = $vals->{rowCount};
+    if (defined $vals->{documentCount}) {
+      $self->{documentCount} = $vals->{documentCount};
     }
     if (defined $vals->{queries}) {
       $self->{queries} = $vals->{queries};
@@ -398,31 +370,19 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{tableName});
+      /^1$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{bytes});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
       /^2$/ && do{      if ($ftype == TType::I64) {
-        $xfer += $input->readI64(\$self->{bytes});
+        $xfer += $input->readI64(\$self->{documentCount});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
       /^3$/ && do{      if ($ftype == TType::I64) {
-        $xfer += $input->readI64(\$self->{recordCount});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^4$/ && do{      if ($ftype == TType::I64) {
-        $xfer += $input->readI64(\$self->{rowCount});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^5$/ && do{      if ($ftype == TType::I64) {
         $xfer += $input->readI64(\$self->{queries});
       } else {
         $xfer += $input->skip($ftype);
@@ -440,28 +400,18 @@ sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
   $xfer += $output->writeStructBegin('TableStats');
-  if (defined $self->{tableName}) {
-    $xfer += $output->writeFieldBegin('tableName', TType::STRING, 1);
-    $xfer += $output->writeString($self->{tableName});
-    $xfer += $output->writeFieldEnd();
-  }
   if (defined $self->{bytes}) {
-    $xfer += $output->writeFieldBegin('bytes', TType::I64, 2);
+    $xfer += $output->writeFieldBegin('bytes', TType::I64, 1);
     $xfer += $output->writeI64($self->{bytes});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{recordCount}) {
-    $xfer += $output->writeFieldBegin('recordCount', TType::I64, 3);
-    $xfer += $output->writeI64($self->{recordCount});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{rowCount}) {
-    $xfer += $output->writeFieldBegin('rowCount', TType::I64, 4);
-    $xfer += $output->writeI64($self->{rowCount});
+  if (defined $self->{documentCount}) {
+    $xfer += $output->writeFieldBegin('documentCount', TType::I64, 2);
+    $xfer += $output->writeI64($self->{documentCount});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{queries}) {
-    $xfer += $output->writeFieldBegin('queries', TType::I64, 5);
+    $xfer += $output->writeFieldBegin('queries', TType::I64, 3);
     $xfer += $output->writeI64($self->{queries});
     $xfer += $output->writeFieldEnd();
   }
@@ -470,9 +420,9 @@ sub write {
   return $xfer;
 }
 
-package Blur::Schema;
+package Blur::LiveSchema;
 use base qw(Class::Accessor);
-Blur::Schema->mk_accessors( qw( table columnFamilies ) );
+Blur::LiveSchema->mk_accessors( qw( table columnFamilies ) );
 
 sub new {
   my $classname = shift;
@@ -492,7 +442,7 @@ sub new {
 }
 
 sub getName {
-  return 'Schema';
+  return 'LiveSchema';
 }
 
 sub read {
@@ -560,7 +510,7 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Schema');
+  $xfer += $output->writeStructBegin('LiveSchema');
   if (defined $self->{table}) {
     $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
     $xfer += $output->writeString($self->{table});
@@ -595,97 +545,29 @@ 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;
+package Blur::ClassDefinition;
 use base qw(Class::Accessor);
-Blur::ColumnDefinition->mk_accessors( qw( analyzerClassName fullTextIndex alternateColumnDefinitions ) );
+Blur::ClassDefinition->mk_accessors( qw( className arguments ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{analyzerClassName} = "org.apache.lucene.analysis.standard.StandardAnalyzer";
-  $self->{fullTextIndex} = undef;
-  $self->{alternateColumnDefinitions} = undef;
+  $self->{className} = undef;
+  $self->{arguments} = 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->{className}) {
+      $self->{className} = $vals->{className};
     }
-    if (defined $vals->{alternateColumnDefinitions}) {
-      $self->{alternateColumnDefinitions} = $vals->{alternateColumnDefinitions};
+    if (defined $vals->{arguments}) {
+      $self->{arguments} = $vals->{arguments};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'ColumnDefinition';
+  return 'ClassDefinition';
 }
 
 sub read {
@@ -704,32 +586,25 @@ sub read {
     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});
+        $xfer += $input->readString(\$self->{className});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^3$/ && do{      if ($ftype == TType::MAP) {
+      /^2$/ && do{      if ($ftype == TType::MAP) {
         {
           my $_size25 = 0;
-          $self->{alternateColumnDefinitions} = {};
+          $self->{arguments} = {};
           my $_ktype26 = 0;
           my $_vtype27 = 0;
           $xfer += $input->readMapBegin(\$_ktype26, \$_vtype27, \$_size25);
           for (my $_i29 = 0; $_i29 < $_size25; ++$_i29)
           {
             my $key30 = '';
-            my $val31 = new Blur::AlternateColumnDefinition();
+            my $val31 = '';
             $xfer += $input->readString(\$key30);
-            $val31 = new Blur::AlternateColumnDefinition();
-            $xfer += $val31->read($input);
-            $self->{alternateColumnDefinitions}->{$key30} = $val31;
+            $xfer += $input->readString(\$val31);
+            $self->{arguments}->{$key30} = $val31;
           }
           $xfer += $input->readMapEnd();
         }
@@ -748,26 +623,21 @@ sub read {
 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->writeStructBegin('ClassDefinition');
+  if (defined $self->{className}) {
+    $xfer += $output->writeFieldBegin('className', TType::STRING, 1);
+    $xfer += $output->writeString($self->{className});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{alternateColumnDefinitions}) {
-    $xfer += $output->writeFieldBegin('alternateColumnDefinitions', TType::MAP, 3);
+  if (defined $self->{arguments}) {
+    $xfer += $output->writeFieldBegin('arguments', TType::MAP, 2);
     {
-      $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{alternateColumnDefinitions}}));
+      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{arguments}}));
       {
-        while( my ($kiter32,$viter33) = each %{$self->{alternateColumnDefinitions}}) 
+        while( my ($kiter32,$viter33) = each %{$self->{arguments}}) 
         {
           $xfer += $output->writeString($kiter32);
-          $xfer += ${viter33}->write($output);
+          $xfer += $output->writeString($viter33);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -779,29 +649,29 @@ sub write {
   return $xfer;
 }
 
-package Blur::ColumnFamilyDefinition;
+package Blur::AnalyzerSubType;
 use base qw(Class::Accessor);
-Blur::ColumnFamilyDefinition->mk_accessors( qw( defaultDefinition columnDefinitions ) );
+Blur::AnalyzerSubType->mk_accessors( qw( fieldName classDefinition ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{defaultDefinition} = undef;
-  $self->{columnDefinitions} = undef;
+  $self->{fieldName} = undef;
+  $self->{classDefinition} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{defaultDefinition}) {
-      $self->{defaultDefinition} = $vals->{defaultDefinition};
+    if (defined $vals->{fieldName}) {
+      $self->{fieldName} = $vals->{fieldName};
     }
-    if (defined $vals->{columnDefinitions}) {
-      $self->{columnDefinitions} = $vals->{columnDefinitions};
+    if (defined $vals->{classDefinition}) {
+      $self->{classDefinition} = $vals->{classDefinition};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'ColumnFamilyDefinition';
+  return 'AnalyzerSubType';
 }
 
 sub read {
@@ -819,31 +689,15 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{defaultDefinition} = new Blur::ColumnDefinition();
-        $xfer += $self->{defaultDefinition}->read($input);
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{fieldName});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^2$/ && do{      if ($ftype == TType::MAP) {
-        {
-          my $_size34 = 0;
-          $self->{columnDefinitions} = {};
-          my $_ktype35 = 0;
-          my $_vtype36 = 0;
-          $xfer += $input->readMapBegin(\$_ktype35, \$_vtype36, \$_size34);
-          for (my $_i38 = 0; $_i38 < $_size34; ++$_i38)
-          {
-            my $key39 = '';
-            my $val40 = new Blur::ColumnDefinition();
-            $xfer += $input->readString(\$key39);
-            $val40 = new Blur::ColumnDefinition();
-            $xfer += $val40->read($input);
-            $self->{columnDefinitions}->{$key39} = $val40;
-          }
-          $xfer += $input->readMapEnd();
-        }
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{classDefinition} = new Blur::ClassDefinition();
+        $xfer += $self->{classDefinition}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -859,25 +713,15 @@ sub read {
 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->writeStructBegin('AnalyzerSubType');
+  if (defined $self->{fieldName}) {
+    $xfer += $output->writeFieldBegin('fieldName', TType::STRING, 1);
+    $xfer += $output->writeString($self->{fieldName});
     $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 ($kiter41,$viter42) = each %{$self->{columnDefinitions}}) 
-        {
-          $xfer += $output->writeString($kiter41);
-          $xfer += ${viter42}->write($output);
-        }
-      }
-      $xfer += $output->writeMapEnd();
-    }
+  if (defined $self->{classDefinition}) {
+    $xfer += $output->writeFieldBegin('classDefinition', TType::STRUCT, 2);
+    $xfer += $self->{classDefinition}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -885,33 +729,33 @@ sub write {
   return $xfer;
 }
 
-package Blur::AnalyzerDefinition;
+package Blur::AnalyzerType;
 use base qw(Class::Accessor);
-Blur::AnalyzerDefinition->mk_accessors( qw( defaultDefinition fullTextAnalyzerClassName columnFamilyDefinitions ) );
+Blur::AnalyzerType->mk_accessors( qw( fieldName classDefinition analyzerSubTypes ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{defaultDefinition} = undef;
-  $self->{fullTextAnalyzerClassName} = "org.apache.lucene.analysis.standard.StandardAnalyzer";
-  $self->{columnFamilyDefinitions} = undef;
+  $self->{fieldName} = undef;
+  $self->{classDefinition} = undef;
+  $self->{analyzerSubTypes} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{defaultDefinition}) {
-      $self->{defaultDefinition} = $vals->{defaultDefinition};
+    if (defined $vals->{fieldName}) {
+      $self->{fieldName} = $vals->{fieldName};
     }
-    if (defined $vals->{fullTextAnalyzerClassName}) {
-      $self->{fullTextAnalyzerClassName} = $vals->{fullTextAnalyzerClassName};
+    if (defined $vals->{classDefinition}) {
+      $self->{classDefinition} = $vals->{classDefinition};
     }
-    if (defined $vals->{columnFamilyDefinitions}) {
-      $self->{columnFamilyDefinitions} = $vals->{columnFamilyDefinitions};
+    if (defined $vals->{analyzerSubTypes}) {
+      $self->{analyzerSubTypes} = $vals->{analyzerSubTypes};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'AnalyzerDefinition';
+  return 'AnalyzerType';
 }
 
 sub read {
@@ -929,36 +773,33 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{defaultDefinition} = new Blur::ColumnDefinition();
-        $xfer += $self->{defaultDefinition}->read($input);
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{fieldName});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^2$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{fullTextAnalyzerClassName});
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{classDefinition} = new Blur::ClassDefinition();
+        $xfer += $self->{classDefinition}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^3$/ && do{      if ($ftype == TType::MAP) {
+      /^3$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size43 = 0;
-          $self->{columnFamilyDefinitions} = {};
-          my $_ktype44 = 0;
-          my $_vtype45 = 0;
-          $xfer += $input->readMapBegin(\$_ktype44, \$_vtype45, \$_size43);
-          for (my $_i47 = 0; $_i47 < $_size43; ++$_i47)
+          my $_size34 = 0;
+          $self->{analyzerSubTypes} = [];
+          my $_etype37 = 0;
+          $xfer += $input->readListBegin(\$_etype37, \$_size34);
+          for (my $_i38 = 0; $_i38 < $_size34; ++$_i38)
           {
-            my $key48 = '';
-            my $val49 = new Blur::ColumnFamilyDefinition();
-            $xfer += $input->readString(\$key48);
-            $val49 = new Blur::ColumnFamilyDefinition();
-            $xfer += $val49->read($input);
-            $self->{columnFamilyDefinitions}->{$key48} = $val49;
+            my $elem39 = undef;
+            $elem39 = new Blur::AnalyzerSubType();
+            $xfer += $elem39->read($input);
+            push(@{$self->{analyzerSubTypes}},$elem39);
           }
-          $xfer += $input->readMapEnd();
+          $xfer += $input->readListEnd();
         }
       } else {
         $xfer += $input->skip($ftype);
@@ -975,29 +816,28 @@ sub read {
 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->writeStructBegin('AnalyzerType');
+  if (defined $self->{fieldName}) {
+    $xfer += $output->writeFieldBegin('fieldName', TType::STRING, 1);
+    $xfer += $output->writeString($self->{fieldName});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{fullTextAnalyzerClassName}) {
-    $xfer += $output->writeFieldBegin('fullTextAnalyzerClassName', TType::STRING, 2);
-    $xfer += $output->writeString($self->{fullTextAnalyzerClassName});
+  if (defined $self->{classDefinition}) {
+    $xfer += $output->writeFieldBegin('classDefinition', TType::STRUCT, 2);
+    $xfer += $self->{classDefinition}->write($output);
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{columnFamilyDefinitions}) {
-    $xfer += $output->writeFieldBegin('columnFamilyDefinitions', TType::MAP, 3);
+  if (defined $self->{analyzerSubTypes}) {
+    $xfer += $output->writeFieldBegin('analyzerSubTypes', TType::LIST, 3);
     {
-      $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{columnFamilyDefinitions}}));
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{analyzerSubTypes}}));
       {
-        while( my ($kiter50,$viter51) = each %{$self->{columnFamilyDefinitions}}) 
+        foreach my $iter40 (@{$self->{analyzerSubTypes}}) 
         {
-          $xfer += $output->writeString($kiter50);
-          $xfer += ${viter51}->write($output);
+          $xfer += ${iter40}->write($output);
         }
       }
-      $xfer += $output->writeMapEnd();
+      $xfer += $output->writeListEnd();
     }
     $xfer += $output->writeFieldEnd();
   }
@@ -1006,25 +846,25 @@ sub write {
   return $xfer;
 }
 
-package Blur::ColumnPreCache;
+package Blur::Analyzer;
 use base qw(Class::Accessor);
-Blur::ColumnPreCache->mk_accessors( qw( preCacheCols ) );
+Blur::Analyzer->mk_accessors( qw( analyzerTypes ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{preCacheCols} = undef;
+  $self->{analyzerTypes} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{preCacheCols}) {
-      $self->{preCacheCols} = $vals->{preCacheCols};
+    if (defined $vals->{analyzerTypes}) {
+      $self->{analyzerTypes} = $vals->{analyzerTypes};
     }
   }
   return bless ($self, $classname);
 }
 
 sub getName {
-  return 'ColumnPreCache';
+  return 'Analyzer';
 }
 
 sub read {
@@ -1044,15 +884,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size52 = 0;
-          $self->{preCacheCols} = [];
-          my $_etype55 = 0;
-          $xfer += $input->readListBegin(\$_etype55, \$_size52);
-          for (my $_i56 = 0; $_i56 < $_size52; ++$_i56)
+          my $_size41 = 0;
+          $self->{analyzerTypes} = [];
+          my $_etype44 = 0;
+          $xfer += $input->readListBegin(\$_etype44, \$_size41);
+          for (my $_i45 = 0; $_i45 < $_size41; ++$_i45)
           {
-            my $elem57 = undef;
-            $xfer += $input->readString(\$elem57);
-            push(@{$self->{preCacheCols}},$elem57);
+            my $elem46 = undef;
+            $elem46 = new Blur::AnalyzerType();
+            $xfer += $elem46->read($input);
+            push(@{$self->{analyzerTypes}},$elem46);
           }
           $xfer += $input->readListEnd();
         }
@@ -1071,15 +912,15 @@ sub read {
 sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
-  $xfer += $output->writeStructBegin('ColumnPreCache');
-  if (defined $self->{preCacheCols}) {
-    $xfer += $output->writeFieldBegin('preCacheCols', TType::LIST, 1);
+  $xfer += $output->writeStructBegin('Analyzer');
+  if (defined $self->{analyzerTypes}) {
+    $xfer += $output->writeFieldBegin('analyzerTypes', TType::LIST, 1);
     {
-      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{preCacheCols}}));
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{analyzerTypes}}));
       {
-        foreach my $iter58 (@{$self->{preCacheCols}}) 
+        foreach my $iter47 (@{$self->{analyzerTypes}}) 
         {
-          $xfer += $output->writeString($iter58);
+          $xfer += ${iter47}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1093,64 +934,40 @@ sub write {
 
 package Blur::TableDescriptor;
 use base qw(Class::Accessor);
-Blur::TableDescriptor->mk_accessors( qw( isEnabled analyzerDefinition shardCount tableUri compressionClass compressionBlockSize cluster name similarityClass blockCaching blockCachingFileTypes readOnly columnPreCache ) );
+Blur::TableDescriptor->mk_accessors( qw( name enabled shardCount storagePath analyzer readOnly properties ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
-  $self->{isEnabled} = 1;
-  $self->{analyzerDefinition} = undef;
-  $self->{shardCount} = 1;
-  $self->{tableUri} = undef;
-  $self->{compressionClass} = "org.apache.hadoop.io.compress.DefaultCodec";
-  $self->{compressionBlockSize} = 32768;
-  $self->{cluster} = "default";
   $self->{name} = undef;
-  $self->{similarityClass} = undef;
-  $self->{blockCaching} = 1;
-  $self->{blockCachingFileTypes} = undef;
+  $self->{enabled} = 1;
+  $self->{shardCount} = 1;
+  $self->{storagePath} = undef;
+  $self->{analyzer} = undef;
   $self->{readOnly} = 0;
-  $self->{columnPreCache} = undef;
+  $self->{properties} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{isEnabled}) {
-      $self->{isEnabled} = $vals->{isEnabled};
+    if (defined $vals->{name}) {
+      $self->{name} = $vals->{name};
     }
-    if (defined $vals->{analyzerDefinition}) {
-      $self->{analyzerDefinition} = $vals->{analyzerDefinition};
+    if (defined $vals->{enabled}) {
+      $self->{enabled} = $vals->{enabled};
     }
     if (defined $vals->{shardCount}) {
       $self->{shardCount} = $vals->{shardCount};
     }
-    if (defined $vals->{tableUri}) {
-      $self->{tableUri} = $vals->{tableUri};
+    if (defined $vals->{storagePath}) {
+      $self->{storagePath} = $vals->{storagePath};
     }
-    if (defined $vals->{compressionClass}) {
-      $self->{compressionClass} = $vals->{compressionClass};
-    }
-    if (defined $vals->{compressionBlockSize}) {
-      $self->{compressionBlockSize} = $vals->{compressionBlockSize};
-    }
-    if (defined $vals->{cluster}) {
-      $self->{cluster} = $vals->{cluster};
-    }
-    if (defined $vals->{name}) {
-      $self->{name} = $vals->{name};
-    }
-    if (defined $vals->{similarityClass}) {
-      $self->{similarityClass} = $vals->{similarityClass};
-    }
-    if (defined $vals->{blockCaching}) {
-      $self->{blockCaching} = $vals->{blockCaching};
-    }
-    if (defined $vals->{blockCachingFileTypes}) {
-      $self->{blockCachingFileTypes} = $vals->{blockCachingFileTypes};
+    if (defined $vals->{analyzer}) {
+      $self->{analyzer} = $vals->{analyzer};
     }
     if (defined $vals->{readOnly}) {
       $self->{readOnly} = $vals->{readOnly};
     }
-    if (defined $vals->{columnPreCache}) {
-      $self->{columnPreCache} = $vals->{columnPreCache};
+    if (defined $vals->{properties}) {
+      $self->{properties} = $vals->{properties};
     }
   }
   return bless ($self, $classname);
@@ -1175,15 +992,14 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{isEnabled});
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{name});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^2$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{analyzerDefinition} = new Blur::AnalyzerDefinition();
-        $xfer += $self->{analyzerDefinition}->read($input);
+      /^2$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{enabled});
       } else {
         $xfer += $input->skip($ftype);
       }
@@ -1195,78 +1011,45 @@ sub read {
       }
       last; };
       /^4$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{tableUri});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^5$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{compressionClass});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^6$/ && do{      if ($ftype == TType::I32) {
-        $xfer += $input->readI32(\$self->{compressionBlockSize});
+        $xfer += $input->readString(\$self->{storagePath});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^7$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{cluster});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^8$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{name});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^9$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{similarityClass});
+      /^5$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{analyzer} = new Blur::Analyzer();
+        $xfer += $self->{analyzer}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^10$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{blockCaching});
+      /^6$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{readOnly});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^11$/ && do{      if ($ftype == TType::SET) {
+      /^7$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size59 = 0;
-          $self->{blockCachingFileTypes} = {};
-          my $_etype62 = 0;
-          $xfer += $input->readSetBegin(\$_etype62, \$_size59);
-          for (my $_i63 = 0; $_i63 < $_size59; ++$_i63)
+          my $_size48 = 0;
+          $self->{properties} = {};
+          my $_ktype49 = 0;
+          my $_vtype50 = 0;
+          $xfer += $input->readMapBegin(\$_ktype49, \$_vtype50, \$_size48);
+          for (my $_i52 = 0; $_i52 < $_size48; ++$_i52)
           {
-            my $elem64 = undef;
-            $xfer += $input->readString(\$elem64);
-            $self->{blockCachingFileTypes}->{$elem64} = 1;
+            my $key53 = '';
+            my $val54 = '';
+            $xfer += $input->readString(\$key53);
+            $xfer += $input->readString(\$val54);
+            $self->{properties}->{$key53} = $val54;
           }
-          $xfer += $input->readSetEnd();
+          $xfer += $input->readMapEnd();
         }
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^12$/ && do{      if ($ftype == TType::BOOL) {
-        $xfer += $input->readBool(\$self->{readOnly});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^13$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{columnPreCache} = new Blur::ColumnPreCache();
-        $xfer += $self->{columnPreCache}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -1279,14 +1062,14 @@ sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
   $xfer += $output->writeStructBegin('TableDescriptor');
-  if (defined $self->{isEnabled}) {
-    $xfer += $output->writeFieldBegin('isEnabled', TType::BOOL, 1);
-    $xfer += $output->writeBool($self->{isEnabled});
+  if (defined $self->{name}) {
+    $xfer += $output->writeFieldBegin('name', TType::STRING, 1);
+    $xfer += $output->writeString($self->{name});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{analyzerDefinition}) {
-    $xfer += $output->writeFieldBegin('analyzerDefinition', TType::STRUCT, 2);
-    $xfer += $self->{analyzerDefinition}->write($output);
+  if (defined $self->{enabled}) {
+    $xfer += $output->writeFieldBegin('enabled', TType::BOOL, 2);
+    $xfer += $output->writeBool($self->{enabled});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{shardCount}) {
@@ -1294,157 +1077,34 @@ sub write {
     $xfer += $output->writeI32($self->{shardCount});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{tableUri}) {
-    $xfer += $output->writeFieldBegin('tableUri', TType::STRING, 4);
-    $xfer += $output->writeString($self->{tableUri});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{compressionClass}) {
-    $xfer += $output->writeFieldBegin('compressionClass', TType::STRING, 5);
-    $xfer += $output->writeString($self->{compressionClass});
+  if (defined $self->{storagePath}) {
+    $xfer += $output->writeFieldBegin('storagePath', TType::STRING, 4);
+    $xfer += $output->writeString($self->{storagePath});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{compressionBlockSize}) {
-    $xfer += $output->writeFieldBegin('compressionBlockSize', TType::I32, 6);
-    $xfer += $output->writeI32($self->{compressionBlockSize});
+  if (defined $self->{analyzer}) {
+    $xfer += $output->writeFieldBegin('analyzer', TType::STRUCT, 5);
+    $xfer += $self->{analyzer}->write($output);
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{cluster}) {
-    $xfer += $output->writeFieldBegin('cluster', TType::STRING, 7);
-    $xfer += $output->writeString($self->{cluster});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{name}) {
-    $xfer += $output->writeFieldBegin('name', TType::STRING, 8);
-    $xfer += $output->writeString($self->{name});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{similarityClass}) {
-    $xfer += $output->writeFieldBegin('similarityClass', TType::STRING, 9);
-    $xfer += $output->writeString($self->{similarityClass});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{blockCaching}) {
-    $xfer += $output->writeFieldBegin('blockCaching', TType::BOOL, 10);
-    $xfer += $output->writeBool($self->{blockCaching});
+  if (defined $self->{readOnly}) {
+    $xfer += $output->writeFieldBegin('readOnly', TType::BOOL, 6);
+    $xfer += $output->writeBool($self->{readOnly});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{blockCachingFileTypes}) {
-    $xfer += $output->writeFieldBegin('blockCachingFileTypes', TType::SET, 11);
+  if (defined $self->{properties}) {
+    $xfer += $output->writeFieldBegin('properties', TType::MAP, 7);
     {
-      $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{blockCachingFileTypes}}));
+      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{properties}}));
       {
-        foreach my $iter65 (@{$self->{blockCachingFileTypes}})
+        while( my ($kiter55,$viter56) = each %{$self->{properties}}) 
         {
-          $xfer += $output->writeString($iter65);
+          $xfer += $output->writeString($kiter55);
+          $xfer += $output->writeString($viter56);
         }
       }
-      $xfer += $output->writeSetEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{readOnly}) {
-    $xfer += $output->writeFieldBegin('readOnly', TType::BOOL, 12);
-    $xfer += $output->writeBool($self->{readOnly});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{columnPreCache}) {
-    $xfer += $output->writeFieldBegin('columnPreCache', TType::STRUCT, 13);
-    $xfer += $self->{columnPreCache}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::Attribute;
-use base qw(Class::Accessor);
-Blur::Attribute->mk_accessors( qw( name value type ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{name} = undef;
-  $self->{value} = undef;
-  $self->{type} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{name}) {
-      $self->{name} = $vals->{name};
-    }
-    if (defined $vals->{value}) {
-      $self->{value} = $vals->{value};
-    }
-    if (defined $vals->{type}) {
-      $self->{type} = $vals->{type};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'Attribute';
-}
-
-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->{name});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{value});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^3$/ && do{      if ($ftype == TType::I32) {
-        $xfer += $input->readI32(\$self->{type});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-        $xfer += $input->skip($ftype);
+      $xfer += $output->writeMapEnd();
     }
-    $xfer += $input->readFieldEnd();
-  }
-  $xfer += $input->readStructEnd();
-  return $xfer;
-}
-
-sub write {
-  my ($self, $output) = @_;
-  my $xfer   = 0;
-  $xfer += $output->writeStructBegin('Attribute');
-  if (defined $self->{name}) {
-    $xfer += $output->writeFieldBegin('name', TType::STRING, 1);
-    $xfer += $output->writeString($self->{name});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{value}) {
-    $xfer += $output->writeFieldBegin('value', TType::STRING, 2);
-    $xfer += $output->writeString($self->{value});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{type}) {
-    $xfer += $output->writeFieldBegin('type', TType::I32, 3);
-    $xfer += $output->writeI32($self->{type});
     $xfer += $output->writeFieldEnd();
   }
   $xfer += $output->writeFieldStop();
@@ -1454,21 +1114,17 @@ sub write {
 
 package Blur::Session;
 use base qw(Class::Accessor);
-Blur::Session->mk_accessors( qw( sessionId properties ) );
+Blur::Session->mk_accessors( qw( sessionId ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
   $self->{sessionId} = undef;
-  $self->{properties} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{sessionId}) {
       $self->{sessionId} = $vals->{sessionId};
     }
-    if (defined $vals->{properties}) {
-      $self->{properties} = $vals->{properties};
-    }
   }
   return bless ($self, $classname);
 }
@@ -1498,27 +1154,6 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^2$/ && do{      if ($ftype == TType::MAP) {
-        {
-          my $_size66 = 0;
-          $self->{properties} = {};
-          my $_ktype67 = 0;
-          my $_vtype68 = 0;
-          $xfer += $input->readMapBegin(\$_ktype67, \$_vtype68, \$_size66);
-          for (my $_i70 = 0; $_i70 < $_size66; ++$_i70)
-          {
-            my $key71 = '';
-            my $val72 = '';
-            $xfer += $input->readString(\$key71);
-            $xfer += $input->readString(\$val72);
-            $self->{properties}->{$key71} = $val72;
-          }
-          $xfer += $input->readMapEnd();
-        }
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
         $xfer += $input->skip($ftype);
     }
     $xfer += $input->readFieldEnd();
@@ -1536,101 +1171,6 @@ sub write {
     $xfer += $output->writeString($self->{sessionId});
     $xfer += $output->writeFieldEnd();
   }
-  if (defined $self->{properties}) {
-    $xfer += $output->writeFieldBegin('properties', TType::MAP, 2);
-    {
-      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{properties}}));
-      {
-        while( my ($kiter73,$viter74) = each %{$self->{properties}}) 
-        {
-          $xfer += $output->writeString($kiter73);
-          $xfer += $output->writeString($viter74);
-        }
-      }
-      $xfer += $output->writeMapEnd();
-    }
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
-package Blur::QuerySession;
-use base qw(Class::Accessor);
-Blur::QuerySession->mk_accessors( qw( session queryId ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{session} = undef;
-  $self->{queryId} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{session}) {
-      $self->{session} = $vals->{session};
-    }
-    if (defined $vals->{queryId}) {
-      $self->{queryId} = $vals->{queryId};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'QuerySession';
-}
-
-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->{session} = new Blur::Session();
-        $xfer += $self->{session}->read($input);
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::STRING) {
-        $xfer += $input->readString(\$self->{queryId});
-      } 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('QuerySession');
-  if (defined $self->{session}) {
-    $xfer += $output->writeFieldBegin('session', TType::STRUCT, 1);
-    $xfer += $self->{session}->write($output);
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{queryId}) {
-    $xfer += $output->writeFieldBegin('queryId', TType::STRING, 2);
-    $xfer += $output->writeString($self->{queryId});
-    $xfer += $output->writeFieldEnd();
-  }
   $xfer += $output->writeFieldStop();
   $xfer += $output->writeStructEnd();
   return $xfer;
@@ -1768,16 +1308,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size75 = 0;
+          my $_size57 = 0;
           $self->{fields} = [];
-          my $_etype78 = 0;
-          $xfer += $input->readListBegin(\$_etype78, \$_size75);
-          for (my $_i79 = 0; $_i79 < $_size75; ++$_i79)
+          my $_etype60 = 0;
+          $xfer += $input->readListBegin(\$_etype60, \$_size57);
+          for (my $_i61 = 0; $_i61 < $_size57; ++$_i61)
           {
-            my $elem80 = undef;
-            $elem80 = new Blur::SortField();
-            $xfer += $elem80->read($input);
-            push(@{$self->{fields}},$elem80);
+            my $elem62 = undef;
+            $elem62 = new Blur::SortField();
+            $xfer += $elem62->read($input);
+            push(@{$self->{fields}},$elem62);
           }
           $xfer += $input->readListEnd();
         }
@@ -1802,9 +1342,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{fields}}));
       {
-        foreach my $iter81 (@{$self->{fields}}) 
+        foreach my $iter63 (@{$self->{fields}}) 
         {
-          $xfer += ${iter81}->write($output);
+          $xfer += ${iter63}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1816,85 +1356,6 @@ sub write {
   return $xfer;
 }
 
-package Blur::DocLocation;
-use base qw(Class::Accessor);
-Blur::DocLocation->mk_accessors( qw( doc shardIndex ) );
-
-sub new {
-  my $classname = shift;
-  my $self      = {};
-  my $vals      = shift || {};
-  $self->{doc} = undef;
-  $self->{shardIndex} = undef;
-  if (UNIVERSAL::isa($vals,'HASH')) {
-    if (defined $vals->{doc}) {
-      $self->{doc} = $vals->{doc};
-    }
-    if (defined $vals->{shardIndex}) {
-      $self->{shardIndex} = $vals->{shardIndex};
-    }
-  }
-  return bless ($self, $classname);
-}
-
-sub getName {
-  return 'DocLocation';
-}
-
-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::I32) {
-        $xfer += $input->readI32(\$self->{doc});
-      } else {
-        $xfer += $input->skip($ftype);
-      }
-      last; };
-      /^2$/ && do{      if ($ftype == TType::I32) {
-        $xfer += $input->readI32(\$self->{shardIndex});
-      } 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('DocLocation');
-  if (defined $self->{doc}) {
-    $xfer += $output->writeFieldBegin('doc', TType::I32, 1);
-    $xfer += $output->writeI32($self->{doc});
-    $xfer += $output->writeFieldEnd();
-  }
-  if (defined $self->{shardIndex}) {
-    $xfer += $output->writeFieldBegin('shardIndex', TType::I32, 2);
-    $xfer += $output->writeI32($self->{shardIndex});
-    $xfer += $output->writeFieldEnd();
-  }
-  $xfer += $output->writeFieldStop();
-  $xfer += $output->writeStructEnd();
-  return $xfer;
-}
-
 package Blur::ScoreDoc;
 use base qw(Class::Accessor);
 Blur::ScoreDoc->mk_accessors( qw( score docLocation fields ) );
@@ -1945,24 +1406,23 @@ sub read {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^2$/ && do{      if ($ftype == TType::STRUCT) {
-        $self->{docLocation} = new Blur::DocLocation();
-        $xfer += $self->{docLocation}->read($input);
+      /^2$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{docLocation});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
       /^4$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size82 = 0;
+          my $_size64 = 0;
           $self->{fields} = [];
-          my $_etype85 = 0;
-          $xfer += $input->readListBegin(\$_etype85, \$_size82);
-          for (my $_i86 = 0; $_i86 < $_size82; ++$_i86)
+          my $_etype67 = 0;
+          $xfer += $input->readListBegin(\$_etype67, \$_size64);
+          for (my $_i68 = 0; $_i68 < $_size64; ++$_i68)
           {
-            my $elem87 = undef;
-            $xfer += $input->readString(\$elem87);
-            push(@{$self->{fields}},$elem87);
+            my $elem69 = undef;
+            $xfer += $input->readString(\$elem69);
+            push(@{$self->{fields}},$elem69);
           }
           $xfer += $input->readListEnd();
         }
@@ -1988,8 +1448,8 @@ sub write {
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{docLocation}) {
-    $xfer += $output->writeFieldBegin('docLocation', TType::STRUCT, 2);
-    $xfer += $self->{docLocation}->write($output);
+    $xfer += $output->writeFieldBegin('docLocation', TType::I64, 2);
+    $xfer += $output->writeI64($self->{docLocation});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{fields}) {
@@ -1997,9 +1457,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{fields}}));
       {
-        foreach my $iter88 (@{$self->{fields}}) 
+        foreach my $iter70 (@{$self->{fields}}) 
         {
-          $xfer += $output->writeString($iter88);
+          $xfer += $output->writeString($iter70);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2013,21 +1473,25 @@ sub write {
 
 package Blur::QueryArgs;
 use base qw(Class::Accessor);
-Blur::QueryArgs->mk_accessors( qw( after query filter numberToFetch sort doDocScores doMaxScore shardIndexes ) );
+Blur::QueryArgs->mk_accessors( qw( id after query filter numberToFetch sort doDocScores doMaxScore shardIndexes ) );
 
 sub new {
   my $classname = shift;
   my $self      = {};
   my $vals      = shift || {};
+  $self->{id} = undef;
   $self->{after} = undef;
   $self->{query} = undef;
   $self->{filter} = undef;
-  $self->{numberToFetch} = undef;
+  $self->{numberToFetch} = 100;
   $self->{sort} = undef;
-  $self->{doDocScores} = undef;
-  $self->{doMaxScore} = undef;
+  $self->{doDocScores} = 1;
+  $self->{doMaxScore} = 0;
   $self->{shardIndexes} = undef;
   if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{id}) {
+      $self->{id} = $vals->{id};
+    }
     if (defined $vals->{after}) {
       $self->{after} = $vals->{after};
     }
@@ -2075,61 +1539,67 @@ sub read {
     }
     SWITCH: for($fid)
     {
-      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+      /^1$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{id});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
         $self->{after} = new Blur::ScoreDoc();
         $xfer += $self->{after}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^2$/ && do{      if ($ftype == TType::STRING) {
+      /^3$/ && do{      if ($ftype == TType::STRING) {
         $xfer += $input->readString(\$self->{query});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^3$/ && do{      if ($ftype == TType::STRING) {
+      /^4$/ && do{      if ($ftype == TType::STRING) {
         $xfer += $input->readString(\$self->{filter});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^4$/ && do{      if ($ftype == TType::I32) {
+      /^5$/ && do{      if ($ftype == TType::I32) {
         $xfer += $input->readI32(\$self->{numberToFetch});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^5$/ && do{      if ($ftype == TType::STRUCT) {
+      /^6$/ && do{      if ($ftype == TType::STRUCT) {
         $self->{sort} = new Blur::Sort();
         $xfer += $self->{sort}->read($input);
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^6$/ && do{      if ($ftype == TType::BOOL) {
+      /^7$/ && do{      if ($ftype == TType::BOOL) {
         $xfer += $input->readBool(\$self->{doDocScores});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^7$/ && do{      if ($ftype == TType::BOOL) {
+      /^8$/ && do{      if ($ftype == TType::BOOL) {
         $xfer += $input->readBool(\$self->{doMaxScore});
       } else {
         $xfer += $input->skip($ftype);
       }
       last; };
-      /^8$/ && do{      if ($ftype == TType::LIST) {
+      /^9$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size89 = 0;
+          my $_size71 = 0;
           $self->{shardIndexes} = [];
-          my $_etype92 = 0;
-          $xfer += $input->readListBegin(\$_etype92, \$_size89);
-          for (my $_i93 = 0; $_i93 < $_size89; ++$_i93)
+          my $_etype74 = 0;
+          $xfer += $input->readListBegin(\$_etype74, \$_size71);
+          for (my $_i75 = 0; $_i75 < $_size71; ++$_i75)
           {
-            my $elem94 = undef;
-            $xfer += $input->readI32(\$elem94);
-            push(@{$self->{shardIndexes}},$elem94);
+            my $elem76 = undef;
+            $xfer += $input->readI32(\$elem76);
+            push(@{$self->{shardIndexes}},$elem76);
           }
           $xfer += $input->readListEnd();
         }
@@ -2149,49 +1619,54 @@ sub write {
   my ($self, $output) = @_;
   my $xfer   = 0;
   $xfer += $output->writeStructBegin('QueryArgs');
+  if (defined $self->{id}) {
+    $xfer += $output->writeFieldBegin('id', TType::I64, 1);
+    $xfer += $output->writeI64($self->{id});
+    $xfer += $output->writeFieldEnd();
+  }
   if (defined $self->{after}) {
-    $xfer += $output->writeFieldBegin('after', TType::STRUCT, 1);
+    $xfer += $output->writeFieldBegin('after', TType::STRUCT, 2);
     $xfer += $self->{after}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{query}) {
-    $xfer += $output->writeFieldBegin('query', TType::STRING, 2);
+    $xfer += $output->writeFieldBegin('query', TType::STRING, 3);
     $xfer += $output->writeString($self->{query});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{filter}) {
-    $xfer += $output->writeFieldBegin('filter', TType::STRING, 3);
+    $xfer += $output->writeFieldBegin('filter', TType::STRING, 4);
     $xfer += $output->writeString($self->{filter});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{numberToFetch}) {
-    $xfer += $output->writeFieldBegin('numberToFetch', TType::I32, 4);
+    $xfer += $output->writeFieldBegin('numberToFetch', TType::I32, 5);
     $xfer += $output->writeI32($self->{numberToFetch});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{sort}) {
-    $xfer += $output->writeFieldBegin('sort', TType::STRUCT, 5);
+    $xfer += $output->writeFieldBegin('sort', TType::STRUCT, 6);
     $xfer += $self->{sort}->write($output);
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{doDocScores}) {
-    $xfer += $output->writeFieldBegin('doDocScores', TType::BOOL, 6);
+    $xfer += $output->writeFieldBegin('doDocScores', TType::BOOL, 7);
     $xfer += $output->writeBool($self->{doDocScores});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{doMaxScore}) {
-    $xfer += $output->writeFieldBegin('doMaxScore', TType::BOOL, 7);
+    $xfer += $output->writeFieldBegin('doMaxScore', TType::BOOL, 8);
     $xfer += $output->writeBool($self->{doMaxScore});
     $xfer += $output->writeFieldEnd();
   }
   if (defined $self->{shardIndexes}) {
-    $xfer += $output->writeFieldBegin('shardIndexes', TType::LIST, 8);
+    $xfer += $output->writeFieldBegin('shardIndexes', TType::LIST, 9);
     {
       $xfer += $output->writeListBegin(TType::I32, scalar(@{$self->{shardIndexes}}));
       {
-        foreach my $iter95 (@{$self->{shardIndexes}}) 
+        foreach my $iter77 (@{$self->{shardIndexes}}) 
         {
-          $xfer += $output->writeI32($iter95);
+          $xfer += $output->writeI32($iter77);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2269,16 +1744,16 @@ sub read {
       last; };
       /^3$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size96 = 0;
+          my $_size78 = 0;
           $self->{scoreDocs} = [];
-          my $_etype99 = 0;
-          $xfer += $input->readListBegin(\$_etype99, \$_size96);
-          for (my $_i100 = 0; $_i100 < $_size96; ++$_i100)
+          my $_etype81 = 0;
+          $xfer += $input->readListBegin(\$_etype81, \$_size78);
+          for (my $_i82 = 0; $_i82 < $_size78; ++$_i82)
           {
-            my $elem101 = undef;
-            $elem101 = new Blur::ScoreDoc();
-            $xfer += $elem101->read($input);
-            push(@{$self->{scoreDocs}},$elem101);
+            my $elem83 = undef;
+            $elem83 = new Blur::ScoreDoc();
+            $xfer += $elem83->read($input);
+            push(@{$self->{scoreDocs}},$elem83);
           }
           $xfer += $input->readListEnd();
         }
@@ -2294,16 +1769,16 @@ sub read {
       last; };
       /^5$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size102 = 0;
+          my $_size84 = 0;
           $self->{fields} = [];
-          my $_etype105 = 0;
-          $xfer += $input->readListBegin(\$_etype105, \$_size102);
-          for (my $_i106 = 0; $_i106 < $_size102; ++$_i106)
+          my $_etype87 = 0;
+          $xfer += $input->readListBegin(\$_etype87, \$_size84);
+          for (my $_i88 = 0; $_i88 < $_size84; ++$_i88)
           {
-            my $elem107 = undef;
-            $elem107 = new Blur::SortField();
-            $xfer += $elem107->read($input);
-            push(@{$self->{fields}},$elem107);
+            my $elem89 = undef;
+            $elem89 = new Blur::SortField();
+            $xfer += $elem89->read($input);
+            push(@{$self->{fields}},$elem89);
           }
           $xfer += $input->readListEnd();
         }
@@ -2338,9 +1813,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{scoreDocs}}));
       {
-        foreach my $iter108 (@{$self->{scoreDocs}}) 
+        foreach my $iter90 (@{$self->{scoreDocs}}) 
         {
-          $xfer += ${iter108}->write($output);
+          $xfer += ${iter90}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2357,9 +1832,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{fields}}));
       {
-        foreach my $iter109 (@{$self->{fields}}) 
+        foreach my $iter91 (@{$self->{fields}}) 
         {
-          $xfer += ${iter109}->write($output);
+          $xfer += ${iter91}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2518,16 +1993,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size110 = 0;
+          my $_size92 = 0;
           $self->{fields} = [];
-          my $_etype113 = 0;
-          $xfer += $input->readListBegin(\$_etype113, \$_size110);
-          for (my $_i114 = 0; $_i114 < $_size110; ++$_i114)
+          my $_etype95 = 0;
+          $xfer += $input->readListBegin(\$_etype95, \$_size92);
+          for (my $_i96 = 0; $_i96 < $_size92; ++$_i96)
           {
-            my $elem115 = undef;
-            $elem115 = new Blur::Field();
-            $xfer += $elem115->read($input);
-            push(@{$self->{fields}},$elem115);
+            my $elem97 = undef;
+            $elem97 = new Blur::Field();
+            $xfer += $elem97->read($input);
+            push(@{$self->{fields}},$elem97);
           }
           $xfer += $input->readListEnd();
         }
@@ -2552,9 +2027,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{fields}}));
       {
-        foreach my $iter116 (@{$self->{fields}}) 
+        foreach my $iter98 (@{$self->{fields}}) 
         {
-          $xfer += ${iter116}->write($output);
+          $xfer += ${iter98}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2655,8 +2130,8 @@ sub new {
   my $vals      = shift || {};
   $self->{table} = undef;
   $self->{shardIndex} = undef;
-  $self->{waitToBeVisible} = undef;
-  $self->{writeAheadLog} = undef;
+  $self->{waitToBeVisible} = 0;
+  $self->{writeAheadLog} = 1;
   if (UNIVERSAL::isa($vals,'HASH')) {
     if (defined $vals->{table}) {
       $self->{table} = $vals->{table};
@@ -2803,16 +2278,16 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size117 = 0;
+          my $_size99 = 0;
           $self->{documents} = [];
-          my $_etype120 = 0;
-          $xfer += $input->readListBegin(\$_etype120, \$_size117);
-          for (my $_i121 = 0; $_i121 < $_size117; ++$_i121)
+          my $_etype102 = 0;
+          $xfer += $input->readListBegin(\$_etype102, \$_size99);
+          for (my $_i103 = 0; $_i103 < $_size99; ++$_i103)
           {
-            my $elem122 = undef;
-            $elem122 = new Blur::Document();
-            $xfer += $elem122->read($input);
-            push(@{$self->{documents}},$elem122);
+            my $elem104 = undef;
+            $elem104 = new Blur::Document();
+            $xfer += $elem104->read($input);
+            push(@{$self->{documents}},$elem104);
           }
           $xfer += $input->readListEnd();
         }
@@ -2842,9 +2317,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{documents}}));
       {
-        foreach my $iter123 (@{$self->{documents}}) 
+        foreach my $iter105 (@{$self->{documents}}) 
         {
-          $xfer += ${iter123}->write($output);
+          $xfer += ${iter105}->write($output);
         }
       }
       $xfer += $output->writeListEnd();


Mime
View raw message