Ergebnis aus Joined Tabelle erhalten

Meine Named Query sieht wie folgt aus

[SQL]
SELECT l.iso639, l.flag, n.name FROM Language l LEFT JOIN LanguageName n ON l.id = n.owner WHERE l.published = 1 AND l.deletedAt IS NULL AND n.language = :language
[/SQL]

Klasse Language ist eine Tabelle in der ich Informationen zu einer Sprache halte
Klasse LanguageName ist eine Tabelle in der die Namensbezeichnungen enthalten sind.

LanguageName verfügt über

  • primary key
  • owner (die Language zu der die Tabelle gehört)
  • language (die Language in der “Name” gespeichert ist)
  • name (der Bezeichner der Sprache)

Ich möchte über JPA den obigen Staatement als Liste absetzen.

String qlString = "SELECT l.iso639, l.flag, n.name "
                                  + " FROM Language l LEFT JOIN LanguageName n ON l.id = n.owner "
                                  + " WHERE l.published = 1 AND l.deletedAt IS NULL AND n.language = :language";
String key = "language";
Language value = new Language(2);  

List list = em.createQuery(qlString).setParameter(key, value).getResultList();

Ich habe schon einiges ausprobiert, aber ich erhalte immer wieder irgendwelche Exceptions. Kann mir einer sagen wie ich das korrekt schreiben müsste?

also so geht wohl kein Join in JPA oder hast du ein Tutorial auf das du dich beziehst?

irgendwas auszudenken, auch wenn vielleicht mit SQL eine respektable Referenz, ist kein guter Versuch

falls die Klassen ganz unterschiedlich sind dann geht vielleicht


Query auf beide Klassen, im WHERE Verknüpfung erstellen, der klassische Fall auch fürs SQL
(oder jemand postet noch etwas besseres)

viel geläufiger und angebrachter ist, dass die Klassen sich gegenseitig mappen, hat Language eine Referenz auf LanguageName?
dafür finden sich nun überall Beispiele, ein Link den ich gerade auf habe:
EclipseLink/UserGuide/JPA/Basic JPA Development/Querying/JPQL - Eclipsepedia
mit

SELECT e FROM Employee e JOIN e.address a WHERE a.city = :city
oder auch
SELECT e FROM Employee e LEFT JOIN e.address a ORDER BY a.city

Erstmal Danke SlaterB,

wie oben bereits beschrieben gibt es 2 1:N - Beziehungen zwischen der Tabelle “language” und “language_name”. In language befinden sich alle Meta-Daten, in LanguageName befinden sich die beiden Beziehungen auf Language

  • owner_id // Der Besitzer des Namen
  • language_id // die Language in der der Text von “name” gespeichert ist.

Deine beiden SQL Statments sind mir schon klar, ich möchte aber außer “e” auch in deinem Fall a.city als Ergebnis mit erhalten.

wie gesagt denke ich dass deine Query hinsichtlich Join nicht tauglich ist, kann mich aber irren,
SELECT .. FROM LanguageName n LEFT JOIN n.language l WHERE .. vielleicht oder was auch immer owner noch für ein Rolle spielt,
experimentieren wenn diese Richtung noch vakant,

wobei deine Frage in andere Richtung geht, nur nach Spalten für SELECT? da weiß ich nun nicht gar nicht wo du welche Probleme hat,
was sind denn die Fehlermeldungen?

in SQL dürftest du jede beliebige Spalte selektieren können und auch in JPQL gibt es da keine allgemein verdächtigen Beschränkungen möchte ich behaupten

Die Fehlermeldung lautet

Exception in thread “main” Local Exception Stack:
Exception [EclipseLink-6076] (Eclipse Persistence Services - 2.5.2.v20140319-9ad6abd): org.eclipse.persistence.exceptions.QueryException
Exception Description: Object comparisons can only be used with OneToOneMappings. Other mapping comparisons must be done through query keys or direct attribute level comparisons.
Mapping: [org.eclipse.persistence.mappings.DirectToFieldMapping[id–>language.ID]]
Expression: [
Query Key id
Base roy.entities.localisation.Language]
Query: ReportQuery(referenceClass=Language jpql=“SELECT l.iso639, l.flag, n.name FROM Language l LEFT JOIN LanguageName n ON l.id = n.owner WHERE l.published = 1 AND l.deletedAt IS NULL AND n.language = :language”)
at org.eclipse.persistence.exceptions.QueryException.unsupportedMappingForObjectComparison(QueryException.java:1170)
at org.eclipse.persistence.mappings.DatabaseMapping.buildObjectJoinExpression(DatabaseMapping.java:292)
at org.eclipse.persistence.internal.expressions.RelationExpression.normalize(RelationExpression.java:832)
at org.eclipse.persistence.expressions.ExpressionBuilder.normalize(ExpressionBuilder.java:267)
at org.eclipse.persistence.internal.expressions.RelationExpression.normalize(RelationExpression.java:825)
at org.eclipse.persistence.internal.expressions.CompoundExpression.normalize(CompoundExpression.java:232)
at org.eclipse.persistence.internal.expressions.SQLSelectStatement.normalize(SQLSelectStatement.java:1449)
at org.eclipse.persistence.internal.queries.ExpressionQueryMechanism.buildReportQuerySelectStatement(ExpressionQueryMechanism.java:641)
at org.eclipse.persistence.internal.queries.ExpressionQueryMechanism.buildReportQuerySelectStatement(ExpressionQueryMechanism.java:586)
at org.eclipse.persistence.internal.queries.ExpressionQueryMechanism.prepareReportQuerySelectAllRows(ExpressionQueryMechanism.java:1694)
at org.eclipse.persistence.queries.ReportQuery.prepareSelectAllRows(ReportQuery.java:1203)
at org.eclipse.persistence.queries.ReadAllQuery.prepare(ReadAllQuery.java:744)
at org.eclipse.persistence.queries.ReportQuery.prepare(ReportQuery.java:1071)
at org.eclipse.persistence.queries.DatabaseQuery.checkPrepare(DatabaseQuery.java:661)
at org.eclipse.persistence.queries.ObjectLevelReadQuery.checkPrepare(ObjectLevelReadQuery.java:901)
at org.eclipse.persistence.queries.DatabaseQuery.checkPrepare(DatabaseQuery.java:613)
at org.eclipse.persistence.internal.jpa.EJBQueryImpl.buildEJBQLDatabaseQuery(EJBQueryImpl.java:194)
at org.eclipse.persistence.internal.jpa.EJBQueryImpl.buildEJBQLDatabaseQuery(EJBQueryImpl.java:116)
at org.eclipse.persistence.internal.jpa.EJBQueryImpl.(EJBQueryImpl.java:102)
at org.eclipse.persistence.internal.jpa.EJBQueryImpl.(EJBQueryImpl.java:86)
at org.eclipse.persistence.internal.jpa.EntityManagerImpl.createQuery(EntityManagerImpl.java:1603)
at roy.main.Main.main(Main.java:33)

Hier auch nochmal die beiden Entitäten

@Entity
@Table(name="language_name")
public class LanguageName implements IEntity<Integer> {
        private static final long serialVersionUID = 1L;
        
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Basic(optional = false)
        @Column(nullable = false)
        private Integer id; 
        
        @JoinColumn(name = "owner_id", referencedColumnName = "id")
        @ManyToOne(optional = false)
        private Language owner;
        
        @JoinColumn(name = "language_id", referencedColumnName = "id")
        @ManyToOne(optional = false)
        private Language language;
        
        @Basic(optional = false)
        @NotNull
        @Size(min = 1, max = 255)
        @Column(name = "name")
        private String name;

        public LanguageName() {
        }

        public LanguageName(Integer id) {
            this.id = id;
        }

        @Override
        public Integer getId() {
            return id;
        }
        
        @Override
        public void setId(Integer id) {
            this.id = id;
        }     
        
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
        
        public Language getOwner() {
            return owner;
        }

        public void setOwner(Language owner) {
            this.owner = owner;
        }

        public Language getLanguage() {
            return language;
        }

        public void setLanguage(Language language) {
            this.language = language;
        }

        @Override
        public int hashCode() {
            int hash = 0;
            hash += (id != null ? id.hashCode() : 0);
            return hash;
        }

        @Override
        public boolean equals(Object object) {
            // TODO: Warning - this method won't work in the case the id fields are not set
            if (!(object instanceof LanguageName)) {
                return false;
            }
            LanguageName other = (LanguageName) object;
            if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
                return false;
            }
            return true;
        }

        @Override
        public String toString() {
            return "LanguageName[ id=" + id + " ]";
        }        
}
@Entity
@Table(name="language")
@NamedQueries({
        @NamedQuery(name = "Language.availabels", query = "SELECT l FROM Language l WHERE l.published = true AND l.deletedAt IS NULL")
})
public class Language implements IMaintainceEntity<Integer> {
        private static final long serialVersionUID = 1L;
        
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Basic(optional = false)
        @Column(nullable = false)
        private Integer id;

        @Column(name = "created_at")
        @Temporal(TemporalType.TIMESTAMP)
        private Date createdAt;
        
        @JoinColumn(name = "created_by", referencedColumnName = "id")
        @ManyToOne(fetch = FetchType.LAZY)
        private Person createdBy;       
        
        @Column(name = "modified_at")
        @Temporal(TemporalType.TIMESTAMP)
        private Date modifiedAt;
        
        @JoinColumn(name = "modified_by", referencedColumnName = "id")
        @ManyToOne(fetch = FetchType.LAZY)
        private Person modifiedBy;        
        
        @Column(name = "deleted_at")
        @Temporal(TemporalType.TIMESTAMP)
        private Date deletedAt;
        
        @JoinColumn(name = "deleted_by", referencedColumnName = "id")
        @ManyToOne(fetch = FetchType.LAZY)
        private Person deletedBy;
        
        @Basic(optional = false)
        @NotNull
        @Column(nullable = false)
        private boolean published;
        
        private Integer ordering;

        @Basic(optional = false)
        @NotNull
        @Column(nullable = false)
        private boolean standard;
        
        @Basic(optional = false)
        @NotNull
        @Size(min = 1, max = 10)
        @Column(nullable = false, length = 10)
        private String iso639;

        @Size(max = 255)
        @Column(length = 255)
        private String flag;
        
        @Basic(optional = false)
        @NotNull
        @Size(min = 1, max = 255)
        @Column(name = "short_date_format", nullable = false, length = 255)
        private String shortDateFormat;
        
        @Basic(optional = false)
        @NotNull
        @Size(min = 1, max = 255)
        @Column(name = "long_date_format", nullable = false, length = 255)
        private String longDateFormat;

        @OneToMany(mappedBy = "preferedLanguage", fetch = FetchType.LAZY)
        private List<Person> personList;
        
        @OneToMany(cascade = CascadeType.ALL, mappedBy = "owner", fetch = FetchType.LAZY)
        private List<LanguageName> languageNames;

        @OneToMany(cascade = CascadeType.ALL, mappedBy = "language", fetch = FetchType.LAZY)
        private List<LanguageName> usingLanguages;
        
        public Language() {
        }

        public Language(Integer id) {
                this.id = id;
        }        

        @Override
        public Integer getId() {
            return id;
        }

        @Override
        public void setId(Integer id) {
            this.id = id;
        }

        @Override
        public Date getCreatedAt() {
            return createdAt;
        }

        @Override
        public void setCreatedAt(Date createdAt) {
            this.createdAt = createdAt;
        }

        @Override
        public Person getCreatedBy() {
            return createdBy;
        }

        @Override
        public void setCreatedBy(Person createdBy) {
            this.createdBy = createdBy;
        }

        @Override
        public Date getModifiedAt() {
            return modifiedAt;
        }

        @Override
        public void setModifiedAt(Date modifiedAt) {
            this.modifiedAt = modifiedAt;
        }

        @Override
        public Person getModifiedBy() {
            return modifiedBy;
        }

        @Override
        public void setModifiedBy(Person modifiedBy) {
            this.modifiedBy = modifiedBy;
        }

        public Date getDeletedAt() {
            return deletedAt;
        }

        public void setDeletedAt(Date deletedAt) {
            this.deletedAt = deletedAt;
        }

        public Person getDeletedBy() {
            return deletedBy;
        }

        public void setDeletedBy(Person deletedBy) {
            this.deletedBy = deletedBy;
        }

        public boolean isPublished() {
            return published;
        }

        public void setPublished(boolean published) {
            this.published = published;
        }

        public Integer getOrdering() {
            return ordering;
        }

        public void setOrdering(Integer ordering) {
            this.ordering = ordering;
        }

        public boolean isStandard() {
            return standard;
        }

        public void setStandard(boolean standard) {
            this.standard = standard;
        }

        public String getIso639() {
            return iso639;
        }

        public void setIso639(String iso639) {
            this.iso639 = iso639;
        }

        public String getFlag() {
            return flag;
        }

        public void setFlag(String flag) {
            this.flag = flag;
        }

        public String getShortDateFormat() {
            return shortDateFormat;
        }

        public void setShortDateFormat(String shortDateFormat) {
            this.shortDateFormat = shortDateFormat;
        }

        public String getLongDateFormat() {
            return longDateFormat;
        }

        public void setLongDateFormat(String longDateFormat) {
            this.longDateFormat = longDateFormat;
        }

        public List<Person> getPersonList() {
            return personList;
        }

        public void setPersonList(List<Person> personList) {
            this.personList = personList;
        }

        public List<LanguageName> getLanguageNames() {
            return languageNames;
        }

        public void setLanguageNames(List<LanguageName> languageNames) {
            this.languageNames = languageNames;
        }

        public List<LanguageName> getUsingLanguages() {
            return usingLanguages;
        }

        public void setUsingLanguages(List<LanguageName> usingLanguages) {
            this.usingLanguages = usingLanguages;
        }
        
        @Override
        public int hashCode() {
            int hash = 0;
            hash += (id != null ? id.hashCode() : 0);
            return hash;
        }

        @Override
        public boolean equals(Object object) {
            // TODO: Warning - this method won't work in the case the id fields are not set
            if (!(object instanceof Language)) {
                return false;
            }
            
            Language other = (Language) object;
            if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
                return false;
            }
            return true;
        }

        @Override
        public String toString() {
            return "Language{" + "id=" + id + ", createdAt=" + createdAt + ", createdBy=" + createdBy + ", modifiedAt=" + modifiedAt + ", modifiedBy=" + modifiedBy + ", deletedAt=" + deletedAt + ", deletedBy=" + deletedBy + ", published=" + published + ", ordering=" + ordering + ", standard=" + standard + ", iso639=" + iso639 + ", flag=" + flag + ", shortDateFormat=" + shortDateFormat + ", longDateFormat=" + longDateFormat + ", personList=" + personList + ", languageNames=" + languageNames + ", usingLanguages=" + usingLanguages + '}';
        }
        
}

SELECT l.iso639, l.flag, n.name FROM Language l LEFT JOIN LanguageName n ON l.id = n.owner WHERE l.published = 1 AND l.deletedAt IS NULL AND n.language = :language"

ist nicht so klar (sieht aber gut aus), eines fällt mir auf: du machst einen LEFT JOIN auf LanguageName und willst n.name im Ergebnis (owohl das NULL sein kann) und fragst das gleichzeitig
in der Bedingung ab (n.language=:language) - das ist ein Vergleich mit NULL (oder null) und das ganze ist irgendwie komisch

ums nochmal darzustellen. Ich habe n Sprachen. Jede Spräche heist in einer anderen Sprache anders z.B.

für LanguageName

1 | de | de | deutsch
2 | de | en | german
3 | de | fr | aleman (sorry spreche kein Französisch falls es falsch sein sollte)
4 | en | de | englisch
5 | en | en | english

die 2 Spalte (owner) gibt den Besitzer an zu Language (die spalte ist eigentlich ein Integer) aber zum Verständnis habe ich hier mal iso639 eingetragen.
die 3 Spalte (language) gibt die Sprache an in der der zugehörige Text steht (auch dieses ist eigentlich ein Integer, s. Spalte 2)
die 4 Spalte ist der eigentliche Text

für Language
id | … | iso639 | flag | …
1 | … | de | german.jpg | …
2 | … | en | english.png | …

Habt ihr bessere Ideen wie man das lösen könnte?
Aber wenn es richtig ist wieso bekomme ich dann eine Exception?

Dein Design ist soweit richtig (Tabellen und Spalten)

es geht ja nur um die LEFT JOIN Abfrage

und warum machst du einen LEFT join auf die LanguageNames, wenn du in der abschließenden WHERE Klausel eine Bedingung an diese Tabelle stellst? Da kannst du ja gleich einen inner Join machen?

ODER

zwei getrennte queries: erst mal nachschauen, welchen Pk die Sprache hat und dann in der Übersetzungstabelle nachschauen, ob es einen Namen für diese Sprache1 in Sprache2 überhaupt gibt

*** Edit ***

Ach ja:

in deiner Query =1, aber l.published = true ist besser

@Roy
mein allererster Satz gestern war

und du gehst immer noch nicht auf das Join ein,

ON l.id = n.owner kann doch nicht funktionieren wenn n.owner ein Language-Objekt ist, aber l.id ein Integer?!
oder sehe ich alles falsch und in der Hinsicht schon genauer getestet

vielleicht geht ON l = n.owner

vielleicht nach wie vor die von mir vorgeschlagenen anderen Varianten testen
(wobei ich nur Hibernate + HQL kenne, nicht direkt JPQL, EclipseLink, was immer das sein mag)
also FROM LanguageName n LEFT JOIN n.language l usw.

arbeiten, ausprobieren, nachschlagen wie Joins funktionieren

Danke euch beiden. Irgendwie stand und stehe ich immer noch wie behämmert vor einem weiteren Problem.

Ich wollte das Ergebnis gerne in ein Object

public class ResultClass {
       public String  iso639;
       public String  name;
       public String  flag;

        @Override
        public String toString() {
            return "ResultClass{" + "iso639=" + iso639 + ", name=" + name + ", flag=" + flag + '}';
        }
}

speichern um auf die Ergebnisse zugreifen zu können:

               List<ResultClass> list = (List<ResultClass>)em.createQuery(qlString).setParameter(key, value).getResultList();
                System.out.println("Count = " + list.size());
                for (int i=0; i<list.size(); i++) {
                    System.out.println(list.get(i));
                }

Als Ergebnis erhalte ich allerdings

Count = 2
[Ljava.lang.Object;@36aa52d2
[Ljava.lang.Object;@4ee25d80

Ich habe es mit

  • createQuery(qlString, ResultClass)
  • System.out.println(list.get(i).name)
    etc.

ausprobiert. Mit letzterem erhalte ich z.B.

Exception in thread “main” java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to roy.ResultClass

irgendwie stehe ich hier wie der Ochs vorm Berg. Kann mir bitte einer sagen, was ich hier hier gerad übersehe bzw wie ich die Werte der SQL Abfrage erhalte


also dort SELECT NEW com.mycompany.model.CustomerCityInfo(c.name, c.address.city) from Customer c

dass als Standard eine Liste von Object[] kommt (falls nicht genau eine gemappte Klasse abgefragt) ist hoffentlich bekannt

Welche Abfrage? Du hast vergessen uns mitzuteilen, welche query jetzt funktioniert?

Im übrigen ist deine ResultClass wertlos (JPA weiß nichts davon) - kann das also auch nicht zurückgeben…

Danke SlaterB.

Meine kleine Main - Methode sieht inzwischen so aus

       public static void main(String[] a) {  
                EntityManagerFactory factory = Persistence.createEntityManagerFactory("pu");
                EntityManager em = factory.createEntityManager();

//                String qlString = "SELECT l.iso639, l.flag, n.name "
//                                    + " FROM Language l INNER JOIN LanguageName n ON l = n.owner "
//                                    + " WHERE l.published = true AND l.deletedAt IS NULL AND n.language = :language";

                String qlString = "SELECT NEW roy.ResultClass( l.iso639, l.flag, n.name )"
                                    + " FROM Language l INNER JOIN l.languageNames n ON l = n.owner "
                                    + " WHERE l.published = true AND l.deletedAt IS NULL AND n.language = :language";
                
                String key = "language";
                Language value = new Language();  
                value.setId(1);
                    
                List<ResultClass> list = em.createQuery(qlString).setParameter(key, value).getResultList();

                System.out.println("Count = " + list.size());
                for (int i=0; i<list.size(); i++) {
                    System.out.println(list.get(i).name);
                }
       }

Aber ich erhalte jetzt eine Exception

Exception in thread “main” Local Exception Stack:
Exception [EclipseLink-6137] (Eclipse Persistence Services - 2.5.2.v20140319-9ad6abd): org.eclipse.persistence.exceptions.QueryException
Exception Description: An Exception was thrown while executing a ReportQuery with a constructor expression: java.lang.NoSuchMethodException: roy.ResultClass.(java.lang.String, java.lang.String, java.lang.String)
Internal Exception: java.lang.NoSuchMethodException: roy.ResultClass.(java.lang.String, java.lang.String, java.lang.String)
Query: ReportQuery(referenceClass=Language jpql=“SELECT NEW roy.ResultClass( l.iso639, l.flag, n.name ) FROM Language l JOIN l.languageNames n ON l = n.owner WHERE l.published = true AND l.deletedAt IS NULL AND n.language = :language”)
at org.eclipse.persistence.exceptions.QueryException.exceptionWhileUsingConstructorExpression(QueryException.java:530)
at org.eclipse.persistence.queries.ConstructorReportItem.initialize(ConstructorReportItem.java:188)
at org.eclipse.persistence.queries.ReportQuery.prepare(ReportQuery.java:1059)
at org.eclipse.persistence.queries.DatabaseQuery.checkPrepare(DatabaseQuery.java:661)
at org.eclipse.persistence.queries.ObjectLevelReadQuery.checkPrepare(ObjectLevelReadQuery.java:901)
at org.eclipse.persistence.queries.DatabaseQuery.checkPrepare(DatabaseQuery.java:613)
at org.eclipse.persistence.internal.jpa.EJBQueryImpl.buildEJBQLDatabaseQuery(EJBQueryImpl.java:194)
at org.eclipse.persistence.internal.jpa.EJBQueryImpl.buildEJBQLDatabaseQuery(EJBQueryImpl.java:116)
at org.eclipse.persistence.internal.jpa.EJBQueryImpl.(EJBQueryImpl.java:102)
at org.eclipse.persistence.internal.jpa.EJBQueryImpl.(EJBQueryImpl.java:86)
at org.eclipse.persistence.internal.jpa.EntityManagerImpl.createQuery(EntityManagerImpl.java:1603)
at roy.main(Main.java:39)
Caused by: java.lang.NoSuchMethodException: roy.ResultClass.(java.lang.String, java.lang.String, java.lang.String)
at java.lang.Class.getConstructor0(Class.java:3074)
at java.lang.Class.getConstructor(Class.java:1817)
at org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getConstructorFor(PrivilegedAccessHelper.java:157)
at org.eclipse.persistence.queries.ConstructorReportItem.initialize(ConstructorReportItem.java:184)
… 10 more

Sie wird durch anscheinend durch

39  List<ResultClass> list = em.createQuery(qlString).setParameter(key, value).getResultList();

ausgelöst.

Hier vorsichtshalber nochmal die ResultClass

public class ResultClass {
       public String  iso639;
       public String  name;
       public String  flag;
 
        @Override
        public String toString() {
            return "ResultClass{" + "iso639=" + iso639 + ", name=" + name + ", flag=" + flag + '}';
        }
}

Ich weis nur nicht was ich gerade falsch mache.

steht in StackTraces allgemein für Konstruktoren, da kommt es durchaus auch mal zu Exceptions

NoSuchMethodException: roy.ResultClass.<init>(java.lang.String, java.lang.String, java.lang.String)
heißt dass es keinen Konstruktor mit 3 Strings gibt,

dass dieser benötigt wird ist recht naheliegend (im Link schlendrianerweise auch nicht erwähnt),
freilich nur bei einem gewissen Programmierverständnis, später vielleicht einmal

wie sollte es sonst funktionieren, sollte die Query sich nach Reihenfolge der Definition in Query und Klasse
(bei name zu flag übrigens unterschiedliche Reihenfolge, aufpassen wie Konstruktor definiert und was übergeben!)
oder Namensähnlichkeit entscheiden, welches Attribut der Query zu welchem Attribut der Klasse kommt?

"Ich weis nur nicht was ich gerade falsch mache. " -> das gilt ja anscheinend immer und überall, schreibe lieber gar nicht solche Sätze dazu
[spätes edit: wirklich nur auf diesen Satz bezogen, die Frage an sich ohne den Satz wäre weitaus ok-er :wink: ]

Ahh ok werds gleich mal ausprobieren.