We have a client server app and we send the eclipselink entities from the server to the client using eclipselink copygroups. It is terribly great in the sense that we don't have to create DTOs as we can decide what parts of the object graph get serialized and we can keep all the business logic and validation in the domain model (entities).

One downside of it is that in order for this to work we need to statically weave the classes as the client side doesn't have a persi

We have released Forums Libre 2.0.

This release includes many new features such as:

• New rich "wysiwyg" editor.
• New HTML source editor.

We have migrated to a new, more powerful server.

All data has been migrated, and everything remains the same, except the IP address is new.

It should be possible, but sounds like you may have hit a bug (ensure you are using the latest version/patch). Try checking if the bug is already logged on Eclipselink's Bugzilla, vote it up, or log a new one.

You might want to try a @VariableOneToOne instead, then you can store a type indicator to the target subclass. Otherwise you could change the inheritance to JOINED, or remove the relationship, and just query for it.

I have an abstract @Entity with @Inheritance(strategy=TABLE_PERCLASS) called Booking.

Is it possible to have an @Entity Payment.java with a @ManyToOne relationship to the abstract class?

We all have affiliate links, programs, and networks that we promote. Some we earn commissions off of just for signups. Help each other out by signing up for each others links. Each of us will earn and it helps our community!

We all need some help now and then. Help to increase each others likes and followers. Be sure to like and follow those that help you!

Welcome to the Christmas forum, a forum to discuss Christmas and the season of giving.

Ask questions on what gifts to buy, talk about what to cook, what to do, where to go, and in general spread Christmas cheer.

Please feel free to post anything music related in our forums, Thanks!

I would assume you have a @OneToMany in the Locality that is holding the reference and changes. I can't see it recording changes otherwise. What attribute in the ObjectChangeSet is it under?

If it is still tracking changes, then it doesn't know it is detached. You may want to clone it or copy it to force it to be detached. (em.detach(), doesn't really do anything).

James,

Thank you for your help.

Do you have a job opportunity you would like to present to others? Share it here!

Pozdravljeni,

postavil sem poskusni forum, ker iščem najbolj ugodno rešitev za umestitev na mojo spletno stran.

Discussion

In Need Of Help?

What Are Your Best Earners.

Share Your Tips With Each Other.

FORUMS libre believes you should get paid for your posts.

FORUMS libre lets you add your own ads to your forum, or account to let you make advertising revenue from your forum or posts.

The root of your problem is that something is holding onto the old EntityManagers. After the end of the transaction the container should be releasing references to them and they should be free to garbage collect, so it should not matter what they reference.

Ensure that nothing in your app references any of the entity objects, as they can hold a reference to their entity manager and prevent gc. Also what is the @Yam annotation, check that it is not holding a reference. Try using

We are using EL with JTA on glassfish

We are trying to insert about 1M records

Perhaps I'm naive, but I always thought Java serialization must surely be the fastest and most efficient way to serialize Java objects into binary form. After all, Java is on it's 7th major release, so this is not new technology, and since every JDK seems to be faster than the last, I incorrectly assumed serialization must be very fast and efficient by now. I thought, since Java serialization is binary, and language dependent, it must be much faster and more efficient than XML or JSON. Unfort

EclipseLink 2.5 added several new JPQL features and supported syntax.
These include:

• HQL compatibility
• Array expressions

One of the most effective database optimizations is batch writing. Batch writing is supported by most modern databases and part of the JDBC standard and is supported by most JPA providers.

Normal database access consists of sending each DML (insert, update, delete) statement to the database in a separate database/network access. Each database access has a certain amount of overhead to it, and the database must process each statement independently. Batch writing has two forms, dynamic an

Most data models define a sequence generated numeric primary key. This is the most efficient key to use as it is a single efficient guaranteed unique value. Some applications also use a UUID, which is a little less efficient in terms of time and space, but has its advantages in distributed systems and databases.

In JPA the primary key is defined as the JPA Id, and since JPA's object cache is indexed by Id, any queries by this Id obtain cache hits, and avoid database access. This is grea

The website was updated today. The changes include forum subscriptions, mobile and widescreen interface, user ads, JavaScript SDK, and many minor fixes and enhancements.

Subscriptions

Caching is the most valuable optimization one can make in software development. Making something run faster is nice, but it can never beat not having to run anything at all, because you already have the result cached.

JPA caches many things. The most important thing to cache is the EntityManagerFactory, this is generally done for you in JavaEE, but in JavaSE you need to do this yourself, such as storing it in a static variable. If you don't cache your EntityManagerFa

I'm sorry to disappoint those of you looking to see some canned benchmark showing how EclipseLink dominates over all competitors in performance and scalability.

It is not that this would be difficult to do, or that I don't have such a benchmark that shows this, but that I give the JPA community credit for not attributing much weight to a benchmark produced by a single JPA provider that shows their JPA product excels against their competitors. If you really want such a benchmark, scroll to

One of the most common questions I see on JPA, is users wanting to know how to write some specific SQL query as a JPQL query. Some of the time, they just need to learn JPQL, and their SQL can easily be converted to JPQL. Other times their SQL is using one of the many features on SQL that are not provided in JPQL, and their only option is to use a native SQL query.

In EclipseLink 2.4, we have greatly enhanced our JPQL support to support most features of SQL. I refer to EclipseLink's JPQ

JPA deals with objects, and SQL deals with rows. Some developers love JPA because it allows them to use objects in an object-oriented fashion. However, other developers have trouble understanding JPA precisely because it is object-oriented.

Even though object-oriented programming has been popular for several decades, there are still a lot of procedural languages out their. Developers used to procedural programming have a different mindset than object-oriented developers. This

In the beginning data was free and wild. It was not confined to rows and columns and not bounded to standardization. Data access was unruly and proprietary. These were the first "NoSQL" databases. They consisted of flat file, hierarchical and network databases such as VSAM, IMS and ADABASE.

Then there was SQL, and things were good.

SQL was developed during the golden age of data in the 1970s. Database access became standardized through the SQL language and the

The Java Persistence API (JPA) provides a rich persistence architecture. JPA hides much of the low level dull-drum of database access, freeing the application developer from worrying about the database, and allowing them to concentrate on developing the application. However, this abstraction can lead to poor performance, if the application programmer does not consider how their implementation affects database usage.

JPA provides several optimization features and techniques, and

In Enterprise Java most of the effort is normally done to scale the mid-tier application and its server.  Pretty much every Java application server supports clustering and scaling out the application to several mid-tier machines.  Even if the application server does not officially support clustering, it is normally pretty easy to have a "cluster" of application servers fronted by a round-robin load-balancer.  This would even work with something as simple as Tomcat.

You can register a SessionEventListener with your session (eclipselink.session-event-listener).

You can see its JavaDoc here,

In EclipseLink 2.5.2, I would like to somehow register a listener for whenever cache coordination messages have been received and processed by EclipseLink.

The listener would have to have a collection of coordinated entities passed in as an argument, so that my code could perform different logic depending on what entities were coordinated.

HEX is a standard why to convert from binary data to character data. It is useful in web development when you need to encode binary data in HTML or XML. HEX conversion is also useful when storing binary data in a database character field.

HEX is a base 16 numbering system, so 1-9 are the same, and the letters A-F are used for 10-15. So in HEX 10 = 16, 100 = 256, AA = 170, FF = 255. HEX conversion encodes each byte as two HEX characters, so the encoded string will be twice the siz

Hi Montechristos,

QueryHints and ResultType are in the org.eclipse.persistence.config package.

Hi James,

I saw an old post of yours about EclipseLink and how to hint it to return a map.

test

Přidej vtip

Concurent Maps

The main difference between Hashtable and HashMap is that Hashtable is synchronized. For this reason Hashtable is still used in a lot of concurrent code because it is, in theory, thread safe.  This theory is however normally just a theory, because if you don't write concurrent code correctly, it will still not be thread safe no matter how many synchronized methods you have.

For example you could call get() on the Hashtable, then if it is not there call

As promised, I have results from running some of the tests in other JVMs. The most interesting results were from the Map test and the Method execution test, so I have re-run those on various JVMs and environments.

The first result comes from running with Oracle (Sun) JDK 1.6.23 on the same Windows XP machine. Next I ran on Oracle (Sun) JDK 1.5.5, and then Oracle JRockit 1.6. I then ran the tests on another machine, an old 4 cpu 8 core AMD machine running Linux. The results are

Java performance optimization is part analysis, and part superstition and witch craft.

In deciding how to optimize their applications a lot of developers search the web for what people say is faster, or go by what they have heard from their co-workers sister's boyfriend's cousin, or by what seems to be the "public opinion". Sometimes the public opinion is correct, and their application benefits, and sometimes it is not, and they waste their time and effort and make little perform

In my last post I investigated different ways to optimize the loading of objects and their relationships. I presented some performance results, but from a very small database with small query result sets. In this post I will investigate how those same query optimization strategies scale to larger data sets.

The previous post only had a database of 12 rows. So for this run I will increase the database size by 5,000 to 60,000 rows. Still not a huge database, but should be big en

Respuesta a la respuesta de prueba

Respuesta a prueba

Most well designed websites no longer use the standard browser button styles, but instead use their own styles for submit and other buttons. Either to make them bigger, colored, or use images.
This is fairly easy to do for standard submit buttons, and other input types, but file upload buttons do not let you style them, so you are left with the ugly browser default. As well it is normally desirable to submit the form when the user selects the file to upload, but with the standard file