MySQL Hibernate: Massenupdate auf unbekannte Tabelle

[Xenya]

Hallo,
ich habe ein Programm das mit vielen Modulen aufgebaut ist. Da jedes Modul auf die gleiche Weise aufgebaut ist und sich vieles ähnelt, gibt es eine abstrakte Klasse, die alles was möglich ist bereits umsetzt.
Da oft neue Module hinzukommen ist dies ziemlich genial, da sich der Aufwand für neue somit gering hält.

Jedes dieser Module speichert seine Inhalte per Hibernate in die Datenbank. Damit auch hier der Aufwand möglichst gering bleibt, gibt es für die Entities auch eine abstrakte Klasse, die durch das @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) für jede abgeleitete Entity eine eigene Tabelle macht.

In der abstrakten Entity ist z.B. auch ein Date-Feld für ein Aktions-Zeitpunkt definiert.

Nun ist es ab und an nötig, dass bei allen Datensätzen jedes Moduls ein bestimmtes Datum gespeichert wird, wenn bis jetzt null darin steht.

Um genau diese Umsetzung geht es mir nun. Da überall der gleiche Schritt nötig ist, würde ich es gerne so machen, dass komplett alles in der abstrakten Modul-Klasse geschieht und man sich bei neuen Modulen rein gar nicht drum kümmern muss.

Erst mal zu den Möglichkeiten, wie es bei Hibernate geht:
Ich könnte alle Datensätze laden, bei denen actionDate == null ist, dann setActionDate(newDate) machen und ein update darauf ausführen. Das ist allerdings doch sehr umständlich und auch ineffizient, da viele Anfragen an das Datenbank geschickt werden. Darüber hinaus brauche ich die Objekte danach nicht mehr.

Eine Methode über die Criterias kenne ich nicht, die nur ein Update machen.

Also gibt es nur noch die Alternative, es über ein SQL-Statement zu machen. Das funktioniert auch wunderbar:

Transaction transaction = session.beginTransaction();

SQLQuery query = session.createSQLQuery("UPDATE ModulTable " +
		"Set actionDate = ? " +
		"WHERE actionDate IS NULL");
query.setDate(0, newDate);
query.executeUpdate();

transaction.commit();

Das große Problem ist nun aber, dass ich den Tabellennamen, wo bei dem Beispiel "ModulTable" steht, angeben muss.
Das heißt, ich müsste mir den Namen der Entity zum Beispiel im Konstruktor übergeben lassen und kann das ganze Problem doch nicht kapseln, so dass der Programmierer von neuen Modulen sich damit beschäftigen muss. Viel besser würde es mir gefallen, wenn auch dies noch automatisch geht.

Die Modul-Klassen bekommen alle die Entity als Generic mit:

class AbstractModul<E extends AbstractModulEntity>

Kann ich über dieses E vielleicht zur Laufzeit den Tabellen-Namen herausbekommen?


Fällt euch etwas ein, wie ich dieses Problem so lösen könnte, dass bei neuen Modulen nichtmal der Entity-Name mitgegeben werden muss?

Vielen lieben Dank für eure Hilfe.

 

[Airborne]

Du kannst dir mit [c]SessionFactory.getAllClassMetaData()[/c] alle Tabellen nennen lassen und dich dann daran entlang hangeln:

SessionFactory (Hibernate API Documentation))

java - Get all table names set up in SessionFactory - Stack Overflow
...da hat das auch wer hübsch erklärt.

 

[DanZ]

Also... es kommt drauf an wie deine Vererbungsstrukturen aussehen.

Nehmen wir mal an du hast AbstractModule<E extends AbstractModuleEntity> und SpecificModule extends AbstractModule<SpecificModuleEntity>, dann kannst du in AbstractModule sowas machen wie:

 Type[] actualTypeArguments = ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments();
  Class moduleEntityClass=(Class) actualTypeArguments[0];
  Table tableAnnotation=(Table) moduleEntityClass.getAnnotation(Table.class);
  usw.

(Hab ich aus einem komplexeren Zusammenhang gepasted und vereinfacht/angepasst. Musst evt. bisschen rumpürobieren bis es wirklich funktioniert).

Aber sei vorsichtig damit! Sobald sich was an der Vererbung ändert kann das schnell in sich zusammenbrechen und dann stehst du da und weißt nicht warum so komische Exceptions geworfen werden. Und wirklich schön ist so ein Konstrukt generell nie.

 

[Xenya]

Hallo ihr beiden,
vielen Dank für die Antworten, sie haben mir sehr geholfen.
Habe nun eine Lösung aus beiden Tipps gebaut. Ob sie wirklich optimal ist, weiß ich nicht.

Den Code von dir DanZ, musste ich ausbauen. Da es sein kann, dass die Hierachie tiefer ist und der generische Parameter erst ganz zum Schluss kommt, brauche ich was, der mit jeder Hierachtiefe umgehen kann.

Habe da selber was zusammen gefrickelt, da ich mir aber nicht sicher bin, was alles in Zukunft kommt, habe ich mich für Helfer-Methoden entschieden, die ich auf dieser Seite gefunden habe.
Hier kurz die Methode, die mir die generischen Klassen ermittelt:

public static <T> List<Class<?>> getTypeArguments(Class<T> baseClass, Class<? extends T> childClass) 
{
	Map<Type, Type> resolvedTypes = new HashMap<Type, Type>();
    Type type = childClass;
    // start walking up the inheritance hierarchy until we hit baseClass
    while (! getClass(type).equals(baseClass))
        if (type instanceof Class)
            // there is no useful information for us in raw types, so just keep going.
        	type = ((Class<?>) type).getGenericSuperclass();
        else
        {
        	ParameterizedType parameterizedType = (ParameterizedType) type;
            Class<?> rawType = (Class<?>) parameterizedType.getRawType();
      
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            TypeVariable<?>[] typeParameters = rawType.getTypeParameters();
            for (int i = 0; i < actualTypeArguments.length; i++)
            	resolvedTypes.put(typeParameters[i], actualTypeArguments[i]);
      
            if (!rawType.equals(baseClass))
            	type = rawType.getGenericSuperclass();
        }
  
    // finally, for each actual type argument provided to baseClass, determine (if possible)
    // the raw class for that type argument.
    Type[] actualTypeArguments;
    if (type instanceof Class)
    	actualTypeArguments = ((Class<?>) type).getTypeParameters();
    else
    	actualTypeArguments = ((ParameterizedType) type).getActualTypeArguments();

    List<Class<?>> typeArgumentsAsClasses = new ArrayList<Class<?>>();
    // resolve types by chasing down type variables.
    for (Type baseType: actualTypeArguments)
    {
    	while (resolvedTypes.containsKey(baseType))
    		baseType = resolvedTypes.get(baseType);

    	typeArgumentsAsClasses.add(getClass(baseType));
    }
    
    return typeArgumentsAsClasses;
}

public static Class<?> getClass(Type type)
{
    if (type instanceof Class)
    	return (Class<?>) type;
    else
    	if (type instanceof ParameterizedType)
    		return getClass(((ParameterizedType) type).getRawType());
	    else
	    	if (type instanceof GenericArrayType)
	    	{
	    		Type componentType = ((GenericArrayType) type).getGenericComponentType();
	    		Class<?> componentClass = getClass(componentType);
	    		if (componentClass != null )
	    			return Array.newInstance(componentClass, 0).getClass();
	    	else
	    		return null;
	    	}
	    else 
    return null;
}

Die Klassen benötige ich für die Methode, die mir Airborne vorgeschlagen hat.

Somit bekomme ich die Tabellennamen:

List<Class<?>> genericClasses = getTypeArguments(AbstractModul.class, getClass());

ClassMetadata metaData = sessionFactory.getClassMetadata(genericClasses[0]);
AbstractEntityPersister entityPersister = (AbstractEntityPersister) metaData;

System.out.println(entityPersister.getTableName());

Später muss ich aber noch raus kriegen, ob ich den Tabellen-Namen oder den Klassen-Namen brauche. Hab grad keine Zeit zu Testen, mach ich später.

Vielen Dank für eure Hilfe

 

[Xenya]

Es hat sich ein kleiner Fehler eingeschlichen.

Zeile 3 im untersten Code abschnitt ist eine List und kein Array, weshalb der Zugriff mit get erfolgen muss:

List<Class<?>> genericClasses = getTypeArguments(AbstractModul.class, getClass());

ClassMetadata metaData = sessionFactory.getClassMetadata(genericClasses.get(0));
AbstractEntityPersister entityPersister = (AbstractEntityPersister) metaData;

System.out.println(entityPersister.getTableName());