rethinkdb 1.2.6.1 → 1.4.0.0

data/lib/exc.rb

@@ -0,0 +1,30 @@
+module RethinkDB
+  class RqlError < RuntimeError; end
+  class RqlRuntimeError < RqlError; end
+  class RqlDriverError < RqlError; end
+  class RqlCompileError < RqlError; end
+
+  # class Error < StandardError
+  #   def initialize(msg, bt)
+  #     @msg = msg
+  #     @bt = bt
+  #     @pp_query_bt = "UNIMPLEMENTED #{bt.inspect}"
+  #     super inspect
+  #   end
+  #   def inspect
+  #     "#{@msg}\n#{@pp_query_bt}"
+  #   end
+  #   attr_accessor :msg, :bt, :pp_query_bt
+  # end
+
+  # class Connection_Error < Error; end
+
+  # class Compile_Error < Error; end
+  # class Malformed_Protobuf_Error < Compile_Error; end
+  # class Malformed_Query_Error < Compile_Error; end
+
+  # class Runtime_Error < Error; end
+  # class Data_Error < Runtime_Error; end
+  # class Type_Error < Data_Error; end
+  # class Resource_Error < Runtime_Error; end
+end

data/lib/func.rb

@@ -0,0 +1,156 @@
+module RethinkDB
+  class RQL
+    @@gensym_cnt = 0
+    def new_func(&b)
+      args = (0...b.arity).map{@@gensym_cnt += 1}
+      body = b.call(*(args.map{|i| RQL.new.var i}))
+      RQL.new.func(args, body)
+    end
+
+    @@special_optargs = {
+      :replace => :non_atomic, :update => :non_atomic, :insert => :upsert
+    }
+    @@opt_off = {
+      :reduce => -1, :between => -1, :grouped_map_reduce => -1,
+      :table => -1, :table_create => -1
+    }
+    @@rewrites = {
+      :< => :lt, :<= => :le, :> => :gt, :>= => :ge,
+      :+ => :add, :- => :sub, :* => :mul, :/ => :div, :% => :mod,
+      :"|" => :any, :or => :any,
+      :"&" => :all, :and => :all,
+      :order_by => :orderby,
+      :group_by => :groupby,
+      :concat_map => :concatmap,
+      :for_each => :foreach,
+      :js => :javascript,
+      :type_of => :typeof
+    }
+    def method_missing(m, *a, &b)
+      bitop = [:"|", :"&"].include?(m) ? [m, a, b] : nil
+      if [:<, :<=, :>, :>=, :+, :-, :*, :/, :%].include?(m)
+        a.each {|arg|
+          if arg.class == RQL && arg.bitop
+            err = "Calling #{m} on result of infix bitwise operator:\n" +
+              "#{arg.inspect}.\n" +
+              "This is almost always a precedence error.\n" +
+              "Note that `a < b | b < c` <==> `a < (b | b) < c`.\n" +
+              "If you really want this behavior, use `.or` or `.and` instead."
+            raise ArgumentError, err
+          end
+        }
+      end
+
+      m = @@rewrites[m] || m
+      termtype = Term::TermType.values[m.to_s.upcase.to_sym]
+      unbound_if(!termtype, m)
+
+      if (opt_name = @@special_optargs[m])
+        a = optarg_jiggle(a, opt_name)
+        opt_offset = -1
+      end
+      if (opt_offset ||= @@opt_off[m])
+        optargs = a.delete_at(opt_offset) if a[opt_offset].class == Hash
+      end
+
+      args = (@body ? [self] : []) + a + (b ? [new_func(&b)] : [])
+
+      t = Term.new
+      t.type = termtype
+      t.args = args.map{|x| RQL.new.expr(x).to_pb}
+      t.optargs = (optargs || {}).map {|k,v|
+        ap = Term::AssocPair.new
+        ap.key = k.to_s
+        ap.val = RQL.new.expr(v).to_pb
+        ap
+      }
+      return RQL.new(t, bitop)
+    end
+
+    def group_by(*a, &b)
+      a = [self] + a if @body
+      RQL.new.method_missing(:group_by, a[0], a[1..-2], a[-1], &b)
+    end
+    def groupby(*a, &b); group_by(*a, &b); end
+
+    def optarg_jiggle(args, optarg)
+      if (ind = args.map{|x| x.class == Symbol ? x : nil}.index(optarg))
+        args << {args.delete_at(ind) => true}
+      else
+        args << {}
+      end
+      return args
+    end
+
+    def connect(*args)
+      unbound_if @body
+      Connection.new(*args)
+    end
+
+    def avg(attr)
+      unbound_if @body
+      {:AVG => attr}
+    end
+    def sum(attr)
+      unbound_if @body
+      {:SUM => attr}
+    end
+    def count(*a, &b)
+      !@body && a == [] ? {:COUNT => true} : super(*a, &b)
+    end
+
+    def reduce(*a, &b)
+      a = a[1..-2] + [{:base => a[-1]}] if a.size + (@body ? 1 : 0) == 2
+      super(*a, &b)
+    end
+
+    def grouped_map_reduce(*a, &b)
+      a << {:base => a.delete_at(-2)} if a.size >= 2 && a[-2].class != Proc
+      super(*a, &b)
+    end
+
+    def between(l=nil, r=nil)
+      super(Hash[(l ? [['left_bound', l]] : []) + (r ? [['right_bound', r]] : [])])
+    end
+
+    def -@; RQL.new.sub(0, self); end
+
+    def [](ind)
+      if ind.class == Fixnum
+        return nth(ind)
+      elsif ind.class == Symbol || ind.class == String
+        return getattr(ind)
+      elsif ind.class == Range
+        if ind.end == 0 && ind.exclude_end?
+          raise ArgumentError, "Cannot slice to an excluded end of 0."
+        end
+        return slice(ind.begin, ind.end - (ind.exclude_end? ? 1 : 0))
+      end
+      raise ArgumentError, "[] cannot handle #{ind.inspect} of type #{ind.class}."
+    end
+
+    def ==(rhs)
+      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 protobufs like: `query1.to_pb == query2.to_pb`."
+    end
+
+
+    def do(*args, &b)
+      a = (@body ? [self] : []) + args.dup
+      if a == [] && !b
+        raise RqlDriverError, "Expected 1 or more argument(s) but found 0."
+      end
+      RQL.new.funcall(*((b ? [new_func(&b)] : [a.pop]) + a))
+    end
+
+    def row
+      unbound_if @body
+      raise NoMethodError, ("Sorry, r.row is not available in the ruby driver.  " +
+                            "Use blocks instead.")
+    end
+  end
+end

data/lib/net.rb

@@ -1,34 +1,53 @@
 # Copyright 2010-2012 RethinkDB, all rights reserved.
 require 'socket'
 require 'thread'
-require 'json'
+
+# $f = File.open("fuzz_seed.rb", "w")
 
 module RethinkDB
-  module Faux_Abort # :nodoc:
-    class Abort # :nodoc:
+  module Faux_Abort
+    class Abort
+    end
+  end
+
+  class RQL
+    def self.set_default_conn c; @@default_conn = c; end
+    def run(c=@@default_conn, opts=nil)
+      # $f.puts "("+RPP::pp(@body)+"),"
+      unbound_if !@body
+      c, opts = @@default_conn, c if opts.nil? && !c.kind_of?(RethinkDB::Connection)
+      opts = {} if opts.nil?
+      opts = {opts => true} if opts.class != Hash
+      if !c
+        raise ArgumentError, "No connection specified!\n" \
+        "Use `query.run(conn)` or `conn.repl(); query.run`."
+      end
+      c.run(@body, opts)
     end
   end
-  # The result of a calling Connection#run on a query that returns a stream.
-  # This class is <b>+Enumerable+</b>.  You can find documentation on Enumerable
-  # classes at http://ruby-doc.org/core-1.9.3/Enumerable.html .
-  #
-  # <b>NOTE:</b> unlike most enumerable objects, you can only iterate over Query
-  # results once.  The results are fetched lazily from the server in chunks
-  # of 1000.  If you need to access values multiple times, use the <b>+to_a+</b>
-  # instance method to get an Array, and then work with that.
-  class Query_Results
+
+  class Cursor
+    include Enumerable
     def out_of_date # :nodoc:
       @conn.conn_id != @conn_id
     end
 
     def inspect # :nodoc:
+      preview_res = @results[0...10]
+      if (@results.size > 10 || @more)
+        preview_res << (dots = "..."; class << dots; def inspect; "..."; end; end; dots)
+      end
+      preview = preview_res.pretty_inspect[0...-1]
       state = @run ? "(exhausted)" : "(enumerable)"
       extra = out_of_date ? " (Connection #{@conn.inspect} reset!)" : ""
-      "#<RethinkDB::Query_Results:#{self.object_id} #{state}#{extra}: #{@query.inspect}>"
+      "#<RethinkDB::Cursor:#{self.object_id} #{state}#{extra}: #{RPP.pp(@msg)}" +
+        (@run ? "" : "\n#{preview}") + ">"
     end
 
-    def initialize(query, connection, token) # :nodoc:
-      @query = query
+    def initialize(results, msg, connection, token, more = true) # :nodoc:
+      @more = more
+      @results = results
+      @msg = msg
       @run = false
       @conn_id = connection.conn_id
       @conn = connection
@@ -36,187 +55,129 @@ module RethinkDB
     end
 
     def each (&block) # :nodoc:
-      raise RuntimeError, "Can only iterate over Query_Results once!" if @run
-      raise RuntimeError, "Connection has been reset!" if out_of_date
-      @conn.token_iter(@query, @token, &block)
+      raise RqlRuntimeError, "Can only iterate over Query_Results once!" if @run
       @run = true
-      return self
+      raise RqlRuntimeError, "Connection has been reset!" if out_of_date
+      while true
+        @results.each(&block)
+        return self if !@more
+        q = Query.new
+        q.type = Query::QueryType::CONTINUE
+        q.token = @token
+        res = @conn.run_internal q
+        @results = Shim.response_to_native(res, @msg)
+        if res.type == Response::ResponseType::SUCCESS_SEQUENCE
+          @more = false
+        end
+      end
     end
   end
 
-  # TODO: Make sure tokens don't overflow.
-
-  # A connection to the RethinkDB
-  # cluster.  You need to create at least one connection before you can run
-  # queries.  After creating a connection <b>+conn+</b> and constructing a
-  # query <b>+q+</b>, the following are equivalent:
-  #  conn.run(q)
-  #  q.run
-  # (This is because by default, invoking the <b>+run+</b> instance method on a
-  # query runs it on the most-recently-opened connection.)
-  #
-  # ==== Attributes
-  # * +default_db+ - The current default database (can be set with Connection#use).  Defaults to 'test'.
-  # * +conn_id+ - You probably don't care about this.  Used in some advanced situations where you care about whether a connection object has reconnected.
   class Connection
-    def inspect # :nodoc:
-      properties = "(#{@host}:#{@port}) (Default Database: '#{@default_db}')"
-      state = @listener ? "(listening)" : "(closed)"
-      "#<RethinkDB::Connection:#{self.object_id} #{properties} #{state}>"
-    end
+    def repl; RQL.set_default_conn self; end
 
-    @@last = nil
-    @@magic_number = 0xaf61ba35
+    def initialize(host='localhost', port=28015, default_db=nil)
+      begin
+        @abort_module = ::IRB
+      rescue NameError => e
+        @abort_module = Faux_Abort
+      end
+      @@last = self
+      @host = host
+      @port = port
+      @default_opts = default_db ? {:db => RQL.new.db(default_db)} : {}
+      @conn_id = 0
+      reconnect
+    end
+    attr_reader :default_db, :conn_id
 
-    def debug_socket # :nodoc:
-      @socket;
+    @@token_cnt = 0
+    def run_internal q
+      dispatch q
+      wait q.token
+    end
+    def run(msg, opts)
+      q = Query.new
+      q.type = Query::QueryType::START
+      q.query = msg
+      q.token = @@token_cnt += 1
+
+      @default_opts.merge(opts).each {|k,v|
+        ap = Query::AssocPair.new
+        ap.key = k.to_s
+        ap.val = v.to_pb
+        q.global_optargs << ap
+      }
+
+      res = run_internal q
+      if res.type == Response::ResponseType::SUCCESS_PARTIAL
+        Cursor.new(Shim.response_to_native(res, msg), msg, self, q.token, true)
+      elsif res.type == Response::ResponseType::SUCCESS_SEQUENCE
+        Cursor.new(Shim.response_to_native(res, msg), msg, self, q.token, false)
+      else
+        Shim.response_to_native(res, msg)
+      end
     end
 
-    # Reconnect to the server.  This will interrupt all queries on the
-    # server and invalidate all outstanding enumerables on the client.
-    def reconnect
-      @socket.close if @socket
-      @socket = TCPSocket.open(@host, @port)
-      @waiters = {}
-      @data = {}
-      @mutex = Mutex.new
-      @conn_id += 1
-      start_listener
-      self
+    def send packet
+      @socket.send(packet, 0)
     end
 
-    def dispatch msg # :nodoc:
+    def dispatch msg
       PP.pp msg if $DEBUG
       payload = msg.serialize_to_string
       #File.open('sexp_payloads.txt', 'a') {|f| f.write(payload.inspect+"\n")}
-      packet = [payload.length].pack('L<') + payload
-      @socket.send(packet, 0)
+      send([payload.length].pack('L<') + payload)
       return msg.token
     end
 
-    def wait token # :nodoc:
-      res = nil
-      raise RuntimeError, "Connection closed by server!" if not @listener
-      @mutex.synchronize do
-        (@waiters[token] = ConditionVariable.new).wait(@mutex) if not @data[token]
-        res = @data.delete token if @data[token]
+    def wait token
+      begin
+        res = nil
+        raise RqlRuntimeError, "Connection closed by server!" if not @listener
+        @mutex.synchronize do
+          (@waiters[token] = ConditionVariable.new).wait(@mutex) if not @data[token]
+          res = @data.delete token if @data[token]
+        end
+        raise RqlRuntimeError, "Connection closed by server!" if !@listener or !res
+        return res
+      rescue @abort_module::Abort => e
+        print "\nAborting query and reconnecting...\n"
+        reconnect
+        raise e
       end
-      raise RuntimeError, "Connection closed by server!" if !@listener or !res
-      return res
     end
 
-    def continue token # :nodoc:
-      msg = Query.new
-      msg.type = Query::QueryType::CONTINUE
-      msg.token = token
-      dispatch msg
-    end
-
-    def error(query,protob,err=RuntimeError) # :nodoc:
-      bt = protob.backtrace ? protob.backtrace.frame : []
-      #PP.pp bt
-      msg = "RQL: #{protob.error_message}\n" + query.print_backtrace(bt)
-      raise err,msg
+    # Change the default database of a connection.
+    def use(new_default_db)
+      @default_opts[:db] = RQL.new.db(new_default_db)
     end
 
-    def token_iter(query, token) # :nodoc:
-      done = false
-      data = []
-      loop do
-        if (data == [])
-          break if done
-
-          begin
-            protob = wait token
-          rescue @abort_module::Abort => e
-            print "\nAborting query and reconnecting...\n"
-            self.reconnect()
-            raise e
-          end
-
-          case protob.status_code
-          when Response::StatusCode::SUCCESS_JSON then
-            yield JSON.parse('['+protob.response[0]+']')[0]
-            return false
-          when Response::StatusCode::SUCCESS_PARTIAL then
-            continue token
-            data.push *protob.response
-          when Response::StatusCode::SUCCESS_STREAM then
-            data.push *protob.response
-            done = true
-          when Response::StatusCode::SUCCESS_EMPTY then
-            return false
-          when Response::StatusCode::BAD_QUERY then error query,protob,ArgumentError
-          when Response::StatusCode::RUNTIME_ERROR then error query,protob,RuntimeError
-          else error query,protob
-          end
-        end
-        #yield JSON.parse("["+data.shift+"]")[0] if data != []
-        yield JSON.parse('['+data.shift+']')[0] if data != []
-        #yield data.shift if data != []
-      end
-      return true
+    def inspect
+      db = @default_opts[:db] || RQL.new.db('test')
+      properties = "(#{@host}:#{@port}) (Default DB: #{db.inspect})"
+      state = @listener ? "(listening)" : "(closed)"
+      "#<RethinkDB::Connection:#{self.object_id} #{properties} #{state}>"
     end
 
-    # Create a new connection to <b>+host+</b> on port <b>+port+</b>.
-    # You may also optionally provide a default database to use when
-    # running queries over that connection.  Example:
-    #   c = Connection.new('localhost', 28015, 'default_db')
-    def initialize(host='localhost', port=28015, default_db='test')
-      begin
-        @abort_module = ::IRB
-      rescue NameError => e
-        @abort_module = Faux_Abort
-      end
-      @@last = self
-      @host = host
-      @port = port
-      @default_db = default_db
-      @conn_id = 0
-      reconnect
-    end
-    attr_reader :default_db, :conn_id
+    @@last = nil
+    @@magic_number = 0x3f61ba36
 
-    # Change the default database of a connection.
-    def use(new_default_db)
-      @default_db = new_default_db
-    end
+    def debug_socket; @socket; end
 
-    # Run a query over the connection.  If you run a query that returns a JSON
-    # expression (e.g. a reduce), you get back that JSON expression.  If you run
-    # a query that returns a stream of results (e.g. filtering a table), you get
-    # back an enumerable object of class RethinkDB::Query_Results.
-    #
-    # You may also provide some options as an optional second
-    # argument.  The only useful option right now is
-    # <b>+:use_outdated+</b>, which specifies whether tables can use
-    # outdated information.  (If you specified this on a per-table
-    # basis in your query, specifying it again here won't override the
-    # original choice.)
-    #
-    # <b>NOTE:</b> unlike most enumerable objects, you can only iterate over the
-    # result once.  See RethinkDB::Query_Results for more details.
-    def run (query, opts={:use_outdated => false})
-      #File.open('sexp.txt', 'a') {|f| f.write(query.sexp.inspect+"\n")}
-      is_atomic = (query.kind_of?(JSON_Expression) ||
-                   query.kind_of?(Meta_Query) ||
-                   query.kind_of?(Write_Query))
-      map = {}
-      map[:default_db] = @default_db if @default_db
-      S.check_opts(opts, [:use_outdated])
-      map[S.conn_outdated] = !!opts[:use_outdated]
-      protob = query.query(map)
-      if is_atomic
-        a = []
-        singular = token_iter(query, dispatch(protob)){|row| a.push row}
-        a.each{|o| BT.maybe_reformat_err(query, o)}
-        singular ? a : a[0]
-      else
-        return Query_Results.new(query, self, dispatch(protob))
-      end
+    # Reconnect to the server.  This will interrupt all queries on the
+    # server and invalidate all outstanding enumerables on the client.
+    def reconnect
+      @socket.close if @socket
+      @socket = TCPSocket.open(@host, @port)
+      @waiters = {}
+      @data = {}
+      @mutex = Mutex.new
+      @conn_id += 1
+      start_listener
+      self
     end
 
-    # Close the connection.
     def close
       @listener.terminate if @listener
       @listener = nil
@@ -224,18 +185,18 @@ module RethinkDB
       @socket = nil
     end
 
-    # Return the last opened connection, or throw if there is no such
-    # connection.  Used by e.g. RQL_Query#run.
     def self.last
       return @@last if @@last
-      raise RuntimeError, "No last connection.  Use RethinkDB::Connection.new."
+      raise RqlRuntimeError, "No last connection.  Use RethinkDB::Connection.new."
     end
 
-    def start_listener # :nodoc:
+    def start_listener
       class << @socket
-        def read_exn(len) # :nodoc:
+        def read_exn(len)
           buf = read len
-          raise RuntimeError,"Connection closed by server." if !buf or buf.length != len
+          if !buf or buf.length != len
+            raise RqlRuntimeError, "Connection closed by server."
+          end
           return buf
         end
       end
@@ -246,7 +207,7 @@ module RethinkDB
           begin
             response_length = @socket.read_exn(4).unpack('L<')[0]
             response = @socket.read_exn(response_length)
-          rescue RuntimeError => e
+          rescue RqlRuntimeError => e
             @mutex.synchronize do
               @listener = nil
               @waiters.each {|kv| kv[1].signal}
@@ -258,8 +219,7 @@ module RethinkDB
           begin
             protob = Response.new.parse_from_string(response)
           rescue
-            p response
-            abort("Bad Protobuf.")
+            raise RqlRuntimeError, "Bad Protobuf #{response}, server is buggy."
           end
           @mutex.synchronize do
             @data[protob.token] = protob