Group items tagged

What happens when you perform a query on a type that has subclasses?

It turns out support for inheritance in queries (as well as JPA) is built in

do not actually need to do anything other than have one entity inherit from another entity to get everything to work

book entity inherit from the Resource entity

Introduce a new entity type called Resource

Change the BookDao to be a ResourceDao

Update the methods returning Book and have them instead return Resource

Update all references to Book and replace them with Resource

Change the bookId to resourceId

For INSERT statements where the number of rows to be inserted is known at the beginning of processing the statement, InnoDB quickly allocates the required number of auto-increment values without taking any lock, but only if there is no concurrent session already holding the table-level AUTO-INC lock (because that other statement will be allocating auto-increment values one-by-one as it proceeds)

innodb_autoinc_lock_mode = 0 (“traditional” lock mode)

special table-level AUTO-INC lock is obtained and held to the end of the statement

lock mode is provided for:

innodb_autoinc_lock_mode = 1 (“consecutive” lock mode)

important impact of this lock mode is significantly better scalability

This mode is safe for use with

innodb_autoinc_lock_mode = 2 (“interleaved” lock mode)

This is the fastest and most scalable lock mode

but it is

Using auto-increment with replication

set innodb_autoinc_lock_mode to 0 or 1 and use the same value on the master and its slaves

If you are using

all of the auto-increment lock modes are safe

@MappedSuperclass

Important things on ID/UID

entity lives in three layers:

Flex client

JPA persistence context

database

id is defined and is maintained in the three layers during the different serialization/persistence operations

most common solution is to

which is created by the client and persisted along with the entity

recommended approach to avoid any kind of subtle problems is to have a real uid property which will be persisted in the database but is not a primary key for efficiency concerns

You can now ask Tide to

Flex with the following API :

EntityGraphUnintializer

Person object will be uninitialized

uperson contains

to correctly merge your changes in the server persistence context

Tide uses the

to determine which parts of the graph need to be sent

Calling the EntityGraphUninitializer manually is a bit tedious and ugly, so there is a cleaner possibility when you are using generated typesafe service proxies

in the Flex application, register the UninitializeArgumentPreprocessor component in Tide as follows :

[UninitializeArgumentPreprocessor]

all calls to PersonService.save() will

of the person argument.

15.4. Dirty Checking and Conflict Handling

simplify the handling of data between Flex and Java EE

Chapter 15. Data Management

Tide maintains a client-side cache of entity instances and ensures that every instance is unique in the Flex client context

 uid().hashCode();

Tide currently only supports Integer or Long version fields, not timestamps and that the field must be nullable

in a multi-tier environment (@Version annotation)

highly recommended to use

highly recommended to add a

in general this identifier will be

@Column(name="ENTITY_UID", unique=true, nullable=false, updatable=false, length=36)     private String uid;

uid().equals(((AbstractEntity)o).uid())

consistent identifier through all application layers

@PrePersist

15.3. Reverse Lazy Loading

15.4. Dirty Checking and Conflict Handling

15.4. Dirty Checking and Conflict Handling

15.4. Dirty Checking and Conflict Handling

Dirty Checking and Conflict Handling

entity instance can be in two states :

Stable

Dirty

property meta_dirty is

could be used

to enable/disable a Save button

correct way of knowing if any object has been changed in the context, is to use the property meta_dirty of the Tide context

tideContext.meta_dirty

reliable when using optimistic locking

check that its @Version field has been incremented