Setup multiple data sources in Grails 2.0

Hi there,

lately I was trying to use multiple data sources with a Grails application. It took me some time to figure out how to do that, therefore I thought it would be something worth sharing. The approach described here will only work for applications written in Grails 2.0 and above since the usage of multiple data sources is a feature which was added into Grails starting with version 2.0.

So here is how you do it. Unsurprisingly you can add your additional data sources within your DataSources.groovy configuration file. You simply add them to the appropriate subsection (development, test, production etc.) within the environments section of your configuration file. That should look some like this:

environments {
    development {
        dataSource {
        //This is your DEFAULT data source
	//Add the configuration parameters for your DEFAULT data source here.

	dataSource_monsters {
	//This is thefirst of your additional data sources, put the configuration
        //parameters  corresponding to the first data source here.

	dataSource_aliens {
	//This is the second of your additional data sources, put the configuration
        //parameters  corresponding to the second data source here.
    test {
	//You can specify other data sources in your test environment as usual.
        dataSource {

	dataSource_monsters {

	dataSource_aliens {

    production {
	//You can specify other data sources in your production environment as usual.
        dataSource {

	dataSource_monsters {

	dataSource_aliens {


As you may have noticed, there is a convention on how to specify additional data sources. The convention is to name the section “datasource_[your choosen name]”. So in the example file there are two different data sources, “datasource_monsters” and “datasource_aliens”. The name you choose after the the underscore is totally up to you. Another thing to notice is that you specify your default data source for a specific environment by using the “dataSource” clause without the additional underscore part.

So for each environment – development, test and production we have defined three different data sources. One default data source, and two additional data sources (‘monsters’ and ‘aliens’).

But how do you decide which data source a specific class should use?

The answer is by defining a mapping section within your class. Let’s see how that looks with some domain classes:

class Lair{


class Monster{
    static mapping = {
        datasource 'monsters'

class Alien{
    static mapping = {
        datasource 'aliens'

If a class does not specify a mapping section it will use the default data source defined in your section. So the Lair class would use the default data source for persisting itself. The other two classes (‘Monster’ and ‘Alien’) each define a mapping section with a data source that they would like to use. So the Monster class would be mapped to a monsters table in the ‘monsters’ data source and the Aliens class would be mapped to an aliens table in the ‘aliens’ data source.

I hope you enjoyed the read an everything worked for you. Drop me a comment if you experience any issues or if you think I should add some information to this article.


Python: Getting umask without change

Hi, I recently found myself in the need of getting the umask of a process. After a few searches there seems to be no other way of getting the desired umask then using the umask() system call located within the python os module. The following code seems to be the universally accepted solution to this particular problem:

def getUMask():
    current_umask = os.umask(0)

    return current_umask 

So the solution is to make a first call to umask() and get a hold of the current umask (Line 2). The argument you pass to the umask() call during the first invocation doesn’t matter since you are going to change it back to its original value. After that you make a second call to umask() (Line 3) with the umask you acquired during the first call (Line 2). So this is the point where you change the umask back to its original value. The call to umask is not atomic though, so you have to take this fact into account if you are using multiple threads, this could lead to race conditions.

Even though this is certainly not the holy grail of programming I thought I share this piece of code anyway…

If this post was useful to you, don’t forget to share it with the world…till next time…

Howto Install Sun’s Java 6 on Debain

This article is a short Tutorial on how to install Java 6 on a Machine running Debian (Lenny) OS. I will try to keep the Installation process as simple as possible so let’s get started…

Step 1: Add “non-free” parameter

If you haven’t already done so, you have to add the “non-free” parameter to your apt “sources.list”. So open up your sources.list normallly located in /etc/apt/sources.list like so

nano /etc/apt/sources.list

…if you did not modify your “sources.list” up to now it might look something like this…

# deb cdrom:[Debian GNU/Linux 5.0.4 _Lenny_ - Official i386 NETINST Binary-1 20100201-16:45]/ lenny main
# deb cdrom:[Debian GNU/Linux 5.0.4 _Lenny_ - Official i386 NETINST Binary-1 20100201-16:45]/ lenny main

deb lenny main
deb-src lenny main

deb lenny/updates main
deb-src lenny/updates main

…now you have to add the “non-free” parameter to the end of the deb and deb-src lines. After that your “sources.list” should look like:

# deb cdrom:[Debian GNU/Linux 5.0.4 _Lenny_ - Official i386 NETINST Binary-1 20100201-16:45]/ lenny main
# deb cdrom:[Debian GNU/Linux 5.0.4 _Lenny_ - Official i386 NETINST Binary-1 20100201-16:45]/ lenny main

deb lenny main non-free
deb-src lenny main  non-free

deb lenny/updates main
deb-src lenny/updates main

…save your modified “sources.list” file.

Step 2: Install Java

Before you can install the sun-java packages you have to update your package repository…

apt-get update

now you can install the java packages…

apt-get install sun-java6-jdk sun-java6-jre

Step 3: Make Sun Java the preferred Java runtime

You can make the installed Java distribution the preferred Java runtime by using the “update-java-alternatives” command like so:

update-java-alternatives -s java-6-sun

This will make the newly installed Java runtime the standard Java runtime for your system.

Step 4: Set JAVA_HOME

Before we do anything else we set the JAVA_HOME environment variable so that other applications can find your java distribution. To to that you have to edit your “.bashrc” file located in your home directory. So open up your “.bashrc” file:

nano ~/.bashrc

…and add the following line to the end of your file

export JAVA_HOME=/usr/lib/jvm/java-6-sun

at this point I’m assuming that your distribution installed java in /usr/lib/jvm/java-6-sun which is the default behaviour. If that is not the case you have to replace the path with your installation path. Now you can try to log out and log in again to check if the JAVA_HOME is correctly set. After logging in again you just type…


if everything went right you should see the path that you set in your “.bashrc” earlier.


The approach discussed above will set the JAVA_HOME environment variable for your user only! So other users on the system cannot make use of your JAVA_HOME variable. To set the JAVA_HOME variable on a systemwide scale you have to edit the /etc/profile file. Setting the JAVA_HOME variable in the /etc/profile file will make it available to every user of the current system. The process of setting the JAVA_HOME variable is the same as described above, except that you use the /etc/profile file instead of the ~/.bashrc file in your users home directory.

Step 5: Check your Java Installation

If everything went right the command

java -version

…should yield the following output:

java version "1.6.0_20"
Java(TM) SE Runtime Environment (build 1.6.0_20-b02)
Java HotSpot(TM) Client VM (build 16.3-b01, mixed mode, sharing)

… so that’s that…hope it helps…cya

Variable LIMIT statement in MySQL


Is there a way to use variables in conjunction with the SQL LIMIT clause?
(e.g. SELECT * FROM movies LIMIT @foo)?


No not directly…at the time of writing this is still a big issue of MySQL Development. Nonetheless there exist various workarounds. I will discuss a few of them in this article.


The main issue is that you want to construct an SQL query that hands a variable as a parameter to the LIMIT clause. That could look something like this:

SET @foo = 5;
SELECT * FROM movies LIMIT @foo;

This immediately results in the following error message.

Error Code: 1064
You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ‘@’ at line 1)

So to all appearances SELECT queries using the LIMIT clause do not work when a SQL variable (e.g. @foo) is used as a parameter in the LIMIT clause.


In the following I present a few workarounds to resolve this little handicap:

1. Make use of Prepared Statements

SET @foo=5;

You could also concatenate your entire SELECT Statement and convert this to a Prepared Statement. In the following example the parameter “sParameter” is the used variable.

SET @myQuery = CONCAT('SELECT * FROM test ORDER BY ', sParameter);
PREPARE stmt FROM @myQuery;

If you use queries like these a lot, it might make sense to wrap the whole thing up in a stored procedure:


CREATE PROCEDURE `get_movie_range`(
SET @TO = _TO;

With the stored procedure in place you can make calls like:

CALL get_movie_range(7,(SELECT COUNT(*) FROM movies));

2. Make use of variables and the BETWEEN Statement

This statement selects all rows beginning with 12 and ending at 20.

set @i=0;
select * from movies where (@i:=@i+1) between 12 and 20;

So that’s it…hope it helps…:)


Question: Is there a way to emulate the behavior of SELECT TOP [Integer] … in MySQL?

Answer: Yes there is…you have to make use of the LIMIT clause.


The query…

SELECT TOP 5 * FROM movies;


titleID title url
0012349 The Kid
0015864 The Gold Rush
0017136 Metropolis
0017925 The General
0018455 Sunrise: A Song of Two Humans

…will look like this in MySQL…



titleID title url
0012349 The Kid
0015864 The Gold Rush
0017136 Metropolis
0017925 The General
0018455 Sunrise: A Song of Two Humans

You can find more information about selections with LIMIT here.

Hope this helps…

Adding XML namespaces via Dom4j

Hello everyone,

today’s article is about adding namespaces to your XML document using Java and Dom4j, so let’s get started…

First of all we need an instance of the Dom4j factory, here is how we do it…

//Get an instance of the dom4j document factory
DocumentFactory factory = DocumentFactory.getInstance();

…next we create an element which is going to serve as the root element as well as a new xml document using the factory object.

//use the factory to create a root element
Element rootElement = factory.createElement("RootElement");
//use the factory to create a new document with the previously created root element
Document doc = factory.createDocument(rootElement);

Now we are ready to create our namespaces.

//create some dom4j namespaces that we like to add to our new document
Namespace namespace1 = new Namespace("xsd","");
Namespace namespace2 = new Namespace("rdfs","");
Namespace namespace3 = new Namespace("rdf","");
Namespace namespace4 = new Namespace("owl","");
Namespace namespace5 = new Namespace("some","http://some/other/namespace:-)#");

The last step we have to take is to add all the namespaces to the XML document.

//add the created namespaces to the document</span>

Finished! To check if everything worked as intended we’re going to write the document to an XML file…

  //write the created document to an arbitrary file
  FileOutputStream fos = new FileOutputStream( "files/output.xml" );

  OutputFormat outformat = OutputFormat.createPrettyPrint();
  XMLWriter writer = new XMLWriter(fos, outformat);

}catch(FileNotFoundException e) {
  // catch exception
}catch(UnsupportedEncodingException e) {
  // catch exception
}catch (IOException e) {
  // catch exception

…if everything went fine we should end up with an XML file that looks like this:

<xml version="1.0" encoding="UTF-8">

<RootElement xmlns:xsd=""


So this is how you add namespaces to your xml document via Dom4j…have a nice day and stay tuned for more face-melting articles :)…