1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
package org.openslx.satellitedaemon.db;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.List;
import java.util.Properties;
import org.apache.log4j.Logger;
import org.openslx.satellitedaemon.util.Util;
import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
import fi.evident.dalesbred.Database;
/**
* Class for talking to the DB via the dalesbred jdbc wrapper. Package private,
* so only the Db* classes can actually communicate with the database.
*
*/
class MySQL
{
private static final Logger log = Logger.getLogger( MySQL.class );
private static Database db = null;
/**
* Static initializer for setting up the database connection.
* This gets called implicitly as soon as the class loader loads
* the class. In most cases that happens when the class is being
* accessed for the first time during run time.
*/
static
{
// Load connection info from class (TODO: Make pretty)
Properties properties = new Properties();
String propertiesPath = "config/mysql.properties";
try {
final BufferedInputStream stream = new BufferedInputStream( new FileInputStream( propertiesPath ) );
properties.load( stream );
stream.close();
} catch ( FileNotFoundException e ) {
log.fatal( propertiesPath + " not found!" );
System.exit( 1 );
} catch ( IOException e ) {
log.fatal( "Error reading from " + propertiesPath + ": " + e.getMessage() );
System.exit( 1 );
} catch ( Exception e ) {
log.fatal( "Generic error loading mysql properties file." );
e.printStackTrace();
System.exit( 1 );
}
final String host = properties.getProperty( "host" );
final String dbname = properties.getProperty( "db" );
final String user = properties.getProperty( "user" );
final String password = properties.getProperty( "password" );
Util.notNullFatal( host, "host not set in mysql properties" );
Util.notNullFatal( dbname, "db not set in mysql properties" );
Util.notNullFatal( user, "user not set in mysql properties" );
Util.notNullFatal( password, "password not set in mysql properties" );
// Setup db connection
try {
MysqlDataSource ds = new MysqlDataSource();
ds.setServerName( host );
ds.setDatabaseName( dbname );
ds.setUser( user );
ds.setPassword( password );
db = Database.forDataSource( ds );
} catch ( Exception e ) {
log.fatal( "Error initializing mysql data source!" );
e.printStackTrace();
System.exit( 1 );
}
}
/**
* Get a list of objects of the given class from the database.
* The class needs a matching constructor for the query you pass in, i.e. number of
* arguments has to be equal to number of columns returned by query.
*
* @param clazz The class to instanciate for the result(s)
* @param sql The sql query to run
* @param args Any number of arguments to the query (using the '?' placeholder)
* @return A list containing the rows returned by the query, represented by the given class
*/
protected static <T> List<T> findAll( final Class<T> clazz, final String sql, final Object... args )
{
return db.findAll( clazz, sql, args );
}
/**
* Run a query on the database that will return at most one result.
* If the query returns a row, it will be used to instanciate the given class. If
* it doesn't return a row, null will be returned.
*
* @param clazz The class to instanciate for the result (if any)
* @param sql The sql query to run
* @param args Any number of arguments to the query (using the '?' placeholder)
* @return Instance of clazz or null
*/
protected static <T> T findUniqueOrNull( final Class<T> clazz, final String sql, final Object... args )
{
return db.findUniqueOrNull( clazz, sql, args );
}
/**
* Run an update on the database, return number of rows affected.
*
* @param sql The update/insert query to run
* @param args Any number of arguments to the query (using the '?' placeholder)
* @return Number of rows affected by query
*/
protected static int update( String sql, Object... args )
{
return db.update( sql, args );
}
}
|
