| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.cocoon.acting.modular; |
| |
| import java.io.IOException; |
| import java.sql.Connection; |
| import java.sql.PreparedStatement; |
| import java.sql.SQLException; |
| import java.util.Map; |
| |
| import org.apache.avalon.excalibur.datasource.DataSourceComponent; |
| import org.apache.avalon.framework.activity.Disposable; |
| import org.apache.avalon.framework.configuration.Configuration; |
| import org.apache.avalon.framework.configuration.ConfigurationException; |
| import org.apache.avalon.framework.parameters.Parameters; |
| import org.apache.avalon.framework.service.ServiceException; |
| import org.apache.avalon.framework.service.ServiceManager; |
| import org.apache.avalon.framework.service.ServiceSelector; |
| import org.apache.avalon.framework.thread.ThreadSafe; |
| |
| import org.apache.cocoon.Constants; |
| import org.apache.cocoon.ProcessingException; |
| import org.apache.cocoon.acting.AbstractComplementaryConfigurableAction; |
| import org.apache.cocoon.components.modules.database.AutoIncrementModule; |
| import org.apache.cocoon.components.modules.input.InputModule; |
| import org.apache.cocoon.components.modules.output.OutputModule; |
| import org.apache.cocoon.environment.Redirector; |
| import org.apache.cocoon.environment.SourceResolver; |
| import org.apache.cocoon.util.HashMap; |
| import org.apache.cocoon.util.JDBCTypeConversions; |
| import org.apache.commons.lang.BooleanUtils; |
| |
| /** |
| * Abstract action for common function needed by database actions. |
| * The difference to the other Database*Actions is, that the actions |
| * in this package use additional components ("modules") for reading |
| * and writing parameters. In addition the descriptor format has |
| * changed to accomodate the new features. |
| * |
| * <p>This action is heavily based upon the original DatabaseAddActions.</p> |
| * |
| * <p>Modes have to be configured in cocoon.xconf. Mode names from |
| * descriptor.xml file are looked up in the component service. Default |
| * mode names can only be set during action setup. </p> |
| * |
| * <p>The number of affected rows is returned to the sitemap with the |
| * "row-count" parameter if at least one row was affected.</p> |
| * |
| * <p>All known column types can be found in |
| * {@link org.apache.cocoon.util.JDBCTypeConversions JDBCTypeConversions}.</p> |
| * |
| * <table> |
| * <tr><td colspan="2">Configuration options (setup):</td></tr> |
| * <tr><td>input </td><td>default mode name for reading values (request-param)</td></tr> |
| * <tr><td>autoincrement </td><td>default mode name for obtaining values from autoincrement columns (auto)</td></tr> |
| * <tr><td>append-row </td><td>append row number in square brackets to column name for output (yes)</td></tr> |
| * <tr><td>append-table-name</td><td>add table name to column name for both in- and output (yes)</td></tr> |
| * <tr><td>first-row </td><td>row index of first row (0)</td></tr> |
| * <tr><td>path-separator </td><td>string to separate table name from column name (.)</td></tr> |
| * </table> |
| * |
| * <table> |
| * <tr><td colspan="2">Configuration options (setup and per invocation):</td></tr> |
| * <tr><td>throw-exception </td><td>throw an exception when an error occurs (default: false)</td></tr> |
| * <tr><td>descriptor </td><td>file containing database description</td></tr> |
| * <tr><td>table-set </td><td>table-set name to work with </td></tr> |
| * <tr><td>output </td><td>mode name for writing values (request-attr)</td></tr> |
| * <tr><td>reloadable </td><td>dynamically reload descriptor file if change is detected</td></tr> |
| * <tr><td>use-transactions </td><td>defaults to yes</td></tr> |
| * <tr><td>connection </td><td>configured datasource connection to use (overrides value from descriptor file)</td></tr> |
| * <tr><td>fail-on-empty </td><td>(boolean) fail is statement affected zero rows (true)</td></tr> |
| * </table> |
| * |
| * @author <a href="mailto:haul@apache.org">Christian Haul</a> |
| * @version $Id$ |
| * @see org.apache.cocoon.components.modules.input |
| * @see org.apache.cocoon.components.modules.output |
| * @see org.apache.cocoon.components.modules.database |
| * @see org.apache.cocoon.util.JDBCTypeConversions |
| */ |
| public abstract class DatabaseAction extends AbstractComplementaryConfigurableAction implements Disposable, ThreadSafe { |
| |
| // ======================================================================== |
| // constants |
| // ======================================================================== |
| |
| static final Integer MODE_AUTOINCR = new Integer(0); |
| static final Integer MODE_OTHERS = new Integer(1); |
| static final Integer MODE_OUTPUT = new Integer(2); |
| |
| static final String ATTRIBUTE_KEY = "org.apache.cocoon.action.modular.DatabaseAction.outputModeName"; |
| |
| // These can be overidden from cocoon.xconf |
| static final String inputHint = "request-param"; // default to request parameters |
| static final String outputHint = "request-attr"; // default to request attributes |
| static final String databaseHint = "manual"; // default to manual auto increments |
| |
| static final String INPUT_MODULE_SELECTOR = InputModule.ROLE + "Selector"; |
| static final String OUTPUT_MODULE_SELECTOR = OutputModule.ROLE + "Selector"; |
| static final String DATABASE_MODULE_SELECTOR = AutoIncrementModule.ROLE + "Selector"; |
| |
| |
| // ======================================================================== |
| // instance vars |
| // ======================================================================== |
| |
| protected ServiceSelector dbselector; |
| protected Map defaultModeNames = new HashMap( 3 ); |
| protected final HashMap cachedQueryData = new HashMap(); |
| protected String pathSeparator = "."; |
| protected int firstRow = 0; |
| protected boolean failOnEmpty = true; |
| |
| // ======================================================================== |
| // inner helper classes |
| // ======================================================================== |
| |
| /** |
| * Structure that takes all processed data for one column. |
| */ |
| protected static class Column { |
| boolean isKey = false; |
| boolean isSet = false; |
| boolean isAutoIncrement = false; |
| String mode = null; |
| Configuration modeConf = null; |
| Configuration columnConf = null; |
| } |
| |
| /** |
| * Structure that takes all processed data for a table depending |
| * on current default modes |
| */ |
| protected static class CacheHelper { |
| /** |
| * Generated query string |
| */ |
| public String queryString = null; |
| /** |
| * if a set is used, column number which is used to determine |
| * the number of rows to insert. |
| */ |
| public int setMaster = -1; |
| public boolean isSet = false; |
| public int noOfKeys = 0; |
| public Column[] columns = null; |
| |
| public CacheHelper( int cols ) { |
| this(0,cols); |
| } |
| |
| public CacheHelper( int keys, int cols ) { |
| noOfKeys = keys; |
| columns = new Column[cols]; |
| for ( int i=0; i<cols; i++ ) { |
| columns[i] = new Column(); |
| } |
| } |
| } |
| |
| /** |
| * Structure that takes up both current mode types for database |
| * operations and table configuration data. Used to access parsed |
| * configuration data. |
| */ |
| protected static class LookUpKey { |
| public Configuration tableConf = null; |
| public Map modeTypes = null; |
| |
| public LookUpKey( Configuration tableConf, Map modeTypes ) { |
| this.tableConf = tableConf; |
| this.modeTypes = modeTypes; |
| } |
| |
| /* (non-Javadoc) |
| * @see java.lang.Object#equals(java.lang.Object) |
| */ |
| public boolean equals(Object obj) { |
| boolean result = false; |
| if (obj != null && obj instanceof LookUpKey) { |
| LookUpKey luk = (LookUpKey) obj; |
| result = true; |
| result = result && (luk.tableConf == null ? |
| this.tableConf == null : luk.tableConf.equals(this.tableConf)); |
| result = result && (luk.modeTypes == null ? |
| this.modeTypes == null : luk.modeTypes.equals(this.modeTypes)); |
| } |
| |
| return result; |
| } |
| |
| /* (non-Javadoc) |
| * @see java.lang.Object#hashCode() |
| */ |
| public int hashCode() { |
| return (this.tableConf != null ? |
| this.tableConf.hashCode() : |
| (this.modeTypes != null ? this.modeTypes.hashCode() : super.hashCode())); |
| } |
| } |
| |
| // set up default modes |
| // <input/> |
| // <output/> |
| // <autoincrement/> |
| // |
| // all other modes need to be declared in cocoon.xconf |
| // no need to declare them per action (anymore!) |
| public void configure(Configuration conf) throws ConfigurationException { |
| super.configure(conf); |
| if (this.settings != null) { |
| this.defaultModeNames.put(MODE_OTHERS, this.settings.get("input", inputHint)); |
| this.defaultModeNames.put(MODE_OUTPUT, this.settings.get("output", outputHint)); |
| this.defaultModeNames.put(MODE_AUTOINCR, this.settings.get("autoincrement", databaseHint)); |
| this.pathSeparator = (String)this.settings.get("path-separator", this.pathSeparator); |
| String tmp = (String)this.settings.get("first-row",null); |
| if (tmp != null) { |
| try { |
| this.firstRow = Integer.parseInt(tmp); |
| } catch (NumberFormatException nfe) { |
| if (getLogger().isWarnEnabled()) |
| getLogger().warn("problem parsing first row option "+tmp+" using default instead."); |
| } |
| } |
| tmp = (String) this.settings.get("fail-on-empty",String.valueOf(this.failOnEmpty)); |
| this.failOnEmpty = BooleanUtils.toBoolean(tmp); |
| } |
| } |
| |
| // ======================================================================== |
| // Avalon methods |
| // ======================================================================== |
| |
| /** |
| * Compose the Actions so that we can select our databases. |
| */ |
| public void service(ServiceManager manager) throws ServiceException { |
| super.service(manager); |
| this.dbselector = (ServiceSelector) manager.lookup(DataSourceComponent.ROLE + "Selector"); |
| } |
| |
| /** |
| * dispose |
| */ |
| public void dispose() { |
| this.manager.release(dbselector); |
| } |
| |
| // ======================================================================== |
| // protected utility methods |
| // ======================================================================== |
| |
| /** |
| * Get the Datasource we need. |
| */ |
| protected DataSourceComponent getDataSource( Configuration conf, Parameters parameters ) |
| throws ServiceException { |
| |
| String sourceName = parameters.getParameter( "connection", (String) settings.get( "connection" ) ); |
| if ( sourceName == null ) { |
| Configuration dsn = conf.getChild("connection"); |
| return (DataSourceComponent) this.dbselector.select(dsn.getValue("")); |
| } else { |
| if (getLogger().isDebugEnabled()) |
| getLogger().debug("Using datasource: "+sourceName); |
| return (DataSourceComponent) this.dbselector.select(sourceName); |
| } |
| } |
| |
| /** |
| * Return whether a type is a Large Object (BLOB/CLOB). |
| */ |
| protected final boolean isLargeObject (String type) { |
| if ("ascii".equals(type)) return true; |
| if ("binary".equals(type)) return true; |
| if ("image".equals(type)) return true; |
| return false; |
| } |
| |
| /** |
| * Store a key/value pair in the output attributes. We prefix the key |
| * with the name of this class to prevent potential name collisions. |
| */ |
| protected void setOutputAttribute(Map objectModel, String outputMode, String key, Object value) { |
| |
| ServiceSelector outputSelector = null; |
| OutputModule output = null; |
| try { |
| outputSelector = (ServiceSelector) this.manager.lookup(OUTPUT_MODULE_SELECTOR); |
| if (outputMode != null && outputSelector != null && outputSelector.isSelectable(outputMode)) { |
| output = (OutputModule) outputSelector.select(outputMode); |
| } |
| if (output != null) { |
| output.setAttribute(null, objectModel, key, value); |
| } else if (getLogger().isWarnEnabled()) { |
| getLogger().warn("Could not select output mode " + outputMode); |
| } |
| } catch (Exception e) { |
| if (getLogger().isWarnEnabled()) { |
| getLogger().warn("Could not select output mode " + outputMode + ":" + e.getMessage()); |
| } |
| } finally { |
| if (outputSelector != null) { |
| if (output != null) |
| outputSelector.release(output); |
| this.manager.release(outputSelector); |
| } |
| } |
| } |
| |
| /** |
| * Inserts a row or a set of rows into the given table based on the |
| * request parameters |
| * |
| * @param table the table's configuration |
| * @param conn the database connection |
| * @param objectModel the objectModel |
| */ |
| protected int processTable( Configuration table, Connection conn, Map objectModel, |
| Map results, Map modeTypes ) |
| throws SQLException, ConfigurationException, Exception { |
| |
| PreparedStatement statement = null; |
| int rows = 0; |
| try { |
| LookUpKey luk = new LookUpKey(table, modeTypes); |
| CacheHelper queryData = null; |
| |
| if (getLogger().isDebugEnabled()) |
| getLogger().debug("modeTypes : "+ modeTypes); |
| |
| // get cached data |
| // synchronize complete block since we don't want 100s of threads |
| // generating the same cached data set. In the long run all data |
| // is cached anyways so this won't cost much. |
| synchronized (this.cachedQueryData) { |
| queryData = (CacheHelper) this.cachedQueryData.get(luk,null); |
| if (queryData == null) { |
| queryData = this.getQuery( table, modeTypes, defaultModeNames ); |
| this.cachedQueryData.put(luk,queryData); |
| } |
| } |
| |
| if (getLogger().isDebugEnabled()) |
| getLogger().debug("query: "+queryData.queryString); |
| statement = conn.prepareStatement(queryData.queryString); |
| |
| Object[][] columnValues = this.getColumnValues( table, queryData, objectModel ); |
| |
| int setLength = 1; |
| if ( queryData.isSet ) { |
| if ( columnValues[ queryData.setMaster ] != null ) { |
| setLength = columnValues[ queryData.setMaster ].length; |
| } else { |
| setLength = 0; |
| } |
| } |
| |
| for ( int rowIndex = 0; rowIndex < setLength; rowIndex++ ) { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug( "====> row no. " + rowIndex ); |
| } |
| rows += processRow( objectModel, conn, statement, (String) modeTypes.get(MODE_OUTPUT), table, queryData, columnValues, rowIndex, results ); |
| } |
| } finally { |
| try { |
| if (statement != null) { |
| statement.close(); |
| } |
| } catch (SQLException e) {} |
| } |
| return rows; |
| } |
| |
| /** |
| * Choose a mode configuration based on its name. |
| * @param conf Configuration (i.e. a column's configuration) that might have |
| * several children configurations named "mode". |
| * @param type desired type (i.e. every mode has a type |
| * attribute), find the first mode that has a compatible type. |
| * Special mode "all" matches all queried types. |
| * @return configuration that has desired type or type "all" or null. |
| */ |
| protected Configuration getMode( Configuration conf, String type ) |
| throws ConfigurationException { |
| |
| String modeAll = "all"; |
| Configuration[] modes = conf.getChildren("mode"); |
| Configuration modeConfig = null; |
| |
| for ( int i=0; i<modes.length; i++ ) { |
| String modeType = modes[i].getAttribute("type", "others"); |
| if ( modeType.equals(type) || modeType.equals(modeAll)) { |
| if (getLogger().isDebugEnabled()) |
| getLogger().debug("requested mode was \""+type+"\" returning \""+modeType+"\""); |
| modeConfig = modes[i]; |
| break; |
| } |
| } |
| return modeConfig; |
| } |
| |
| /** |
| * compose name for output a long the lines of "table.column" |
| */ |
| protected String getOutputName ( Configuration tableConf, Configuration columnConf ) { |
| |
| return getOutputName( tableConf, columnConf, -1 ); |
| } |
| |
| /** |
| * compose name for output a long the lines of "table.column[row]" or |
| * "table.column" if rowIndex is -1. |
| * If the section of the sitemap corresponding to the action contains |
| * <append-table-name>false</append-table-name> |
| * the name for output is "column[row]" |
| * If the section of the sitemap corresponding to the action contains |
| * <append-row>false</append-row> |
| * the name for output is "column" |
| */ |
| protected String getOutputName ( Configuration tableConf, Configuration columnConf, int rowIndex ) { |
| |
| if ( rowIndex != -1 && this.settings.containsKey("append-row") && |
| (this.settings.get("append-row").toString().equalsIgnoreCase("false") || |
| this.settings.get("append-row").toString().equalsIgnoreCase("0")) ) { |
| rowIndex = -1; |
| } else { |
| rowIndex = rowIndex + this.firstRow; |
| } |
| if ( this.settings.containsKey("append-table-name") && |
| (this.settings.get("append-table-name").toString().equalsIgnoreCase("false") || |
| this.settings.get("append-table-name").toString().equalsIgnoreCase("0")) ) |
| { |
| return ( columnConf.getAttribute("name",null) |
| + ( rowIndex == -1 ? "" : "[" + rowIndex + "]" ) ); |
| } else { |
| return ( tableConf.getAttribute("alias", tableConf.getAttribute("name", null) ) |
| + this.pathSeparator + columnConf.getAttribute("name",null) |
| + ( rowIndex == -1 ? "" : "[" + rowIndex + "]" ) ); |
| } |
| } |
| |
| /* |
| * Read all values for a column from an InputModule |
| * |
| * If the given column is an autoincrement column, an empty array |
| * is returned, otherwise if it is part of a set, all available |
| * values are fetched, or only the first one if it is not part of |
| * a set. |
| * |
| */ |
| protected Object[] getColumnValue(Configuration tableConf, Column column, Map objectModel) |
| throws ConfigurationException, ServiceException { |
| |
| if (column.isAutoIncrement) { |
| return new Object[1]; |
| } else { |
| Object[] values; |
| String cname = getOutputName( tableConf, column.columnConf ); |
| |
| // obtain input module and read values |
| ServiceSelector inputSelector = null; |
| InputModule input = null; |
| try { |
| inputSelector = (ServiceSelector) this.manager.lookup(INPUT_MODULE_SELECTOR); |
| if (column.mode != null && inputSelector != null && inputSelector.isSelectable(column.mode)){ |
| input = (InputModule) inputSelector.select(column.mode); |
| } |
| |
| if (column.isSet) { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug( "Trying to set column " + cname + " from " + column.mode + " using getAttributeValues method"); |
| } |
| values = input.getAttributeValues( cname, column.modeConf, objectModel ); |
| } else { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug( "Trying to set column " + cname + " from " + column.mode + " using getAttribute method"); |
| } |
| values = new Object[1]; |
| values[0] = input.getAttribute( cname, column.modeConf, objectModel ); |
| } |
| |
| if (values != null) { |
| for ( int i = 0; i < values.length; i++ ) { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug( "Setting column " + cname + " [" + i + "] " + values[i] ); |
| } |
| } |
| } |
| } finally { |
| if (inputSelector != null) { |
| if (input != null) { |
| inputSelector.release(input); |
| } |
| this.manager.release(inputSelector); |
| } |
| } |
| return values; |
| } |
| } |
| |
| /** |
| * Setup parsed attribute configuration object |
| */ |
| protected void fillModes ( Configuration[] conf, boolean isKey, Map defaultModeNames, |
| Map modeTypes, CacheHelper set ) |
| throws ConfigurationException { |
| |
| String setMode = null; |
| int offset = (isKey ? 0: set.noOfKeys); |
| |
| for (int i = offset; i < conf.length + offset; i++) { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("i=" + i); |
| } |
| set.columns[i].columnConf = conf[ i - offset ]; |
| set.columns[i].isSet = false; |
| set.columns[i].isKey = isKey; |
| set.columns[i].isAutoIncrement = false; |
| if (isKey & this.honourAutoIncrement()) { |
| set.columns[i].isAutoIncrement = set.columns[i].columnConf.getAttributeAsBoolean("autoincrement",false); |
| } |
| set.columns[i].modeConf = getMode(set.columns[i].columnConf, |
| selectMode(set.columns[i].isAutoIncrement, modeTypes)); |
| set.columns[i].mode = (set.columns[i].modeConf != null ? |
| set.columns[i].modeConf.getAttribute("name", selectMode(isKey, defaultModeNames)) : |
| selectMode(isKey, defaultModeNames)); |
| // Determine set mode for a whole column ... |
| setMode = set.columns[i].columnConf.getAttribute("set", null); // master vs slave vs null |
| if (setMode == null && set.columns[i].modeConf != null) { |
| // ... or for each mode individually |
| setMode = set.columns[i].modeConf.getAttribute("set", null); |
| } |
| if (setMode != null) { |
| set.columns[i].isSet = true; |
| set.isSet = true; |
| if (setMode.equals("master")) { |
| set.setMaster = i; |
| } |
| } |
| } |
| } |
| |
| /** |
| * create a unique name using the getOutputName method and write |
| * the value to the output module and the results map if present. |
| * |
| */ |
| protected void setOutput( Map objectModel, String outputMode, Map results, |
| Configuration table, Configuration column, int rowIndex, Object value ) { |
| |
| String param = this.getOutputName( table, column, rowIndex ); |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug( "Setting column " + param + " to " + value ); |
| } |
| this.setOutputAttribute(objectModel, outputMode, param, value); |
| if (results != null) { |
| results.put( param, String.valueOf( value ) ); |
| } |
| } |
| |
| /** |
| * set a column in a statement using the appropriate JDBC setXXX method. |
| * |
| */ |
| protected void setColumn (PreparedStatement statement, int position, Configuration entry, Object value) throws Exception { |
| JDBCTypeConversions.setColumn(statement, position, value, |
| (Integer)JDBCTypeConversions.typeConstants.get(entry.getAttribute("type"))); |
| } |
| |
| /** |
| * set a column in a statement using the appropriate JDBC setXXX |
| * method and propagate the value to the output module and results |
| * map if present. Effectively combines calls to setColumn and |
| * setOutput. |
| * |
| */ |
| protected void setColumn (Map objectModel, String outputMode, Map results, |
| Configuration table, Configuration column, int rowIndex, |
| Object value, PreparedStatement statement, int position) throws Exception { |
| |
| if (results != null) { |
| this.setOutput(objectModel, outputMode, results, table, column, rowIndex, value); |
| } |
| this.setColumn( statement, position, column, value ); |
| } |
| |
| // ======================================================================== |
| // main method |
| // ======================================================================== |
| |
| /** |
| * Add a record to the database. This action assumes that |
| * the file referenced by the "descriptor" parameter conforms |
| * to the AbstractDatabaseAction specifications. |
| */ |
| public Map act(Redirector redirector, SourceResolver resolver, Map objectModel, |
| String source, Parameters param) throws Exception { |
| |
| DataSourceComponent datasource = null; |
| Connection conn = null; |
| Map results = new HashMap(); |
| int rows = 0; |
| boolean failed = false; |
| |
| // read global parameter settings |
| boolean reloadable = Constants.DESCRIPTOR_RELOADABLE_DEFAULT; |
| |
| // call specific default modes apart from output mode are not supported |
| // set request attribute |
| String outputMode = param.getParameter("output", (String) defaultModeNames.get(MODE_OUTPUT)); |
| |
| if (this.settings.containsKey("reloadable")) { |
| reloadable = Boolean.valueOf((String) this.settings.get("reloadable")).booleanValue(); |
| } |
| // read local parameter settings |
| try { |
| Configuration conf = |
| this.getConfiguration(param.getParameter("descriptor", (String) this.settings.get("descriptor")), |
| resolver, |
| param.getParameterAsBoolean("reloadable",reloadable)); |
| |
| // get database connection and try to turn off autocommit |
| datasource = this.getDataSource(conf, param); |
| conn = datasource.getConnection(); |
| if (conn.getAutoCommit() == true) { |
| try { |
| conn.setAutoCommit(false); |
| } catch (Exception ex) { |
| String tmp = param.getParameter("use-transactions",(String) this.settings.get("use-transactions",null)); |
| if (tmp != null && (tmp.equalsIgnoreCase("no") || tmp.equalsIgnoreCase("false") || tmp.equalsIgnoreCase("0"))) { |
| if (getLogger().isErrorEnabled()) |
| getLogger().error("This DB connection does not support transactions. If you want to risk your data's integrity by continuing nonetheless set parameter \"use-transactions\" to \"no\"."); |
| throw ex; |
| } |
| } |
| } |
| |
| // find tables to work with |
| Configuration[] tables = conf.getChildren("table"); |
| String tablesetname = param.getParameter("table-set", (String) this.settings.get("table-set")); |
| |
| Map modeTypes = null; |
| |
| if (tablesetname == null) { |
| modeTypes = new HashMap(6); |
| modeTypes.put( MODE_AUTOINCR, "autoincr" ); |
| modeTypes.put( MODE_OTHERS, "others" ); |
| modeTypes.put( MODE_OUTPUT, outputMode ); |
| for (int i = 0; i < tables.length; i++) { |
| rows += processTable(tables[i], conn, objectModel, results, modeTypes); |
| } |
| } else { |
| // new set based behaviour |
| |
| // create index for table names / aliases |
| Map tableIndex = new HashMap(2*tables.length); |
| String tableName = null; |
| Object result = null; |
| for (int i=0; i<tables.length; i++) { |
| tableName = tables[i].getAttribute("alias",tables[i].getAttribute("name","")); |
| result = tableIndex.put(tableName,new Integer(i)); |
| if (result != null) { |
| throw new IOException("Duplicate table entry for "+tableName+" at positions "+result+" and "+i); |
| } |
| } |
| |
| Configuration[] tablesets = conf.getChildren("table-set"); |
| String setname = null; |
| boolean found = false; |
| |
| // find tables contained in tableset |
| int j = 0; |
| for (j = 0; j < tablesets.length; j++) { |
| setname = tablesets[j].getAttribute ("name", ""); |
| if (tablesetname.trim().equals (setname.trim ())) { |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| throw new IOException(" given set " + tablesetname + " does not exists in a description file."); |
| } |
| |
| Configuration[] set = tablesets[j].getChildren("table"); |
| |
| for (int i = 0; i < set.length; i++) { |
| // look for alternative mode types |
| modeTypes = new HashMap(6); |
| modeTypes.put( MODE_AUTOINCR, set[i].getAttribute( "autoincr-mode", "autoincr" ) ); |
| modeTypes.put( MODE_OTHERS, set[i].getAttribute( "others-mode", "others" ) ); |
| modeTypes.put( MODE_OUTPUT, outputMode ); |
| tableName=set[i].getAttribute("name",""); |
| if (tableIndex.containsKey(tableName)) { |
| j = ((Integer)tableIndex.get(tableName)).intValue(); |
| rows += processTable( tables[j], conn, objectModel, results, modeTypes ); |
| } else { |
| throw new IOException(" given table " + tableName + " does not exists in a description file."); |
| } |
| } |
| } |
| |
| if (conn.getAutoCommit() == false) { |
| conn.commit(); |
| } |
| |
| // obtain output mode module and rollback output |
| ServiceSelector outputSelector = null; |
| OutputModule output = null; |
| try { |
| outputSelector = (ServiceSelector) this.manager.lookup(OUTPUT_MODULE_SELECTOR); |
| if (outputMode != null && outputSelector != null && outputSelector.isSelectable(outputMode)){ |
| output = (OutputModule) outputSelector.select(outputMode); |
| } |
| if (output != null) { |
| output.commit(null, objectModel); |
| } else if (getLogger().isWarnEnabled()) { |
| getLogger().warn("Could not select output mode " + outputMode); |
| } |
| } catch (ServiceException e) { |
| if (getLogger().isWarnEnabled()) { |
| getLogger().warn("Could not select output mode " + outputMode + ":" + e.getMessage()); |
| } |
| } finally { |
| if (outputSelector != null) { |
| if (output != null) { |
| outputSelector.release(output); |
| } |
| this.manager.release(outputSelector); |
| } |
| } |
| } catch (Exception e) { |
| failed = true; |
| if ( conn != null ) { |
| try { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug( "Rolling back transaction. Caused by " + e.getMessage() ); |
| e.printStackTrace(); |
| } |
| conn.rollback(); |
| results = null; |
| |
| // obtain output mode module and commit output |
| ServiceSelector outputSelector = null; |
| OutputModule output = null; |
| try { |
| outputSelector = (ServiceSelector) this.manager.lookup(OUTPUT_MODULE_SELECTOR); |
| if (outputMode != null && outputSelector != null && outputSelector.isSelectable(outputMode)){ |
| output = (OutputModule) outputSelector.select(outputMode); |
| } |
| if (output != null) { |
| output.rollback( null, objectModel, e); |
| } else if (getLogger().isWarnEnabled()) { |
| getLogger().warn("Could not select output mode " + outputMode); |
| } |
| } catch (ServiceException e2) { |
| if (getLogger().isWarnEnabled()) { |
| getLogger().warn("Could not select output mode " + outputMode + ":" + e2.getMessage()); |
| } |
| } finally { |
| if (outputSelector != null) { |
| if (output != null) { |
| outputSelector.release(output); |
| } |
| this.manager.release(outputSelector); |
| } |
| } |
| } catch (SQLException se) { |
| if (getLogger().isDebugEnabled()) |
| getLogger().debug("There was an error rolling back the transaction", se); |
| } |
| } |
| |
| //throw new ProcessingException("Could not add record :position = " + currentIndex, e); |
| |
| // don't throw an exception, an error has been signalled, that should suffice |
| |
| String throwException = (String) this.settings.get( "throw-exception", |
| param.getParameter( "throw-exception", null ) ); |
| if ( throwException != null && BooleanUtils.toBoolean(throwException)) { |
| throw new ProcessingException("Cannot process the requested SQL statement ",e); |
| } |
| } finally { |
| if (conn != null) { |
| try { |
| conn.close(); |
| } catch (SQLException sqe) { |
| getLogger().warn("There was an error closing the datasource", sqe); |
| } |
| } |
| |
| if (datasource != null) |
| this.dbselector.release(datasource); |
| } |
| if (results != null) { |
| if (rows>0 || (!failed && !this.failOnEmpty)) { |
| results.put("row-count",new Integer(rows)); |
| } else { |
| results = null; |
| } |
| } else { |
| if (rows>0) { |
| results = new HashMap(1); |
| results.put("row-count",new Integer(rows)); |
| } |
| } |
| |
| return results; // (results == null? results : Collections.unmodifiableMap(results)); |
| } |
| |
| // ======================================================================== |
| // abstract methods |
| // ======================================================================== |
| |
| /** |
| * set all necessary ?s and execute the query |
| * return number of rows processed |
| * |
| * This method is intended to be overridden by classes that |
| * implement other operations e.g. delete |
| */ |
| protected abstract int processRow( Map objectModel, Connection conn, PreparedStatement statement, String outputMode, |
| Configuration table, CacheHelper queryData, Object[][] columnValues, |
| int rowIndex, Map results ) |
| throws SQLException, ConfigurationException, Exception; |
| |
| /** |
| * determine which mode to use as default mode |
| * |
| * This method is intended to be overridden by classes that |
| * implement other operations e.g. delete |
| */ |
| protected abstract String selectMode( boolean isAutoIncrement, Map modes ); |
| |
| /** |
| * determine whether autoincrement columns should be honoured by |
| * this operation. This is usually snsible only for INSERTs. |
| * |
| * This method is intended to be overridden by classes that |
| * implement other operations e.g. delete |
| */ |
| protected abstract boolean honourAutoIncrement(); |
| |
| /** |
| * Fetch all values for all columns that are needed to do the |
| * database operation. |
| * |
| * This method is intended to be overridden by classes that |
| * implement other operations e.g. delete |
| */ |
| abstract Object[][] getColumnValues( Configuration tableConf, CacheHelper queryData, Map objectModel ) |
| throws ConfigurationException, ServiceException; |
| |
| /** |
| * Get the String representation of the PreparedStatement. This is |
| * mapped to the Configuration object itself, so if it doesn't exist, |
| * it will be created. |
| * |
| * This method is intended to be overridden by classes that |
| * implement other operations e.g. delete |
| * |
| * @param table the table's configuration object |
| * @return the insert query as a string |
| */ |
| protected abstract CacheHelper getQuery( Configuration table, Map modeTypes, Map defaultModeNames ) |
| throws ConfigurationException, ServiceException; |
| |
| } |
