--- src/net/lemnik/eodsql/QuickQueryUtil.java.orig	2010-07-14 21:51:48.000000000 +0200
+++ src/net/lemnik/eodsql/QuickQueryUtil.java	2010-07-14 21:07:31.000000000 +0200
@@ -90,6 +90,34 @@
 
     };
 
+    private static final Update DEFAULT_UPDATE_PARAMETERS = new Update() {
+
+	public boolean batchUpdate() {
+	    return false;
+	}
+
+	public GeneratedKeys keys() {
+	    return GeneratedKeys.NO_KEYS_RETURNED;
+	}
+
+	@SuppressWarnings("unchecked")
+	public Class<? extends TypeMapper>[] parameterBindings() {
+	    return new Class[0];
+	}
+
+	public String sql() {
+	    return "";
+	}
+
+	public String value() {
+	    return "";
+	}
+
+	public Class<? extends Annotation> annotationType() {
+	    return Update.class;
+	}
+    };
+	
     private QuickQueryUtil() {
     }
 
@@ -126,7 +154,7 @@
     private static void fillStatementParameters(
             final Query eodquery,
             final PreparedStatement statement,
-            final Context<Select> context)
+            final Context<?> context)
             throws SQLException {
 
         final Map<Class, TypeMapper> mappers = QueryTool.getTypeMap();
@@ -190,6 +218,33 @@
         return output;
     }
 
+    public static int update(
+            final Connection connection,
+            final boolean closeConnection,
+            final String query,
+            final Object... parameters)
+            throws SQLException, ParseException {
+
+        final Context<Update> context = new Context<Update>(
+                DEFAULT_UPDATE_PARAMETERS,
+                parameters);
+
+        try {
+            final Class<?>[] parameterTypes = getParameterTypes(parameters);
+
+            context.setResource(new ConnectionResource(connection, closeConnection));
+            final Query eodquery = Query.getQuery(query, parameterTypes);
+            final PreparedStatement statement = connection.prepareStatement(
+                    eodquery.toString());
+
+            fillStatementParameters(eodquery, statement, context);
+            context.setResource(new StatementResource(statement));
+            return statement.executeUpdate();
+        } finally {
+            context.close();
+        }
+    }
+
     private static class ConnectionResource implements Resource<Connection> {
         private Connection connection;
 
--- src/net/lemnik/eodsql/QueryTool.java.orig	2010-07-14 21:51:13.000000000 +0200
+++ src/net/lemnik/eodsql/QueryTool.java	2010-07-14 21:45:10.000000000 +0200
@@ -597,6 +597,159 @@
     }
 
     /**
+     *<p>
+     * Sometimes you need to perform a less structured "UPDATE", "INSERT" or "DELETE" than a Query interface allows. Although this method
+     * is significantly slower than building a Query interface, it provides needed functionality that a Query
+     * interface cannot.
+     *</p><p>
+     * This method does no caching of any sort, and the query will be re-parsed each time it is executed. It however
+     * provides the same primitive-type abstraction that a Query interface provides you with. The query string is
+     * parsed in the same way as a query string passed to an {@link Select @Select} annotation.
+     *</p>
+     *
+     * @param connection the <code>Connection</code> to use to perform the query
+     * @param query the SQL query to be executed
+     * @param parameters the parameters to be used in
+     *      conjunction with the query string.
+     * @return either (1) the row count for <code>INSERT</code>, <code>UPDATE</code>,
+     *         or <code>DELETE</code> statements
+     *         or (2) 0 for SQL statements that return nothing
+     * @throws InvalidDataTypeException if the given {@code type} cannot
+     *      be bound as a row data-type
+     * @throws InvalidQueryException if the query string given cannot
+     *      be parsed, or doesn't match the given parameters
+     * @throws IllegalArgumentException is the <code>DataSource</code>
+     *      provided is <code>null</code>
+     */
+    public static int update(
+            final Connection connection,
+            final String query,
+            final Object... parameters)
+            throws InvalidDataTypeException,
+            InvalidQueryException {
+
+        if(connection == null) {
+            throw new IllegalArgumentException(
+                    "A Connection must be specified for update");
+        }
+
+        if(query == null || query.length() == 0) {
+            throw new IllegalArgumentException(
+                    "You must specify a query for update");
+        }
+
+        try {
+            return QuickQueryUtil.update(
+                    connection,
+                    false,
+                    query,
+                    parameters);
+        } catch(SQLException sqle) {
+            throw new InvalidQueryException(
+                    "Couldn't execute query: '" + query + "'", sqle);
+        } catch(ParseException pe) {
+            throw new InvalidQueryException(
+                    "Cannot parser EoD SQL query: '" + query + "'", pe);
+        }
+    }
+
+    /**
+     *<p>
+     * Sometimes you need to perform a less structured "UPDATE", "INSERT" or "DELETE" than a Query interface allows. Although this method
+     * is significantly slower than building a Query interface, it provides needed functionality that a Query
+     * interface cannot.
+     *</p><p>
+     * This method does no caching of any sort, and the query will be re-parsed each time it is executed. It however
+     * provides the same primitive-type abstraction that a Query interface provides you with. The query string is
+     * parsed in the same way as a query string passed to an {@link Select @Select} annotation.
+     *</p>
+     *
+     * @param dataSource the <code>DataSource</code> to use get the connection from to perform the query
+     * @param query the SQL query to be executed
+     * @param parameters the parameters to be used in
+     *      conjunction with the query string.
+     * @return either (1) the row count for <code>INSERT</code>, <code>UPDATE</code>,
+     *         or <code>DELETE</code> statements
+     *         or (2) 0 for SQL statements that return nothing
+     * @throws InvalidDataTypeException if the given {@code type} cannot
+     *      be bound as a row data-type
+     * @throws InvalidQueryException if the query string given cannot
+     *      be parsed, or doesn't match the given parameters
+     * @throws IllegalArgumentException is the <code>DataSource</code>
+     *      provided is <code>null</code>
+     */
+    public static int update(
+            final DataSource dataSource,
+            final String query,
+            final Object... parameters)
+            throws InvalidDataTypeException,
+            InvalidQueryException {
+
+        if(dataSource == null) {
+            throw new IllegalArgumentException(
+                    "A DataSource must be specified for update");
+        }
+
+        if(query == null || query.length() == 0) {
+            throw new IllegalArgumentException(
+                    "You must specify a query for update");
+        }
+
+        try {
+            return QuickQueryUtil.update(
+                    dataSource.getConnection(),
+                    false,
+                    query,
+                    parameters);
+        } catch(SQLException sqle) {
+            throw new InvalidQueryException(
+                    "Couldn't execute query: '" + query + "'", sqle);
+        } catch(ParseException pe) {
+            throw new InvalidQueryException(
+                    "Cannot parser EoD SQL query: '" + query + "'", pe);
+        }
+    }
+
+    /**
+     *<p>
+     * Sometimes you need to perform a less structured "UPDATE", "INSERT" or "DELETE" than a Query interface allows. Although this method
+     * is significantly slower than building a Query interface, it provides needed functionality that a Query
+     * interface cannot.
+     *</p><p>
+     * This method does no caching of any sort, and the query will be re-parsed each time it is executed. It however
+     * provides the same primitive-type abstraction that a Query interface provides you with. The query string is
+     * parsed in the same way as a query string passed to an {@link Select @Select} annotation.
+     *</p><p>
+     * This method is the same as calling <code>update(getDefaultDataSource(), query, parameters)</code>.
+     *</p>
+     *
+     * @param query the SQL query to be executed
+     * @param parameters the parameters to be used in
+     *      conjunction with the query string.
+     * @return either (1) the row count for <code>INSERT</code>, <code>UPDATE</code>,
+     *         or <code>DELETE</code> statements
+     *         or (2) 0 for SQL statements that return nothing
+     * @throws InvalidDataTypeException if the given {@code type} cannot
+     *      be bound as a row data-type
+     * @throws InvalidQueryException if the query string given cannot
+     *      be parsed, or doesn't match the given parameters
+     * @throws IllegalArgumentException is the <code>DataSource</code>
+     *      provided is <code>null</code>
+     */
+    public static int update(
+            final String query,
+            final Object... parameters)
+            throws InvalidDataTypeException,
+            InvalidQueryException {
+        if(defaultDataSource != null) {
+            return update(defaultDataSource, query, parameters);
+        } else {
+            throw new IllegalStateException(
+                    "the default DataSource has not been set.");
+        }
+    }
+
+    /**
      * <p>
      * Returns the <code>Map</code> that specifies how Java types should
      * be mapped to SQL types and back again. This <code>Map</code> may be