• Home
• com.draagon
• metaobjects-omdb
• 3.5.1
• source code
• ObjectManagerDB.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.draagon.meta.manager.db.ObjectManagerDB Maven / Gradle / Ivy

/*
 * Copyright 2003 Draagon Software LLC. All Rights Reserved.
 *
 * This software is the proprietary information of Draagon Software LLC.
 * Use is subject to license terms.
 */

package com.draagon.meta.manager.db;

import com.draagon.meta.*;
import com.draagon.meta.object.MetaObjectClass;
import com.draagon.meta.manager.*;
import com.draagon.meta.manager.db.driver.*;
//import com.draagon.util.InitializationException;
import com.draagon.cache.Cache;
import com.draagon.meta.manager.exp.Expression;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.util.Collection;
import java.util.Date;
import java.util.LinkedList;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Timestamp;
import javax.sql.DataSource;

/**
 * The Object Manager Base is able to add, update, delete,
 * and retrieve objects of those types from a datastore.
 */
public class ObjectManagerDB extends ObjectManager
{
	private static Log log = LogFactory.getLog( ObjectManagerDB.class );

	private final static String CREATE_MAP_ATTR = "dbCreateMap";
	private final static String READ_MAP_ATTR   = "dbReadMap";
	private final static String UPDATE_MAP_ATTR = "dbUpdateMap";
	private final static String DELETE_MAP_ATTR = "dbDeleteMap";
	private final static String HAS_CREATE_MAP_ATTR = "hasDbCreateMap";
	private final static String HAS_READ_MAP_ATTR   = "hasDbReadMap";
	private final static String HAS_UPDATE_MAP_ATTR = "hasDbUpdateMap";
	private final static String HAS_DELETE_MAP_ATTR = "hasDbDeleteMap";
        
	public final static String ALLOW_DIRTY_WRITE = "dbAllowDirtyWrite";
	public final static String DIRTY_WRITE_CHECK_FIELD = "dbDirtyWriteCheckField";
	public final static String POPULATE_FILE = "dbPopulateFile";

	private MappingHandler mMappingHandler = null;
	private DatabaseDriver mDriver = null;
	private DataSource mSource = null;

	private boolean enforceTransaction = false;
	
	private static Cache templateCache = new Cache( true, 3000, 1500 );

	//private ArrayList mValidatedClasses = new ArrayList();

	//private boolean autoCreateTables = false;

	//private HashMap mDirtyFieldCache = new HashMap();

	public ObjectManagerDB()
	{
	}

	/** Handles enforcing transactions on SQL queries */
	public void setEnforceTransaction( boolean enforce ) {
		enforceTransaction = enforce;
	}

	/** Returns whether to enforce transactions */
	public boolean enforceTransaction() {
		return enforceTransaction;
	}

	/** Checks to see if a transaction exists or not */
	protected void checkTransaction( Connection c, boolean throwEx ) throws MetaException {
		try {
			if ( enforceTransaction() && c.getAutoCommit() ) {
				MetaException me = new MetaException( "The connection retrieved is not operating under a transaction and transactions are being enforced" ); 
				if ( throwEx ) {
					throw me; 
				} else {
					log.warn( me.getMessage(), me );
				}
			}
		} catch( SQLException e ) {
			throw new MetaException( "Error checking connection for transaction enforcement: " + e.getMessage(), e );
		}
	}

	///////////////////////////////////////////////////////
	// CONNECTION HANDLING METHODS
	//

	/**
	 * Retrieves a connection object representing the datastore
	 */
	public ObjectConnection getConnection() 
	{
		DataSource ds =  getDataSource();
		if ( ds == null )
			throw new IllegalArgumentException( "No DataSource was specified for this ObjectManager, cannot request connection" );

		Connection c;
		try {
			c = ds.getConnection();
		} catch (SQLException e) {
			throw new RuntimeException( "Could not retrieve a connection from the datasource: " + e.getMessage(), e );
		}

		return new ObjectConnectionDB( c );
	}

	/** Release the Database Connection */
	public void releaseConnection( ObjectConnection oc ) 
	throws MetaException
	{
		oc.close();
	}


	/**
	 * Sets the Data Source to use for database connections
	 */
	public void setDataSource( DataSource ds )
	{
		mSource = ds;
	}

	/**
	 * Retrieves the data source
	 */
	public DataSource getDataSource()
	{
		return mSource;
	}

	/**
	 * Initializes the ObjectManager
	 */
	public void init() throws Exception
	{
		super.init();

		if ( getDataSource() == null )
			throw new IllegalStateException( "No DataSource was specified" );
	}

	///////////////////////////////////////////////////////
	// DATABASE DRIVER METHODS
	//

	public void setDriverClass( String className ) throws ClassNotFoundException, InstantiationException, IllegalAccessException 
	{
		Class c = Class.forName( className );
		setDatabaseDriver( (DatabaseDriver) c.newInstance() );
	}

	public void setDatabaseDriver( DatabaseDriver dd )
	{
		mDriver = dd;
		mDriver.setManager( this );
	}

	public synchronized DatabaseDriver getDatabaseDriver()
	{
		if ( mDriver == null ) {
			mDriver = new GenericSQLDriver();
			mDriver.setManager( this );
		}

		return mDriver;
	}

	///////////////////////////////////////////////////////
	// PERSISTENCE METHODS
	//

	public MappingHandler getDefaultMappingHandler() {
		return new SimpleMappingHandlerDB();
	}

        public void setMappingHandler( MappingHandler handler ) {
		mMappingHandler = handler;
	}

	public MappingHandler getMappingHandler() {
		if ( mMappingHandler == null ) {
			mMappingHandler = getDefaultMappingHandler();    		
		}
		return mMappingHandler;
	}

	/** Gets the create mapping */
	protected ObjectMapping getCreateMapping( MetaClass mc ) {
		ObjectMapping mapping = (ObjectMapping) mc.getCacheValue( CREATE_MAP_ATTR );
		if ( mapping == null ) {
			mapping = getMappingHandler().getCreateMapping( mc );
			if ( mapping != null ) {
				mc.setCacheValue( CREATE_MAP_ATTR, mapping );
			}
		}
		return mapping;
	}

	/** Gets the read mapping */
	protected ObjectMapping getReadMapping( MetaClass mc ) {
		ObjectMapping mapping = (ObjectMapping) mc.getCacheValue( READ_MAP_ATTR );
		if ( mapping == null ) {
			mapping = getMappingHandler().getReadMapping( mc );
			if ( mapping != null ) {
				mc.setCacheValue( READ_MAP_ATTR, mapping );
				mc.setCacheValue( HAS_READ_MAP_ATTR, Boolean.TRUE );
			} else {
				mc.setCacheValue( HAS_READ_MAP_ATTR, Boolean.FALSE );
			}
		}
		return mapping;
	}

	/** Gets the update mapping */
	protected ObjectMapping getUpdateMapping( MetaClass mc ) {
		ObjectMapping mapping = (ObjectMapping) mc.getCacheValue( UPDATE_MAP_ATTR );
		if ( mapping == null ) {
			mapping = getMappingHandler().getUpdateMapping( mc );
			if ( mapping != null ) {
				mc.setCacheValue( UPDATE_MAP_ATTR, mapping );
				mc.setCacheValue( HAS_UPDATE_MAP_ATTR, Boolean.TRUE );
			} else {
				mc.setCacheValue( HAS_UPDATE_MAP_ATTR, Boolean.FALSE );
			}
		}
		return mapping;
	}

	/** Gets the delete mapping */
	protected ObjectMapping getDeleteMapping( MetaClass mc ) {
		ObjectMapping mapping = (ObjectMapping) mc.getCacheValue( DELETE_MAP_ATTR );
		if ( mapping == null ) {
			mapping = getMappingHandler().getUpdateMapping( mc );
			if ( mapping != null ) {
				mc.setCacheValue( DELETE_MAP_ATTR, mapping );
				mc.setCacheValue( HAS_DELETE_MAP_ATTR, Boolean.TRUE );
			} else {
				mc.setCacheValue( HAS_DELETE_MAP_ATTR, Boolean.FALSE );
			}
		}
		return mapping;
	}        

	/** Is this a createable class */        
	public boolean isCreateableClass( MetaClass mc ) {
		Boolean hasMapping = (Boolean) mc.getCacheValue( HAS_CREATE_MAP_ATTR );
		if ( hasMapping == null ) {
			if ( getCreateMapping( mc ) == null ) return false;
			else return true;
		}
		return hasMapping.booleanValue();
	}

	/** Is this a readable class */
	public boolean isReadableClass( MetaClass mc ) {
		Boolean hasMapping = (Boolean) mc.getCacheValue( HAS_READ_MAP_ATTR );
		if ( hasMapping == null ) {
			if ( getReadMapping( mc ) == null ) return false;
			else return true;
		}
		return hasMapping.booleanValue();
	}

	/** Gets the update mapping to the DB */
	public boolean isUpdateableClass( MetaClass mc ) {
		Boolean hasMapping = (Boolean) mc.getCacheValue( HAS_UPDATE_MAP_ATTR );
		if ( hasMapping == null ) {
			if ( getUpdateMapping( mc ) == null ) return false;
			else return true;
		}
		return hasMapping.booleanValue();
	}

	/** Gets the delete mapping to the DB */
	public boolean isDeleteableClass( MetaClass mc ) {
		Boolean hasMapping = (Boolean) mc.getCacheValue( HAS_DELETE_MAP_ATTR );
		if ( hasMapping == null ) {
			if ( getDeleteMapping( mc ) == null ) return false;
			else return true;
		}
		return hasMapping.booleanValue();
	}
        
	/**
	 * Breaks apart the values from the id field represented by the keys
	 */
	/*protected Collection getKeyValuesFromRef( MetaClass mc, Collection keys, String ref )
        throws MetaException
    {
        ArrayList values = new ArrayList();

        String tmp = ref;

    // Split apart the id field
    for ( Iterator i = keys.iterator(); i.hasNext(); )
    {
            MetaField f = (MetaField) i.next();

            if ( tmp == null || tmp.length() == 0 )
                throw new MetaException( "Invalid Reference [" + ref + "] for MetaClass [" + mc + "]" );

            String val = null;
            int j = tmp.indexOf( '-' );
            if ( j >= 0 )
            {
                val = tmp.substring( 0, j );
                tmp = tmp.substring( j + 1 );
            }
            else
            {
                val = tmp;
                tmp = null;
            }

            values.add( val );
    }

    return values;
    }*/


	/**
	 * Sets the prepared statement values for the keys of a class and
	 *  a specifed id.
	 */
	/*    protected void setStatementValuesForRef( PreparedStatement s, Collection keys, int start, ObjectRef ref )
        throws MetaException, SQLException
    {
        //Collection values = getKeyValuesFromRef( keys, ref );
        String [] ids = ref.getIds();

        int k = 0;
        int j = start;
        //Iterator v = values.iterator();
        for ( Iterator i = keys.iterator(); i.hasNext(); j++, k++ )
        {
            MetaField f = (MetaField) i.next();
            String value = ids[ k ];

            setStatementValue( s, f, j, value );
        }
    }*/

	/**
	 * Parses an Object returned from the database
	 */
	public void parseObject( ResultSet rs, Collection fields, MetaClass mc, Object o ) throws SQLException, MetaException
	{
		if ( !isReadableClass( mc )) throw new MetaException( "MetaClass [" + mc + "] is not readable" );

		int j = 1;
		for( MetaField f : fields ) {
			parseField( o, f, rs, j++ );
		}

		if ( mc instanceof StatefulMetaClass )
		{
			// It was pulled from the database, so it doesn't need to be flagged as modified
			((StatefulMetaClass) mc ).setModified( o, false );

			// It is also no longer a new item
			((StatefulMetaClass) mc ).setNew( o, false );
		}    
	}

	protected void parseField( Object o, MetaField f, ResultSet rs, int j ) throws SQLException
	{
		switch( f.getType() )
		{
		case MetaField.BOOLEAN:
		{
			boolean bv = rs.getBoolean( j );
			if ( rs.wasNull() )
				f.setBoolean( o, null );
			else
				f.setBoolean( o, new Boolean( bv ));
		}
		break;

		case MetaField.BYTE:
		{
			byte bv = rs.getByte( j );
			if ( rs.wasNull() )
				f.setByte( o, null );
			else
				f.setByte( o, new Byte( bv ));
		}
		break;

		case MetaField.SHORT:
		{
			short sv = rs.getShort( j );
			if ( rs.wasNull() )
				f.setShort( o, null );
			else
				f.setShort( o, new Short( sv ));
		}
		break;

		case MetaField.INT:
		{
			int iv = rs.getInt( j );
			if ( rs.wasNull() )
				f.setInt( o, null );
			else
				f.setInt( o, new Integer( iv ));
		}
		break;


		case MetaField.DATE:
		{
			Timestamp tv = rs.getTimestamp( j );
			if ( rs.wasNull() )
				f.setDate( o, null );
			else
				f.setDate( o, new java.util.Date( tv.getTime() ));
		}
		break;

		case MetaField.LONG:
		{
			long lv = rs.getLong( j );
			if ( rs.wasNull() )
				f.setLong( o, null );
			else
				f.setLong( o, new Long( lv ));
		}
		break;

		case MetaField.FLOAT:
		{
			float fv = rs.getFloat( j );
			if ( rs.wasNull() )
				f.setFloat( o, null );
			else
				f.setFloat( o, new Float( fv ));
		}
		break;

		case MetaField.DOUBLE:
		{
			double dv = rs.getDouble( j );
			if ( rs.wasNull() )
				f.setDouble( o, null );
			else
				f.setDouble( o, new Double( dv ));
		}
		break;

		case MetaField.STRING:
			f.setString( o, rs.getString( j ));
			break;

		case MetaField.OBJECT:
			f.setObject( o, rs.getObject( j ));
			break;
		}
	}

	/** Reset the objects to not be new or modified */
	protected void resetObjects( MetaClass mc, Collection