CanDeepSave bug in .netTiers v2.0.0.387 ( I think )

The official 2.0 release (v2.0.0.387) has been causing me some DeepSave problems.

 I think I found the source of the problem.  EntityProviderBaseCoreClass.generated.cst  contains a new helper method CanDeepSave.  The following section of code from CanDeepSave I belive contins a bug:

else if ( deepSaveType == DeepSaveType.IncludeChildren )
    {
     if ( innerList.Contains(key) && innerList.HasProperty(entity, key, property) )
     {
      innerList.AddProperty(entity, key, property);
      return true;
     }
    }

I think it should be as follows otherwise the innerList.AddProperty will never get hit. (note the "!"):

 else if ( deepSaveType == DeepSaveType.IncludeChildren )
    {
     if ( innerList.Contains(key) && !innerList.HasProperty(entity, key, property) )
     {
      innerList.AddProperty(entity, key, property);
      return true;
     }
    }

Can anyone confirm this for me?

I have found the same bug in the CanDeepSave logic while working with a many-to-many relationship. The thread is here:

http://community.codesmithtools.com/forums/thread/18625.aspx

I've already tried the fix you suggested but it does not work for my simple many-to-many example. Unfortunately I've been side tracked and haven't had a chance to pursue this any further but it has been reported to the NetTiers group.

Mike 

Hi Mike,

Does deep save work for your 1:N and 1:1 relationships (if you have any?). 

DeepSave was not working for me at all, in any situation, even 1:N which I expect would have affected everyone using the official 2.0 relase. 

My application has 1:N, N:N and 1:1 relationships.  All are working now after that change.  As a double check that the change actually took and was generated correctly you could compare the generated CanDeepSave and CanDeepLoad methods.  The logic in both should be similar. 

Again ... I'm not sure how this is not affecting all DeepSave operations ... perhaps not many people have taken up the final 2.0 relase.

 -GBR

Earlier I had made the change you suggested but the many-to-many still does not persist.

Here's why:

- I call DeepSave for the student, the student is saved
- Inside the student's DeepSave, the TeacherCollection_From_StudentTeacher DeepSave is called
- The teachers are saved
- Then the teachers are DeepSaved
- The teacher's StudentTeacher collection is saved but this collection does not contain anything (I had loaded teachers into the student's StudentTeacher collection)
- When control returns back to the student's DeepSave, the StudentTeacher CanDeepSave is called but returns false because the teacher already has handled the StudentTeachers
- At this point I have a saved student and teacher but not StudentTeacher

Unfortunately in my simple test case I don't have 1:1 or 1:n relationships but I would imagine those would persist fine using your suggested change.

Mike 

I've got the complete fix now. Make your change and modify each DeepSave so that you only call CanDeepSave if there's something that needs to be saved.
This eliminates the teacher snagging StudentTeacher when there's no StudentTeachers related to the teacher.

One example of what I changed:
                        
#region StudentCollection_From_StudentTeacher>
if (entity.StudentCollection_From_StudentTeacher.Count > 0 || entity.StudentCollection_From_StudentTeacher.DeletedItems.Count > 0)
{
    if (CanDeepSave(entity, "List<Student>", "StudentCollection_From_StudentTeacher", deepSaveType, innerList))
    {
        DataRepository.StudentProvider.DeepSave(transactionManager, entity.StudentCollection_From_StudentTeacher, deepSaveType, childTypes, innerList);
    }
}
#endregion

This still does not handle every case though. For example if a student has some StudentTeachers and a teacher also has some different StudentTeachers. The first entity that saves will block all other entities from saving.

Mike 

Howdy,

 Just thought I would say that I have hit some similar CanDeepSave problems.  It looks like the entity tracking is preventing that from deep save from completing all the way.  The entity tracking key remains the same and prevents all child entites in a collection from saving.

   I can post some more details if you are interested... currently too tired to think about it though.

 Adrian.

I also have the exactly same problem :

The CanDeepSave always return false.

I believe the same problem exists for DeepLoad. See Possible BUG : DeepLoad Annoyance

At least I can never get any Childs of Children loaded. Always returns empty. Still haven't been updated on that progress hopefully NetTiers will read this and hopefully get back to us...

i got it to work, by modifying CanDeepSave, if anyone's interested.

CanDeepSave() used to have this:

                else if ( deepSaveType == DeepSaveType.IncludeChildren )
                {
                    if ( innerList.Contains(key) && innerList.HasProperty(entity, key, property) )
                    {
                        innerList.AddProperty(entity, key, property);
                        return true;
                    }
                }

 replace it with this:

                else if ( deepSaveType == DeepSaveType.IncludeChildren )
                {
                    if ( innerList.Contains(key) )
                    {
                        innerList.AddProperty(entity, key, property);
                        return true;
                    }
                }

I had gotten it to work at first by negating the result of innerList.HasProperty(), but that won't work 100% of the time.  I had a scenario where a DeepSave would still not work on some entities 2 levels down the hierarchy from the main entity being saved.  So let's say I was calling DeepSave on a Customer object which has a TList of Orders, each of which in turn has a TList of OrderLines.  It would save the TList<Order>, and the TList<OrderLine> of the first Order it seemed, but it would skip out on the TList<OrderLine> for the rest of the Orders.

Very strange.... 

I just ran into the DeepSave problem tonight. Basically I have:

Customer - 1:N relationship with AcceptedPayment

Customer - 1:N relationship with Address.

---To save a new customer with an address:

Customer newCustomer  = new Customer();

.........set newCustomer properties

Address newAddress  = new Address();

............set newAddress properties

newCustomer.AddressCollection.Add(newAddress);

Type[] typesToDeepSave = new Type[] { typeof(TList<Address>)};

DataRepository.CustomerProvider.DeepSave(newCustomer, DeepSaveType.IncludeChildren, typesToDeepSave);

The new address didn't get saved. After modifying the CanDeepSave as suggested above, it's saved!

However, here is a strange problem that happens both before and after the fix...Even though I didn't specify AcceptedPaymentin my "typesToDeepSave",  the save would insert several rows of AcceptedPayment into the database. I haven't been able to trace it. I happened to came across this thread, so just wanted to see if anyone else had the same type of problem...BTW, I'm totally a .netTiers newbie, so any help would be very appreciated!

Does anyone know the last version of .NetTiers where deep saving was working?

Thanks Robert for working on this and getting back to us!!!

-Chris

Robert,

how's it going on this issue?  Making any headway? 

With CodeSmith 4.0 out the door, i've finally been able to have to some time to finish this.  And for being so patient with us, I added a nice treat.  There's one problem with composite primary keys on m2m that i'm trying to fix right quick before I post it.

 So this is what it looked like before.

So this becomes:

    LeftTable left = new LeftTable();

    left.LeftColumnName = "MyLeftName2";

    RightTable right = new RightTable();

    right.RightColumnName = "MyRightName2";

    RightTable right2 = new RightTable();

    right2.RightColumnName = "MyRightName3";

    RightTable right3 = new RightTable();

    right3.RightColumnName = "MyRightName4";

    left.RightTableCollection_From_RightLeftJunction.Add(right);

    left.RightTableCollection_From_RightLeftJunction.Add(right2);

    left.RightTableCollection_From_RightLeftJunction.Add(right3);

    using (TransactionManager tm = DataRepository.Provider.CreateTransaction())

    {

        tm.BeginTransaction();

        DataRepository.LeftTableProvider.DeepSave(tm, left);

        tm.Commit();

    }

This has been tested with a few databases that I have, but it would be great if you guys could give it a spin.

I've changed the way the internals of the DeepSave work as well, they don't work off the keys and properties names anymore.  They just use a WeakReference to track if the collection or entity has been loaded.  I have not implemented this on the deep load just yet, wanted to verify all was well with DeepSave before I stuck my head in DeepLoad.  Should not be that difficult to implement.