mongodb-mongo 0.1.3

data/lib/mongo/message/update_message.rb

@@ -0,0 +1,21 @@
+require 'mongo/message/message'
+require 'mongo/message/opcodes'
+
+module XGen
+  module Mongo
+    module Driver
+
+      class UpdateMessage < Message
+
+        def initialize(db_name, collection_name, sel, obj, repsert)
+          super(OP_UPDATE)
+          write_int(0)
+          write_string("#{db_name}.#{collection_name}")
+          write_int(repsert ? 1 : 0) # 1 if a repsert operation (upsert)
+          write_doc(sel)
+          write_doc(obj)
+        end
+      end
+    end
+  end
+end

data/lib/mongo/message.rb

@@ -0,0 +1,4 @@
+%w(get_more_message insert_message kill_cursors_message message_header
+   msg_message query_message remove_message update_message).each { |f|
+  require "mongo/message/#{f}"
+}

data/lib/mongo/mongo.rb

@@ -0,0 +1,98 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License, version 3, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+# ++
+
+require 'mongo/db'
+
+module XGen
+  module Mongo
+    module Driver
+
+      # Represents a Mongo database server.
+      class Mongo
+
+        DEFAULT_PORT = 27017
+
+        # Either nodes_or_host is a host name string and port is an optional
+        # port number that defaults to DEFAULT_PORT, or nodes_or_host is an
+        # array of arrays, where each is a host/port pair (or a host with no
+        # port). Finally, if nodes_or_host is nil then host is 'localhost' and
+        # port is DEFAULT_PORT. Since that's so confusing, here are a few
+        # examples:
+        #
+        #  Mongo.new                         # localhost, DEFAULT_PORT
+        #  Mongo.new("localhost")            # localhost, DEFAULT_PORT
+        #  Mongo.new("localhost", 3000)      # localhost, 3000
+        #  Mongo.new([["localhost"]])        # localhost, DEFAULT_PORT
+        #  Mongo.new([["localhost", 3000]])  # localhost, 3000
+        #  Mongo.new([["db1.example.com", 3000], ["db2.example.com", 3000]]])
+        #
+        # When a DB object first connects, it tries nodes and stops at the
+        # first one it connects to.
+        def initialize(nodes_or_host=nil, port=nil)
+          @nodes = case nodes_or_host
+                   when String
+                     [[nodes_or_host, port || DEFAULT_PORT]]
+                   when Array
+                     nodes_or_host.collect { |nh| [nh[0], nh[1] || DEFAULT_PORT] }
+                   when nil
+                     [['localhost', DEFAULT_PORT]]
+                   end
+        end
+
+        # Return the XGen::Mongo::Driver::DB named +db_name+. See DB#new for
+        # +options+.
+        def db(db_name, options={})
+          XGen::Mongo::Driver::DB.new(db_name, @nodes, options)
+        end
+
+        # Returns a hash containing database names as keys and disk space for
+        # each as values.
+        def database_info
+          admin_db = nil
+          begin
+            admin_db = db('admin')
+            doc = admin_db.db_command(:listDatabases => 1)
+            raise "error retrieving database info" unless admin_db.ok?(doc)
+            h = {}
+            doc['databases'].each { |db|
+              h[db['name']] = db['sizeOnDisk'].to_i
+            }
+            h
+          ensure
+            admin_db.close
+          end
+        end
+
+        # Returns an array of database names.
+        def database_names
+          database_info.keys
+        end
+
+        # Not implemented.
+        def clone_database(from)
+          raise "not implemented"
+        end
+
+        # Not implemented.
+        def copy_database(from_host, from_db, to_db)
+          raise "not implemented"
+        end
+
+      end
+    end
+  end
+end
+

data/lib/mongo/query.rb

@@ -0,0 +1,110 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License, version 3, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+# ++
+
+require 'mongo/collection'
+require 'mongo/message'
+
+module XGen
+  module Mongo
+    module Driver
+
+      # A query against a collection. A query's selector is a hash. See the
+      # Mongo documentation for query details.
+      class Query
+
+        attr_accessor :number_to_skip, :number_to_return, :order_by
+        # If true, $explain will be set in QueryMessage that uses this query.
+        attr_accessor :explain
+        # Either +nil+ or an array of hint field names.
+        attr_accessor :hint_fields
+        attr_reader :selector   # writer defined below
+
+        # sel :: A hash describing the query. See the Mongo docs for details.
+        #
+        # return_fields :: If not +nil+, a single field name or an array of
+        #                  field names. Only those fields will be returned.
+        #                  (Called :fields in calls to Collection#find.)
+        #
+        # number_to_skip :: Number of records to skip before returning
+        #                   records. (Called :offset in calls to
+        #                   Collection#find.) Default is 0.
+        #
+        # number_to_return :: Max number of records to return. (Called :limit
+        #                     in calls to Collection#find.) Default is 0 (all
+        #                     records).
+        #
+        # order_by :: If not +nil+, specifies record sort order. May be a
+        #             String, Hash, OrderedHash, or Array. If a string, the
+        #             results will be ordered by that field in ascending
+        #             order. If an array, it should be an array of field names
+        #             which will all be sorted in ascending order. If a hash,
+        #             it may be either a regular Hash or an OrderedHash. The
+        #             keys should be field names, and the values should be 1
+        #             (ascending) or -1 (descending). Note that if it is a
+        #             regular Hash then sorting by more than one field
+        #             probably will not be what you intend because key order
+        #             is not preserved. (order_by is called :sort in calls to
+        #             Collection#find.)
+        def initialize(sel={}, return_fields=nil, number_to_skip=0, number_to_return=0, order_by=nil)
+          @number_to_skip, @number_to_return, @order_by = number_to_skip, number_to_return, order_by
+          self.selector = sel
+          self.fields = return_fields
+        end
+
+        # Set query selector hash. If sel is a string, it will be used as a
+        # $where clause. (See Mongo docs for details.)
+        def selector=(sel)
+          @selector = case sel
+                      when nil
+                        {}
+                      when String
+                        {"$where" => sel}
+                      when Hash
+                        sel
+                      end
+        end
+
+        # Set fields to return. If +val+ is +nil+ or empty, all fields will be
+        # returned.
+        def fields=(val)
+          @fields = val
+          @fields = nil if @fields && @fields.empty?
+        end
+
+        def fields
+          case @fields
+          when String
+            {@fields => 1}
+          when Array
+            if @fields.length == 0
+              nil
+            else
+              h = {}
+              @fields.each { |field| h[field] = 1 }
+              h
+            end
+          else                  # nil, anything else
+            nil
+          end
+        end
+
+        def contains_special_fields
+          (@order_by != nil && @order_by.length > 0) || @explain || @hint_fields
+        end
+      end
+    end
+  end
+end

data/lib/mongo/types/binary.rb

@@ -0,0 +1,34 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License, version 3, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+# ++
+
+module XGen
+  module Mongo
+    module Driver
+
+      # An array of binary bytes. The only reason this exists is so that the
+      # BSON encoder will know to output the Mongo BINARY type.
+      class Binary < String; end
+
+    end
+  end
+end
+
+class String
+  # Convert a string into a XGen::Mongo::Driver::Binary
+  def to_mongo_binary
+    XGen::Mongo::Driver::Binary.new(self)
+  end
+end

data/lib/mongo/types/dbref.rb

@@ -0,0 +1,37 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License, version 3, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+# ++
+
+module XGen
+  module Mongo
+    module Driver
+
+      class DBRef
+
+        attr_reader :parent, :field_name, :db, :namespace, :object_id
+
+        def initialize(parent, field_name, db, namespace, object_id)
+          @parent, @field_name, @db, @namespace, @object_id =
+            parent, field_name, db, namespace, object_id
+        end
+
+        def to_s
+          "ns: #{namespace}, id: #{object_id}"
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo/types/objectid.rb

@@ -0,0 +1,137 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License, version 3, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+# ++
+
+require 'mutex_m'
+require 'mongo/util/byte_buffer'
+
+module XGen
+  module Mongo
+    module Driver
+
+      # Implementation of the Babble OID. Object ids are not required by
+      # Mongo, but they make certain operations more efficient.
+      #
+      # The driver does not automatically assign ids to records that are
+      # inserted. (An upcoming feature will allow you to give an id "factory"
+      # to a database and/or a collection.)
+      # 
+      #   12 bytes
+      #   ---
+      #    0 time
+      #    1
+      #    2
+      #    3
+      #    4 machine
+      #    5
+      #    6
+      #    7 pid
+      #    8
+      #    9 inc
+      #   10
+      #   11
+      class ObjectID
+
+        MACHINE = ( val = rand(0x1000000); [val & 0xff, (val >> 8) & 0xff, (val >> 16) & 0xff] )
+        PID = ( val = rand(0x10000); [val & 0xff, (val >> 8) & 0xff]; )
+
+        # The string representation of an OID is different than its internal
+        # and BSON byte representations. The BYTE_ORDER here maps
+        # internal/BSON byte position (the index in BYTE_ORDER) to the
+        # position of the two hex characters representing that byte in the
+        # string representation. For example, the 0th BSON byte corresponds to
+        # the (0-based) 7th pair of hex chars in the string.
+        BYTE_ORDER = [7, 6, 5, 4, 3, 2, 1, 0, 11, 10, 9, 8]
+
+        LOCK = Object.new
+        LOCK.extend Mutex_m
+
+        @@index_time = Time.new.to_i
+        @@index = 0
+
+        # Given a string representation of an ObjectID, return a new ObjectID
+        # with that value.
+        def self.from_string(str)
+          raise "illegal ObjectID format" unless legal_oid_string(str)
+          data = []
+          BYTE_ORDER.each_with_index { |string_position, data_index|
+            data[data_index] = str[string_position * 2, 2].to_i(16)
+          }
+          self.new(data)
+        end
+
+        def self.legal_oid_string(str)
+          len = BYTE_ORDER.length * 2
+          str =~ /([0-9a-f]+)/i
+          match = $1
+          str && str.length == len && match == str
+        end
+
+        # +data+ is an array of bytes. If nil, a new id will be generated.
+        # The time +t+ is only used for testing; leave it nil.
+        def initialize(data=nil, t=nil)
+          @data = data || generate_id(t)
+        end
+
+        def eql?(other)
+          @data == other.to_a
+        end
+        alias_method :==, :eql?
+
+        def to_a
+          @data.dup
+        end
+
+        def to_s
+          str = ' ' * 24
+          BYTE_ORDER.each_with_index { |string_position, data_index|
+            str[string_position * 2, 2] = '%02x' % @data[data_index]
+          }
+          str
+        end
+
+        # (Would normally be private, but isn't so we can test it.)
+        def generate_id(t=nil)
+          t ||= Time.new.to_i
+          buf = ByteBuffer.new
+          buf.put_int(t & 0xffffffff)
+          buf.put_array(MACHINE)
+          buf.put_array(PID)
+          i = index_for_time(t)
+          buf.put(i & 0xff)
+          buf.put((i >> 8) & 0xff)
+          buf.put((i >> 16) & 0xff)
+
+          buf.rewind
+          buf.to_a.dup
+        end
+
+        # (Would normally be private, but isn't so we can test it.)
+        def index_for_time(t)
+          LOCK.mu_synchronize {
+            if t != @@index_time
+              @@index = 0
+              @@index_time = t
+            end
+            retval = @@index
+            @@index += 1
+            retval
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo/types/regexp_of_holding.rb

@@ -0,0 +1,44 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License, version 3, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+# ++
+
+module XGen
+  module Mongo
+    module Driver
+
+      # A Regexp that can hold on to extra options and ignore them. Mongo
+      # regexes may contain option characters beyond 'i', 'm', and 'x'. (Note
+      # that Mongo only uses those three, but that regexes coming from other
+      # languages may store different option characters.)
+      #
+      # Note that you do not have to use this class at all if you wish to
+      # store regular expressions in Mongo. The Mongo and Ruby regex option
+      # flags are the same. Storing regexes is discouraged, in any case.
+      class RegexpOfHolding < Regexp
+
+        attr_accessor :extra_options_str
+
+        # +str+ and +options+ are the same as Regexp. +extra_options_str+
+        # contains all the other flags that were in Mongo but we do not use or
+        # understand.
+        def initialize(str, options, extra_options_str)
+          super(str, options)
+          @extra_options_str = extra_options_str
+        end
+      end
+
+    end
+  end
+end

data/lib/mongo/types/undefined.rb

@@ -0,0 +1,31 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License, version 3, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+# ++
+
+module XGen
+  module Mongo
+    module Driver
+
+      # A special "undefined" type to match Mongo's storage of UNKNOWN values.
+      # "UNKNOWN" comes from JavaScript.
+      #
+      # NOTE: this class does not attempt to provide ANY of the semantics an
+      # "unknown" object might need. It isn't nil, it isn't special in any
+      # way, and there isn't any singleton value.
+      class Undefined < Object; end
+
+    end
+  end
+end