jmongo 1.0.3 → 1.1.0

data/lib/jmongo/connection.rb

@@ -20,23 +20,30 @@ module Mongo
     include Mongo::JavaImpl::Connection_::InstanceMethods
      extend Mongo::JavaImpl::Connection_::ClassMethods
 
-    attr_reader :connection, :logger, :auths
+    attr_reader :connection, :connector, :logger, :auths, :primary
+
+    DEFAULT_PORT = 27017
 
     def initialize host = nil, port = nil, opts = {}
       if opts.has_key?(:new_from_uri)
-        @connection = opts[:new_from_uri]
+        @options = opts
+        @mongo_uri = opts[:new_from_uri]
+        @connection = JMongo::Mongo.new(@mongo_uri)
       else
         @logger = opts[:logger]
         @host = host || 'localhost'
         @port = port || 27017
-        server_address = JMongo::ServerAddress.new @host, @port
-        options = JMongo::MongoOptions.new
-        options.connectionsPerHost = opts[:pool_size] || 1
-        options.socketTimeout = opts[:timeout].to_i * 1000 || 5000
-        @connection = JMongo::Mongo.new(server_address, options)
+        @server_address = JMongo::ServerAddress.new @host, @port
+        @options = JMongo::MongoOptions.new
+        @options.connectionsPerHost = opts[:pool_size] || 1
+        @options.socketTimeout = opts[:timeout].to_i * 1000 || 5000
+        @connection = JMongo::Mongo.new(@server_address, @options)
       end
+      @connector = @connection.connector
       @logger = opts[:logger]
       @auths = opts.fetch(:auths, [])
+      add = @connector.address
+      @primary = [add.host, add.port]
     end
 
     def self.paired(nodes, opts={})
@@ -147,7 +154,7 @@ module Mongo
     #
     # @core databases []-instance_method
     def [](db_name)
-      DB.new db_name, self
+      db db_name
     end
 
     # Drop a database.
@@ -176,11 +183,18 @@ module Mongo
       raise_not_implemented
     end
 
+    # Checks if a server is alive. This command will return immediately
+    # even if the server is in a lock.
+    #
+    # @return [Hash]
+    def ping
+      db("admin").command('ping')
+    end
     # Get the build information for the current connection.
     #
     # @return [Hash]
     def server_info
-      raise_not_implemented
+      db("admin").command('buildinfo')
     end
 
     # Get the build version of the current server.
@@ -188,7 +202,7 @@ module Mongo
     # @return [Mongo::ServerVersion]
     #   object allowing easy comparability of version.
     def server_version
-      _server_version
+      ServerVersion.new(server_info["version"])
     end
 
     # Is it okay to connect to a slave?
@@ -230,15 +244,27 @@ module Mongo
     end
 
     def connect_to_master
-      raise_not_implemented
+      connect
     end
 
     def connected?
-      raise_not_implemented
+      @connection && @connector && @connector.is_open
+    end
+
+    def connect
+      close
+      if @mongo_uri
+        @connection = JMongo::Mongo.new(@mongo_uri)
+      else
+        @connection = JMongo::Mongo.new(@server_address, @options)
+      end
+      @connector = @connection.connector
     end
+    alias :reconnect :connect
 
     def close
-      raise_not_implemented
+      @connection.close if @connection
+      @connection = @connector = nil
     end
 
   end # class Connection

data/lib/jmongo/cursor.rb

@@ -17,90 +17,173 @@ module Mongo
   class Cursor
     include Mongo::JavaImpl::Utils
 
-    attr_reader :j_cursor
+    attr_reader :j_cursor, :collection, :selector, :fields,
+      :order, :hint, :snapshot, :timeout,
+      :full_collection_name, :transformer,
+      :options
 
     def initialize(collection, options={})
+      @collection = collection
       @j_collection = collection.j_collection
-
+      @query_run = false
       @selector   = convert_selector_for_query(options[:selector])
       @fields     = convert_fields_for_query(options[:fields])
-      @admin      = options[:admin]    || false
-      @skip       = options[:skip]     || 0
-      @limit      = options[:limit]    || 0
-      @order      = _sort(options[:order])
+      @admin      = options.fetch(:admin, false)
+      @order      = nil
+      @batch_size = Mongo::DEFAULT_BATCH_SIZE
+      @skip       = 0
+      @limit      = 0
+      _skip options[:skip]
+      _limit options[:limit]
+      _sort options[:order]
+      _batch_size options[:batch_size]
       @hint       = options[:hint]
       @snapshot   = options[:snapshot]
       @explain    = options[:explain]
       @socket     = options[:socket]
-      @batch_size = options[:batch_size] || Mongo::Constants::DEFAULT_BATCH_SIZE
-      @timeout    = options[:timeout]  || false
-      @tailable   = options[:tailable] || false
+      @timeout    = options.fetch(:timeout, true)
+      @tailable   = options.fetch(:tailable, false)
+      @transformer = options[:transformer]
 
-      #@full_collection_name = "#{@collection.db.name}.#{@collection.name}"
-      @query_run = false
+      @full_collection_name = "#{@collection.db.name}.#{@collection.name}"
+
+      spawn_cursor
+    end
 
+    def rewind!
+      close
+      @query_run = false
       spawn_cursor
     end
+
+    def close
+      @query_run = true
+      @j_cursor.close
+    end
+
+    def cursor_id
+      @j_cursor.get_cursor_id
+    end
+
+    def closed?
+      cursor_id == 0
+    end
+
+    def alive?
+      cursor_id != 0
+    end
+
+    def add_option(opt)
+      check_modifiable
+      @j_cursor.addOption(opt)
+      options
+    end
+
+    def options
+      @j_cursor.getOptions
+    end
+
+    def query_opts
+      warn "The method Cursor#query_opts has been deprecated " +
+        "and will removed in v2.0. Use Cursor#options instead."
+      options
+    end
+
+    def remove_option(opt)
+      check_modifiable
+      @j_cursor.setOptions(options & ~opt)
+      options
+    end
+
     def current_document
-      if !@query_run
-        next_document
-      else
-        from_dbobject(@j_cursor.curr)
-      end
+      _xform(from_dbobject(@j_cursor.curr))
     end
 
     def next_document
-      @query_run = true
-      @j_cursor.has_next? ? from_dbobject(@j_cursor.next) : BSON::OrderedHash.new
+      _xform(has_next? ? __next : nil)
     end
+    alias :next :next_document
+
+    def _xform(doc)
+      if @transformer && @transformer.respond_to?('call')
+        @transformer.call(doc)
+      else
+        doc
+      end
+    end
+    private :_xform
 
     def has_next?
       @j_cursor.has_next?
     end
+
     # iterate directly from the mongo db
     def each
       check_modifiable
-      #raise "Backtrace..."
-      while @j_cursor.has_next?
+      while has_next?
         yield next_document
       end
     end
 
-    def limit(number_to_return=nil)
-      return @limit unless number_to_return
+    def _batch_size(size=nil)
+      return if size.nil?
       check_modifiable
-      raise ArgumentError, "limit requires an integer" unless number_to_return.is_a? Integer
+      raise ArgumentError, "batch_size requires an integer" unless size.is_a? Integer
+      @batch_size = size
+    end
+    private :_batch_size
 
-      @limit = number_to_return
-      @j_cursor = @j_cursor.limit(@limit)
+    def batch_size(size=nil)
+      _batch_size(size)
+      @j_cursor = @j_cursor.batchSize(@batch_size) if @batch_size
       self
     end
 
-    def skip(number_to_skip=nil)
-      return @skip unless number_to_skip
+    def _limit(number_to_return=nil)
+      return if number_to_return.nil?
       check_modifiable
-      raise ArgumentError, "skip requires an integer" unless number_to_skip.is_a? Integer
+      raise ArgumentError, "limit requires an integer" unless number_to_return.is_a? Integer
+      @limit = number_to_return
+    end
+    private :_limit
 
-      @skip = number_to_skip
-      @j_cursor = @j_cursor.skip(@skip)
+    def limit(number_to_return=nil)
+      _limit(number_to_return)
+      wrap_invalid_op do
+        @j_cursor = @j_cursor.limit(@limit) if @limit
+      end
       self
     end
 
-    def sort(key_or_list, direction=nil)
+    def _skip(number_to_skip=nil)
+      return if number_to_skip.nil?
       check_modifiable
-      @ord = _sort(key_or_list, direction)
-      @j_cursor = @j_cursor.sort(@ord)
+      raise ArgumentError, "skip requires an integer" unless number_to_skip.is_a? Integer
+      @skip = number_to_skip
+    end
+    private :_skip
+
+    def skip(number_to_skip=nil)
+      _skip(number_to_skip)
+      wrap_invalid_op do
+        @j_cursor = @j_cursor.skip(@skip) if @skip
+      end
       self
     end
 
-    def _sort(key_or_list, direction=nil)
+    def _sort(key_or_list=nil, direction=nil)
       return if key_or_list.nil?
-      if !direction.nil?
-        order = [[key_or_list, direction]]
-      else
-        order = [key_or_list]
+      check_modifiable
+      @order = prep_sort(key_or_list, direction)
+    end
+    private :_sort
+
+    def sort(key_or_list, direction=nil)
+      _sort(key_or_list, direction)
+      wrap_invalid_op do
+        @j_cursor = @j_cursor.sort(@order) if @order
       end
-      to_dbobject(Hash[*order.flatten])
+      self
     end
 
     def size
@@ -110,9 +193,9 @@ module Mongo
     def count(skip_and_limit = false)
       if skip_and_limit && @skip && @limit
         check_modifiable
-        @j_cursor.skip(@skip).limit(@limit).size
-      else
         @j_cursor.size
+      else
+        @j_cursor.count
       end
     end
 
@@ -122,38 +205,38 @@ module Mongo
 
     def map(&block)
       ret = []
-      check_modifiable
-      while @j_cursor.has_next?
-        ret << block.call(from_dbobject(@j_cursor.next))
+      rewind! unless has_next?
+      while has_next?
+        ret << block.call(__next)
       end
       ret
     end
 
     def to_a
       ret = []
-      check_modifiable
-      while @j_cursor.has_next?
-        ret << from_dbobject(@j_cursor.next)
+      rewind! unless has_next?
+      while has_next?
+        ret << __next
       end
       ret
     end
+
+    def to_set
+      Set.new self.to_a
+    end
+
     private
 
+    def __next
+      @query_run = true
+      from_dbobject(@j_cursor.next)
+    end
+
     # Convert the +:fields+ parameter from a single field name or an array
     # of fields names to a hash, with the field names for keys and '1' for each
     # value.
     def convert_fields_for_query(fields)
-      case fields
-      when String, Symbol
-        to_dbobject({fields => 1})
-      when Array
-        return nil if fields.length.zero?
-        hash = {}
-        fields.each { |field| hash[field] = 1 }
-        to_dbobject hash
-      when Hash
-        to_dbobject fields
-      end
+      to_dbobject prep_fields(fields)
     end
 
     # Set the query selector hash.
@@ -166,14 +249,18 @@ module Mongo
       end
     end
 
+    def no_fields?
+      @fields.nil? || @fields.empty?
+    end
+
     def spawn_cursor
-      @j_cursor = @fields.nil? || @fields.empty? ? @j_collection.find(@selector) :  @j_collection.find(@selector, @fields)
+      @j_cursor = no_fields? ? @j_collection.find(@selector) :  @j_collection.find(@selector, @fields)
 
       if @j_cursor
         @j_cursor = @j_cursor.sort(@order) if @order
-        @j_cursor = @j_cursor.skip(@skip) if @skip > 0
-        @j_cursor = @j_cursor.limit(@limit) if @limit > 0
-        @j_cursor = @j_cursor.batchSize(@batch_size)
+        @j_cursor = @j_cursor.skip(@skip) if @skip && @skip > 0
+        @j_cursor = @j_cursor.limit(@limit) if @limit && @limit > 0
+        @j_cursor = @j_cursor.batchSize(@batch_size) if @batch_size && @batch_size > 0
 
         @j_cursor = @j_cursor.addOption JMongo::Bytes::QUERYOPTION_NOTIMEOUT unless @timeout
         @j_cursor = @j_cursor.addOption JMongo::Bytes::QUERYOPTION_TAILABLE if @tailable
@@ -184,10 +271,21 @@ module Mongo
 
     def check_modifiable
       if @query_run
-        raise "Cannot modify the query once it has been run or closed."
+        raise_invalid_op
       end
     end
 
+    def wrap_invalid_op
+      begin
+        yield
+      rescue => ex
+        raise_invalid_op
+      end
+    end
+
+    def raise_invalid_op
+      raise InvalidOperation, "Cannot modify the query once it has been run or closed."
+    end
   end # class Cursor
 
 end # module Mongo

data/lib/jmongo/db.rb

@@ -22,10 +22,16 @@ module Mongo
     attr_reader :name
     attr_reader :connection
 
+    attr_writer :strict
+
+    ProfileLevel = {:off => 0, :slow_only => 1, :all => 2, 0 => 'off', 1 => 'slow_only', 2 => 'all'}
+
     def initialize(db_name, connection, options={})
       @name       = db_name
       @connection = connection
       @j_db = @connection.connection.get_db db_name
+      @pk_factory = options[:pk]
+      @strict = options.fetch(:strict, false)
     end
 
     def authenticate(username, password, save_auth=true)
@@ -53,9 +59,7 @@ module Mongo
     end
 
     def collection_names
-      names = collections_info.to_a.collect { |doc| doc['name'] || '' }
-      names = names.delete_if {|name| name.index(@name).nil? || name.index('$')}
-      names.map {|name| name.sub(@name + '.', '')}
+      @j_db.get_collection_names
     end
 
     def collections
@@ -67,15 +71,27 @@ module Mongo
     def collections_info(coll_name=nil)
       selector = {}
       selector[:name] = full_collection_name(coll_name) if coll_name
-      Cursor.new(Collection.new(self, SYSTEM_NAMESPACE_COLLECTION), :selector => selector)
+      coll = self.collection(SYSTEM_NAMESPACE_COLLECTION)
+      coll.find selector
     end
 
     def create_collection(name, options={})
-      @j_db.createCollection(name, to_dbobject(options))
+      if collection_names.include?(name)
+        raise MongoDBError, "Collection #{name} already exists. Currently in strict mode." if @strict
+        collection(name, options)
+      else
+        begin
+          jc = @j_db.create_collection(name, to_dbobject(options))
+          Collection.new self, name, options, jc
+        rescue NativeException => ex
+          raise MongoDBError, "Collection #{name} creation error: " +
+              ex.message
+        end
+      end
     end
 
-    def collection(name)
-      Collection.new self, name
+    def collection(name, options = {})
+      Collection.new self, name, options
     end
     alias_method :[], :collection
 
@@ -83,24 +99,21 @@ module Mongo
       coll = collection(name).j_collection.drop
     end
 
-    def error
-      raise_not_implemented
-    end
-
-    def last_status
+    def get_last_error
       from_dbobject(@j_db.getLastError)
     end
+    alias :last_status :get_last_error
 
     def error?
-      raise_not_implemented
+      !get_last_error['err'].nil?
     end
 
     def previous_error
-      raise_not_implemented
+      exec_command :getpreverror
     end
 
     def reset_error_history
-      raise_not_implemented
+      exec_command :reseterror
     end
 
     def query(collection, query, admin=false)
@@ -108,68 +121,144 @@ module Mongo
     end
 
     def dereference(dbref)
-      raise_not_implemented
+      ns = dbref.namespace
+      raise MongoArgumentError, "No namespace for dbref: #{dbref.inspect}"
+      collection(ns).find_one("_id" => dbref.object_id)
     end
 
     def eval(code, *args)
-      raise_not_implemented
+      doc = do_eval(code, *args)
+      return unless doc
+      return doc['retval']['value'] if doc['retval'] && doc['retval']['value']
+      doc['retval']
     end
 
     def rename_collection(from, to)
-      raise_not_implemented
+      begin
+        @j_db.get_collection(from).rename(to)
+      rescue => ex
+        raise(MongoDBError, "Error renaming collection from: #{from}, to: #{to}")
+      end
+      true
     end
 
     def drop_index(collection_name, index_name)
-      raise_not_implemented
+      self[collection_name].drop_index(index_name)
     end
 
     def index_information(collection_name)
-      raise_not_implemented
+      info = {}
+      from_dbobject(@j_db.get_collection(collection_name).get_index_info).each do |index|
+        info[index['name']] = index
+      end
+      info
     end
 
     def stats
-      exec_command(:dbstats)
+      from_dbobject exec_command(:dbstats)
     end
 
     def create_index(collection_name, field_or_spec, unique=false)
       collection(collection_name).create_indexes(field_or_spec,{:unique=>unique})
     end
+    # Return +true+ if an error was caused by the most recently executed
+    # database operation.
+    #
+    # @return [Boolean]
+    def error?
+      get_last_error['err'] != nil
+    end
 
     def ok?(doc)
-      doc['ok'] == 1.0
+      doc['ok'] == 1.0 || doc['ok'] == true
     end
 
-    def command(selector, opts={})
-      raise_not_implemented
+    def command(cmd, opts={})
+      selector = cmd.respond_to?('merge') ? cmd : {cmd.to_s => 1}
+      check_response = opts.fetch(:check_response, true)
+      raise MongoArgumentError, "command must be given a selector" if selector.empty?
+      if selector.keys.length > 1 && RUBY_VERSION < '1.9' && selector.class != BSON::OrderedHash
+        raise MongoArgumentError, "DB#command requires an OrderedHash when hash contains multiple keys"
+      end
+
+      begin
+        result = exec_command(selector)
+      rescue => ex
+        raise OperationFailure, "Database command '#{selector.keys.first}' failed: #{ex.message}"
+      end
+
+      raise OperationFailure, "Database command '#{selector.keys.first}' failed: returned null." if result.nil?
+
+      if (check_response && !ok?(result))
+        message = "Database command '#{selector.keys.first}' failed: (" + result.map{|k, v| "#{k}: '#{v}'"}.join('; ') + ")."
+        raise OperationFailure.new message
+      else
+        result
+      end
     end
 
     def full_collection_name(collection_name)
       "#{@name}.#{collection_name}"
     end
 
+    # Returns the value of the +strict+ flag.
+    def strict?; @strict; end
+
+    # The primary key factory object (or +nil+).
+    #
+    # @return [Object, Nil]
     def pk_factory
-      raise_not_implemented
+      @pk_factory
     end
 
+    # Specify a primary key factory if not already set.
+    #
+    # @raise [MongoArgumentError] if the primary key factory has already been set.
     def pk_factory=(pk_factory)
-      raise_not_implemented
+      if @pk_factory
+        raise MongoArgumentError, "Cannot change primary key factory once it's been set"
+      end
+
+      @pk_factory = pk_factory
     end
 
     def profiling_level
-      raise_not_implemented
+      oh = BSON::OrderedHash.new
+      oh['profile'] = -1
+      doc = command(oh, :check_response => false)
+      raise "Error with profile command: #{doc.inspect}" unless ok?(doc) && doc['was'].kind_of?(Numeric)
+      was = ProfileLevel[doc['was'].to_i]
+      raise "Error: illegal profiling level value #{doc['was']}" if was.nil?
+      was.to_sym
     end
 
     def profiling_level=(level)
-      raise_not_implemented
+      oh = BSON::OrderedHash.new
+      int_lvl = ProfileLevel[level]
+      raise "Error: illegal profiling level value #{level}" if int_lvl.nil?
+      oh['profile'] = int_lvl
+      doc = command(oh, :check_response => false)
+      ok?(doc) || raise(MongoDBError, "Error with profile command: #{doc.inspect}")
     end
 
     def profiling_info
-      raise_not_implemented
+      Cursor.new(Collection.new(SYSTEM_PROFILE_COLLECTION, self), :selector => {}).to_a
     end
 
     def validate_collection(name)
-      raise_not_implemented
+      cmd = BSON::OrderedHash.new
+      cmd['validate'] = name
+      cmd['full'] = true
+      doc = command(cmd, :check_response => false)
+      if !ok?(doc)
+        raise MongoDBError, "Error with validate command: #{doc.inspect}"
+      end
+      if (doc.has_key?('valid') && !doc['valid']) || (doc['result'] =~ /\b(exception|corrupt)\b/i)
+        raise MongoDBError, "Error: invalid collection #{name}: #{doc.inspect}"
+      end
+      doc
     end
+
     # additions to the ruby driver
     def has_collection?(name)
       has_coll name