In few project I have been successfully using 

    @PersistenceUnit(unitName = &quot;MiddlewareJPA&quot;)
    EntityManagerFactory emf;
    ...
    EntityManager entityManager = emf.createEntityManager();

to obtain `EntityManager` for Database connection, but some days ago I was trying to move my project to `Jboss EAP 6.2` and it couldn&#39;t create `EntityManager`. I was googling it and I found that I should try change `@PersistenceUnit` to

    @PersistenceContext(unitName = &quot;MiddlewareJPA&quot;)
    private EntityManager entityManager;
 
to obtain *EntityManager*. It worked but I don&#39;t know why. What is the difference bettween `PersistenceUnit` and `PersistenceContext`? What are pros and cons of each one? Where should we be using one of them? 


     

PersistenceUnit vs PersistenceContext

I have been suffering from infamous hibernate exception

    org.hibernate.LazyInitializationException: could not initialize proxy - no Session

Now the community is cheering over 

`&lt;property name=&quot;hibernate.enable_lazy_load_no_trans&quot; value=&quot;true&quot;/&gt;`

saying it solves the problem but **USE IT WITH CAUTION**.

What they mean by use it with caution? What this property actually does?

Please give me any insights. Thanks in advance.


Solve Hibernate Lazy-Init issue with hibernate.enable_lazy_load_no_trans

I&#39;m using PHP&#39;s PDO layer for data access in a project, and I&#39;ve been reading up on it and seeing that it has good innate support for persistent DB connections. I&#39;m wondering when/if I should use them. Would I see performance benefits in a CRUD-heavy app? Are there downsides to consider, perhaps related to security?

If it matters to you, I&#39;m using MySQL 5.x.



Persistent DB Connections - Yea or Nay?

I am currently using memcached with my java app, and overall it&#39;s working great.
&lt;p&gt;
The features of memcached that are most important to me are:
&lt;ul&gt;
&lt;li&gt;it&#39;s fast, since reads and writes are in-memory and don&#39;t touch the disk
&lt;li&gt;it&#39;s just a key/value store (since that&#39;s all my app needs)
&lt;li&gt;it&#39;s distributed
&lt;li&gt;it uses memory efficiently by having each object live on exactly one server
&lt;li&gt;it doesn&#39;t assume that the objects are from a database (since my objects are not database objects)
&lt;/ul&gt;
&lt;p&gt;
However, there is one thing that I&#39;d like to do that memcached can&#39;t do.  I want to periodically (perhaps once per day) save the cache contents to disk.  And I want to be able to restore the cache from the saved disk image.
&lt;p&gt;
The disk save does not need to be very complex.  If a new key/value is added while the save is taking place, I don&#39;t care if it&#39;s included in the save or not.  And if an existing key/value is modified while the save is taking place, the saved value should be either the old value or the new value, but I don&#39;t care which one.
&lt;p&gt;
Can anyone recommend another caching solution (either free or commercial) that has all (or a significant percentage) of the memcached features that are important to me, and also allows the ability to save and restore the entire cache from disk?




alternative to memcached that can persist to disk

Is there a way to persist an enum to the DB using NHibernate? That is have a table of both the code and the name of each value in the enum.

I want to keep the enum without an entity, but still have a foreign key (the int representation of the enum) from all other referencing entities to the enum&#39;s table.

How to persist an enum using NHibernate

How do I persist changes made within the same object inheriting from `TestCase` in unitttest?

    from unittest import TestCase, main as unittest_main
    
    
    class TestSimpleFoo(TestCase):
        foo = &#39;bar&#39;
    
        def setUp(self):
            pass
    
        def test_a(self):
            self.assertEqual(self.foo, &#39;bar&#39;)
            self.foo = &#39;can&#39;
    
        def test_f(self):
            self.assertEqual(self.foo, &#39;can&#39;)
    
    
    if __name__ == &#39;__main__&#39;:
        unittest_main()

I.e.: I want those two tests above to pass

Persist variable changes between tests in unittest?

I just begin my JPA 2.0 studies, and I have this piece of code:

    em = SessionFactory.startSession();
    tx = em.getTransaction();

My problem is: I&#39;m not sure if I completly understand the difference between the use of a session and the use of a transaction. In a few lines, can anyone please tell me the biggest differences between them ? Thanks !




What is the difference between a session and a transaction in JPA 2.0?

1. When they appear on a field/getter of an `@Entity`, what is the difference between them? (I persist the Entity through **Hibernate**).

2. What framework and/or specification each one of them belongs to?

3. `@NotNull` is located within `javax.validation.constraints`. In the `javax.validation.constraints.NotNull` javadoc it says

  &gt; The annotated element must not be null

 but it does not speak of the element&#39;s representation in the database, so why would I add the constraint `nullable=false` to the column?



Confusion: @NotNull vs. @Column(nullable = false) with JPA and Hibernate

Hibernate has a handful of methods that, one way or another, takes your object and puts it into the database. What are the differences between them, when to use which, and why isn&#39;t there just one intelligent method that knows when to use what?

The methods that I have identified thus far are:

 - `save()`
 - `update()`
 - `saveOrUpdate()`
 - `saveOrUpdateCopy()`
 - `merge()`
 - `persist()`

What are the differences between the different saving methods in Hibernate?

I am trying to use the `org.springframework.orm.jdo.TransactionAwarePersistenceManagerFactoryProxy` in my Spring project, but I am not sure how to use it or whether it&#39;s exactly what I am looking for. I realize it can help make my DAOs work with a plain JDO `PersistenceManagerFactory`. Another question is: what happens if the proxy doesn&#39;t get made properly? Can I still use it to access my factory to create a transaction aware persistence manager? If the object managed by the factory is a singleton, does this change things? Why not just access the PersistenceManagerFactory directly? Perhaps `PersistenceManagerFactoryUtils.getPersistenceManager` would be more suited to my needs? Can `getObject` return null?

Unsure if I understand TransactionAwarePersistenceManagerFactoryProxy

I have my `persistence.xml` with the same name using `TopLink` under the `META-INF` directory.
Then, I have my code calling it with:

    EntityManagerFactory emfdb = Persistence.createEntityManagerFactory(&quot;agisdb&quot;);

Yet, I got the following error message:

&lt;pre&gt;
2009-07-21 09:22:41,018 [main] ERROR - No Persistence provider for EntityManager named agisdb
javax.persistence.PersistenceException: No Persistence provider for EntityManager named agisdb
	at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:89)
	at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:60)
&lt;/pre&gt;

Here is the `persistence.xml`:

    &lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;
    &lt;persistence xmlns=&quot;http://java.sun.com/xml/ns/persistence&quot; version=&quot;1.0&quot;&gt;
        &lt;persistence-unit name=&quot;agisdb&quot;&gt;
            &lt;class&gt;com.agis.livedb.domain.AddressEntity&lt;/class&gt;
            &lt;class&gt;com.agis.livedb.domain.TrafficCameraEntity&lt;/class&gt;
            &lt;class&gt;com.agis.livedb.domain.TrafficPhotoEntity&lt;/class&gt;
            &lt;class&gt;com.agis.livedb.domain.TrafficReportEntity&lt;/class&gt;
            &lt;properties&gt;
                &lt;property name=&quot;toplink.jdbc.url&quot; value=&quot;jdbc:mysql://localhost:3306/agisdb&quot;/&gt;
                &lt;property name=&quot;toplink.jdbc.driver&quot; value=&quot;com.mysql.jdbc.Driver&quot;/&gt;
                &lt;property name=&quot;toplink.jdbc.user&quot; value=&quot;root&quot;/&gt;
                &lt;property name=&quot;toplink.jdbc.password&quot; value=&quot;password&quot;/&gt;
            &lt;/properties&gt;
        &lt;/persistence-unit&gt;
    &lt;/persistence&gt;

It should have been in the classpath. Yet, I got the above error.

No Persistence provider for EntityManager named

I&#39;m facing what I think is a simple problem with Hibernate, but can&#39;t solve it (Hibernate forums being unreachable certainly doesn&#39;t help).

I have a simple class I&#39;d like to persist, but keep getting:

    SEVERE: Field &#39;id&#39; doesn&#39;t have a default value
    Exception in thread &quot;main&quot; org.hibernate.exception.GenericJDBCException: could not insert: [hibtest.model.Mensagem]
        at org.hibernate.exception.SQLStateConverter.handledNonSpecificException(SQLStateConverter.java:103)
        at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:91)
        [ a bunch more ]
    Caused by: java.sql.SQLException: Field &#39;id&#39; doesn&#39;t have a default value
        [ a bunch more ]

The relevant code for the persisted class is:

    package hibtest.model;

    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.Inheritance;
    import javax.persistence.InheritanceType;

    @Entity
    @Inheritance(strategy = InheritanceType.JOINED)
    public class Mensagem  {
        protected Long id;
        
        protected Mensagem() { }

        @Id
        @GeneratedValue
        public Long getId() {
            return id;
	}

        public Mensagem setId(Long id) {
            this.id = id;
            return this;
        }
    }

And the actual running code is just plain:

    SessionFactory factory = new AnnotationConfiguration()
        .configure()
        .buildSessionFactory();

    {
        Session session = factory.openSession();
        Transaction tx = session.beginTransaction();

        Mensagem msg = new Mensagem(&quot;YARR!&quot;);

        session.save(msg);

        tx.commit();
        session.close();
    }

I tried some &quot;strategies&quot; within the `GeneratedValue` annotation but it just doesn&#39;t seem to work. Initializing `id` doesn&#39;t help either! (eg `Long id = 20L`).

Could anyone shed some light?

**EDIT 2:** confirmed: messing with`@GeneratedValue(strategy = GenerationType.XXX)` doesn&#39;t solve it

**SOLVED:** recreating the database solved the problem

Hibernate: &quot;Field &#39;id&#39; doesn&#39;t have a default value&quot;

I am new to the Java world and JPA. I was studying JPA and came across many new terms like Entity, persistence. While reading, I could not understand the exact definition for **Persistence Context**.

Can anyone explain it in simple laymen terms? What is it to do with the data used in the `@Entity`?

For example, I find this definition too complicated to understand:
&gt; A persistence context is a set of entities such that for any persistent identity there is a unique entity instance.

What is Persistence Context?

What is the difference between `@Column` and `@Basic` annotations in JPA? Can they be used together? *Should* they be used together? Or does one of them suffice?

Java Persistence / JPA: @Column vs @Basic

I was gathering information about the flush() method, but I&#39;m not quite clear when to use it and how to use it correctly. From what I read, my understanding is that the contents of the persistence context will be synchronized with the database, i. e. issuing outstanding statements or refreshing entity data.

Now I got following scenario with two entities `A` and `B` (in a one-to-one relationship, but not enforced or modelled by JPA). `A` has a composite PK, which is manually set, and also has an auto-generated IDENTITY field `recordId`. This `recordId` should be written to entity `B` as a foreign-key to `A`. I&#39;m saving `A` and `B` in a single transaction. The problem is that the auto-generated value `A.recordId` is not available within the transaction, unless I make an explicit call of `em.flush()` after calling `em.persist()` on `A`. (If I have an auto-generated IDENTITY PK then the value is directly updated in the entity, but that&#39;s not the case here.)

**Can `em.flush()` cause any harm when using it within a transaction?**

Correct use of flush() in JPA/Hibernate

I have come across a situation (which I think is weird but is possibly quite normal) where I use the EntityManager.getReference(LObj.getClass(), LObj.getId()) to get a database entity and then pass the returned object to be persisted in another table.

So basically the flow was like this:

&lt;pre&gt;
class TFacade{

  createT(FObj, AObj) {
    T TObj = new T();
    TObj.setF(FObj);
    TObj.setA(AObj);
    ...
    EntityManager.persist(TObj);
    ...
    L LObj = A.getL();
    FObj.setL(LObj);
    FFacade.editF(FObj);
  }
}

@TransactionAttributeType.REQUIRES_NEW
class FFacade{

  editF(FObj){
    L LObj = FObj.getL();
    LObj = EntityManager.getReference(LObj.getClass(), LObj.getId());
    ...
    EntityManager.merge(FObj);
    ...
    FLHFacade.create(FObj, LObj);
  }
}

@TransactionAttributeType.REQUIRED
class FLHFacade{

  createFLH(FObj, LObj){
    FLH FLHObj = new FLH();
    FLHObj.setF(FObj);
    FLHObj.setL(LObj);
    ....
    EntityManager.persist(FLHObj);
    ...
  }
}

&lt;/pre&gt;

I was getting the following exception &quot;java.lang.IllegalArgumentException: Unknown entity: com.my.persistence.L$$EnhancerByCGLIB$$3e7987d0&quot;

After looking into it for a while, I finally figured out that it was because I was using the EntityManager.getReference() method that I was getting the above exception as the method was returning a proxy.

This makes me wonder, *when is it advisable to use the EntityManager.getReference() method instead of the EntityManager.find() method*? 

EntityManager.getReference() throws an EntityNotFoundException if it cant find the entity being searched for which is very convenient in itself. EntityManager.find() method merely returns null if it cant find the entity.

With regards to transaction boundaries, sounds to me like you would need to use the find() method before passing the newly found entity to a new transaction. If you use the getReference() method then you would probably end up in a situation similar to mine with the above exception.




When to use EntityManager.find() vs EntityManager.getReference() with JPA

I&#39;m depending heavily on localStorage for a plugin I&#39;m writing. All the user settings are stored in it. Some settings require the user the write regex&#39;es and they would be sad if their regex rules are gone at some point. 
So now I am wondering just how persistent the localStorage is.

From [the specs][1]:

&gt; User agents should expire data from the local storage areas only for security reasons or when requested to do so by the user.

The above looks like it works just like cookies on the clientside. I.e. when the user clears all browser data (history, cookies, cache etc) the localStorage will also be truncated. Is this assumption correct?

[1]:http://www.w3.org/TR/webstorage/#dom-localstorage

How persistent is localStorage?

I have a doubt, because name attribute is there in both @Entity and @Table

For example, I&#39;m allowed to have same value for name attribute 

    @Entity(name = &quot;someThing&quot;)
    @Table(name = &quot;someThing&quot;)

and I can have different names as well for same class

  

     @Entity(name = &quot;someThing&quot;)
     @Table(name = &quot;otherThing&quot;)

Can anybody tell me what is the difference between these two and why we have same attribute in both?

Name attribute in @Entity and @Table

I&#39;m curious and need to find this answer quick. Google won&#39;t help much.

The Java Persistence API has these properties that tell the framework to cascade operations on associated entities:

    CascadeType.PERSIST
    CascadeType.DELETE
    CascadeType.MERGE
    CascadeType.REFRESH

I know what the first two mean: when I persist object A which has B, persist B as well, and when I delete A, delete B as well.

But I can&#39;t make any sense of what the other two accomplish. Help?

What do REFRESH and MERGE mean in terms of databases?

I have queries as below:

 1. What is the difference of these two?   
 2. Are both of these supported by all databases?
 3. Are JPA TransactionManager and JTA TransactionManager different?





Persistence unit as RESOURCE_LOCAL or JTA?

For our new product re-engineering, we are in the process of selecting the best framework from Java. As the consideration is to go for database agnostic approach for model, we are working on options between Struts + Spring with iBATIS or Hibernate. Please advice which is best as both offer persistence.

Hibernate Vs iBATIS

In my SQL Server 2000 database, I have a timestamp (in function not in data type) column of type `DATETIME` named `lastTouched` set to `getdate()` as its default value/binding.

I am using the Netbeans 6.5 generated JPA entity classes, and have this in my code

    @Basic(optional = false)
    @Column(name = &quot;LastTouched&quot;)
    @Temporal(TemporalType.TIMESTAMP)
    private Date lastTouched;

However when I try to put the object into the database I get, 

    javax.persistence.PersistenceException: org.hibernate.PropertyValueException: not-null property references a null or transient value: com.generic.Stuff.lastTouched

I&#39;ve tried setting the `@Basic` to `(optional = true)`, but that throws an exception saying the database doesn&#39;t allow `null` values for the `TIMESTAMP` column, which it doesn&#39;t by design.

    ERROR JDBCExceptionReporter - Cannot insert the value NULL into column &#39;LastTouched&#39;, table &#39;DatabaseName.dbo.Stuff&#39;; column does not allow nulls. INSERT fails.

I previously got this to work in pure Hibernate, but I have since switched over to JPA and have no idea how to tell it that this column is supposed to be generated on the database side. Note that I am still using Hibernate as my JPA persistence layer.

Setting a JPA timestamp column to be generated by the database?

I&#39;m reading the Redis documentation on persistence here - https://redis.io/topics/persistence - and am wondering what the acronyms AOF and RDB stand for. Thanks! :)

What do the acronyms AOF and RDB stand for in Redis?

I&#39;ve seen several questions/discussions here about the best way to handle and persist enum-like values (e.g. https://stackoverflow.com/questions/492096/persisting-data-suited-for-enums , https://stackoverflow.com/questions/256978/how-to-persist-an-enum-using-nhibernate ), and I&#39;d like to ask what the general consenus is.

In particular:

* How should these values be handled in the code?
* How should they be persisted to a database (as text/as a number)?
* What are the tradeoffs of different solutions?

*Note: I moved the explanations originally included in this question to an answer.*

Best practices for using and persisting enums

I have just started migrating my homegrown persistence framework to JPA.

Given that the persistence frameworks hide a lot of the plumbing, I&#39;m interested in knowing if NOT closing EntityManagers will create a resource leak, or if the frameworks will collect and close them for me.

I intend in all places to close them, but do I HAVE to?

At the moment using TopLink, just because it works with NetBeans easily, but am happy to investigate other JPA providers.

Do I have to close() every EntityManager?

This is my model:

    class User {...}
    class Book {
      User author;
      int number;
    }

Every book number starts at 1 per author and increments upwards. So we&#39;ll have Books 1,2,3 by John Grisham, Book 1..5 by George Martin, etc...

Is there a unique constraint I can place on `Book`, that would guarantee we don&#39;t have two books with the same number by the same author? Similar to `@Column(unique = true)`, but the constraint only applies on the composite of `Author X number`?



Creating a composite Unique constraints on multiple columns

I am using JPA 2. For safety reasons, I am working type safe with CriteriaQuery&#39;s (and thus, I am not searching for any solutions to typed queries and so on).

I recently came across an issue in which I needed to set a SQL-LIMIT.

After a lot of searching, I was still not successful in finding a solution.

    CriteriaQuery&lt;Product&gt; query = getEntityManager().getCriteriaBuilder().createQuery(Product.class);
    Root&lt;Product&gt; product = query.from(Product.class);
    query.select(product);

    return em.createQuery(query).getResultList();

Can anyone help me?

JPA 2 CriteriaQuery, using a limit

**Background**

I am trying to encode a String-style enum using the NSCoding protocol, but I am running into errors converting to and back from String.

I get the following errors while decoding and encoding:

*String is not convertible to Stage*

*Extra argument ForKey: in call*


**Code**

        enum Stage : String
        {
            case DisplayAll    = &quot;Display All&quot;
            case HideQuarter   = &quot;Hide Quarter&quot;
            case HideHalf      = &quot;Hide Half&quot;
            case HideTwoThirds = &quot;Hide Two Thirds&quot;
            case HideAll       = &quot;Hide All&quot;
        }
        
        class AppState : NSCoding, NSObject
        {
            var idx   = 0
            var stage = Stage.DisplayAll
        
            override init() {}
        
            required init(coder aDecoder: NSCoder) {
                self.idx   = aDecoder.decodeIntegerForKey( &quot;idx&quot;   )
                self.stage = aDecoder.decodeObjectForKey(  &quot;stage&quot; ) as String    // ERROR
            }
            
            func encodeWithCoder(aCoder: NSCoder) {
                aCoder.encodeInteger( self.idx,             forKey:&quot;idx&quot;   )
                aCoder.encodeObject(  self.stage as String, forKey:&quot;stage&quot; )  // ERROR
            }
    
        // ...
    
        }

How do I encode enum using NSCoder in swift?

I need to store some data in a Django model. These data are not equal to all instances of the model.

At first I thought about subclassing the model, but I’m trying to keep the application flexible. If I use subclasses, I’ll need to create a whole class each time I need a new kind of object, and that’s no good. I’ll also end up with a lot of subclasses only to store a pair of extra fields.

I really feel that a dictionary would be the best approach, but there’s nothing in the Django documentation about storing a dictionary in a Django model (or I can’t find it).

Any clues?

How to store a dictionary on a Django Model?

I&#39;m working on an [open source project][1] dealing with adding metadata to folders. The provided (Python) API lets you browse and access metadata like it was just another folder. Because it is just another folder.

    \folder\.meta\folder\somedata.json

Then I came across [HDF5][2] and its derivation [Alembic][3].

Reading up on HDF5 in the book [Python and HDF5][4] I was looking for benefits to using it compared to using files in folders, but most of what I came across spoke about the benefits of a hierarchical file-format in terms of its simplicity in adding data via its API:

    &gt;&gt;&gt; import h5py
    &gt;&gt;&gt; f = h5py.File(&quot;weather.hdf5&quot;)
    &gt;&gt;&gt; f[&quot;/15/temperature&quot;] = 21

Or its ability to read only certain parts of it upon request (e.g. random access), and parallel execution of a single HDF5 file (e.g. for multiprocessing)

You could mount HDF5 files, [https://github.com/zjttoefs/hdfuse5][5]

It even boasts a strong yet simple foundation concept of **Groups** and **Datasets** which from wiki reads:

 - Datasets, which are multidimensional arrays of a homogeneous type 
 - Groups, which are container structures which can hold datasets and
   other groups

Replace **Dataset** with **File** and **Group** with **Folder** and the whole feature-set sounds to me like what files in folders are already fully capable of doing.

For every benefit I came across, not one stood out as being exclusive to HDF5.

So my question is, if I were to give you one HDF5 file and one folder with files, both with identical content, in which scenario would HDF5 be better suited?

Edit:

Having gotten some responses about the portability of HDF5.

It sounds lovely and all, but I still haven&#39;t been given an example, a scenario, in which an HDF5 would out-do a folder with files. Why would someone consider using HDF5 when a folder is readable on any computer, any file-system, over a network, supports &quot;parallel I/O&quot;, is readable by humans without an HDF5 interpreter.

I would go as far as to say, a folder with files is far more portable than any HDF5.

Edit 2:

Thucydides411 just gave an example of a scenario where portability matters.
https://stackoverflow.com/a/28512028/478949

I think what I&#39;m taking away from the answers in this thread is that HDF5 is well suited for when you need the organisational structure of files and folders, like in the example scenario above, with lots (millions) small (~1 byte) data structures; like individual numbers or strings. That it makes up for what file-systems lack by providing a &quot;sub file-system&quot; favouring the small and many as opposed to few and large.

In computer graphics, we use it to store geometric models and arbitrary data about individual vertices which seems to align quite well with it&#39;s use in the scientific community.

  [1]: https://github.com/abstractfactory/openmetadata
  [2]: http://www.hdfgroup.org/HDF5/
  [3]: http://www.alembic.io/
  [4]: http://shop.oreilly.com/product/0636920030249.do
  [5]: https://github.com/zjttoefs/hdfuse5

How is HDF5 different from a folder with files?

I have an existing system, which is using *protobuf-based* communication protocol between GUI and server. Now I would like to add some persistence, but at the moment protobuf messages are straight converted to a third-party custom objects.

Is there a way to convert *proto* messages to *json*, which could be then persisted to database.

**N.B.:** I don&#39;t much like an idea of writing binary protobuf to database, because it can one day become not backward-compatible with newer versions and break the system that way.

Java: JSON -&gt; Protobuf &amp; back conversion

I&#39;m using JPA2 and both `@Entity` and `@Table` have a `name` attribute, e. g.:

    @Entity(name=&quot;Foo&quot;)
    @Table (name=&quot;Bar&quot;)
    class Baz

What should I use, which ones are optional? 

In my specific case I have a class `User` and a class `Group`, which have additional requirements (as far as I understand) because they are reserved words in SQL.

How would a working solution look like and with which name would I refer to the entity when writing queries?

Update: I added `name=&quot;GROUPS&quot;` to both annotations in `Group` and did the same for `User`, but now I get this error: 

    Exception Description: The table [USERS] is not present in this descriptor.
    Descriptor: RelationalDescriptor(example.Group --&gt; [DatabaseTable(GROUPS)])

and this error

    Internal Exception: java.sql.SQLException: Table not found in statement [SELECT ID, MAXIMUMROLE, MEMBERSHIPS_ID FROM USERS]

What&#39;s the difference between the name argument in @Entity and @Table when using JPA?

I&#39;ve these two simple entities `Something` and `Property`.
The `Something` entity has a many-to-one relationship to `Property`, so when I create a new `Something` row, I assign an existing `Property`.

**Something:**

    @Entity
    @Table(name = &quot;something&quot;)
    public class Something implements Serializable {
    
        private static final long serialVersionUID = 1L;
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
    
        @Column(name = &quot;name&quot;)
        private String name;
    
        @Column(name = &quot;owner&quot;)
        private String owner;
    
        @ManyToOne
        private Property property;
    
        // getters and setters
    
        @Override
        public String toString() {
            return &quot;Something{&quot; +
                &quot;id=&quot; + getId() +
                &quot;, name=&#39;&quot; + getName() + &quot;&#39;&quot; +
                &quot;, owner=&#39;&quot; + getOwner() + &quot;&#39;&quot; +
                &quot;, property=&quot; + getProperty() +
                &quot;}&quot;;
        }

**Property:**

    @Entity
    @Table(name = &quot;property&quot;)
    public class Property implements Serializable {
    
        private static final long serialVersionUID = 1L;
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
    
        @Column(name = &quot;shape&quot;)
        private String shape;
    
        @Column(name = &quot;color&quot;)
        private String color;
    
        @Column(name = &quot;dimension&quot;)
        private Integer dimension;
    
        // getters and setters
    
        @Override
        public String toString() {
            return &quot;Property{&quot; +
                &quot;id=&quot; + getId() +
                &quot;, shape=&#39;&quot; + getShape() + &quot;&#39;&quot; +
                &quot;, color=&#39;&quot; + getColor() + &quot;&#39;&quot; +
                &quot;, dimension=&#39;&quot; + getDimension() + &quot;&#39;&quot; +
                &quot;}&quot;;
        }
    }

This is the `SomethingRepository` (Spring):

    @SuppressWarnings(&quot;unused&quot;)
    @Repository
    public interface SomethingRepository extends JpaRepository&lt;Something,Long&gt; {
        
    }

Through a REST controller and a JSON, I want to create a new `Something`:

    @RestController
    @RequestMapping(&quot;/api&quot;)
    public class SomethingResource {
    
        private final SomethingRepository somethingRepository;
    
        public SomethingResource(SomethingRepository somethingRepository) {
            this.somethingRepository = somethingRepository;
        }
    
        @PostMapping(&quot;/somethings&quot;)
        public Something createSomething(@RequestBody Something something) throws URISyntaxException {
            Something result = somethingRepository.save(something);
            return result;
        }
    }

This is the JSON in input (the `property` `id` 1 is an existing row in the database):

    {
      &quot;name&quot;: &quot;MyName&quot;,
      &quot;owner&quot;: &quot;MySelf&quot;,
      &quot;property&quot;: {
        &quot;id&quot;: 1
      }
}

The problem is: after the method `.save(something)`, the variable `result` contains the persisted entity, but without the fields of field `property`, validated (they are `null`):

Output JSON:

    {
      &quot;id&quot;: 1,
      &quot;name&quot;: &quot;MyName&quot;,
      &quot;owner&quot;: &quot;MySelf&quot;,
      &quot;property&quot;: {
        &quot;id&quot;: 1,
        &quot;shape&quot;: null,
        &quot;color&quot;: null,
        &quot;dimension&quot;: null
      }
    }

I expect that they are validated/returned after the save operation.

To workaround this, I have to inject/declare the `EntityManager` in the REST controller, and call the method `EntityManager.refresh(something)` (or I have to call a `.findOne(something.getId())` method to have the complete persisted entity):

    @RestController
    @RequestMapping(&quot;/api&quot;)
    @Transactional
    public class SomethingResource {
    
        private final SomethingRepository somethingRepository;
        
        private final EntityManager em;
    
        public SomethingResource(SomethingRepository somethingRepository, EntityManager em) {
            this.somethingRepository = somethingRepository;
            this.em = em;
        }
    
        @PostMapping(&quot;/somethings&quot;)
        public Something createSomething(@RequestBody Something something) throws URISyntaxException {
            Something result = somethingRepository.save(something);
            em.refresh(result);
            return result;
        }
    }

With this workaround, I&#39;ve the expected saved entith (with a correct JSON):

    {
      &quot;id&quot;: 4,
      &quot;name&quot;: &quot;MyName&quot;,
      &quot;owner&quot;: &quot;MySelf&quot;,
      &quot;property&quot;: {
        &quot;id&quot;: 1,
        &quot;shape&quot;: &quot;Rectangle&quot;,
        &quot;color&quot;: &quot;Red&quot;,
        &quot;dimension&quot;: 50
      }
    }

Is there an automatic method/annotation, with JPA or Spring or Hibernate, in order to have the &quot;complete&quot; persisted entity?

I would like to avoid to declare the `EntityManager` in every REST or Service class, or I want avoid to call the `.findOne(Long)` method everytime I want the new refreshed persisted entity.

Refresh and fetch an entity after save (JPA/Spring Data/Hibernate)

I was hoping to write a python script to create some appropriate environmental variables by running the script in whatever directory I&#39;ll be executing some simulation code, and I&#39;ve read that I can&#39;t write a script to make these env vars persist in the mac os terminal. So two things:

Is this true?

and

It seems like it would be a useful things to do; why isn&#39;t it possible in general?

Why can&#39;t environmental variables set in python persist?

What and when is the best scenario to use DiscriminatorValue annotation in hibernate?

When to use DiscriminatorValue annotation in hibernate

I&#39;m developing something that needs Prometheus to persist its data between restarts. Having followed the instructions 

    $ docker volume create a-new-volume
    $ docker run \
        --publish 9090:9090 \
        --volume a-new-volume:/prometheus-data \
        --volume &quot;$(pwd)&quot;/prometheus.yml:/etc/prometheus/prometheus.yml \
        prom/prometheus

I have a valid `prometheus.yml` in the right directory on the host machine and it&#39;s being read by Prometheus from within the container. I&#39;m just scraping a couple of HTTP endpoints for testing purposes at the moment.

But when I restart the container it&#39;s empty, no data from the previous run. What am I missing from my `docker run ...` command to persist the data into the `a-new-volume` volume?

How to persist data in Prometheus running in a Docker container?

I&#39;ve created an object like this:

    company1.name = &#39;banana&#39; 
    company1.value = 40

I would like to save this object. How can I do that?


Saving an Object (Data persistence)

In my application,there are some application specific settings, which should be available to me , next time when my application starts up.

In other words i want the data to be available across the sessions of an application cycle.

Can this be achieved without using database(sqlite).

Making data persistent in android

I have Hibernate entity that I have to convert to JSON, and I have to translate some values in entity, but when I translate values, these values are instantly saved to database, but I don&#39;t want to save these changes to database. Is there any workaround for this problem?

All Persistence Solutions on Gang of Coders

Total of 39 Persistence Solutions