anchor.diff:  				// We have a field ending with _ID, which typically indicates a "foriegn key" property to a tabled named whatever prefixes the _ID
   				// Using this convention, if the parent table is "orders" and the field name is "orders_ID" we can load the parent
   				try{
  -					var newTableName = var propertyName = listDeleteAt( col.name, listLen( col.name, '_' ), '_' );
  -					if( structKeyExists( getDynamicMappings(), col.name ) ){
  -						newTableName = getDynamicMappings()[ col.name ];
  -					}
  -					var newObj = new( table = newTableName, dao = this.getDao() );
  -					newObj.setTable( newTableName );
  -					// Load data into new object
  -					writeLog('Loading dynamic relationship entity #newTableName# with id of #variables[col.name]#');
  -					newObj.load( variables[ col.name ], lazy );
  -					writeLog('Well, was there anything to load?: #yesNoFormat( !newObj.isNew() )#')
  -					// Create setter methods for this relationship property.
  -					variables[ "set" & propertyName ] = _setter;
  -					// Now set the relationhsip property value to the newly created and instantiated object.
  -					variables[ propertyName ] = this[ propertyName ] = variables.properties[ propertyName ] = newObj;
  -					// Append the relationship property to the meta properties
  -					arrayAppend( variables.meta.properties, {
  -										"column" = propertyName,
  -										"name" = propertyName,
  -										"dynamic" = true,
  -										"cfc" = "BaseModelObject",
  -										"table" = newTableName,
  -										"inverseJoinColumn" = newObj.getIDField(),
  -										"fkcolumn" = col.name,
  -										"fieldType" = "one-to-many"
  -									} );
  -					this[ "get" & propertyName ] = getFunc;
  -
  +					// if( col.name == 'orders_id'){
  +					// 	writeDump([getParentTable(), col, super, getMetadata(this), getFunctionCalledName()]);
  +					// 	throw("bad");
  +					// }
  +					var propertyName = listDeleteAt( col.name, listLen( col.name, '_' ), '_' );
  +					writeLog("#this.getParentTable()# neq #propertyName# ? #yesNoFormat(getParentTable() neq propertyName)#");
  +					if( parentTable != propertyName ){
  +						variables[ propertyName ] = this[ propertyName ] = _getManyToOne( table = lcase( propertyName ), fkColumn = col.name );
  +					}else{
  +						writeDump( [this.getParentTable(), propertyName] );abort;
  +					}
   				} catch ( any e ){
   					if( e.type != 'BMO' ){
   						// throw(e.detail);
  
positive.code: 		var orderby = arguments.missingMethodName is "loadTop" ? "ORDER BY " & arguments.missingMethodArguments[2] : '';
  		var where = "1=1";
  
  		// @TODO: create custom "getters" to dynamically bind and load realted entities.
  
  
  		// Allow "loadFirst" method to instantiate the entity and load it with the first
  		// record returned per the "By" criteria
  
negative.code: 				return this.load( ID = record, lazy = left( originalMethodName , 4 ) is "lazy" );
  			// If more than one record was returned, or method called was a "loadAll" type, return an array of data.
  			}else if( record.recordCount > 1 || left( originalMethodName, 7 ) is "loadAll" || left( originalMethodName , 11 ) is "lazyLoadAll" ) {
  				writeLog('lazy load all #getTable()# - [#originalMethodName# | #getParentTable()#]');
  				var recordArray = [];
  				var qn = queryNew( record.columnList );
  				var recCount = record.recordCount;
  				queryAddRow( qn, 1 );
  
  				for ( var rec = 1; rec LTE recCount; rec++ ){
  					// append each record to the array. Each record will be an instance of the model entity in represents.  If lazy loading
  					// this will be an empty entity instance with "overloaded" getter methods that instantiate when needed.
  					for( var col in listToArray( record.columnList ) ){
  						querySetCell( qn, col, record[ col ][ rec ] );
  					}
  					var tmpLazy = left( originalMethodName , 4 ) is "lazy" || record.recordCount GTE 100 || this.getParentTable() != "";
  					var cachedObject = cacheGet( '#getTable()#-#qn[ getIDField() ][ 1 ]#' );
  
  					writeLog('is object cached? #yesNoFormat(!isNull(cachedObject))#');
  					if( !isNull( cachedObject ) ){
  						// object cached, load from memory.
  						var tmpNewEntity = cachedObject;
  					}else{
  
  						// Creating a new instance of the entity for each record.  Tried to use duplicate( this ), but that
  						// does not appear to be thread safe and ends up causing concurrency issues.
  						var tmpNewEntity = new(); //createObject("component", variables.meta.fullName ).init( dao = this.getDao() );
  						tmpNewEntity.load( ID = qn , lazy = tmpLazy, parent = getParentTable() );
  
  					}
  					cachePut( '#getTable()#-#qn[ getIDField() ][ 1 ]#' , tmpNewEntity, createTimeSpan( 0, 0, 0, 20 ) );
  					if( returnType is "struct" || returnType is "array" ){
  						tmpNewEntity = tmpNewEntity.toStruct();
  					}else if (returnType is "json"){
  						tmpNewEntity = tmpNewEntity.toJSON();
  					}
  
  					arrayAppend( recordArray, tmpNewEntity );
  				}
  					// writeDump([tmplazy,this,variables.meta,arguments,getFunctionCalledName(),recordArray]);abort;
  				if( returnType is "json" ){
  					return "[" & arrayToList( recordArray ) & "]";
  				}
  
  				return recordArray;
  			//Otherwise, set the passed in arguments and return the new entity
  			}else{
  