I'm working on a genealogy project. The problem is with two tables - the Person and Marriage tables.
The marriage class looks like this:
class Marriage implements Serializable{
Person husband
Person wife
String notes
}
The primary key is the husband.id and the wife.id.
The person class looks like this:
Class Person{
//lots of members
Marriage parents
}
Everything works, except adding parents to a person that's already created, but without parents, i.e. updating the person. There's no problem getting the right marriage to add to this person. Creating a person from scratch and adding a marriage to him works. I use much the same code. It works for save() but not for update()
Here's the problem: org.hibernate.TransientObjectException - object references an unsaved transient instance - save the transient instance before flushing: - it's the Marriage object. It exists in the database and is clearly visible. Using the Grails console I have no problem accessing it.
I've tried belongsTo and hasOne, no go.
Any idea what to do? I'd like to keep the composite key, it causes me no problems and prevents the same two people entering in another marriage - the notes can deal with that if they do.
what you see in the DB CAN NOT cause the TransientObjectException.
It looks like you are trying to save an perso instance, the marriage instance cannot be saved.
Print out the errors properties for both objects to see if they can be saved
Related
Hi I have a simple problem.
My domain class is like this:
class Example {
long seq
hasMany = [example_array: ExampleData]
long count
}
class ExampleData {
String type
long description
static belongsTo = Example
static constraints = {
}
}
This results in 3 tables, like a many to many relation.
Why is this?
Thanks
The reason for the extra table is that you've modeled the relation only in one direction - an Example can access its ExampleData instances via the example_array Set that's added to your class bytecode because of the hasMany property, but an ExampleData instance has no way to reference its owning Example.
You added a belongsTo property, but only specified the class name. That's sufficient to configure ownership, cascaded deletes, etc. but doesn't provide a property in the class to access the Example instance.
If you change it to the other supported syntax it will work as you expected:
static belongsTo = [example: Example]
Here example will end up being the name of an Example property (and you can change it and/or example_array to any valid property name), which is basically the same as declaring
Example example
Now that both sides can access the other, the relationship is bidirectional and you no longer need the third table. That's because a 1-many is typically implemented using a foreign key in the child table, in this case in the table for ExampleData that points to the table for Example. That wasn't possible without a property in the class to wire up to that column, so the join table was necessary.
I believe that you have to map the BelongsTo, like this:
static belongsTo = [example:Example]
Hope it helps :)
From the definition of hasMany Grails will, by default, map this kind of relationship with a join table.That join table is the 3rd table you mentioned.No need to worry about that.
Well the one-to-many relationship is constructed by having additional table (i.e. Example_ExampleData) containing two columns each id fields from tables of the entities forming the relationship(i.e. Example and ExampleData).
The newly added table is child to parent tables – Example and ExampleData.
So in your case when you run your application the 3rd table gets created by Grails by default as your table relationship falls under the one-to-many relationship.
I'm using the Grails wiki example to setup a many-to-many relationship. When I make the Membership.unlink(employee, team) call, the m.delete causes the "Deleted object would be re-saved by cascade" error and I can't seem to get around this.
When you delete an instance that is linked to a hasMany relationship, you also have to remove the object from the 'many' side. For example:
employee.removeFromTeam(team)
employee.delete(flush: true)
It looks like in your example, you likely have a Membership class which holds a Team and an Employee relationship. In this case, you'll need to do the following:
membership.removeFromTeam(team)
membership.removeFromEmployee(employee)
membership.delete(flush: true)
Hi I am getting some strange activity from a many to many in grails.
It seems to be calling its self recursively.
my domains are set up like:
Product domain:
class Product {
String name
String comments
static hasMany = [components:Components]
}
Component domain:
class Components {
Product product
static hasMany = [alternatives:Product]
static belongsTo = Product
}
This seems to be causing a infinate loop and not saving the components correctly.
I know when using JSON.use("deep") on a Product I get a ../.. in components. The next strange thing is that. If I as for a product as JSON after I saved that product everything works fine, but when I try and get the same product as JSON later I get the ../.. in components.
I am totally lost about this.
If you require more details please let me know and I will me best to comply.
If you're going to have a many-to-many relationship you need to store the relationship data somewhere. If your relationship was one-to-many you could store them in the client table (like how you already have a component having one specific product in your component table) but in many to many you need the relationship to be its own table. To do this in Grails, use the JoinTable attribute or create a separate domain class to handle the relationship. Probably the fact that you have one-to-many relationship with Product already for Components and the many-to-many relationship with no join table is why you are getting the weird recursion issue.
I'm having some problems getting a one to many relationship in grails working properly.
I have a person instance and this person has relationships to other persons. This relationship is defined in a relationship object.
The relevant code is as follows.
class Person {
static hasMany = [relationships:Relationship]
String name
}
class Relationship {
Person relationShipTo
// Enum containing married, living together, parent etc.
RelationshipType typeOfRelationship
}
Now what i want is a one to many reference to that relationship to be persisted but what happens in grails is that it seems to think the relationShipTo instance is refering back to the Person that has this relationship with someone else, and not to the other person.
So a person has a reference to a relationship, and that relationship has a type and a reference to the person with whom you have a relationship with.
I'm not able to change the domain model for this. Is there any way of accomplishing what i want?
What is currently happening if i use the generated views and controllers for the Relationship and try to create a relationship with a type and a person it is refering to, only the type is persisted and the person is ignored. When i then try to add it to the person in the persons edit or create page, all the relationShipTo properties of the relationships i add is saved with the id of the person.
Hopefully what i wrote is understandable.
Finally got it working.
Had to add a static mappedBy =[relationship: 'belongsTo'] to person
and a static belongsTo = [belongsTo: Person].
Not exactly how i wanted it but it works and is an ok compromise
Currently I'm having some trouble, creating an unidirectional relationship in Grails.
I have a class Toilet with an Attribute Address.
This Address is a seperate class.
The Address can - theoretically - still exist, if the Toilet-Object, which the Address is associated with, gets deleted.
The toilet will stay, too, if the address gets deleted.
GORM's hasOne is not what i need, because it creates a bidirectional relation.
Defining an attribute of the type class only results in a non-persisted Address (despite it's own table) - that means, the association of the Address to the Toilet-Object doesn't exist
I'm not really familiar with these kinds of relationships, so I would really appreciate a solution or another way to accomplish my goal
Hope my problem is clear - if not comment, and I will try to add further explanations
taken from
http://grails.org/doc/1.0.x/guide/5.%20Object%20Relational%20Mapping%20(GORM).html
5.3.3 Understanding Cascading Updates and Deletes
It is critical that you understand how cascading updates and deletes work when using GORM. The key part to remember is the belongsTo setting which controls which class "owns" a relationship.
Whether it is a one-to-one, one-to-many or many-to-many if you define belongsTo updates and deletes will cascade from the owning class to its possessions (the other side of the relationship).
If you do not define belongsTo then no cascades will happen and you will have to manually save each object.
So.....if you do not use belongsTo then if you manually save each object you should not have a problem.
If the address on Toilet is a simple association without a hasOne or belongsTo mapping, then no operations will be cascaded.
That means you'll have to save the address, assign it toilet.address, and save the toilet.
Found the solution.
What I left out, was the implemenation of an interface in the Toilet class.
The problem was (as a reminder) that the relationship of the address within the toilet class wasn't saved to the database.
This was a problem of the interface itself - in this interface, getters and setters were defined and had to be implemented (the way an interface works - obviously). The problem here was, that the setter of the Address-Attribute expected the Type IAddress.
I overloaded the setter to also receive a parameter of the type Address.
With this change, the relationship between Toilet and Address is saved correctly to the database - the ID of the Address is saved in the table of the Toilet.
I think the definition of the setter is just a mistake (i have no influence on the interface), but with this workaround i can get it to work anyways
Hope this explanation helps others too.
Why not have a class which models the association ?
class ToiletAddress {
Toilet toilet
Address address
...
}
... and then simply wrap your logic into a service where you assign addresses to toilets, and delete toilets or addresses.
Using constraints you can define what kind of association it is. eg 1-1, 1-n (both sides), and n-m
static constraints = {
address unique: ['toilet']
toilet validator: {val, obj -> ... }
}