# JPA

## Java Persistance API
## Entity Types
- @OneToOne
	- One Entity related to one other
- @OneToMany
	- One entity is related to many entities (List, Set, Map, SortedSet, SortedMap)
- @ManyToOne
	- Inverse of OneToMany
- @ManyToMany 
	- Many entities are related to many entities
	- Each has a List or Set reference to the other
 	- A join table is used to define relationships
- Unidirectional - mapping is only done one way, one side does not know about relationship
- Bidirectional - both entities know about each other (reccommended by hibernate)

The "Owning Side" of a relationship will hold the foreign key in the database.

## Fetch Type
- Lazy Fetch Type - Data is not queried until referenced
- Eager Fetch Type - Data is queried up front
- Hibernate 5 supports the JPA 2.1 Fetch Type Defaults:
	- OneToMany - Lazy
	- ManyToOne - Eager
	- ManyToMany - Lazy
	- OneToOne - Eager
## Cascade Types 
If I delete the parent will the child be deleted as well?
- JPA Cascade Types control how state changes are cascaded from parent objects to child objects
- JPA Cascade Types
	- PERSIST - Save operations will cascade to related entities
	- MERGE - related entities are merged when the owning entitiy is merged
	- REFRESH - related entities are refreshed when the owning entity is refreshed
	- REMOVE - removes all related entities when the owning entity is deleted
	- DETACH - detaches all related entities if a manual detach occurs
	- ALL - Applies all the above cascade options.

By default, no operations are cascaded

## Embeddable Types
- JPA/Hibernate support emeddable types
- These are used to define a common set of properties
- For example, a package with a shipping and billing address

## Inheritance
- MappedSuperclass - Entities inherit from a super class. A database table IS NOT created for the super class.
- Single Table - (Hibernate Default) - One Table is used for all subclasses
	- This can lead to a lot of unused database columns
- Joined Table - Base class and subclasses have their own tables. 
	- Fetching subclass entities require a join to the table of the superclass. (could cause preformance issues)
- Table Per Class - Each subclass has its own table.

### Create and Update Timestamps
- For audit purposes it is often a best practice to use timestamps
- JPA supports @Prepersist and @PreUpdate which can be used to support audit timestamps via JPA lifecycle callbacks.
- Hibernate provides @CreationTimestamp and @UpdateTimestamp