animehunter-mongo 0.9

data/lib/mongo/message/update_message.rb

@@ -0,0 +1,37 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+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/mongo.rb

@@ -0,0 +1,164 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+require 'mongo/db'
+
+module XGen
+  module Mongo
+    module Driver
+
+      # Represents a Mongo database server.
+      class Mongo
+
+        DEFAULT_PORT = 27017
+
+        # Create a Mongo database server instance. You specify either one or a
+        # pair of servers. If one, you also say if connecting to a slave is
+        # OK. In either case, the host default is "localhost" and port default
+        # is DEFAULT_PORT.
+        #
+        # If you specify a pair, pair_or_host is a hash with two keys :left
+        # and :right. Each key maps to either
+        # * a server name, in which case port is DEFAULT_PORT
+        # * a port number, in which case server is "localhost"
+        # * an array containing a server name and a port number in that order
+        #
+        # +options+ are passed on to each DB instance:
+        #
+        # :slave_ok :: Only used if one host is specified. If false, when
+        #              connecting to that host/port a DB object will check to
+        #              see if the server is the master. If it is not, an error
+        #              is thrown.
+        #
+        # :auto_reconnect :: If a DB connection gets closed (for example, we
+        #                    have a server pair and saw the "not master"
+        #                    error, which closes the connection), then
+        #                    automatically try to reconnect to the master or
+        #                    to the single server we have been given. Defaults
+        #                    to +false+.
+        #
+        # Since that's so confusing, here are a few examples:
+        #
+        #  Mongo.new                         # localhost, DEFAULT_PORT, !slave
+        #  Mongo.new("localhost")            # localhost, DEFAULT_PORT, !slave
+        #  Mongo.new("localhost", 3000)      # localhost, 3000, slave not ok
+        #  # localhost, 3000, slave ok
+        #  Mongo.new("localhost", 3000, :slave_ok => true)
+        #  # localhost, DEFAULT_PORT, auto reconnect
+        #  Mongo.new(nil, nil, :auto_reconnect => true)
+        #
+        #  # A pair of servers. DB will always talk to the master. On socket
+        #  # error or "not master" error, we will auto-reconnect to the
+        #  # current master.
+        #  Mongo.new({:left  => ["db1.example.com", 3000],
+        #             :right => "db2.example.com"}, # DEFAULT_PORT
+        #            nil, :auto_reconnect => true)
+        #
+        #  # Here, :right is localhost/DEFAULT_PORT. No auto-reconnect.
+        #  Mongo.new({:left => ["db1.example.com", 3000]})
+        #
+        # When a DB object first connects to a pair, it will find the master
+        # instance and connect to that one.
+        def initialize(pair_or_host=nil, port=nil, options={})
+          @pair = case pair_or_host
+                   when String
+                     [[pair_or_host, port ? port.to_i : DEFAULT_PORT]]
+                   when Hash
+                    connections = []
+                    connections << pair_val_to_connection(pair_or_host[:left])
+                    connections << pair_val_to_connection(pair_or_host[:right])
+                    connections
+                   when nil
+                     [['localhost', DEFAULT_PORT]]
+                   end
+          @options = options
+        end
+
+        # Return the XGen::Mongo::Driver::DB named +db_name+. The slave_ok and
+        # auto_reconnect options passed in via #new may be overridden here.
+        # See DB#new for other options you can pass in.
+        def db(db_name, options={})
+          XGen::Mongo::Driver::DB.new(db_name, @pair, @options.merge(options))
+        end
+
+        # Returns a hash containing database names as keys and disk space for
+        # each as values.
+        def database_info
+          doc = single_db_command('admin', :listDatabases => 1)
+          h = {}
+          doc['databases'].each { |db|
+            h[db['name']] = db['sizeOnDisk'].to_i
+          }
+          h
+        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
+
+        # Drops the database +name+.
+        def drop_database(name)
+          single_db_command(name, :dropDatabase => 1)
+        end
+
+        protected
+
+        # Turns an array containing a host name string and a
+        # port number integer into a [host, port] pair array.
+        def pair_val_to_connection(a)
+          case a
+          when nil
+            ['localhost', DEFAULT_PORT]
+          when String
+            [a, DEFAULT_PORT]
+          when Integer
+            ['localhost', a]
+          when Array
+            a
+          end
+        end
+
+        # Send cmd (a hash, possibly ordered) to the admin database and return
+        # the answer. Raises an error unless the return is "ok" (DB#ok?
+        # returns +true+).
+        def single_db_command(db_name, cmd)
+          db = nil
+          begin
+            db = db(db_name)
+            doc = db.db_command(cmd)
+            raise "error retrieving database info: #{doc.inspect}" unless db.ok?(doc)
+            doc
+          ensure
+            db.close if db
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/mongo/query.rb

@@ -0,0 +1,119 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+require 'mongo/collection'
+require 'mongo/message'
+require 'mongo/types/code'
+
+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 a hash (preferably an OrderedHash).
+        attr_accessor :hint
+        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.)
+        #
+        # hint :: If not +nil+, specifies query hint fields. Must be either
+        #                +nil+ or a hash (preferably an OrderedHash). See
+        #                Collection#hint.
+        def initialize(sel={}, return_fields=nil, number_to_skip=0, number_to_return=0, order_by=nil, hint=nil)
+          @number_to_skip, @number_to_return, @order_by, @hint =
+            number_to_skip, number_to_return, order_by, hint
+          @explain = nil
+          self.selector = sel
+          self.fields = return_fields
+        end
+
+        # Set query selector hash. If sel is Code/string, it will be used as a
+        # $where clause. (See Mongo docs for details.)
+        def selector=(sel)
+          @selector = case sel
+                      when nil
+                        {}
+                      when Code
+                        {"$where" => sel}
+                      when String
+                        {"$where" => Code.new(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
+        end
+      end
+    end
+  end
+end

data/lib/mongo/types/binary.rb

@@ -0,0 +1,42 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+require 'mongo/util/byte_buffer'
+
+module XGen
+  module Mongo
+    module Driver
+
+      # An array of binary bytes with a Mongo subtype value.
+      class Binary < ByteBuffer
+
+        SUBTYPE_BYTES = 0x02
+        SUBTYPE_UUID = 0x03
+        SUBTYPE_MD5 = 0x05
+        SUBTYPE_USER_DEFINED = 0x80
+
+        # One of the SUBTYPE_* constants. Default is SUBTYPE_BYTES.
+        attr_accessor :subtype
+
+        def initialize(initial_data=[], subtype=SUBTYPE_BYTES)
+          super(initial_data)
+          @subtype = subtype
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo/types/code.rb

@@ -0,0 +1,34 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+module XGen
+  module Mongo
+    module Driver
+
+      # JavaScript code to be evaluated by MongoDB
+      class Code < String
+        # Hash mapping identifiers to their values
+        attr_accessor :scope
+
+        def initialize(code, scope={})
+          super(code)
+          @scope = scope
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo/types/dbref.rb

@@ -0,0 +1,37 @@
+# --
+# Copyright (C) 2008-2009 10gen Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+module XGen
+  module Mongo
+    module Driver
+
+      class DBRef
+
+        attr_reader :namespace, :object_id
+
+        def initialize(namespace, object_id)
+          @namespace, @object_id =
+            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.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ++
+
+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?(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?(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.instance_variable_get("@data")
+        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