Hibernate Quiz # 3

Hibernate uses this cache by default

It loads objects and make them available to the entire application

it reduces the number of generated SQL queries within a given transaction

It always "associates" with the Session object

Read-only

Write-only

Nonstrict read/write

Read/write

You cannot retrieve objects using native SQL queries in Hibernate

HQL Hibernate Query Language is a full object oriented query language

When you're using get() method to retrieve an object that doesn't exist in the database, Hibernate will throw an exception

When you using load() method to retrieve an object that doesn't exist in the database, Hibernate will return null

delimited

tabular

array

graph

If the timestamp of the most recent update made to the queried table is early than the timestamp of the cached query results, then the cached results are discarded

UpdateTimestampsCache is a special cache region that holds timestamps of the most recent updates to each table

The query cache must be enabled using a Hibernate property setting:hibernate.cache.use_query_cache true

Hibernate allows you to specify a different named cache region for each query

The many to may relationship can be both unidirectional or bidirectional

mappedBy element must be included for the bidirectional many to many relationship

The @JoinColumn and @InverseJoinColumns are used to defined the column names of the foreign keys in the join table

The @JoinTable annotation must be defined on the reverse side of the many to many relation ship

Hibernate component is the lowest level of unit and cannot own other component

We can declare a component of an entity by using <component> element

Component is the user defined class that is persisted to the table of owning entity

Hibernate support both unidirectional and bidirectional composition

It is a persistence engine providing Java Persistence (JPA) support for NoSQL storage solutions

It is expected to be used to interact with all NoSQL solution in all use cases

It reuses Hibernate Core's object life cycle management and (de)hydration engine but persists entities into a key/value store instead of a relational database

It reuses the Java Persistence Query Language (JP-QL) as an interface to querying stored data

cascade ="delete" tells Hibernate to navigate the association when performing delete

cascade="all-delete-orphan" is the same as cascade="all" in addition it deletes any persistent instant when it get dereferenced

cascade="save-update" is the default setup in hibernate

cascade ="none" tells hibernate to ignore association

The default value of discriminatorType element in @DiscriminatorColumn is DiscriminatorType.INTEGER

the @Inheritance annotation is used on the subclass to setup the inheritance mapping strategy

the @DiscriminatorValue annotation is used to specify the value in the in the discriminator column in database

the name element of @DiscriminatorColumn annotation specify the name of table

Caching query will have more impact on applications that perform many inserts, deletes or updates.

The iterate()method of the Session and Query interfaces is provided to take advantage of second-level cache.

The query cache cache all the entities properties returned in the query result set

To enable query cache all it needs is to invoke setCacheable(true) on the query instance.

Path navigation from one entity is a form of outer join.

Join conditions can be specified explicitly by using the 'join' keyword

An inner join between two entities returns the objects from both entity types that satisfy all the join conditions

Join conditions can be specified implicitly as a result of path navigation.

It is called 'second-level' because there is already a cache operating in Hibernate for the duration of an open session

It always "associates" with the Session Factory object

It exists as long as the session factory is alive

By default it effectively holds on to the identifiers for an individual query

entities may be mapped across multiple tables by making use of the @SecondaryTables annotation

The "table" attribute needs to be defined in the @Column annotation to specify which table the column belongs

The @PrimaryKeyJoinColumn annotation specifies the primary key of the primary table

entities may be mapped across multiple tables by making use of the @SecondaryTable annotation

It represents the absence of a lock

All objects switch to this lock mode at the end of a Transaction

Objects associated with the session via a call to update() or saveOrUpdate() also start out in this lock mode

If an object is requested with this lock mode, a WRITE lock will be obtained if it is necessary to actually read the state from the database

The @Inheritance annotation has a "strategy" attribute which can be used to define the inheritance mapping strategy

The @DiscriminatorColumn is used to defined the named of the column that is used to differentiate subclasses

The root class of the hierarchy needs to be marked by the @Inheritance annotation

The @DiscriminatorValue doesn't have default value and must be defined.

The load() method returns null, when the unique id could not found in the database

The load() method returns proxy by default and the data base will not be effected until the invocation of the proxy

The load() method throws an exception,when the unique id could not found in the database

The get() method returns null when the unique id is unavailable in the database.

Log all SQL DDL statements as they are executed

Log all SQL DML statements as they are executed

Log all JDBC parameters

Log the state of all entities

It is more is expensive to query subclass when using join strategy

Join strategy is the most efficient way to insert data

Join strategy is the most efficient way to store data

In join strategy every class will have its state mapped to a different table

Firing of a PostPersist event does not indicate that the entity has committed successfully to the database

If the PERSIST cascade option is set on a relationship of an object that is being persisted and the target object is also a new object, the PrePersist event is triggered on the target object.

The PostLoad callback occurs after the data for an entity is read from the database and the entity instance is constructed.

When the SQL for deletion of an entity gets sent to the database, the PostRemove event will get fired and it indicates success of deletion

hilo

primary

identity

sequence

The query returns a List of Object[] arrays

The query assigns the alias "item" to the class ITEM and alias "bid" to the Bid class

The query returns all combinations of associated Bids and Items

The bids collection of each Item will be eagerly loaded.

An object of value type always has a primary key value in the database

Value type objects belongs to an entity and is embedded in the table row of owning entity

An object of Entity type does NOT have its own database identity

An Entity type object cannot exist independently and has to bond to another object

the Item indicates the name of the entity class and it's case sensitive

The query is using native SQL syntax

the letter I is alias and the "as" keyword must be place in front of the alias

this query is using positional parameter binding

The @JoinColumn must be defined with @OneToMany annotation

The @JoinColumn defines the name of the foreign column

If the relationship is bidirectional mappedBy attribute must be defined for the @OneToMany annotation

The @ManyToOne defines a single-valued association to another entity class that has many-to-one multiplicity.

objects referred by other transient instances are transient

Transient instance is always associated with a row in a database

After a persisted instance gets deleted, it'll become a transient instance

Objects instantiated using new operator aren't persisted immediately and their state is transient.

It does not provide many of the higher-level life cycle semantics

A stateless session does not implement a first-level cache

A stateless session has no persistence context associated with it

Operations performed using a stateless session cascade to associated instances

ON_OPEN

AFTER_TRANSACTION

AFTER_STATEMENT

ON_CLOSE

The query is using outer join

The department objects returned are lazy loaded.

The query will return all departments not matter the department has an employee or not

The query returns a List of Object[] arrays, at index 0 is Department and Index 1 is Employee

Log all first-level cache activity but NOT second-level cache activity

Log NEITHER first-level NOR second-level cache activity

Log both first-level and second-level cache activity

Log all second-level cache activity