package domain;

import java.util.HashMap;
import java.util.Map;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.PostLoad;
import javax.persistence.Transient;

@Entity
public class AbstractEntity {

   @Id
   @Column(name = "ABSTRACT_ID")
   private Long id;

   @Transient
   private Map<String, Object> dynamicAttributes = null;

   public Long getId() {
      return id;
   }

   public void setId(Long id) {
      this.id = id;
   }

   @PostLoad
   public void postload() {
      if (dynamicAttributes == null || dynamicAttributes.isEmpty()) {
         dynamicAttributes = new HashMap<String, Object>();
      }
   }

   public Map<String, Object> getDynamicAttributes() {
      return dynamicAttributes;
   }

   public void setDynamicAttributes(Map<String, Object> dynamicAttributes) {
      this.dynamicAttributes = dynamicAttributes;
   }

   public void setDynamicProperty(String propertyName, Object value) {
      dynamicAttributes.put(propertyName, value);
   }

   @Override
   public String toString() {
      return "AbstractEntity [dynamicAttributes=" + dynamicAttributes
            + ", id=" + id + "]";
   }

}

package test;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.criterion.Restrictions;
import org.hibernate.mapping.Column;
import org.hibernate.mapping.Component;
import org.hibernate.mapping.PersistentClass;
import org.hibernate.mapping.Property;
import org.hibernate.mapping.SimpleValue;

import hibernate.HibernateUtil;
import domain.AbstractEntity;

public class TestAbstract {

   /**
    * @param args
    */
   @SuppressWarnings("unchecked")
   public static void main(String[] args) {
      AnnotationConfiguration cfg = HibernateUtil.getConfiguration();
      PersistentClass clazz = cfg
            .getClassMapping(domain.AbstractEntity.class
                  .getName());

      // Lege den Namen der neuen Tabelle fest
      String tablename = "TABLE_BLA";
      clazz.getIdentifier().getTable().setName(tablename);

      // Legt den Spaltennamen der ID-Spalte fest
      Property identifierProperty = clazz.getIdentifierProperty();
      Iterator<?> columnIterator = identifierProperty.getColumnIterator();
      while (columnIterator.hasNext()) {
         Column col = (Column) columnIterator.next();
         col.setName("FIRST_ID");
      }
      
      // Mappt die Map für die neuen Spalten
      Component component = new Component(clazz);
      component.setTable(clazz.getTable());

      Property dynamicProperty = new Property();
      dynamicProperty.setName("dynamicAttributes");
      dynamicProperty.setNodeName("dynamicAttributes");
      dynamicProperty.setValue(component);

      clazz.addProperty(dynamicProperty);

      // Legt eine neue Spalte an
      Column column = new Column("FIRST_NAME");
      column.setLength(50);
      clazz.getTable().addColumn(column);

      // Setzt den Typ der Spalte als String
      SimpleValue value = new SimpleValue();
      value.setTable(clazz.getTable());
      value.addColumn(column);
      value.setTypeName("string");

      // Mappt die eigentliche Property auf den Namen "name"
      Property property = new Property();
      property.setName("name");
      property.setNodeName("name");
      property.setValue(value);

      // Legt die neue Spalte als Paar in der Map ab
      component.addProperty(property);

      // Legt eine neue Spalte an
      Column column2 = new Column("ALTER_P");
      column2.setPrecision(2);
      column2.setLength(5);
      clazz.getTable().addColumn(column2);

      // Setzt den Typ der Spalte als String
      SimpleValue value2 = new SimpleValue();
      value2.setTable(clazz.getTable());
      value2.addColumn(column2);
      value2.setTypeName("double");

      // Mappt die eigentliche Property auf den Namen "alter"
      Property property2 = new Property();
      property2.setName("alter");
      property2.setNodeName("alter");
      property2.setValue(value2);

      component.addProperty(property2);

      SessionFactory sessionFactory = cfg.buildSessionFactory();

      Session session = sessionFactory.openSession();
      Transaction trans = session.beginTransaction();
      Criteria crit = session.createCriteria(AbstractEntity.class);
      //crit.add(Restrictions.gt("dynamicAttributes.alter", new Double(20)));
      List<AbstractEntity> list = crit.list();
      for (AbstractEntity entity : list) {
         System.out.println(entity);
         String old = entity.getDynamicProperty("name");
         String newValue = old + " neu";
         entity.setDynamicProperty("name", newValue);
         Double alter = entity.getDynamicProperty("alter");
         entity.setDynamicProperty("alter", new Double(
               alter.doubleValue()- 1d));
      }
      trans.commit();
      session.close();
   }

}

package test;

import java.util.HashMap;
import java.util.List;
import java.util.Set;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Mappings;
import org.hibernate.mapping.Column;
import org.hibernate.mapping.PrimaryKey;
import org.hibernate.mapping.Property;
import org.hibernate.mapping.RootClass;
import org.hibernate.mapping.SimpleValue;
import org.hibernate.mapping.Table;

import hibernate.HibernateUtil;

public class TestMapping{

   @SuppressWarnings("unchecked")
   public static void main(String[] args) {
      AnnotationConfiguration cfg = HibernateUtil.getConfiguration();

      // ID-Spalte anlegen
      Column idColumn = new Column();
      idColumn.setName("ID1");

      // Tabelle anlegen und Spalte mappen
      Table tNew = new Table("TABELLE1");
      tNew.addColumn(idColumn);

      // Value erzeugen, Typ, Spalte und Tabelle festlegen
      SimpleValue idValue = new SimpleValue();
      idValue.setTable(tNew);
      idValue.addColumn(idColumn);
      idValue.setTypeName("long");

      // Property erzeugen, Name und Value zuweisen
      Property propId = new Property();
      propId.setName("id");
      propId.setNodeName("id");
      propId.setValue(idValue);

      // Class-Mapping
      RootClass rc = new RootClass();
      rc.setIdentifierProperty(propId);
      rc.setIdentifier(idValue);
      rc.setEntityName("Entity1");
      rc.setNodeName("Entity1");
      rc.setTable(tNew);

      // Primärschlüssel festlegen
      PrimaryKey pk = new PrimaryKey();
      pk.setName("ID1");

      // Primärschlüssel und Tabelle "bekannt machen"
      pk.setTable(tNew);
      tNew.setPrimaryKey(pk);

      // Mapping hinzufügen
      Mappings createMappings = cfg.createMappings();
      createMappings.addClass(rc);

      // Mapping abschliessen
      SessionFactory sessionFactory = cfg.buildSessionFactory();

      // Daten erzeugen, speichern, lesen und ausgeben
      Session session = sessionFactory.openSession();
      Transaction trans = session.beginTransaction();

      HashMap<String, Object> newVal = new HashMap<String, Object>();
      newVal.put("id", new Long(4712));

      session.save("Entity1", newVal);
      session.flush();

      Criteria crit = session.createCriteria("Entity1");
      List<HashMap> list = crit.list();
      for (HashMap o : list) {
         Set keySet = o.keySet();
         for (Object key : keySet) {
            System.out.println(key + "=>" + o.get(key));
         }
      }

      trans.commit();
      session.close();
   }
}

Exception in thread "main" org.hibernate.MappingException: Unknown entity: TEST

package test;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.cfg.Mappings;
import org.hibernate.mapping.Column;
import org.hibernate.mapping.Property;
import org.hibernate.mapping.RootClass;
import org.hibernate.mapping.SimpleValue;
import org.hibernate.mapping.Table;

import java.util.*;

import test.HibernateUtil;

public class TestManager {

    public static void main(String[] args) {
        TestManager mgr = new TestManager();

        mgr.createAndStoreEvent();
    }

    @SuppressWarnings({ "unchecked", "rawtypes" })
    private void createAndStoreEvent() {

        Table tab = new Table("TEST");
       
        String[] felder = new String[4];
        felder[0] = "ROWID";
        felder[1] = "NAME";
        felder[2] = "AGE";
        felder[3] = "BLA";
       
        Column col;
        SimpleValue sv;
        Property prop;
       
        Mappings map;
        map = HibernateUtil.getConfig().createMappings();
       
        RootClass rc;
        rc = new RootClass();
        rc.setEntityName("TEST");
        rc.setNodeName("TEST");
        rc.setTable(tab);
       
        map.addClass(rc);
       
        for(String feld : felder) {
            col = new Column(feld);
            tab.addColumn(col);
           
            sv = new SimpleValue(map);
            sv.setTable(tab);
            sv.addColumn(col);
            sv.setTypeName("string");
           
            prop = new Property();
            prop.setName(feld);
            prop.setNodeName(feld);
            prop.setValue(sv);
           
            if(feld.equals("ROWID")) {
                rc.setIdentifierProperty(prop);
                rc.setIdentifier(sv);
            }
        }
       
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
       
        Criteria crit = session.createCriteria("TEST");
        List<HashMap> list = crit.list();
        for(HashMap o : list) {
            Set keySet = o.keySet();
            for(Object key : keySet) {
                System.out.println(key + "=>" + o.get(key));
            }
        }
       
        session.getTransaction().commit();
        session.close();
    }

}

package test;

import java.util.HashMap;
import java.util.List;
import java.util.Set;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Mappings;
import org.hibernate.mapping.Column;
import org.hibernate.mapping.PrimaryKey;
import org.hibernate.mapping.Property;
import org.hibernate.mapping.RootClass;
import org.hibernate.mapping.SimpleValue;
import org.hibernate.mapping.Table;

import hibernate.HibernateUtil;

public class TestAbstract3 {

   public static void main(String[] args) {
      TestAbstract3 mgr = new TestAbstract3();
      mgr.createAndStoreEvent();
   }

   @SuppressWarnings( { "unchecked", "rawtypes" })
   private void createAndStoreEvent() {
      AnnotationConfiguration cfg = HibernateUtil.getConfiguration();
      Table tab = new Table("TABELLE1");

      String[] felder = new String[4];
      felder[0] = "ID1";
      felder[1] = "NAME";
      felder[2] = "AGE";
      felder[3] = "BLA";

      Mappings map;
      map = cfg.createMappings();

      RootClass rc;
      rc = new RootClass();
      rc.setEntityName("TEST");
      rc.setNodeName("TEST");
      rc.setTable(tab);

      for (String feld : felder) {
         Column col = new Column(feld);
         tab.addColumn(col);

         SimpleValue sv = new SimpleValue();
         sv.setTable(tab);
         sv.addColumn(col);
         sv.setTypeName("string");

         Property prop = new Property();
         prop.setName(feld);
         prop.setNodeName(feld);
         prop.setValue(sv);

         if (feld.equals("ID1")) {
            rc.setIdentifierProperty(prop);
            rc.setIdentifier(sv);
            // Primärschlüssel festlegen
            PrimaryKey pk = new PrimaryKey();
            pk.setName(feld);
            // Primärschlüssel und Tabelle "bekannt machen"
            pk.setTable(tab);
            tab.setPrimaryKey(pk);
         } else {

            rc.addProperty(prop);
         }
      }

      map.addClass(rc);

      // Mapping abschliessen
      SessionFactory sessionFactory = cfg.buildSessionFactory();
      Session session = sessionFactory.openSession();
      session.beginTransaction();

      Criteria crit = session.createCriteria("TEST");
      List<HashMap> list = crit.list();
      for (HashMap o : list) {
         Set keySet = o.keySet();
         for (Object key : keySet) {
            System.out.println(key + "=>" + o.get(key));
         }
      }

      session.getTransaction().commit();
      session.close();
   }

}

public void delete(HashMap o) {
        try {
            this.sess().beginTransaction();
            this.sess().delete(o);
            this.sess().getTransaction().commit();
        }
        catch (HibernateException ex) {
            handleException(ex);
        }
    }

Unknown entity: java.util.HashMap

public void delete(String id) {
        try {
            this.sess().beginTransaction();
            Query q = this.sess().createQuery("delete from " + this.table + " where rowidtochar(rowid) = '" + id + "'");
            q.executeUpdate();
            this.sess().getTransaction().commit();
        }
        catch (HibernateException ex) {
            handleException(ex);
        }
    }

Criteria crit = session.createCriteria("TEST");
      List<HashMap> list = crit.list();
      for (HashMap o : list) {
         session.delete("TEST", o);
      }

      HashMap<String, Object> newObject = new HashMap<String, Object>();
      newObject.put("BLA", "testBla");
      newObject.put("NAME", "testName");
      newObject.put("ID1", "12345");

      session.save("TEST", newObject);