DatabaseObject.java

Violations

Source code

/*
  * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
 */
package biz.hammurapi.sql;

import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.Map.Entry;

import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import biz.hammurapi.config.ConfigurationException;
import biz.hammurapi.config.Context;
import biz.hammurapi.config.ContextConfigurable;
import biz.hammurapi.config.DomConfigFactory;
import biz.hammurapi.config.DomConfigurable;
import biz.hammurapi.convert.Converter;
import biz.hammurapi.convert.ConvertingService;
import biz.hammurapi.sql.columns.Column;
import biz.hammurapi.sql.columns.ColumnChangeListener;
import biz.hammurapi.util.Attributable;
import biz.hammurapi.util.ClassResourceLoader;
import biz.hammurapi.util.Observable;
import biz.hammurapi.util.Observer;
import biz.hammurapi.util.Versioned;
import biz.hammurapi.xml.dom.AbstractDomObject;
import biz.hammurapi.xml.dom.DOMUtils;
import biz.hammurapi.xml.dom.DomSerializable;


/**
 * SQLC-generated interface implementations implement this method to achieve
 * differential update functionality - inserting and updating only modified fields.
 * @author Pavel Vlasov
 * @version $Revision: 1.11 $
 */
public class DatabaseObject 
	implements 
		DomSerializable, 
		ColumnChangeListener, 
		Cloneable, 
		ContextConfigurable, 
		Context,
		DomConfigurable,
		Attributable,
		Versioned,
		Observable, 
		IDatabaseObject,
		Serializable {
    
    protected Collection columns=new ArrayList();
    private Map columnMap=new HashMap();
    private Map columnXmlMap=new HashMap();    
    private boolean force;
	private boolean isDeleted;
	
	protected Column getColumn(String name) {
		return (Column) columnMap.get(name);
	}
	
	/**
	 * Default constructor
	 */
	public DatabaseObject() {
		// Default constructor

	}
	
	/**
	 *
	 * @param force Forces columns to be marked as
	 * modified if setter method is invoked even if value being set equals to existing column
	 * value. Useful during inserts with non-nullable columns which map to primitive
	 * types and as such have default values.
	 */
	public DatabaseObject(boolean force) {
		this.force=force;
	}
	
    protected void addColumn(Column column) {
    	column.setForce(force);
        columns.add(column);
        columnMap.put(column.getName(), column);
        columnXmlMap.put(column.getXmlName(), column);
        column.setListener(this);
    }
       
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#update(biz.hammurapi.sql.SQLProcessor, java.lang.String)
	 */
	public int update(SQLProcessor processor, String tableName) throws SQLException {
	    StringBuffer sb=new StringBuffer("UPDATE ");
	    sb.append(tableName);
	    sb.append(" SET ");
	    boolean hasColumns=false;
	    Iterator it=columns.iterator();
	    while (it.hasNext()) {
	        Column column = (Column) it.next();
			String colName=(column).listName();
	        if (colName!=null) {
	            if (hasColumns) {
	                sb.append(", ");
	            }
	            sb.append(colName);
	            sb.append("=?");
	            hasColumns=true;
	            
	        }
	    }
	    
	    if (!hasColumns) {
	        return 0;
	    }
	    
	    sb.append(" WHERE ");
	    
	    boolean hasPkColumns=false;
	    it=columns.iterator();
	    while (it.hasNext()) {
	        Column column = (Column) it.next();
	        if (column.isPrimaryKey()) {
				String colName=(column).getName();
	            if (hasPkColumns) {
	                sb.append(" AND ");
	            }
	            sb.append(colName);
	            sb.append("=?");
	            hasPkColumns=true;
	        }
	    }
	    
	    int ret=processor.processUpdate(sb.toString(), new Parameterizer() {
            public int parameterize(PreparedStatement ps, int idx) throws SQLException {
        	    Iterator it=columns.iterator();
        	    while (it.hasNext()) {
        	        Column column = (Column) it.next();
       	        	idx=column.parameterize(ps, idx, false);
        	    }
        	    
        	    it=columns.iterator();
        	    while (it.hasNext()) {
        	        Column column = (Column) it.next();
        	        if (column.isPrimaryKey()) {
        	        	column.parameterizeOriginal(ps, idx++);
        	        }
        	    }
        	    return idx;
            }	        
	    });

	    it=columns.iterator();
	    while (it.hasNext()) {
	        ((Column) it.next()).clearModified();
	    }	  
	    
	    originalVersion=objectVersion;	    
	    isModified=false;
	    
	    return ret;
	}
	
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#delete(biz.hammurapi.sql.SQLProcessor, java.lang.String)
	 */
	public int delete(SQLProcessor processor, String tableName) throws SQLException {
	
	    StringBuffer sb=new StringBuffer("DELETE FROM ");
	    sb.append(tableName);
	    sb.append(" WHERE ");
	    
	    boolean hasPkColumns=false;
	    Iterator it=columns.iterator();
	    while (it.hasNext()) {
	        Column column = (Column) it.next();
	        if (column.isPrimaryKey()) {
				String colName=(column).getName();
	            if (hasPkColumns) {
	                sb.append(" AND ");
	            }
	            sb.append(colName);
	            sb.append("=?");
	            hasPkColumns=true;
	        }
	    }
	    
	    int ret=processor.processUpdate(sb.toString(), new Parameterizer() {
            public int parameterize(PreparedStatement ps, int idx) throws SQLException {
        	    Iterator it=columns.iterator();
        	    while (it.hasNext()) {
        	        Column column = (Column) it.next();
        	        if (!column.isPrimaryKey()) {
        	        	idx=column.parameterize(ps, idx, false);
        	        }
        	    }
        	    
        	    it=columns.iterator();
        	    while (it.hasNext()) {
        	        Column column = (Column) it.next();
        	        if (column.isPrimaryKey()) {
        	        	idx=column.parameterize(ps, idx, true);
        	        }
        	    }
                return idx;
            }
	    });

	    it=columns.iterator();
	    while (it.hasNext()) {
	        ((Column) it.next()).clearModified();
	    }	    
	    
	    originalVersion=objectVersion;
	    isDeleted=true;
	    return ret;
	}
	
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#insert(biz.hammurapi.sql.SQLProcessor, java.lang.String)
	 */
	public int insert(SQLProcessor processor, String tableName) throws SQLException {
	    StringBuffer sb=new StringBuffer("INSERT INTO ");
	    sb.append(tableName);
	    sb.append(" (");
	    int columnsCounter=0;
	    Iterator it=columns.iterator();
	    while (it.hasNext()) {
	        String colName=((Column) it.next()).listName();
	        if (colName!=null) {
	            if (columnsCounter>0) {
	                sb.append(", ");
	            }
	            sb.append(colName);
	            columnsCounter++;
	            
	        }
	    }
	    
	    if (columnsCounter==0) {
	        return 0;
	    }
	    
	    sb.append(") VALUES (");
	    for (int i=0; i<columnsCounter; i++) {
	        if (i>0) {
	            sb.append(", ");
	        }
	        sb.append("?");
	    }
	    sb.append(")");
	    
	    int ret=processor.processUpdate(sb.toString(), new Parameterizer() {
            public int parameterize(PreparedStatement ps, int idx) throws SQLException {
        	    Iterator it=columns.iterator();
        	    while (it.hasNext()) {
        	    	idx = ((Column) it.next()).parameterize(ps, idx, false);
        	    }
        	    return idx;
            }	        
	    });

	    it=columns.iterator();
	    while (it.hasNext()) {
	        ((Column) it.next()).clearModified();
	    }	    
	    
	    originalVersion=objectVersion;
	    isModified=false;
	    
	    return ret;
	}
	
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#fromDom(org.w3c.dom.Element)
	 */
	public void fromDom(Element holder) throws ConfigurationException {
		fromDom(holder, getNameMap(getClass()));
	}
	
	private void loadAttributes(Element holder) throws ConfigurationException {
		DomConfigFactory dcf=new DomConfigFactory();
		attributes.clear();
		try {
			Node attributesNode = DOMUtils.selectSingleNode(holder, "object-attributes");
			if (attributesNode!=null) {
				attributes.putAll((Map) dcf.create(attributesNode));
			}
		} catch (Exception e) {
			throw new ConfigurationException("Cannot load database object attributes: "+e, e);
		}
				
	}
	
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#fromDom(org.w3c.dom.Element, java.util.Properties)
	 */
	public void fromDom(Element holder, Properties nameMap) throws ConfigurationException {
		Iterator it=columns.iterator();
		while (it.hasNext()) {
			Column column=(Column) it.next();
			String nodeName = nameMap.getProperty(column.getName(), column.getName()).trim();			

			if (nodeName.length()==0) {
				// Zero mapping

				continue;
			} else if (nodeName.startsWith("@")) {
				// Attribute mapping

				if (holder.hasAttribute(nodeName.substring(1))) {
					column.load(holder.getAttribute(nodeName.substring(1)));
				}
			} else if (nodeName.equals(".")) {
				// Text content mapping

				column.load(AbstractDomObject.getElementText(holder));
			} else if (nodeName.startsWith("!")) {
				// Simple node mapping

				try {
					Node cNode=DOMUtils.selectSingleNode(holder, nodeName.substring(1));
					if (cNode!=null) {
						column.load(AbstractDomObject.getElementText(cNode));
					}
				} catch (Exception e) {
					throw new ConfigurationException("Cannot load column "+column.getName());
				}				
			} else {
				// Regular node mapping

				try {
					Node cNode=DOMUtils.selectSingleNode(holder, nodeName);
					if (cNode!=null) {
						column.configure(cNode, null, getClass().getClassLoader());
					}
				} catch (Exception e) {
					throw new ConfigurationException("Cannot load column "+column.getName());
				}
			}
		}				
		
		loadAttributes(holder);
	}
		
	public void toDom(Element holder) {
		toDom(holder, getNameMap(getClass()), false);
	}
	
	/**
	 * XML namespace.
	 */
	protected String xmlNamespace;
	
	/**
	 * Name of object XML Element.
	 */
	protected String xmlElement;
	
	/**
	 * Converts fully qualified class name to namespace and element name.
	 * @param className
	 * @return String array with two elements. First - namespace, second - element name
	 */
	public static String[] xmlNames(String className) {
		String[] ret={null, null};
		className = className.replace('$', '.');
		int idx = className.lastIndexOf('.');
		if (idx!=-1) {
			String[] pName = className.substring(0, idx).split("\\.");
			StringBuffer sb = new StringBuffer("http://www.");
			if (pName.length>1) {
				sb.append(pName[1]);
				sb.append(".");
				sb.append(pName[0]);
				for (int i=2; i<pName.length; ++i) {
					sb.append("/");
					sb.append(pName[i]);
				}
				ret[0] = sb.toString();
			} else {
				sb.append(pName[0]);
			}
			className = className.substring(idx+1);
		}
		
		StringBuffer sb = new StringBuffer();
		for (int i=0, j=0, l=className.length(); i<=l; i++) {
			if (i==l && j<i) {
				if (sb.length()>0) {
					sb.append("-");
				}
				sb.append(className.substring(j, i));				
			} else if (Character.isUpperCase(className.charAt(i)) && j<i && Character.isLowerCase(className.charAt(i-1))) {
				if (sb.length()>0) {
					sb.append("-");
				}
				sb.append(className.substring(j, i));
				j=i;
			}
		}
		
		ret[1]=sb.toString().toLowerCase();				
		return ret;
	}
	
	/**
	 * Serializes object to XML events
	 * @param contentHandler Events receiver
	 * @param withHolder If true outputs object XML element, otherwise only nested elements.
	 * @throws SAXException
	 */
	public void toSax(ContentHandler contentHandler, boolean withHolder) throws SAXException {
		if (xmlElement==null) {
			String[] xmlNames = xmlNames(getClass().getName());
			xmlElement=xmlNames[1];
			xmlNamespace=xmlNames[0];
		}
		if (withHolder) {
			contentHandler.startElement(xmlNamespace, xmlElement, xmlElement, null);
		}

		childrenToSax(contentHandler);
		if (withHolder) {
			contentHandler.endElement(xmlNamespace, xmlElement, xmlElement);
		}
	}
	
	/**
	 * Outputs child objects to SAX.
	 * @param contentHandler
	 * @throws SAXException
	 */
	protected void childrenToSax(ContentHandler contentHandler) throws SAXException {
		if (xmlElement==null) {
			String[] xmlNames = xmlNames(getClass().getName());
			xmlElement=xmlNames[1];
			xmlNamespace=xmlNames[0];
		}
		
	    Iterator it=columns.iterator();
	    while (it.hasNext()) {
	        Column column = (Column) it.next();
			String colName=(column).listName();
	        if (colName!=null) {
	        	column.toSax(xmlNamespace, contentHandler);
	        }
	    }	    		
	}
	
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#toDom(org.w3c.dom.Element, java.util.Properties, boolean)
	 */
	public void toDom(Element holder, Properties nameMap, boolean originals) {
		if (nameMap==null) {
			nameMap=new Properties();
		}
		
		String cna = nameMap.getProperty("@type", "type").trim();
		if (!"".equals(cna)) {
			holder.setAttribute(cna, getClass().getName());
		}
		
		Iterator it=columns.iterator();
		while (it.hasNext()) {
			Column column = (Column) it.next();
			column.toDom(holder, nameMap.getProperty(column.getName(), column.getName()).trim(), originals);
		}
				
		if (!attributes.isEmpty()) {
			DomSerializable ads = (DomSerializable) ConvertingService.convert(attributes, DomSerializable.class);
			ads.toDom(AbstractDomObject.addElement(holder, "object-attributes"));
		}		
	}
	
	public String toString() {
		StringBuffer ret=new StringBuffer(getClass().getName());
		ret.append("[");
		Iterator it=columns.iterator();
		while (it.hasNext()) {
			ret.append(it.next());
			if (it.hasNext()) {
				ret.append(", ");
			}
		}		
		
		ret.append("]");		
		return ret.toString();
	}

	/**
	 * Sets modified flag to true and increments version number.
	 * Also broadcasts the change to observers. Changed column is
	 * passed as second argument of update() method.
	 * Override this method in subclasses to react on
	 * change events, but don't forget to invoke
	 * super.onChange().
	 * @param column Changed column
	 */
	public void onChange(Column column) {
		isModified=true;
		
		++objectVersion;
		
		if (column.isPrimaryKey()) {
			isDeleted=false;
		}
				
		synchronized (observers) {
			Iterator it=observers.iterator();
			while (it.hasNext()) {
				((Observer) it.next()).update(this, column);
			}
		}		

	}
	
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#setOriginal()
	 */
	public void setOriginal() {
		objectVersion=originalVersion;
		Iterator it=columns.iterator();
		while (it.hasNext()) {
			((Column) it.next()).setOriginal();
		}		
	}
	
	private boolean isModified=false;
	
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#isModified()
	 */
	public boolean isModified() {
		return isModified;
	}
	
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#isDeleted()
	 */
	public boolean isDeleted() {
		return isDeleted;
	}
	
	/**
	 * Two objects are considered equal and all their fields are equal.
	 * @param otherBean Other object
	 * @return true if object classes are equal and all member column values are
	 * equal.
	 */
    public boolean equals(Object otherBean) {
        if (otherBean==null) {
            return false;
        } else if (getClass().equals(otherBean.getClass())) {
        	Collection myColumns=new ArrayList(columns);
        	Collection otherColumns=new ArrayList(((DatabaseObject) otherBean).columns);
        	Iterator mcit=myColumns.iterator();
        	Z:
        	while (mcit.hasNext()) {
        		Column mc=(Column) mcit.next();
        		Iterator ocit=otherColumns.iterator();
				while (ocit.hasNext()) {
					Column oc=(Column) ocit.next();
					if (mc.getName().equals(oc.getName())) {
						if (mc.equals(oc)) {
							ocit.remove();
							mcit.remove();
							continue Z;
						}
						
						return false;
					}
				}
        	}
        	
			return myColumns.isEmpty() && otherColumns.isEmpty();
        } else {
            return false;
        }
    }
    
	public int hashCode() {
		int ret=0;
		Iterator cit=columns.iterator();
		while (cit.hasNext()) {
			ret^=cit.next().hashCode();
		}
		return ret;
	}

	/**
	 * Clones object, clears columns collection, clears isDeleted and isModified flags.
	 * Subclasses shall add cloned columns.
	 */
	public Object clone() throws CloneNotSupportedException {
		DatabaseObject ret = (DatabaseObject) super.clone();
		ret.columns.clear();
		ret.isDeleted=false;
		ret.isModified=false;
		return ret;
	}
	
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#clear()
	 */
	public void clear() {
		Iterator it = columns.iterator();
		while (it.hasNext()) {
			((Column) it.next()).clear();
		}
		isModified=false;
		isDeleted=false;
	}

	public void configure(Context context, Converter converter) throws ConfigurationException {
		Iterator it = columns.iterator();
		while (it.hasNext()) {
			((Column) it.next()).configure(context, converter);
		}
	}

    public Object get(String name) {
        Column col=(Column) columnMap.get(name);
        return col==null ? null : col.getObjectValue(false);
    }

	public void configure(Node configNode, Context context, ClassLoader classLoader) throws ConfigurationException {
		fromDom((Element) configNode);
	}
	
	private static Map nnMap=new HashMap();
	
	private static Properties getNameMap(Class clazz) {
		synchronized (nnMap) {
			Properties ret=(Properties) nnMap.get(clazz.getName());
			if (ret==null) {
				ret=new ClassResourceLoader(clazz).getProperties(null, "namemap");
				nnMap.put(clazz.getName(), ret);
			}
			return ret;
		}
	}		
				
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#copy(biz.hammurapi.sql.DatabaseObject)
	 */
	public void copy(DatabaseObject source) {
		Iterator it=columns.iterator();
		while (it.hasNext()) {
			Column targetColumn=(Column) it.next();
			Column sourceColumn=(Column) source.columnMap.get(targetColumn.getName());
			if (targetColumn.getClass().isInstance(sourceColumn)) { // Copy values only from compatible columns

				targetColumn.set(sourceColumn);
				if (targetColumn.isPrimaryKey()) {
					targetColumn.clearModified();
				}
			}
		}
	}
	
	private Map attributes=new HashMap();
	
	public void setAttribute(Object key, Object value) {
		attributes.put(key, value);		
	}
	
	public Object getAttribute(Object key) {
		return attributes.get(key);
	}
	
	public Object removeAttribute(Object key) {
		return attributes.remove(key);
	}
	
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#setColumnAttribute(java.lang.String, java.lang.Object, java.lang.Object)
	 */
	public void setColumnAttribute(String columnName, Object key, Object value) {
		Column column=(Column) columnMap.get(columnName);
		if (column==null) {
			throw new IllegalArgumentException("Column not found: "+columnName);
		}
		column.setAttribute(key, value);		
	}
	
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#getColumnAttribute(java.lang.String, java.lang.Object)
	 */
	public Object getColumnAttribute(String columnName, Object key) {
		Column column=(Column) columnMap.get(columnName);
		if (column==null) {
			throw new IllegalArgumentException("Column not found: "+columnName);
		}
		return column.getAttribute(key);
	}
	
	/* (non-Javadoc)
	 * @see biz.hammurapi.sql.IDatabaseObject#removeColumnAttribute(java.lang.String, java.lang.Object)
	 */
	public Object removeColumnAttribute(String columnName, Object key) {
		Column column=(Column) columnMap.get(columnName);
		if (column==null) {
			throw new IllegalArgumentException("Column not found: "+columnName);
		}
		return column.removeAttribute(key);
	}
	
	private static Map sqlTypes=new HashMap();
	
	/**
	 * Allows to override generated column types with &lt;class name&gt;.sqltypes resource.
	 * Subclasses shall use this method when dealing with Object columns.
	 * @param columnName
	 * @param generatedType
	 * @return
	 */
	protected int getSqlType(String columnName, int generatedType) {
		Map typeMap;
		synchronized (sqlTypes) {
			String className = getClass().getName();
			if (sqlTypes.containsKey(className)) {
				typeMap=(Map) sqlTypes.get(className);
			} else {
				Properties literalMap=new ClassResourceLoader(getClass()).getProperties(null, "sqltypes");
				typeMap=new HashMap();
				sqlTypes.put(className, typeMap);
				Iterator it=literalMap.entrySet().iterator();				
				while (it.hasNext()) {
					Entry entry=(Entry) it.next();
					try {
						Integer type = (Integer) Types.class.getDeclaredField((String) entry.getValue()).get(null) ;
						typeMap.put(entry.getKey(), type);
					} catch (IllegalArgumentException e) {
						System.err.println("Invalid SQL Type "+entry.getValue()+", ignored. Cause: "+e);
						e.printStackTrace();
					} catch (SecurityException e) {
						System.err.println("Invalid SQL Type "+entry.getValue()+", ignored. Cause: "+e);
						e.printStackTrace();
					} catch (IllegalAccessException e) {
						System.err.println("Invalid SQL Type "+entry.getValue()+", ignored. Cause: "+e);
						e.printStackTrace();
					} catch (NoSuchFieldException e) {
						System.err.println("Invalid SQL Type "+entry.getValue()+", ignored. Cause: "+e);
						e.printStackTrace();
					}
				}
			}
		}
		
		Integer st=(Integer) typeMap.get(columnName);
		return st==null ? generatedType : st.intValue();
	}
	
	/**
	 * Subclasses can choose to read object version from the database.
	 */
	protected int objectVersion;
	protected int originalVersion;

	public int getObjectVersion() {
		return objectVersion;
	}
	
	private Set observers = new HashSet();

	public void addObserver(Observer observer) {
		synchronized (observers) {
			observers.add(observer);
		}		
	}

	public void removeObserver(Observer observer) {
		synchronized (observers) {
			observers.remove(observer);
		}		
	}
	
	private boolean equal(String str1, String str2) {
		return str1==null ? str2==null : str1.equals(str2);
	}
	
	/**
	 * @param withHolder True if XML events stream contains start/endElement for
	 * this object.
	 * @return Content handler to populate database object by XML events.
	 */
	public ContentHandler getContentHandler(final boolean withHolder) {
		return new DefaultHandler() {
			int level = withHolder ? -1 : 0;
			private ContentHandler currentDelegate;
			private Column currentColumn;
			private StringBuffer buffer;
			
			public void characters(char[] ch, int start, int length) throws SAXException {
				if (currentDelegate==null) {
					if (buffer!=null) {
						buffer.append(ch, start, length);
					}
				} else {
					currentDelegate.characters(ch, start, length);
				}
			}
			
			public void startElement(String uri, String localName, String name,	Attributes attributes) throws SAXException {
				
				++level;
				if (level==1) {
					if (xmlElement==null) {
						String[] xmlNames = xmlNames(getClass().getName());
						xmlElement=xmlNames[1];
						xmlNamespace=xmlNames[0];
					}
					
					if (equal(xmlNamespace, uri)) {
						currentColumn = (Column) columnXmlMap.get(localName);
						if (currentColumn!=null) {
							buffer = new StringBuffer();
							return;
						}
					}
					
					currentDelegate = getSubHandler(uri, localName, name);
				} else if (currentDelegate!=null) {
					currentDelegate.startElement(uri, localName, name, attributes);
				}
			}
			
			public void endElement(String uri, String localName, String name) throws SAXException {
				--level;
				if (level==0) {
					if (buffer!=null && currentColumn!=null) {
						currentColumn.load(buffer.toString());
					}
					
					currentColumn=null;
					buffer=null;
					currentDelegate=null;
				} else if (currentDelegate!=null) {
					currentDelegate.endElement(uri, localName, name);
				}
			}
			
		};
	}	
		
	/**
	 * If database object receives XML event which doesn't map to any
	 * column, it invokes this method to obtain sub-handler for an element.
	 * Subclasses can override this method to populate relationships.
	 * This implementation returns default handler.
	 * @param name element local name
	 * @param qName element qualified name
	 * @return Sub-handler.
	 */
	protected ContentHandler getSubHandler(String uri, String name, String qName) {
		return null;
	}
	
	// TODO - Auditor, thread-local instance to listen for inserts, deletes and updates.

	
}