Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * 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.util.InitializationException;
  
  
  import java.util.Date;
  
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.getLogObjectManagerDB.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<String,MetaClasstemplateCache = new Cache<String,MetaClass>( 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 setEnforceTransactionboolean enforce ) {
  		 = enforce;
  	}

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

Checks to see if a transaction exists or not
  
  	protected void checkTransactionConnection cboolean 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 {
  					.warnme.getMessage(), me );
  				}
  			}
  		} catchSQLException e ) {
  			throw new MetaException"Error checking connection for transaction enforcement: " + e.getMessage(), e );
  		}
  	}
  
  	///////////////////////////////////////////////////////
  	// CONNECTION HANDLING METHODS
  	//
 
Retrieves a connection object representing the datastore
 
 	{
 		if ( ds == null )
 			throw new IllegalArgumentException"No DataSource was specified for this ObjectManager, cannot request connection" );
 
 		try {
 			c = ds.getConnection();
 		} catch (SQLException e) {
 			throw new RuntimeException"Could not retrieve a connection from the datasource: " + e.getMessage(), e );
 		}
 
 		return new ObjectConnectionDBc );
 	}

Release the Database Connection
 
 	public void releaseConnectionObjectConnection oc ) 
 	throws MetaException
 	{
 		oc.close();
 	}


Sets the Data Source to use for database connections
 
 	public void setDataSourceDataSource ds )
 	{
 		 = ds;
 	}

Retrieves the data source
 
 	{
 		return ;
 	}

Initializes the ObjectManager
 
 	public void init() throws Exception
 	{
 		super.init();
 
 		if ( getDataSource() == null )
 			throw new IllegalStateException"No DataSource was specified" );
 	}
 
 	///////////////////////////////////////////////////////
 	// DATABASE DRIVER METHODS
 	//
 
 	{
 		Class<?> c = Class.forNameclassName );
 	}
 
 	public void setDatabaseDriverDatabaseDriver dd )
 	{
 		 = dd;
 		.setManagerthis );
 	}
 
 	public synchronized DatabaseDriver getDatabaseDriver()
 	{
 		if (  == null ) {
 			.setManagerthis );
 		}
 
 		return ;
 	}
 
 	///////////////////////////////////////////////////////
 	// PERSISTENCE METHODS
 	//
 
 		return new SimpleMappingHandlerDB();
 	}
 
         public void setMappingHandlerMappingHandler handler ) {
 		 = handler;
 	}
 
 		if (  == null ) {
 		}
 		return ;
 	}

Gets the create mapping
 
 	protected ObjectMapping getCreateMappingMetaClass mc ) {
 		if ( mapping == null ) {
 			mapping = getMappingHandler().getCreateMappingmc );
 			if ( mapping != null ) {
 				mc.setCacheValuemapping );
 			}
 		}
 		return mapping;
 	}

Gets the read mapping
 
 	protected ObjectMapping getReadMappingMetaClass mc ) {
 		if ( mapping == null ) {
 			mapping = getMappingHandler().getReadMappingmc );
 			if ( mapping != null ) {
 				mc.setCacheValuemapping );
 			} else {
 			}
 		}
 		return mapping;
 	}

Gets the update mapping
 
 	protected ObjectMapping getUpdateMappingMetaClass mc ) {
 		if ( mapping == null ) {
 			mapping = getMappingHandler().getUpdateMappingmc );
 			if ( mapping != null ) {
 				mc.setCacheValuemapping );
 			} else {
 			}
 		}
 		return mapping;
 	}

Gets the delete mapping
 
 	protected ObjectMapping getDeleteMappingMetaClass mc ) {
 		if ( mapping == null ) {
 			mapping = getMappingHandler().getUpdateMappingmc );
 			if ( mapping != null ) {
 				mc.setCacheValuemapping );
 			} else {
 			}
 		}
 		return mapping;
 	}        

Is this a createable class
         
 	public boolean isCreateableClassMetaClass mc ) {
 		Boolean hasMapping = (Booleanmc.getCacheValue );
 		if ( hasMapping == null ) {
 			if ( getCreateMappingmc ) == null ) return false;
 			else return true;
 		}
 		return hasMapping.booleanValue();
 	}

Is this a readable class
 
 	public boolean isReadableClassMetaClass mc ) {
 		Boolean hasMapping = (Booleanmc.getCacheValue );
 		if ( hasMapping == null ) {
 			if ( getReadMappingmc ) == null ) return false;
 			else return true;
 		}
 		return hasMapping.booleanValue();
 	}

Gets the update mapping to the DB
 
 	public boolean isUpdateableClassMetaClass mc ) {
 		Boolean hasMapping = (Booleanmc.getCacheValue );
 		if ( hasMapping == null ) {
 			if ( getUpdateMappingmc ) == null ) return false;
 			else return true;
 		}
 		return hasMapping.booleanValue();
 	}

Gets the delete mapping to the DB
 
 	public boolean isDeleteableClassMetaClass mc ) {
 		Boolean hasMapping = (Booleanmc.getCacheValue );
 		if ( hasMapping == null ) {
 			if ( getDeleteMappingmc ) == 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 parseObjectResultSet rsCollection<MetaFieldfieldsMetaClass mcObject o ) throws SQLExceptionMetaException
 	{
 		if ( !isReadableClassmc )) throw new MetaException"MetaClass [" + mc + "] is not readable" );
 
 		int j = 1;
 		forMetaField f : fields ) {
 			parseFieldofrsj++ );
 		}
 
 		if ( mc instanceof StatefulMetaClass )
 		{
 			// It was pulled from the database, so it doesn't need to be flagged as modified
 			((StatefulMetaClassmc ).setModifiedofalse );
 
 			// It is also no longer a new item
 			((StatefulMetaClassmc ).setNewofalse );
 		}    
 	}
 
 	protected void parseFieldObject oMetaField fResultSet rsint j ) throws SQLException
 	{
 		switchf.getType() )
 		{
 		{
 			boolean bv = rs.getBooleanj );
 			if ( rs.wasNull() )
 				f.setBooleanonull );
 			else
 				f.setBooleanonew Booleanbv ));
 		}
 		break;
 
 		case .:
 		{
 			byte bv = rs.getBytej );
 			if ( rs.wasNull() )
 				f.setByteonull );
 			else
 				f.setByteonew Bytebv ));
 		}
 		break;
 
 		{
 			short sv = rs.getShortj );
 			if ( rs.wasNull() )
 				f.setShortonull );
 			else
 				f.setShortonew Shortsv ));
 		}
 		break;
 
 		case .:
 		{
 			int iv = rs.getIntj );
 			if ( rs.wasNull() )
 				f.setIntonull );
 			else
 				f.setIntonew Integeriv ));
 		}
 		break;
 
 
 		case .:
 		{
 			Timestamp tv = rs.getTimestampj );
 			if ( rs.wasNull() )
 				f.setDateonull );
 			else
 				f.setDateonew java.util.Datetv.getTime() ));
 		}
 		break;
 
 		case .:
 		{
 			long lv = rs.getLongj );
 			if ( rs.wasNull() )
 				f.setLongonull );
 			else
 				f.setLongonew Longlv ));
 		}
 		break;
 
 		{
 			float fv = rs.getFloatj );
 			if ( rs.wasNull() )
 				f.setFloatonull );
 			else
 				f.setFloatonew Floatfv ));
 		}
 		break;
 
 		{
 			double dv = rs.getDoublej );
 			if ( rs.wasNull() )
 				f.setDoubleonull );
 			else
 				f.setDoubleonew Doubledv ));
 		}
 		break;
 
 			f.setStringors.getStringj ));
 			break;
 
 			f.setObjectors.getObjectj ));
 			break;
 		}
 	}

Reset the objects to not be new or modified
 
 	protected void resetObjectsMetaClass mcCollection<Objectobjects ) {
 	
 		if ( !( mc instanceof StatefulMetaClass )) return;
 			
 		// Reset all the objects
 		for ( Object o : objects ) {
 			resetObjectmco );
 		}
 	}

Reset the object to not be new or modified
 
 	protected void resetObjectMetaClass mcObject o ) {
 		
 		if ( mc instanceof StatefulMetaClass ) {
 			
 			// It was pulled from the database, so it doesn't need to be flagged as modified
 			((StatefulMetaClassmc ).setModifiedofalse );
 
 			// It is also no longer a new item
 			((StatefulMetaClassmc ).setNewofalse );
 		}
 	}

Gets the object by the id; throws exception if it did not exist
 
 	public Object getObjectByRefObjectConnection cString refStr ) 
 	{
 		ObjectRef ref = getObjectRefrefStr );		
 		MetaClass mc = ref.getMetaClass();
 		
 		if ( !isReadableClassmc )) throw new PersistenceException"MetaClass [" + mc + "] is not readable" );
 		
 		
 
 		// Check for a valid transaction if enforced
 		checkTransactionconnfalse );      
 
 		if ( .isDebugEnabled() ) {
 			.debug"Loading object [" + mc + "] with reference [" + ref + "]" );
 		}
 
 		try {
 			
 			// Create the Expression for the Primary Keys
 			Expression exp = null;
 			int i = 0;
 			forMetaField mf : getPrimaryKeysmc )) {
 				Expression e = new Expressionmf.getName(), ref.getIds()[ i ] );
 				if ( exp == null ) exp = e;
 				else exp = exp.ande );
 				i++;
 			}
 			
 			if ( exp == null ) throw new PersistenceException"MetaClass [" + mc + "] has no primary keys get object by reference [" + ref + "]" ); 
 				
 			// Create the QueryOptions and limit to the first 1
 			QueryOptions qo = new QueryOptions();
 			qo.setRange( 1, 1 );
 			
 			// Read the objects from the database driver
 			Collection<Objectobjects = getDatabaseDriver().readManyconnmcreadMapqo );
 			
 			// Reset the object persistence states
 			resetObjectsmcobjects );
 			
 			// Return the object if found
 			if ( objects.size() > 0 ) return objects.iterator().next();
 			else throw new ObjectNotFoundExceptionrefStr );			
 		}
 		catchSQLException e ) {
 			//log.error( "Unable to load object [" + mc + "] with reference [" + ref + "]: " + e.getMessage(), e );
 			throw new PersistenceException"Unable to load object [" + mc + "] with reference [" + ref + "]: " + e.getMessage(), e );
 		}
 	}


Delete the objects from the datastore where the field has the specified value
 
 	public int deleteObjectsObjectConnection cMetaClass mcExpression exp ) {
 
 		if ( !isDeleteableClassmc )) throw new PersistenceException"MetaClass [" + mc + "] is not deletable" );
 		
 
 
 		// Check for a valid transaction if enforced
 		checkTransactionconntrue );
 
 		if ( .isDebugEnabled() ) {
 			.debug"Deleting Objects of Class [" + mc + "] where [" + exp + "]" );
 		}
 
 		//int failures = 0;
 		//while( true )
 		//{
 			try {
 				return getDatabaseDriver().deleteManyconnmcmappingexp );
 			}
 			catchSQLException e )
 			{
 				//log.error( "Unable to delete objects of class [" + mc.getName() + "] with expression [" + exp + "]: " + e.getMessage() );
 				//if ( ++failures > 5 )
 				throw new PersistenceException"Unable to delete objects of class [" + mc.getName() + "] with expression [" + exp + "]: " + e.getMessage(), e );
 			}
 
 			// Sleep on a delete failure
 			//try { Thread.sleep( 200 * failures ); }
 			//catch (InterruptedException e) {}
 		//}
 	}

Gets the total count of objects with the specified search criteria
 
 	public long getObjectsCountObjectConnection cMetaClass mcExpression exp ) throws MetaException
 	{
 		if ( !isReadableClassmc )) throw new PersistenceException"MetaClass [" + mc + "] is not persistable" );
 
 
 		
 		// Check for a valid transaction if enforced
 		checkTransactionconnfalse );	    
 
 		try
 		{
 			// Read the objects
 			return getDatabaseDriver().getCountconnmcmappingexp );			
 		}
 		catchSQLException e )
 		{
 			throw new PersistenceException"Unable to get objects count of class [" + mc.getName() + "] with expression [" + exp + "]: " + e.getMessage(), e );
 		}		
 	}

Gets the objects by the field with the specified search criteria
 
 	public Collection<ObjectgetObjectsObjectConnection cMetaClass mcQueryOptions options ) throws MetaException
 	{
 		if ( !isReadableClassmc )) throw new PersistenceException"MetaClass [" + mc + "] is not persistable" );
 
 
 		
 		// Check for a valid transaction if enforced
 		checkTransactionconnfalse );	    
 
 		//int failures = 0;
 		//while( true )
 		//{
 			try
 			{
 				// Read the objects
 				Collection<Objectobjects = getDatabaseDriver().readManyconnmcmappingoptions );
 				
 				// Reset the object persistence states
 				resetObjectsmcobjects );
 
 				// Return the objects
 				return objects;
 			}
 			catchSQLException e )
 			{
 				//log.error( "Unable to load objects of class [" + mc.getName() + "]: " + e.getMessage() );
 
 				//if ( ++failures > 5 )
 					throw new PersistenceException"Unable to get objects of class [" + mc.getName() + "] with options [" + options + "]: " + e.getMessage(), e );
 			}
 
 			// Sleep on a read failure
 			//try { Thread.sleep( 200 * failures ); }
 			//catch (InterruptedException e) {}
 		//}
 	}

Load the specified object from the database
 
 	public void loadObjectObjectConnection cObject o ) throws MetaException
 	{
 		// Verify this object was loaded by the same object manager
 		//verifyObjectManager( o );
 		
 		// Get the MetaClass for the object
 		MetaClass mc = getClassForObjecto );
 		
 		// If it's not a readable class throw an exception
 		if ( !isReadableClassmc )) throw new PersistenceException"MetaClass [" + mc + "] is not persistable" );
 		
 		// Get the read mapping
 				
 		// Get the connection
 
 		// Check for a valid transaction if enforced
 		checkTransactionconnfalse );    
 
 		if ( .isDebugEnabled() ) {
 		    .debug"Loading object [" + o + "] of class [" + mc + "]" );
 		}
 
 		// Create the Expression for the Primary Keys
 		Expression exp = null;
 		forMetaField mf : getPrimaryKeysmc )) {
 			Expression e = new Expressionmf.getName(), mf.getObjecto ));
 			if ( exp == null ) exp = e;
 			else exp = exp.ande );
 		}
 		
 		if ( exp == null ) throw new PersistenceException"MetaClass [" + mc + "] has no primary keys defined to load object [" + o + "]" );
 		
 		// Try to read the object
 		try {
 			// Read the object from the mapping
 			boolean found = getDatabaseDriver().readconnmcmappingoexp );
 			
 			// If not found throw an exception
 			if ( !found ) throw new ObjectNotFoundExceptiono );				
 
 			// Reset the object after it's loaded
 			resetObjectmco );
 		}
 		catchSQLException e )
 		{
 			//log.error( "Unable to load object [" + o + "]: " + e.getMessage(), e );
 			throw new PersistenceException"Unable to load object [" + o + "]: " + e.getMessage(), e );
 		}
 	}

Add the specified object to the datastore
 
 	public void createObjectObjectConnection cObject obj ) throws PersistenceException
 	{
 
 		// Check for a valid transaction if enforced
 		checkTransactionconntrue );
 
 		MetaClass mc = getClassForObjectobj );
 		
 		if ( !isCreateableClassmc )) throw new PersistenceException"Object of class [" + mc + "] is not createable" );
 		
 		// Get the create mapping
 
 		//verifyObjectManager( obj );
 
 		prePersistencecmcobj );
 
 		if ( .isDebugEnabled() ) {
 			.debug"Adding object [" + obj + "] of class [" + mc + "]" );
 		}
 
 		try
 		{
 			if ( !getDatabaseDriver().createconnmcmappingobj )) {
 				throw new PersistenceException"Now rows created for object [" + obj + "] of class [" + mc + "]" );
 			}
 			
 			postPersistencecmcobj );
 		}
 		catchSQLException e )
 		{
 			//log.error( "Unable to add object of class [" + mc + "]: " + e.getMessage() );
 			throw new PersistenceException"Unable to add object of class [" + mc + "]:" + e.getMessage(), e );
 		}
 	}
Update the specified object in the datastore
 
 	public void updateObjectObjectConnection cObject obj ) throws PersistenceException
 	{
 
 		// Check for a valid transaction if enforced
 		checkTransactionconntrue );
 
 		// Get the metaclass and make sure it is updateable
 		MetaClass mc = getClassForObjectobj );
 		if ( !isUpdateableClassmc )) throw new PersistenceException"Object of class [" + mc + "] is not writeable" );
 
 		// check the object manager
 		//verifyObjectManager( obj );
 		
 		// Get the update mapping
 
 		// Check whether there are dirty writes
 		boolean allowsDirtyWrites = allowsDirtyWritesmc );
 		
 		MetaField dirtyField = null;
 		Object dirtyFieldValue = null;
 		
 		// If we don't allow dirty writes then get the field we're filtering from
 		if ( !allowsDirtyWrites ) {
 			dirtyField = getDirtyFieldmc );
 			dirtyFieldValue = dirtyField.getObjectobj );
 		}
 		
 		if ( .isDebugEnabled() ) {
 		    .debug"Updating object [" + obj + "] of class [" + mc + "]" );
 		}
 
 		// Run the pre-peristence methods
 		prePersistencecmcobj );
 		
 		// Get the modified fields
 		Collection<MetaFieldfields = mc.getMetaFields(); //mapping.getMetaFields();
 		if ( mc instanceof StatefulMetaClass ) {
 			fields = getModifiedPersistableFields( (StatefulMetaClassmcfieldsobj );
 		}
 
 		// If nothing needs to be persisted, then don't bother
 		if ( fields.size() == 0 ) {
 			if ( .isDebugEnabled() ) {
 				.debug"No need to update object of class [" + mc + "]" );
 			}
 			return;
 		}
 		
 		try {
 			// Update the object
 			if ( !getDatabaseDriver().updateconnmcmappingobjfieldsgetPrimaryKeysmc ), dirtyFielddirtyFieldValue )) {
 				
 				// If no dirty writes, see if that was the issue
 				if ( !allowsDirtyWrites ) {
 					
 					mapping = (ObjectMappingDBgetReadMappingmc );
 					
 					// Create the Expression for the Primary Keys
 					Expression exp = null;
 					forMetaField mf : getPrimaryKeysmc )) {
 						Expression e = new Expressionmf.getName(), mf.getObjectobj ));
 						if ( exp == null ) exp = e;
 						else exp = exp.ande );
 					}
 					
 					if ( exp == null ) throw new PersistenceException"MetaClass [" + mc + "] has no primary keys defined to update object [" + obj + "]" );
 										
 					Collection<Objectresults = getDatabaseDriver().readManyconnmcmappingnew QueryOptionsexp ));
 					if ( results.size() > 0 ) {
 						throw new DirtyWriteExceptionobj );
 					}
 				}
 				
 				throw new ObjectNotFoundExceptionobj );
 			}
 
 			postPersistencecmcobj );
 		}
 		catchSQLException e ) {
 			//log.error( "Unable to update object of class [" + mc + "]: " + e.getMessage() );
 			throw new PersistenceException"Unable to update object [" + obj + "] of class [" + mc + "]: " + e.getMessage(), e );
 		}
 	}

Delete the specified object from the datastore
 
 	public void deleteObjectObjectConnection cObject obj ) throws PersistenceException
 	{
 
 		// Check for a valid transaction if enforced
 		checkTransactionconntrue );
 
 		MetaClass mc = getClassForObjectobj );
 
 		if ( !isDeleteableClassmc )) {
 			throw new PersistenceException"Object [" + obj + "] of class [" + mc + "] is not deleteable" );
 		}
 
 		//verifyObjectManager( obj );
 		
 		// Get the update mapping
 
 		// Check whether there are dirty writes
 		boolean allowsDirtyWrites = allowsDirtyWritesmc );
 		
 		//MetaField dirtyField = null;
 		//Object dirtyFieldValue = null;
 		
 		// If we don't allow dirty writes then get the field we're filtering from
 		//if ( !allowsDirtyWrites ) {
 			//dirtyField = getDirtyField( mc );
 			//dirtyFieldValue = dirtyField.getObject( obj );
 		//}
 						
 		prePersistencecmcobj );
 
 		if ( .isDebugEnabled() ) {
 		    .debug"Deleting object [" + obj + "] of class [" + mc + "]" );
 		}
 
 		try
 		{
 			boolean success = getDatabaseDriver().deleteconnmcmappingobjgetPrimaryKeysmc ));
 			
 			if ( !success ) {
 				
 				// If no dirty writes, see if that was the issue
 				if ( !allowsDirtyWrites ) {
 					
 					// Create the Expression for the Primary Keys
 					Expression exp = null;
 					forMetaField mf : getPrimaryKeysmc )) {
 						Expression e = new Expressionmf.getName(), mf.getObjectobj ));
 						if ( exp == null ) exp = e;
 						else exp = exp.ande );
 					}
 					
 					if ( exp == null ) throw new PersistenceException"MetaClass [" + mc + "] has no primary keys defined to delete object [" + obj + "]" );
 					
 					Collection<Objectresults = getDatabaseDriver().readManyconnmcmappingnew QueryOptionsexp ));
 					if ( results.size() > 0 ) {
 						throw new DirtyWriteExceptionobj );
 					}
 				}
 				
 				throw new ObjectNotFoundExceptionobj );
 			}
 
 			postPersistencecmcobj );
 		}
 		catchSQLException e )
 		{
 			//log.error( "Unable to delete object of class [" + mc + "]: " + e.getMessage() );
 			throw new PersistenceException"Unable to delete object [" + obj + "] of class [" + mc + "]: " + e.getMessage(), e );
 		}
 	}
 
 	/*public boolean isAutoCreateTables() {
       return autoCreateTables;
     }
 
     public void setAutoCreateTables(boolean autoCreateTables) {
       this.autoCreateTables = autoCreateTables;
     }*/
 
 
 	///////////////////////////////////////////////////////
 	// OBJECT QUERY LANGUAGE METHODS
 	//
 
 	//private final static String ROOT_CLASS_KEY = "*ROOT_CLASS_KEY*";
 
 	/*protected Map<String,MetaClass> getMetaClassMap( String query ) throws MetaException
 	{
 		Map<String,MetaClass> m = new HashMap<String,MetaClass>();
 
 		int i = -1;
 
 		while( ( i = query.indexOf( '[', i + 1 )) > 0 )
 		{
 			int j = query.indexOf( ']', i );
 			int k = query.indexOf( '=', i );
 			if ( j <= 0 )
 				throw new IllegalArgumentException( "Malformed OQL, missing closing '}': [" + query + "]" );
 
 			if ( k >= 0 && k < j )
 			{
 				String cn = query.substring( i + 1, k );
 				String var = query.substring( k + 1, j );
 				m.put( var, MetaClass.forName( cn ));
 			}
 			else
 			{
 				String cn = query.substring( i + 1, j );
 				m.put( ROOT_CLASS_KEY, MetaClass.forName( cn ));
 			}
 
 			i = j;
 		}
 
 		//ystem.out.println( "MAP: " + m );
 
 		return m;
 	}*/
 
 	/* private String convertToSQL( String query, Map<String,MetaClass> m ) throws MetaException
 	{
 		//StringBuffer b = new StringBuffer();
 		//ystem.out.println( "IN: " + query );
 
 		int i = -1;
 
 		// Replace tables
 		while( ( i = query.indexOf( '{', i + 1 )) > 0 )
 		{
 			int j = query.indexOf( '}', i );
 			if ( j <= 0 )
 				throw new IllegalArgumentException( "Malformed OQL, missing closing '}': [" + query + "]" );
 
 			String field = null;
 			String var = null;
 			MetaClass mc = null;
 
 			int k = query.indexOf( '.', i );
 			if ( k >= 0 && k < j )
 			{
 				var = query.substring( i + 1, k );
 				field = query.substring( k + 1, j );
 
 				mc = (MetaClass) m.get( var );
 
 				if ( mc == null )
 					throw new IllegalArgumentException( "Malformed OQL, unmapped metaclass variable '" + var + "': [" + query + "]" );
 
 				var += ".";
			else
				field = query.substring( i + 1, j );
				mc = (MetaClass) m.get( ROOT_CLASS_KEY );
				var = "";
				if ( mc == null )
					throw new IllegalArgumentException( "Malformed OQL, no default metaclass defined: [" + query + "]" );
			String colName = null;
			if ( field.equals( "*" ))
				colName = "*";
			else
				colName = getColumnName( mc.getMetaField( field ));
			query = query.substring( 0, i ) +
			var + colName +
			query.substring( j + 1 );
		// Replace fields
		i = -1;
		while( ( i = query.indexOf( '[', i + 1 )) > 0 )
			int j = query.indexOf( ']', i );
			if ( j <= 0 )
				throw new IllegalArgumentException( "Malformed OQL, missing closing '}': [" + query + "]" );
			String var = null;
			MetaClass mc = null;
			int k = query.indexOf( '=', i );
			if ( k >= 0 && k < j )
				var = query.substring( k + 1, j );
				mc = (MetaClass) m.get( var );
				if ( mc == null )
					throw new IllegalArgumentException( "Malformed OQL, unmapped metaclass variable '" + var + "': [" + query + "]" );
				var = " " + var;
			else
				mc = (MetaClass) m.get( ROOT_CLASS_KEY );
				if ( mc == null )
					throw new IllegalArgumentException( "Malformed OQL, no default metaclass defined: [" + query + "]" );
				var = "";
			query = query.substring( 0, i ) +
			getViewName( mc ) + var +
			query.substring( j + 1 );
		//ystem.out.println( "OUT: " + query );
		//return b.toString();
		return query;
	}*/


Returns whether a MetaClass allows dirty writes
	public boolean allowsDirtyWritesMetaClass mc )
				|| !("false".equalsmc.getAttribute ))))
			return true;
		else
			return false;
	}

Gets the name of the dirty field of a metaclass
	protected MetaField getDirtyFieldMetaClass mc )
		final String KEY = "getDirtyField()";
		MetaField field = (MetaFieldmc.getCacheValueKEY );
		if ( field == null )
			else
				for ( MetaField f : getAutoFieldsmc ))
						field = f;
						break;
			if ( field == null )
				throw new MetaFieldNotFoundException"No MetaField that is useable to prevent dirty writes was found" );
			mc.setCacheValueKEYfield );
		return field;
	///**
	// * Retrieves the value of the dirty field for an object
	// */
	//protected Object getDirtyFieldValue( MetaClass mc, Object obj ) {
	//	return getDirtyField( mc ).getObject( obj );
	//}
	//private Cache<String,String> mOQLCache = new Cache<String,String>( true, 900, 3600 );
		String sql = query// (String) mOQLCache.get( query );
		// If it's not in the cache, then parse it and put it there
		//if ( sql == null )
		//{
			//Map<String,MetaClass> m = getMetaClassMap( query );
			//if ( m.size() > 0 ) {
			//	sql = convertToSQL( query, m );
			//}
			//else sql = query;
			//mOQLCache.put( query, sql );
		//}
		if ( args != null )
			int i = 1;
			forObject o : args )
				if ( o instanceof Boolean )
					s.setBooleani, (Booleano );
				else if ( o instanceof Byte )
					s.setBytei, (Byteo );
				else if ( o instanceof Short )
					s.setShorti, (Shorto );
				else if ( o instanceof Integer )
					s.setInti, (Integero );
				else if ( o instanceof Long )
					s.setLongi, (Longo );
				else if ( o instanceof Float )
					s.setFloati, (Floato );
				else if ( o instanceof Double )
					s.setDoublei, (Doubleo );
				else if ( o instanceof Date )
					s.setTimestampinew Timestamp( ((Date)o).getTime() ));
				else if ( o == null )
					s.setStringinull );
				else
					s.setStringio.toString() );
				// Increment the i
				i++;
			}        
		return s;
	public int executeObjectConnection cString queryCollection<?> arguments ) throws MetaException
		// Check for a valid transaction if enforced
		checkTransactionconntrue );
		try
		{    	  
			PreparedStatement s = getPreparedStatementconnqueryarguments );
			try {
				if ( .isDebugEnabled() ) {
					.debug"SQL (" + conn.hashCode() + ") - execute: [" + query + " " + arguments + "]" );
				return s.executeUpdate();
			finally { s.close(); }
		catchSQLException e )
			.error"Unable to execute object query [" + query + "]: " + e.getMessage() );
			throw new MetaException"Unable to execute object query [" + query + "]"e );
	protected MetaField getFieldForColumnMetaClass resultClassObjectMapping mappingString col ) throws MetaException
		// Generate a cache key
		//final String KEY = ( new StringBuilder( "getFieldForColumn(" ) ).append( col ).append( ")" ).toString();
		MetaField rc = null//(MetaField) resultClass.getCacheValue( KEY );
		if ( rc == null ) {
			// First check against the read mapping
			//ObjectMapping om = getReadMapping( resultClass );
			if ( mapping != null ) {
				rc = mapping.getFieldcol ); 
			// Next try to match by the metafield name
			if ( rc == null ) {
				try {
					rc = resultClass.getMetaFieldcol );
catchMetaFieldNotFoundException e ) {}
			// Add it to the cache to speed things up
			//if ( rc != null ) resultClass.setCacheValue( KEY, rc );
		return rc;
	}

Executes the specified query and maps it to the given object. String oql = "[" + Product.CLASSNAME + "]" + " SELECT {P.*}, {M.name} AS manuName" + " FROM [" + Product.CLASSNAME + "=P]," + " [" + Manufacturer.CLASSNAME + "=M]" + " WHERE {M.id}={P.manuId} AND {M.id} > ?"; String oql = "[{min:int,max:int,num:int}]" + " SELECT MIN({extra2}) AS min, MAX({extra2}) AS max, COUNT(1) AS num" + " FROM [" + Product.CLASSNAME + "]";