@Entity
@Table(name = "User_Table")
public class User extends NamedObject implements java.io.Serializable
{
    .
    .
    .
    @ManyToOne(optional = true, cascade = {CascadeType.ALL})
    @org.hibernate.annotations.Cascade({
        org.hibernate.annotations.CascadeType.SAVE_UPDATE,
        org.hibernate.annotations.CascadeType.DELETE_ORPHAN
        })
    private PlatformPolicies platformPolicies = null;

}

public class testUpdate
{
    private static final Log LOG = Factory.getLog(TestCreate.class, LoggableComponent.API);

    public static void main(String[] args)
    {
        TestRunner t1 = new TestRunner("aaaaaaaaa");
        TestRunner t2 = new TestRunner("bbbbbbbbb");
        t1.start();
        t2.start();
    }

    public static class TestRunner extends Thread
    {
       
        String name = null;
       
        public TestRunner(String name)
        {
            this.name = name;
        }
        private int NUM_USERS = 1;
        @Override
        public void run()
        {
            long[] ids = new long[NUM_USERS];
            TxFactory txFactory = TxFactory.getInstance();
            String tx = txFactory.createTransaction();
            try
            {
                Session session = txFactory.getSession(tx);
                // Create a user - use a loop so we can test creating multiple users
                for (int ii=0; ii < NUM_USERS; ii++)
                {
                    User user = new User(name + ii, "", "", "");
                    Map<PolicyType, Policy> policies = new HashMap<PolicyType, Policy>();
                    user.setPlatformPolicies(policies);
                    LOG.info("Creating user " + user.getName());
                    ids[ii] = (Long)session.save(user);
                    LOG.info("Created user " + user.getName());
                }
                LOG.info("Committing xaction for create " + name);
                txFactory.commitTransaction(tx);
                LOG.info("Committed xaction for create " + name);
               
                tx = txFactory.createTransaction();
                session = txFactory.getSession(tx);
                // Delete user we just created
                for (int ii=0; ii < NUM_USERS; ii++)
                {
                    User user = (User)session.load(User.class, ids[ii]);
                    LOG.info("Deleting user " + user.getName());
                    session.delete(user);
                    LOG.info("Deleted user " + user.getName());
                }
               
                // Synch with other threads
                synchWait();

                // Commit the xaction to perform the delete
                LOG.info("Committing delete xaction");
                txFactory.commitTransaction(tx);
                LOG.info("Committed delete xaction");
                tx = null;
            }
            catch (Throwable t)
            {
                if (tx != null)
                {
                    txFactory.rollbackTransaction(tx);
                }
                LOG.error("Error in TestRunner", t);
            }
        }
    }

    private final static Object updateSynch = new Object();
    private static int synchCounter = 0;
    // Synchronize 2 threads - 2nd one in wakes the 1st
    private static void synchWait()
    {
        synchCounter++;
        if (synchCounter == 2)
        {
            synchronized(updateSynch)
            {
                synchCounter = 0;
                LOG.info("Notifying updateSynch");
                updateSynch.notify();
            }
        }
        else
        {
            synchronized(updateSynch)
            {
                try
                {
                    LOG.info("Waiting on updateSynch");
                    updateSynch.wait();
                }
                catch(Throwable t) {LOG.error("Error in updateSynch: " + t.getClass() + " - " + t.getMessage(), t);}
            }
        }
    }
}

                tx = txFactory.createTransaction();
                session = txFactory.getSession(tx);
                // Delete user we just created
                User user =  (User)session.load(User.class, ids[0]);
                PlatformPolicies pp = user.getPlatformPolicies();
                txFactory.commitTransaction(tx);
               
                List<String> queries = new ArrayList<String>();
                queries.add("Delete from user_table where id = " + user.getId() + " and revision = "
                        + user.getRevision());
                queries.add("Delete from platformPolicies where id = " + pp.getId() + " and revision = "
                        + pp.getRevision());
                synchWait();
                executeBatch(queries);

public class A
{
    @OneToOne(optional = true, cascade = CascadeType.ALL)
    @Cascade( { org.hibernate.annotations.CascadeType.DELETE_ORPHAN })
    // @Index(name="IDX_A_B")
    private B b;
}