PHP5 Hosting, Java , Jsp, J2Ee, Struts, Servlets And Jboss Blog

Integrating legacy databases …
You don t have to join a component; you can as well join individual properties or even a (we did this in the previous chapter for optional entity associations). By setting optional=”true”, you indicate that the component property may also be null for a User with no billingAddress, and that no row should then be inserted into the secondary table. Hibernate also executes an outer join instead of an inner join to retrieve the row from the secondary table. If you declared fetch=”select” on the mapping, a secondary select would be used for that purpose. The notion of a secondary table is also included in the Java Persistence specification. First, you have to declare a secondary table (or several) for a particular entity: @Entity @Table(name = “USERS”) @SecondaryTable( name = “BILLING_ADDRESS”, pkJoinColumns = { @PrimaryKeyJoinColumn(name=”USER_ID”) } ) public class User { … }
Looking for affordable and reliable webhost to host and run your business application? Then look no more and go to servlet web hosting services.

CHAPTER 8 Legacy databases and custom SQL mapping to create a literal join condition from the association table to the entity table(s). Unfortunately, at the time of writing, Hibernate Annotations doesn t support arbitrary join conditions expressed with formulas. The grouping of properties under a reference name also wasn t possible. We expect that these features will closely resemble the XML mapping, once they re available. Another issue you may encounter in a legacy schema is that it doesn t integrate nicely with your class granularity. Our usual recommendation to have more classes than tables may not work, and you may have to do the opposite and join arbitrary tables into one class. 8.1.3 Joining arbitrary tables We ve already shown the mapping element in an inheritance mapping in chapter 5; see section 5.1.5, Mixing inheritance strategies. It helped to break out properties of a particular subclass into a separate table, out of the primary inheritance hierarchy table. This generic functionality has more uses however, we have to warn you that can also be a bad idea. Any properly designed system should have more classes than tables. Splitting a single class into separate tables is something you should do only when you need to merge several tables in a legacy schema into a single class. Moving properties into a secondary table Suppose that in CaveatEmptor, you aren t keeping a user s address information with the user s main information in the USERS table, mapped as a component, but in a separate table. This is shown in figure 8.4. Note that each BILLING_ADDRESS has a foreign key USER_ID, which is in turn the primary key of the BILLING_ ADDRESS table. To map this in XML, you need to group the properties of the Address in a element: Figure 8.4 Breaking out the billing address data into a secondary table
We recommend high quality webhost to host and run your jsp application: christian web host services.

Integrating legacy databases Hence, another join condition is appended: i.ITEM_ID = b.ITEM_ID. You can expand this and add more join conditions if you need additional restrictions. Note that an outer join is generated because the item in question may not have a successful bid, so NULL is returned for each b.* column. You can now call anItem.getSuccessfulBid() to get a reference to the successful bid (or null if none exists). Finally, with or without database constraints, you can t just implement an item.setSuccessfulBid() method that only sets the value on a private field in the Item instance. You have to implement a small procedure in this setter method that takes care of this special relationship and the flag property on the bids: public class Item { … private Bid successfulBid; private Set bids = new HashSet(); public Bid getSuccessfulBid() { return successfulBid; } public void setSuccessfulBid(Bid successfulBid) { if (successfulBid != null) { for (Bid bid : bids) bid.setSuccessful(false); successfulBid.setSuccessful(true); this.successfulBid = successfulBid; } } } When setSuccessfulBid() is called, you set all bids to not successful. Doing so may trigger the loading of the collection a price you have to pay with this strategy. Then, the new successful bid is marked and set as an instance variable. Setting the flag updates the SUCCESSFUL column in the BID table when you save the objects. To complete this (and to fix the legacy schema), your database-level constraints need to do the same as this method. (We ll come back to constraints later in this chapter.) One of the things to remember about this literal join condition mapping is that it can be applied in many other situations, not only for successful or default relationships. Whenever you need some arbitrary join condition appended to your queries, a formula is the right choice. For example, you could use it in a
We recommend cheap and reliable webhost to host and run your web applications: Coldfusion Web Hosting services.

CHAPTER 8 Legacy databases and custom SQL Ignore the association mapping in this example; this is the regular one-tomany association between Item and Bid, bidirectional, on the ITEM_ID foreign key column in BID. NOTE Isn t used for primary key associations? Usually, a mapping is a primary key relationship between two entities, when rows in both entity tables share the same primary key value. However, by using a formula with a property-ref, you can apply it to a foreign key relationship. In the example shown in this section, you could replace the element with , and it would still work. The interesting part is the mapping and how it relies on a property-ref and literal formula values as a join condition when you work with the association. Working with the association The full SQL query for retrieval of an auction item and its successful bid looks like this: select i.ITEM_ID, i.INITIAL_PRICE, … b.BID_ID, b.AMOUNT, b.SUCCESSFUL, b.BIDDER_ID, … from ITEM i left outer join BID b on ‘T’ = b.SUCCESSFUL and i.ITEM_ID = b.ITEM_ID where i.ITEM_ID = ? When you load an Item, Hibernate now joins a row from the BID table by applying a join condition that involves the columns of the successfulReference property. Because this is a grouped property, you can declare individual expressions for each of the columns involved, in the right order. The first one, ‘T’, is a literal, as you can see from the quotes. Hibernate now includes ‘T’ = SUCCESSFUL in the join condition when it tries to find out whether there is a successful row in the BID table. The second expression isn t a literal but a column name (no quotes).
Searching for affordable and reliable webhost to host and run your web applications? Go to our java web server services and you will be pleased.

Integrating legacy databases … … … The type=”true_false” attribute creates a mapping between a Java boolean primitive (or its wrapper) property and a simple CHAR(1) column with T/F literal values it s a built-in Hibernate mapping type. You again group several properties with
under a name that you can reference in other mappings. What is new here is that you can group a , not only basic properties. The real trick is happening on the other side, for the mapping of the success fulBid property of the Item class: ‘T’ ITEM_ID
Check Tomcat Web Hosting services for best quality webspace to host your web application.

CHAPTER 8 Legacy databases and custom SQL one-to-one, is needed to single out one particular Bid instance as the winning bid. You map the first association because you d like to be able to get all the bids for an auctioned item by calling anItem.getBids(). The second association allows you to call anItem.getSuccessfulBid(). Logically, one of the elements in the collection is also the successful bid object referenced by getSuccessfulBid(). The first association is clearly a bidirectional one-to-many/many-to-one association, with a foreign key ITEM_ID in the BID table. (If you haven t mapped this before, look at chapter 6, section 6.4, Mapping a parent/children relationship. ) The one-to-one association is more difficult; you can map it several ways. The most natural is a uniquely constrained foreign key in the ITEM table referencing a row in the BID table the winning row, for example a SUCCESSFUL_ BID_ID column. Legacy schemas often need a mapping that isn t a simple foreign key relationship. Mapping a formula join condition Imagine that each row in the BID table has a flag column to mark the winning bid, as shown in figure 8.3. One BID row has the flag set to true, and all other rows for this auction item are naturally false. Chances are good that you won t find a constraint or an integrity rule for this relationship in a legacy schema, but we ignore this for now and focus on the mapping to Java classes. To make this mapping even more interesting, assume that the legacy schema didn t use the SQL BOOLEAN datatype but a CHAR(1) field and the values T (for true) and F (for false) to simulate the boolean switch. Your goal is to map this flag column to a successfulBid property of the Item class. To map this as an object reference, you need a literal join condition, because there is no foreign key Hibernate can use for a join. In other words, for each ITEM row, you need to join a row from the BID table that has the SUCCESSFUL flag set to T. If there is no such row, the anItem.getSuccessfulBid() call returns null. Let s first map the Bid class and a successful boolean property to the SUCCESSFUL database column: Figure 8.3 The winning bid is marked with the SUCCESSFUL column flag.
From our experience, we can recommend PHP5 Web Hosting services, if you need affordable webhost to host and run your web application.

Integrating legacy databases Fortunately, it s often straightforward to clean up such a schema by refactoring foreign keys to reference primary keys if you can make changes to the database that don t disturb other applications sharing the data. This completes our exploration of natural, composite, and foreign key-related problems you may have to deal with when you try to map a legacy schema. Let s move on to other interesting special mapping strategies. Sometimes you can t make any changes to a legacy database not even creating tables or views. Hibernate can map classes, properties, and even parts of associations to a simple SQL statement or expression. We call these kinds of mappings formula mappings. 8.1.2 Arbitrary join conditions with formulas Mapping a Java artifact to an SQL expression is useful for more than integrating a legacy schema. You created two formula mappings already: The first, Using derived properties, in chapter 4, section 4.4.1, was a simple derived read-only property mapping. The second formula calculated the discriminator in an inheritance mapping; see chapter 5, section 5.1.3, Table per class hierarchy. You ll now apply formulas for a more exotic purposes. Keep in mind that some of the mappings you ll see now are complex, and you may be better prepared to understand them after reading all the chapters in part 2 of this book. Understanding the use case You now map a literal join condition between two entities. This sounds more com plex than it is in practice. Look at the two classes shown in figure 8.2. A particular Item may have several Bids this is a one-to-many association. But it isn t the only association between the two classes; the other, a unidirectional Figure 8.2 A single-association that references an instance in a many-association
We recommend cheap and reliable webhost to host and run your web applications: Coldfusion Web Hosting services.

CHAPTER 8 Legacy databases and custom SQL Figure 8.1 A composite foreign key references a composite primary key. …
As you can see, the
element is useful not only to give several properties a name, but also to define a multicolumn unique constraint or to make several properties immutable. For the association mappings, the order of columns is again important: …
You want to have a cheap webhost for your apache application, then check apache web hosting services.

Integrating legacy databases further thing to note is that property-ref requires the target property to be unique, so unique=”true”, as shown earlier, is needed for this mapping. If you try to map this association with JPA annotations, you may look for an equivalent to the property-ref attribute. You map the association with an explicit reference to the natural key column, CUSTOMER_NR: @ManyToOne @JoinColumn(name=”SELLER_NR”, referencedColumnName = “CUSTOMER_NR”) private User seller; Hibernate now knows that the referenced target column is a natural key and manages the foreign key relationship accordingly. To complete this example, you make this association mapping between the two classes bidirectional, with a mapping of an itemsForAuction collection on the User class. First, here it is in XML: …
Again the foreign key column in ITEM is mapped with a property reference to customerNr. In annotations, this is a lot easier to map as an inverse side: @OneToMany(mappedBy = “seller”) private Set itemsForAuction = new HashSet(); Composite foreign key referencing nonprimary keys Some legacy schemas are even more complicated than the one discussed before: A foreign key might be a composite key and, by design, reference a composite natural nonprimary key! Let s assume that USERS has a natural composite key that includes the FIRSTNAME, LASTNAME, and BIRTHDAY columns. A foreign key may reference this natural key, as shown in figure 8.1. To map this, you need to group several properties under the same name otherwise you can t name the composite in a property-ref. Apply the
element to group the mappings:
If you are in need for cheap and reliable webhost to host your website, we recommend http web server services.