Hi,

Please explain me this -

From chapter 1 page 17..
It isn’t possible to determine the multiplicity of a unidirectional association by looking only at the Java classes.

Then the author says ....

Java associations can have many-to-many multiplicity.
For example, the classes could look like this:

public class User {
private Set billingDetails;
...
}
public class BillingDetails {
private Set users;
...
}

Does the second sentence explains what the first sentence has to say, if yes...how?

Or simply put...why the author says what he says in the first sentence

Also: Please see the questions inline following the bolds

For example, if you need to retrieve a User and aren’t interested in the
user’s billing information, you can write this simple query:
select * from USERS u where u.USER_ID = 123
On the other hand, if you need to retrieve a User and then subsequently visit each
of the associated BillingDetails instances (let’s say, to list all the user’s credit
cards), you write a different query:
select *
from USERS u
left outer join BILLING_DETAILS bd on bd.USER_ID = u.USER_ID
where u.USER_ID = 123
As you can see, to efficiently use joins you need to know what portion of the object network {in our example what would be that portion?}you plan to access when you retrieve the initial {what is the significance of this word?} User—this is before you start navigating the object network!{the object n/w formed in memory by executing the above query or the resulting java object n/w?}
On the other hand, any object persistence solution provides functionality for fetching the data of associated objects only when the object is first accessed. However, this piecemeal style of data access is fundamentally inefficient in the context of a relational database, because it requires executing one statement for each node or collection of the object network that is accessed. This is the dreaded n+1 selects problem.
This mismatch in the way you access objects in Java and in a relational database is perhaps the single most common source of performance problems in Java applications. {could you give an example to explain how the mismatch leads to this performance problem?} There is a natural tension between too many selects and too big selects, which retrieve unnecessary information into memory. {could you put it in other words, I mean if both are bad what is the tension?}

Thanks,

Ammar

Since I've already explained all that stuff in the book, I don't know how to explain it any different. Maybe someone else wants to have a go and break this down into smaller pieces...

Well, I can spare five minutes right now but that's really all from me:

- "What portion of the object network..." The user and his billingdetails, read the query.

- "initial" The user instance that we wanted to _initially_ load.

- "the object n/w formed in memory by executing the above query or the resulting java object n/w" That is the same thing.

- "could you give an example to explain how the mismatch leads to this performance problem" Really, the second half of the book is only about this problem, with hundreds of examples. This is a sentence from the first chapter, you need to actually read the rest of the book to understand it fully.

- "could you put it in other words, I mean if both are bad what is the tension" Well, if you have two choices, and there are both bad, there is tension, no?

OK, so I now see that all your questions are about the first chapter. Please continue reading, there is a reason why the book has more than one chapter :)

Thanks Christian,

If you could explain one thing that was left..

From chapter 1 page 17..
It isn’t possible to determine the multiplicity of a unidirectional association by looking only at the Java classes.

Then the author says ....

Java associations can have many-to-many multiplicity.
For example, the classes could look like this:

public class User {
private Set billingDetails;
...
}
public class BillingDetails {
private Set users;
...
}

Does the second sentence explains what the first sentence has to say, if yes...how?

Or simply put...why the author says what he says in the first sentence.

Regards,

Ammar (I'll definately read whole of the beautiful book)

Take a pen, add to the sentence "It isn’t possible to determine the multiplicity of a unidirectional association by looking only at the Java classes" the following ", which should be obvious, because unidirectional implies that you are looking at one class only. So you can't see the other 'side', and you obviously can't find out what the multiplicity is going to be."