[RESOLVIDO] Hibernate + Java DB embarcado: cria mas não mantém dados na base

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">org.apache.derby.jdbc.EmbeddedDriver</property>
        <property name="hibernate.connection.url">jdbc:derby:minhabase;create=true</property>
        <property name="hibernate.connection.username">usuario</property>
        <property name="hibernate.connection.password">senha</property>
        <property name="hibernate.show_sql">false</property>
        <property name="hibernate.format_sql">false</property>
        <property name="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</property>
        <property name="hibernate.hbm2ddl.auto">create</property>
        <property name="hibernate.connection.pool_size">1</property>
        <property name="hibernate.dialect">org.hibernate.dialect.DerbyDialect</property>
        <property name="hibernate.default_schema">app</property>
        <property name="hibernate.current_session_context_class">thread</property>    
        <mapping class="com.tfv.model.Cliente"/>
        <mapping class="com.tfv.model.CondicaoPagamento"/>
        <mapping class="com.tfv.model.Produto"/>
    </session-factory>
</hibernate-configuration>

public class HibernateUtil {

    private static final SessionFactory sessionFactory;
    
    static {
        try {
            // Create the SessionFactory from standard (hibernate.cfg.xml) 
            // config file.
            sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            // Log the exception. 
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }
    
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

public class GenericDAO<T extends Serializable> {

    private Session sessao;
    private final Class<T> classePersistente;

    public GenericDAO() {
        this.sessao = HibernateUtil.getSessionFactory().getCurrentSession();
        this.classePersistente = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    public Session getSessao() {
        return sessao;
    }

    protected void salvar(T entity) {
        try {
            this.sessao.beginTransaction().begin();
            this.sessao.save(entity);
            this.sessao.beginTransaction().commit();
        } catch (Throwable t) {
            this.sessao.getTransaction().rollback();
            t.printStackTrace();
        } finally {
            fecharSessao();
        }
    }

    protected void alterar(T entity) {
        try {
            this.sessao.beginTransaction().begin();
            this.sessao.update(entity);
            this.sessao.beginTransaction().commit();
        } catch (Throwable t) {
            this.sessao.getTransaction().rollback();
            t.printStackTrace();
        } finally {
            fecharSessao();
        }
    }

    protected void deletar(T entity) {
        try {
            this.sessao.beginTransaction().begin();
            this.sessao.delete(entity);
            this.sessao.beginTransaction().commit();
        } catch (Throwable t) {
            this.sessao.getTransaction().rollback();
            t.printStackTrace();
        } finally {
            fecharSessao();
        }
    }

    /**
     * retorna todos os registros de determinada tabela.
     *
     * @return
     * @throws Exception
     */
    public List<T> BuscaTodos() throws Exception {
        return this.sessao.createCriteria(classePersistente).list();
    }

    /**
     * método para retornar registros que possuem determinada string no campo
     * indicado no primeiro parâmetro.
     *
     * @param campo - nome do campo por onde será pesquisado.
     * @param conteudo - conteúdo a ser pesquisado no campo informado no 1º
     * parâmetro.
     * @return
     */
    public List<T> BuscaCampoString(String campo, String conteudo) {
        this.sessao.beginTransaction().begin();
        List<T> aResultado = this.sessao.createCriteria(classePersistente).add(Restrictions.like(campo.toString(), "%" + conteudo + "%").ignoreCase()).list();
        this.sessao.beginTransaction().commit();
        fecharSessao();
        return aResultado;
    }

    /**
     * método para retornar registro que possui determinada id passada como
     * parâmetro.
     *
     * @param campo - nome do campo chave-primária
     * @param id - conteúdo a ser pesquisado no campo chave-primária
     * @return
     */
    public T BuscaCampoId(String campo, String id) {
        this.sessao.beginTransaction().begin();
        T oResultado = (T) this.sessao.createCriteria(classePersistente).add(Restrictions.eq(campo.toString(), id)).uniqueResult();
        this.sessao.beginTransaction().commit();
        fecharSessao();
        return oResultado;
    }

    public void fecharSessao() {
        if (this.sessao != null && this.sessao.isOpen()) {
            this.sessao.getTransaction().commit();
            this.sessao.close();
        }
    }
}

public class ClienteDAO extends GenericDAO<Cliente> {
    
    @Override
    public void salvar(Cliente cliente){
        salvar(cliente);        
    }
    
    @Override
    public void alterar(Cliente cliente){
        alterar(cliente);
    }
    
    public void deletar(String id){
        Cliente c = BuscaCampoId("id", id);
        deletar(c);
    }
}

...
            sessao = HibernateUtil.getSessionFactory().openSession();
            sessao.beginTransaction().begin();

                Cliente cliente = new Cliente();
... cliente.sets ...
                sessao.saveOrUpdate(cliente);
            sessao.getTransaction().commit();
            sessao.close();