public interface DtoDao {
	public List loadDtos(Class dtoClass, Criterion criterion);
 
	// TODO: query by exmaple
	// aber hierzu müssen die dto-properties auf entity-properties zurück gemappt werden
}

public class DvoDaoImpl implements DvoDao, InitializingBean{
	private static final Log LOG = LogFactory.getLog(DvoDaoImpl.class);
 
	private HqlToSqlTranslator translator;
	private SessionFactory sessionFactory;
	private final DvoEntityManager entityManager = DvoEntityManager.getInstance();
 
	@Transactional(isolation=Isolation.READ_COMMITTED, propagation=Propagation.REQUIRED, readOnly=true, rollbackFor=Exception.class)
	public List loadDvos(Class dvoClass, Criterion criterion){
		return loadDvos(entityManager.getMetaByDvo(dvoClass), criterion);
	}
 
	private List loadDvos(DvoEntityMeta meta, Criterion criterion){
		/**/
		// TODO: optimieren: wenn mehrere attribute einer aggregation (z.b. x.y.id und x.y.name) benutzt werden,
		// dann sollen nicht zwei joins erzeugt werden
		final Criteria criteria = sessionFactory.getCurrentSession().createCriteria(meta.getEntityClass(), "d");
		// es werden zwei informationen von der meta benötigt:
		// 1. welche felder sollen in der query geladen werden
		// 2. in welche properties sollen die daten gespeichert werden
 
		// beispiel:
		// dlrListDvoPropertiesByAlias.put("customerName", "referencedMTMessage.customer.name");
		// bedeutet, dass die dvo-property "customerName" mit den daten aus "referencedMTMessage.customer.name"
		// befüllt werden soll.
 
		// der query-teil ("referencedMTMessage.customer.name") muss gesplittet und mit joins in die abfrage integriert werden.
		// auch muss der index jedes feldes nachgehalten werden, da das resultset nur über indizes einzelne kolumnen liefert
 
		final Map<String, String> propertyToQueryMappings = meta.getDvoPropertiesToQueryPaths();
		if (LOG.isDebugEnabled()){
			LOG.debug("propertyToQueryMappings="+propertyToQueryMappings);
		}
		// property -> index in resultset
		final HashMap<String, Integer> columnMappingsByIndex = new HashMap<String, Integer>(10);
		// key -> ag_referencedMTMessage.country, value -> ag_referencedMTMessage_country
		// LEFT JOIN ag_referencedMTMessage.country AS ag_referencedMTMessage_country
		final HashMap<String, String> aggregations = new HashMap<String, String>(10);
		final ProjectionList projections = Projections.projectionList();
 
		int maxAggregationDeepth = 0; // maximale anzahl aggregationen bei allen querypaths
		int propertyColumnIndex = 0; // index der property in resultset
 
		String queryPath; // querypath der aktuellen property
		int aggregationDeepth; // anzahl aggregationen im querypath der aktuellen property
		final ArrayList<String> aggregationParts = new ArrayList<String>(5); // querypath der aktuellen property zerstueckelt
 
		for (final String property:propertyToQueryMappings.keySet()){
			queryPath = propertyToQueryMappings.get(property);
 
			// zur ermittlung der aggregationen
			aggregationDeepth = StringUtil.occurences(queryPath, '.');
			if (LOG.isDebugEnabled()){
				LOG.debug("property="+property+", queryPath="+queryPath+", aggregationDeepth="+aggregationDeepth);
			}
 
			if (aggregationDeepth<1){
				// keine aggregation
				// state -> d.state
				projections.add(Projections.property("d."+queryPath));
				if (LOG.isDebugEnabled()){
					LOG.debug("  adding direct property projection d."+queryPath);
				}
			}
			else{
				maxAggregationDeepth = Math.max(maxAggregationDeepth, aggregationDeepth);
				// aggregationen vorhanden
				// alle abarbeiten
 
				// erst alle teile ermitteln
				aggregationParts.clear();
				CollectionSplitter.toList(aggregationParts, queryPath, "\\.", true, true);
 
				if (LOG.isDebugEnabled()){
					LOG.debug("  aggregationParts="+aggregationParts);
				}
 
				// beispiele für aggregationen:
 
				// customer.id -> ag_customer.id + LEFT JOIN d.customer AS ag_customer
 
				// referencedMTMessage.country.iso3166
				// -> ag_referencedMTMessage_country.iso3166
				// + LEFT JOIN d.referencedMTMessage AS ag_referencedMTMessage
				// + LEFT JOIN ag_referencedMTMessage.country AS ag_referencedMTMessage_country
 
				// Es gibt also 3 verschiedene Positionen, an denen ein queryPath-Teil stehen kann:
				// 1. am anfang. Dann handelt es sich um ein attribut der domain
				//	hier muss ein join erzeugt werden, weil weitere attribute folgen (mindestens ein weiteres, dass das projection attribut des joins darstellt) 
				// 2. am ende. dann handelt es sich um ein attribut der zuletzt erzeugten aggregation (z.b. ag_referencedMTMessage_country.iso3166)
				//	hier braucht nichts mehr gejoint zu werden, sondern das attribut muss als projektion hinzugefügt werden
				// 3. in der mitte. dann handelt es sich um ein attribut der zuletzt erzeugten aggregation, die aber
				// 	gejoint werden muss, weil weitere attribute folgen
 
				// letzte aggregation
				String lastAggregationName = null;
				String currentAggregationPart, currentAggregationName;
 
				// es gibt hier mindestens zwei aggregationParts
				// erster teil beschreibt attribut von domain, also z.b. d.customer
				for (int aggregationIndex=0; aggregationIndex<=aggregationDeepth; aggregationIndex++){
					currentAggregationPart = aggregationParts.get(aggregationIndex);
					if (LOG.isDebugEnabled()){
						LOG.debug("    checking aggregationIndex="+aggregationIndex+", part="+currentAggregationPart);
					}
					if (aggregationIndex==0){
						// entspricht "LEFT JOIN d.referencedMTMessage AS ag_referencedMTMessage"
						lastAggregationName = "ag_"+currentAggregationPart;
						aggregations.put("d."+currentAggregationPart, lastAggregationName);
					}
					else if (aggregationIndex==aggregationDeepth){
						// letzter teil beschreibt das endliche attribut, dass zur projektion hinzukommt
						projections.add(Projections.property(lastAggregationName+"."+currentAggregationPart));
						if (LOG.isDebugEnabled()){
							LOG.debug("    last aggregation part found: adding projection "+lastAggregationName+"."+currentAggregationPart);
						}
					}
					else{
						// mitten drin
						// entspricht "LEFT JOIN ag_referencedMTMessage.country AS ag_referencedMTMessage_country"
						currentAggregationName = lastAggregationName+"_"+currentAggregationPart;
						aggregations.put(lastAggregationName+"."+currentAggregationPart, currentAggregationName);
						if (LOG.isDebugEnabled()){
							LOG.debug("    middle aggregation part found: adding aggregation "+lastAggregationName+"."+currentAggregationPart+" -> "+currentAggregationName);
						}
						lastAggregationName = currentAggregationName;
					}
				}
			}
 
			columnMappingsByIndex.put(property, propertyColumnIndex++);
		}
 
		// wenn aggregationen vorhanden sind, dann einfügen
		if (maxAggregationDeepth>0){
			// aggregationen (joins)
			// nach länge sortieren
			if (LOG.isDebugEnabled()){
				LOG.debug("building aggregations");
			}
			final List<String> aggregationsSizeSorted = new ArrayList<String>(aggregations.keySet());
			Collections.sort(aggregationsSizeSorted, new StringLengthComparator());
			if (LOG.isDebugEnabled()){
				LOG.debug("aggregations (sorted): "+aggregationsSizeSorted);
			}
			for (final String fromAggregation:aggregationsSizeSorted){
				criteria.createAlias(fromAggregation, aggregations.get(fromAggregation));
			}
		}
 
		// projektionen
		criteria.setProjection(projections);
 
		if (criterion!=null){
			criteria.add(criterion);
		}
 
		if (LOG.isDebugEnabled()){ 
			if (translator!=null){
				LOG.debug("created query: "+translator.toSql(criteria));
			}
			LOG.debug("columnmappings: "+columnMappingsByIndex);
		}
 
		// nun abfrage ausführen und dvofactory zum erzeugen der dvos benutzen
		final HibernateBuildByRowScrollAction scrollAction = new DvoBuildByRowScrollActionImpl(meta, columnMappingsByIndex);
		return loadByScroll(scrollAction, criteria);
	}
 
	@SuppressWarnings("unchecked")
	protected List loadByScroll(final HibernateBuildByRowScrollAction scrollAction, final Criteria criteria){
		final ArrayList data = new ArrayList();
		ScrollableResults result = null;
		try{
			if (scrollAction.getCacheMode()!=null){
				criteria.setCacheMode(scrollAction.getCacheMode());
			}
			if (scrollAction.getLockMode()!=null){
				criteria.setLockMode("d", scrollAction.getLockMode());
			}
			if (scrollAction.getScrollMode()!=null){
				result = criteria.scroll(scrollAction.getScrollMode());
			}
			else{
				result = criteria.scroll();
			}
			Object [] rowdata;
			Object resultObject;
			while (result.next()){
				rowdata = result.get();
				resultObject = scrollAction.build(rowdata);
				if (resultObject!=null){
					data.add(resultObject);
				}
			}
		}
		finally{
			if (result!=null){
				result.close();
			}
		}
		return data;
	}
 
	public void setHqlToSqlTranslator(HqlToSqlTranslator translator) {
		this.translator = translator;
	}
 
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
 
	public void afterPropertiesSet() throws Exception {
		if (sessionFactory==null){
			throw new NullPointerException("sessionFactory not set");
		}
	}
}

public class DvoEntityMeta {
	@SuppressWarnings("unused")
	private static final Log LOG = LogFactory.getLog(DvoEntityMeta.class);
 
	private final HashMap<String, String> dvoPropertiesToQueryPaths = new HashMap<String, String>();
	private final Class entityClass;
	private final Class dvoClass;
 
	public DvoEntityMeta(Class entityClass, Class dvoClass){
		this(entityClass, dvoClass, false);
	}
 
	public DvoEntityMeta(Class entityClass, Class dvoClass, boolean useSimplePropertyMapping){
		this.entityClass = entityClass;
		this.dvoClass = dvoClass;
		if (useSimplePropertyMapping){
			try {
				// My custom BeanUtil class extracts all bean-method names from the given class,
				// excluding methods like "getClass()".
				final Collection<String> properties = BeanUtil.getPropertyNamesFilteredFromClass(dvoClass);
				for (final String property:properties){
					dvoPropertiesToQueryPaths.put(property, property);
				}
			}
			catch (Exception e) {
				if (e instanceof RuntimeException){
					throw (RuntimeException) e;
				}
				else{
					final RuntimeException r = new RuntimeException(e);
					r.setStackTrace(e.getStackTrace());
					throw r;
				}
			}
		}
	}
 
 
	public Class getDvoClass() {
		return dvoClass;
	}
 
	public Class getEntityClass() {
		return entityClass;
	}
 
	public Map<String, String> getDvoPropertiesToQueryPaths() {
		return dvoPropertiesToQueryPaths;
	}
 
	public String getQueryPathForDvoProperty(String dvoProperty){
		return dvoPropertiesToQueryPaths.get(dvoProperty);
	}
 
	public void addDvoPropertiesToQueryPaths(String dvoProperty, String queryPath){
		dvoPropertiesToQueryPaths.put(dvoProperty, queryPath);
	}
 
	public String toString(){
		return "dvoClass="+dvoClass.getName()+", domainClass="+entityClass.getName()+", properties="+dvoPropertiesToQueryPaths;
	}
}

public class DvoEntityManager {
	private static final Log LOG = LogFactory.getLog(DvoEntityManager.class);
	private static DvoEntityManager INSTANCE = new DvoEntityManager();
	private HashMap<Class, DvoEntityMeta> entityMetaByDvoClass = new HashMap<Class, DvoEntityMeta>();
 
	private DvoEntityManager(){
		if (LOG.isDebugEnabled()){
			LOG.debug("creating dvo entity manager");
		}
	}
 
	public static DvoEntityManager getInstance(){
		return INSTANCE;
	}
 
	public boolean isDvo(Object o){
		if (o==null){
			return false;
		}
		return isDvo(o.getClass());
	}
 
	@SuppressWarnings("unchecked")
	public boolean isDvo(Class cls){
		if (cls==null){
			return false;
		}
		return cls.getAnnotation(DvoAnnotation.class)!=null;
	}
 
	@SuppressWarnings("unchecked")
	public void registerDvo(Class dvo){
		if (LOG.isDebugEnabled()){
			LOG.debug("registering "+dvo.getName());
		}
		if (isDvo(dvo) && !entityMetaByDvoClass.containsKey(dvo)){
			DvoAnnotation dvoAnnotation = (DvoAnnotation) dvo.getAnnotation(DvoAnnotation.class);
			final DvoEntityMeta meta = new DvoEntityMeta(dvoAnnotation.rootDomainClass(), dvo);
			// erzeugen einer entsprechenden meta-data
			final Method methods [] = dvo.getDeclaredMethods();
			final boolean defaultPropertyMapping = dvoAnnotation.defaultPropertyMapping(); 
			DvoPropertyAnnotation dvoPropertyAnnotation;
			String propertyName;
			for (final Method method:methods){
				propertyName = BeanUtil.getPropertyName(method);
				dvoPropertyAnnotation = method.getAnnotation(DvoPropertyAnnotation.class);
				if (dvoPropertyAnnotation!=null){
					meta.addDvoPropertiesToQueryPaths(propertyName, dvoPropertyAnnotation.attributePath());
				}
				else if (defaultPropertyMapping && !"class".equals(propertyName) && method.getAnnotation(Transient.class)==null && (propertyName.startsWith("get") || propertyName.startsWith("set") || propertyName.startsWith("is"))){
					meta.addDvoPropertiesToQueryPaths(propertyName, propertyName);
				}
			}
			entityMetaByDvoClass.put(dvo, meta);
			if (LOG.isDebugEnabled()){
				LOG.debug("Created entity meta: "+meta);
			}
		}
	}
 
	public void registerDvo(Object dvo){
		registerDvo(dvo.getClass());
	}
 
	public DvoEntityMeta getMetaByDvo(Class dvoClass){
		if (isDvo(dvoClass)){
			registerDvo(dvoClass);
		}
		return entityMetaByDvoClass.get(dvoClass);
	}
 
	public DvoEntityMeta getMetaByDvo(Object dvo){
		if (isDvo(dvo)){
			registerDvo(dvo);
		}
		return entityMetaByDvoClass.get(dvo.getClass());
	}
 
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface DvoAnnotation {
	Class rootDomainClass();
	boolean defaultPropertyMapping() default true;
}

@DvoAnnotation(rootDomainClass=Person.class)
public class PersonLastNameCountryViewObject{
	private String lastName;
	private String countryName;
	// more to come
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Inherited
public @interface DvoPropertyAnnotation {
	String attributePath();
}

@DvoAnnotation(rootDomainClass=Person.class)
public class PersonLastNameCountryViewObject{
	private String lastName;
	private String countryName;
 
	@DvoPropertyAnnotation(attributePath="lastName")
	public Long getLastName() {
		return id;
	}
 
	public void setLastName(Long id) {
		this.id = id;
	}
 
	@DvoPropertyAnnotation(attributePath="address.country.name")
	public String getCountryName() {
		return name;
	}
 
	public void setCountryName(String countryName){
		this.countryName = countryName;
	}

public class DvoBuildByRowScrollActionImpl{
	private CacheMode cacheMode;
	private LockMode lockMode;
	private DvoEntityMeta meta;
	private Map<String, Integer> propertyColumnMapping;
 
	public DvoBuildByRowScrollActionImpl(DvoEntityMeta meta, Map<String, Integer> propertyColumnMapping){
		this.meta = meta;
		this.propertyColumnMapping = propertyColumnMapping;
	}
 
	public final Object build(Object[] resultSetRow) {
		Object dvo;
		try {
			dvo = meta.getDvoClass().newInstance();
		}
		catch (Exception e) {
			final String err = "While creating instance of dvo "+meta.getDvoClass().getName()+" with default constructor";
			if (LOG.isErrorEnabled()){
				LOG.error(err, e);
			}
			if (e instanceof RuntimeException){
				throw (RuntimeException) e;
			}
			else{
				RuntimeException rt = new RuntimeException(err, e);
				rt.setStackTrace(e.getStackTrace());
				throw rt;
			}
		}
		for (final String property:propertyColumnMapping.keySet()){
			try {
				PropertyUtils.setProperty(dvo, property, resultSetRow[propertyColumnMapping.get(property)]);
			}
			catch (Exception e) {
				final String err = "While setting property \""+property+"\" from column \""+propertyColumnMapping.get(property)+"\" on dvo "+dvo.getClass().getName();
				if (LOG.isErrorEnabled()){
					LOG.error(err, e);
				}
				if (e instanceof RuntimeException){
					throw (RuntimeException) e;
				}
				else{
					RuntimeException rt = new RuntimeException(err, e);
					rt.setStackTrace(e.getStackTrace());
					throw rt;
				}
			}
		}
		return dvo;
	}
 
	public final CacheMode getCacheMode() {
		return cacheMode;
	}
 
	public final LockMode getLockMode() {
		return lockMode;
	}
 
	public final ScrollMode getScrollMode() {
		return ScrollMode.FORWARD_ONLY;
	}
}

remove_action('wp_head', 'rsd_link'); // remove Really Simple Discovery entry
remove_action('wp_head', 'wlwmanifest_link');  // remove Windows Live Writer Link  
remove_action('wp_head', 'wp_generator');  // remove Version output

<meta name="generator" content="Movable Type v3.2" />
<meta name="generator" content="Joomla! 1.5 - Open Source Content Management" />
<meta name="generator" content="TYPO3 4.1 CMS" />
<meta name="generator" content="Yahoo! SiteBuilder/2.4/1.5.0_02" />
<!-- 
	This website is powered by TYPO3 - inspiring people to share!
	TYPO3 is a free open source Content Management Framework initially created by Kasper Skaarhoj and licensed under GNU/GPL.
	TYPO3 is copyright 1998-2006 of Kasper Skaarhoj. Extensions are copyright of their respective owners.
	Information and contribution at http://typo3.com/ and http://typo3.org/
-->

delimiter //
 
CREATE TRIGGER `mywordpressdb`.`root_insert_only` 
  BEFORE INSERT ON `mywordpressdb`.`wp_users`
  FOR EACH ROW BEGIN
    DECLARE dummy INT;
    IF STRCMP(SUBSTRING(SESSION_USER(),1 , 4), 'dba@')<>0 THEN
      SELECT 'no' INTO dummy FROM dual.id WHERE dual.id=NEW.id;
    END IF;
  END
//
 
CREATE TRIGGER `mywordpressdb`.`root_delete_only` 
  BEFORE DELETE ON `mywordpressdb`.`wp_users`
  FOR EACH ROW BEGIN
    DECLARE dummy INT;
    IF STRCMP(SUBSTRING(SESSION_USER(),1 , 4), 'dba@')<>0 THEN
      SELECT 'no' INTO dummy FROM dual.id WHERE dual.id=12;
    END IF;
  END
//
 
delimiter ;

delimiter //
 
CREATE TRIGGER `mywordpressdb`.`restricted_update_only` 
  BEFORE UPDATE ON `mywordpressdb`.`wp_users`
  FOR EACH ROW BEGIN
    DECLARE dummy INT;
    IF STRCMP(SUBSTRING(SESSION_USER(),1 , 4), 'dba@')<>0 THEN
      SET NEW.ID=OLD.ID;
      SET NEW.user_login=OLD.user_login;
      SET NEW.user_pass=OLD.user_pass;
      SET NEW.user_registered=OLD.user_registered;
      SET NEW.user_activation_key=OLD.user_activation_key;
      SET NEW.user_status=OLD.user_status;
    END IF;
  END
//
 
delimiter ;

@Entity
public class Person{
	private Long id;
	private String firstname:
	private String lastName;
	private Date birthdate;
	private String comment;
	private Address address;
 
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	public Long getId(){
		return id;
	}
 
	// appropriate getters and setter for id,
	// firstname, lastname, birthdate and comment
 
	@ManyToOne
	public Address getAddress(){
		return address;
	}
}
 
@Entity
public class Address{
	private Long id;
	private String street;
	private Country country;
 
	// appropriate getters and setter for 
	// id, street and country
 
	@ManyToOne
	public Country getCountry(){
		return country;
	}
}
 
@Entity
public class Country{
	private String iso3166; 
	// iso 3166 2 letter code 
	// (uppercase), like DE for Germany
	private String name;
 
	@Id
	@Column(length=2)
	public String getIso3166(){
		return iso3166;
	}
 
	// appropriate getters and setter for name and iso3166
}

public class PersonLastNameCountryViewObject{
	private String lastName;
	private String countryName;
 
	// appropriate getters and setter
}

// Just an interface that will create a 
// view object for us for each resultset row
public interface ViewObjectFactory{
  public Object createNewViewObject();
}
 
// a cimple class to hold all ,eta data needed for building our view objects
public class ViewObjectMetaData{
  // This will hold the mappings like
  // lastName -> lastName
  // countryName -> address.country.name
  private final HashMap<String, String> 
    propertiesToObjectPaths = new HashMap<String, String>();
 
  // this will hold our initial domain class, like Person.class.
  // we need this to create a criteria in hibernate later on
  private Class domainClass;
 
  // the factory we will use to create the view objects
  private ViewObjectFactory voFactory;
 
  // as default, if no object paths are given, we assume that each view object property
  // will be mapped non-nestingly to the domain class propertys with the same name.
  // so the mapping will be something like:
  // propertyA -> propertyA
  // propertyB -> propertyB
  // will need BeanUtils to work, or make some own code with reflection
  public ViewObjectMetaData(ViewObjectFactory voFactory, 
    Class domainClass){
    this.voFactory = voFactory;
    this.domainClass = domainClass;
    try {
      Map desc = BeanUtils.describe(dtoFactory.createDto());
      desc.remove("class");
      final Collection<String> properties = 
        (Collection<String>) desc.keySet();
      for (final String property:properties){
        propertiesToObjectPaths.put(property, property);
      }
    }
    catch (Exception e) {
      // just make a runtime exception from it...
      if (e instanceof RuntimeException){
        throw (RuntimeException) e;
      }
      else{
        final RuntimeException r = new RuntimeException(e);
        r.setStackTrace(e.getStackTrace());
        throw r;
      }
    }
  }
 
  public ViewObjectMetaData(ViewObjectFactory voFactory, 
    Class domainClass, 
    Map<String, String> propertiesToObjectPaths){
    this.voFactory = voFactory;
    this.domainClass = domainClass;
    this.propertiesToObjectPaths.putAll(propertiesToObjectPaths); 
  }
 
  // appropriate getters
}

public class ViewObjectCriteriaBuilder{
 
  // just a helper class to transport 
  // criteria and columnmappings
  public static class ViewObjectCriteria{
    private Criteria criteria;
    private HashMap<String, Integer> propertyToColumnMappings = 
      new HashMap<String, Integer>();
 
    // apropriate getters/setters
  }
 
  private SessionFactory sessionFactory;
 
  // appropriate setter for the sessionFactory 
  // or just pass a current session to the next method
 
  public ViewObjectCriteria buildCriteria(ViewObjectMetaData voMetaData){
    final ViewObjectCriteria voCriteria = new ViewObjectCriteria();
 
    final Criteria criteria = sessionFactory.
      getCurrentSession().
      createCriteria("d", voMetaData.getDomainClass());
    voCriteria.setCriteria(criteria);
 
    final Map<String, String> propertiesToObjectPaths = 
      voMetaData.getPropertiesToObjectPaths();
 
    // our projections
    final ProjectionList projections = Projections.projectionList();
 
    // max. amount of aggregations in object path
    int maxAggregationDeepth = 0;
    // index of property in resultset
    int propertyColumnIndex = 0;
 
    String objectPath; // objectpath of current vo property
    // amount of aggregations in current object path
    int aggregationDeepth; 
    final ArrayList<String> aggregationParts = 
      new ArrayList<String>(5); // parts of the object path, splitted
 
 
    // in the first step we only collect information 
    // about the needed aggregations,
    // the joins will be build later on
    for (final String property:propertiesToObjectPaths.keySet()){
      objectPath = propertiesToObjectPaths.get(property);
 
      // this helper just counts the 
      // occurences of '.' in the objectPath
      aggregationDeepth = StringUtil.occurences(objectPath, '.');
 
      if (aggregationDeepth<1){
        // no aggregation, like
        // lastName -> d.lastName
        projections.add(Projections.property("d."+objectPath));
      }
      else{
        maxAggregationDeepth = 
          Math.max(maxAggregationDeepth, aggregationDeepth);
        // aggregations exist
 
        // first split the object path
        aggregationParts.clear();
        // this helper splits the objectPath 
        // on "\\." and adds all parts to the 
        // aggregationParts-list. Works the same 
        // way as String.split
        CollectionSplitter.toList(aggregationParts, objectPath, "\\.");
 
        // last aggregations alias
        String lastAggregationName = null;
        String currentAggregationPart, currentAggregationName;
 
        // when we're here, there are at least two parts in the object path
        // first part is an property of the 
        // root domain class, e. g. address -> d.address
        for (int aggregationIndex=0; 
          aggregationIndex<=aggregationDeepth; aggregationIndex++){
 
          currentAggregationPart = aggregationParts.get(aggregationIndex);
          if (aggregationIndex==0){
            // equals to "LEFT JOIN d.address AS ag_address"
            lastAggregationName = "ag_"+currentAggregationPart;
            aggregations.put(
              "d."+currentAggregationPart, 
              lastAggregationName);
          }
          else if (aggregationIndex==aggregationDeepth){
            // last part in object path, which 
            // denotes a property we want to have projected
            // equals to "SELECT ... ag_address_country.name FROM ..."
            projections.add(
              Projections.property(
                lastAggregationName+"."+currentAggregationPart));
          }
          else{
            // somewhere in the middle
            // equals to 
            // "LEFT JOIN ag_address.country AS ag_address_country"
            currentAggregationName = 
              lastAggregationName+"_"+currentAggregationPart;
            aggregations.put(
              lastAggregationName+"."+currentAggregationPart, 
              currentAggregationName);
            lastAggregationName = currentAggregationName;
          }
        }
      }
 
      // update index of property in resultset
      voCriteria.getPropertyToColumnMappings().
        put(property, propertyColumnIndex++);
    }
 
    // if there are any aggregations, we have
    // to add an alias for each to the criteria
    if (maxAggregationDeepth>0){
      // sort aggregatios (joins) by their alias length
      // this is to enshure that ag_address is 
      // added before ag_address_country
 
      final List<String> aggregationsSizeSorted = 
        new ArrayList<String>(aggregations.keySet());
 
      Collections.sort(aggregationsSizeSorted, 
        // the string length comparator just compares
        // the length of two strings
        new StringLengthComparator());
      for (final String fromAggregation:aggregationsSizeSorted){
        // here we also may use LEFT JOIN or some other join type
        criteria.createAlias(
          fromAggregation, 
          aggregations.get(fromAggregation));
      }
    }
 
    // add projections to criteria
    criteria.setProjection(projections);
 
    return voCriteria;    
  }
}

public List buildViewObjects(ViewObjectCriteria voCriteria, 
  ViewObjectMetaData voMetaData){
 
  ScrollableResults result = null;
  try{
    Criteria criteria = voCriteria.getCriteria();
    Map<String, Integer> propertyColumnMappings = 
      voCriteria.getPropertyColumnMappings();
    // some cache method or scroll lock method here, if needed
    result = criteria.scroll(ScrollMode.FORWARD_ONLY);
    Object [] rowdata;
    Object resultObject;
    final ArrayList viewObjects = new ArrayList();
    while (result.next()){
      rowdata = result.get();
      resultObject = voMetaData.getViewObjectFactory().
        createNewViewObject();
      for (final String property:
        propertyColumnMapping.keySet()){
        try {
          // also possible via reflection
          PropertyUtils.setProperty(resultObject, 
            property, rowdata[propertyColumnMappings.get(property)]);
        }
        catch (Exception e) {
          if (LOG.isErrorEnabled()){
            LOG.error("While setting property \""+
              property+"\" from column \""+
              propertyColumnMapping.get(property)+"\"", e);
          }
          resultObject = null;
        }
      }
      if (resultObject!=null){
        viewObjects.add(resultObject);
      }
    }
    return viewObjects;
  }
  finally{
    if (result!=null){
      result.close();
    }
  }
}

/*
Usage:
formatDate(new Date(), 'yyyy/MM/dd HH:mm:ss.SSS');
will return current date as something like '2010/01/01 14:41:52.957'.
 
Implemented:
y  	Year 	Year  	1996 (by using yyyy); 96 (by using yy)
M 	Month in year 	Month 	7 or 10 (by using M); 07 or 10 (by using MM)
d 	Day in month 	Number 	7 or 10 (by using d); 07 or 10 (by using dd)
H 	Hour in day (0-23) 	Number 	7 or 10 (by using H); 07 or 10 (by using HH)
k 	Hour in day (1-24) 	Number 	7 or 10 (by using k); 07 or 10 (by using kk)
m 	Minute in hour 	Number 	7 or 10 (by using m); 07 or 10 (by using mm)
s 	Second in minute 	Number 	7 or 10 (by using s); 07 or 10 (by using ss)
S 	Millisecond 	Number 	 7 or 10 or 100 (by using S); 07 or 10 or 100 (by using SS); 007 or 010 or 100 (by using SSS);
 
Not implemented:
M 	Month in year 	Month 	July; Jul; textual values (by using MMM or MMMM)
G  	Era designator 	Text  	AD
w 	Week in year 	Number 	27
W 	Week in month 	Number 	2
D 	Day in year 	Number 	189
F 	Day of week in month 	Number 	2
E 	Day in week 	Text 	Tuesday; Tue
a 	Am/pm marker 	Text 	PM
K 	Hour in am/pm (0-11) 	Number 	0
h 	Hour in am/pm (1-12) 	Number 	12
 * */
function formatDate(date, format){
	var dayInMonth = date.getDate();
	var fullDayInMonth = dayInMonth+'';
	if (fullDayInMonth.length<2){
		fullDayInMonth = "0"+fullDayInMonth;
	}
	var month = date.getMonth()+1;
	var fullMonth = month+'';
	if (fullMonth.length<2){
		fullMonth = "0"+fullMonth;
	}
	var fullYear = date.getFullYear()+'';
	var year = fullYear.substring(2);
	var hour = date.getHours();
	var fullHour = hour+'';
	if (fullHour.length<2){
		fullHour = "0"+fullHour;
	}
	var khour = hour+1;
	var fullKhour = khour+'';
	if (fullKhour.length<2){
		fullKhour = fullKhour+'';
	}
 
	var minutes = date.getMinutes();
	var fullMinutes = minutes+'';
	if (fullMinutes.length<2){
		fullMinutes = "0"+fullMinutes;
	}
	var seconds = date.getSeconds();
	var fullSeconds = seconds+'';
	if (fullSeconds.length<2){
		fullSeconds = "0"+seconds;
	}
	var millis = date.getMilliseconds();
	var fullMillis1 = millis+'';
	if (fullMillis1.length<2){
		fullMillis1 = '0'+fullMillis1;
	}
	var fullMillis2 = fullMillis1;
	if (fullMillis2.length<3){
		fullMillis2 = '0'+fullMillis2;
	}
 
	var result = format;
	result = result.replace(/MM/g, fullMonth);
	result = result.replace(/M/g, month);
	result = result.replace(/yyyy/g, fullYear);
	result = result.replace(/yy/g, year);
	result = result.replace(/dd/g, fullDayInMonth);
	result = result.replace(/d/g, dayInMonth);
	result = result.replace(/HH/g, fullHour);
	result = result.replace(/H/g, hour);
	result = result.replace(/kk/g, fullKhour);
	result = result.replace(/k/g, khour);
	result = result.replace(/mm/g, fullMinutes);
	result = result.replace(/m/g, minutes);
	result = result.replace(/ss/g, fullSeconds);
	result = result.replace(/s/g, seconds);
	result = result.replace(/SSS/g, fullMillis2);
	result = result.replace(/SS/g, fullMillis1);
	result = result.replace(/S/g, millis);
 
	return result;
}

User user = createUser();
final RememberMeAuthenticationToken auth = new RememberMeAuthenticationToken(webKey, userAccount.getUser(), userAccount.getUser().getAuthorities()); 
auth.setAuthenticated(true); 
SecurityContextHolder.getContext().setAuthentication(auth);

SecurityContextHolder.getContext().setAuthentication(null);