--- a/lib/couch_object/persistable.rb
+++ b/lib/couch_object/persistable.rb
@@ -364,8 +364,18 @@ module CouchObject
       # If it's belongs_to relationships haven't been saved
       # then it has be done first.
       # Saving the master will also automatically save the child
-
       performed_save = false
+      
+      # If the belongs_to relationships haven't already been loaded,
+      # there is reason to believe that:
+      # * The object is new and doesn't have any relation set
+      # * The object already knows about it's belongs_to relations
+      #   and doesn't need aditional information about them for saving
+      # We therefore deactivate the loading of belongs_to relations
+      original_state_of_load_belongs_to_relations = \
+        @do_not_load_belongs_to_relations
+      @do_not_load_belongs_to_relations = true
+      
       belongs_to.each do |what_it_belongs_to|
         master_class = self.send(what_it_belongs_to)
         unless master_class == nil || !master_class.new?
@@ -374,6 +384,11 @@ module CouchObject
         end
       end
         
+      # Reset the do_not_load_belongs_to_relations variable to its 
+      # original state
+      @do_not_load_belongs_to_relations = \
+        original_state_of_load_belongs_to_relations
+      
       # If none of the master classes were saved, meaning they weren't new
       # or didn't exist, then we have to manually save this object.
       couch_perform_save unless performed_save
@@ -665,6 +680,7 @@ module CouchObject
                                      "@id",
                                      "@revision",
                                      "@do_not_load_has_many_relations",
+                                     "@do_not_load_belongs_to_relations",
                                      "@couch_object_original_state",
                                      "@couch_initial_load",
                                      "@belongs_to"]
@@ -713,6 +729,13 @@ module CouchObject
                                                    # NOTE: this is only for
                                                    # cases where smart_save
                                                    # has been activated.
+        
+        # No reason to load the belongs_to relations if they haven't
+        # already been loaded from the database!
+        original_state_of_load_belongs_to_relations = \
+          @do_not_load_belongs_to_relations
+        @do_not_load_belongs_to_relations = true
+    
         what_it_belongs_to = {}
         self.send(:belongs_to).each do |relation|
           as_what = self.send("belongs_to_#{relation}_as")
@@ -720,13 +743,48 @@ module CouchObject
       
           # Unless the relation is unset, in which case it will be of
           # type NilClass, set it.
-          what_it_belongs_to[as_what] = object_it_belongs_to.id \
+          what_it_belongs_to[as_what.to_s] = object_it_belongs_to.id || "new" \
             unless object_it_belongs_to.class == NilClass
         end
-        parameters["belongs_to"] = what_it_belongs_to
+        
+        # Reset the value so they are loaded the next time when needed
+        # if that is what the user wants.
+        @do_not_load_belongs_to_relations = \
+          original_state_of_load_belongs_to_relations
+
+
+        # We have to make sure the @belongs_to variable contains all changes
+        # and all the original values for the keys that haven't changed/
+        # relations that haven't been loaded
+        original_belongs_to = @belongs_to || {}
+        @belongs_to = what_it_belongs_to
+        times_through = 1
+
+        # LOOP 1... see below for problem description
+        original_belongs_to.each_pair do |key, value|
+          times_through += 1
+          @belongs_to[key.to_s] = value unless @belongs_to[key.to_s]
+        end
+
+        # FIXME:
+        # Now... this is a really hacky way to solve this problem
+        # and should be improved... Feel free to come up with sollutions
+        # Case:
+        # If it has a belongs_to relationship that is new and therefore 
+        # doesn't have an ID it would normally be written in the @belongs_to 
+        # variable as nil. The problem is that if self has previously
+        # been saved with another parent object this ID would still come
+        # through in the @belongs_to variable updater (see "LOOP 1" above).
+        # We therefore assign the ID "new" to all unsaved relations, which we
+        # now have to nilify. If we don't the smart save wont work for this 
+        # type of cases.
+
       end
       
-      parameters["belongs_to"] = @belongs_to if @couch_initial_load && @belongs_to
+      parameters["belongs_to"] = @belongs_to 
+      parameters.delete("belongs_to") if @belongs_to == {} or @belongs_to == nil
+
+       # if @couch_initial_load && @belongs_to
       
       begin
         parameters.to_json
@@ -756,6 +814,26 @@ module CouchObject
     def do_load_has_many_relations  
       @do_not_load_has_many_relations = false
     end
+    alias do_not_load_has_one_relations do_not_load_has_many_relations
+    alias do_load_has_one_relations do_load_has_many_relations
+    alias do_not_load_has_one_relation do_not_load_has_many_relations
+    alias do_load_has_one_relation do_load_has_many_relations
+
+    # 
+    # If you need to access the belongs_to variable without loading the
+    # relation if it hasn't already been loaded, you can call the instance
+    # method +do_not_load_belongs_to_relations+. To reactivate loading so
+    # the relation is loaded the next time it is needed, call the instance 
+    # method +do_load_belongs_to_relations+.
+    #
+    def do_not_load_belongs_to_relations
+      @do_not_load_belongs_to_relations = true
+    end
+    def do_load_belongs_to_relations
+      @do_not_load_belongs_to_relations = false
+    end
+    alias do_not_load_has_many_relation do_not_load_has_many_relations
+    alias do_load_belongs_to_relation do_load_belongs_to_relations
 
     
     protected
@@ -832,6 +910,8 @@ module CouchObject
     # 
     def couch_load_belongs_to_relation(that_is_called)
       
+      return nil if new? || @do_not_load_belongs_to_relations
+      
       # If it doesn't have a belongs to ID then there is no
       # related object in the database
       if @belongs_to && @belongs_to[that_is_called]

--- a/lib/couch_object/persistable/meta_classes.rb
+++ b/lib/couch_object/persistable/meta_classes.rb
@@ -301,7 +301,15 @@ module CouchObject
               else
                 is_a_has_many_relationship = true
               end
-                        
+                
+              # Now... there is no good reason loading a belongs_to relation
+              # from the database only to remove the relation with the child,
+              # because the relation is stored in the child anyway...
+              # We therefore temporarily deactivate the loading of belongs_to
+              # relations
+              original_state_of_load_belongs_to_relations = \
+                @do_not_load_belongs_to_relations
+              @do_not_load_belongs_to_relations = true
                         
               if is_a_has_many_relationship
               
@@ -331,6 +339,12 @@ module CouchObject
                   if object_to_add    
                 
               end
+              
+              # And now we reset the @do_not_load_belongs_to_relations
+              # variable to its original value:
+              @do_not_load_belongs_to_relations = \
+                original_state_of_load_belongs_to_relations
+            
             end
 
             # Setter without callback for new objects 

--- a/lib/couch_object/utils.rb
+++ b/lib/couch_object/utils.rb
@@ -43,6 +43,8 @@ module CouchObject
       case p.class.to_s.downcase
       when "fixnum", "bignum", "trueclass", "falseclass"
         "#{p.to_s}"
+      when "nilclass"
+        nil
       else        
         # Sanitize forward slashes
         # # / => \/

--- a/spec/persistable/relations.rb
+++ b/spec/persistable/relations.rb
@@ -268,6 +268,26 @@ describe CouchObject::Persistable, "saving related objects: " do
     @apartment.save("foo")
     @apartment.new?.should == false      
   end
+
+  it "should not load the belongs_to relations if they are not already loaded before saving" do
+    @inhabitant_content = %{ {"_id":"50F1A07A283C1879057AFE4C4B727D35","_rev":"1957693345","belongs_to":{"inhabitants":"12A64B5156002BFD66F23F559C5AD5FA"},"class":"Inhabitant","attributes":{}}
+    }
+    
+    response = HTTPResponse.new(@inhabitant_content)
+    
+    CouchObject::Database.should_receive(:open).exactly(1).and_return(@db)
+    
+    @db.should_receive(:get).once.with("foo").and_return(response)
+              
+    inhabitant = Inhabitant.get_with_smart_save("foo")
+    puts "\boriginal: #{inhabitant.instance_variable_get("@couch_object_original_state")}"
+    puts "     now: #{inhabitant.to_json}"
+    inhabitant.location.should_not == nil
+    
+    # Telling the object not to load its relatives
+    inhabitant.save
+    
+  end
 end
 
 describe CouchObject::Persistable, "loading object relations: " do
@@ -349,7 +369,7 @@ describe CouchObject::Persistable, "loading object relations: " do
     
   end
 
-  it "should be possible to tell the object not to load its relatives" do
+  it "should be possible to tell the object not to load its has many relations" do
     response = HTTPResponse.new(@apartment_building_content)
     
     CouchObject::Database.should_receive(:open).exactly(1).and_return(@db)
@@ -366,6 +386,25 @@ describe CouchObject::Persistable, "loading object relations: " do
     apartment_building.inhabitants.size.should == 0
     
   end
+
+  it "should be possible to tell the object not to load its has many relations" do
+    response = HTTPResponse.new(@inhabitant_content)
+    
+    CouchObject::Database.should_receive(:open).exactly(1).and_return(@db)
+    
+    @db.should_receive(:get).once.with("foo").and_return(response)
+              
+    inhabitant = Inhabitant.get("foo")
+    inhabitant.location.should_not == nil
+    
+    # Telling the object not to load its relatives
+    inhabitant.do_not_load_belongs_to_relations
+        
+    # The content should be loaded on first request!
+    inhabitant.apartment_building.should == nil
+    
+  end
+
 end
 
 describe CouchObject::Persistable, "has_one relations" do

--- a/spec/persistable/unsaved_changes.rb
+++ b/spec/persistable/unsaved_changes.rb
@@ -88,7 +88,6 @@ describe CouchObject::Persistable, "for loading objects:" do
     
   end
 
-
   it "should save an object that does not unsaved changes if it hasn't activated smart_save" do
     response = HTTPResponse.new(@normal_content_motor_bike)
     
@@ -134,7 +133,6 @@ describe CouchObject::Persistable, "for loading objects:" do
 
   end
 
-
   it "should only save relations that need to be saved" do
 
     response = HTTPResponse.new(@apartment_building_content)
@@ -166,7 +164,7 @@ describe CouchObject::Persistable, "for loading objects:" do
     
   end
 
-  it "a class in a belongs_to relationship should notice if it parent changes" do
+  it "a class in a belongs_to relationship should notice if its parent changes" do
 
     response = HTTPResponse.new(@apartment_building_content)
     response_relation = HTTPResponse.new(@apartment_building_inhabitants)
@@ -200,7 +198,12 @@ describe CouchObject::Persistable, "for loading objects:" do
     second_apartment_building.inhabitants.size.should == 1
     apartment_building.inhabitants.size.should == 1
     apartment_building.inhabitants.first.unsaved_changes?.should == false
+    puts "Original: #{second_apartment_building.inhabitants.first.instance_variable_get("@couch_object_original_state")}"
+    puts "     Now: #{second_apartment_building.inhabitants.first.to_json}"
+
+    puts "second_apartment_building.id '#{second_apartment_building.id == nil}'"
     second_apartment_building.inhabitants.first.unsaved_changes?.should == true
+
     
     # Should not save anything at all...
     apartment_building.save