Grape issues

I've also noticed different behaviour using the @Grab annotation.

The following code

import groovy.sql.Sql
import java.sql.Time

@Grab(group='oracle', module='ojdbc14', version='10.1.0.4.0' )

def db = Sql.newInstance("jdbc:oracle:thin:@dbUrl:1525:BEAM", "xxx", "xxxx",
"oracle.jdbc.driver.OracleDriver")

returns Caught: java.lang.ClassNotFoundException: oracle.jdbc.driver.OracleDriver
at t2.run(t2.groovy:6)

There seems also to be different behaviour depending on whether the groovy script contain a class or not.
The following code (semantically identical to above), results in a different error.

 
import groovy.sql.Sql
import java.sql.Time

@Grab(group='oracle', module='ojdbc14', version='10.1.0.4.0' )
public class t2{
	public static void main(String[] args){
		def db = Sql.newInstance("jdbc:oracle:thin:@flagtest.intmet.ie:1525:BEAM", "user", "password",
		"oracle.jdbc.driver.OracleDriver")
	}
}

Caught: java.sql.SQLException: No suitable driver
at t2.main(t2.groovy:7)

I ran into this with mysql drivers. Although it totally defeats the purpose of grape, I can get my code working by adding the jar to my classloader using something like:

 
public void addFileToClassPath(String fileName) {
    addFileToClassPath(new File(fileName))
}

public void addFileToClassPath(File file) {
    println("Classpath <-- ${file.path}");

    def loader = this.class.classLoader
    (loader.rootLoader ?: loader.systemClassLoader).addURL(file.toURL())
}

and sending in a valid driver file. So maybe grape should be doing this in some fashion and it isn't? Hopefully this can provide a hint to some kind soul so they can fix this...or help somebody get their script running.

Not really an update but just a note that we don't currently expect Keith's first comment to currently work, i.e. this one:
http://jira.codehaus.org/browse/GROOVY-3583?focusedCommentId=180620&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#action_180620

Grab annotations must currently annotate a class or method.
In the next release this will also include imports and package definitions.
Some time in the future, also variable expressions like Keith's first comment.

The second thing you are noticing is possibly related to different classloaders coming into play. I'll need to play a bit more to confirm.

We are experiencing this problem as well with the MySQL driver:

Caught: java.sql.SQLException: No suitable driver found for jdbc:mysql://localhost:3306/testdb

Things work when the driver is in .groovy/lib, but not when missing from .groovy/lib and referenced solely from @Grab as shown below:

@Grab(group='mysql', module='mysql-connector-java', version='5.1.6')

dirty workaround,
based on idea http://jira.codehaus.org/browse/GROOVY-3583?focusedCommentId=184570&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#action_184570
just works...

import groovy.sql.Sql;

@Grab(group='mysql', module='mysql-connector-java', version='5.1.6')
 
def loadDriverJar(toLoad)
{	
	//extract path to .jar file
	def res='/'+toLoad.replaceAll('\\.','/')+'.class';	
	def c=this.class.classLoader.loadClass(toLoad);
	def file=''+ c.getResource(res).file;	
	file=file.substring(0,file.size()-(res.size()+1));

	// add .jar to systemClassLoader 
	ClassLoader.systemClassLoader.addURL(new URL(file));	
}

def createSql()
{
	def driverClass="com.mysql.jdbc.Driver";
	loadDriverJar(driverClass);	
	def sql=Sql.newInstance("jdbc:mysql://localhost/test","root","",driverClass);
	return sql;
}

def sql=createSql();
println sql.firstRow("SELECT now( )");

A better solution is this:
{{{
import groovy.sql.Sql;
import groovy.grape.Grape;

Grape.grab(group:'mysql', module:'mysql-connector-java', version:'5.1.6' )

this.class.classLoader.getURLs().each

}}

This way all dependencies of the driver are also referenced.

Another solution:

you can also use the classLoader property for Grape:

Grape.grab(group:'mysql', module:'mysql-connector-java', version:'5.1.6', classLoader: this.class.classLoader.rootLoader)

This will add the JAR to the Groovy Rootloader and Sql.newInstance can find the driver class.

however the map version does not seem work (extrapolating from mrhaki's example):

Grape.grab([group:'com.thoughtworks.xstream', module:'xstream', version:"1.3.1", classLoader:ClassLoader.systemClassLoader],
[group:'xpp3', module:'xpp3', version:'1.1.2a',classLoader:ClassLoader.systemClassLoader])

but perhaps I have the wrong syntax?

The map version can be used like this:

Grape.grab(
  /* arguments Map */
  [classLoader: ClassLoader.systemClassLoader], 
  /* dependencies Map*/
  [group:'com.thoughtworks.xstream', module:'xstream', version:"1.3.1"],  
  [group:'xpp3', module:'xpp3', version:'1.1.2a'] 
)

Please see GROOVY-3730 for one potential solution.

Note that with Groovy 1.6, a perfectly reasonable solution is to switch from using the newInstance()/DriverManager way of creating a groovy.sql.Sql instance, and instead use the constructor taking a DataSource.

For example, for Oracle:

import oracle.jdbc.pool.OracleDataSource

@Grab(group='com.oracle', module='ojdbc14', version='10.2.0.3.0') // assuming you have this in your grape repo
void foo() {}

url = "..."

def db = new Sql(new OracleDataSource(URL: url))

This works well for me. You do have to learn what the appropriate DataSource class is for your driver, and what it's properties are.

John Hurst

The current thinking is that @GrabConfig won't be back-ported to 1.6.5. Is having the solution for 1.7 good enough given that we have the Grape.grab() with classloaders workaround?

I think @GrabConfig doesn't have to be back-ported to 1.6.5. We have workarounds to get around the issue.

So, everyone happy if we close this issue?

Yes, Fine with me, the workarounds should suffice for 1.6

Fixed in 1.7 thanks to GROOVY-3730. Workarounds exist for Groovy 1.6.

Guys, I'm using Groovy Version: 1.8.0-rc-1 JVM: 1.6.0_23 and the problem with loading JDBC drivers still persists. Should I reopen this issue?

Here's the example:

@Grab('mysql:mysql-connector-java:5.1.15')
import groovy.sql.Sql

def sql = Sql.newInstance("jdbc:mysql://localhost:3306/example", "root", "", "com.mysql.jdbc.Driver")

It produces the following exception:

Caught: java.sql.SQLException: No suitable driver found for jdbc:mysql://localhost:3306/example
at test.run(test.groovy:4)

Which is identical to the problem reported in this issue.

The solution

this.class.classLoader.getURLs().each{ 
  ClassLoader.systemClassLoader.addURL(it); 
}

still works.

This seemed to work for me:

@Grab('mysql:mysql-connector-java:5.1.15')
@GrabConfig(systemClassLoader=true)
...

So I don't think reopening is necessary.

I have a script that requires a JDBC driver and has a Xerces dependency. With the root classloader the JDBC driver loads, without the xerces dependency could be loaded. I want to reopen this issue.

One solution could be to add the systemClassLoader property to the @Grab line to decide which classloader to use for this line and all dependencies of this line.

Caught: java.lang.LinkageError: loader constraint violation: when resolving overridden method "org.apache.xerces.jaxp.SAXParserImpl.getParser()Lorg/xml/sax/Parser;" the class loader (instance of org/codehaus/groovy/tools/RootLoader) of the current class, org/apache/xerces/jaxp/SAXParserImpl, and its superclass loader (instance of <
bootloader>), have different Class objects for the type org/xml/sax/Parser used in the signature
at gutil.TestEnvironment.read(TestEnvironment.groovy:60)
at gutil.TestEnvironment.<init>(TestEnvironment.groovy:22)
at TcpIpTest1.run(TcpIpTest1.groovy:20)