rethinkdb 1.2.0.1

data/lib/protob_compiler.rb

@@ -0,0 +1,137 @@
+# Copyright 2010-2012 RethinkDB, all rights reserved.
+module RethinkDB
+  module RQL_Protob_Mixin
+    include P_Mixin
+    @@token = 0 # We need a new token every time we compile a query
+    @@backtrace = []
+
+    # Right now the only special case is :compare, but in general we might have
+    # terms that don't follow the conventions and we need a place to store that.
+    def handle_special_cases(message, query_type, query_args)
+      #PP.pp ["special_case", message, query_type, query_args]
+      case query_type
+      when :compare then
+        message.comparison = enum_type(Builtin::Comparison, *query_args)
+        throw :unknown_comparator_error if not message.comparison
+        return true
+      else return false
+      end
+    end
+
+################################################################################
+    # I apologize for the code after this.  I was originally doing something
+    # clever to generate the S-expressions, so they don't always match the
+    # protobufs perfectly, and the complexity necessary to handle that got
+    # pushed down into protobuf compilation.  Later the cleverness went away,
+    # but I left the code below intact rather than refactoring for two reasons:
+    #   1) It's fragile and took about a day to get right, so refactoring it
+    #      probably isn't free.
+    #   2) We are probably going to have to change protobuf implementations for
+    #      speed reasons anyway, at which point this will have to be rewritten,
+    #      and rewriting it twice doesn't make sense
+################################################################################
+
+    # Compile an RQL query into a protobuf.
+    def comp(message_class, args, repeating=false)
+      # H4x to make the backtraces print right until we fix the protobuf.
+      message_class = S.rewrite(message_class);
+      #PP.pp(["A", message_class, args, repeating]) #DEBUG
+
+      # Handle special cases of arguments:
+      #   * When we're compiling a repeating term, in which case we want to
+      #     compile the elements of [args] rather than [args] itself.
+      #   * Objects, which correspond to optional argument specifications.
+      #   * Empty arguments
+      return args.map {|arg| comp(message_class, arg)} if repeating
+      args = args[0] if args.class == Array and args[0].class == Hash
+      raise TypeError,"Can't build #{message_class} from #{args.inspect}." if args == []
+
+      # Handle terminal parts of the protobuf, where we have to actually pack values.
+      if message_class.kind_of? Symbol
+        # It's easier for the user if we allow both atoms and 1-element lists
+        args = [args] if args.class != Array
+        if args.length != 1
+        then raise TypeError,"Can't build #{message_class} from #{args.inspect}." end
+        # Coercing symbols into strings makes our attribute notation more consistent
+        args[0] = args[0].to_s if args[0].class == Symbol
+        return args[0]
+      end
+
+      # Handle nonterminal parts of the protobuf, where we have to descend
+      message = message_class.new
+      if (message_type_class = C.class_types[message_class])
+        query_type = S.rewrite(args[0]) # Our first argument is the type of our variant.
+        message.type = enum_type(message_type_class, query_type)
+        raise TypeError,"No type '#{query_type}' for '#{message_class}'."if !message.type
+
+        if args.length == 1 # Our variant takes no arguments of its own.
+          return message
+        else # Compile our variant's arguments.
+          query_args = args[1..-1]
+          query_args = [query_args] if C.trampolines.include? query_type
+          return message if handle_special_cases(message, query_type, query_args)
+
+          # The general, non-special case.
+          query_type = C.query_rewrites[query_type] || query_type
+          field_metadata = message_class.fields.select{|x,y| y.name==query_type}.to_a[0]
+          if not field_metadata
+          then raise ArgumentError,"No field '#{query_type}' in '#{message_class}'." end
+          field = field_metadata[1]
+          message_set(message, query_type,
+                      comp(field.type, query_args,field.rule==:repeated))
+        end
+      # Handle cases where we aren't constructing a toplevel variant type.
+      elsif args.class == Array
+        # Handle the case where we're constructinga the fields in order.
+        args = args.map{|x| x == nil ? RQL.expr(x) : x}
+        fields = message.fields.sort_by {|kv| kv[0]}
+        fields.zip(args).each {|_params|;field = _params[0][1];arg = _params[1]
+          if arg == S.skip
+            if field.rule != :optional
+              raise RuntimeError, "Cannot skip non-optional rule."
+            end
+          else
+            message_set(message, field.name,
+                        comp(field.type, arg, field.rule==:repeated)) if arg != nil
+          end
+        }
+      else
+        # Handle the case where the user provided neither an Array nor a Hash,
+        # in which case they probably provided an Atom that we should treat as a
+        # single argument (allowing this makes the interface cleaner).
+        message = comp(message_class, [args], repeating)
+      end
+      return message
+    rescue => e # Add our own, semantic backtrace to exceptions
+      new_msg = repeating ? e.message :
+        e.message + "\n...when compiling #{message_class} with:\n#{args.pretty_inspect}"
+      raise e.class, new_msg
+    end
+
+    def handle_special_query_cases(sexp)
+      if C.nonatomic_variants.include?(sexp[0])
+        sexp[0] = sexp[0].to_s.split('_')[0].to_sym
+        res = query(sexp)
+        res.write_query.atomic = false
+        return res
+      end
+      return nil
+    end
+
+    # Construct a protobuf query from an RQL query by inferring the query type.
+    def query(sexp)
+      raise TypeError, "Cannot build query from #{sexp.inspect}" if sexp.class != Array
+      if (m = handle_special_query_cases(sexp))
+      then q = m
+      elsif enum_type(WriteQuery::WriteQueryType, S.rewrite(sexp[0]))
+      then q = comp(Query, [:write, *sexp])
+      elsif enum_type(MetaQuery::MetaQueryType, sexp[0])
+      then q = comp(Query, [:meta, *sexp])
+      else q = comp(Query, [:read, sexp])
+      end
+      q.token = (@@token += 1)
+      return q
+    end
+  end
+  module RQL_Protob; extend RQL_Protob_Mixin; end
+end

data/lib/query.rb

@@ -0,0 +1,111 @@
+# Copyright 2010-2012 RethinkDB, all rights reserved.
+module RethinkDB
+  # An RQL query that can be sent to the RethinkDB cluster.  This class contains
+  # only functions that work for any type of query.  Queries are either
+  # constructed by methods in the RQL module, or by invoking the instance
+  # methods of a query on other queries.
+  class RQL_Query
+    def boolop? # :nodoc:
+      false
+    end
+    # Run the invoking query using the most recently opened connection.  See
+    # Connection#run for more details.
+    def run(*args)
+      Connection.last_connection.send(:run, self, *args)
+    end
+
+    def set_body(val, context=nil) # :nodoc:
+      @context = context || caller
+      @body = val
+    end
+
+    def initialize(init_body, context=nil) # :nodoc:
+      set_body(init_body, context)
+    end
+
+    def ==(rhs) # :nodoc:
+      raise ArgumentError,"
+      Cannot use inline ==/!= with RQL queries, use .eq() instead if
+      you want a query that does equality comparison.
+
+      If you need to see whether two queries are the same, compare
+      their S-expression representations like: `query1.sexp ==
+      query2.sexp`."
+    end
+
+    # Return the S-expression representation of a query.  Used for
+    # equality comparison and advanced debugging.
+    def sexp
+      S.clean_lst @body
+    end
+    attr_accessor :body, :marked, :context
+
+    # Compile into either a protobuf class or a query.
+    def as _class # :nodoc:
+      RQL_Protob.comp(_class, sexp)
+    end
+    def query(map={S.conn_outdated => false}) # :nodoc:
+      RQL_Protob.query(S.replace(sexp, map))
+    end
+
+    def print_backtrace(bt) # :nodoc:
+      #PP.pp [bt, bt.map{|x| BT.expand x}.flatten, sexp]
+      begin
+        BT.with_marked_error(self, bt) {
+          query = "Query: #{inspect}\n       #{BT.with_highlight {inspect}}"
+          line = "Line: #{BT.line || "Unknown"}"
+          line + "\n" + query
+        }
+      rescue Exception => e
+        PP.pp [bt, e] if $DEBUG
+        "<Internal error in query pretty printer.>"
+      end
+    end
+
+    def pprint # :nodoc:
+      return @body.inspect if @body.class != Array
+      return "" if @body == []
+      case @body[0]
+      when :call then
+        if @body[2].length == 1
+          @body[2][0].inspect + "." + RQL_Query.new(@body[1],@context).inspect
+        else
+          func = @body[1][0].to_s
+          func_args = @body[1][1..-1].map{|x| x.inspect}
+          call_args = @body[2].map{|x| x.inspect}
+          func + "(" + (func_args + call_args).join(", ") + ")"
+        end
+      else
+        func = @body[0].to_s
+        func_args = @body[1..-1].map{|x| x.inspect}
+        func + "(" + func_args.join(", ") + ")"
+      end
+    end
+
+    def real_inspect(args) # :nodoc:
+      str = args[:str] || pprint
+      (BT.highlight and @marked) ? "\000"*str.length : str
+    end
+
+    def inspect # :nodoc:
+      real_inspect({})
+    end
+
+    # Dereference aliases (see utils.rb) and possibly dispatch to RQL
+    # (because the caller may be trying to use the more convenient
+    # inline version of an RQL function).
+    def method_missing(m, *args, &block) # :nodoc:
+      if (m2 = C.method_aliases[m]); then return self.send(m2, *args, &block); end
+      if RQL.methods.map{|x| x.to_sym}.include?(m)
+        return RQL.send(m, *[self, *args], &block)
+      end
+      super(m, *args, &block)
+    end
+  end
+end
+
+load 'tables.rb'
+load 'sequence.rb'
+load 'streams.rb'
+load 'jsons.rb'
+load 'writes.rb'

data/lib/query_language.pb.rb

@@ -0,0 +1,687 @@
+### Generated by rprotoc. DO NOT EDIT!
+### <proto file: ../../src/rdb_protocol/query_language.proto>
+# message TableRef {
+#     required string db_name    = 1;
+#     required string table_name = 2;
+#     optional bool use_outdated  = 3 [default = false]; //Use and outdated version of this table
+# };
+# 
+# message VarTermTuple {
+#     required string var = 1;
+#     required Term term = 2;
+# };
+# 
+# message Term {
+#     enum TermType {
+#         JSON_NULL = 0; //can't use just "NULL" here we get in trouble
+#         VAR = 1;
+#         LET = 2;
+#         CALL = 3;
+#         IF = 4;
+#         ERROR = 5;
+#         NUMBER = 6;
+#         STRING = 7;
+#         JSON = 8;
+#         BOOL = 9;
+#         ARRAY = 10;
+#         OBJECT = 11;
+#         GETBYKEY = 12;
+#         TABLE = 13;
+#         JAVASCRIPT = 14;
+#         IMPLICIT_VAR = 15;
+#     };
+# 
+#     required TermType type = 1;
+# 
+#     optional string var = 2;
+# 
+#     message Let {
+#         repeated VarTermTuple binds = 1;
+#         required Term expr = 2;
+#     };
+# 
+#     optional Let let = 3;
+# 
+#     message Call {
+#         required Builtin builtin = 1;
+#         repeated Term args = 2;
+#     };
+# 
+#     optional Call call = 4;
+# 
+#     message If {
+#         required Term test = 1;
+#         required Term true_branch = 2;
+#         required Term false_branch = 3;
+#     };
+# 
+#     optional If if_ = 5;
+# 
+#     optional string error = 6;
+# 
+#     optional double number = 7;
+# 
+#     optional string valuestring = 8;
+# 
+#     optional string jsonstring = 9;
+# 
+#     optional bool valuebool = 10;
+# 
+#     repeated Term array = 11;
+# 
+#     repeated VarTermTuple object = 12;
+#     message GetByKey {
+#         required TableRef table_ref = 1;
+#         required string attrname = 2;
+#         required Term key = 3;
+#     };
+# 
+#     optional GetByKey get_by_key = 14;
+# 
+#     message Table {
+#         required TableRef table_ref = 1;
+#     };
+# 
+#     optional Table table = 15;
+# 
+#     optional string javascript = 16;
+# 
+#     // reserved for RethinkDB internal use.
+#     extensions 1000 to 1099;
+# };
+# 
+# message Builtin {
+#     enum BuiltinType {
+#         NOT = 1;
+#         GETATTR = 2;
+#         IMPLICIT_GETATTR = 3;
+#         HASATTR = 4;
+#         IMPLICIT_HASATTR = 5;
+#         PICKATTRS = 6;
+#         IMPLICIT_PICKATTRS = 7;
+#         MAPMERGE = 8;
+#         ARRAYAPPEND = 9;
+#         SLICE = 11;         // slice(thing_to_slice, None/left extent, None/right extent)
+#         ADD = 14;
+#         SUBTRACT = 15;
+#         MULTIPLY = 16;
+#         DIVIDE = 17;
+#         MODULO = 18;
+#         COMPARE = 19;
+#         FILTER = 20;
+#         MAP = 21;          // operates over streams
+#         CONCATMAP = 22;
+#         ORDERBY = 23;
+#         DISTINCT = 24;
+#         LENGTH = 26;
+#         UNION = 27;
+#         NTH = 28;
+#         STREAMTOARRAY = 29;
+#         ARRAYTOSTREAM = 30;
+#         REDUCE = 31;
+#         GROUPEDMAPREDUCE = 32;
+#         ANY = 35;
+#         ALL = 36;
+#         RANGE = 37;
+#         IMPLICIT_WITHOUT = 38;
+#         WITHOUT = 39;
+#     };
+# 
+#     enum Comparison {
+#         EQ = 1;
+#         NE = 2;
+#         LT = 3;
+#         LE = 4;
+#         GT = 5;
+#         GE = 6;
+#     };
+# 
+#     required BuiltinType type = 1;
+# 
+#     optional string attr = 2; //used if type is GETATTR of HASATTR
+# 
+#     repeated string attrs = 3; //used if type is PICKATTRS or WITHOUT
+# 
+#     optional Comparison comparison = 4;
+# 
+#     message Filter {
+#         required Predicate predicate = 1;
+#     };
+# 
+#     optional Filter filter = 5;
+# 
+#     message Map {
+#         required Mapping mapping = 1;
+#     };
+# 
+#     optional Map map = 6;
+# 
+#     message ConcatMap {
+#         required Mapping mapping = 1;
+#     };
+# 
+#     optional ConcatMap concat_map = 7;
+# 
+#     message OrderBy {
+#         required string attr = 1;
+#         optional bool ascending = 2 [default = true];
+#     };
+# 
+#     repeated OrderBy order_by = 8;
+# 
+#     optional Reduction reduce = 9;
+# 
+#     message GroupedMapReduce {
+#         required Mapping group_mapping = 1;
+#         required Mapping value_mapping = 2;
+#         required Reduction reduction = 3;
+#     };
+# 
+#     optional GroupedMapReduce grouped_map_reduce = 10;
+# 
+#     message Range {
+#         required string attrname = 1;
+#         optional Term lowerbound = 2;
+#         optional Term upperbound = 3;
+#     };
+# 
+#     optional Range range = 11;
+# };
+# 
+# message Reduction {
+#     required Term base = 1;
+#     required string var1 = 2;
+#     required string var2 = 3;
+#     required Term body = 4;
+# };
+# 
+# message Mapping {
+#     required string arg = 1;
+#     required Term body = 2;
+#     extensions 1000 to 1099;
+# };
+# 
+# message Predicate {
+#     required string arg = 1;
+#     required Term body = 2;
+# };
+# 
+# message ReadQuery {
+#     required Term term = 1;
+#     optional int64 max_chunk_size = 2; //may be 0 for unlimited
+#     optional int64 max_age = 3;
+# 
+#     // reserved for RethinkDB internal use.
+#     extensions 1000 to 1099;
+# };
+# 
+# message WriteQuery {
+#     enum WriteQueryType {
+#         UPDATE = 1;
+#         DELETE = 2;
+#         MUTATE = 3;
+#         INSERT = 4;
+#         FOREACH = 6;
+#         POINTUPDATE = 7;
+#         POINTDELETE = 8;
+#         POINTMUTATE = 9;
+#     };
+# 
+#     required WriteQueryType type = 1;
+#     optional bool atomic = 11 [default = true];
+# 
+#     message Update {
+#         required Term view = 1;
+#         required Mapping mapping = 2;
+#     };
+# 
+#     optional Update update = 2;
+# 
+#     message Delete {
+#         required Term view = 1;
+#     };
+# 
+#     optional Delete delete = 3;
+# 
+#     message Mutate {
+#         required Term view = 1;
+#         required Mapping mapping = 2;
+#     };
+# 
+#     optional Mutate mutate = 4;
+# 
+#     message Insert {
+#         required TableRef table_ref = 1;
+#         repeated Term terms = 2;
+#         optional bool overwrite = 3 [default = false];
+#     };
+# 
+#     optional Insert insert = 5;
+# 
+#     message ForEach {
+#         required Term stream = 1;
+#         required string var = 2;
+#         repeated WriteQuery queries = 3;
+#     };
+# 
+#     optional ForEach for_each = 7;
+# 
+#     message PointUpdate {
+#         required TableRef table_ref = 1;
+#         required string attrname = 2;
+#         required Term key = 3;
+#         required Mapping mapping = 4;
+#     };
+# 
+#     optional PointUpdate point_update = 8;
+# 
+#     message PointDelete {
+#         required TableRef table_ref = 1;
+#         required string attrname = 2;
+#         required Term key = 3;
+#     };
+# 
+#     optional PointDelete point_delete = 9;
+# 
+#     message PointMutate {
+#         required TableRef table_ref = 1;
+#         required string attrname = 2;
+#         required Term key = 3;
+#         required Mapping mapping = 4;
+#     };
+# 
+#     optional PointMutate point_mutate = 10;
+# };
+# 
+# message MetaQuery {
+#     enum MetaQueryType {
+#         CREATE_DB     = 1; //db_name
+#         DROP_DB       = 2; //db_name
+#         LIST_DBS      = 3;
+# 
+#         CREATE_TABLE  = 4;
+#         DROP_TABLE    = 5;
+#         LIST_TABLES   = 6; //db_name
+#     };
+#     required MetaQueryType type = 1;
+#     optional string db_name = 2;
+# 
+#     message CreateTable {
+#         optional string datacenter  = 1;
+#         required TableRef table_ref = 3;
+#         optional string primary_key = 4 [default = "id"];
+#         optional int64 cache_size = 5 [default = 1073741824]; //notice that's a gigabyte right there.
+#     }
+#     optional CreateTable create_table = 3;
+# 
+#     optional TableRef drop_table = 4;
+# };
+# 
+# message Query {
+#     enum QueryType {
+#         READ       = 1; //Begin reading from a stream (and possibly finish if it's short)
+#         WRITE      = 2; //Write to a table (currently does not create a stream)
+#         CONTINUE   = 3; //Continue reading from a stream
+#         STOP       = 4; //Stop reading from a stream and release its resources
+#         META       = 5; //Meta operations that create, drop, or list databases/tables
+#     }
+# 
+#     required QueryType type = 1;
+# 
+#     required int64 token = 2;
+# 
+#     optional ReadQuery read_query = 3;
+#     optional WriteQuery write_query = 4;
+#     optional MetaQuery meta_query = 5;
+# }
+# 
+# message Response {
+#     enum StatusCode {
+#         SUCCESS_EMPTY = 0;
+#         SUCCESS_JSON = 1;
+#         SUCCESS_PARTIAL = 2; //need to send CONTINUE repeatedly until SUCCESS_STREAM
+#         SUCCESS_STREAM = 3;
+# 
+#         BROKEN_CLIENT = 101; // Means the client is misbehaving, not the user
+#         BAD_QUERY = 102;
+#         RUNTIME_ERROR = 103;
+#     }
+#     required StatusCode status_code = 1;
+# 
+#     required int64 token = 2;
+# 
+#     repeated string response = 3;
+# 
+#     optional string error_message = 4;
+# 
+#     message Backtrace {
+#         repeated string frame = 1;
+#     };
+# 
+#     optional Backtrace backtrace = 5;
+# }
+
+require 'protobuf/message/message'
+require 'protobuf/message/enum'
+require 'protobuf/message/service'
+require 'protobuf/message/extend'
+
+class TableRef < ::Protobuf::Message
+  defined_in __FILE__
+  required :string, :db_name, 1
+  required :string, :table_name, 2
+  optional :bool, :use_outdated, 3, :default => false
+end
+class VarTermTuple < ::Protobuf::Message
+  defined_in __FILE__
+  required :string, :var, 1
+  required :Term, :term, 2
+end
+class Term < ::Protobuf::Message
+  defined_in __FILE__
+  class TermType < ::Protobuf::Enum
+    defined_in __FILE__
+    JSON_NULL = value(:JSON_NULL, 0)
+    VAR = value(:VAR, 1)
+    LET = value(:LET, 2)
+    CALL = value(:CALL, 3)
+    IF = value(:IF, 4)
+    ERROR = value(:ERROR, 5)
+    NUMBER = value(:NUMBER, 6)
+    STRING = value(:STRING, 7)
+    JSON = value(:JSON, 8)
+    BOOL = value(:BOOL, 9)
+    ARRAY = value(:ARRAY, 10)
+    OBJECT = value(:OBJECT, 11)
+    GETBYKEY = value(:GETBYKEY, 12)
+    TABLE = value(:TABLE, 13)
+    JAVASCRIPT = value(:JAVASCRIPT, 14)
+    IMPLICIT_VAR = value(:IMPLICIT_VAR, 15)
+  end
+  required :TermType, :type, 1
+  optional :string, :var, 2
+  class Let < ::Protobuf::Message
+    defined_in __FILE__
+    repeated :VarTermTuple, :binds, 1
+    required :Term, :expr, 2
+  end
+  optional :Let, :let, 3
+  class Call < ::Protobuf::Message
+    defined_in __FILE__
+    required :Builtin, :builtin, 1
+    repeated :Term, :args, 2
+  end
+  optional :Call, :call, 4
+  class If < ::Protobuf::Message
+    defined_in __FILE__
+    required :Term, :test, 1
+    required :Term, :true_branch, 2
+    required :Term, :false_branch, 3
+  end
+  optional :If, :if_, 5
+  optional :string, :error, 6
+  optional :double, :number, 7
+  optional :string, :valuestring, 8
+  optional :string, :jsonstring, 9
+  optional :bool, :valuebool, 10
+  repeated :Term, :array, 11
+  repeated :VarTermTuple, :object, 12
+  class GetByKey < ::Protobuf::Message
+    defined_in __FILE__
+    required :TableRef, :table_ref, 1
+    required :string, :attrname, 2
+    required :Term, :key, 3
+  end
+  optional :GetByKey, :get_by_key, 14
+  class Table < ::Protobuf::Message
+    defined_in __FILE__
+    required :TableRef, :table_ref, 1
+  end
+  optional :Table, :table, 15
+  optional :string, :javascript, 16
+  extensions 1000..1099
+end
+class Builtin < ::Protobuf::Message
+  defined_in __FILE__
+  class BuiltinType < ::Protobuf::Enum
+    defined_in __FILE__
+    NOT = value(:NOT, 1)
+    GETATTR = value(:GETATTR, 2)
+    IMPLICIT_GETATTR = value(:IMPLICIT_GETATTR, 3)
+    HASATTR = value(:HASATTR, 4)
+    IMPLICIT_HASATTR = value(:IMPLICIT_HASATTR, 5)
+    PICKATTRS = value(:PICKATTRS, 6)
+    IMPLICIT_PICKATTRS = value(:IMPLICIT_PICKATTRS, 7)
+    MAPMERGE = value(:MAPMERGE, 8)
+    ARRAYAPPEND = value(:ARRAYAPPEND, 9)
+    SLICE = value(:SLICE, 11)
+    ADD = value(:ADD, 14)
+    SUBTRACT = value(:SUBTRACT, 15)
+    MULTIPLY = value(:MULTIPLY, 16)
+    DIVIDE = value(:DIVIDE, 17)
+    MODULO = value(:MODULO, 18)
+    COMPARE = value(:COMPARE, 19)
+    FILTER = value(:FILTER, 20)
+    MAP = value(:MAP, 21)
+    CONCATMAP = value(:CONCATMAP, 22)
+    ORDERBY = value(:ORDERBY, 23)
+    DISTINCT = value(:DISTINCT, 24)
+    LENGTH = value(:LENGTH, 26)
+    UNION = value(:UNION, 27)
+    NTH = value(:NTH, 28)
+    STREAMTOARRAY = value(:STREAMTOARRAY, 29)
+    ARRAYTOSTREAM = value(:ARRAYTOSTREAM, 30)
+    REDUCE = value(:REDUCE, 31)
+    GROUPEDMAPREDUCE = value(:GROUPEDMAPREDUCE, 32)
+    ANY = value(:ANY, 35)
+    ALL = value(:ALL, 36)
+    RANGE = value(:RANGE, 37)
+    IMPLICIT_WITHOUT = value(:IMPLICIT_WITHOUT, 38)
+    WITHOUT = value(:WITHOUT, 39)
+  end
+  class Comparison < ::Protobuf::Enum
+    defined_in __FILE__
+    EQ = value(:EQ, 1)
+    NE = value(:NE, 2)
+    LT = value(:LT, 3)
+    LE = value(:LE, 4)
+    GT = value(:GT, 5)
+    GE = value(:GE, 6)
+  end
+  required :BuiltinType, :type, 1
+  optional :string, :attr, 2
+  repeated :string, :attrs, 3
+  optional :Comparison, :comparison, 4
+  class Filter < ::Protobuf::Message
+    defined_in __FILE__
+    required :Predicate, :predicate, 1
+  end
+  optional :Filter, :filter, 5
+  class Map < ::Protobuf::Message
+    defined_in __FILE__
+    required :Mapping, :mapping, 1
+  end
+  optional :Map, :map, 6
+  class ConcatMap < ::Protobuf::Message
+    defined_in __FILE__
+    required :Mapping, :mapping, 1
+  end
+  optional :ConcatMap, :concat_map, 7
+  class OrderBy < ::Protobuf::Message
+    defined_in __FILE__
+    required :string, :attr, 1
+    optional :bool, :ascending, 2, :default => true
+  end
+  repeated :OrderBy, :order_by, 8
+  optional :Reduction, :reduce, 9
+  class GroupedMapReduce < ::Protobuf::Message
+    defined_in __FILE__
+    required :Mapping, :group_mapping, 1
+    required :Mapping, :value_mapping, 2
+    required :Reduction, :reduction, 3
+  end
+  optional :GroupedMapReduce, :grouped_map_reduce, 10
+  class Range < ::Protobuf::Message
+    defined_in __FILE__
+    required :string, :attrname, 1
+    optional :Term, :lowerbound, 2
+    optional :Term, :upperbound, 3
+  end
+  optional :Range, :range, 11
+end
+class Reduction < ::Protobuf::Message
+  defined_in __FILE__
+  required :Term, :base, 1
+  required :string, :var1, 2
+  required :string, :var2, 3
+  required :Term, :body, 4
+end
+class Mapping < ::Protobuf::Message
+  defined_in __FILE__
+  required :string, :arg, 1
+  required :Term, :body, 2
+  extensions 1000..1099
+end
+class Predicate < ::Protobuf::Message
+  defined_in __FILE__
+  required :string, :arg, 1
+  required :Term, :body, 2
+end
+class ReadQuery < ::Protobuf::Message
+  defined_in __FILE__
+  required :Term, :term, 1
+  optional :int64, :max_chunk_size, 2
+  optional :int64, :max_age, 3
+  extensions 1000..1099
+end
+class WriteQuery < ::Protobuf::Message
+  defined_in __FILE__
+  class WriteQueryType < ::Protobuf::Enum
+    defined_in __FILE__
+    UPDATE = value(:UPDATE, 1)
+    DELETE = value(:DELETE, 2)
+    MUTATE = value(:MUTATE, 3)
+    INSERT = value(:INSERT, 4)
+    FOREACH = value(:FOREACH, 6)
+    POINTUPDATE = value(:POINTUPDATE, 7)
+    POINTDELETE = value(:POINTDELETE, 8)
+    POINTMUTATE = value(:POINTMUTATE, 9)
+  end
+  required :WriteQueryType, :type, 1
+  optional :bool, :atomic, 11, :default => true
+  class Update < ::Protobuf::Message
+    defined_in __FILE__
+    required :Term, :view, 1
+    required :Mapping, :mapping, 2
+  end
+  optional :Update, :update, 2
+  class Delete < ::Protobuf::Message
+    defined_in __FILE__
+    required :Term, :view, 1
+  end
+  optional :Delete, :delete, 3
+  class Mutate < ::Protobuf::Message
+    defined_in __FILE__
+    required :Term, :view, 1
+    required :Mapping, :mapping, 2
+  end
+  optional :Mutate, :mutate, 4
+  class Insert < ::Protobuf::Message
+    defined_in __FILE__
+    required :TableRef, :table_ref, 1
+    repeated :Term, :terms, 2
+    optional :bool, :overwrite, 3, :default => false
+  end
+  optional :Insert, :insert, 5
+  class ForEach < ::Protobuf::Message
+    defined_in __FILE__
+    required :Term, :stream, 1
+    required :string, :var, 2
+    repeated :WriteQuery, :queries, 3
+  end
+  optional :ForEach, :for_each, 7
+  class PointUpdate < ::Protobuf::Message
+    defined_in __FILE__
+    required :TableRef, :table_ref, 1
+    required :string, :attrname, 2
+    required :Term, :key, 3
+    required :Mapping, :mapping, 4
+  end
+  optional :PointUpdate, :point_update, 8
+  class PointDelete < ::Protobuf::Message
+    defined_in __FILE__
+    required :TableRef, :table_ref, 1
+    required :string, :attrname, 2
+    required :Term, :key, 3
+  end
+  optional :PointDelete, :point_delete, 9
+  class PointMutate < ::Protobuf::Message
+    defined_in __FILE__
+    required :TableRef, :table_ref, 1
+    required :string, :attrname, 2
+    required :Term, :key, 3
+    required :Mapping, :mapping, 4
+  end
+  optional :PointMutate, :point_mutate, 10
+end
+class MetaQuery < ::Protobuf::Message
+  defined_in __FILE__
+  class MetaQueryType < ::Protobuf::Enum
+    defined_in __FILE__
+    CREATE_DB = value(:CREATE_DB, 1)
+    DROP_DB = value(:DROP_DB, 2)
+    LIST_DBS = value(:LIST_DBS, 3)
+    CREATE_TABLE = value(:CREATE_TABLE, 4)
+    DROP_TABLE = value(:DROP_TABLE, 5)
+    LIST_TABLES = value(:LIST_TABLES, 6)
+  end
+  required :MetaQueryType, :type, 1
+  optional :string, :db_name, 2
+  class CreateTable < ::Protobuf::Message
+    defined_in __FILE__
+    optional :string, :datacenter, 1
+    required :TableRef, :table_ref, 3
+    optional :string, :primary_key, 4, :default => "id"
+    optional :int64, :cache_size, 5, :default => 1073741824
+  end
+  optional :CreateTable, :create_table, 3
+  optional :TableRef, :drop_table, 4
+end
+class Query < ::Protobuf::Message
+  defined_in __FILE__
+  class QueryType < ::Protobuf::Enum
+    defined_in __FILE__
+    READ = value(:READ, 1)
+    WRITE = value(:WRITE, 2)
+    CONTINUE = value(:CONTINUE, 3)
+    STOP = value(:STOP, 4)
+    META = value(:META, 5)
+  end
+  required :QueryType, :type, 1
+  required :int64, :token, 2
+  optional :ReadQuery, :read_query, 3
+  optional :WriteQuery, :write_query, 4
+  optional :MetaQuery, :meta_query, 5
+end
+class Response < ::Protobuf::Message
+  defined_in __FILE__
+  class StatusCode < ::Protobuf::Enum
+    defined_in __FILE__
+    SUCCESS_EMPTY = value(:SUCCESS_EMPTY, 0)
+    SUCCESS_JSON = value(:SUCCESS_JSON, 1)
+    SUCCESS_PARTIAL = value(:SUCCESS_PARTIAL, 2)
+    SUCCESS_STREAM = value(:SUCCESS_STREAM, 3)
+    BROKEN_CLIENT = value(:BROKEN_CLIENT, 101)
+    BAD_QUERY = value(:BAD_QUERY, 102)
+    RUNTIME_ERROR = value(:RUNTIME_ERROR, 103)
+  end
+  required :StatusCode, :status_code, 1
+  required :int64, :token, 2
+  repeated :string, :response, 3
+  optional :string, :error_message, 4
+  class Backtrace < ::Protobuf::Message
+    defined_in __FILE__
+    repeated :string, :frame, 1
+  end
+  optional :Backtrace, :backtrace, 5
+end