\n");
// recurse on each child
NodeList nodes = node.getChildNodes();
if (nodes != null) {
for (int i = 0; i < nodes.getLength(); i++) {
printWriter.print(nodeToString(nodes.item(i), ""));
}
}
break;
case Node.ELEMENT_NODE:
String name = node.getNodeName();
printWriter.print(indent + "<" + name);
NamedNodeMap attributes = node.getAttributes();
for (int i = 0; i < attributes.getLength(); i++) {
Node current = attributes.item(i);
printWriter.print(" " + current.getNodeName() +
"=\"" + current.getNodeValue() +
"\"");
}
printWriter.print(">");
// recurse on each child
NodeList children = node.getChildNodes();
if (children != null) {
for (int i = 0; i < children.getLength(); i++) {
printWriter.print(nodeToString(children.item(i), indent + indent));
}
}
printWriter.print("");
break;
case Node.TEXT_NODE:
printWriter.print(node.getNodeValue());
break;
}
printWriter.flush();
String result = stringWriter.getBuffer().toString();
printWriter.close();
return result;
}
}
ibatis/src/com/ibatis/common/beans/GenericProbe.java 0000644 0001750 0001750 00000022106 11047641630 022701 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.beans;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
/**
* StaticBeanProbe provides methods that allow simple, reflective access to
* JavaBeans style properties. Methods are provided for all simple types as
* well as object types.
*
* Examples:
*
* StaticBeanProbe.setObject(object, propertyName, value);
*
* Object value = StaticBeanProbe.getObject(object, propertyName);
*/
public class GenericProbe extends BaseProbe {
private static final BaseProbe BEAN_PROBE = new ComplexBeanProbe();
private static final BaseProbe DOM_PROBE = new DomProbe();
protected GenericProbe() {
}
/**
* Gets an object from a Map or bean
*
* @param object - the object to probe
* @param name - the name of the property (or map entry)
* @return The value of the property (or map entry)
* @see com.ibatis.common.beans.BaseProbe#getObject(java.lang.Object, java.lang.String)
*/
public Object getObject(Object object, String name) {
if (object instanceof org.w3c.dom.Document) {
return DOM_PROBE.getObject(object, name);
} else if (object instanceof List) {
return BEAN_PROBE.getIndexedProperty(object, name);
} else if (object instanceof Object[]) {
return BEAN_PROBE.getIndexedProperty(object, name);
} else if (object instanceof char[]) {
return BEAN_PROBE.getIndexedProperty(object, name);
} else if (object instanceof boolean[]) {
return BEAN_PROBE.getIndexedProperty(object, name);
} else if (object instanceof byte[]) {
return BEAN_PROBE.getIndexedProperty(object, name);
} else if (object instanceof double[]) {
return BEAN_PROBE.getIndexedProperty(object, name);
} else if (object instanceof float[]) {
return BEAN_PROBE.getIndexedProperty(object, name);
} else if (object instanceof int[]) {
return BEAN_PROBE.getIndexedProperty(object, name);
} else if (object instanceof long[]) {
return BEAN_PROBE.getIndexedProperty(object, name);
} else if (object instanceof short[]) {
return BEAN_PROBE.getIndexedProperty(object, name);
} else {
return BEAN_PROBE.getObject(object, name);
}
}
/**
* Sets an object in a Map or bean
*
* @param object - the object to probe
* @param name - the name of the property (or map entry)
* @param value - the new value of the property (or map entry)
* @see com.ibatis.common.beans.BaseProbe#setObject(java.lang.Object, java.lang.String, java.lang.Object)
*/
public void setObject(Object object, String name, Object value) {
if (object instanceof org.w3c.dom.Document) {
DOM_PROBE.setObject(object, name, value);
} else {
BEAN_PROBE.setObject(object, name, value);
}
}
/**
* Gets an array of the readable properties in a Map or JavaBean
*
* @param object - the object to get properties for
* @return The array of properties (or map entries)
* @see com.ibatis.common.beans.BaseProbe#getReadablePropertyNames(java.lang.Object)
*/
public String[] getReadablePropertyNames(Object object) {
if (object instanceof org.w3c.dom.Document) {
return DOM_PROBE.getReadablePropertyNames(object);
} else {
return BEAN_PROBE.getReadablePropertyNames(object);
}
}
/**
* Gets an array of the writeable properties in a Map or JavaBean
*
* @param object - the object to get properties for
* @return The array of properties (or map entries)
* @see com.ibatis.common.beans.BaseProbe#getWriteablePropertyNames(java.lang.Object)
*/
public String[] getWriteablePropertyNames(Object object) {
if (object instanceof org.w3c.dom.Document) {
return DOM_PROBE.getWriteablePropertyNames(object);
} else {
return BEAN_PROBE.getWriteablePropertyNames(object);
}
}
/**
* Returns the class that the setter expects to receive as a parameter when
* setting a property value.
*
* @param object - The class to check
* @param name - the name of the property
* @return The type of the property
* @see com.ibatis.common.beans.Probe#getPropertyTypeForSetter(java.lang.Object, java.lang.String)
*/
public Class getPropertyTypeForSetter(Object object, String name) {
if (object instanceof Class) {
return getClassPropertyTypeForSetter((Class) object, name);
} else if (object instanceof org.w3c.dom.Document) {
return DOM_PROBE.getPropertyTypeForSetter(object, name);
} else {
return BEAN_PROBE.getPropertyTypeForSetter(object, name);
}
}
/**
* Returns the class that the getter will return when reading a property value.
*
* @param object The bean to check
* @param name The name of the property
* @return The type of the property
* @see com.ibatis.common.beans.Probe#getPropertyTypeForGetter(java.lang.Object, java.lang.String)
*/
public Class getPropertyTypeForGetter(Object object, String name) {
if (object instanceof Class) {
return getClassPropertyTypeForGetter((Class) object, name);
} else if (object instanceof org.w3c.dom.Document) {
return DOM_PROBE.getPropertyTypeForGetter(object, name);
} else if (name.indexOf('[') > -1) {
return BEAN_PROBE.getIndexedType(object,name);
} else {
return BEAN_PROBE.getPropertyTypeForGetter(object, name);
}
}
/**
* Checks to see if an object has a writable property by a given name
*
* @param object The bean to check
* @param propertyName The property to check for
* @return True if the property exists and is writable
* @see com.ibatis.common.beans.Probe#hasWritableProperty(java.lang.Object, java.lang.String)
*/
public boolean hasWritableProperty(Object object, String propertyName) {
if (object instanceof org.w3c.dom.Document) {
return DOM_PROBE.hasWritableProperty(object, propertyName);
} else {
return BEAN_PROBE.hasWritableProperty(object, propertyName);
}
}
/**
* Checks to see if a bean has a readable property by a given name
*
* @param object The bean to check
* @param propertyName The property to check for
* @return True if the property exists and is readable
* @see com.ibatis.common.beans.Probe#hasReadableProperty(java.lang.Object, java.lang.String)
*/
public boolean hasReadableProperty(Object object, String propertyName) {
if (object instanceof org.w3c.dom.Document) {
return DOM_PROBE.hasReadableProperty(object, propertyName);
} else {
return BEAN_PROBE.hasReadableProperty(object, propertyName);
}
}
protected void setProperty(Object object, String property, Object value) {
if (object instanceof org.w3c.dom.Document) {
DOM_PROBE.setProperty(object, property, value);
} else {
BEAN_PROBE.setProperty(object, property, value);
}
}
protected Object getProperty(Object object, String property) {
if (object instanceof org.w3c.dom.Document) {
return DOM_PROBE.getProperty(object, property);
} else {
return BEAN_PROBE.getProperty(object, property);
}
}
private Class getClassPropertyTypeForGetter(Class type, String name) {
if (name.indexOf('.') > -1) {
StringTokenizer parser = new StringTokenizer(name, ".");
while (parser.hasMoreTokens()) {
name = parser.nextToken();
if (Map.class.isAssignableFrom(type)) {
type = Object.class;
break;
}
type = ClassInfo.getInstance(type).getGetterType(name);
}
} else {
type = ClassInfo.getInstance(type).getGetterType(name);
}
return type;
}
/**
* Returns the class that the setter expects to receive as a parameter when
* setting a property value.
*
* @param type The class to check
* @param name The name of the property
* @return The type of the property
*/
private Class getClassPropertyTypeForSetter(Class type, String name) {
if (name.indexOf('.') > -1) {
StringTokenizer parser = new StringTokenizer(name, ".");
while (parser.hasMoreTokens()) {
name = parser.nextToken();
if (Map.class.isAssignableFrom(type)) {
type = Object.class;
break;
}
type = ClassInfo.getInstance(type).getSetterType(name);
}
} else {
type = ClassInfo.getInstance(type).getSetterType(name);
}
return type;
}
}
ibatis/src/com/ibatis/common/beans/GetFieldInvoker.java 0000644 0001750 0001750 00000001046 11047641630 023356 0 ustar twerner twerner package com.ibatis.common.beans;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Field;
public class GetFieldInvoker implements Invoker {
private Field field;
private String name;
public GetFieldInvoker(Field field) {
this.field = field;
this.name = "(" + field.getName() + ")";
}
public Object invoke(Object target, Object[] args) throws IllegalAccessException, InvocationTargetException {
return field.get(target);
}
public String getName() {
return name;
}
}
ibatis/src/com/ibatis/common/beans/Invoker.java 0000644 0001750 0001750 00000000370 11047641630 021751 0 ustar twerner twerner package com.ibatis.common.beans;
import java.lang.reflect.InvocationTargetException;
public interface Invoker {
String getName();
Object invoke(Object target, Object[] args) throws IllegalAccessException, InvocationTargetException;
}
ibatis/src/com/ibatis/common/beans/MethodInvoker.java 0000644 0001750 0001750 00000001144 11047641630 023112 0 ustar twerner twerner package com.ibatis.common.beans;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
public class MethodInvoker implements Invoker {
private Method method;
private String name;
public MethodInvoker(Method method) {
this.method = method;
this.name = method.getName();
}
public Object invoke(Object target, Object[] args) throws IllegalAccessException, InvocationTargetException {
return method.invoke(target, args);
}
public Method getMethod() {
return method;
}
public String getName() {
return name;
}
}
ibatis/src/com/ibatis/common/beans/Probe.java 0000644 0001750 0001750 00000005010 11047641630 021377 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.beans;
/**
* A Probe is an object that is used to work with beans, DOM objects, or other
* objects.
*/
public interface Probe {
/**
* Gets an Object property from another object
*
* @param object - the object
* @param name - the property name
* @return The property value (as an Object)
*/
public Object getObject(Object object, String name);
/**
* Sets the value of a property on an object
*
* @param object - the object to change
* @param name - the name of the property to set
* @param value - the new value to set
*/
public void setObject(Object object, String name, Object value);
/**
* Returns the class that the setter expects when setting a property
*
* @param object - the object to check
* @param name - the name of the property
* @return The type of the property
*/
public Class getPropertyTypeForSetter(Object object, String name);
/**
* Returns the class that the getter will return when reading a property
*
* @param object - the object to check
* @param name - the name of the property
* @return The type of the property
*/
public Class getPropertyTypeForGetter(Object object, String name);
/**
* Checks to see if an object has a writable property by a given name
*
* @param object - the object to check
* @param propertyName - the property to check for
* @return True if the property exists and is writable
*/
public boolean hasWritableProperty(Object object, String propertyName);
/**
* Checks to see if an object has a readable property by a given name
*
* @param object - the object to check
* @param propertyName - the property to check for
* @return True if the property exists and is readable
*/
public boolean hasReadableProperty(Object object, String propertyName);
}
ibatis/src/com/ibatis/common/beans/ProbeException.java 0000644 0001750 0001750 00000003006 11047641630 023261 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.beans;
/**
* BeansException for use for by BeanProbe and StaticBeanProbe.
*/
public class ProbeException extends RuntimeException {
/**
* Default constructor
*/
public ProbeException() {
}
/**
* Constructor to set the message for the exception
*
* @param msg - the message for the exception
*/
public ProbeException(String msg) {
super(msg);
}
/**
* Constructor to create a nested exception
*
* @param cause - the reason the exception is being thrown
*/
public ProbeException(Throwable cause) {
super(cause);
}
/**
* Constructor to create a nested exception with a message
*
* @param msg - the message for the exception
* @param cause - the reason the exception is being thrown
*/
public ProbeException(String msg, Throwable cause) {
super(msg, cause);
}
}
ibatis/src/com/ibatis/common/beans/ProbeFactory.java 0000644 0001750 0001750 00000003024 11047641630 022732 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.beans;
/**
* An abstract factory for getting Probe implementations.
*/
public class ProbeFactory {
private static final Probe DOM = new DomProbe();
private static final Probe BEAN = new ComplexBeanProbe();
private static final Probe GENERIC = new GenericProbe();
/**
* Factory method for getting a Probe object
*
* @return An implementation of the Probe interface
*/
public static Probe getProbe() {
return GENERIC;
}
/**
* Factory method for getting a Probe object that is
* the best choice for the type of object supplied
* by the object parameter.
*
* @param object The object to get a Probe for
* @return An implementation of the Probe interface
*/
public static Probe getProbe(Object object) {
if (object instanceof org.w3c.dom.Document) {
return DOM;
} else {
return BEAN;
}
}
}
ibatis/src/com/ibatis/common/beans/SetFieldInvoker.java 0000644 0001750 0001750 00000001072 11047641630 023371 0 ustar twerner twerner package com.ibatis.common.beans;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Field;
public class SetFieldInvoker implements Invoker {
private Field field;
private String name;
public SetFieldInvoker(Field field) {
this.field = field;
this.name = "(" + field.getName() + ")";
}
public Object invoke(Object target, Object[] args) throws IllegalAccessException, InvocationTargetException {
field.set(target, args[0]);
return null;
}
public String getName() {
return name;
}
}
ibatis/src/com/ibatis/common/io/ 0000755 0001750 0001750 00000000000 11047641626 017015 5 ustar twerner twerner ibatis/src/com/ibatis/common/io/ReaderInputStream.java 0000644 0001750 0001750 00000010133 11047641626 023254 0 ustar twerner twerner /*
* Java Network Programming, Second Edition
* Merlin Hughes, Michael Shoffner, Derek Hamner
* Manning Publications Company; ISBN 188477749X
*
* http://nitric.com/jnp/
*
* Copyright (c) 1997-1999 Merlin Hughes, Michael Shoffner, Derek Hamner;
* all rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE ABOVE NAMED AUTHORS "AS IS" AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS, THEIR
* PUBLISHER OR THEIR EMPLOYERS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.ibatis.common.io;
import java.io.*;
/**
* An InputStream backed by a Reader
*/
public class ReaderInputStream extends InputStream {
protected Reader reader;
protected ByteArrayOutputStream byteArrayOut;
protected Writer writer;
protected char[] chars;
protected byte[] buffer;
protected int index, length;
/**
* Constructor to supply a Reader
*
* @param reader - the Reader used by the InputStream
*/
public ReaderInputStream(Reader reader) {
this.reader = reader;
byteArrayOut = new ByteArrayOutputStream();
writer = new OutputStreamWriter(byteArrayOut);
chars = new char[1024];
}
/**
* Constructor to supply a Reader and an encoding
*
* @param reader - the Reader used by the InputStream
* @param encoding - the encoding to use for the InputStream
* @throws UnsupportedEncodingException if the encoding is not supported
*/
public ReaderInputStream(Reader reader, String encoding) throws UnsupportedEncodingException {
this.reader = reader;
byteArrayOut = new ByteArrayOutputStream();
writer = new OutputStreamWriter(byteArrayOut, encoding);
chars = new char[1024];
}
/**
* @see java.io.InputStream#read()
*/
public int read() throws IOException {
if (index >= length)
fillBuffer();
if (index >= length)
return -1;
return 0xff & buffer[index++];
}
protected void fillBuffer() throws IOException {
if (length < 0)
return;
int numChars = reader.read(chars);
if (numChars < 0) {
length = -1;
} else {
byteArrayOut.reset();
writer.write(chars, 0, numChars);
writer.flush();
buffer = byteArrayOut.toByteArray();
length = buffer.length;
index = 0;
}
}
/**
* @see java.io.InputStream#read(byte[], int, int)
*/
public int read(byte[] data, int off, int len) throws IOException {
if (index >= length)
fillBuffer();
if (index >= length)
return -1;
int amount = Math.min(len, length - index);
System.arraycopy(buffer, index, data, off, amount);
index += amount;
return amount;
}
/**
* @see java.io.InputStream#available()
*/
public int available() throws IOException {
return (index < length) ? length - index :
((length >= 0) && reader.ready()) ? 1 : 0;
}
/**
* @see java.io.InputStream#close()
*/
public void close() throws IOException {
reader.close();
}
}
ibatis/src/com/ibatis/common/jdbc/ 0000755 0001750 0001750 00000000000 11047641626 017310 5 ustar twerner twerner ibatis/src/com/ibatis/common/jdbc/exception/ 0000755 0001750 0001750 00000000000 11047641626 021306 5 ustar twerner twerner ibatis/src/com/ibatis/common/jdbc/exception/NestedSQLException.java 0000644 0001750 0001750 00000006012 11047641626 025631 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.jdbc.exception;
import java.sql.SQLException;
/**
* Class to allow passing an Exception with the original SQLException
*/
public class NestedSQLException extends SQLException {
/**
* Constructor from java.sql.SQLException
* @see java.sql.SQLException
* @param msg - the message for the exception
*/
public NestedSQLException(String msg) {
super(msg);
}
/**
* Constructor from java.sql.SQLException
* @see java.sql.SQLException
* @param reason - the reason for the exception
* @param SQLState - the SQLState
*/
public NestedSQLException(String reason, String SQLState) {
super(reason, SQLState);
}
/**
* Constructor from java.sql.SQLException
* @see java.sql.SQLException
* @param reason - the reason for the exception
* @param SQLState - the SQLState
* @param vendorCode - a vendor supplied code to go w/ the message
*/
public NestedSQLException(String reason, String SQLState, int vendorCode) {
super(reason, SQLState, vendorCode);
}
/**
* Constructor from java.sql.SQLException with added nested exception
* @param msg - the message for the exception
* @param cause - the cause of the exception
*/
public NestedSQLException(String msg, Throwable cause) {
super(msg);
initCause(cause);
}
/**
* Constructor from java.sql.SQLException with added nested exception
* @see java.sql.SQLException
* @param reason - the reason for the exception
* @param SQLState - the SQLState
* @param cause - the cause of the exception
*/
public NestedSQLException(String reason, String SQLState, Throwable cause) {
super(reason, SQLState);
initCause(cause);
}
/**
* Constructor from java.sql.SQLException with added nested exception
* @param reason - the reason for the exception
* @param SQLState - the SQLState
* @param vendorCode - a vendor supplied code to go w/ the message
* @param cause - the cause of the exception
*/
public NestedSQLException(String reason, String SQLState, int vendorCode, Throwable cause) {
super(reason, SQLState, vendorCode);
initCause(cause);
}
/**
* Constructor from java.sql.SQLException with added nested exception
* @param cause - the cause of the exception
*/
public NestedSQLException(Throwable cause) {
super();
initCause(cause);
}
}
ibatis/src/com/ibatis/common/jdbc/exception/RuntimeSQLException.java 0000644 0001750 0001750 00000005263 11047641626 026041 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.jdbc.exception;
import java.sql.SQLException;
/**
* Unchecked exception to allow passing an Exception with the original SQLException
*/
public class RuntimeSQLException extends RuntimeException {
/**
* Default constructor
*/
public RuntimeSQLException() {
}
/**
* Constructor to pass along a message
* @param msg - the message
*/
public RuntimeSQLException(String msg) {
super(msg);
}
/**
* Constructor to pass along another exception
* @param sqlException - the exception
*/
public RuntimeSQLException(SQLException sqlException) {
super(sqlException);
}
/**
* Constructor to pass along a message and an exception
* @param msg - the message
* @param sqlException - the exception
*/
public RuntimeSQLException(String msg, SQLException sqlException) {
super(msg, sqlException);
}
/**
* Getter for the SQL State
* @return - the state
*/
public String getSQLState() {
Throwable cause = getCause();
if (cause instanceof SQLException) {
return ((SQLException) cause).getSQLState();
} else {
return null;
}
}
/**
* Getter for the error code
* @return - the error code
*/
public int getErrorCode() {
Throwable cause = getCause();
if (cause instanceof SQLException) {
return ((SQLException) cause).getErrorCode();
} else {
return -1;
}
}
/**
* Get the next exception in the chain
* @return - the next exception
*/
public SQLException getNextException() {
Throwable cause = getCause();
if (cause instanceof SQLException) {
return ((SQLException) cause).getNextException();
} else {
return null;
}
}
/**
* Set the next exception in the chain
* @param ex - the next exception
*/
public synchronized void setNextException(SQLException ex) {
Throwable cause = getCause();
if (cause instanceof SQLException) {
((SQLException) cause).setNextException(ex);
}
}
}
ibatis/src/com/ibatis/common/jdbc/logging/ 0000755 0001750 0001750 00000000000 11047641626 020736 5 ustar twerner twerner ibatis/src/com/ibatis/common/jdbc/logging/BaseLogProxy.java 0000644 0001750 0001750 00000007655 11047641626 024174 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.jdbc.logging;
import java.util.*;
/**
* Base class for proxies to do logging
*/
public class BaseLogProxy {
private static int nextId = 100000;
protected static final Set SET_METHODS = new HashSet();
protected static final Set GET_METHODS = new HashSet();
protected static final Set EXECUTE_METHODS = new HashSet();
private Map columnMap = new HashMap();
private List columnNames = new ArrayList();
private List columnValues = new ArrayList();
protected int id;
/**
* Default constructor
*/
public BaseLogProxy() {
id = getNextId();
}
static {
SET_METHODS.add("setString");
SET_METHODS.add("setInt");
SET_METHODS.add("setByte");
SET_METHODS.add("setShort");
SET_METHODS.add("setLong");
SET_METHODS.add("setDouble");
SET_METHODS.add("setFloat");
SET_METHODS.add("setTimestamp");
SET_METHODS.add("setDate");
SET_METHODS.add("setTime");
SET_METHODS.add("setArray");
SET_METHODS.add("setBigDecimal");
SET_METHODS.add("setAsciiStream");
SET_METHODS.add("setBinaryStream");
SET_METHODS.add("setBlob");
SET_METHODS.add("setBoolean");
SET_METHODS.add("setBytes");
SET_METHODS.add("setCharacterStream");
SET_METHODS.add("setClob");
SET_METHODS.add("setObject");
SET_METHODS.add("setNull");
GET_METHODS.add("getString");
GET_METHODS.add("getInt");
GET_METHODS.add("getByte");
GET_METHODS.add("getShort");
GET_METHODS.add("getLong");
GET_METHODS.add("getDouble");
GET_METHODS.add("getFloat");
GET_METHODS.add("getTimestamp");
GET_METHODS.add("getDate");
GET_METHODS.add("getTime");
GET_METHODS.add("getArray");
GET_METHODS.add("getBigDecimal");
GET_METHODS.add("getAsciiStream");
GET_METHODS.add("getBinaryStream");
GET_METHODS.add("getBlob");
GET_METHODS.add("getBoolean");
GET_METHODS.add("getBytes");
GET_METHODS.add("getCharacterStream");
GET_METHODS.add("getClob");
GET_METHODS.add("getObject");
GET_METHODS.add("getNull");
EXECUTE_METHODS.add("execute");
EXECUTE_METHODS.add("executeUpdate");
EXECUTE_METHODS.add("executeQuery");
}
protected void setColumn(Object key, Object value) {
columnMap.put(key, value);
columnNames.add(key);
columnValues.add(value);
}
protected Object getColumn(Object key) {
return columnMap.get(key);
}
protected String getValueString() {
return columnValues.toString();
}
protected String getTypeString() {
List typeList = new ArrayList(columnValues.size());
for (int i = 0; i < columnValues.size(); i++) {
Object value = columnValues.get(i);
if (value == null) {
typeList.add("null");
} else {
typeList.add(value.getClass().getName());
}
}
return typeList.toString();
}
protected String getColumnString() {
return columnNames.toString();
}
protected void clearColumnInfo() {
columnMap.clear();
columnNames.clear();
columnValues.clear();
}
protected String removeBreakingWhitespace(String original) {
return original.replace('\n', ' ').replace('\r', ' ').replace('\t', ' ');
}
protected synchronized static int getNextId() {
return nextId++;
}
}
ibatis/src/com/ibatis/common/jdbc/logging/ConnectionLogProxy.java 0000644 0001750 0001750 00000006537 11047641626 025417 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.jdbc.logging;
import com.ibatis.common.beans.ClassInfo;
import com.ibatis.common.logging.Log;
import com.ibatis.common.logging.LogFactory;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.Statement;
/**
* Connection proxy to add logging
*/
public class ConnectionLogProxy extends BaseLogProxy implements InvocationHandler {
private static final Log log = LogFactory.getLog(Connection.class);
private Connection connection;
private ConnectionLogProxy(Connection conn) {
super();
this.connection = conn;
if (log.isDebugEnabled()) {
log.debug("{conn-" + id + "} Connection");
}
}
public Object invoke(Object proxy, Method method, Object[] params)
throws Throwable {
try {
if ("prepareStatement".equals(method.getName())) {
if (log.isDebugEnabled()) {
log.debug("{conn-" + id + "} Preparing Statement: " + removeBreakingWhitespace((String) params[0]));
}
PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
stmt = PreparedStatementLogProxy.newInstance(stmt, (String) params[0]);
return stmt;
} else if ("prepareCall".equals(method.getName())) {
if (log.isDebugEnabled()) {
log.debug("{conn-" + id + "} Preparing Call: " + removeBreakingWhitespace((String) params[0]));
}
PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
stmt = PreparedStatementLogProxy.newInstance(stmt, (String) params[0]);
return stmt;
} else if ("createStatement".equals(method.getName())) {
Statement stmt = (Statement) method.invoke(connection, params);
stmt = StatementLogProxy.newInstance(stmt);
return stmt;
} else {
return method.invoke(connection, params);
}
} catch (Throwable t) {
Throwable t1 = ClassInfo.unwrapThrowable(t);
log.error("Error calling Connection." + method.getName() + ':', t1);
throw t1;
}
}
/**
* Creates a logging version of a connection
* @param conn - the original connection
* @return - the connection with logging
*/
public static Connection newInstance(Connection conn) {
InvocationHandler handler = new ConnectionLogProxy(conn);
ClassLoader cl = Connection.class.getClassLoader();
return (Connection) Proxy.newProxyInstance(cl, new Class[]{Connection.class}, handler);
}
/**
* return the wrapped connection
*
* @return the connection
*/
public Connection getConnection() {
return connection;
}
}
ibatis/src/com/ibatis/common/jdbc/logging/PreparedStatementLogProxy.java 0000644 0001750 0001750 00000007651 11047641626 026745 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.jdbc.logging;
import com.ibatis.common.beans.ClassInfo;
import com.ibatis.common.logging.Log;
import com.ibatis.common.logging.LogFactory;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/**
* PreparedStatement proxy to add logging
*/
public class PreparedStatementLogProxy extends BaseLogProxy implements InvocationHandler {
private static final Log log = LogFactory.getLog(PreparedStatement.class);
private PreparedStatement statement;
private String sql;
private PreparedStatementLogProxy(PreparedStatement stmt, String sql) {
this.statement = stmt;
this.sql = sql;
}
public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
try {
if (EXECUTE_METHODS.contains(method.getName())) {
if (log.isDebugEnabled()) {
log.debug("{pstm-" + id + "} Executing Statement: " + removeBreakingWhitespace(sql));
log.debug("{pstm-" + id + "} Parameters: " + getValueString());
log.debug("{pstm-" + id + "} Types: " + getTypeString());
}
clearColumnInfo();
if ("executeQuery".equals(method.getName())) {
ResultSet rs = (ResultSet) method.invoke(statement, params);
if ( rs != null ) {
return ResultSetLogProxy.newInstance(rs);
}
else {
return null;
}
} else {
return method.invoke(statement, params);
}
} else if (SET_METHODS.contains(method.getName())) {
if ("setNull".equals(method.getName())) {
setColumn(params[0], null);
} else {
setColumn(params[0], params[1]);
}
return method.invoke(statement, params);
} else if ("getResultSet".equals(method.getName())) {
ResultSet rs = (ResultSet) method.invoke(statement, params);
if ( rs != null ) {
return ResultSetLogProxy.newInstance(rs);
}
else {
return null;
}
} else if ("equals".equals(method.getName())) {
Object ps = params[0];
if (ps instanceof Proxy) {
return new Boolean(proxy == ps);
}
return new Boolean(false);
} else if ("hashCode".equals(method.getName())) {
return new Integer(proxy.hashCode());
} else {
return method.invoke(statement, params);
}
} catch (Throwable t) {
throw ClassInfo.unwrapThrowable(t);
}
}
/**
* Creates a logging version of a PreparedStatement
* @param stmt - the statement
* @param sql - the sql statement
* @return - the proxy
*/
public static PreparedStatement newInstance(PreparedStatement stmt, String sql) {
InvocationHandler handler = new PreparedStatementLogProxy(stmt, sql);
ClassLoader cl = PreparedStatement.class.getClassLoader();
return (PreparedStatement) Proxy.newProxyInstance(cl, new Class[]{PreparedStatement.class, CallableStatement.class}, handler);
}
/**
* Return the wrapped prepared statement
* @return the PreparedStatement
*/
public PreparedStatement getPreparedStatement() {
return statement;
}
}
ibatis/src/com/ibatis/common/jdbc/logging/ResultSetLogProxy.java 0000644 0001750 0001750 00000005570 11047641626 025246 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.jdbc.logging;
import com.ibatis.common.beans.ClassInfo;
import com.ibatis.common.logging.Log;
import com.ibatis.common.logging.LogFactory;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.ResultSet;
/**
* ResultSet proxy to add logging
*/
public class ResultSetLogProxy extends BaseLogProxy implements InvocationHandler {
private static final Log log = LogFactory.getLog(ResultSet.class);
boolean first = true;
private ResultSet rs;
private ResultSetLogProxy(ResultSet rs) {
super();
this.rs = rs;
if (log.isDebugEnabled()) {
log.debug("{rset-" + id + "} ResultSet");
}
}
public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
try {
Object o = method.invoke(rs, params);
if (GET_METHODS.contains(method.getName())) {
if (params[0] instanceof String) {
if(rs.wasNull()) {
setColumn(params[0], null);
} else {
setColumn(params[0], o);
}
}
} else if ("next".equals(method.getName()) || "close".equals(method.getName())) {
String s = getValueString();
if (!"[]".equals(s)) {
if (first) {
first = false;
if (log.isDebugEnabled()) {
log.debug("{rset-" + id + "} Header: " + getColumnString());
}
}
if (log.isDebugEnabled()) {
log.debug("{rset-" + id + "} Result: " + s);
}
}
clearColumnInfo();
}
return o;
} catch (Throwable t) {
throw ClassInfo.unwrapThrowable(t);
}
}
/**
* Creates a logging version of a ResultSet
*
* @param rs - the ResultSet to proxy
* @return - the ResultSet with logging
*/
public static ResultSet newInstance(ResultSet rs) {
InvocationHandler handler = new ResultSetLogProxy(rs);
ClassLoader cl = ResultSet.class.getClassLoader();
return (ResultSet) Proxy.newProxyInstance(cl, new Class[]{ResultSet.class}, handler);
}
/**
* Get the wrapped result set
* @return the resultSet
*/
public ResultSet getRs() {
return rs;
}
}
ibatis/src/com/ibatis/common/jdbc/logging/StatementLogProxy.java 0000644 0001750 0001750 00000006310 11047641626 025251 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.jdbc.logging;
import com.ibatis.common.beans.ClassInfo;
import com.ibatis.common.logging.Log;
import com.ibatis.common.logging.LogFactory;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.ResultSet;
import java.sql.Statement;
/**
* Statement proxy to add logging
*/
public class StatementLogProxy extends BaseLogProxy implements InvocationHandler {
private static final Log log = LogFactory.getLog(Statement.class);
private Statement statement;
private StatementLogProxy(Statement stmt) {
super();
this.statement = stmt;
}
public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
try {
if (EXECUTE_METHODS.contains(method.getName())) {
if (log.isDebugEnabled()) {
log.debug("{stmt-" + id + "} Statement: " + removeBreakingWhitespace((String) params[0]));
}
if ("executeQuery".equals(method.getName())) {
ResultSet rs = (ResultSet) method.invoke(statement, params);
if ( rs != null ) {
return ResultSetLogProxy.newInstance(rs);
}
else {
return null;
}
} else {
return method.invoke(statement, params);
}
} else if ("getResultSet".equals(method.getName())) {
ResultSet rs = (ResultSet) method.invoke(statement, params);
if ( rs != null ) {
return ResultSetLogProxy.newInstance(rs);
}
else {
return null;
}
} else if ("equals".equals(method.getName())) {
Object ps = params[0];
if (ps instanceof Proxy) {
return new Boolean(proxy == ps);
}
return new Boolean(false);
} else if ("hashCode".equals(method.getName())) {
return new Integer(proxy.hashCode());
} else {
return method.invoke(statement, params);
}
} catch (Throwable t) {
throw ClassInfo.unwrapThrowable(t);
}
}
/**
* Creates a logging version of a Statement
* @param stmt - the statement
* @return - the proxy
*/
public static Statement newInstance(Statement stmt) {
InvocationHandler handler = new StatementLogProxy(stmt);
ClassLoader cl = Statement.class.getClassLoader();
return (Statement) Proxy.newProxyInstance(cl, new Class[]{Statement.class}, handler);
}
/**
* return the wrapped statement
*
* @return the statement
*/
public Statement getStatement() {
return statement;
}
}
ibatis/src/com/ibatis/common/jdbc/DbcpConfiguration.java 0000644 0001750 0001750 00000012041 11047641626 023551 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.jdbc;
import com.ibatis.common.beans.Probe;
import com.ibatis.common.beans.ProbeFactory;
import org.apache.commons.dbcp.BasicDataSource;
import javax.sql.DataSource;
import java.util.Iterator;
import java.util.Map;
/**
* Wrapper class to simplify use of DBCP
*/
public class DbcpConfiguration {
private static final Probe PROBE = ProbeFactory.getProbe();
private static final String ADD_DRIVER_PROPS_PREFIX = "Driver.";
private static final int ADD_DRIVER_PROPS_PREFIX_LENGTH = ADD_DRIVER_PROPS_PREFIX.length();
private DataSource dataSource;
/**
* Constructor to supply a map of properties
*
* @param properties - the map of configuration properties
*/
public DbcpConfiguration(Map properties) {
try {
dataSource = legacyDbcpConfiguration(properties);
if (dataSource == null) {
dataSource = newDbcpConfiguration(properties);
}
} catch (Exception e) {
throw new RuntimeException("Error initializing DbcpDataSourceFactory. Cause: " + e, e);
}
}
/**
* Getter for DataSource
*
* @return The DataSource
*/
public DataSource getDataSource() {
return dataSource;
}
private BasicDataSource newDbcpConfiguration(Map map) {
BasicDataSource basicDataSource = new BasicDataSource();
Iterator props = map.keySet().iterator();
while (props.hasNext()) {
String propertyName = (String) props.next();
if (propertyName.startsWith(ADD_DRIVER_PROPS_PREFIX)) {
String value = (String) map.get(propertyName);
basicDataSource.addConnectionProperty(propertyName.substring(ADD_DRIVER_PROPS_PREFIX_LENGTH), value);
} else if (PROBE.hasWritableProperty(basicDataSource, propertyName)) {
String value = (String) map.get(propertyName);
Object convertedValue = convertValue(basicDataSource, propertyName, value);
PROBE.setObject(basicDataSource, propertyName, convertedValue);
}
}
return basicDataSource;
}
private Object convertValue(Object object, String propertyName, String value) {
Object convertedValue = value;
Class targetType = PROBE.getPropertyTypeForSetter(object, propertyName);
if (targetType == Integer.class || targetType == int.class) {
convertedValue = Integer.valueOf(value);
} else if (targetType == Long.class || targetType == long.class) {
convertedValue = Long.valueOf(value);
} else if (targetType == Boolean.class || targetType == boolean.class) {
convertedValue = Boolean.valueOf(value);
}
return convertedValue;
}
private BasicDataSource legacyDbcpConfiguration(Map map) {
BasicDataSource basicDataSource = null;
if (map.containsKey("JDBC.Driver")) {
basicDataSource = new BasicDataSource();
String driver = (String) map.get("JDBC.Driver");
String url = (String) map.get("JDBC.ConnectionURL");
String username = (String) map.get("JDBC.Username");
String password = (String) map.get("JDBC.Password");
String validationQuery = (String) map.get("Pool.ValidationQuery");
String maxActive = (String) map.get("Pool.MaximumActiveConnections");
String maxIdle = (String) map.get("Pool.MaximumIdleConnections");
String maxWait = (String) map.get("Pool.MaximumWait");
basicDataSource.setUrl(url);
basicDataSource.setDriverClassName(driver);
basicDataSource.setUsername(username);
basicDataSource.setPassword(password);
if (notEmpty(validationQuery)) {
basicDataSource.setValidationQuery(validationQuery);
}
if (notEmpty(maxActive)) {
basicDataSource.setMaxActive(Integer.parseInt(maxActive));
}
if (notEmpty(maxIdle)) {
basicDataSource.setMaxIdle(Integer.parseInt(maxIdle));
}
if (notEmpty(maxWait)) {
basicDataSource.setMaxWait(Integer.parseInt(maxWait));
}
Iterator props = map.keySet().iterator();
while (props.hasNext()) {
String propertyName = (String) props.next();
if (propertyName.startsWith(ADD_DRIVER_PROPS_PREFIX)) {
String value = (String) map.get(propertyName);
basicDataSource.addConnectionProperty(propertyName.substring(ADD_DRIVER_PROPS_PREFIX_LENGTH), value);
}
}
}
return basicDataSource;
}
private boolean notEmpty(String s) {
return s != null && s.length() > 0;
}
}
ibatis/src/com/ibatis/common/jdbc/ScriptRunner.java 0000644 0001750 0001750 00000016765 11047641626 022630 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.jdbc;
import com.ibatis.common.resources.Resources;
import java.io.IOException;
import java.io.LineNumberReader;
import java.io.PrintWriter;
import java.io.Reader;
import java.sql.*;
/**
* Tool to run database scripts
*/
public class ScriptRunner {
private static final String DEFAULT_DELIMITER = ";";
private Connection connection;
private String driver;
private String url;
private String username;
private String password;
private boolean stopOnError;
private boolean autoCommit;
private PrintWriter logWriter = new PrintWriter(System.out);
private PrintWriter errorLogWriter = new PrintWriter(System.err);
private String delimiter = DEFAULT_DELIMITER;
private boolean fullLineDelimiter = false;
/**
* Default constructor
*/
public ScriptRunner(Connection connection, boolean autoCommit, boolean stopOnError) {
this.connection = connection;
this.autoCommit = autoCommit;
this.stopOnError = stopOnError;
}
public void setDelimiter(String delimiter, boolean fullLineDelimiter) {
this.delimiter = delimiter;
this.fullLineDelimiter = fullLineDelimiter;
}
public ScriptRunner(String driver, String url, String username, String password, boolean autoCommit, boolean stopOnError) {
this.driver = driver;
this.url = url;
this.username = username;
this.password = password;
this.autoCommit = autoCommit;
this.stopOnError = stopOnError;
}
/**
* Setter for logWriter property
*
* @param logWriter - the new value of the logWriter property
*/
public void setLogWriter(PrintWriter logWriter) {
this.logWriter = logWriter;
}
/**
* Setter for errorLogWriter property
*
* @param errorLogWriter - the new value of the errorLogWriter property
*/
public void setErrorLogWriter(PrintWriter errorLogWriter) {
this.errorLogWriter = errorLogWriter;
}
/**
* Runs an SQL script (read in using the Reader parameter)
*
* @param reader - the source of the script
*/
public void runScript(Reader reader) throws IOException, SQLException{
try {
if (connection == null) {
DriverManager.registerDriver((Driver) Resources.instantiate(driver));
Connection conn = DriverManager.getConnection(url, username, password);
try {
if (conn.getAutoCommit() != autoCommit) {
conn.setAutoCommit(autoCommit);
}
runScript(conn, reader);
} finally {
conn.close();
}
} else {
boolean originalAutoCommit = connection.getAutoCommit();
try {
if (originalAutoCommit != this.autoCommit) {
connection.setAutoCommit(this.autoCommit);
}
runScript(connection, reader);
} finally {
connection.setAutoCommit(originalAutoCommit);
}
}
} catch (IOException e) {
throw e;
} catch (SQLException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException("Error running script. Cause: " + e, e);
}
}
/**
* Runs an SQL script (read in using the Reader parameter) using the connection passed in
*
* @param conn - the connection to use for the script
* @param reader - the source of the script
* @throws SQLException if any SQL errors occur
* @throws IOException if there is an error reading from the Reader
*/
private void runScript(Connection conn, Reader reader)
throws IOException, SQLException {
StringBuffer command = null;
try {
LineNumberReader lineReader = new LineNumberReader(reader);
String line = null;
while ((line = lineReader.readLine()) != null) {
if (command == null) {
command = new StringBuffer();
}
String trimmedLine = line.trim();
if (trimmedLine.startsWith("--")) {
println(trimmedLine);
} else if (trimmedLine.length() < 1 || trimmedLine.startsWith("//")) {
//Do nothing
} else if (trimmedLine.length() < 1 || trimmedLine.startsWith("--")) {
//Do nothing
} else if (!fullLineDelimiter && trimmedLine.endsWith(getDelimiter())
|| fullLineDelimiter && trimmedLine.equals(getDelimiter())) {
command.append(line.substring(0, line.lastIndexOf(getDelimiter())));
command.append(" ");
Statement statement = conn.createStatement();
println(command);
boolean hasResults = false;
if (stopOnError) {
hasResults = statement.execute(command.toString());
} else {
try {
statement.execute(command.toString());
} catch (SQLException e) {
e.fillInStackTrace();
printlnError("Error executing: " + command);
printlnError(e);
}
}
if (autoCommit && !conn.getAutoCommit()) {
conn.commit();
}
ResultSet rs = statement.getResultSet();
if (hasResults && rs != null) {
ResultSetMetaData md = rs.getMetaData();
int cols = md.getColumnCount();
for (int i = 0; i < cols; i++) {
String name = md.getColumnLabel(i);
print(name + "\t");
}
println("");
while (rs.next()) {
for (int i = 0; i < cols; i++) {
String value = rs.getString(i);
print(value + "\t");
}
println("");
}
}
command = null;
try {
statement.close();
} catch (Exception e) {
// Ignore to workaround a bug in Jakarta DBCP
}
Thread.yield();
} else {
command.append(line);
command.append(" ");
}
}
if (!autoCommit) {
conn.commit();
}
} catch (SQLException e) {
e.fillInStackTrace();
printlnError("Error executing: " + command);
printlnError(e);
throw e;
} catch (IOException e) {
e.fillInStackTrace();
printlnError("Error executing: " + command);
printlnError(e);
throw e;
} finally {
conn.rollback();
flush();
}
}
private String getDelimiter() {
return delimiter;
}
private void print(Object o) {
if (logWriter != null) {
System.out.print(o);
}
}
private void println(Object o) {
if (logWriter != null) {
logWriter.println(o);
}
}
private void printlnError(Object o) {
if (errorLogWriter != null) {
errorLogWriter.println(o);
}
}
private void flush() {
if (logWriter != null) {
logWriter.flush();
}
if (errorLogWriter != null) {
errorLogWriter.flush();
}
}
}
ibatis/src/com/ibatis/common/jdbc/SimpleDataSource.java 0000644 0001750 0001750 00000115306 11047641626 023365 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.jdbc;
import com.ibatis.common.beans.ClassInfo;
import com.ibatis.common.resources.Resources;
import com.ibatis.common.logging.LogFactory;
import com.ibatis.common.logging.Log;
import javax.sql.DataSource;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.*;
import java.util.*;
/**
* This is a simple, synchronous, thread-safe database connection pool.
*
* REQUIRED PROPERTIES
* -------------------
* JDBC.Driver
* JDBC.ConnectionURL
* JDBC.Username
* JDBC.Password
*
* Pool.MaximumActiveConnections
* Pool.MaximumIdleConnections
* Pool.MaximumCheckoutTime
* Pool.TimeToWait
* Pool.PingQuery
* Pool.PingEnabled
* Pool.PingConnectionsOlderThan
* Pool.PingConnectionsNotUsedFor
* Pool.QuietMode
*/
public class SimpleDataSource implements DataSource {
private static final Log log = LogFactory.getLog(SimpleDataSource.class);
// Required Properties
private static final String PROP_JDBC_DRIVER = "JDBC.Driver";
private static final String PROP_JDBC_URL = "JDBC.ConnectionURL";
private static final String PROP_JDBC_USERNAME = "JDBC.Username";
private static final String PROP_JDBC_PASSWORD = "JDBC.Password";
private static final String PROP_JDBC_DEFAULT_AUTOCOMMIT = "JDBC.DefaultAutoCommit";
// Optional Properties
private static final String PROP_POOL_MAX_ACTIVE_CONN = "Pool.MaximumActiveConnections";
private static final String PROP_POOL_MAX_IDLE_CONN = "Pool.MaximumIdleConnections";
private static final String PROP_POOL_MAX_CHECKOUT_TIME = "Pool.MaximumCheckoutTime";
private static final String PROP_POOL_TIME_TO_WAIT = "Pool.TimeToWait";
private static final String PROP_POOL_PING_QUERY = "Pool.PingQuery";
private static final String PROP_POOL_PING_CONN_OLDER_THAN = "Pool.PingConnectionsOlderThan";
private static final String PROP_POOL_PING_ENABLED = "Pool.PingEnabled";
private static final String PROP_POOL_PING_CONN_NOT_USED_FOR = "Pool.PingConnectionsNotUsedFor";
private int expectedConnectionTypeCode;
// Additional Driver Properties prefix
private static final String ADD_DRIVER_PROPS_PREFIX = "Driver.";
private static final int ADD_DRIVER_PROPS_PREFIX_LENGTH = ADD_DRIVER_PROPS_PREFIX.length();
// ----- BEGIN: FIELDS LOCKED BY POOL_LOCK -----
private final Object POOL_LOCK = new Object();
private List idleConnections = new ArrayList();
private List activeConnections = new ArrayList();
private long requestCount = 0;
private long accumulatedRequestTime = 0;
private long accumulatedCheckoutTime = 0;
private long claimedOverdueConnectionCount = 0;
private long accumulatedCheckoutTimeOfOverdueConnections = 0;
private long accumulatedWaitTime = 0;
private long hadToWaitCount = 0;
private long badConnectionCount = 0;
// ----- END: FIELDS LOCKED BY POOL_LOCK -----
// ----- BEGIN: PROPERTY FIELDS FOR CONFIGURATION -----
private String jdbcDriver;
private String jdbcUrl;
private String jdbcUsername;
private String jdbcPassword;
private boolean jdbcDefaultAutoCommit;
private Properties driverProps;
private boolean useDriverProps;
private int poolMaximumActiveConnections;
private int poolMaximumIdleConnections;
private int poolMaximumCheckoutTime;
private int poolTimeToWait;
private String poolPingQuery;
private boolean poolPingEnabled;
private int poolPingConnectionsOlderThan;
private int poolPingConnectionsNotUsedFor;
//----- END: PROPERTY FIELDS FOR CONFIGURATION -----
/**
* Constructor to allow passing in a map of properties for configuration
*
* @param props - the configuration parameters
*/
public SimpleDataSource(Map props) {
initialize(props);
}
private void initialize(Map props) {
try {
String prop_pool_ping_query = null;
if (props == null) {
throw new RuntimeException("SimpleDataSource: The properties map passed to the initializer was null.");
}
if (!(props.containsKey(PROP_JDBC_DRIVER)
&& props.containsKey(PROP_JDBC_URL)
&& props.containsKey(PROP_JDBC_USERNAME)
&& props.containsKey(PROP_JDBC_PASSWORD))) {
throw new RuntimeException("SimpleDataSource: Some properties were not set.");
} else {
jdbcDriver = (String) props.get(PROP_JDBC_DRIVER);
jdbcUrl = (String) props.get(PROP_JDBC_URL);
jdbcUsername = (String) props.get(PROP_JDBC_USERNAME);
jdbcPassword = (String) props.get(PROP_JDBC_PASSWORD);
poolMaximumActiveConnections =
props.containsKey(PROP_POOL_MAX_ACTIVE_CONN)
? Integer.parseInt((String) props.get(PROP_POOL_MAX_ACTIVE_CONN))
: 10;
poolMaximumIdleConnections =
props.containsKey(PROP_POOL_MAX_IDLE_CONN)
? Integer.parseInt((String) props.get(PROP_POOL_MAX_IDLE_CONN))
: 5;
poolMaximumCheckoutTime =
props.containsKey(PROP_POOL_MAX_CHECKOUT_TIME)
? Integer.parseInt((String) props.get(PROP_POOL_MAX_CHECKOUT_TIME))
: 20000;
poolTimeToWait =
props.containsKey(PROP_POOL_TIME_TO_WAIT)
? Integer.parseInt((String) props.get(PROP_POOL_TIME_TO_WAIT))
: 20000;
poolPingEnabled =
props.containsKey(PROP_POOL_PING_ENABLED)
&& Boolean.valueOf((String) props.get(PROP_POOL_PING_ENABLED)).booleanValue();
prop_pool_ping_query = (String) props.get(PROP_POOL_PING_QUERY);
poolPingQuery =
props.containsKey(PROP_POOL_PING_QUERY)
? prop_pool_ping_query
: "NO PING QUERY SET";
poolPingConnectionsOlderThan =
props.containsKey(PROP_POOL_PING_CONN_OLDER_THAN)
? Integer.parseInt((String) props.get(PROP_POOL_PING_CONN_OLDER_THAN))
: 0;
poolPingConnectionsNotUsedFor =
props.containsKey(PROP_POOL_PING_CONN_NOT_USED_FOR)
? Integer.parseInt((String) props.get(PROP_POOL_PING_CONN_NOT_USED_FOR))
: 0;
jdbcDefaultAutoCommit =
props.containsKey(PROP_JDBC_DEFAULT_AUTOCOMMIT)
&& Boolean.valueOf((String) props.get(PROP_JDBC_DEFAULT_AUTOCOMMIT)).booleanValue();
useDriverProps = false;
Iterator propIter = props.keySet().iterator();
driverProps = new Properties();
driverProps.put("user", jdbcUsername);
driverProps.put("password", jdbcPassword);
while (propIter.hasNext()) {
String name = (String) propIter.next();
String value = (String) props.get(name);
if (name.startsWith(ADD_DRIVER_PROPS_PREFIX)) {
driverProps.put(name.substring(ADD_DRIVER_PROPS_PREFIX_LENGTH), value);
useDriverProps = true;
}
}
expectedConnectionTypeCode = assembleConnectionTypeCode(jdbcUrl, jdbcUsername, jdbcPassword);
Resources.instantiate(jdbcDriver);
if ( poolPingEnabled && (!props.containsKey(PROP_POOL_PING_QUERY) ||
prop_pool_ping_query.trim().length() == 0) ) {
throw new RuntimeException("SimpleDataSource: property '" + PROP_POOL_PING_ENABLED + "' is true, but property '" +
PROP_POOL_PING_QUERY + "' is not set correctly.");
}
}
} catch (Exception e) {
log.error("SimpleDataSource: Error while loading properties. Cause: " + e.toString(), e);
throw new RuntimeException("SimpleDataSource: Error while loading properties. Cause: " + e, e);
}
}
private int assembleConnectionTypeCode(String url, String username, String password) {
return ("" + url + username + password).hashCode();
}
/**
* @see javax.sql.DataSource#getConnection()
*/
public Connection getConnection() throws SQLException {
return popConnection(jdbcUsername, jdbcPassword).getProxyConnection();
}
/**
* @see javax.sql.DataSource#getConnection(java.lang.String, java.lang.String)
*/
public Connection getConnection(String username, String password) throws SQLException {
return popConnection(username, password).getProxyConnection();
}
/**
* @see javax.sql.DataSource#setLoginTimeout(int)
*/
public void setLoginTimeout(int loginTimeout) throws SQLException {
DriverManager.setLoginTimeout(loginTimeout);
}
/**
* @see javax.sql.DataSource#getLoginTimeout()
*/
public int getLoginTimeout() throws SQLException {
return DriverManager.getLoginTimeout();
}
/**
* @see javax.sql.DataSource#setLogWriter(java.io.PrintWriter)
*/
public void setLogWriter(PrintWriter logWriter) throws SQLException {
DriverManager.setLogWriter(logWriter);
}
/**
* @see javax.sql.DataSource#getLogWriter()
*/
public PrintWriter getLogWriter() throws SQLException {
return DriverManager.getLogWriter();
}
/**
* If a connection has not been used in this many milliseconds, ping the
* database to make sure the connection is still good.
*
* @return the number of milliseconds of inactivity that will trigger a ping
*/
public int getPoolPingConnectionsNotUsedFor() {
return poolPingConnectionsNotUsedFor;
}
/**
* Getter for the name of the JDBC driver class used
* @return The name of the class
*/
public String getJdbcDriver() {
return jdbcDriver;
}
/**
* Getter of the JDBC URL used
* @return The JDBC URL
*/
public String getJdbcUrl() {
return jdbcUrl;
}
/**
* Getter for the JDBC user name used
* @return The user name
*/
public String getJdbcUsername() {
return jdbcUsername;
}
/**
* Getter for the JDBC password used
* @return The password
*/
public String getJdbcPassword() {
return jdbcPassword;
}
/**
* Getter for the maximum number of active connections
* @return The maximum number of active connections
*/
public int getPoolMaximumActiveConnections() {
return poolMaximumActiveConnections;
}
/**
* Getter for the maximum number of idle connections
* @return The maximum number of idle connections
*/
public int getPoolMaximumIdleConnections() {
return poolMaximumIdleConnections;
}
/**
* Getter for the maximum time a connection can be used before it *may* be
* given away again.
* @return The maximum time
*/
public int getPoolMaximumCheckoutTime() {
return poolMaximumCheckoutTime;
}
/**
* Getter for the time to wait before retrying to get a connection
* @return The time to wait
*/
public int getPoolTimeToWait() {
return poolTimeToWait;
}
/**
* Getter for the query to be used to check a connection
* @return The query
*/
public String getPoolPingQuery() {
return poolPingQuery;
}
/**
* Getter to tell if we should use the ping query
* @return True if we need to check a connection before using it
*/
public boolean isPoolPingEnabled() {
return poolPingEnabled;
}
/**
* Getter for the age of connections that should be pinged before using
* @return The age
*/
public int getPoolPingConnectionsOlderThan() {
return poolPingConnectionsOlderThan;
}
private int getExpectedConnectionTypeCode() {
return expectedConnectionTypeCode;
}
/**
* Getter for the number of connection requests made
* @return The number of connection requests made
*/
public long getRequestCount() {
synchronized (POOL_LOCK) {
return requestCount;
}
}
/**
* Getter for the average time required to get a connection to the database
* @return The average time
*/
public long getAverageRequestTime() {
synchronized (POOL_LOCK) {
return requestCount == 0 ? 0 : accumulatedRequestTime / requestCount;
}
}
/**
* Getter for the average time spent waiting for connections that were in use
* @return The average time
*/
public long getAverageWaitTime() {
synchronized (POOL_LOCK) {
return hadToWaitCount == 0 ? 0 : accumulatedWaitTime / hadToWaitCount;
}
}
/**
* Getter for the number of requests that had to wait for connections that were in use
* @return The number of requests that had to wait
*/
public long getHadToWaitCount() {
synchronized (POOL_LOCK) {
return hadToWaitCount;
}
}
/**
* Getter for the number of invalid connections that were found in the pool
* @return The number of invalid connections
*/
public long getBadConnectionCount() {
synchronized (POOL_LOCK) {
return badConnectionCount;
}
}
/**
* Getter for the number of connections that were claimed before they were returned
* @return The number of connections
*/
public long getClaimedOverdueConnectionCount() {
synchronized (POOL_LOCK) {
return claimedOverdueConnectionCount;
}
}
/**
* Getter for the average age of overdue connections
* @return The average age
*/
public long getAverageOverdueCheckoutTime() {
synchronized (POOL_LOCK) {
return claimedOverdueConnectionCount == 0 ? 0 : accumulatedCheckoutTimeOfOverdueConnections / claimedOverdueConnectionCount;
}
}
/**
* Getter for the average age of a connection checkout
* @return The average age
*/
public long getAverageCheckoutTime() {
synchronized (POOL_LOCK) {
return requestCount == 0 ? 0 : accumulatedCheckoutTime / requestCount;
}
}
/**
* Returns the status of the connection pool
* @return The status
*/
public String getStatus() {
StringBuffer buffer = new StringBuffer();
buffer.append("\n===============================================================");
buffer.append("\n jdbcDriver ").append(jdbcDriver);
buffer.append("\n jdbcUrl ").append(jdbcUrl);
buffer.append("\n jdbcUsername ").append(jdbcUsername);
buffer.append("\n jdbcPassword ").append((jdbcPassword == null ? "NULL" : "************"));
buffer.append("\n poolMaxActiveConnections ").append(poolMaximumActiveConnections);
buffer.append("\n poolMaxIdleConnections ").append(poolMaximumIdleConnections);
buffer.append("\n poolMaxCheckoutTime " + poolMaximumCheckoutTime);
buffer.append("\n poolTimeToWait " + poolTimeToWait);
buffer.append("\n poolPingEnabled " + poolPingEnabled);
buffer.append("\n poolPingQuery " + poolPingQuery);
buffer.append("\n poolPingConnectionsOlderThan " + poolPingConnectionsOlderThan);
buffer.append("\n poolPingConnectionsNotUsedFor " + poolPingConnectionsNotUsedFor);
buffer.append("\n --------------------------------------------------------------");
buffer.append("\n activeConnections " + activeConnections.size());
buffer.append("\n idleConnections " + idleConnections.size());
buffer.append("\n requestCount " + getRequestCount());
buffer.append("\n averageRequestTime " + getAverageRequestTime());
buffer.append("\n averageCheckoutTime " + getAverageCheckoutTime());
buffer.append("\n claimedOverdue " + getClaimedOverdueConnectionCount());
buffer.append("\n averageOverdueCheckoutTime " + getAverageOverdueCheckoutTime());
buffer.append("\n hadToWait " + getHadToWaitCount());
buffer.append("\n averageWaitTime " + getAverageWaitTime());
buffer.append("\n badConnectionCount " + getBadConnectionCount());
buffer.append("\n===============================================================");
return buffer.toString();
}
/**
* Closes all of the connections in the pool
*/
public void forceCloseAll() {
synchronized (POOL_LOCK) {
for (int i = activeConnections.size(); i > 0; i--) {
try {
SimplePooledConnection conn = (SimplePooledConnection) activeConnections.remove(i - 1);
conn.invalidate();
Connection realConn = conn.getRealConnection();
if (!realConn.getAutoCommit()) {
realConn.rollback();
}
realConn.close();
} catch (Exception e) {
// ignore
}
}
for (int i = idleConnections.size(); i > 0; i--) {
try {
SimplePooledConnection conn = (SimplePooledConnection) idleConnections.remove(i - 1);
conn.invalidate();
Connection realConn = conn.getRealConnection();
if (!realConn.getAutoCommit()) {
realConn.rollback();
}
realConn.close();
} catch (Exception e) {
// ignore
}
}
}
if (log.isDebugEnabled()) {
log.debug("SimpleDataSource forcefully closed/removed all connections.");
}
}
private void pushConnection(SimplePooledConnection conn)
throws SQLException {
synchronized (POOL_LOCK) {
activeConnections.remove(conn);
if (conn.isValid()) {
if (idleConnections.size() < poolMaximumIdleConnections && conn.getConnectionTypeCode() == getExpectedConnectionTypeCode()) {
accumulatedCheckoutTime += conn.getCheckoutTime();
if (!conn.getRealConnection().getAutoCommit()) {
conn.getRealConnection().rollback();
}
SimplePooledConnection newConn = new SimplePooledConnection(conn.getRealConnection(), this);
idleConnections.add(newConn);
newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
conn.invalidate();
if (log.isDebugEnabled()) {
log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
}
POOL_LOCK.notifyAll();
} else {
accumulatedCheckoutTime += conn.getCheckoutTime();
if (!conn.getRealConnection().getAutoCommit()) {
conn.getRealConnection().rollback();
}
conn.getRealConnection().close();
if (log.isDebugEnabled()) {
log.debug("Closed connection " + conn.getRealHashCode() + ".");
}
conn.invalidate();
}
} else {
if (log.isDebugEnabled()) {
log.debug("A bad connection (" + conn.getRealHashCode() + ") attempted to return to the pool, discarding connection.");
}
badConnectionCount++;
}
}
}
private SimplePooledConnection popConnection(String username, String password)
throws SQLException {
boolean countedWait = false;
SimplePooledConnection conn = null;
long t = System.currentTimeMillis();
int localBadConnectionCount = 0;
while (conn == null) {
synchronized (POOL_LOCK) {
if (idleConnections.size() > 0) {
// Pool has available connection
conn = (SimplePooledConnection) idleConnections.remove(0);
if (log.isDebugEnabled()) {
log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
}
} else {
// Pool does not have available connection
if (activeConnections.size() < poolMaximumActiveConnections) {
// Can create new connection
if (useDriverProps) {
conn = new SimplePooledConnection(DriverManager.getConnection(jdbcUrl, driverProps), this);
} else {
conn = new SimplePooledConnection(DriverManager.getConnection(jdbcUrl, jdbcUsername, jdbcPassword), this);
}
Connection realConn = conn.getRealConnection();
if (realConn.getAutoCommit() != jdbcDefaultAutoCommit) {
realConn.setAutoCommit(jdbcDefaultAutoCommit);
}
if (log.isDebugEnabled()) {
log.debug("Created connection " + conn.getRealHashCode() + ".");
}
} else {
// Cannot create new connection
SimplePooledConnection oldestActiveConnection = (SimplePooledConnection) activeConnections.get(0);
long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
if (longestCheckoutTime > poolMaximumCheckoutTime) {
// Can claim overdue connection
claimedOverdueConnectionCount++;
accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
accumulatedCheckoutTime += longestCheckoutTime;
activeConnections.remove(oldestActiveConnection);
if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
oldestActiveConnection.getRealConnection().rollback();
}
conn = new SimplePooledConnection(oldestActiveConnection.getRealConnection(), this);
oldestActiveConnection.invalidate();
if (log.isDebugEnabled()) {
log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
}
} else {
// Must wait
try {
if (!countedWait) {
hadToWaitCount++;
countedWait = true;
}
if (log.isDebugEnabled()) {
log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");
}
long wt = System.currentTimeMillis();
POOL_LOCK.wait(poolTimeToWait);
accumulatedWaitTime += System.currentTimeMillis() - wt;
} catch (InterruptedException e) {
break;
}
}
}
}
if (conn != null) {
if (conn.isValid()) {
if (!conn.getRealConnection().getAutoCommit()) {
conn.getRealConnection().rollback();
}
conn.setConnectionTypeCode(assembleConnectionTypeCode(jdbcUrl, username, password));
conn.setCheckoutTimestamp(System.currentTimeMillis());
conn.setLastUsedTimestamp(System.currentTimeMillis());
activeConnections.add(conn);
requestCount++;
accumulatedRequestTime += System.currentTimeMillis() - t;
} else {
if (log.isDebugEnabled()) {
log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection.");
}
badConnectionCount++;
localBadConnectionCount++;
conn = null;
if (localBadConnectionCount > (poolMaximumIdleConnections + 3)) {
if (log.isDebugEnabled()) {
log.debug("SimpleDataSource: Could not get a good connection to the database.");
}
throw new SQLException("SimpleDataSource: Could not get a good connection to the database.");
}
}
}
}
}
if (conn == null) {
if (log.isDebugEnabled()) {
log.debug("SimpleDataSource: Unknown severe error condition. The connection pool returned a null connection.");
}
throw new SQLException("SimpleDataSource: Unknown severe error condition. The connection pool returned a null connection.");
}
return conn;
}
/**
* Method to check to see if a connection is still usable
*
* @param conn - the connection to check
* @return True if the connection is still usable
*/
private boolean pingConnection(SimplePooledConnection conn) {
boolean result = true;
try {
result = !conn.getRealConnection().isClosed();
} catch (SQLException e) {
if (log.isDebugEnabled()) {
log.debug("Connection " + conn.getRealHashCode() + " is BAD: " + e.getMessage());
}
result = false;
}
if (result) {
if (poolPingEnabled) {
if ((poolPingConnectionsOlderThan > 0 && conn.getAge() > poolPingConnectionsOlderThan)
|| (poolPingConnectionsNotUsedFor > 0 && conn.getTimeElapsedSinceLastUse() > poolPingConnectionsNotUsedFor)) {
try {
if (log.isDebugEnabled()) {
log.debug("Testing connection " + conn.getRealHashCode() + " ...");
}
Connection realConn = conn.getRealConnection();
Statement statement = realConn.createStatement();
ResultSet rs = statement.executeQuery(poolPingQuery);
rs.close();
statement.close();
if (!realConn.getAutoCommit()) {
realConn.rollback();
}
result = true;
if (log.isDebugEnabled()) {
log.debug("Connection " + conn.getRealHashCode() + " is GOOD!");
}
} catch (Exception e) {
log.warn("Execution of ping query '" + poolPingQuery + "' failed: " + e.getMessage());
try {
conn.getRealConnection().close();
} catch (Exception e2) {
//ignore
}
result = false;
if (log.isDebugEnabled()) {
log.debug("Connection " + conn.getRealHashCode() + " is BAD: " + e.getMessage());
}
}
}
}
}
return result;
}
/**
* Unwraps a pooled connection to get to the 'real' connection
*
* @param conn - the pooled connection to unwrap
* @return The 'real' connection
*/
public static Connection unwrapConnection(Connection conn) {
if (conn instanceof SimplePooledConnection) {
return ((SimplePooledConnection) conn).getRealConnection();
} else {
return conn;
}
}
protected void finalize() throws Throwable {
forceCloseAll();
}
/**
* ---------------------------------------------------------------------------------------
* SimplePooledConnection
* ---------------------------------------------------------------------------------------
*/
public static class SimplePooledConnection implements InvocationHandler {
private static final String CLOSE = "close";
private static final Class[] IFACES = new Class[]{Connection.class};
private int hashCode = 0;
private SimpleDataSource dataSource;
private Connection realConnection;
private Connection proxyConnection;
private long checkoutTimestamp;
private long createdTimestamp;
private long lastUsedTimestamp;
private int connectionTypeCode;
private boolean valid;
/**
* Constructor for SimplePooledConnection that uses the Connection and SimpleDataSource passed in
*
* @param connection - the connection that is to be presented as a pooled connection
* @param dataSource - the dataSource that the connection is from
*/
public SimplePooledConnection(Connection connection, SimpleDataSource dataSource) {
this.hashCode = connection.hashCode();
this.realConnection = connection;
this.dataSource = dataSource;
this.createdTimestamp = System.currentTimeMillis();
this.lastUsedTimestamp = System.currentTimeMillis();
this.valid = true;
proxyConnection = (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), IFACES, this);
}
/**
* Invalidates the connection
*/
public void invalidate() {
valid = false;
}
/**
* Method to see if the connection is usable
*
* @return True if the connection is usable
*/
public boolean isValid() {
return valid && realConnection != null && dataSource.pingConnection(this);
}
/**
* Getter for the *real* connection that this wraps
* @return The connection
*/
public Connection getRealConnection() {
return realConnection;
}
/**
* Getter for the proxy for the connection
* @return The proxy
*/
public Connection getProxyConnection() {
return proxyConnection;
}
/**
* Gets the hashcode of the real connection (or 0 if it is null)
*
* @return The hashcode of the real connection (or 0 if it is null)
*/
public int getRealHashCode() {
if (realConnection == null) {
return 0;
} else {
return realConnection.hashCode();
}
}
/**
* Getter for the connection type (based on url + user + password)
* @return The connection type
*/
public int getConnectionTypeCode() {
return connectionTypeCode;
}
/**
* Setter for the connection type
* @param connectionTypeCode - the connection type
*/
public void setConnectionTypeCode(int connectionTypeCode) {
this.connectionTypeCode = connectionTypeCode;
}
/**
* Getter for the time that the connection was created
* @return The creation timestamp
*/
public long getCreatedTimestamp() {
return createdTimestamp;
}
/**
* Setter for the time that the connection was created
* @param createdTimestamp - the timestamp
*/
public void setCreatedTimestamp(long createdTimestamp) {
this.createdTimestamp = createdTimestamp;
}
/**
* Getter for the time that the connection was last used
* @return - the timestamp
*/
public long getLastUsedTimestamp() {
return lastUsedTimestamp;
}
/**
* Setter for the time that the connection was last used
* @param lastUsedTimestamp - the timestamp
*/
public void setLastUsedTimestamp(long lastUsedTimestamp) {
this.lastUsedTimestamp = lastUsedTimestamp;
}
/**
* Getter for the time since this connection was last used
* @return - the time since the last use
*/
public long getTimeElapsedSinceLastUse() {
return System.currentTimeMillis() - lastUsedTimestamp;
}
/**
* Getter for the age of the connection
* @return the age
*/
public long getAge() {
return System.currentTimeMillis() - createdTimestamp;
}
/**
* Getter for the timestamp that this connection was checked out
* @return the timestamp
*/
public long getCheckoutTimestamp() {
return checkoutTimestamp;
}
/**
* Setter for the timestamp that this connection was checked out
* @param timestamp the timestamp
*/
public void setCheckoutTimestamp(long timestamp) {
this.checkoutTimestamp = timestamp;
}
/**
* Getter for the time that this connection has been checked out
* @return the time
*/
public long getCheckoutTime() {
return System.currentTimeMillis() - checkoutTimestamp;
}
private Connection getValidConnection() {
if (!valid) {
throw new RuntimeException("Error accessing SimplePooledConnection. Connection is invalid.");
}
return realConnection;
}
public int hashCode() {
return hashCode;
}
/**
* Allows comparing this connection to another
*
* @param obj - the other connection to test for equality
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
if (obj instanceof SimplePooledConnection) {
return realConnection.hashCode() == (((SimplePooledConnection) obj).realConnection.hashCode());
} else if (obj instanceof Connection) {
return hashCode == obj.hashCode();
} else {
return false;
}
}
// **********************************
// Implemented Connection Methods -- Now handled by proxy
// **********************************
/**
* Required for InvocationHandler implementation.
*
* @param proxy - not used
* @param method - the method to be executed
* @param args - the parameters to be passed to the method
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
String methodName = method.getName();
if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {
dataSource.pushConnection(this);
return null;
} else {
try {
return method.invoke(getValidConnection(), args);
} catch (Throwable t) {
throw ClassInfo.unwrapThrowable(t);
}
}
}
public Statement createStatement() throws SQLException {
return getValidConnection().createStatement();
}
public PreparedStatement prepareStatement(String sql) throws SQLException {
return getValidConnection().prepareStatement(sql);
}
public CallableStatement prepareCall(String sql) throws SQLException {
return getValidConnection().prepareCall(sql);
}
public String nativeSQL(String sql) throws SQLException {
return getValidConnection().nativeSQL(sql);
}
public void setAutoCommit(boolean autoCommit) throws SQLException {
getValidConnection().setAutoCommit(autoCommit);
}
public boolean getAutoCommit() throws SQLException {
return getValidConnection().getAutoCommit();
}
public void commit() throws SQLException {
getValidConnection().commit();
}
public void rollback() throws SQLException {
getValidConnection().rollback();
}
public void close() throws SQLException {
dataSource.pushConnection(this);
}
public boolean isClosed() throws SQLException {
return getValidConnection().isClosed();
}
public DatabaseMetaData getMetaData() throws SQLException {
return getValidConnection().getMetaData();
}
public void setReadOnly(boolean readOnly) throws SQLException {
getValidConnection().setReadOnly(readOnly);
}
public boolean isReadOnly() throws SQLException {
return getValidConnection().isReadOnly();
}
public void setCatalog(String catalog) throws SQLException {
getValidConnection().setCatalog(catalog);
}
public String getCatalog() throws SQLException {
return getValidConnection().getCatalog();
}
public void setTransactionIsolation(int level) throws SQLException {
getValidConnection().setTransactionIsolation(level);
}
public int getTransactionIsolation() throws SQLException {
return getValidConnection().getTransactionIsolation();
}
public SQLWarning getWarnings() throws SQLException {
return getValidConnection().getWarnings();
}
public void clearWarnings() throws SQLException {
getValidConnection().clearWarnings();
}
public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
return getValidConnection().createStatement(resultSetType, resultSetConcurrency);
}
public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
return getValidConnection().prepareCall(sql, resultSetType, resultSetConcurrency);
}
public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
return getValidConnection().prepareCall(sql, resultSetType, resultSetConcurrency);
}
public Map getTypeMap() throws SQLException {
return getValidConnection().getTypeMap();
}
public void setTypeMap(Map map) throws SQLException {
getValidConnection().setTypeMap(map);
}
// **********************************
// JDK 1.4 JDBC 3.0 Methods below
// **********************************
public void setHoldability(int holdability) throws SQLException {
getValidConnection().setHoldability(holdability);
}
public int getHoldability() throws SQLException {
return getValidConnection().getHoldability();
}
public Savepoint setSavepoint() throws SQLException {
return getValidConnection().setSavepoint();
}
public Savepoint setSavepoint(String name) throws SQLException {
return getValidConnection().setSavepoint(name);
}
public void rollback(Savepoint savepoint) throws SQLException {
getValidConnection().rollback(savepoint);
}
public void releaseSavepoint(Savepoint savepoint) throws SQLException {
getValidConnection().releaseSavepoint(savepoint);
}
public Statement createStatement(int resultSetType, int resultSetConcurrency,
int resultSetHoldability) throws SQLException {
return getValidConnection().createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
}
public PreparedStatement prepareStatement(String sql, int resultSetType,
int resultSetConcurrency, int resultSetHoldability)
throws SQLException {
return getValidConnection().prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
}
public CallableStatement prepareCall(String sql, int resultSetType,
int resultSetConcurrency,
int resultSetHoldability) throws SQLException {
return getValidConnection().prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
}
public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
throws SQLException {
return getValidConnection().prepareStatement(sql, autoGeneratedKeys);
}
public PreparedStatement prepareStatement(String sql, int columnIndexes[])
throws SQLException {
return getValidConnection().prepareStatement(sql, columnIndexes);
}
public PreparedStatement prepareStatement(String sql, String columnNames[])
throws SQLException {
return getValidConnection().prepareStatement(sql, columnNames);
}
}
}
ibatis/src/com/ibatis/common/logging/ 0000755 0001750 0001750 00000000000 11047641626 020034 5 ustar twerner twerner ibatis/src/com/ibatis/common/logging/jakarta/ 0000755 0001750 0001750 00000000000 11047641626 021451 5 ustar twerner twerner ibatis/src/com/ibatis/common/logging/jakarta/JakartaCommonsLoggingImpl.java 0000644 0001750 0001750 00000001233 11047641626 027355 0 ustar twerner twerner package com.ibatis.common.logging.jakarta;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.logging.Log;
public class JakartaCommonsLoggingImpl implements com.ibatis.common.logging.Log {
private Log log;
public JakartaCommonsLoggingImpl(Class clazz) {
log = LogFactory.getLog(clazz);
}
public boolean isDebugEnabled() {
return log.isDebugEnabled();
}
public void error(String s, Throwable e) {
log.error(s,e);
}
public void error(String s) {
log.error(s);
}
public void debug(String s) {
log.debug(s);
}
public void warn(String s) {
log.warn(s);
}
}
ibatis/src/com/ibatis/common/logging/jdk14/ 0000755 0001750 0001750 00000000000 11047641626 020751 5 ustar twerner twerner ibatis/src/com/ibatis/common/logging/jdk14/Jdk14LoggingImpl.java 0000644 0001750 0001750 00000001341 11047641626 024621 0 ustar twerner twerner package com.ibatis.common.logging.jdk14;
import java.util.logging.Logger;
import java.util.logging.Level;
public class Jdk14LoggingImpl implements com.ibatis.common.logging.Log {
private Logger log;
public Jdk14LoggingImpl(Class clazz) {
log = Logger.getLogger(clazz.getName());
}
public boolean isDebugEnabled() {
return log.isLoggable(Level.FINE);
}
public void error(String s, Throwable e) {
log.log(Level.SEVERE, s, e);
}
public void error(String s) {
log.log(Level.SEVERE, s);
}
public void debug(String s) {
log.log(Level.FINE, s);
}
public void warn(String s) {
log.log(Level.WARNING, s);
}
}
ibatis/src/com/ibatis/common/logging/log4j/ 0000755 0001750 0001750 00000000000 11047641626 021053 5 ustar twerner twerner ibatis/src/com/ibatis/common/logging/log4j/Log4jImpl.java 0000644 0001750 0001750 00000001111 11047641626 023511 0 ustar twerner twerner package com.ibatis.common.logging.log4j;
import org.apache.log4j.Logger;
public class Log4jImpl implements com.ibatis.common.logging.Log {
private Logger log;
public Log4jImpl(Class clazz) {
log = Logger.getLogger(clazz);
}
public boolean isDebugEnabled() {
return log.isDebugEnabled();
}
public void error(String s, Throwable e) {
log.error(s, e);
}
public void error(String s) {
log.error(s);
}
public void debug(String s) {
log.debug(s);
}
public void warn(String s) {
log.warn(s);
}
}
ibatis/src/com/ibatis/common/logging/nologging/ 0000755 0001750 0001750 00000000000 11047641626 022017 5 ustar twerner twerner ibatis/src/com/ibatis/common/logging/nologging/NoLoggingImpl.java 0000644 0001750 0001750 00000000644 11047641626 025373 0 ustar twerner twerner package com.ibatis.common.logging.nologging;
import com.ibatis.common.logging.Log;
public class NoLoggingImpl implements Log {
public NoLoggingImpl(Class clazz) {
}
public boolean isDebugEnabled() {
return false;
}
public void error(String s, Throwable e) {
}
public void error(String s) {
}
public void debug(String s) {
}
public void warn(String s) {
}
}
ibatis/src/com/ibatis/common/logging/Log.java 0000644 0001750 0001750 00000000352 11047641626 021420 0 ustar twerner twerner package com.ibatis.common.logging;
public interface Log {
boolean isDebugEnabled();
void error(String s, Throwable e);
void error(String s);
public void debug(String s);
public void warn(String s);
}
ibatis/src/com/ibatis/common/logging/LogFactory.java 0000644 0001750 0001750 00000005620 11047641626 022753 0 ustar twerner twerner package com.ibatis.common.logging;
import java.lang.reflect.Constructor;
import com.ibatis.common.resources.Resources;
public class LogFactory {
private static Constructor logConstructor;
static {
tryImplementation("org.apache.commons.logging.LogFactory", "com.ibatis.common.logging.jakarta.JakartaCommonsLoggingImpl");
tryImplementation("org.apache.log4j.Logger", "com.ibatis.common.logging.log4j.Log4jImpl");
tryImplementation("java.util.logging.Logger", "com.ibatis.common.logging.jdk14.Jdk14LoggingImpl");
tryImplementation("java.lang.Object", "com.ibatis.common.logging.nologging.NoLoggingImpl");
}
private static void tryImplementation(String testClassName, String implClassName) {
if (logConstructor == null) {
try {
Resources.classForName(testClassName);
Class implClass = Resources.classForName(implClassName);
logConstructor = implClass.getConstructor(new Class[]{Class.class});
} catch (Throwable t) {
}
}
}
public static Log getLog(Class aClass) {
try {
return (Log)logConstructor.newInstance(new Object[]{aClass});
} catch (Throwable t) {
throw new RuntimeException("Error creating logger for class " + aClass + ". Cause: " + t, t);
}
}
/**
* This method will switch the logging implementation to Log4J if
* Log4J is available on the classpath. This is useful in situations
* where you want to use Log4J to log iBATIS activity but
* commons logging is on the classpath. Note that this method is only
* effective for log classes obtained after calling this method. If you
* intend to use this method you should call it before calling any other
* iBATIS method.
*
*/
public static synchronized void selectLog4JLogging() {
try {
Resources.classForName("org.apache.log4j.Logger");
Class implClass = Resources.classForName("com.ibatis.common.logging.log4j.Log4jImpl");
logConstructor = implClass.getConstructor(new Class[]{Class.class});
} catch (Throwable t) {
}
}
/**
* This method will switch the logging implementation to Java native logging if
* you are running in JRE 1.4 or above. This is useful in situations
* where you want to use Java native logging to log iBATIS activity but
* commons logging or Log4J is on the classpath. Note that this method is only
* effective for log classes obtained after calling this method. If you
* intend to use this method you should call it before calling any other
* iBATIS method.
*/
public static synchronized void selectJavaLogging() {
try {
Resources.classForName("java.util.logging.Logger");
Class implClass = Resources.classForName("com.ibatis.common.logging.jdk14.Jdk14LoggingImpl");
logConstructor = implClass.getConstructor(new Class[]{Class.class});
} catch (Throwable t) {
}
}
}
ibatis/src/com/ibatis/common/resources/ 0000755 0001750 0001750 00000000000 11047641630 020413 5 ustar twerner twerner ibatis/src/com/ibatis/common/resources/Resources.java 0000644 0001750 0001750 00000024667 11047641630 023247 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.resources;
import com.ibatis.common.beans.ClassInfo;
import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.Charset;
import java.util.Properties;
/**
* A class to simplify access to resources through the classloader.
*/
public class Resources extends Object {
private static ClassLoader defaultClassLoader;
/**
* Charset to use when calling getResourceAsReader.
* null means use the system default.
*/
private static Charset charset;
private Resources() {
}
/**
* Returns the default classloader (may be null).
*
* @return The default classloader
*/
public static ClassLoader getDefaultClassLoader() {
return defaultClassLoader;
}
/**
* Sets the default classloader
*
* @param defaultClassLoader - the new default ClassLoader
*/
public static void setDefaultClassLoader(ClassLoader defaultClassLoader) {
Resources.defaultClassLoader = defaultClassLoader;
}
/**
* Returns the URL of the resource on the classpath
*
* @param resource The resource to find
* @return The resource
* @throws IOException If the resource cannot be found or read
*/
public static URL getResourceURL(String resource) throws IOException {
return getResourceURL(getClassLoader(), resource);
}
/**
* Returns the URL of the resource on the classpath
*
* @param loader The classloader used to load the resource
* @param resource The resource to find
* @return The resource
* @throws IOException If the resource cannot be found or read
*/
public static URL getResourceURL(ClassLoader loader, String resource) throws IOException {
URL url = null;
if (loader != null) url = loader.getResource(resource);
if (url == null) url = ClassLoader.getSystemResource(resource);
if (url == null) throw new IOException("Could not find resource " + resource);
return url;
}
/**
* Returns a resource on the classpath as a Stream object
*
* @param resource The resource to find
* @return The resource
* @throws IOException If the resource cannot be found or read
*/
public static InputStream getResourceAsStream(String resource) throws IOException {
return getResourceAsStream(getClassLoader(), resource);
}
/**
* Returns a resource on the classpath as a Stream object
*
* @param loader The classloader used to load the resource
* @param resource The resource to find
* @return The resource
* @throws IOException If the resource cannot be found or read
*/
public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException {
InputStream in = null;
if (loader != null) in = loader.getResourceAsStream(resource);
if (in == null) in = ClassLoader.getSystemResourceAsStream(resource);
if (in == null) throw new IOException("Could not find resource " + resource);
return in;
}
/**
* Returns a resource on the classpath as a Properties object
*
* @param resource The resource to find
* @return The resource
* @throws IOException If the resource cannot be found or read
*/
public static Properties getResourceAsProperties(String resource)
throws IOException {
Properties props = new Properties();
InputStream in = null;
String propfile = resource;
in = getResourceAsStream(propfile);
props.load(in);
in.close();
return props;
}
/**
* Returns a resource on the classpath as a Properties object
*
* @param loader The classloader used to load the resource
* @param resource The resource to find
* @return The resource
* @throws IOException If the resource cannot be found or read
*/
public static Properties getResourceAsProperties(ClassLoader loader, String resource)
throws IOException {
Properties props = new Properties();
InputStream in = null;
String propfile = resource;
in = getResourceAsStream(loader, propfile);
props.load(in);
in.close();
return props;
}
/**
* Returns a resource on the classpath as a Reader object
*
* @param resource The resource to find
* @return The resource
* @throws IOException If the resource cannot be found or read
*/
public static Reader getResourceAsReader(String resource) throws IOException {
Reader reader;
if (charset == null) {
reader = new InputStreamReader(getResourceAsStream(resource));
} else {
reader = new InputStreamReader(getResourceAsStream(resource), charset);
}
return reader;
}
/**
* Returns a resource on the classpath as a Reader object
*
* @param loader The classloader used to load the resource
* @param resource The resource to find
* @return The resource
* @throws IOException If the resource cannot be found or read
*/
public static Reader getResourceAsReader(ClassLoader loader, String resource) throws IOException {
Reader reader;
if (charset == null) {
reader = new InputStreamReader(getResourceAsStream(loader, resource));
} else {
reader = new InputStreamReader(getResourceAsStream(loader, resource), charset);
}
return reader;
}
/**
* Returns a resource on the classpath as a File object
*
* @param resource The resource to find
* @return The resource
* @throws IOException If the resource cannot be found or read
*/
public static File getResourceAsFile(String resource) throws IOException {
return new File(getResourceURL(resource).getFile());
}
/**
* Returns a resource on the classpath as a File object
*
* @param loader - the classloader used to load the resource
* @param resource - the resource to find
* @return The resource
* @throws IOException If the resource cannot be found or read
*/
public static File getResourceAsFile(ClassLoader loader, String resource) throws IOException {
return new File(getResourceURL(loader, resource).getFile());
}
/**
* Gets a URL as an input stream
*
* @param urlString - the URL to get
* @return An input stream with the data from the URL
* @throws IOException If the resource cannot be found or read
*/
public static InputStream getUrlAsStream(String urlString) throws IOException {
URL url = new URL(urlString);
URLConnection conn = url.openConnection();
return conn.getInputStream();
}
/**
* Gets a URL as a Reader
*
* @param urlString - the URL to get
* @return A Reader with the data from the URL
* @throws IOException If the resource cannot be found or read
*/
public static Reader getUrlAsReader(String urlString) throws IOException {
return new InputStreamReader(getUrlAsStream(urlString));
}
/**
* Gets a URL as a Properties object
*
* @param urlString - the URL to get
* @return A Properties object with the data from the URL
* @throws IOException If the resource cannot be found or read
*/
public static Properties getUrlAsProperties(String urlString) throws IOException {
Properties props = new Properties();
InputStream in = null;
String propfile = urlString;
in = getUrlAsStream(propfile);
props.load(in);
in.close();
return props;
}
/**
* Loads a class
*
* @param className - the class to load
* @return The loaded class
* @throws ClassNotFoundException If the class cannot be found (duh!)
*/
public static Class classForName(String className) throws ClassNotFoundException {
Class clazz = null;
try {
clazz = getClassLoader().loadClass(className);
} catch (Exception e) {
// Ignore. Failsafe below.
}
if (clazz == null) {
clazz = Class.forName(className);
}
return clazz;
}
/**
* Creates an instance of a class
*
* @param className - the class to create
* @return An instance of the class
* @throws ClassNotFoundException If the class cannot be found (duh!)
* @throws InstantiationException If the class cannot be instantiaed
* @throws IllegalAccessException If the class is not public, or other access problems arise
*/
public static Object instantiate(String className)
throws ClassNotFoundException, InstantiationException, IllegalAccessException {
return instantiate(classForName(className));
}
/**
* Creates an instance of a class
*
* @param clazz - the class to create
* @return An instance of the class
* @throws InstantiationException If the class cannot be instantiaed
* @throws IllegalAccessException If the class is not public, or other access problems arise
*/
public static Object instantiate(Class clazz) throws InstantiationException, IllegalAccessException {
try {
return ClassInfo.getInstance(clazz).instantiateClass();
} catch (Exception e) {
// Try alternative...theoretically should fail for the exact same
// reason, but in case of a weird security manager, this will help
// some cases.
//return clazz.newInstance();
return clazz.newInstance();
}
}
private static ClassLoader getClassLoader() {
if (defaultClassLoader != null) {
return defaultClassLoader;
} else {
return Thread.currentThread().getContextClassLoader();
}
}
public static Charset getCharset() {
return charset;
}
/**
* Use this method to set the Charset to be used when
* calling the getResourceAsReader methods. This will
* allow iBATIS to function properly when the system default
* encoding doesn't deal well with unicode (IBATIS-340, IBATIS-349)
*
* @param charset
*/
public static void setCharset(Charset charset) {
Resources.charset = charset;
}
}
ibatis/src/com/ibatis/common/util/ 0000755 0001750 0001750 00000000000 11047641630 017356 5 ustar twerner twerner ibatis/src/com/ibatis/common/util/PaginatedArrayList.java 0000644 0001750 0001750 00000013126 11047641630 023753 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.util;
import java.util.*;
/**
* Implementation of PaginatedList backed by an ArrayList
* @deprecated All paginated list features have been deprecated
*/
public class PaginatedArrayList implements PaginatedList {
private static final ArrayList EMPTY_LIST = new ArrayList(0);
private List list;
private List page;
private int pageSize;
private int index;
/**
* @param pageSize
*/
public PaginatedArrayList(int pageSize) {
this.pageSize = pageSize;
this.index = 0;
this.list = new ArrayList();
repaginate();
}
/**
* Constructor to set the initial size and the page size
* @param initialCapacity - the initial size
* @param pageSize - the page size
*/
public PaginatedArrayList(int initialCapacity, int pageSize) {
this.pageSize = pageSize;
this.index = 0;
this.list = new ArrayList(initialCapacity);
repaginate();
}
/**
* Constructor to create an instance using an existing collection
* @param c - the collection to build the instance with
* @param pageSize - the page size
*/
public PaginatedArrayList(Collection c, int pageSize) {
this.pageSize = pageSize;
this.index = 0;
this.list = new ArrayList(c);
repaginate();
}
private void repaginate() {
if (list.isEmpty()) {
page = EMPTY_LIST;
} else {
int start = index * pageSize;
int end = start + pageSize - 1;
if (end >= list.size()) {
end = list.size() - 1;
}
if (start >= list.size()) {
index = 0;
repaginate();
} else if (start < 0) {
index = list.size() / pageSize;
if (list.size() % pageSize == 0) {
index--;
}
repaginate();
} else {
page = list.subList(start, end + 1);
}
}
}
/* List accessors (uses page) */
public int size() {
return page.size();
}
public boolean isEmpty() {
return page.isEmpty();
}
public boolean contains(Object o) {
return page.contains(o);
}
public Iterator iterator() {
return page.iterator();
}
public Object[] toArray() {
return page.toArray();
}
public Object[] toArray(Object a[]) {
return page.toArray(a);
}
public boolean containsAll(Collection c) {
return page.containsAll(c);
}
public Object get(int index) {
return page.get(index);
}
public int indexOf(Object o) {
return page.indexOf(o);
}
public int lastIndexOf(Object o) {
return page.lastIndexOf(o);
}
public ListIterator listIterator() {
return page.listIterator();
}
public ListIterator listIterator(int index) {
return page.listIterator(index);
}
public List subList(int fromIndex, int toIndex) {
return page.subList(fromIndex, toIndex);
}
/* List mutators (uses master list) */
public boolean add(Object o) {
boolean b = list.add(o);
repaginate();
return b;
}
public boolean remove(Object o) {
boolean b = list.remove(o);
repaginate();
return b;
}
public boolean addAll(Collection c) {
boolean b = list.addAll(c);
repaginate();
return b;
}
public boolean addAll(int index, Collection c) {
boolean b = list.addAll(index, c);
repaginate();
return b;
}
public boolean removeAll(Collection c) {
boolean b = list.removeAll(c);
repaginate();
return b;
}
public boolean retainAll(Collection c) {
boolean b = list.retainAll(c);
repaginate();
return b;
}
public void clear() {
list.clear();
repaginate();
}
public Object set(int index, Object element) {
Object o = list.set(index, element);
repaginate();
return o;
}
public void add(int index, Object element) {
list.add(index, element);
repaginate();
}
public Object remove(int index) {
Object o = list.remove(index);
repaginate();
return o;
}
/* Paginated List methods */
public int getPageSize() {
return pageSize;
}
public boolean isFirstPage() {
return index == 0;
}
public boolean isMiddlePage() {
return !(isFirstPage() || isLastPage());
}
public boolean isLastPage() {
return list.size() - ((index + 1) * pageSize) < 1;
}
public boolean isNextPageAvailable() {
return !isLastPage();
}
public boolean isPreviousPageAvailable() {
return !isFirstPage();
}
public boolean nextPage() {
if (isNextPageAvailable()) {
index++;
repaginate();
return true;
} else {
return false;
}
}
public boolean previousPage() {
if (isPreviousPageAvailable()) {
index--;
repaginate();
return true;
} else {
return false;
}
}
public void gotoPage(int pageNumber) {
index = pageNumber;
repaginate();
}
public int getPageIndex() {
return index;
}
}
ibatis/src/com/ibatis/common/util/PaginatedList.java 0000644 0001750 0001750 00000005764 11047641630 022765 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.common.util;
import java.util.List;
/**
* Interface for lists that support paging
* @deprecated All paginated list features have been deprecated
*/
public interface PaginatedList extends List {
/**
* Returns the maximum number of items per page
*
* @return The maximum number of items per page.
*/
public int getPageSize();
/**
* Is the current page the first page?
*
* @return True if the current page is the first page or if only
* a single page exists.
*/
public boolean isFirstPage();
/**
* Is the current page a middle page (ie not first or last)?
*
* @return True if the current page is not the first or last page,
* and more than one page exists (always returns false if only a
* single page exists).
*/
public boolean isMiddlePage();
/**
* Is the current page the last page?
*
* @return True if the current page is the last page or if only
* a single page exists.
*/
public boolean isLastPage();
/**
* Is a page available after the current page?
*
* @return True if the next page is available
*/
public boolean isNextPageAvailable();
/**
* Is a page available before the current page?
*
* @return True if the previous page is available
*/
public boolean isPreviousPageAvailable();
/**
* Moves to the next page after the current page. If the current
* page is the last page, wrap to the first page.
*
* @return True if the page changed
*/
public boolean nextPage();
/**
* Moves to the page before the current page. If the current
* page is the first page, wrap to the last page.
*
* @return True if the page changed
*/
public boolean previousPage();
/**
* Moves to a specified page. If the specified
* page is beyond the last page, wrap to the first page.
* If the specified page is before the first page, wrap
* to the last page.
*
* @param pageNumber The page to go to
*/
public void gotoPage(int pageNumber);
/**
* Returns the current page index, which is a zero based integer.
* All paginated list implementations should know what index they are
* on, even if they don't know the ultimate boundaries (min/max).
*
* @return The current page
*/
public int getPageIndex();
}
ibatis/src/com/ibatis/common/xml/ 0000755 0001750 0001750 00000000000 11047641626 017206 5 ustar twerner twerner ibatis/src/com/ibatis/common/xml/Nodelet.java 0000644 0001750 0001750 00000002033 11047641626 021441 0 ustar twerner twerner package com.ibatis.common.xml;
import org.w3c.dom.Node;
/**
* A nodelet is a sort of callback or event handler that can be registered
* to handle an XPath event registered with the NodeParser.
*/
public interface Nodelet {
/**
* For a registered XPath, the NodeletParser will call the Nodelet's
* process method for processing.
*
* @param node The node represents any XML node that can be registered under
* an XPath supported by the NodeletParser. Possible nodes are:
*
* - Text - Use node.getNodeValue() for the text value.
*
- Attribute - Use node.getNodeValue() for the attribute value.
*
- Element - This is the most flexible type. You can get the node
* content and iterate over the node's child nodes if neccessary. This is
* useful where a single XPath registration cannot describe the complex
* structure for a given XML stanza.
*
*
*/
void process (Node node) throws Exception;
}
ibatis/src/com/ibatis/common/xml/NodeletException.java 0000644 0001750 0001750 00000000564 11047641626 023327 0 ustar twerner twerner package com.ibatis.common.xml;
public class NodeletException extends Exception {
public NodeletException() {
super();
}
public NodeletException(String msg) {
super(msg);
}
public NodeletException(Throwable cause) {
super(cause);
}
public NodeletException(String msg, Throwable cause) {
super(msg, cause);
}
}
ibatis/src/com/ibatis/common/xml/NodeletParser.java 0000644 0001750 0001750 00000016063 11047641626 022626 0 ustar twerner twerner package com.ibatis.common.xml;
import org.w3c.dom.*;
import org.xml.sax.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.*;
/**
* The NodeletParser is a callback based parser similar to SAX. The big
* difference is that rather than having a single callback for all nodes,
* the NodeletParser has a number of callbacks mapped to
* various nodes. The callback is called a Nodelet and it is registered
* with the NodeletParser against a specific XPath.
*/
public class NodeletParser {
private Map letMap = new HashMap();
private boolean validation;
private EntityResolver entityResolver;
/**
* Registers a nodelet for the specified XPath. Current XPaths supported
* are:
*
* - Text Path - /rootElement/childElement/text()
*
- Attribute Path - /rootElement/childElement/@theAttribute
*
- Element Path - /rootElement/childElement/theElement
*
- All Elements Named - //theElement
*
*/
public void addNodelet(String xpath, Nodelet nodelet) {
letMap.put(xpath, nodelet);
}
/**
* Begins parsing from the provided Reader.
*/
public void parse(Reader reader) throws NodeletException {
try {
Document doc = createDocument(reader);
parse(doc.getLastChild());
} catch (Exception e) {
throw new NodeletException("Error parsing XML. Cause: " + e, e);
}
}
public void parse(InputStream inputStream) throws NodeletException {
try {
Document doc = createDocument(inputStream);
parse(doc.getLastChild());
} catch (Exception e) {
throw new NodeletException("Error parsing XML. Cause: " + e, e);
}
}
/**
* Begins parsing from the provided Node.
*/
public void parse(Node node) {
Path path = new Path();
processNodelet(node, "/");
process(node, path);
}
/**
* A recursive method that walkes the DOM tree, registers XPaths and
* calls Nodelets registered under those XPaths.
*/
private void process(Node node, Path path) {
if (node instanceof Element) {
// Element
String elementName = node.getNodeName();
path.add(elementName);
processNodelet(node, path.toString());
processNodelet(node, new StringBuffer("//").append(elementName).toString());
// Attribute
NamedNodeMap attributes = node.getAttributes();
int n = attributes.getLength();
for (int i = 0; i < n; i++) {
Node att = attributes.item(i);
String attrName = att.getNodeName();
path.add("@" + attrName);
processNodelet(att, path.toString());
processNodelet(node, new StringBuffer("//@").append(attrName).toString());
path.remove();
}
// Children
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
process(children.item(i), path);
}
path.add("end()");
processNodelet(node, path.toString());
path.remove();
path.remove();
} else if (node instanceof Text) {
// Text
path.add("text()");
processNodelet(node, path.toString());
processNodelet(node, "//text()");
path.remove();
}
}
private void processNodelet(Node node, String pathString) {
Nodelet nodelet = (Nodelet) letMap.get(pathString);
if (nodelet != null) {
try {
nodelet.process(node);
} catch (Exception e) {
throw new RuntimeException("Error parsing XPath '" + pathString + "'. Cause: " + e, e);
}
}
}
/**
* Creates a JAXP Document from a reader.
*/
private Document createDocument(Reader reader) throws ParserConfigurationException, FactoryConfigurationError,
SAXException, IOException {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(validation);
factory.setNamespaceAware(false);
factory.setIgnoringComments(true);
factory.setIgnoringElementContentWhitespace(false);
factory.setCoalescing(false);
factory.setExpandEntityReferences(true);
DocumentBuilder builder = factory.newDocumentBuilder();
builder.setEntityResolver(entityResolver);
builder.setErrorHandler(new ErrorHandler() {
public void error(SAXParseException exception) throws SAXException {
throw exception;
}
public void fatalError(SAXParseException exception) throws SAXException {
throw exception;
}
public void warning(SAXParseException exception) throws SAXException {
}
});
return builder.parse(new InputSource(reader));
}
/**
* Creates a JAXP Document from an InoutStream.
*/
private Document createDocument(InputStream inputStream) throws ParserConfigurationException, FactoryConfigurationError,
SAXException, IOException {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(validation);
factory.setNamespaceAware(false);
factory.setIgnoringComments(true);
factory.setIgnoringElementContentWhitespace(false);
factory.setCoalescing(false);
factory.setExpandEntityReferences(true);
DocumentBuilder builder = factory.newDocumentBuilder();
builder.setEntityResolver(entityResolver);
builder.setErrorHandler(new ErrorHandler() {
public void error(SAXParseException exception) throws SAXException {
throw exception;
}
public void fatalError(SAXParseException exception) throws SAXException {
throw exception;
}
public void warning(SAXParseException exception) throws SAXException {
}
});
return builder.parse(new InputSource(inputStream));
}
public void setValidation(boolean validation) {
this.validation = validation;
}
public void setEntityResolver(EntityResolver resolver) {
this.entityResolver = resolver;
}
/**
* Inner helper class that assists with building XPath paths.
*
* Note: Currently this is a bit slow and could be optimized.
*/
private static class Path {
private List nodeList = new ArrayList();
public Path() {
}
public Path(String path) {
StringTokenizer parser = new StringTokenizer(path, "/", false);
while (parser.hasMoreTokens()) {
nodeList.add(parser.nextToken());
}
}
public void add(String node) {
nodeList.add(node);
}
public void remove() {
nodeList.remove(nodeList.size() - 1);
}
public String toString() {
StringBuffer buffer = new StringBuffer("/");
for (int i = 0; i < nodeList.size(); i++) {
buffer.append(nodeList.get(i));
if (i < nodeList.size() - 1) {
buffer.append("/");
}
}
return buffer.toString();
}
}
} ibatis/src/com/ibatis/common/xml/NodeletUtils.java 0000644 0001750 0001750 00000004123 11047641626 022464 0 ustar twerner twerner package com.ibatis.common.xml;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import java.util.Properties;
public class NodeletUtils {
public static boolean getBooleanAttribute(Properties attribs, String name, boolean def) {
String value = attribs.getProperty(name);
if (value == null) {
return def;
} else {
return "true".equals(value);
}
}
public static int getIntAttribute(Properties attribs, String name, int def) {
String value = attribs.getProperty(name);
if (value == null) {
return def;
} else {
return Integer.parseInt(value);
}
}
public static Properties parseAttributes(Node n) {
return parseAttributes(n, null);
}
public static Properties parseAttributes(Node n, Properties variables) {
Properties attributes = new Properties();
NamedNodeMap attributeNodes = n.getAttributes();
for (int i = 0; i < attributeNodes.getLength(); i++) {
Node attribute = attributeNodes.item(i);
String value = parsePropertyTokens(attribute.getNodeValue(), variables);
attributes.put(attribute.getNodeName(), value);
}
return attributes;
}
public static String parsePropertyTokens(String string, Properties variables) {
final String OPEN = "${";
final String CLOSE = "}";
String newString = string;
if (newString != null && variables != null) {
int start = newString.indexOf(OPEN);
int end = newString.indexOf(CLOSE);
while (start > -1 && end > start) {
String prepend = newString.substring(0, start);
String append = newString.substring(end + CLOSE.length());
String propName = newString.substring(start + OPEN.length(), end);
String propValue = variables.getProperty(propName);
if (propValue == null) {
newString = prepend + propName + append;
} else {
newString = prepend + propValue + append;
}
start = newString.indexOf(OPEN);
end = newString.indexOf(CLOSE);
}
}
return newString;
}
}
ibatis/src/com/ibatis/sqlmap/ 0000755 0001750 0001750 00000000000 11047641640 016407 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/client/ 0000755 0001750 0001750 00000000000 11047641640 017665 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/client/event/ 0000755 0001750 0001750 00000000000 11047641640 021006 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/client/event/package.html 0000644 0001750 0001750 00000000123 11047641640 023263 0 ustar twerner twerner
This package contains event handler interfaces.
ibatis/src/com/ibatis/sqlmap/client/event/RowHandler.java 0000644 0001750 0001750 00000003063 11047641640 023720 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.client.event;
/**
* Event handler for row by row processing.
*
* The RowHandler interface is used by the SqlMapSession.queryWithRowHandler() method.
* Generally a RowHandler implementation will perform some row-by-row processing logic
* in cases where there are too many rows to efficiently load into memory.
*
* Example:
*
* sqlMap.queryWithRowHandler ("findAllEmployees", null, new MyRowHandler()));
*
*/
public interface RowHandler {
/**
* Handles a single row of a result set.
*
* This method will be called for each row in a result set. For each row the result map
* will be applied to build the value object, which is then passed in as the valueObject
* parameter.
*
* @param valueObject The object representing a single row from the query.
* @see com.ibatis.sqlmap.client.SqlMapSession
*/
void handleRow(Object valueObject);
}
ibatis/src/com/ibatis/sqlmap/client/extensions/ 0000755 0001750 0001750 00000000000 11047641640 022064 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/client/extensions/ParameterSetter.java 0000644 0001750 0001750 00000022355 11047641640 026045 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.client.extensions;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.*;
import java.util.Calendar;
/**
* Allows parameters to be set on the underlying prepared statement.
* TypeHandlerCallback implementations use this interface to
* process values before they are set on the prepared statement.
* Each of these methods has a corresponding method on the
* PreparedStatement class, the only difference being
* that there is no need to specify the parameter index with these
* methods.
*
* NOTE: There is no need to implement this. The implementation
* will be passed into the TypeHandlerCallback automatically.
*/
public interface ParameterSetter {
/**
* Set an array on the underlying prepared statement
* @param x - the array to set
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setArray(Array x) throws SQLException;
/**
* Set an InputStream on the underlying prepared statement
* @param x - the InputStream
* @param length - the length of the InputStream
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setAsciiStream(InputStream x, int length) throws SQLException;
/**
* Set an on the underlying prepared statement
* @param x
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setBigDecimal(BigDecimal x) throws SQLException;
/**
* Set an InputStream on the underlying prepared statement
* @param x - the InputStream
* @param length - the length of the InputStream
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setBinaryStream(InputStream x, int length) throws SQLException;
/**
* Set a blob on the underlying prepared statement
* @param x - the blob
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setBlob(Blob x) throws SQLException;
/**
* Set a boolean on the underlying prepared statement
* @param x - the boolean
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setBoolean(boolean x) throws SQLException;
/**
* Set a byte on the underlying prepared statement
* @param x - the byte
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setByte(byte x) throws SQLException;
/**
* Set a byte array on the underlying prepared statement
* @param x - the byte[]
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setBytes(byte x[]) throws SQLException;
/**
* Set a character stream on the underlying prepared statement
* @param reader - the reader
* @param length - the length of the reader
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setCharacterStream(Reader reader, int length) throws SQLException;
/**
* Set a clob on the underlying prepared statement
* @param x - the clob
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setClob(Clob x) throws SQLException;
/**
* Set a date on the underlying prepared statement
* @param x - the date
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setDate(Date x) throws SQLException;
/**
* Set a date with a calendar on the underlying prepared statement
* @param x - the date
* @param cal - the calendar
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setDate(Date x, Calendar cal) throws SQLException;
/**
* Set a double on the underlying prepared statement
* @param x - the double
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setDouble(double x) throws SQLException;
/**
* Set a float on the underlying prepared statement
* @param x the float
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setFloat(float x) throws SQLException;
/**
* Set an integer on the underlying prepared statement
* @param x - the int
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setInt(int x) throws SQLException;
/**
* Set a long on the underlying prepared statement
* @param x - the long
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setLong(long x) throws SQLException;
/**
* Set a null on the underlying prepared statement
* @param sqlType - the type for the null value
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setNull(int sqlType) throws SQLException;
/**
* Set a null on the underlying prepared statement
* @param sqlType - the type for the null value
* @param typeName - the name of the type
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setNull(int sqlType, String typeName) throws SQLException;
/**
* Set an object on the underlying prepared statement
* @param x - the object to set
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setObject(Object x) throws SQLException;
/**
* Set an object on the underlying prepared statement
* @param x - the object to set
* @param targetSqlType - the sql type of the object
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setObject(Object x, int targetSqlType) throws SQLException;
/**
* Set an object on the underlying prepared statement
* @param x - the object to set
* @param targetSqlType - the sql type of the object
* @param scale - the scale of the object
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setObject(Object x, int targetSqlType, int scale) throws SQLException;
/**
* Set a reference on the underlying prepared statement
* @param x - the reference to set
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setRef(Ref x) throws SQLException;
/**
* Set a short on the underlying prepared statement
* @param x - the short to set
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setShort(short x) throws SQLException;
/**
* Set a string on the underlying prepared statement
* @param x - the string to set
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setString(String x) throws SQLException;
/**
* Set a time on the underlying prepared statement
* @param x - the time to set
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setTime(Time x) throws SQLException;
/**
* Set a time with a calendar on the underlying prepared statement
* @param x - the time to set
* @param cal - the calendar to use
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setTime(Time x, Calendar cal) throws SQLException;
/**
* Set a timestamp on the underlying prepared statement
* @param x - the timestamp to set
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setTimestamp(Timestamp x) throws SQLException;
/**
* Set a timestamp on the underlying prepared statement
* @param x - the timestamp to set
* @param cal - the calendar to use
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setTimestamp(Timestamp x, Calendar cal) throws SQLException;
/**
* Set a URL on the underlying prepared statement
* @param x - the url to set
* @throws SQLException - thrown if the underlying prepared statement throws it
*/
public void setURL(URL x) throws SQLException;
/**
* Returns the underlying prepared statement...be careful!
*/
public PreparedStatement getPreparedStatement();
/**
* Returns the index of the parameter being set.
*
* @return the parameter index used to set the value in the underlying
* PreparedStatement
*/
public int getParameterIndex();
}
ibatis/src/com/ibatis/sqlmap/client/extensions/ResultGetter.java 0000644 0001750 0001750 00000016666 11047641640 025377 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.client.extensions;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.*;
import java.util.Calendar;
import java.util.Map;
/**
* Allows values to be retrieved from the underlying result set.
* TypeHandlerCallback implementations use this interface to
* get values that they can subsequently manipulate before
* having them returned. Each of these methods has a corresponding
* method on the ResultSet (or CallableStatement) class, the only
* difference being that there is no need to specify the column name
* or index with these methods.
*
* NOTE: There is no need to implement this. The implementation
* will be passed into the TypeHandlerCallback automatically.
*/
public interface ResultGetter {
/**
* Gets an array from the underlying result set
* @return - the array
* @throws SQLException - if the underlying result set throws an exception
*/
public Array getArray() throws SQLException;
/**
* Gets a BigDecimal from the underlying result set
* @return - the BigDecimal
* @throws SQLException - if the underlying result set throws an exception
*/
public BigDecimal getBigDecimal() throws SQLException;
/**
* Gets a Blob from the underlying result set
* @return - the Blob
* @throws SQLException - if the underlying result set throws an exception
*/
public Blob getBlob() throws SQLException;
/**
* Gets a boolean from the underlying result set
* @return - the boolean
* @throws SQLException - if the underlying result set throws an exception
*/
public boolean getBoolean() throws SQLException;
/**
* Gets a byte from the underlying result set
* @return - the byte
* @throws SQLException - if the underlying result set throws an exception
*/
public byte getByte() throws SQLException;
/**
* Gets a byte[] from the underlying result set
* @return - the byte[]
* @throws SQLException - if the underlying result set throws an exception
*/
public byte[] getBytes() throws SQLException;
/**
* Gets a Clob from the underlying result set
* @return - the Clob
* @throws SQLException - if the underlying result set throws an exception
*/
public Clob getClob() throws SQLException;
/**
* Gets a Date from the underlying result set
* @return - the Date
* @throws SQLException - if the underlying result set throws an exception
*/
public Date getDate() throws SQLException;
/**
* Gets a Date from the underlying result set using a calendar
* @param cal - the Calendar
* @return - the Date
* @throws SQLException - if the underlying result set throws an exception
*/
public Date getDate(Calendar cal) throws SQLException;
/**
* Gets a double from the underlying result set
* @return - the double
* @throws SQLException - if the underlying result set throws an exception
*/
public double getDouble() throws SQLException;
/**
* Gets a float from the underlying result set
* @return - the float
* @throws SQLException - if the underlying result set throws an exception
*/
public float getFloat() throws SQLException;
/**
* Gets an int from the underlying result set
* @return - the int
* @throws SQLException - if the underlying result set throws an exception
*/
public int getInt() throws SQLException;
/**
* Gets a long from the underlying result set
* @return - the long
* @throws SQLException - if the underlying result set throws an exception
*/
public long getLong() throws SQLException;
/**
* Gets an Object from the underlying result set
* @return - the Object
* @throws SQLException - if the underlying result set throws an exception
*/
public Object getObject() throws SQLException;
/**
* Gets an Object from the underlying result set using a Map
* @param map - the Map
* @return - the Object
* @throws SQLException - if the underlying result set throws an exception
*/
public Object getObject(Map map) throws SQLException;
/**
* Gets a Ref from the underlying result set
* @return - the Ref
* @throws SQLException - if the underlying result set throws an exception
*/
public Ref getRef() throws SQLException;
/**
* Gets a short from the underlying result set
* @return - the short
* @throws SQLException - if the underlying result set throws an exception
*/
public short getShort() throws SQLException;
/**
* Gets a String from the underlying result set
* @return - the String
* @throws SQLException - if the underlying result set throws an exception
*/
public String getString() throws SQLException;
/**
* Gets a Time from the underlying result set
* @return - the Time
* @throws SQLException - if the underlying result set throws an exception
*/
public Time getTime() throws SQLException;
/**
* Gets a Time from the underlying result set using a Calendar
* @param cal - the Calendar
* @return - the Time
* @throws SQLException - if the underlying result set throws an exception
*/
public Time getTime(Calendar cal) throws SQLException;
/**
* Gets a Timestamp from the underlying result set
* @return - the Timestamp
* @throws SQLException - if the underlying result set throws an exception
*/
public Timestamp getTimestamp() throws SQLException;
/**
* Gets a Timestamp from the underlying result set
* @param cal - the Calendar
* @return - the Timestamp
* @throws SQLException - if the underlying result set throws an exception
*/
public Timestamp getTimestamp(Calendar cal) throws SQLException;
/**
* Gets a URL from the underlying result set
* @return - the URL
* @throws SQLException - if the underlying result set throws an exception
*/
public URL getURL() throws SQLException;
/**
* Tells if the field was null
* @return - true if it was null
* @throws SQLException - if the underlying result set throws an exception
*/
public boolean wasNull() throws SQLException;
/**
* Returns the underlying ResultSet...be careful!
* @return a ResultSet instance.
*/
public ResultSet getResultSet();
/**
* Returns the name of the column being got in the underlying ResultSet.
* May be null in which case the getColumnIndex
* method should be used.
*
* @return the column name (may be null)
*/
public String getColumnName();
/**
* Returns the index of the column being got in the underlying ResultSet.
* Only use this method if the value returned from getColumnName
* is null.
*
* @return the index of the column (if zero then use the column name)
*/
public int getColumnIndex();
}
ibatis/src/com/ibatis/sqlmap/client/extensions/TypeHandlerCallback.java 0000644 0001750 0001750 00000010465 11047641640 026571 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.client.extensions;
import java.sql.SQLException;
/**
* A simple interface for implementing custom type handlers.
*
* Using this interface, you can implement a type handler that
* will perform customized processing before parameters are set
* on a PreparedStatement and after values are retrieved from
* a ResultSet. Using a custom type handler you can extend
* the framework to handle types that are not supported, or
* handle supported types in a different way. For example,
* you might use a custom type handler to implement proprietary
* BLOB support (e.g. Oracle), or you might use it to handle
* booleans using "Y" and "N" instead of the more typical 0/1.
*
* EXAMPLE
* Here's a simple example of a boolean handler that uses "Yes" and "No".
*
* public class YesNoBoolTypeHandlerCallback implements TypeHandlerCallback {
*
* private static final String YES = "Yes";
* private static final String NO = "No";
*
* public Object getResult(ResultGetter getter) throws SQLException {
* String s = getter.getString();
* if (YES.equalsIgnoreCase(s)) {
* return new Boolean (true);
* } else if (NO.equalsIgnoreCase(s)) {
* return new Boolean (false);
* } else {
* throw new SQLException ("Unexpected value " + s + " found where "+YES+" or "+NO+" was expected.");
* }
* }
*
* public void setParameter(ParameterSetter setter, Object parameter) throws SQLException {
* boolean b = ((Boolean)parameter).booleanValue();
* if (b) {
* setter.setString(YES);
* } else {
* setter.setString(NO);
* }
* }
*
* public Object valueOf(String s) {
* if (YES.equalsIgnoreCase(s)) {
* return new Boolean (true);
* } else if (NO.equalsIgnoreCase(s)) {
* return new Boolean (false);
* } else {
* throw new SQLException ("Unexpected value " + s + " found where "+YES+" or "+NO+" was expected.");
* }
* }
*
* }
*
*/
public interface TypeHandlerCallback {
/**
* Performs processing on a value before it is used to set
* the parameter of a PreparedStatement.
*
* @param setter The interface for setting the value on the PreparedStatement.
* @param parameter The value to be set.
* @throws SQLException If any error occurs.
*/
public void setParameter(ParameterSetter setter, Object parameter)
throws SQLException;
/**
* Performs processing on a value before after it has been retrieved
* from a ResultSet.
*
* @param getter The interface for getting the value from the ResultSet.
* @return The processed value.
* @throws SQLException If any error occurs.
*/
public Object getResult(ResultGetter getter)
throws SQLException;
/**
* Casts the string representation of a value into a type recognized by
* this type handler. This method is used to translate nullValue values
* into types that can be appropriately compared. If your custom type handler
* cannot support nullValues, or if there is no reasonable string representation
* for this type (e.g. File type), you can simply return the String representation
* as it was passed in. It is not recommended to return null, unless null was passed
* in.
*
* @param s A string representation of a valid value for this type.
* @return One of the following:
*
* - the casted repersentation of the String value,
* - the string as is,
* - null, only if null was passed in.
*
*/
public Object valueOf(String s);
}
ibatis/src/com/ibatis/sqlmap/client/package.html 0000644 0001750 0001750 00000000132 11047641640 022142 0 ustar twerner twerner
This package contains the core library client interface.
ibatis/src/com/ibatis/sqlmap/client/SqlMapClient.java 0000644 0001750 0001750 00000022145 11047641640 023070 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.client;
import java.sql.Connection;
/**
* A thread safe client for working with your SQL Maps (Start Here). This interface inherits transaction control
* and execution methods from the SqlMapTransactionManager and SqlMapExecutor interfaces.
*
* The SqlMapClient is the central class for working with SQL Maps. This class will allow you
* to run mapped statements (select, insert, update, delete etc.), and also demarcate
* transactions and work with batches. Once you have an SqlMapClient instance, everything
* you need to work with SQL Maps is easily available.
*
* The SqlMapClient can either
* be worked with directly as a multi-threaded client (internal session management), or you can get a single threaded
* session and work with that. There may be a slight performance increase if you explicitly
* get a session (using the openSession() method), as it saves the SqlMapClient from having
* to manage threads contexts. But for most cases it won't make much of a difference, so
* choose whichever paradigm suits your needs or preferences.
*
* An SqlMapClient instance can be safely made static or applied as a Singleton.
* Generally it's a good idea to make a simple configuration class that will configure the
* instance (using SqlMapClientBuilder) and provide access to it.
*
* The following example will demonstrate the use of SqlMapClient.
*
*
* //
* // autocommit simple query --these are just examples...not patterns
* //
*
* Employee emp = (Employee) sqlMap.queryForObject("getEmployee", new Integer(1));
*
* //
* // transaction --these are just examples...not patterns
* //
*
* try {
* sqlMap.startTransaction()
* Employee emp2 = new Employee();
* // ...set emp2 data
* Integer generatedKey = (Integer) sqlMap.insert ("insertEmployee", emp2);
* emp2.setFavouriteColour ("green");
* sqlMap.update("updateEmployee", emp2);
* sqlMap.commitTransaction();
* } finally {
* sqlMap.endTransaction();
* }
*
* //
* // session --these are just examples...not patterns
* //
*
* try {
* SqlMapSession session = sqlMap.openSession()
* session.startTransaction()
* Employee emp2 = new Employee();
* // ...set emp2 data
* Integer generatedKey = (Integer) session.insert ("insertEmployee", emp2);
* emp2.setFavouriteColour ("green");
* session.update("updateEmployee", emp2);
* session.commitTransaction();
* } finally {
* try {
* session.endTransaction();
* } finally {
* session.close();
* }
* // Generally your session scope would be in a wider context and therefore the
* // ugly nested finally block above would not be there. Realize that sessions
* // MUST be closed if explicitly opened (via openSession()).
* }
*
* //
* // batch --these are just examples...not patterns
* //
*
* try {
* sqlMap.startTransaction()
* List list = (Employee) sqlMap.queryForList("getFiredEmployees", null);
* sqlMap.startBatch ();
* for (int i=0, n=list.size(); i < n; i++) {
* sqlMap.delete ("deleteEmployee", list.get(i));
* }
* sqlMap.executeBatch();
* sqlMap.commitTransaction();
* } finally {
* sqlMap.endTransaction();
* }
*
*
* @see SqlMapClientBuilder
* @see SqlMapSession
* @see SqlMapExecutor
*/
public interface SqlMapClient extends SqlMapExecutor, SqlMapTransactionManager {
/**
* Returns a single threaded SqlMapSession implementation for use by
* one user. Remember though, that SqlMapClient itself is a thread safe SqlMapSession
* implementation, so you can also just work directly with it. If you do get a session
* explicitly using this method be sure to close it! You can close a session using
* the sqlMapSession.close() method.
*
*
* @return An SqlMapSession instance.
*/
public SqlMapSession openSession();
/**
* Returns a single threaded SqlMapSession implementation for use by
* one user. Remember though, that SqlMapClient itself is a thread safe SqlMapSession
* implementation, so you can also just work directly with it. If you do get a session
* explicitly using this method be sure to close it! You can close a session using
* the SqlMapSession.close() method.
*
* This particular implementation takes a user provided connection as a parameter. This
* connection will be used for executing statements, and therefore overrides any
* configured datasources. Using this approach allows the developer to easily use an externally
* supplied connection for executing statements.
*
* Important: Using a user supplied connection basically sidesteps the datasource
* so you are responsible for appropriately handling your connection lifecycle (i.e. closing).
* Here's a (very) simple example (throws SQLException):
*
* try {
* Connection connection = dataSource.getConnection();
* SqlMapSession session = sqlMap.openSession(connection);
* // do work
* connection.commit();
* } catch (SQLException e) {
* try {
* if (connection != null) commit.rollback();
* } catch (SQLException ignored) {
* // generally ignored
* }
* throw e; // rethrow the exception
* } finally {
* try {
* if (connection != null) connection.close();
* } catch (SQLException ignored) {
* // generally ignored
* }
* }
*
*
* @param conn - the connection to use for the session
*
* @return An SqlMapSession instance.
*/
public SqlMapSession openSession(Connection conn);
/**
* TODO : Deprecated and will be removed.
*
* @return A session (DEPRECATED)
* @deprecated Use openSession() instead. THIS METHOD WILL BE REMOVED BEFORE
* FINAL RELEASE.
*/
public SqlMapSession getSession();
/**
* Flushes all data caches.
*/
public void flushDataCache();
/**
* Flushes the data cache that matches the cache model ID provided.
* cacheId should include the namespace, even when
* useStatementNamespaces="false".
*
* @param cacheId The cache model to flush
*/
public void flushDataCache(String cacheId);
/**
* Returns a generated implementation of a cusom mapper class as specified by the method
* parameter. The generated implementation will run mapped statements by matching the method
* name to the statement name. The mapped statement elements determine how the statement is
* run as per the following:
*
* - <insert> -- insert()
*
- <update> -- update()
*
- <delete> -- delete()
*
- <select> -- queryForObject, queryForList or queryForMap, as determined by signature (see below)
*
- <procedure> -- determined by method name (see below)
*
*
* How select statements are run is determined by the method signature,
* as per the following:
*
* - Object methodName (Object param) -- queryForObject
*
- List methodName (Object param [, int skip, int max | , int pageSize]) -- queryForList
*
- Map methodName (Object param, String keyProp [,valueProp]) -- queryForMap
*
*
* How stored procedures are run is determined by the method name,
* as per the following:
*
* - insertXxxxx -- insert()
*
- createXxxxx -- insert()
*
- updateXxxxx -- update()
*
- saveXxxxx -- update()
*
- deleteXxxxx -- delete()
*
- removeXxxxx -- delete()
*
- selectXxxxx -- queryForXxxxxx() determined by method signature as above
*
- queryXxxxx -- queryForXxxxxx() determined by method signature as above
*
- fetchXxxxx -- queryForXxxxxx() determined by method signature as above
*
- getXxxxx -- queryForXxxxxx() determined by method signature as above
*
*
* @param iface The interface that contains methods representing the mapped statements contained.
* @return An instance of iface that can be used to call mapped statements directly in a typesafe
* manner.
*/
//public Object getMapper(Class iface);
} ibatis/src/com/ibatis/sqlmap/client/SqlMapClientBuilder.java 0000644 0001750 0001750 00000010165 11047641640 024376 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.client;
import com.ibatis.sqlmap.engine.builder.xml.SqlMapConfigParser;
import java.io.InputStream;
import java.io.Reader;
import java.util.Properties;
/**
* Builds SqlMapClient instances from a supplied resource (e.g. XML configuration file)
*
* The SqlMapClientBuilder class is responsible for parsing configuration documents
* and building the SqlMapClient instance. Its current implementation works with
* XML configuration files (e.g. sql-map-config.xml).
*
* Example:
*
* Reader reader = Resources.getResourceAsReader("properties/sql-map-config.xml");
* SqlMapClient client = SqlMapClientBuilder.buildSqlMapClient (reader);
*
*
* Examples of the XML document structure used by SqlMapClientBuilder can
* be found at the links below.
*
* Note: They might look big, but they're mostly comments!
*
* - The SQL Map Config File
*
- An SQL Map File
*
*/
public class SqlMapClientBuilder {
/**
* No instantiation allowed.
*/
protected SqlMapClientBuilder() {
}
/**
* Builds an SqlMapClient using the specified reader.
*
* @param reader A Reader instance that reads an sql-map-config.xml file.
* The reader should read an well formed sql-map-config.xml file.
* @return An SqlMapClient instance.
*/
public static SqlMapClient buildSqlMapClient(Reader reader) {
// return new XmlSqlMapClientBuilder().buildSqlMap(reader);
return new SqlMapConfigParser().parse(reader);
}
/**
* Builds an SqlMapClient using the specified reader and properties file.
*
*
* @param reader A Reader instance that reads an sql-map-config.xml file.
* The reader should read an well formed sql-map-config.xml file.
* @param props Properties to be used to provide values to dynamic property tokens
* in the sql-map-config.xml configuration file. This provides an easy way to
* achieve some level of programmatic configuration.
* @return An SqlMapClient instance.
*/
public static SqlMapClient buildSqlMapClient(Reader reader, Properties props) {
// return new XmlSqlMapClientBuilder().buildSqlMap(reader, props);
return new SqlMapConfigParser().parse(reader, props);
}
/**
* Builds an SqlMapClient using the specified input stream.
*
* @param inputStream An InputStream instance that reads an sql-map-config.xml file.
* The stream should read a well formed sql-map-config.xml file.
* @return An SqlMapClient instance.
*/
public static SqlMapClient buildSqlMapClient(InputStream inputStream) {
return new SqlMapConfigParser().parse(inputStream);
}
/**
* Builds an SqlMapClient using the specified input stream and properties file.
*
*
* @param inputStream An InputStream instance that reads an sql-map-config.xml file.
* The stream should read an well formed sql-map-config.xml file.
* @param props Properties to be used to provide values to dynamic property tokens
* in the sql-map-config.xml configuration file. This provides an easy way to
* achieve some level of programmatic configuration.
* @return An SqlMapClient instance.
*/
public static SqlMapClient buildSqlMapClient(InputStream inputStream, Properties props) {
return new SqlMapConfigParser().parse(inputStream, props);
}
}
ibatis/src/com/ibatis/sqlmap/client/SqlMapException.java 0000644 0001750 0001750 00000003512 11047641640 023605 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.client;
/**
* Thrown to indicate a problem with SQL Map configuration or state. Generally
* if an SqlMapException is thrown, something is critically wronge and cannot
* be corrected until a change to the configuration or the environment is made.
*
* Note: Generally this wouldn't be used to indicate that an SQL execution error
* occurred (that's what SQLException is for).
*/
public class SqlMapException extends RuntimeException {
/**
* Simple constructor
*/
public SqlMapException() {
}
/**
* Constructor to create exception with a message
*
* @param msg A message to associate with the exception
*/
public SqlMapException(String msg) {
super(msg);
}
/**
* Constructor to create exception to wrap another exception
*
* @param cause The real cause of the exception
*/
public SqlMapException(Throwable cause) {
super(cause);
}
/**
* Constructor to create exception to wrap another exception and pass a message
*
* @param msg The message
* @param cause The real cause of the exception
*/
public SqlMapException(String msg, Throwable cause) {
super(msg, cause);
}
}
ibatis/src/com/ibatis/sqlmap/client/SqlMapExecutor.java 0000644 0001750 0001750 00000035754 11047641640 023462 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.client;
import com.ibatis.common.util.PaginatedList;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.execution.BatchException;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
/**
* This interface declares all methods involved with executing statements
* and batches for an SQL Map.
*
* @see SqlMapSession
* @see SqlMapClient
*/
public interface SqlMapExecutor {
/**
* Executes a mapped SQL INSERT statement.
* Insert is a bit different from other update methods, as it
* provides facilities for returning the primary key of the
* newly inserted row (rather than the effected rows). This
* functionality is of course optional.
*
* The parameter object is generally used to supply the input
* data for the INSERT values.
*
* @param id The name of the statement to execute.
* @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.).
* @return The primary key of the newly inserted row. This might be automatically
* generated by the RDBMS, or selected from a sequence table or other source.
* @throws java.sql.SQLException If an error occurs.
*/
Object insert(String id, Object parameterObject) throws SQLException;
/**
* Executes a mapped SQL INSERT statement.
* Insert is a bit different from other update methods, as it
* provides facilities for returning the primary key of the
* newly inserted row (rather than the effected rows). This
* functionality is of course optional.
*
* This overload assumes no parameter is needed.
*
* @param id The name of the statement to execute.
* @return The primary key of the newly inserted row. This might be automatically
* generated by the RDBMS, or selected from a sequence table or other source.
* @throws java.sql.SQLException If an error occurs.
*/
Object insert(String id) throws SQLException;
/**
* Executes a mapped SQL UPDATE statement.
* Update can also be used for any other update statement type,
* such as inserts and deletes. Update returns the number of
* rows effected.
*
* The parameter object is generally used to supply the input
* data for the UPDATE values as well as the WHERE clause parameter(s).
*
* @param id The name of the statement to execute.
* @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.).
* @return The number of rows effected.
* @throws java.sql.SQLException If an error occurs.
*/
int update(String id, Object parameterObject) throws SQLException;
/**
* Executes a mapped SQL UPDATE statement.
* Update can also be used for any other update statement type,
* such as inserts and deletes. Update returns the number of
* rows effected.
*
* This overload assumes no parameter is needed.
*
* @param id The name of the statement to execute.
* @return The number of rows effected.
* @throws java.sql.SQLException If an error occurs.
*/
int update(String id) throws SQLException;
/**
* Executes a mapped SQL DELETE statement.
* Delete returns the number of rows effected.
*
* The parameter object is generally used to supply the input
* data for the WHERE clause parameter(s) of the DELETE statement.
*
* @param id The name of the statement to execute.
* @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.).
* @return The number of rows effected.
* @throws java.sql.SQLException If an error occurs.
*/
int delete(String id, Object parameterObject) throws SQLException;
/**
* Executes a mapped SQL DELETE statement.
* Delete returns the number of rows effected.
*
* This overload assumes no parameter is needed.
*
* @param id The name of the statement to execute.
* @return The number of rows effected.
* @throws java.sql.SQLException If an error occurs.
*/
int delete(String id) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns data to populate
* a single object instance.
*
* The parameter object is generally used to supply the input
* data for the WHERE clause parameter(s) of the SELECT statement.
*
* @param id The name of the statement to execute.
* @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.).
* @return The single result object populated with the result set data,
* or null if no result was found
* @throws java.sql.SQLException If more than one result was found, or if any other error occurs.
*/
Object queryForObject(String id, Object parameterObject) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns data to populate
* a single object instance.
*
* This overload assumes no parameter is needed.
*
* @param id The name of the statement to execute.
* @return The single result object populated with the result set data,
* or null if no result was found
* @throws java.sql.SQLException If more than one result was found, or if any other error occurs.
*/
Object queryForObject(String id) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns data to populate
* the supplied result object.
*
* The parameter object is generally used to supply the input
* data for the WHERE clause parameter(s) of the SELECT statement.
*
* @param id The name of the statement to execute.
* @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.).
* @param resultObject The result object instance that should be populated with result data.
* @return The single result object as supplied by the resultObject parameter, populated with the result set data,
* or null if no result was found
* @throws java.sql.SQLException If more than one result was found, or if any other error occurs.
*/
Object queryForObject(String id, Object parameterObject, Object resultObject) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns data to populate
* a number of result objects.
*
* The parameter object is generally used to supply the input
* data for the WHERE clause parameter(s) of the SELECT statement.
*
* @param id The name of the statement to execute.
* @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.).
* @return A List of result objects.
* @throws java.sql.SQLException If an error occurs.
*/
List queryForList(String id, Object parameterObject) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns data to populate
* a number of result objects.
*
* This overload assumes no parameter is needed.
*
* @param id The name of the statement to execute.
* @return A List of result objects.
* @throws java.sql.SQLException If an error occurs.
*/
List queryForList(String id) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns data to populate
* a number of result objects within a certain range.
*
* The parameter object is generally used to supply the input
* data for the WHERE clause parameter(s) of the SELECT statement.
*
* @param id The name of the statement to execute.
* @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.).
* @param skip The number of results to ignore.
* @param max The maximum number of results to return.
* @return A List of result objects.
* @throws java.sql.SQLException If an error occurs.
*/
List queryForList(String id, Object parameterObject, int skip, int max) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns data to populate
* a number of result objects within a certain range.
*
* This overload assumes no parameter is needed.
*
* @param id The name of the statement to execute.
* @param skip The number of results to ignore.
* @param max The maximum number of results to return.
* @return A List of result objects.
* @throws java.sql.SQLException If an error occurs.
*/
List queryForList(String id, int skip, int max) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns a number of
* result objects that will be handled one at a time by a
* RowHandler.
*
* This is generally a good approach to take when dealing with large sets
* of records (i.e. hundreds, thousands...) that need to be processed without
* eating up all of the system resources.
*
* The parameter object is generally used to supply the input
* data for the WHERE clause parameter(s) of the SELECT statement.
*
* @param id The name of the statement to execute.
* @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.).
* @param rowHandler A RowHandler instance
* @throws java.sql.SQLException If an error occurs.
*/
void queryWithRowHandler(String id, Object parameterObject, RowHandler rowHandler) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns a number of
* result objects that will be handled one at a time by a
* RowHandler.
*
* This is generally a good approach to take when dealing with large sets
* of records (i.e. hundreds, thousands...) that need to be processed without
* eating up all of the system resources.
*
* This overload assumes no parameter is needed.
*
* @param id The name of the statement to execute.
* @param rowHandler A RowHandler instance
* @throws java.sql.SQLException If an error occurs.
*/
void queryWithRowHandler(String id, RowHandler rowHandler) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns data to populate
* a number of result objects a page at a time.
*
* The parameter object is generally used to supply the input
* data for the WHERE clause parameter(s) of the SELECT statement.
*
* @param id The name of the statement to execute.
* @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.).
* @param pageSize The maximum number of result objects each page can hold.
* @return A PaginatedList of result objects.
* @throws java.sql.SQLException If an error occurs.
* @deprecated All paginated list features have been deprecated
*/
PaginatedList queryForPaginatedList(String id, Object parameterObject, int pageSize) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns data to populate
* a number of result objects a page at a time.
*
* This overload assumes no parameter is needed.
*
* @param id The name of the statement to execute.
* @param pageSize The maximum number of result objects each page can hold.
* @return A PaginatedList of result objects.
* @throws java.sql.SQLException If an error occurs.
* @deprecated All paginated list features have been deprecated
*/
PaginatedList queryForPaginatedList(String id, int pageSize) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns data to populate
* a number of result objects that will be keyed into a Map.
*
* The parameter object is generally used to supply the input
* data for the WHERE clause parameter(s) of the SELECT statement.
*
* @param id The name of the statement to execute.
* @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.).
* @param keyProp The property to be used as the key in the Map.
* @return A Map keyed by keyProp with values being the result object instance.
* @throws java.sql.SQLException If an error occurs.
*/
Map queryForMap(String id, Object parameterObject, String keyProp) throws SQLException;
/**
* Executes a mapped SQL SELECT statement that returns data to populate
* a number of result objects from which one property will be keyed into a Map.
*
* The parameter object is generally used to supply the input
* data for the WHERE clause parameter(s) of the SELECT statement.
*
* @param id The name of the statement to execute.
* @param parameterObject The parameter object (e.g. JavaBean, Map, XML etc.).
* @param keyProp The property to be used as the key in the Map.
* @param valueProp The property to be used as the value in the Map.
* @return A Map keyed by keyProp with values of valueProp.
* @throws java.sql.SQLException If an error occurs.
*/
Map queryForMap(String id, Object parameterObject, String keyProp, String valueProp) throws SQLException;
/**
* Starts a batch in which update statements will be cached before being sent to
* the database all at once. This can improve overall performance of updates update
* when dealing with numerous updates (e.g. inserting 1:M related data).
*
* @throws java.sql.SQLException If the batch could not be started.
*/
void startBatch() throws SQLException;
/**
* Executes (flushes) all statements currently batched.
*
* @return the number of rows updated in the batch
* @throws java.sql.SQLException If the batch could not be executed or if any of the statements
* fails.
*/
int executeBatch() throws SQLException;
/**
* Executes (flushes) all statements currently batched.
*
* @return a List of BatchResult objects. There will be one element in the
* list for each sub-batch executed. A sub-batch is created by adding a statement
* to the batch that does not equal the prior statement.
* @throws SQLException if a database access error occurs, or the drive
* does not support batch statements
* @throws BatchException if the driver throws BatchUpdateException
* @see com.ibatis.sqlmap.engine.execution.BatchException
*/
List executeBatchDetailed() throws SQLException, BatchException;
}
ibatis/src/com/ibatis/sqlmap/client/SqlMapSession.java 0000644 0001750 0001750 00000002107 11047641640 023271 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.client;
/**
* A single threaded session for working with your SQL Maps. This interface inherits transaction control
* and execution methods from the SqlMapTransactionManager and SqlMapExecutor interfaces.
*
* @see SqlMapClient
* @see SqlMapSession
* @see SqlMapExecutor
*/
public interface SqlMapSession extends SqlMapExecutor, SqlMapTransactionManager {
/**
* Closes the session
*/
public void close();
}
ibatis/src/com/ibatis/sqlmap/client/SqlMapTransactionManager.java 0000644 0001750 0001750 00000012022 11047641640 025423 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.client;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
/**
* This interface declares methods for demarcating SQL Map transactions.
*
* @see SqlMapSession
* @see SqlMapClient
*/
public interface SqlMapTransactionManager {
/**
* Demarcates the beginning of a transaction scope. Transactions must be properly
* committed or rolled back to be effective. Use the following pattern when working
* with transactions:
*
* try {
* sqlMap.startTransaction();
* // do work
* sqlMap.commitTransaction();
* } finally {
* sqlMap.endTransaction();
* }
*
*
* Always call endTransaction() once startTransaction() has been called.
*
* @throws java.sql.SQLException If an error occurs while starting the transaction, or
* the transaction could not be started.
*/
public void startTransaction() throws SQLException;
/**
* Demarcates the beginning of a transaction scope using the specified transaction
* isolation. Transactions must be properly committed or rolled back to be effective.
* Use the following pattern when working with transactions:
*
* try {
* sqlMap.startTransaction(Connection.TRANSACTION_REPEATABLE_READ);
* // do work
* sqlMap.commitTransaction();
* } finally {
* sqlMap.endTransaction();
* }
*
*
* Always call endTransaction() once startTransaction() has been called.
*
* @throws java.sql.SQLException If an error occurs while starting the transaction, or
* the transaction could not be started.
*/
public void startTransaction(int transactionIsolation) throws SQLException;
/**
* Commits the currently started transaction.
*
* @throws SQLException If an error occurs while committing the transaction, or
* the transaction could not be committed.
*/
public void commitTransaction() throws SQLException;
/**
* Ends a transaction and rolls back if necessary. If the transaction has
* been started, but not committed, it will be rolled back upon calling
* endTransaction().
*
* @throws SQLException If an error occurs during rollback or the transaction could
* not be ended.
*/
public void endTransaction() throws SQLException;
/**
* Allows the developer to easily use an externally supplied connection
* when executing statements.
*
* Important: Using a user supplied connection basically sidesteps the transaction manager,
* so you are responsible for appropriately. Here's a (very) simple example (throws SQLException):
*
* try {
* Connection connection = dataSource.getConnection();
* sqlMap.setUserConnection(connection);
* // do work
* connection.commit();
* } catch (SQLException e) {
* try {
* if (connection != null) commit.rollback();
* } catch (SQLException ignored) {
* // generally ignored
* }
* throw e; // rethrow the exception
* } finally {
* try {
* if (connection != null) connection.close();
* } catch (SQLException ignored) {
* // generally ignored
* }
* }
*
*
* @param connnection
* @throws SQLException
*/
public void setUserConnection(Connection connnection) throws SQLException;
/**
* Returns the current user supplied connection as set by setUserConnection().
*
* TODO : DEPRECATED
*
* @return The current user supplied connection.
* @throws SQLException
* @deprecated Use getCurrentConnection() instead.
*/
public Connection getUserConnection() throws SQLException;
/**
* Returns the current connection in use. If no connection exists null will
* be returned. There may be no connection if no transaction has been started,
* and if no user provided connection has been set.
*
* @return The current connection or null.
* @throws SQLException
*/
public Connection getCurrentConnection() throws SQLException;
/**
* Returns the DataSource instance currently being used by the SqlMapSession.
*
* @return The DataSource instance currently being used by the SqlMapSession.
*/
public DataSource getDataSource();
}
ibatis/src/com/ibatis/sqlmap/engine/ 0000755 0001750 0001750 00000000000 11047641640 017654 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/accessplan/ 0000755 0001750 0001750 00000000000 11047641640 021770 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/accessplan/AccessPlan.java 0000644 0001750 0001750 00000002217 11047641640 024651 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.accessplan;
/**
* An interface to make access to resources consistent, regardless of type.
*/
public interface AccessPlan {
/**
* Sets all of the properties of a bean
*
* @param object - the bean
* @param values - the property values
*/
public void setProperties(Object object, Object[] values);
/**
* Gets all of the properties of a bean
*
* @param object - the bean
* @return the properties
*/
public Object[] getProperties(Object object);
}
ibatis/src/com/ibatis/sqlmap/engine/accessplan/AccessPlanFactory.java 0000644 0001750 0001750 00000005634 11047641640 026207 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.accessplan;
import java.util.Map;
/**
* Factory to get an accesss plan appropriate for an object
*/
public class AccessPlanFactory {
private static boolean bytecodeEnhancementEnabled = false;
private AccessPlanFactory() {
}
/**
* Creates an access plan for working with a bean
*
* @param clazz
* @param propertyNames
* @return An access plan
*/
public static AccessPlan getAccessPlan(Class clazz, String[] propertyNames) {
AccessPlan plan;
boolean complex = false;
if (clazz == null || propertyNames == null) {
complex = true;
} else {
for (int i = 0; i < propertyNames.length; i++) {
if (propertyNames[i].indexOf('[') > -1
|| propertyNames[i].indexOf('.') > -1) {
complex = true;
break;
}
}
}
if (complex) {
plan = new ComplexAccessPlan(clazz, propertyNames);
} else if (Map.class.isAssignableFrom(clazz)) {
plan = new MapAccessPlan(clazz, propertyNames);
} else {
// Possibly causes bug 945746 --but the bug is unconfirmed (can't be reproduced)
if (bytecodeEnhancementEnabled) {
try {
plan = new EnhancedPropertyAccessPlan(clazz, propertyNames);
} catch (Throwable t) {
try {
plan = new PropertyAccessPlan(clazz, propertyNames);
} catch (Throwable t2) {
plan = new ComplexAccessPlan(clazz, propertyNames);
}
}
} else {
try {
plan = new PropertyAccessPlan(clazz, propertyNames);
} catch (Throwable t) {
plan = new ComplexAccessPlan(clazz, propertyNames);
}
}
}
return plan;
}
/**
* Tells whether or not bytecode enhancement (CGLIB, etc) is enabled
*
* @return true if bytecode enhancement is enabled
*/
public static boolean isBytecodeEnhancementEnabled() {
return bytecodeEnhancementEnabled;
}
/**
* Turns on or off bytecode enhancement (CGLIB, etc)
*
* @param bytecodeEnhancementEnabled - the switch
*/
public static void setBytecodeEnhancementEnabled(boolean bytecodeEnhancementEnabled) {
AccessPlanFactory.bytecodeEnhancementEnabled = bytecodeEnhancementEnabled;
}
}
ibatis/src/com/ibatis/sqlmap/engine/accessplan/BaseAccessPlan.java 0000644 0001750 0001750 00000004654 11047641640 025453 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.accessplan;
import com.ibatis.common.beans.ClassInfo;
import com.ibatis.common.beans.Invoker;
/**
* Base implementation of the AccessPlan interface
*/
public abstract class BaseAccessPlan implements AccessPlan {
protected Class clazz;
protected String[] propertyNames;
protected ClassInfo info;
BaseAccessPlan(Class clazz, String[] propertyNames) {
this.clazz = clazz;
this.propertyNames = propertyNames;
info = ClassInfo.getInstance(clazz);
}
protected Class[] getTypes(String[] propertyNames) {
Class[] types = new Class[propertyNames.length];
for (int i = 0; i < propertyNames.length; i++) {
types[i] = info.getGetterType(propertyNames[i]);
}
return types;
}
protected Invoker[] getGetters(String[] propertyNames) {
Invoker[] methods = new Invoker[propertyNames.length];
for (int i = 0; i < propertyNames.length; i++) {
methods[i] = info.getGetInvoker(propertyNames[i]);
}
return methods;
}
protected Invoker[] getSetters(String[] propertyNames) {
Invoker[] methods = new Invoker[propertyNames.length];
for (int i = 0; i < propertyNames.length; i++) {
methods[i] = info.getSetInvoker(propertyNames[i]);
}
return methods;
}
protected String[] getGetterNames(String[] propertyNames) {
String[] names = new String[propertyNames.length];
for (int i = 0; i < propertyNames.length; i++) {
names[i] = info.getGetter(propertyNames[i]).getName();
}
return names;
}
protected String[] getSetterNames(String[] propertyNames) {
String[] names = new String[propertyNames.length];
for (int i = 0; i < propertyNames.length; i++) {
names[i] = info.getSetter(propertyNames[i]).getName();
}
return names;
}
}
ibatis/src/com/ibatis/sqlmap/engine/accessplan/ComplexAccessPlan.java 0000644 0001750 0001750 00000002713 11047641640 026202 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.accessplan;
import com.ibatis.common.beans.Probe;
import com.ibatis.common.beans.ProbeFactory;
/**
* Access plan for working with beans
*/
public class ComplexAccessPlan extends BaseAccessPlan {
private static final Probe PROBE = ProbeFactory.getProbe();
ComplexAccessPlan(Class clazz, String[] propertyNames) {
super(clazz, propertyNames);
}
public void setProperties(Object object, Object[] values) {
for (int i = 0; i < propertyNames.length; i++) {
PROBE.setObject(object, propertyNames[i], values[i]);
}
}
public Object[] getProperties(Object object) {
Object[] values = new Object[propertyNames.length];
for (int i = 0; i < propertyNames.length; i++) {
values[i] = PROBE.getObject(object, propertyNames[i]);
}
return values;
}
}
ibatis/src/com/ibatis/sqlmap/engine/accessplan/EnhancedPropertyAccessPlan.java 0000644 0001750 0001750 00000002511 11047641640 030041 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.accessplan;
import net.sf.cglib.beans.BulkBean;
/**
* Enhanced PropertyAccessPlan (for working with beans using CG Lib)
*/
public class EnhancedPropertyAccessPlan extends BaseAccessPlan {
private BulkBean bulkBean;
EnhancedPropertyAccessPlan(Class clazz, String[] propertyNames) {
super(clazz, propertyNames);
bulkBean = BulkBean.create(clazz, getGetterNames(propertyNames), getSetterNames(propertyNames), getTypes(propertyNames));
}
public void setProperties(Object object, Object[] values) {
bulkBean.setPropertyValues(object, values);
}
public Object[] getProperties(Object object) {
return bulkBean.getPropertyValues(object);
}
}
ibatis/src/com/ibatis/sqlmap/engine/accessplan/MapAccessPlan.java 0000644 0001750 0001750 00000002535 11047641640 025312 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.accessplan;
import java.util.Map;
/**
* Access plan for working with Maps
*/
public class MapAccessPlan extends BaseAccessPlan {
MapAccessPlan(Class clazz, String[] propertyNames) {
super(clazz, propertyNames);
}
public void setProperties(Object object, Object[] values) {
Map map = (Map) object;
for (int i = 0; i < propertyNames.length; i++) {
map.put(propertyNames[i], values[i]);
}
}
public Object[] getProperties(Object object) {
Object[] values = new Object[propertyNames.length];
Map map = (Map) object;
for (int i = 0; i < propertyNames.length; i++) {
values[i] = map.get(propertyNames[i]);
}
return values;
}
}
ibatis/src/com/ibatis/sqlmap/engine/accessplan/PropertyAccessPlan.java 0000644 0001750 0001750 00000004466 11047641640 026426 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.accessplan;
import com.ibatis.common.beans.ClassInfo;
import com.ibatis.common.beans.Invoker;
import java.lang.reflect.Method;
/**
* Property access plan (for working with beans)
*/
public class PropertyAccessPlan extends BaseAccessPlan {
protected static final Object[] NO_ARGUMENTS = new Object[0];
protected Invoker[] setters;
protected Invoker[] getters;
PropertyAccessPlan(Class clazz, String[] propertyNames) {
super(clazz, propertyNames);
setters = getSetters(propertyNames);
getters = getGetters(propertyNames);
}
public void setProperties(Object object, Object[] values) {
int i = 0;
try {
Object[] arg = new Object[1];
for (i = 0; i < propertyNames.length; i++) {
arg[0] = values[i];
try {
setters[i].invoke(object, arg);
} catch (Throwable t) {
throw ClassInfo.unwrapThrowable(t);
}
}
} catch (Throwable t) {
throw new RuntimeException("Error setting property '" + setters[i].getName() + "' of '" +
object + "'. Cause: " + t, t);
}
}
public Object[] getProperties(Object object) {
int i = 0;
Object[] values = new Object[propertyNames.length];
try {
for (i = 0; i < propertyNames.length; i++) {
try {
values[i] = getters[i].invoke(object, NO_ARGUMENTS);
} catch (Throwable t) {
throw ClassInfo.unwrapThrowable(t);
}
}
} catch (Throwable t) {
throw new RuntimeException("Error getting property '" + getters[i].getName() + "' of '" + object + "'. Cause: " + t, t);
}
return values;
}
}
ibatis/src/com/ibatis/sqlmap/engine/builder/ 0000755 0001750 0001750 00000000000 11047641632 021303 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/builder/xml/ 0000755 0001750 0001750 00000000000 11047641632 022103 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/builder/xml/sql-map-2.dtd 0000644 0001750 0001750 00000061570 11047641632 024322 0 ustar twerner twerner
ibatis/src/com/ibatis/sqlmap/engine/builder/xml/sql-map-config-2.dtd 0000644 0001750 0001750 00000026213 11047641632 025560 0 ustar twerner twerner
ibatis/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapClasspathEntityResolver.java 0000644 0001750 0001750 00000006233 11047641632 030731 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.builder.xml;
import com.ibatis.common.resources.*;
import org.xml.sax.*;
import java.io.*;
import java.util.*;
/**
* Offline entity resolver for the iBATIS DTDs
*/
public class SqlMapClasspathEntityResolver implements EntityResolver {
private static final String SQL_MAP_CONFIG_DTD = "com/ibatis/sqlmap/engine/builder/xml/sql-map-config-2.dtd";
private static final String SQL_MAP_DTD = "com/ibatis/sqlmap/engine/builder/xml/sql-map-2.dtd";
private static final Map doctypeMap = new HashMap();
static {
doctypeMap.put("http://www.ibatis.com/dtd/sql-map-config-2.dtd".toUpperCase(), SQL_MAP_CONFIG_DTD);
doctypeMap.put("http://ibatis.apache.org/dtd/sql-map-config-2.dtd".toUpperCase(), SQL_MAP_CONFIG_DTD);
doctypeMap.put("-//iBATIS.com//DTD SQL Map Config 2.0//EN".toUpperCase(), SQL_MAP_CONFIG_DTD);
doctypeMap.put("-//ibatis.apache.org//DTD SQL Map Config 2.0//EN".toUpperCase(), SQL_MAP_CONFIG_DTD);
doctypeMap.put("http://www.ibatis.com/dtd/sql-map-2.dtd".toUpperCase(), SQL_MAP_DTD);
doctypeMap.put("http://ibatis.apache.org/dtd/sql-map-2.dtd".toUpperCase(), SQL_MAP_DTD);
doctypeMap.put("-//iBATIS.com//DTD SQL Map 2.0//EN".toUpperCase(), SQL_MAP_DTD);
doctypeMap.put("-//ibatis.apache.org//DTD SQL Map 2.0//EN".toUpperCase(), SQL_MAP_DTD);
}
/**
* Converts a public DTD into a local one
*
* @param publicId Unused but required by EntityResolver interface
* @param systemId The DTD that is being requested
* @return The InputSource for the DTD
* @throws SAXException If anything goes wrong
*/
public InputSource resolveEntity(String publicId, String systemId)
throws SAXException {
if (publicId != null) publicId = publicId.toUpperCase();
if (systemId != null) systemId = systemId.toUpperCase();
InputSource source = null;
try {
String path = (String) doctypeMap.get(publicId);
source = getInputSource(path, source);
if (source == null) {
path = (String) doctypeMap.get(systemId);
source = getInputSource(path, source);
}
} catch (Exception e) {
throw new SAXException(e.toString());
}
return source;
}
private InputSource getInputSource(String path, InputSource source) {
if (path != null) {
InputStream in = null;
try {
in = Resources.getResourceAsStream(path);
source = new InputSource(in);
} catch (IOException e) {
// ignore, null is ok
}
}
return source;
}
}
ibatis/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapConfigParser.java 0000644 0001750 0001750 00000032250 11047641632 026450 0 ustar twerner twerner package com.ibatis.sqlmap.engine.builder.xml;
import com.ibatis.common.resources.*;
import com.ibatis.common.xml.*;
import com.ibatis.sqlmap.client.*;
import com.ibatis.sqlmap.engine.config.*;
import com.ibatis.sqlmap.engine.transaction.*;
import com.ibatis.sqlmap.engine.datasource.*;
import com.ibatis.sqlmap.engine.mapping.result.*;
import org.w3c.dom.Node;
import java.io.*;
import java.util.Properties;
public class SqlMapConfigParser {
protected final NodeletParser parser = new NodeletParser();
private XmlParserState state = new XmlParserState();
private boolean usingStreams = false;
public SqlMapConfigParser() {
parser.setValidation(true);
parser.setEntityResolver(new SqlMapClasspathEntityResolver());
addSqlMapConfigNodelets();
addGlobalPropNodelets();
addSettingsNodelets();
addTypeAliasNodelets();
addTypeHandlerNodelets();
addTransactionManagerNodelets();
addSqlMapNodelets();
addResultObjectFactoryNodelets();
}
public SqlMapClient parse(Reader reader, Properties props) {
if (props != null) state.setGlobalProps(props);
return parse(reader);
}
public SqlMapClient parse(Reader reader) {
try {
usingStreams = false;
parser.parse(reader);
return state.getConfig().getClient();
} catch (Exception e) {
throw new RuntimeException("Error occurred. Cause: " + e, e);
}
}
public SqlMapClient parse(InputStream inputStream, Properties props) {
if (props != null) state.setGlobalProps(props);
return parse(inputStream);
}
public SqlMapClient parse(InputStream inputStream) {
try {
usingStreams = true;
parser.parse(inputStream);
return state.getConfig().getClient();
} catch (Exception e) {
throw new RuntimeException("Error occurred. Cause: " + e, e);
}
}
private void addSqlMapConfigNodelets() {
parser.addNodelet("/sqlMapConfig/end()", new Nodelet() {
public void process(Node node) throws Exception {
state.getConfig().finalizeSqlMapConfig();
}
});
}
private void addGlobalPropNodelets() {
parser.addNodelet("/sqlMapConfig/properties", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String resource = attributes.getProperty("resource");
String url = attributes.getProperty("url");
state.setGlobalProperties(resource, url);
}
});
}
private void addSettingsNodelets() {
parser.addNodelet("/sqlMapConfig/settings", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
SqlMapConfiguration config = state.getConfig();
String classInfoCacheEnabledAttr = attributes.getProperty("classInfoCacheEnabled");
boolean classInfoCacheEnabled = (classInfoCacheEnabledAttr == null || "true".equals(classInfoCacheEnabledAttr));
config.setClassInfoCacheEnabled(classInfoCacheEnabled);
String lazyLoadingEnabledAttr = attributes.getProperty("lazyLoadingEnabled");
boolean lazyLoadingEnabled = (lazyLoadingEnabledAttr == null || "true".equals(lazyLoadingEnabledAttr));
config.setLazyLoadingEnabled(lazyLoadingEnabled);
String statementCachingEnabledAttr = attributes.getProperty("statementCachingEnabled");
boolean statementCachingEnabled = (statementCachingEnabledAttr == null || "true".equals(statementCachingEnabledAttr));
config.setStatementCachingEnabled(statementCachingEnabled);
String cacheModelsEnabledAttr = attributes.getProperty("cacheModelsEnabled");
boolean cacheModelsEnabled = (cacheModelsEnabledAttr == null || "true".equals(cacheModelsEnabledAttr));
config.setCacheModelsEnabled(cacheModelsEnabled);
String enhancementEnabledAttr = attributes.getProperty("enhancementEnabled");
boolean enhancementEnabled = (enhancementEnabledAttr == null || "true".equals(enhancementEnabledAttr));
config.setEnhancementEnabled(enhancementEnabled);
String useColumnLabelAttr = attributes.getProperty("useColumnLabel");
boolean useColumnLabel = (useColumnLabelAttr == null || "true".equals(useColumnLabelAttr));
config.setUseColumnLabel(useColumnLabel);
String forceMultipleResultSetSupportAttr = attributes.getProperty("forceMultipleResultSetSupport");
boolean forceMultipleResultSetSupport = "true".equals(forceMultipleResultSetSupportAttr);
config.setForceMultipleResultSetSupport(forceMultipleResultSetSupport);
String defaultTimeoutAttr = attributes.getProperty("defaultStatementTimeout");
Integer defaultTimeout = defaultTimeoutAttr == null ? null : Integer.valueOf(defaultTimeoutAttr);
config.setDefaultStatementTimeout(defaultTimeout);
String useStatementNamespacesAttr = attributes.getProperty("useStatementNamespaces");
boolean useStatementNamespaces = "true".equals(useStatementNamespacesAttr);
state.setUseStatementNamespaces(useStatementNamespaces);
}
});
}
private void addTypeAliasNodelets() {
parser.addNodelet("/sqlMapConfig/typeAlias", new Nodelet() {
public void process(Node node) throws Exception {
Properties prop = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String alias = prop.getProperty("alias");
String type = prop.getProperty("type");
state.getConfig().getTypeHandlerFactory().putTypeAlias(alias, type);
}
});
}
private void addTypeHandlerNodelets() {
parser.addNodelet("/sqlMapConfig/typeHandler", new Nodelet() {
public void process(Node node) throws Exception {
Properties prop = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String jdbcType = prop.getProperty("jdbcType");
String javaType = prop.getProperty("javaType");
String callback = prop.getProperty("callback");
javaType = state.getConfig().getTypeHandlerFactory().resolveAlias(javaType);
callback = state.getConfig().getTypeHandlerFactory().resolveAlias(callback);
state.getConfig().newTypeHandler(Resources.classForName(javaType), jdbcType, Resources.instantiate(callback));
}
});
}
private void addTransactionManagerNodelets() {
parser.addNodelet("/sqlMapConfig/transactionManager/property", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String name = attributes.getProperty("name");
String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), state.getGlobalProps());
state.getTxProps().setProperty(name, value);
}
});
parser.addNodelet("/sqlMapConfig/transactionManager/end()", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String type = attributes.getProperty("type");
boolean commitRequired = "true".equals(attributes.getProperty("commitRequired"));
state.getConfig().getErrorContext().setActivity("configuring the transaction manager");
type = state.getConfig().getTypeHandlerFactory().resolveAlias(type);
TransactionManager txManager;
try {
state.getConfig().getErrorContext().setMoreInfo("Check the transaction manager type or class.");
TransactionConfig config = (TransactionConfig) Resources.instantiate(type);
config.setDataSource(state.getDataSource());
state.getConfig().getErrorContext().setMoreInfo("Check the transactio nmanager properties or configuration.");
config.setProperties(state.getTxProps());
config.setForceCommit(commitRequired);
config.setDataSource(state.getDataSource());
state.getConfig().getErrorContext().setMoreInfo(null);
txManager = new TransactionManager(config);
} catch (Exception e) {
if (e instanceof SqlMapException) {
throw (SqlMapException) e;
} else {
throw new SqlMapException("Error initializing TransactionManager. Could not instantiate TransactionConfig. Cause: " + e, e);
}
}
state.getConfig().setTransactionManager(txManager);
}
});
parser.addNodelet("/sqlMapConfig/transactionManager/dataSource/property", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String name = attributes.getProperty("name");
String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), state.getGlobalProps());
state.getDsProps().setProperty(name, value);
}
});
parser.addNodelet("/sqlMapConfig/transactionManager/dataSource/end()", new Nodelet() {
public void process(Node node) throws Exception {
state.getConfig().getErrorContext().setActivity("configuring the data source");
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String type = attributes.getProperty("type");
Properties props = state.getDsProps();
type = state.getConfig().getTypeHandlerFactory().resolveAlias(type);
try {
state.getConfig().getErrorContext().setMoreInfo("Check the data source type or class.");
DataSourceFactory dsFactory = (DataSourceFactory) Resources.instantiate(type);
state.getConfig().getErrorContext().setMoreInfo("Check the data source properties or configuration.");
dsFactory.initialize(props);
state.setDataSource(dsFactory.getDataSource());
state.getConfig().getErrorContext().setMoreInfo(null);
} catch (Exception e) {
if (e instanceof SqlMapException) {
throw (SqlMapException) e;
} else {
throw new SqlMapException("Error initializing DataSource. Could not instantiate DataSourceFactory. Cause: " + e, e);
}
}
}
});
}
protected void addSqlMapNodelets() {
parser.addNodelet("/sqlMapConfig/sqlMap", new Nodelet() {
public void process(Node node) throws Exception {
state.getConfig().getErrorContext().setActivity("loading the SQL Map resource");
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String resource = attributes.getProperty("resource");
String url = attributes.getProperty("url");
if (usingStreams) {
InputStream inputStream = null;
if (resource != null) {
state.getConfig().getErrorContext().setResource(resource);
inputStream = Resources.getResourceAsStream(resource);
} else if (url != null) {
state.getConfig().getErrorContext().setResource(url);
inputStream = Resources.getUrlAsStream(url);
} else {
throw new SqlMapException("The element requires either a resource or a url attribute.");
}
new SqlMapParser(state).parse(inputStream);
} else {
Reader reader = null;
if (resource != null) {
state.getConfig().getErrorContext().setResource(resource);
reader = Resources.getResourceAsReader(resource);
} else if (url != null) {
state.getConfig().getErrorContext().setResource(url);
reader = Resources.getUrlAsReader(url);
} else {
throw new SqlMapException("The element requires either a resource or a url attribute.");
}
new SqlMapParser(state).parse(reader);
}
}
});
}
private void addResultObjectFactoryNodelets() {
parser.addNodelet("/sqlMapConfig/resultObjectFactory", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String type = attributes.getProperty("type");
state.getConfig().getErrorContext().setActivity("configuring the Result Object Factory");
ResultObjectFactory rof;
try {
rof = (ResultObjectFactory) Resources.instantiate(type);
state.getConfig().setResultObjectFactory(rof);
} catch (Exception e) {
throw new SqlMapException("Error instantiating resultObjectFactory: " + type, e);
}
}
});
parser.addNodelet("/sqlMapConfig/resultObjectFactory/property", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String name = attributes.getProperty("name");
String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), state.getGlobalProps());
state.getConfig().getDelegate().getResultObjectFactory().setProperty(name, value);
}
});
}
}
ibatis/src/com/ibatis/sqlmap/engine/builder/xml/SqlMapParser.java 0000644 0001750 0001750 00000042347 11047641632 025332 0 ustar twerner twerner package com.ibatis.sqlmap.engine.builder.xml;
import com.ibatis.common.xml.*;
import com.ibatis.common.resources.*;
import com.ibatis.sqlmap.client.*;
import com.ibatis.sqlmap.engine.config.*;
import com.ibatis.sqlmap.engine.mapping.statement.*;
import com.ibatis.sqlmap.engine.cache.*;
import org.w3c.dom.Node;
import java.io.*;
import java.util.Properties;
public class SqlMapParser {
private final NodeletParser parser;
private XmlParserState state;
private SqlStatementParser statementParser;
public SqlMapParser(XmlParserState state) {
this.parser = new NodeletParser();
this.state = state;
parser.setValidation(true);
parser.setEntityResolver(new SqlMapClasspathEntityResolver());
statementParser = new SqlStatementParser(this.state);
addSqlMapNodelets();
addSqlNodelets();
addTypeAliasNodelets();
addCacheModelNodelets();
addParameterMapNodelets();
addResultMapNodelets();
addStatementNodelets();
}
public void parse(Reader reader) throws NodeletException {
parser.parse(reader);
}
public void parse(InputStream inputStream) throws NodeletException {
parser.parse(inputStream);
}
private void addSqlMapNodelets() {
parser.addNodelet("/sqlMap", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
state.setNamespace(attributes.getProperty("namespace"));
}
});
}
private void addSqlNodelets() {
parser.addNodelet("/sqlMap/sql", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String id = attributes.getProperty("id");
if (state.isUseStatementNamespaces()) {
id = state.applyNamespace(id);
}
if (state.getSqlIncludes().containsKey(id)) {
throw new SqlMapException("Duplicate -include '" + id + "' found.");
} else {
state.getSqlIncludes().put(id, node);
}
}
});
}
private void addTypeAliasNodelets() {
parser.addNodelet("/sqlMap/typeAlias", new Nodelet() {
public void process(Node node) throws Exception {
Properties prop = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String alias = prop.getProperty("alias");
String type = prop.getProperty("type");
state.getConfig().getTypeHandlerFactory().putTypeAlias(alias, type);
}
});
}
private void addCacheModelNodelets() {
parser.addNodelet("/sqlMap/cacheModel", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String id = state.applyNamespace(attributes.getProperty("id"));
String type = attributes.getProperty("type");
String readOnlyAttr = attributes.getProperty("readOnly");
Boolean readOnly = readOnlyAttr == null || readOnlyAttr.length() <= 0 ? null : new Boolean("true".equals(readOnlyAttr));
String serializeAttr = attributes.getProperty("serialize");
Boolean serialize = serializeAttr == null || serializeAttr.length() <= 0 ? null : new Boolean("true".equals(serializeAttr));
type = state.getConfig().getTypeHandlerFactory().resolveAlias(type);
Class clazz = Resources.classForName(type);
if (readOnly == null) {
readOnly = Boolean.TRUE;
}
if (serialize == null) {
serialize = Boolean.FALSE;
}
CacheModelConfig cacheConfig = state.getConfig().newCacheModelConfig(id, (CacheController) Resources.instantiate(clazz), readOnly.booleanValue(), serialize.booleanValue());
state.setCacheConfig(cacheConfig);
}
});
parser.addNodelet("/sqlMap/cacheModel/end()", new Nodelet() {
public void process(Node node) throws Exception {
state.getCacheConfig().setControllerProperties(state.getCacheProps());
}
});
parser.addNodelet("/sqlMap/cacheModel/property", new Nodelet() {
public void process(Node node) throws Exception {
state.getConfig().getErrorContext().setMoreInfo("Check the cache model properties.");
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String name = attributes.getProperty("name");
String value = NodeletUtils.parsePropertyTokens(attributes.getProperty("value"), state.getGlobalProps());
state.getCacheProps().setProperty(name, value);
}
});
parser.addNodelet("/sqlMap/cacheModel/flushOnExecute", new Nodelet() {
public void process(Node node) throws Exception {
Properties childAttributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String statement = childAttributes.getProperty("statement");
state.getCacheConfig().addFlushTriggerStatement(statement);
}
});
parser.addNodelet("/sqlMap/cacheModel/flushInterval", new Nodelet() {
public void process(Node node) throws Exception {
Properties childAttributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
try {
int milliseconds = childAttributes.getProperty("milliseconds") == null ? 0 : Integer.parseInt(childAttributes.getProperty("milliseconds"));
int seconds = childAttributes.getProperty("seconds") == null ? 0 : Integer.parseInt(childAttributes.getProperty("seconds"));
int minutes = childAttributes.getProperty("minutes") == null ? 0 : Integer.parseInt(childAttributes.getProperty("minutes"));
int hours = childAttributes.getProperty("hours") == null ? 0 : Integer.parseInt(childAttributes.getProperty("hours"));
state.getCacheConfig().setFlushInterval(hours, minutes, seconds, milliseconds);
} catch (NumberFormatException e) {
throw new RuntimeException("Error building cache in '" + "resourceNAME" + "'. Flush interval milliseconds must be a valid long integer value. Cause: " + e, e);
}
}
});
}
private void addParameterMapNodelets() {
parser.addNodelet("/sqlMap/parameterMap/end()", new Nodelet() {
public void process(Node node) throws Exception {
state.getConfig().getErrorContext().setMoreInfo(null);
state.getConfig().getErrorContext().setObjectId(null);
state.setParamConfig(null);
}
});
parser.addNodelet("/sqlMap/parameterMap", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String id = state.applyNamespace(attributes.getProperty("id"));
String parameterClassName = attributes.getProperty("class");
parameterClassName = state.getConfig().getTypeHandlerFactory().resolveAlias(parameterClassName);
try {
state.getConfig().getErrorContext().setMoreInfo("Check the parameter class.");
ParameterMapConfig paramConf = state.getConfig().newParameterMapConfig(id, Resources.classForName(parameterClassName));
state.setParamConfig(paramConf);
} catch (Exception e) {
throw new SqlMapException("Error configuring ParameterMap. Could not set ParameterClass. Cause: " + e, e);
}
}
});
parser.addNodelet("/sqlMap/parameterMap/parameter", new Nodelet() {
public void process(Node node) throws Exception {
Properties childAttributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String propertyName = childAttributes.getProperty("property");
String jdbcType = childAttributes.getProperty("jdbcType");
String type = childAttributes.getProperty("typeName");
String javaType = childAttributes.getProperty("javaType");
String resultMap = state.applyNamespace(childAttributes.getProperty("resultMap"));
String nullValue = childAttributes.getProperty("nullValue");
String mode = childAttributes.getProperty("mode");
String callback = childAttributes.getProperty("typeHandler");
String numericScaleProp = childAttributes.getProperty("numericScale");
callback = state.getConfig().getTypeHandlerFactory().resolveAlias(callback);
Object typeHandlerImpl = null;
if (callback != null) {
typeHandlerImpl = Resources.instantiate(callback);
}
javaType = state.getConfig().getTypeHandlerFactory().resolveAlias(javaType);
Class javaClass = null;
try {
if (javaType != null && javaType.length() > 0) {
javaClass = Resources.classForName(javaType);
}
} catch (ClassNotFoundException e) {
throw new RuntimeException("Error setting javaType on parameter mapping. Cause: " + e);
}
Integer numericScale = null;
if (numericScaleProp != null) {
numericScale = new Integer(numericScaleProp);
}
state.getParamConfig().addParameterMapping(propertyName, javaClass, jdbcType, nullValue, mode, type, numericScale, typeHandlerImpl, resultMap);
}
});
}
private void addResultMapNodelets() {
parser.addNodelet("/sqlMap/resultMap/end()", new Nodelet() {
public void process(Node node) throws Exception {
state.getConfig().getErrorContext().setMoreInfo(null);
state.getConfig().getErrorContext().setObjectId(null);
}
});
parser.addNodelet("/sqlMap/resultMap", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String id = state.applyNamespace(attributes.getProperty("id"));
String resultClassName = attributes.getProperty("class");
String extended = state.applyNamespace(attributes.getProperty("extends"));
String xmlName = attributes.getProperty("xmlName");
String groupBy = attributes.getProperty("groupBy");
resultClassName = state.getConfig().getTypeHandlerFactory().resolveAlias(resultClassName);
Class resultClass;
try {
state.getConfig().getErrorContext().setMoreInfo("Check the result class.");
resultClass = Resources.classForName(resultClassName);
} catch (Exception e) {
throw new RuntimeException("Error configuring Result. Could not set ResultClass. Cause: " + e, e);
}
ResultMapConfig resultConf = state.getConfig().newResultMapConfig(id, resultClass, groupBy, extended, xmlName);
state.setResultConfig(resultConf);
}
});
parser.addNodelet("/sqlMap/resultMap/result", new Nodelet() {
public void process(Node node) throws Exception {
Properties childAttributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String propertyName = childAttributes.getProperty("property");
String nullValue = childAttributes.getProperty("nullValue");
String jdbcType = childAttributes.getProperty("jdbcType");
String javaType = childAttributes.getProperty("javaType");
String columnName = childAttributes.getProperty("column");
String columnIndexProp = childAttributes.getProperty("columnIndex");
String statementName = childAttributes.getProperty("select");
String resultMapName = childAttributes.getProperty("resultMap");
String callback = childAttributes.getProperty("typeHandler");
String notNullColumn = childAttributes.getProperty("notNullColumn");
state.getConfig().getErrorContext().setMoreInfo("Check the result mapping property type or name.");
Class javaClass = null;
try {
javaType = state.getConfig().getTypeHandlerFactory().resolveAlias(javaType);
if (javaType != null && javaType.length() > 0) {
javaClass = Resources.classForName(javaType);
}
} catch (ClassNotFoundException e) {
throw new RuntimeException("Error setting java type on result discriminator mapping. Cause: " + e);
}
state.getConfig().getErrorContext().setMoreInfo("Check the result mapping typeHandler attribute '" + callback + "' (must be a TypeHandler or TypeHandlerCallback implementation).");
Object typeHandlerImpl = null;
try {
if (callback != null && callback.length() > 0) {
callback = state.getConfig().getTypeHandlerFactory().resolveAlias(callback);
typeHandlerImpl = Resources.instantiate(callback);
}
} catch (Exception e) {
throw new RuntimeException("Error occurred during custom type handler configuration. Cause: " + e, e);
}
Integer columnIndex = null;
if (columnIndexProp != null) {
try {
columnIndex = new Integer(columnIndexProp);
} catch (Exception e) {
throw new RuntimeException("Error parsing column index. Cause: " + e, e);
}
}
state.getResultConfig().addResultMapping(propertyName, columnName, columnIndex, javaClass, jdbcType, nullValue, notNullColumn, statementName, resultMapName, typeHandlerImpl);
}
});
parser.addNodelet("/sqlMap/resultMap/discriminator/subMap", new Nodelet() {
public void process(Node node) throws Exception {
Properties childAttributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String value = childAttributes.getProperty("value");
String resultMap = childAttributes.getProperty("resultMap");
resultMap = state.applyNamespace(resultMap);
state.getResultConfig().addDiscriminatorSubMap(value, resultMap);
}
});
parser.addNodelet("/sqlMap/resultMap/discriminator", new Nodelet() {
public void process(Node node) throws Exception {
Properties childAttributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String nullValue = childAttributes.getProperty("nullValue");
String jdbcType = childAttributes.getProperty("jdbcType");
String javaType = childAttributes.getProperty("javaType");
String columnName = childAttributes.getProperty("column");
String columnIndexProp = childAttributes.getProperty("columnIndex");
String callback = childAttributes.getProperty("typeHandler");
state.getConfig().getErrorContext().setMoreInfo("Check the disriminator type or name.");
Class javaClass = null;
try {
javaType = state.getConfig().getTypeHandlerFactory().resolveAlias(javaType);
if (javaType != null && javaType.length() > 0) {
javaClass = Resources.classForName(javaType);
}
} catch (ClassNotFoundException e) {
throw new RuntimeException("Error setting java type on result discriminator mapping. Cause: " + e);
}
state.getConfig().getErrorContext().setMoreInfo("Check the result mapping discriminator typeHandler attribute '" + callback + "' (must be a TypeHandlerCallback implementation).");
Object typeHandlerImpl = null;
try {
if (callback != null && callback.length() > 0) {
callback = state.getConfig().getTypeHandlerFactory().resolveAlias(callback);
typeHandlerImpl = Resources.instantiate(callback);
}
} catch (Exception e) {
throw new RuntimeException("Error occurred during custom type handler configuration. Cause: " + e, e);
}
Integer columnIndex = null;
if (columnIndexProp != null) {
try {
columnIndex = new Integer(columnIndexProp);
} catch (Exception e) {
throw new RuntimeException("Error parsing column index. Cause: " + e, e);
}
}
state.getResultConfig().setDiscriminator(columnName, columnIndex, javaClass, jdbcType, nullValue, typeHandlerImpl);
}
});
}
protected void addStatementNodelets() {
parser.addNodelet("/sqlMap/statement", new Nodelet() {
public void process(Node node) throws Exception {
statementParser.parseGeneralStatement(node, new MappedStatement());
}
});
parser.addNodelet("/sqlMap/insert", new Nodelet() {
public void process(Node node) throws Exception {
statementParser.parseGeneralStatement(node, new InsertStatement());
}
});
parser.addNodelet("/sqlMap/update", new Nodelet() {
public void process(Node node) throws Exception {
statementParser.parseGeneralStatement(node, new UpdateStatement());
}
});
parser.addNodelet("/sqlMap/delete", new Nodelet() {
public void process(Node node) throws Exception {
statementParser.parseGeneralStatement(node, new DeleteStatement());
}
});
parser.addNodelet("/sqlMap/select", new Nodelet() {
public void process(Node node) throws Exception {
statementParser.parseGeneralStatement(node, new SelectStatement());
}
});
parser.addNodelet("/sqlMap/procedure", new Nodelet() {
public void process(Node node) throws Exception {
statementParser.parseGeneralStatement(node, new ProcedureStatement());
}
});
}
}
ibatis/src/com/ibatis/sqlmap/engine/builder/xml/SqlStatementParser.java 0000644 0001750 0001750 00000012111 11047641632 026543 0 ustar twerner twerner package com.ibatis.sqlmap.engine.builder.xml;
import com.ibatis.common.xml.*;
import com.ibatis.common.resources.*;
import com.ibatis.sqlmap.engine.config.*;
import com.ibatis.sqlmap.engine.mapping.statement.*;
import com.ibatis.sqlmap.client.*;
import org.w3c.dom.CharacterData;
import org.w3c.dom.*;
import java.util.Properties;
public class SqlStatementParser {
private XmlParserState state;
public SqlStatementParser(XmlParserState config) {
this.state = config;
}
public void parseGeneralStatement(Node node, MappedStatement statement) {
// get attributes
Properties attributes = NodeletUtils.parseAttributes(node, state.getGlobalProps());
String id = attributes.getProperty("id");
String parameterMapName = state.applyNamespace(attributes.getProperty("parameterMap"));
String parameterClassName = attributes.getProperty("parameterClass");
String resultMapName = attributes.getProperty("resultMap");
String resultClassName = attributes.getProperty("resultClass");
String cacheModelName = state.applyNamespace(attributes.getProperty("cacheModel"));
String xmlResultName = attributes.getProperty("xmlResultName");
String resultSetType = attributes.getProperty("resultSetType");
String fetchSize = attributes.getProperty("fetchSize");
String allowRemapping = attributes.getProperty("remapResults");
String timeout = attributes.getProperty("timeout");
if (state.isUseStatementNamespaces()) {
id = state.applyNamespace(id);
}
String[] additionalResultMapNames = null;
if (resultMapName != null) {
additionalResultMapNames = state.getAllButFirstToken(resultMapName);
resultMapName = state.getFirstToken(resultMapName);
resultMapName = state.applyNamespace(resultMapName);
for (int i = 0; i < additionalResultMapNames.length; i++) {
additionalResultMapNames[i] = state.applyNamespace(additionalResultMapNames[i]);
}
}
String[] additionalResultClassNames = null;
if (resultClassName != null) {
additionalResultClassNames = state.getAllButFirstToken(resultClassName);
resultClassName = state.getFirstToken(resultClassName);
}
Class[] additionalResultClasses = null;
if (additionalResultClassNames != null) {
additionalResultClasses = new Class[additionalResultClassNames.length];
for (int i = 0; i < additionalResultClassNames.length; i++) {
additionalResultClasses[i] = resolveClass(additionalResultClassNames[i]);
}
}
state.getConfig().getErrorContext().setMoreInfo("Check the parameter class.");
Class parameterClass = resolveClass(parameterClassName);
state.getConfig().getErrorContext().setMoreInfo("Check the result class.");
Class resultClass = resolveClass(resultClassName);
Integer timeoutInt = timeout == null ? null : new Integer(timeout);
Integer fetchSizeInt = fetchSize == null ? null : new Integer(fetchSize);
boolean allowRemappingBool = "true".equals(allowRemapping);
MappedStatementConfig statementConf = state.getConfig().newMappedStatementConfig(id, statement,
new XMLSqlSource(state, node), parameterMapName, parameterClass, resultMapName, additionalResultMapNames,
resultClass, additionalResultClasses, resultSetType, fetchSizeInt, allowRemappingBool, timeoutInt, cacheModelName,
xmlResultName);
findAndParseSelectKey(node, statementConf);
}
private Class resolveClass(String resultClassName) {
try {
if (resultClassName != null) {
return Resources.classForName(state.getConfig().getTypeHandlerFactory().resolveAlias(resultClassName));
} else {
return null;
}
} catch (ClassNotFoundException e) {
throw new SqlMapException("Error. Could not initialize class. Cause: " + e, e);
}
}
private void findAndParseSelectKey(Node node, MappedStatementConfig config) {
state.getConfig().getErrorContext().setActivity("parsing select key tags");
boolean foundSQLFirst = false;
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
if (child.getNodeType() == Node.CDATA_SECTION_NODE
|| child.getNodeType() == Node.TEXT_NODE) {
String data = ((CharacterData) child).getData();
if (data.trim().length() > 0) {
foundSQLFirst = true;
}
} else if (child.getNodeType() == Node.ELEMENT_NODE
&& "selectKey".equals(child.getNodeName())) {
Properties attributes = NodeletUtils.parseAttributes(child, state.getGlobalProps());
String keyPropName = attributes.getProperty("keyProperty");
String resultClassName = attributes.getProperty("resultClass");
String type = attributes.getProperty("type");
config.setSelectKeyStatement(new XMLSqlSource(state, child), resultClassName, keyPropName, foundSQLFirst, type);
break;
}
}
state.getConfig().getErrorContext().setMoreInfo(null);
}
}
ibatis/src/com/ibatis/sqlmap/engine/builder/xml/XmlParserState.java 0000644 0001750 0001750 00000007475 11047641632 025701 0 ustar twerner twerner package com.ibatis.sqlmap.engine.builder.xml;
import com.ibatis.common.resources.*;
import com.ibatis.sqlmap.engine.config.*;
import javax.sql.DataSource;
import java.util.*;
public class XmlParserState {
private SqlMapConfiguration config = new SqlMapConfiguration();
private Properties globalProps = new Properties();
private Properties txProps = new Properties();
private Properties dsProps = new Properties();
private Properties cacheProps = new Properties();
private boolean useStatementNamespaces = false;
private Map sqlIncludes = new HashMap();
private ParameterMapConfig paramConfig;
private ResultMapConfig resultConfig;
private CacheModelConfig cacheConfig;
private String namespace;
private DataSource dataSource;
public SqlMapConfiguration getConfig() {
return config;
}
public void setGlobalProps(Properties props) {
globalProps = props;
}
public Properties getGlobalProps() {
return globalProps;
}
public Properties getTxProps() {
return txProps;
}
public Properties getDsProps() {
return dsProps;
}
public Properties getCacheProps() {
return cacheProps;
}
public void setUseStatementNamespaces(boolean useStatementNamespaces) {
this.useStatementNamespaces = useStatementNamespaces;
}
public boolean isUseStatementNamespaces() {
return useStatementNamespaces;
}
public Map getSqlIncludes() {
return sqlIncludes;
}
public void setNamespace(String namespace) {
this.namespace = namespace;
}
public String applyNamespace(String id) {
String newId = id;
if (namespace != null && namespace.length() > 0 && id != null && id.indexOf('.') < 0) {
newId = namespace + "." + id;
}
return newId;
}
public CacheModelConfig getCacheConfig() {
return cacheConfig;
}
public void setCacheConfig(CacheModelConfig cacheConfig) {
this.cacheConfig = cacheConfig;
}
public ParameterMapConfig getParamConfig() {
return paramConfig;
}
public void setParamConfig(ParameterMapConfig paramConfig) {
this.paramConfig = paramConfig;
}
public ResultMapConfig getResultConfig() {
return resultConfig;
}
public void setResultConfig(ResultMapConfig resultConfig) {
this.resultConfig = resultConfig;
}
public String getFirstToken(String s) {
return new StringTokenizer(s, ", ", false).nextToken();
}
public String[] getAllButFirstToken(String s) {
List strings = new ArrayList();
StringTokenizer parser = new StringTokenizer(s, ", ", false);
parser.nextToken();
while (parser.hasMoreTokens()) {
strings.add(parser.nextToken());
}
return (String[]) strings.toArray(new String[strings.size()]);
}
public void setGlobalProperties(String resource, String url) {
config.getErrorContext().setActivity("loading global properties");
try {
Properties props;
if (resource != null) {
config.getErrorContext().setResource(resource);
props = Resources.getResourceAsProperties(resource);
} else if (url != null) {
config.getErrorContext().setResource(url);
props = Resources.getUrlAsProperties(url);
} else {
throw new RuntimeException("The " + "properties" + " element requires either a resource or a url attribute.");
}
// Merge properties with those passed in programmatically
if (props != null) {
props.putAll(globalProps);
globalProps = props;
}
} catch (Exception e) {
throw new RuntimeException("Error loading properties. Cause: " + e, e);
}
}
public DataSource getDataSource() {
return dataSource;
}
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
}
ibatis/src/com/ibatis/sqlmap/engine/builder/xml/XMLSqlSource.java 0000644 0001750 0001750 00000011760 11047641632 025254 0 ustar twerner twerner package com.ibatis.sqlmap.engine.builder.xml;
import com.ibatis.common.xml.*;
import com.ibatis.sqlmap.engine.config.*;
import com.ibatis.sqlmap.engine.mapping.parameter.*;
import com.ibatis.sqlmap.engine.mapping.sql.*;
import com.ibatis.sqlmap.engine.mapping.sql.dynamic.*;
import com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements.*;
import com.ibatis.sqlmap.engine.mapping.sql.raw.*;
import org.w3c.dom.CharacterData;
import org.w3c.dom.*;
import java.util.Properties;
public class XMLSqlSource implements SqlSource {
private static final InlineParameterMapParser PARAM_PARSER = new InlineParameterMapParser();
private XmlParserState state;
private Node parentNode;
public XMLSqlSource(XmlParserState config, Node parentNode) {
this.state = config;
this.parentNode = parentNode;
}
public Sql getSql() {
state.getConfig().getErrorContext().setActivity("processing an SQL statement");
boolean isDynamic = false;
StringBuffer sqlBuffer = new StringBuffer();
DynamicSql dynamic = new DynamicSql(state.getConfig().getClient().getDelegate());
isDynamic = parseDynamicTags(parentNode, dynamic, sqlBuffer, isDynamic, false);
String sqlStatement = sqlBuffer.toString();
if (isDynamic) {
return dynamic;
} else {
return new RawSql(sqlStatement);
}
}
private boolean parseDynamicTags(Node node, DynamicParent dynamic, StringBuffer sqlBuffer, boolean isDynamic, boolean postParseRequired) {
state.getConfig().getErrorContext().setActivity("parsing dynamic SQL tags");
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
String nodeName = child.getNodeName();
if (child.getNodeType() == Node.CDATA_SECTION_NODE
|| child.getNodeType() == Node.TEXT_NODE) {
String data = ((CharacterData) child).getData();
data = NodeletUtils.parsePropertyTokens(data, state.getGlobalProps());
SqlText sqlText;
if (postParseRequired) {
sqlText = new SqlText();
sqlText.setPostParseRequired(postParseRequired);
sqlText.setText(data);
} else {
sqlText = PARAM_PARSER.parseInlineParameterMap(state.getConfig().getClient().getDelegate().getTypeHandlerFactory(), data, null);
sqlText.setPostParseRequired(postParseRequired);
}
dynamic.addChild(sqlText);
sqlBuffer.append(data);
} else if ("include".equals(nodeName)) {
Properties attributes = NodeletUtils.parseAttributes(child, state.getGlobalProps());
String refid = (String) attributes.get("refid");
Node includeNode = (Node) state.getSqlIncludes().get(refid);
if (includeNode == null) {
String nsrefid = state.applyNamespace(refid);
includeNode = (Node) state.getSqlIncludes().get(nsrefid);
if (includeNode == null) {
throw new RuntimeException("Could not find SQL statement to include with refid '" + refid + "'");
}
}
isDynamic = parseDynamicTags(includeNode, dynamic, sqlBuffer, isDynamic, false);
} else {
state.getConfig().getErrorContext().setMoreInfo("Check the dynamic tags.");
SqlTagHandler handler = SqlTagHandlerFactory.getSqlTagHandler(nodeName);
if (handler != null) {
isDynamic = true;
SqlTag tag = new SqlTag();
tag.setName(nodeName);
tag.setHandler(handler);
Properties attributes = NodeletUtils.parseAttributes(child, state.getGlobalProps());
tag.setPrependAttr(attributes.getProperty("prepend"));
tag.setPropertyAttr(attributes.getProperty("property"));
tag.setRemoveFirstPrepend(attributes.getProperty("removeFirstPrepend"));
tag.setOpenAttr(attributes.getProperty("open"));
tag.setCloseAttr(attributes.getProperty("close"));
tag.setComparePropertyAttr(attributes.getProperty("compareProperty"));
tag.setCompareValueAttr(attributes.getProperty("compareValue"));
tag.setConjunctionAttr(attributes.getProperty("conjunction"));
// an iterate ancestor requires a post parse
if (dynamic instanceof SqlTag) {
SqlTag parentSqlTag = (SqlTag) dynamic;
if (parentSqlTag.isPostParseRequired() ||
tag.getHandler() instanceof IterateTagHandler) {
tag.setPostParseRequired(true);
}
} else if (dynamic instanceof DynamicSql) {
if (tag.getHandler() instanceof IterateTagHandler) {
tag.setPostParseRequired(true);
}
}
dynamic.addChild(tag);
if (child.hasChildNodes()) {
isDynamic = parseDynamicTags(child, tag, sqlBuffer, isDynamic, tag.isPostParseRequired());
}
}
}
}
state.getConfig().getErrorContext().setMoreInfo(null);
return isDynamic;
}
}
ibatis/src/com/ibatis/sqlmap/engine/cache/ 0000755 0001750 0001750 00000000000 11047641630 020716 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/cache/fifo/ 0000755 0001750 0001750 00000000000 11047641630 021641 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/cache/fifo/FifoCacheController.java 0000644 0001750 0001750 00000006026 11047641630 026363 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.cache.fifo;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import com.ibatis.sqlmap.engine.cache.CacheController;
import com.ibatis.sqlmap.engine.cache.CacheModel;
/**
* FIFO (first in, first out) cache controller implementation
*/
public class FifoCacheController implements CacheController {
private int cacheSize;
private Map cache;
private List keyList;
/**
* Default constructor
*/
public FifoCacheController() {
this.cacheSize = 100;
this.cache = Collections.synchronizedMap(new HashMap());
this.keyList = Collections.synchronizedList(new LinkedList());
}
public int getCacheSize() {
return cacheSize;
}
public void setCacheSize(int cacheSize) {
this.cacheSize = cacheSize;
}
/**
* Configures the cache
*
* @param props Optionally can contain properties [reference-type=WEAK|SOFT|STRONG]
*/
public void setProperties(Properties props) {
String size = props.getProperty("cache-size");
if (size == null) {
size = props.getProperty("size");
}
if (size != null) {
cacheSize = Integer.parseInt(size);
}
}
/**
* Add an object to the cache
*
* @param cacheModel The cacheModel
* @param key The key of the object to be cached
* @param value The object to be cached
*/
public void putObject(CacheModel cacheModel, Object key, Object value) {
cache.put(key, value);
keyList.add(key);
if (keyList.size() > cacheSize) {
try {
Object oldestKey = keyList.remove(0);
cache.remove(oldestKey);
} catch (IndexOutOfBoundsException e) {
//ignore
}
}
}
/**
* Get an object out of the cache.
*
* @param cacheModel The cache model
* @param key The key of the object to be returned
* @return The cached object (or null)
*/
public Object getObject(CacheModel cacheModel, Object key) {
return cache.get(key);
}
public Object removeObject(CacheModel cacheModel, Object key) {
keyList.remove(key);
return cache.remove(key);
}
/**
* Flushes the cache.
*
* @param cacheModel The cache model
*/
public void flush(CacheModel cacheModel) {
cache.clear();
keyList.clear();
}
}
ibatis/src/com/ibatis/sqlmap/engine/cache/lru/ 0000755 0001750 0001750 00000000000 11047641630 021520 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/cache/lru/LruCacheController.java 0000644 0001750 0001750 00000006204 11047641630 026117 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.cache.lru;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import com.ibatis.sqlmap.engine.cache.CacheController;
import com.ibatis.sqlmap.engine.cache.CacheModel;
/**
* LRU (least recently used) cache controller implementation
*/
public class LruCacheController implements CacheController {
private int cacheSize;
private Map cache;
private List keyList;
/**
* Default constructor
*/
public LruCacheController() {
this.cacheSize = 100;
this.cache = Collections.synchronizedMap(new HashMap());
this.keyList = Collections.synchronizedList(new LinkedList());
}
public int getCacheSize() {
return cacheSize;
}
public void setCacheSize(int cacheSize) {
this.cacheSize = cacheSize;
}
/**
* Configures the cache
*
* @param props Optionally can contain properties [reference-type=WEAK|SOFT|STRONG]
*/
public void setProperties(Properties props) {
String size = props.getProperty("cache-size");
if (size == null) {
size = props.getProperty("size");
}
if (size != null) {
cacheSize = Integer.parseInt(size);
}
}
/**
* Add an object to the cache
*
* @param cacheModel The cacheModel
* @param key The key of the object to be cached
* @param value The object to be cached
*/
public void putObject(CacheModel cacheModel, Object key, Object value) {
cache.put(key, value);
keyList.add(key);
if (keyList.size() > cacheSize) {
try {
Object oldestKey = keyList.remove(0);
cache.remove(oldestKey);
} catch (IndexOutOfBoundsException e) {
//ignore
}
}
}
/**
* Get an object out of the cache.
*
* @param cacheModel The cache model
* @param key The key of the object to be returned
* @return The cached object (or null)
*/
public Object getObject(CacheModel cacheModel, Object key) {
Object result = cache.get(key);
keyList.remove(key);
if (result != null) {
keyList.add(key);
}
return result;
}
public Object removeObject(CacheModel cacheModel, Object key) {
keyList.remove(key);
return cache.remove(key);
}
/**
* Flushes the cache.
*
* @param cacheModel The cache model
*/
public void flush(CacheModel cacheModel) {
cache.clear();
keyList.clear();
}
}
ibatis/src/com/ibatis/sqlmap/engine/cache/memory/ 0000755 0001750 0001750 00000000000 11047641630 022226 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/cache/memory/MemoryCacheController.java 0000644 0001750 0001750 00000010431 11047641630 027330 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.cache.memory;
import com.ibatis.sqlmap.engine.cache.CacheController;
import com.ibatis.sqlmap.engine.cache.CacheModel;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
* Memory-based implementation of CacheController
*/
public class MemoryCacheController implements CacheController {
private MemoryCacheLevel referenceType = MemoryCacheLevel.WEAK;
private Map cache = Collections.synchronizedMap(new HashMap());
/**
* Configures the cache
*
* @param props Optionally can contain properties [reference-type=WEAK|SOFT|STRONG]
*/
public void setProperties(Properties props) {
String refType = props.getProperty("reference-type");
if (refType == null) {
refType = props.getProperty("referenceType");
}
if (refType != null) {
referenceType = MemoryCacheLevel.getByReferenceType(refType);
}
}
public MemoryCacheLevel getReferenceType() {
return referenceType;
}
public void setReferenceType(MemoryCacheLevel referenceType) {
this.referenceType = referenceType;
}
/**
* Add an object to the cache
*
* @param cacheModel The cacheModel
* @param key The key of the object to be cached
* @param value The object to be cached
*/
public void putObject(CacheModel cacheModel, Object key, Object value) {
Object reference = null;
if (referenceType.equals(MemoryCacheLevel.WEAK)) {
reference = new WeakReference(value);
} else if (referenceType.equals(MemoryCacheLevel.SOFT)) {
reference = new SoftReference(value);
} else if (referenceType.equals(MemoryCacheLevel.STRONG)) {
reference = new StrongReference(value);
}
cache.put(key, reference);
}
/**
* Get an object out of the cache.
*
* @param cacheModel The cache model
* @param key The key of the object to be returned
* @return The cached object (or null)
*/
public Object getObject(CacheModel cacheModel, Object key) {
Object value = null;
Object ref = cache.get(key);
if (ref != null) {
if (ref instanceof StrongReference) {
value = ((StrongReference) ref).get();
} else if (ref instanceof SoftReference) {
value = ((SoftReference) ref).get();
} else if (ref instanceof WeakReference) {
value = ((WeakReference) ref).get();
}
}
return value;
}
public Object removeObject(CacheModel cacheModel, Object key) {
Object value = null;
Object ref = cache.remove(key);
if (ref != null) {
if (ref instanceof StrongReference) {
value = ((StrongReference) ref).get();
} else if (ref instanceof SoftReference) {
value = ((SoftReference) ref).get();
} else if (ref instanceof WeakReference) {
value = ((WeakReference) ref).get();
}
}
return value;
}
/**
* Flushes the cache.
*
* @param cacheModel The cache model
*/
public void flush(CacheModel cacheModel) {
cache.clear();
}
/**
* Class to implement a strong (permanent) reference.
*/
private static class StrongReference {
private Object object;
/**
* StrongReference constructor for an object
* @param object - the Object to store
*/
public StrongReference(Object object) {
this.object = object;
}
/**
* Getter to get the object stored in the StrongReference
* @return - the stored Object
*/
public Object get() {
return object;
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/cache/memory/MemoryCacheLevel.java 0000644 0001750 0001750 00000006712 11047641630 026263 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.cache.memory;
import com.ibatis.sqlmap.client.SqlMapException;
import java.util.HashMap;
import java.util.Map;
/**
* An enumeration for the values for the memory cache levels
*/
public final class MemoryCacheLevel {
private static Map cacheLevelMap = new HashMap();
/**
* Constant for weak caching
* This cache model is probably the best choice in most cases. It will increase
* performance for popular results, but it will absolutely release the memory to
* be used in allocating other objects, assuming that the results are not currently
* in use.
*/
public final static MemoryCacheLevel WEAK;
/**
* Constant for soft caching.
* This cache model will reduce the likelihood of running out of memory in case the
* results are not currently in use and the memory is needed for other objects.
* However, this is not the most aggressive cache-model in that regard. Hence,
* memory still might be allocated and unavailable for more important objects.
*/
public final static MemoryCacheLevel SOFT;
/**
* Constant for strong caching.
* This cache model will guarantee that the results stay in memory until the cache
* is explicitly flushed. This is ideal for results that are:
*
* - very small
* - absolutely static
* - used very often
*
* The advantage is that performance will be very good for this particular query.
* The disadvantage is that if the memory used by these results is needed, then it
* will not be released to make room for other objects (possibly more important
* objects).
*/
public final static MemoryCacheLevel STRONG;
private String referenceType;
static {
WEAK = new MemoryCacheLevel("WEAK");
SOFT = new MemoryCacheLevel("SOFT");
STRONG = new MemoryCacheLevel("STRONG");
cacheLevelMap.put(WEAK.referenceType, WEAK);
cacheLevelMap.put(SOFT.referenceType, SOFT);
cacheLevelMap.put(STRONG.referenceType, STRONG);
}
/**
* Creates a new instance of CacheLevel
*/
private MemoryCacheLevel(String type) {
this.referenceType = type;
}
/**
* Getter for the reference type
*
* @return the type of reference type used
*/
public String getReferenceType() {
return this.referenceType;
}
/**
* Gets a MemoryCacheLevel by name
*
* @param refType the name of the reference type
* @return the MemoryCacheLevel that the name indicates
*/
public static MemoryCacheLevel getByReferenceType(String refType) {
MemoryCacheLevel cacheLevel = (MemoryCacheLevel) cacheLevelMap.get(refType);
if (cacheLevel == null) {
throw new SqlMapException("Error getting CacheLevel (reference type) for name: '" + refType + "'.");
}
return cacheLevel;
}
}
ibatis/src/com/ibatis/sqlmap/engine/cache/oscache/ 0000755 0001750 0001750 00000000000 11047641630 022323 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/cache/oscache/OSCacheController.java 0000644 0001750 0001750 00000004653 11047641630 026507 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.cache.oscache;
import com.ibatis.sqlmap.engine.cache.CacheController;
import com.ibatis.sqlmap.engine.cache.CacheModel;
import com.opensymphony.oscache.base.NeedsRefreshException;
import com.opensymphony.oscache.general.GeneralCacheAdministrator;
import java.util.Properties;
/**
* Cache implementation for using OSCache with iBATIS
*/
public class OSCacheController implements CacheController {
private static final GeneralCacheAdministrator CACHE = new GeneralCacheAdministrator();
public void flush(CacheModel cacheModel) {
CACHE.flushGroup(cacheModel.getId());
}
public Object getObject(CacheModel cacheModel, Object key) {
String keyString = key.toString();
try {
int refreshPeriod = (int) (cacheModel.getFlushIntervalSeconds());
return CACHE.getFromCache(keyString, refreshPeriod);
} catch (NeedsRefreshException e) {
CACHE.cancelUpdate(keyString);
return null;
}
}
public Object removeObject(CacheModel cacheModel, Object key) {
Object result;
String keyString = key.toString();
try {
int refreshPeriod = (int) (cacheModel.getFlushIntervalSeconds());
Object value = CACHE.getFromCache(keyString, refreshPeriod);
if (value != null) {
CACHE.flushEntry(keyString);
}
result = value;
} catch (NeedsRefreshException e) {
try {
CACHE.flushEntry(keyString);
} finally {
CACHE.cancelUpdate(keyString);
result = null;
}
}
return result;
}
public void putObject(CacheModel cacheModel, Object key, Object object) {
String keyString = key.toString();
CACHE.putInCache(keyString, object, new String[]{cacheModel.getId()});
}
public void setProperties(Properties props) {
}
}
ibatis/src/com/ibatis/sqlmap/engine/cache/CacheController.java 0000644 0001750 0001750 00000003624 11047641630 024635 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.cache;
import java.util.Properties;
/**
* Cache controller (implementation) interface
*/
public interface CacheController {
/**
* Flush a cache model
*
* @param cacheModel - the model to flush
*/
public void flush(CacheModel cacheModel);
/**
* Get an object from a cache model
*
* @param cacheModel - the model
* @param key - the key to the object
* @return the object if in the cache, or null(?)
*/
public Object getObject(CacheModel cacheModel, Object key);
/**
* Remove an object from a cache model
*
* @param cacheModel - the model to remove the object from
* @param key - the key to the object
* @return the removed object(?)
*/
public Object removeObject(CacheModel cacheModel, Object key);
/**
* Put an object into a cache model
*
* @param cacheModel - the model to add the object to
* @param key - the key to the object
* @param object - the object to add
*/
public void putObject(CacheModel cacheModel, Object key, Object object);
/**
* Configure a cache controller
*
* @param props - the properties object continaing configuration information
*/
public void setProperties(Properties props);
} ibatis/src/com/ibatis/sqlmap/engine/cache/CacheKey.java 0000644 0001750 0001750 00000006774 11047641630 023253 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.cache;
import java.util.List;
import java.util.ArrayList;
/**
* Hash value generator for cache keys
*/
public class CacheKey {
private static final int DEFAULT_MULTIPLYER = 37;
private static final int DEFAULT_HASHCODE = 17;
private int multiplier;
private int hashcode;
private long checksum;
private int count;
private List paramList = new ArrayList();
/**
* Default constructor
*/
public CacheKey() {
hashcode = DEFAULT_HASHCODE;
multiplier = DEFAULT_MULTIPLYER;
count = 0;
}
/**
* Constructor that supplies an initial hashcode
*
* @param initialNonZeroOddNumber - the hashcode to use
*/
public CacheKey(int initialNonZeroOddNumber) {
hashcode = initialNonZeroOddNumber;
multiplier = DEFAULT_MULTIPLYER;
count = 0;
}
/**
* Costructor that supplies an initial hashcode and multiplier
*
* @param initialNonZeroOddNumber - the hashcode to use
* @param multiplierNonZeroOddNumber - the multiplier to use
*/
public CacheKey(int initialNonZeroOddNumber, int multiplierNonZeroOddNumber) {
hashcode = initialNonZeroOddNumber;
multiplier = multiplierNonZeroOddNumber;
count = 0;
}
/**
* Updates this object with new information based on an int value
*
* @param x - the int value
* @return the cache key
*/
public CacheKey update(int x) {
update(new Integer(x));
return this;
}
/**
* Updates this object with new information based on an object
*
* @param object - the object
* @return the cachekey
*/
public CacheKey update(Object object) {
int baseHashCode = object.hashCode();
count++;
checksum += baseHashCode;
baseHashCode *= count;
hashcode = multiplier * hashcode + baseHashCode;
paramList.add(object);
return this;
}
public boolean equals(Object object) {
if (this == object) return true;
if (!(object instanceof CacheKey)) return false;
final CacheKey cacheKey = (CacheKey) object;
if (hashcode != cacheKey.hashcode) return false;
if (checksum != cacheKey.checksum) return false;
if (count != cacheKey.count) return false;
for (int i=0; i < paramList.size(); i++) {
Object thisParam = paramList.get(i);
Object thatParam = cacheKey.paramList.get(i);
if(thisParam == null) {
if (thatParam != null) return false;
} else {
if (!thisParam.equals(thatParam)) return false;
}
}
return true;
}
public int hashCode() {
return hashcode;
}
public String toString() {
StringBuffer returnValue = new StringBuffer().append(hashcode).append('|').append(checksum);
for (int i=0; i < paramList.size(); i++) {
returnValue.append('|').append(paramList.get(i));
}
return returnValue.toString();
}
}
ibatis/src/com/ibatis/sqlmap/engine/cache/CacheModel.java 0000644 0001750 0001750 00000023627 11047641630 023557 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.cache;
import com.ibatis.common.logging.Log;
import com.ibatis.common.logging.LogFactory;
import com.ibatis.sqlmap.engine.mapping.statement.ExecuteListener;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import java.io.*;
import java.util.*;
/**
* Wrapper for Caches.
*/
public class CacheModel implements ExecuteListener {
private static final Log log = LogFactory.getLog(CacheModel.class);
private static final int MAX_OBJECT_LOG_SIZE = 200;
/**
* This is used to represent null objects that are returned from the cache so
* that they can be cached, too.
*/
public static final Object NULL_OBJECT = new String("SERIALIZABLE_NULL_OBJECT");
private int requests = 0;
private int hits = 0;
/**
* Constant to turn off periodic cache flushes
*/
private static final long NO_FLUSH_INTERVAL = -99999;
private String id;
private boolean readOnly;
private boolean serialize;
private long lastFlush;
private long flushInterval;
private long flushIntervalSeconds;
private Set flushTriggerStatements;
private CacheController controller;
private String resource;
/**
* Default constructor
*/
public CacheModel() {
this.flushInterval = NO_FLUSH_INTERVAL;
this.flushIntervalSeconds = NO_FLUSH_INTERVAL;
this.lastFlush = System.currentTimeMillis();
this.flushTriggerStatements = new HashSet();
}
/**
* Getter for the cache model's id
*
* @return the id
*/
public String getId() {
return id;
}
/**
* Setter for the cache model's id
*
* @param id - the new id
*/
public void setId(String id) {
this.id = id;
}
/**
* Getter for read-only property
*
* @return true if a read-only model
*/
public boolean isReadOnly() {
return readOnly;
}
/**
* Setter for read-only property
*
* @param readOnly - the new setting
*/
public void setReadOnly(boolean readOnly) {
this.readOnly = readOnly;
}
/**
* Getter to tell if the cache serializes
*
* @return true if the cache model serializes objects
*/
public boolean isSerialize() {
return serialize;
}
/**
* Setter to tell the cache to serialize objects
*
* @param serialize - if the cache model is to serialize objects
*/
public void setSerialize(boolean serialize) {
this.serialize = serialize;
}
/**
* Getter for resource property
*
* @return the value of the resource property
*/
public String getResource() {
return resource;
}
/**
* Setter for resource property
*
* @param resource - the new value
*/
public void setResource(String resource) {
this.resource = resource;
}
/**
* Sets up the controller for the cache model
*
* @throws ClassNotFoundException - if the class cannot be found
* @throws InstantiationException - if the class cannot be instantiated
* @throws IllegalAccessException - if the classes constructor is not accessible
*/
public void setCacheController(CacheController controller)
throws ClassNotFoundException, InstantiationException, IllegalAccessException {
this.controller = controller;
}
/**
* Getter for flushInterval property
*
* @return The flushInterval (in milliseconds)
*/
public long getFlushInterval() {
return flushInterval;
}
/**
* Getter for flushInterval property
*
* @return The flushInterval (in milliseconds)
*/
public long getFlushIntervalSeconds() {
return flushIntervalSeconds;
}
/**
* Setter for flushInterval property
*
* @param flushInterval The new flushInterval (in milliseconds)
*/
public void setFlushInterval(long flushInterval) {
this.flushInterval = flushInterval;
this.flushIntervalSeconds = flushInterval / 1000;
}
/**
* Adds a flushTriggerStatment. When a flushTriggerStatment is executed, the
* cache is flushed (cleared).
*
* @param statementName The statement to add.
*/
public void addFlushTriggerStatement(String statementName) {
flushTriggerStatements.add(statementName);
}
/**
* Gets an Iterator containing all flushTriggerStatment objects for this cache.
*
* @return The Iterator
*/
public Iterator getFlushTriggerStatementNames() {
return flushTriggerStatements.iterator();
}
/**
* ExecuteListener event. This will be called by a MappedStatement
* for which this cache is registered as a ExecuteListener. It will
* be called each time an executeXXXXXX method is called. In the
* case of the Cache class, it is registered in order to flush the
* cache whenever a certain statement is executed.
* (i.e. the flushOnExecute cache policy)
*
* @param statement The statement to execute
*/
public void onExecuteStatement(MappedStatement statement) {
flush();
}
/**
* Returns statistical information about the cache.
*
* @return the number of cache hits divided by the total requests
*/
public double getHitRatio() {
return (double) hits / (double) requests;
}
/**
* Configures the cache
*
* @param props
*/
public void configure(Properties props) {
controller.setProperties(props);
}
/**
* Clears the cache
*/
public void flush() {
synchronized (this) {
controller.flush(this);
lastFlush = System.currentTimeMillis();
if ( log.isDebugEnabled() ) {
log("flushed", false, null);
}
}
}
/**
* Get an object out of the cache.
* A side effect of this method is that is may clear the cache if it has not been
* cleared in the flushInterval.
*
* @param key The key of the object to be returned
* @return The cached object (or null)
*/
public Object getObject(CacheKey key) {
Object value = null;
synchronized (this) {
if (flushInterval != NO_FLUSH_INTERVAL
&& System.currentTimeMillis() - lastFlush > flushInterval) {
flush();
}
value = controller.getObject(this, key);
if (serialize && !readOnly &&
(value != NULL_OBJECT && value != null)) {
try {
ByteArrayInputStream bis = new ByteArrayInputStream((byte[]) value);
ObjectInputStream ois = new ObjectInputStream(bis);
value = ois.readObject();
ois.close();
} catch (Exception e) {
throw new RuntimeException("Error caching serializable object. Be sure you're not attempting to use " +
"a serialized cache for an object that may be taking advantage of lazy loading. Cause: " + e, e);
}
}
requests++;
if (value != null) {
hits++;
}
if ( log.isDebugEnabled() ) {
if ( value != null ) {
log("retrieved object", true, value);
}
else {
log("cache miss", false, null);
}
}
}
return value;
}
/**
* Add an object to the cache
*
* @param key The key of the object to be cached
* @param value The object to be cached
*/
public void putObject(CacheKey key, Object value) {
if (null == value) value = NULL_OBJECT;
synchronized ( this ) {
if (serialize && !readOnly && value != NULL_OBJECT) {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(value);
oos.flush();
oos.close();
value = bos.toByteArray();
} catch (IOException e) {
throw new RuntimeException("Error caching serializable object. Cause: " + e, e);
}
}
controller.putObject(this, key, value);
if ( log.isDebugEnabled() ) {
log("stored object", true, value);
}
}
}
/**
* Get the maximum size of an object in the log output.
*
* @return Maximum size of a logged object in the output
*/
protected int getMaxObjectLogSize() {
return MAX_OBJECT_LOG_SIZE;
}
/**
* Log a cache action. Since this method is pretty heavy
* weight, it's best to enclose it with a log.isDebugEnabled()
* when called.
*
* @param action String to output
* @param addValue Add the value being cached to the log
* @param cacheValue The value being logged
*/
protected void log(String action, boolean addValue,
Object cacheValue) {
StringBuffer output = new StringBuffer("Cache '");
output.append(getId());
output.append("': ");
output.append(action);
if ( addValue ) {
String cacheObjectStr = (cacheValue == null ? "null" : cacheValue.toString());
output.append(" '");
if ( cacheObjectStr.length() < getMaxObjectLogSize() ) {
output.append(cacheObjectStr.toString());
}
else {
output.append(cacheObjectStr.substring(1,
getMaxObjectLogSize()));
output.append("...");
}
output.append("'");
}
log.debug(output.toString());
}
public void setControllerProperties(Properties cacheProps) {
controller.setProperties(cacheProps);
}
} ibatis/src/com/ibatis/sqlmap/engine/config/ 0000755 0001750 0001750 00000000000 11047641632 021122 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/config/CacheModelConfig.java 0000644 0001750 0001750 00000004326 11047641632 025104 0 ustar twerner twerner package com.ibatis.sqlmap.engine.config;
import com.ibatis.sqlmap.engine.cache.*;
import com.ibatis.sqlmap.engine.impl.*;
import com.ibatis.sqlmap.engine.scope.*;
import java.util.Properties;
public class CacheModelConfig {
private ErrorContext errorContext;
private CacheModel cacheModel;
CacheModelConfig(SqlMapConfiguration config, String id, CacheController controller, boolean readOnly, boolean serialize) {
this.errorContext = config.getErrorContext();
this.cacheModel = new CacheModel();
SqlMapClientImpl client = config.getClient();
errorContext.setActivity("building a cache model");
cacheModel.setReadOnly(readOnly);
cacheModel.setSerialize(serialize);
errorContext.setObjectId(id + " cache model");
errorContext.setMoreInfo("Check the cache model type.");
cacheModel.setId(id);
cacheModel.setResource(errorContext.getResource());
try {
cacheModel.setCacheController(controller);
} catch (Exception e) {
throw new RuntimeException("Error setting Cache Controller Class. Cause: " + e, e);
}
errorContext.setMoreInfo("Check the cache model configuration.");
if (client.getDelegate().isCacheModelsEnabled()) {
client.getDelegate().addCacheModel(cacheModel);
}
errorContext.setMoreInfo(null);
errorContext.setObjectId(null);
}
public void setFlushInterval(long hours, long minutes, long seconds, long milliseconds) {
errorContext.setMoreInfo("Check the cache model flush interval.");
long t = 0L;
t += milliseconds;
t += seconds * 1000L;
t += minutes * 60L * 1000L;
t += hours * 60L * 60L * 1000L;
if (t < 1L)
throw new RuntimeException("A flush interval must specify one or more of milliseconds, seconds, minutes or hours.");
cacheModel.setFlushInterval(t);
}
public void addFlushTriggerStatement(String statement) {
errorContext.setMoreInfo("Check the cache model flush on statement elements.");
cacheModel.addFlushTriggerStatement(statement);
}
public CacheModel getCacheModel() {
return cacheModel;
}
public void setControllerProperties(Properties cacheProps) {
cacheModel.setControllerProperties(cacheProps);
}
}
ibatis/src/com/ibatis/sqlmap/engine/config/MappedStatementConfig.java 0000644 0001750 0001750 00000023132 11047641632 026207 0 ustar twerner twerner package com.ibatis.sqlmap.engine.config;
import com.ibatis.common.beans.*;
import com.ibatis.common.resources.*;
import com.ibatis.sqlmap.client.*;
import com.ibatis.sqlmap.engine.cache.*;
import com.ibatis.sqlmap.engine.impl.*;
import com.ibatis.sqlmap.engine.mapping.parameter.*;
import com.ibatis.sqlmap.engine.mapping.result.*;
import com.ibatis.sqlmap.engine.mapping.sql.*;
import com.ibatis.sqlmap.engine.mapping.sql.dynamic.*;
import com.ibatis.sqlmap.engine.mapping.sql.simple.*;
import com.ibatis.sqlmap.engine.mapping.sql.stat.*;
import com.ibatis.sqlmap.engine.mapping.statement.*;
import com.ibatis.sqlmap.engine.scope.*;
import com.ibatis.sqlmap.engine.type.*;
import java.sql.ResultSet;
import java.util.*;
public class MappedStatementConfig {
private static final Probe PROBE = ProbeFactory.getProbe();
private static final InlineParameterMapParser PARAM_PARSER = new InlineParameterMapParser();
private ErrorContext errorContext;
private SqlMapClientImpl client;
private TypeHandlerFactory typeHandlerFactory;
private MappedStatement mappedStatement;
private MappedStatement rootStatement;
MappedStatementConfig(SqlMapConfiguration config, String id, MappedStatement statement, SqlSource processor,
String parameterMapName, Class parameterClass, String resultMapName,
String[] additionalResultMapNames, Class resultClass, Class[] additionalResultClasses,
String cacheModelName, String resultSetType, Integer fetchSize, boolean allowRemapping,
Integer timeout, Integer defaultStatementTimeout, String xmlResultName) {
this.errorContext = config.getErrorContext();
this.client = config.getClient();
SqlMapExecutorDelegate delegate = client.getDelegate();
this.typeHandlerFactory = config.getTypeHandlerFactory();
errorContext.setActivity("parsing a mapped statement");
errorContext.setObjectId(id + " statement");
errorContext.setMoreInfo("Check the result map name.");
if (resultMapName != null) {
statement.setResultMap(client.getDelegate().getResultMap(resultMapName));
if (additionalResultMapNames != null) {
for (int i = 0; i < additionalResultMapNames.length; i++) {
statement.addResultMap(client.getDelegate().getResultMap(additionalResultMapNames[i]));
}
}
}
errorContext.setMoreInfo("Check the parameter map name.");
if (parameterMapName != null) {
statement.setParameterMap(client.getDelegate().getParameterMap(parameterMapName));
}
statement.setId(id);
statement.setResource(errorContext.getResource());
if (resultSetType != null) {
if ("FORWARD_ONLY".equals(resultSetType)) {
statement.setResultSetType(new Integer(ResultSet.TYPE_FORWARD_ONLY));
} else if ("SCROLL_INSENSITIVE".equals(resultSetType)) {
statement.setResultSetType(new Integer(ResultSet.TYPE_SCROLL_INSENSITIVE));
} else if ("SCROLL_SENSITIVE".equals(resultSetType)) {
statement.setResultSetType(new Integer(ResultSet.TYPE_SCROLL_SENSITIVE));
}
}
if (fetchSize != null) {
statement.setFetchSize(fetchSize);
}
// set parameter class either from attribute or from map (make sure to match)
ParameterMap parameterMap = statement.getParameterMap();
if (parameterMap == null) {
statement.setParameterClass(parameterClass);
} else {
statement.setParameterClass(parameterMap.getParameterClass());
}
// process SQL statement, including inline parameter maps
errorContext.setMoreInfo("Check the SQL statement.");
Sql sql = processor.getSql();
setSqlForStatement(statement, sql);
// set up either null result map or automatic result mapping
ResultMap resultMap = (ResultMap) statement.getResultMap();
if (resultMap == null && resultClass == null) {
statement.setResultMap(null);
} else if (resultMap == null) {
resultMap = buildAutoResultMap(allowRemapping, statement, resultClass, xmlResultName);
statement.setResultMap(resultMap);
if (additionalResultClasses != null) {
for (int i = 0; i < additionalResultClasses.length; i++) {
statement.addResultMap(buildAutoResultMap(allowRemapping, statement, additionalResultClasses[i], xmlResultName));
}
}
}
statement.setTimeout(defaultStatementTimeout);
if (timeout != null) {
try {
statement.setTimeout(timeout);
} catch (NumberFormatException e) {
throw new SqlMapException("Specified timeout value for statement " + statement.getId() + " is not a valid integer");
}
}
errorContext.setMoreInfo(null);
errorContext.setObjectId(null);
statement.setSqlMapClient(client);
if (cacheModelName != null && cacheModelName.length() > 0 && client.getDelegate().isCacheModelsEnabled()) {
CacheModel cacheModel = client.getDelegate().getCacheModel(cacheModelName);
mappedStatement = new CachingStatement(statement, cacheModel);
} else {
mappedStatement = statement;
}
rootStatement = statement;
delegate.addMappedStatement(mappedStatement);
}
public void setSelectKeyStatement(SqlSource processor, String resultClassName, String keyPropName, boolean runAfterSQL, String type) {
if (rootStatement instanceof InsertStatement) {
InsertStatement insertStatement = ((InsertStatement) rootStatement);
Class parameterClass = insertStatement.getParameterClass();
errorContext.setActivity("parsing a select key");
SelectKeyStatement selectKeyStatement = new SelectKeyStatement();
resultClassName = typeHandlerFactory.resolveAlias(resultClassName);
Class resultClass = null;
// get parameter and result maps
selectKeyStatement.setSqlMapClient(client);
selectKeyStatement.setId(insertStatement.getId() + "-SelectKey");
selectKeyStatement.setResource(errorContext.getResource());
selectKeyStatement.setKeyProperty(keyPropName);
selectKeyStatement.setRunAfterSQL(runAfterSQL);
// process the type (pre or post) attribute
if (type != null) {
selectKeyStatement.setRunAfterSQL("post".equals(type));
}
try {
if (resultClassName != null) {
errorContext.setMoreInfo("Check the select key result class.");
resultClass = Resources.classForName(resultClassName);
} else {
if (keyPropName != null && parameterClass != null) {
resultClass = PROBE.getPropertyTypeForSetter(parameterClass, selectKeyStatement.getKeyProperty());
}
}
} catch (ClassNotFoundException e) {
throw new SqlMapException("Error. Could not set result class. Cause: " + e, e);
}
if (resultClass == null) {
resultClass = Object.class;
}
// process SQL statement, including inline parameter maps
errorContext.setMoreInfo("Check the select key SQL statement.");
Sql sql = processor.getSql();
setSqlForStatement(selectKeyStatement, sql);
ResultMap resultMap;
resultMap = new AutoResultMap(client.getDelegate(), false);
resultMap.setId(selectKeyStatement.getId() + "-AutoResultMap");
resultMap.setResultClass(resultClass);
resultMap.setResource(selectKeyStatement.getResource());
selectKeyStatement.setResultMap(resultMap);
errorContext.setMoreInfo(null);
insertStatement.setSelectKeyStatement(selectKeyStatement);
} else {
throw new SqlMapException("You cant set a select key statement on statement named " + rootStatement.getId() + " because it is not an InsertStatement.");
}
}
private void setSqlForStatement(MappedStatement statement, Sql sql) {
if (sql instanceof DynamicSql) {
statement.setSql(sql);
} else {
applyInlineParameterMap(statement, sql.getSql(null, null));
}
}
private void applyInlineParameterMap(MappedStatement statement, String sqlStatement) {
String newSql = sqlStatement;
errorContext.setActivity("building an inline parameter map");
ParameterMap parameterMap = statement.getParameterMap();
errorContext.setMoreInfo("Check the inline parameters.");
if (parameterMap == null) {
ParameterMap map;
map = new ParameterMap(client.getDelegate());
map.setId(statement.getId() + "-InlineParameterMap");
map.setParameterClass(statement.getParameterClass());
map.setResource(statement.getResource());
statement.setParameterMap(map);
SqlText sqlText = PARAM_PARSER.parseInlineParameterMap(client.getDelegate().getTypeHandlerFactory(), newSql, statement.getParameterClass());
newSql = sqlText.getText();
List mappingList = Arrays.asList(sqlText.getParameterMappings());
map.setParameterMappingList(mappingList);
}
Sql sql;
if (SimpleDynamicSql.isSimpleDynamicSql(newSql)) {
sql = new SimpleDynamicSql(client.getDelegate(), newSql);
} else {
sql = new StaticSql(newSql);
}
statement.setSql(sql);
}
private ResultMap buildAutoResultMap(boolean allowRemapping, MappedStatement statement, Class firstResultClass, String xmlResultName) {
ResultMap resultMap;
resultMap = new AutoResultMap(client.getDelegate(), allowRemapping);
resultMap.setId(statement.getId() + "-AutoResultMap");
resultMap.setResultClass(firstResultClass);
resultMap.setXmlName(xmlResultName);
resultMap.setResource(statement.getResource());
return resultMap;
}
public MappedStatement getMappedStatement() {
return mappedStatement;
}
}
ibatis/src/com/ibatis/sqlmap/engine/config/ParameterMapConfig.java 0000644 0001750 0001750 00000006154 11047641632 025477 0 ustar twerner twerner package com.ibatis.sqlmap.engine.config;
import com.ibatis.sqlmap.client.extensions.*;
import com.ibatis.sqlmap.engine.impl.*;
import com.ibatis.sqlmap.engine.mapping.parameter.*;
import com.ibatis.sqlmap.engine.scope.*;
import com.ibatis.sqlmap.engine.type.*;
import java.util.*;
public class ParameterMapConfig {
public static final String MODE_IN = "IN";
public static final String MODE_OUT = "OUT";
public static final String MODE_INOUT = "INUOT";
private SqlMapConfiguration config;
private ErrorContext errorContext;
private SqlMapClientImpl client;
private ParameterMap parameterMap;
private List parameterMappingList;
ParameterMapConfig(SqlMapConfiguration config, String id, Class parameterClass) {
this.config = config;
this.errorContext = config.getErrorContext();
this.client = config.getClient();
errorContext.setActivity("building a parameter map");
parameterMap = new ParameterMap(client.getDelegate());
parameterMap.setId(id);
parameterMap.setResource(errorContext.getResource());
errorContext.setObjectId(id + " parameter map");
parameterMap.setParameterClass(parameterClass);
errorContext.setMoreInfo("Check the parameter mappings.");
this.parameterMappingList = new ArrayList();
client.getDelegate().addParameterMap(parameterMap);
}
public void addParameterMapping(String propertyName, Class javaClass, String jdbcType, String nullValue, String mode, String outParamType, Integer numericScale, Object typeHandlerImpl, String resultMap) {
errorContext.setObjectId(propertyName + " mapping of the " + parameterMap.getId() + " parameter map");
TypeHandler handler;
if (typeHandlerImpl != null) {
errorContext.setMoreInfo("Check the parameter mapping typeHandler attribute '" + typeHandlerImpl + "' (must be a TypeHandler or TypeHandlerCallback implementation).");
if (typeHandlerImpl instanceof TypeHandlerCallback) {
handler = new CustomTypeHandler((TypeHandlerCallback) typeHandlerImpl);
} else if (typeHandlerImpl instanceof TypeHandler) {
handler = (TypeHandler) typeHandlerImpl;
} else {
throw new RuntimeException("The class '" + typeHandlerImpl + "' is not a valid implementation of TypeHandler or TypeHandlerCallback");
}
} else {
errorContext.setMoreInfo("Check the parameter mapping property type or name.");
handler = config.resolveTypeHandler(client.getDelegate().getTypeHandlerFactory(), parameterMap.getParameterClass(), propertyName, javaClass, jdbcType);
}
ParameterMapping mapping = new ParameterMapping();
mapping.setPropertyName(propertyName);
mapping.setJdbcTypeName(jdbcType);
mapping.setTypeName(outParamType);
mapping.setResultMapName(resultMap);
mapping.setNullValue(nullValue);
if (mode != null && mode.length() > 0) {
mapping.setMode(mode);
}
mapping.setTypeHandler(handler);
mapping.setJavaType(javaClass);
mapping.setNumericScale(numericScale);
parameterMappingList.add(mapping);
parameterMap.setParameterMappingList(parameterMappingList);
}
}
ibatis/src/com/ibatis/sqlmap/engine/config/ResultMapConfig.java 0000644 0001750 0001750 00000014040 11047641632 025026 0 ustar twerner twerner package com.ibatis.sqlmap.engine.config;
import com.ibatis.sqlmap.client.extensions.*;
import com.ibatis.sqlmap.engine.impl.*;
import com.ibatis.sqlmap.engine.mapping.result.*;
import com.ibatis.sqlmap.engine.scope.*;
import com.ibatis.sqlmap.engine.type.*;
import java.util.*;
public class ResultMapConfig {
private SqlMapConfiguration config;
private ErrorContext errorContext;
private SqlMapClientImpl client;
private SqlMapExecutorDelegate delegate;
private TypeHandlerFactory typeHandlerFactory;
private ResultMap resultMap;
private List resultMappingList;
private int resultMappingIndex;
private Discriminator discriminator;
ResultMapConfig(SqlMapConfiguration config, String id, Class resultClass, String groupBy, String extendsResultMap, String xmlName) {
this.config = config;
this.errorContext = config.getErrorContext();
this.client = config.getClient();
this.delegate = config.getDelegate();
this.typeHandlerFactory = config.getTypeHandlerFactory();
this.resultMap = new ResultMap(client.getDelegate());
this.resultMappingList = new ArrayList();
errorContext.setActivity("building a result map");
errorContext.setObjectId(id + " result map");
resultMap.setId(id);
resultMap.setXmlName(xmlName);
resultMap.setResource(errorContext.getResource());
if (groupBy != null && groupBy.length() > 0) {
StringTokenizer parser = new StringTokenizer(groupBy, ", ", false);
while (parser.hasMoreTokens()) {
resultMap.addGroupByProperty(parser.nextToken());
}
}
resultMap.setResultClass(resultClass);
errorContext.setMoreInfo("Check the extended result map.");
if (extendsResultMap != null) {
ResultMap extendedResultMap = (ResultMap) client.getDelegate().getResultMap(extendsResultMap);
ResultMapping[] resultMappings = extendedResultMap.getResultMappings();
for (int i = 0; i < resultMappings.length; i++) {
resultMappingList.add(resultMappings[i]);
}
List nestedResultMappings = extendedResultMap.getNestedResultMappings();
if (nestedResultMappings != null) {
Iterator iter = nestedResultMappings.iterator();
while (iter.hasNext()) {
resultMap.addNestedResultMappings((ResultMapping) iter.next());
}
}
if (groupBy == null || groupBy.length() == 0) {
if (extendedResultMap.hasGroupBy()) {
Iterator i = extendedResultMap.groupByProps();
while (i.hasNext()) {
resultMap.addGroupByProperty((String) i.next());
}
}
}
}
errorContext.setMoreInfo("Check the result mappings.");
resultMappingIndex = resultMappingList.size();
resultMap.setResultMappingList(resultMappingList);
client.getDelegate().addResultMap(resultMap);
}
public void setDiscriminator(String columnName, Integer columnIndex, Class javaClass, String jdbcType, String nullValue, Object typeHandlerImpl) {
TypeHandler handler;
if (typeHandlerImpl != null) {
if (typeHandlerImpl instanceof TypeHandlerCallback) {
handler = new CustomTypeHandler((TypeHandlerCallback) typeHandlerImpl);
} else if (typeHandlerImpl instanceof TypeHandler) {
handler = (TypeHandler) typeHandlerImpl;
} else {
throw new RuntimeException("The class '' is not a valid implementation of TypeHandler or TypeHandlerCallback");
}
} else {
handler = config.resolveTypeHandler(client.getDelegate().getTypeHandlerFactory(), resultMap.getResultClass(), "", javaClass, jdbcType, true);
}
ResultMapping mapping = new ResultMapping();
mapping.setColumnName(columnName);
mapping.setJdbcTypeName(jdbcType);
mapping.setTypeHandler(handler);
mapping.setNullValue(nullValue);
mapping.setJavaType(javaClass);
if (columnIndex != null) {
mapping.setColumnIndex(columnIndex.intValue());
}
discriminator = new Discriminator(delegate, mapping);
resultMap.setDiscriminator(discriminator);
}
public void addDiscriminatorSubMap(Object value, String resultMap) {
if (discriminator == null) {
throw new RuntimeException("The discriminator is null, but somehow a subMap was reached. This is a bug.");
}
discriminator.addSubMap(value.toString(), resultMap);
}
public void addResultMapping(String propertyName, String columnName, Integer columnIndex, Class javaClass, String jdbcType, String nullValue, String notNullColumn, String statementName, String resultMapName, Object impl) {
errorContext.setObjectId(propertyName + " mapping of the " + resultMap.getId() + " result map");
TypeHandler handler;
if (impl != null) {
if (impl instanceof TypeHandlerCallback) {
handler = new CustomTypeHandler((TypeHandlerCallback) impl);
} else if (impl instanceof TypeHandler) {
handler = (TypeHandler) impl;
} else {
throw new RuntimeException("The class '" + impl + "' is not a valid implementation of TypeHandler or TypeHandlerCallback");
}
} else {
handler = config.resolveTypeHandler(client.getDelegate().getTypeHandlerFactory(), resultMap.getResultClass(), propertyName, javaClass, jdbcType, true);
}
ResultMapping mapping = new ResultMapping();
mapping.setPropertyName(propertyName);
mapping.setColumnName(columnName);
mapping.setJdbcTypeName(jdbcType);
mapping.setTypeHandler(handler);
mapping.setNullValue(nullValue);
mapping.setNotNullColumn(notNullColumn);
mapping.setStatementName(statementName);
mapping.setNestedResultMapName(resultMapName);
if (resultMapName != null && resultMapName.length() > 0) {
resultMap.addNestedResultMappings(mapping);
}
mapping.setJavaType(javaClass);
if (columnIndex != null) {
mapping.setColumnIndex(columnIndex.intValue());
} else {
resultMappingIndex++;
mapping.setColumnIndex(resultMappingIndex);
}
resultMappingList.add(mapping);
resultMap.setResultMappingList(resultMappingList);
}
}
ibatis/src/com/ibatis/sqlmap/engine/config/SqlMapConfiguration.java 0000644 0001750 0001750 00000026264 11047641632 025724 0 ustar twerner twerner package com.ibatis.sqlmap.engine.config;
import com.ibatis.common.beans.*;
import com.ibatis.common.resources.*;
import com.ibatis.sqlmap.client.*;
import com.ibatis.sqlmap.client.extensions.*;
import com.ibatis.sqlmap.engine.accessplan.*;
import com.ibatis.sqlmap.engine.cache.*;
import com.ibatis.sqlmap.engine.cache.fifo.*;
import com.ibatis.sqlmap.engine.cache.lru.*;
import com.ibatis.sqlmap.engine.cache.memory.*;
import com.ibatis.sqlmap.engine.datasource.*;
import com.ibatis.sqlmap.engine.impl.*;
import com.ibatis.sqlmap.engine.mapping.result.*;
import com.ibatis.sqlmap.engine.mapping.statement.*;
import com.ibatis.sqlmap.engine.scope.*;
import com.ibatis.sqlmap.engine.transaction.*;
import com.ibatis.sqlmap.engine.transaction.external.*;
import com.ibatis.sqlmap.engine.transaction.jdbc.*;
import com.ibatis.sqlmap.engine.transaction.jta.*;
import com.ibatis.sqlmap.engine.type.*;
import java.util.*;
public class SqlMapConfiguration {
private static final Probe PROBE = ProbeFactory.getProbe();
private ErrorContext errorContext;
private SqlMapExecutorDelegate delegate;
private TypeHandlerFactory typeHandlerFactory;
private SqlMapClientImpl client;
private Integer defaultStatementTimeout;
public SqlMapConfiguration() {
errorContext = new ErrorContext();
delegate = new SqlMapExecutorDelegate();
typeHandlerFactory = delegate.getTypeHandlerFactory();
client = new SqlMapClientImpl(delegate);
registerDefaultTypeAliases();
}
public TypeHandlerFactory getTypeHandlerFactory() {
return typeHandlerFactory;
}
public ErrorContext getErrorContext() {
return errorContext;
}
public SqlMapClientImpl getClient() {
return client;
}
public SqlMapExecutorDelegate getDelegate() {
return delegate;
}
public void setClassInfoCacheEnabled (boolean classInfoCacheEnabled) {
errorContext.setActivity("setting class info cache enabled/disabled");
ClassInfo.setCacheEnabled(classInfoCacheEnabled);
}
public void setLazyLoadingEnabled (boolean lazyLoadingEnabled) {
errorContext.setActivity("setting lazy loading enabled/disabled");
client.getDelegate().setLazyLoadingEnabled(lazyLoadingEnabled);
}
public void setStatementCachingEnabled (boolean statementCachingEnabled) {
errorContext.setActivity("setting statement caching enabled/disabled");
client.getDelegate().setStatementCacheEnabled(statementCachingEnabled);
}
public void setCacheModelsEnabled (boolean cacheModelsEnabled) {
errorContext.setActivity("setting cache models enabled/disabled");
client.getDelegate().setCacheModelsEnabled(cacheModelsEnabled);
}
public void setEnhancementEnabled (boolean enhancementEnabled) {
errorContext.setActivity("setting enhancement enabled/disabled");
try {
enhancementEnabled = enhancementEnabled && Resources.classForName("net.sf.cglib.proxy.InvocationHandler") != null;
} catch (ClassNotFoundException e) {
enhancementEnabled = false;
}
client.getDelegate().setEnhancementEnabled(enhancementEnabled);
AccessPlanFactory.setBytecodeEnhancementEnabled(enhancementEnabled);
}
public void setUseColumnLabel(boolean useColumnLabel) {
client.getDelegate().setUseColumnLabel(useColumnLabel);
}
public void setForceMultipleResultSetSupport(boolean forceMultipleResultSetSupport) {
client.getDelegate().setForceMultipleResultSetSupport(forceMultipleResultSetSupport);
}
public void setDefaultStatementTimeout(Integer defaultTimeout) {
errorContext.setActivity("setting default timeout");
if (defaultTimeout != null) {
try {
defaultStatementTimeout = defaultTimeout;
} catch (NumberFormatException e) {
throw new SqlMapException("Specified defaultStatementTimeout is not a valid integer");
}
}
}
public void setTransactionManager(TransactionManager txManager) {
delegate.setTxManager(txManager);
}
public void setResultObjectFactory(ResultObjectFactory rof) {
delegate.setResultObjectFactory(rof);
}
public void newTypeHandler(Class javaType, String jdbcType, Object callback) {
try {
errorContext.setActivity("building a building custom type handler");
TypeHandlerFactory typeHandlerFactory = client.getDelegate().getTypeHandlerFactory();
TypeHandler typeHandler;
if (callback instanceof TypeHandlerCallback) {
typeHandler = new CustomTypeHandler((TypeHandlerCallback) callback);
} else if (callback instanceof TypeHandler) {
typeHandler = (TypeHandler) callback;
} else {
throw new RuntimeException("The object '" + callback + "' is not a valid implementation of TypeHandler or TypeHandlerCallback");
}
errorContext.setMoreInfo("Check the javaType attribute '" + javaType + "' (must be a classname) or the jdbcType '" + jdbcType + "' (must be a JDBC type name).");
if (jdbcType != null && jdbcType.length() > 0) {
typeHandlerFactory.register(javaType, jdbcType, typeHandler);
} else {
typeHandlerFactory.register(javaType, typeHandler);
}
} catch (Exception e) {
throw new SqlMapException("Error registering occurred. Cause: " + e, e);
}
errorContext.setMoreInfo(null);
errorContext.setObjectId(null);
}
public CacheModelConfig newCacheModelConfig(String id, CacheController controller, boolean readOnly, boolean serialize) {
return new CacheModelConfig(this, id, controller, readOnly, serialize);
}
public ParameterMapConfig newParameterMapConfig(String id, Class parameterClass) {
return new ParameterMapConfig(this, id, parameterClass);
}
public ResultMapConfig newResultMapConfig(String id, Class resultClass, String groupBy, String extended, String xmlName) {
return new ResultMapConfig(this, id, resultClass, groupBy, extended, xmlName);
}
public MappedStatementConfig newMappedStatementConfig(String id, MappedStatement statement, SqlSource processor,
String parameterMapName, Class parameterClass,
String resultMapName, String[] additionalResultMapNames,
Class resultClass, Class[] additionalResultClasses,
String resultSetType, Integer fetchSize,
boolean allowRemapping, Integer timeout, String cacheModelName,
String xmlResultName) {
return new MappedStatementConfig(this, id, statement, processor, parameterMapName, parameterClass, resultMapName,
additionalResultMapNames, resultClass, additionalResultClasses, cacheModelName, resultSetType, fetchSize,
allowRemapping, timeout, defaultStatementTimeout, xmlResultName);
}
public void finalizeSqlMapConfig() {
wireUpCacheModels();
bindResultMapDiscriminators();
}
TypeHandler resolveTypeHandler(TypeHandlerFactory typeHandlerFactory, Class clazz, String propertyName, Class javaType, String jdbcType) {
return resolveTypeHandler(typeHandlerFactory, clazz, propertyName, javaType, jdbcType, false);
}
TypeHandler resolveTypeHandler(TypeHandlerFactory typeHandlerFactory, Class clazz, String propertyName, Class javaType, String jdbcType, boolean useSetterToResolve) {
TypeHandler handler;
if (clazz == null) {
// Unknown
handler = typeHandlerFactory.getUnkownTypeHandler();
} else if (DomTypeMarker.class.isAssignableFrom(clazz)) {
// DOM
handler = typeHandlerFactory.getTypeHandler(String.class, jdbcType);
} else if (java.util.Map.class.isAssignableFrom(clazz)) {
// Map
if (javaType == null) {
handler = typeHandlerFactory.getUnkownTypeHandler(); //BUG 1012591 - typeHandlerFactory.getTypeHandler(java.lang.Object.class, jdbcType);
} else {
handler = typeHandlerFactory.getTypeHandler(javaType, jdbcType);
}
} else if (typeHandlerFactory.getTypeHandler(clazz, jdbcType) != null) {
// Primitive
handler = typeHandlerFactory.getTypeHandler(clazz, jdbcType);
} else {
// JavaBean
if (javaType == null) {
if (useSetterToResolve) {
Class type = PROBE.getPropertyTypeForSetter(clazz, propertyName);
handler = typeHandlerFactory.getTypeHandler(type, jdbcType);
} else {
Class type = PROBE.getPropertyTypeForGetter(clazz, propertyName);
handler = typeHandlerFactory.getTypeHandler(type, jdbcType);
}
} else {
handler = typeHandlerFactory.getTypeHandler(javaType, jdbcType);
}
}
return handler;
}
private void registerDefaultTypeAliases() {
// TRANSACTION ALIASES
typeHandlerFactory.putTypeAlias("JDBC", JdbcTransactionConfig.class.getName());
typeHandlerFactory.putTypeAlias("JTA", JtaTransactionConfig.class.getName());
typeHandlerFactory.putTypeAlias("EXTERNAL", ExternalTransactionConfig.class.getName());
// DATA SOURCE ALIASES
typeHandlerFactory.putTypeAlias("SIMPLE", SimpleDataSourceFactory.class.getName());
typeHandlerFactory.putTypeAlias("DBCP", DbcpDataSourceFactory.class.getName());
typeHandlerFactory.putTypeAlias("JNDI", JndiDataSourceFactory.class.getName());
// CACHE ALIASES
typeHandlerFactory.putTypeAlias("FIFO", FifoCacheController.class.getName());
typeHandlerFactory.putTypeAlias("LRU", LruCacheController.class.getName());
typeHandlerFactory.putTypeAlias("MEMORY", MemoryCacheController.class.getName());
// use a string for OSCache to avoid unnecessary loading of properties upon init
typeHandlerFactory.putTypeAlias("OSCACHE", "com.ibatis.sqlmap.engine.cache.oscache.OSCacheController");
// TYPE ALIASEs
typeHandlerFactory.putTypeAlias("dom", DomTypeMarker.class.getName());
typeHandlerFactory.putTypeAlias("domCollection", DomCollectionTypeMarker.class.getName());
typeHandlerFactory.putTypeAlias("xml", XmlTypeMarker.class.getName());
typeHandlerFactory.putTypeAlias("xmlCollection", XmlCollectionTypeMarker.class.getName());
}
private void wireUpCacheModels() {
// Wire Up Cache Models
Iterator cacheNames = client.getDelegate().getCacheModelNames();
while (cacheNames.hasNext()) {
String cacheName = (String) cacheNames.next();
CacheModel cacheModel = client.getDelegate().getCacheModel(cacheName);
Iterator statementNames = cacheModel.getFlushTriggerStatementNames();
while (statementNames.hasNext()) {
String statementName = (String) statementNames.next();
MappedStatement statement = client.getDelegate().getMappedStatement(statementName);
if (statement != null) {
statement.addExecuteListener(cacheModel);
} else {
throw new RuntimeException("Could not find statement named '" + statementName + "' for use as a flush trigger for the cache model named '" + cacheName + "'.");
}
}
}
}
private void bindResultMapDiscriminators() {
// Bind discriminators
Iterator names = delegate.getResultMapNames();
while (names.hasNext()) {
String name = (String) names.next();
ResultMap rm = delegate.getResultMap(name);
Discriminator disc = rm.getDiscriminator();
if (disc != null) {
disc.bindSubMaps();
}
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/config/SqlSource.java 0000644 0001750 0001750 00000000222 11047641632 023701 0 ustar twerner twerner package com.ibatis.sqlmap.engine.config;
import com.ibatis.sqlmap.engine.mapping.sql.*;
public interface SqlSource {
Sql getSql();
}
ibatis/src/com/ibatis/sqlmap/engine/datasource/ 0000755 0001750 0001750 00000000000 11047641632 022007 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/datasource/DataSourceFactory.java 0000644 0001750 0001750 00000002202 11047641632 026230 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.datasource;
import javax.sql.DataSource;
import java.util.Map;
/**
* Interface to provide a way to create and configure a DataSource for iBATIS
*/
public interface DataSourceFactory {
/**
* Simple method to initialize/configure a datasource
*
* @param map - the configuration information
*/
public void initialize(Map map);
/**
* Returns a datasource
*
* @return an implementation of DataSource
*/
public DataSource getDataSource();
}
ibatis/src/com/ibatis/sqlmap/engine/datasource/DbcpDataSourceFactory.java 0000644 0001750 0001750 00000002211 11047641632 027021 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.datasource;
import com.ibatis.common.jdbc.DbcpConfiguration;
import javax.sql.DataSource;
import java.util.Map;
/**
* DataSourceFactory implementation for DBCP
*/
public class DbcpDataSourceFactory implements DataSourceFactory {
private DataSource dataSource;
public void initialize(Map map) {
DbcpConfiguration dbcp = new DbcpConfiguration(map);
dataSource = dbcp.getDataSource();
}
public DataSource getDataSource() {
return dataSource;
}
}
ibatis/src/com/ibatis/sqlmap/engine/datasource/JndiDataSourceFactory.java 0000644 0001750 0001750 00000006064 11047641632 027047 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.datasource;
import com.ibatis.sqlmap.client.SqlMapException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
/**
* DataSourceFactory implementation for JNDI
*/
public class JndiDataSourceFactory implements DataSourceFactory {
private DataSource dataSource;
public void initialize(Map properties) {
try {
InitialContext initCtx = null;
Hashtable context = getContextProperties(properties);
if (context == null) {
initCtx = new InitialContext();
} else {
initCtx = new InitialContext(context);
}
if (properties.containsKey("DataSource")) {
dataSource = (DataSource) initCtx.lookup((String) properties.get("DataSource"));
} else if (properties.containsKey("DBJndiContext")) { // LEGACY --Backward compatibility
dataSource = (DataSource) initCtx.lookup((String) properties.get("DBJndiContext"));
} else if (properties.containsKey("DBFullJndiContext")) { // LEGACY --Backward compatibility
dataSource = (DataSource) initCtx.lookup((String) properties.get("DBFullJndiContext"));
} else if (properties.containsKey("DBInitialContext")
&& properties.containsKey("DBLookup")) { // LEGACY --Backward compatibility
Context ctx = (Context) initCtx.lookup((String) properties.get("DBInitialContext"));
dataSource = (DataSource) ctx.lookup((String) properties.get("DBLookup"));
}
} catch (NamingException e) {
throw new SqlMapException("There was an error configuring JndiDataSourceTransactionPool. Cause: " + e, e);
}
}
public DataSource getDataSource() {
return dataSource;
}
private static Hashtable getContextProperties(Map allProps) {
final String PREFIX = "context.";
Hashtable contextProperties = null;
Iterator keys = allProps.keySet().iterator();
while (keys.hasNext()) {
String key = (String) keys.next();
String value = (String) allProps.get(key);
if (key.startsWith(PREFIX)) {
if (contextProperties == null) {
contextProperties = new Properties();
}
contextProperties.put(key.substring(PREFIX.length()), value);
}
}
return contextProperties;
}
}
ibatis/src/com/ibatis/sqlmap/engine/datasource/SimpleDataSourceFactory.java 0000644 0001750 0001750 00000002144 11047641632 027407 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.datasource;
import com.ibatis.common.jdbc.SimpleDataSource;
import javax.sql.DataSource;
import java.util.Map;
/**
* DataSourceFactory implementation for the iBATIS SimpleDataSource
*/
public class SimpleDataSourceFactory implements DataSourceFactory {
private DataSource dataSource;
public void initialize(Map map) {
dataSource = new SimpleDataSource(map);
}
public DataSource getDataSource() {
return dataSource;
}
}
ibatis/src/com/ibatis/sqlmap/engine/exchange/ 0000755 0001750 0001750 00000000000 11047641630 021435 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/exchange/BaseDataExchange.java 0000644 0001750 0001750 00000003300 11047641630 025403 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.exchange;
import com.ibatis.sqlmap.engine.cache.CacheKey;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.scope.StatementScope;
/**
* Base implementation for the DataExchange interface
*/
public abstract class BaseDataExchange implements DataExchange {
private DataExchangeFactory dataExchangeFactory;
protected BaseDataExchange(DataExchangeFactory dataExchangeFactory) {
this.dataExchangeFactory = dataExchangeFactory;
}
public CacheKey getCacheKey(StatementScope statementScope, ParameterMap parameterMap, Object parameterObject) {
CacheKey key = new CacheKey();
Object[] data = getData(statementScope, parameterMap, parameterObject);
for (int i = 0; i < data.length; i++) {
if (data[i] != null) {
key.update(data[i]);
}
}
return key;
}
/**
* Getter for the factory that created this object
* @return - the factory
*/
public DataExchangeFactory getDataExchangeFactory() {
return dataExchangeFactory;
}
}
ibatis/src/com/ibatis/sqlmap/engine/exchange/ComplexDataExchange.java 0000644 0001750 0001750 00000010772 11047641630 026153 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.exchange;
import com.ibatis.common.beans.Probe;
import com.ibatis.common.beans.ProbeFactory;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMapping;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMapping;
import com.ibatis.sqlmap.engine.mapping.result.ResultObjectFactoryUtil;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.type.TypeHandlerFactory;
import java.util.Map;
/**
* A DataExchange implemtation for working with beans
*/
public class ComplexDataExchange extends BaseDataExchange implements DataExchange {
private static final Probe PROBE = ProbeFactory.getProbe();
/**
* Constructor for the factory
* @param dataExchangeFactory - the factory
*/
public ComplexDataExchange(DataExchangeFactory dataExchangeFactory) {
super(dataExchangeFactory);
}
public void initialize(Map properties) {
}
public Object[] getData(StatementScope statementScope, ParameterMap parameterMap, Object parameterObject) {
TypeHandlerFactory typeHandlerFactory = getDataExchangeFactory().getTypeHandlerFactory();
if (parameterObject == null) {
return new Object[1];
} else {
if (typeHandlerFactory.hasTypeHandler(parameterObject.getClass())) {
ParameterMapping[] mappings = parameterMap.getParameterMappings();
Object[] data = new Object[mappings.length];
for (int i = 0; i < mappings.length; i++) {
data[i] = parameterObject;
}
return data;
} else {
Object[] data = new Object[parameterMap.getParameterMappings().length];
ParameterMapping[] mappings = parameterMap.getParameterMappings();
for (int i = 0; i < mappings.length; i++) {
data[i] = PROBE.getObject(parameterObject, mappings[i].getPropertyName());
}
return data;
}
}
}
public Object setData(StatementScope statementScope, ResultMap resultMap, Object resultObject, Object[] values) {
TypeHandlerFactory typeHandlerFactory = getDataExchangeFactory().getTypeHandlerFactory();
if (typeHandlerFactory.hasTypeHandler(resultMap.getResultClass())) {
return values[0];
} else {
Object object = resultObject;
if (object == null) {
try {
object = ResultObjectFactoryUtil.createObjectThroughFactory(resultMap.getResultClass());
} catch (Exception e) {
throw new RuntimeException("JavaBeansDataExchange could not instantiate result class. Cause: " + e, e);
}
}
ResultMapping[] mappings = resultMap.getResultMappings();
for (int i = 0; i < mappings.length; i++) {
PROBE.setObject(object, mappings[i].getPropertyName(), values[i]);
}
return object;
}
}
public Object setData(StatementScope statementScope, ParameterMap parameterMap, Object parameterObject, Object[] values) {
TypeHandlerFactory typeHandlerFactory = getDataExchangeFactory().getTypeHandlerFactory();
if (typeHandlerFactory.hasTypeHandler(parameterMap.getParameterClass())) {
return values[0];
} else {
Object object = parameterObject;
if (object == null) {
try {
object = ResultObjectFactoryUtil.createObjectThroughFactory(parameterMap.getParameterClass());
} catch (Exception e) {
throw new RuntimeException("JavaBeansDataExchange could not instantiate result class. Cause: " + e, e);
}
}
ParameterMapping[] mappings = parameterMap.getParameterMappings();
for (int i = 0; i < mappings.length; i++) {
if (mappings[i].isOutputAllowed()) {
PROBE.setObject(object, mappings[i].getPropertyName(), values[i]);
}
}
return object;
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/exchange/DataExchange.java 0000644 0001750 0001750 00000005403 11047641630 024616 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.exchange;
import com.ibatis.sqlmap.engine.cache.CacheKey;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import java.util.Map;
/**
* Interface for exchanging data between a parameter map/result map and the related objects
*/
public interface DataExchange {
/**
* Initializes the data exchange instance.
*
* @param properties
*/
public void initialize(Map properties);
/**
* Gets a data array from a parameter object.
*
* @param statementScope - the scope of the request
* @param parameterMap - the parameter map
* @param parameterObject - the parameter object
*
* @return - the objects
*/
public Object[] getData(StatementScope statementScope, ParameterMap parameterMap, Object parameterObject);
/**
* Sets values from a data array into a result object.
*
* @param statementScope - the request scope
* @param resultMap - the result map
* @param resultObject - the result object
* @param values - the values to be mapped
*
* @return the resultObject
*/
public Object setData(StatementScope statementScope, ResultMap resultMap, Object resultObject, Object[] values);
/**
* Sets values from a data array into a parameter object
*
* @param statementScope - the request scope
* @param parameterMap - the parameter map
* @param parameterObject - the parameter object
* @param values - the values to set
*
* @return parameterObject
*/
public Object setData(StatementScope statementScope, ParameterMap parameterMap, Object parameterObject, Object[] values);
/**
* Returns an object capable of being a unique cache key for a parameter object.
*
* @param statementScope - the request scope
* @param parameterMap - the parameter map
* @param parameterObject - the parameter object
*
* @return - a cache key
*/
public CacheKey getCacheKey(StatementScope statementScope, ParameterMap parameterMap, Object parameterObject);
}
ibatis/src/com/ibatis/sqlmap/engine/exchange/DataExchangeFactory.java 0000644 0001750 0001750 00000005344 11047641630 026152 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.exchange;
import com.ibatis.sqlmap.engine.type.DomTypeMarker;
import com.ibatis.sqlmap.engine.type.TypeHandlerFactory;
import java.util.List;
import java.util.Map;
/**
* Factory for DataExchange objects
*/
public class DataExchangeFactory {
private final DataExchange domDataExchange;
private final DataExchange listDataExchange;
private final DataExchange mapDataExchange;
private final DataExchange primitiveDataExchange;
private final DataExchange complexDataExchange;
private TypeHandlerFactory typeHandlerFactory;
/**
* Constructor for the factory
* @param typeHandlerFactory - a type handler factory for the factory
*/
public DataExchangeFactory(TypeHandlerFactory typeHandlerFactory) {
this.typeHandlerFactory = typeHandlerFactory;
domDataExchange = new DomDataExchange(this);
listDataExchange = new ListDataExchange(this);
mapDataExchange = new ComplexDataExchange(this);
primitiveDataExchange = new PrimitiveDataExchange(this);
complexDataExchange = new ComplexDataExchange(this);
}
/**
* Getter for the type handler factory
* @return - the type handler factory
*/
public TypeHandlerFactory getTypeHandlerFactory() {
return typeHandlerFactory;
}
/**
* Get a DataExchange object for the passed in Class
* @param clazz - the class to get a DataExchange object for
* @return - the DataExchange object
*/
public DataExchange getDataExchangeForClass(Class clazz) {
DataExchange dataExchange = null;
if (clazz == null) {
dataExchange = complexDataExchange;
} else if (DomTypeMarker.class.isAssignableFrom(clazz)) {
dataExchange = domDataExchange;
} else if (List.class.isAssignableFrom(clazz)) {
dataExchange = listDataExchange;
} else if (Map.class.isAssignableFrom(clazz)) {
dataExchange = mapDataExchange;
} else if (typeHandlerFactory.getTypeHandler(clazz) != null) {
dataExchange = primitiveDataExchange;
} else {
dataExchange = new JavaBeanDataExchange(this);
}
return dataExchange;
}
}
ibatis/src/com/ibatis/sqlmap/engine/exchange/DomDataExchange.java 0000644 0001750 0001750 00000006432 11047641630 025261 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.exchange;
import com.ibatis.common.beans.*;
import com.ibatis.sqlmap.client.*;
import com.ibatis.sqlmap.engine.mapping.parameter.*;
import com.ibatis.sqlmap.engine.mapping.result.*;
import com.ibatis.sqlmap.engine.scope.*;
import org.w3c.dom.Document;
import javax.xml.parsers.*;
import java.util.Map;
/**
* A DataExchange implemtation for working with DOM objects
*/
public class DomDataExchange extends BaseDataExchange implements DataExchange {
/**
* Constructor for the factory
* @param dataExchangeFactory - the factory
*/
public DomDataExchange(DataExchangeFactory dataExchangeFactory) {
super(dataExchangeFactory);
}
public void initialize(Map properties) {
}
public Object[] getData(StatementScope statementScope, ParameterMap parameterMap, Object parameterObject) {
Probe probe = ProbeFactory.getProbe(parameterObject);
ParameterMapping[] mappings = parameterMap.getParameterMappings();
Object[] values = new Object[mappings.length];
for (int i = 0; i < mappings.length; i++) {
values[i] = probe.getObject(parameterObject, mappings[i].getPropertyName());
}
return values;
}
public Object setData(StatementScope statementScope, ResultMap resultMap, Object resultObject, Object[] values) {
String name = ((ResultMap) resultMap).getXmlName();
if (name == null) {
name = "result";
}
if (resultObject == null) {
try {
Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
doc.appendChild(doc.createElement(name));
resultObject = doc;
} catch (ParserConfigurationException e) {
throw new SqlMapException("Error creating new Document for DOM result. Cause: " + e, e);
}
}
Probe probe = ProbeFactory.getProbe(resultObject);
ResultMapping[] mappings = resultMap.getResultMappings();
for (int i = 0; i < mappings.length; i++) {
if (values[i] != null) {
probe.setObject(resultObject, mappings[i].getPropertyName(), values[i]);
}
}
return resultObject;
}
public Object setData(StatementScope statementScope, ParameterMap parameterMap, Object parameterObject, Object[] values) {
Probe probe = ProbeFactory.getProbe(parameterObject);
ParameterMapping[] mappings = parameterMap.getParameterMappings();
for (int i = 0; i < mappings.length; i++) {
if (values[i] != null) {
if (mappings[i].isOutputAllowed()) {
probe.setObject(parameterObject, mappings[i].getPropertyName(), values[i]);
}
}
}
return parameterObject;
}
}
ibatis/src/com/ibatis/sqlmap/engine/exchange/JavaBeanDataExchange.java 0000644 0001750 0001750 00000013107 11047641630 026206 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.exchange;
import com.ibatis.sqlmap.engine.accessplan.AccessPlan;
import com.ibatis.sqlmap.engine.accessplan.AccessPlanFactory;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMapping;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMapping;
import com.ibatis.sqlmap.engine.mapping.result.ResultObjectFactoryUtil;
import com.ibatis.sqlmap.engine.scope.ErrorContext;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* DataExchange implementation for beans
*/
public class JavaBeanDataExchange extends BaseDataExchange implements DataExchange {
private static final Object[] NO_DATA = new Object[0];
private AccessPlan resultPlan;
private AccessPlan parameterPlan;
private AccessPlan outParamPlan;
protected JavaBeanDataExchange(DataExchangeFactory dataExchangeFactory) {
super(dataExchangeFactory);
}
/**
* Initializes the data exchange instance.
*
* @param properties
*/
public void initialize(Map properties) {
Object map = properties.get("map");
if (map instanceof ParameterMap) {
ParameterMap parameterMap = (ParameterMap) map;
if (parameterMap != null) {
ParameterMapping[] parameterMappings = parameterMap.getParameterMappings();
String[] parameterPropNames = new String[parameterMappings.length];
for (int i = 0; i < parameterPropNames.length; i++) {
parameterPropNames[i] = parameterMappings[i].getPropertyName();
}
parameterPlan = AccessPlanFactory.getAccessPlan(parameterMap.getParameterClass(), parameterPropNames);
// OUTPUT PARAMS
List outParamList = new ArrayList();
for (int i = 0; i < parameterPropNames.length; i++) {
if (parameterMappings[i].isOutputAllowed()) {
outParamList.add(parameterMappings[i].getPropertyName());
}
}
String[] outParams = (String[]) outParamList.toArray(new String[outParamList.size()]);
outParamPlan = AccessPlanFactory.getAccessPlan(parameterMap.getParameterClass(), outParams);
}
} else if (map instanceof ResultMap) {
ResultMap resultMap = (ResultMap) map;
if (resultMap != null) {
ResultMapping[] resultMappings = resultMap.getResultMappings();
String[] resultPropNames = new String[resultMappings.length];
for (int i = 0; i < resultPropNames.length; i++) {
resultPropNames[i] = resultMappings[i].getPropertyName();
}
resultPlan = AccessPlanFactory.getAccessPlan(resultMap.getResultClass(), resultPropNames);
}
}
}
public Object[] getData(StatementScope statementScope, ParameterMap parameterMap, Object parameterObject) {
if (parameterPlan != null) {
return parameterPlan.getProperties(parameterObject);
} else {
return NO_DATA;
}
}
public Object setData(StatementScope statementScope, ResultMap resultMap, Object resultObject, Object[] values) {
if (resultPlan != null) {
Object object = resultObject;
ErrorContext errorContext = statementScope.getErrorContext();
if (object == null) {
errorContext.setMoreInfo("The error occured while instantiating the result object");
try {
object = ResultObjectFactoryUtil.createObjectThroughFactory(resultMap.getResultClass());
} catch (Exception e) {
throw new RuntimeException("JavaBeansDataExchange could not instantiate result class. Cause: " + e, e);
}
}
errorContext.setMoreInfo("The error happened while setting a property on the result object.");
resultPlan.setProperties(object, values);
return object;
} else {
return null;
}
}
// Bug ibatis-12
public Object setData(StatementScope statementScope, ParameterMap parameterMap, Object parameterObject, Object[] values) {
if (outParamPlan != null) {
Object object = parameterObject;
if (object == null) {
try {
object = ResultObjectFactoryUtil.createObjectThroughFactory(parameterMap.getParameterClass());
} catch (Exception e) {
throw new RuntimeException("JavaBeansDataExchange could not instantiate parameter class. Cause: " + e, e);
}
}
values = getOutputParamValues(parameterMap.getParameterMappings(), values);
outParamPlan.setProperties(object, values);
return object;
} else {
return null;
}
}
private Object[] getOutputParamValues(ParameterMapping[] mappings, Object[] values) {
List outParamValues = new ArrayList();
for (int i = 0; i < mappings.length; i++) {
if (mappings[i].isOutputAllowed()) {
outParamValues.add(values[i]);
}
}
return outParamValues.toArray();
}
}
ibatis/src/com/ibatis/sqlmap/engine/exchange/ListDataExchange.java 0000644 0001750 0001750 00000007425 11047641630 025460 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.exchange;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMapping;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMapping;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.common.beans.ProbeFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* DataExchange implementation for List objects
*/
public class ListDataExchange extends BaseDataExchange implements DataExchange {
protected ListDataExchange(DataExchangeFactory dataExchangeFactory) {
super(dataExchangeFactory);
}
public void initialize(Map properties) {
}
public Object[] getData(StatementScope statementScope, ParameterMap parameterMap, Object parameterObject) {
ParameterMapping[] mappings = parameterMap.getParameterMappings();
Object[] data = new Object[mappings.length];
for (int i = 0; i < mappings.length; i++) {
String propName = mappings[i].getPropertyName();
// parse on the '.' notation and get nested properties
String[] propertyArray = propName.split("\\.");
if(propertyArray.length > 0) {
// iterate list of properties to discover values
Object tempData = parameterObject;
for(int x=0; xjava.sql.BatchUpdateException is caught
* during the execution of any nested batch. The exception contains the
* java.sql.BatchUpdateException that is the root cause, as well as
* the results from any prior nested batch that executed successfully. This exception
* is only thrown from the executeBatchDetailed method.
*
* @author Jeff Butler
*
*/
public class BatchException extends Exception {
private List successfulBatchResults;
private BatchUpdateException batchUpdateException;
private String failingSqlStatement;
private String failingStatementId;
/**
*
*/
public BatchException(String message, BatchUpdateException cause, List successfulBatchResults,
String failingStatementId, String failingSqlStatement) {
super(message, cause);
this.batchUpdateException = cause;
this.successfulBatchResults = successfulBatchResults;
this.failingStatementId = failingStatementId;
this.failingSqlStatement = failingSqlStatement;
}
/**
* Returns the BatchUpdateException that caused the nested batch
* to fail. That exception contains an array of row counts
* that can be used to determine exactly which statemtn of the
* batch caused the failure (or failures).
*
* @return the root BatchUpdateException
*/
public BatchUpdateException getBatchUpdateException() {
return batchUpdateException;
}
/**
* Returns a list of BatchResult objects. There will be one entry
* in the list for each successful sub-batch executed before the failing
* batch.
*
* @return the previously successful batch results (may be an empty list
* if no batch has executed successfully)
*/
public List getSuccessfulBatchResults() {
return successfulBatchResults;
}
/**
* Returns the SQL statement that caused the failure
* (not the parameters)
*
* @return the failing SQL string
*/
public String getFailingSqlStatement() {
return failingSqlStatement;
}
/**
* Returns the statement id of the statement that caused the failure
*
* @return the statement id
*/
public String getFailingStatementId() {
return failingStatementId;
}
}
ibatis/src/com/ibatis/sqlmap/engine/execution/BatchResult.java 0000644 0001750 0001750 00000002652 11047641632 024750 0 ustar twerner twerner /*
* Copyright 2006 The Apache Software Foundation
*
* Licensed 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 com.ibatis.sqlmap.engine.execution;
import java.io.Serializable;
/**
* This class holds the statement and row information for every
* successful batch executed by iBATIS
*
* @author Jeff Butler
*
*/
public class BatchResult implements Serializable {
private String sql;
private String statementId;
private int[] updateCounts;
/**
*
*/
public BatchResult(String statementId, String sql) {
super();
this.statementId = statementId;
this.sql = sql;
}
public String getSql() {
return sql;
}
public int[] getUpdateCounts() {
return updateCounts;
}
public void setUpdateCounts(int[] updateCounts) {
this.updateCounts = updateCounts;
}
public String getStatementId() {
return statementId;
}
}
ibatis/src/com/ibatis/sqlmap/engine/execution/SqlExecutor.java 0000644 0001750 0001750 00000065427 11047641632 025017 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.execution;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMapping;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultObjectFactoryUtil;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import com.ibatis.sqlmap.engine.mapping.statement.RowHandlerCallback;
import com.ibatis.sqlmap.engine.scope.ErrorContext;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.scope.SessionScope;
import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl;
import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
import com.ibatis.sqlmap.engine.mapping.statement.DefaultRowHandler;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
* Class responsible for executing the SQL
*/
public class SqlExecutor {
//
// Constants
//
/**
* Constant to let us know not to skip anything
*/
public static final int NO_SKIPPED_RESULTS = 0;
/**
* Constant to let us know to include all records
*/
public static final int NO_MAXIMUM_RESULTS = -999999;
//
// Public Methods
//
/**
* Execute an update
*
* @param statementScope - the request scope
* @param conn - the database connection
* @param sql - the sql statement to execute
* @param parameters - the parameters for the sql statement
* @return - the number of records changed
* @throws SQLException - if the update fails
*/
public int executeUpdate(StatementScope statementScope, Connection conn, String sql, Object[] parameters) throws SQLException {
ErrorContext errorContext = statementScope.getErrorContext();
errorContext.setActivity("executing update");
errorContext.setObjectId(sql);
PreparedStatement ps = null;
setupResultObjectFactory(statementScope);
int rows = 0;
try {
errorContext.setMoreInfo("Check the SQL Statement (preparation failed).");
ps = prepareStatement(statementScope.getSession(), conn, sql);
setStatementTimeout(statementScope.getStatement(), ps);
errorContext.setMoreInfo("Check the parameters (set parameters failed).");
statementScope.getParameterMap().setParameters(statementScope, ps, parameters);
errorContext.setMoreInfo("Check the statement (update failed).");
ps.execute();
rows = ps.getUpdateCount();
} finally {
closeStatement(statementScope.getSession(), ps);
}
return rows;
}
/**
* Adds a statement to a batch
*
* @param statementScope - the request scope
* @param conn - the database connection
* @param sql - the sql statement
* @param parameters - the parameters for the statement
* @throws SQLException - if the statement fails
*/
public void addBatch(StatementScope statementScope, Connection conn, String sql, Object[] parameters) throws SQLException {
Batch batch = (Batch) statementScope.getSession().getBatch();
if (batch == null) {
batch = new Batch();
statementScope.getSession().setBatch(batch);
}
batch.addBatch(statementScope, conn, sql, parameters);
}
/**
* Execute a batch of statements
*
* @param sessionScope - the session scope
* @return - the number of rows impacted by the batch
* @throws SQLException - if a statement fails
*/
public int executeBatch(SessionScope sessionScope) throws SQLException {
int rows = 0;
Batch batch = (Batch) sessionScope.getBatch();
if (batch != null) {
try {
rows = batch.executeBatch();
} finally {
batch.cleanupBatch(sessionScope);
}
}
return rows;
}
/**
* Execute a batch of statements
*
* @param sessionScope - the session scope
* @return - a List of BatchResult objects (may be null if no batch
* has been initiated). There will be one BatchResult object in the
* list for each sub-batch executed
* @throws SQLException if a database access error occurs, or the drive
* does not support batch statements
* @throws BatchException if the driver throws BatchUpdateException
*/
public List executeBatchDetailed(SessionScope sessionScope) throws SQLException, BatchException {
List answer = null;
Batch batch = (Batch) sessionScope.getBatch();
if (batch != null) {
try {
answer = batch.executeBatchDetailed();
} finally {
batch.cleanupBatch(sessionScope);
}
}
return answer;
}
/**
* Long form of the method to execute a query
*
* @param statementScope - the request scope
* @param conn - the database connection
* @param sql - the SQL statement to execute
* @param parameters - the parameters for the statement
* @param skipResults - the number of results to skip
* @param maxResults - the maximum number of results to return
* @param callback - the row handler for the query
* @throws SQLException - if the query fails
*/
public void executeQuery(StatementScope statementScope, Connection conn, String sql, Object[] parameters, int skipResults, int maxResults, RowHandlerCallback callback) throws SQLException {
ErrorContext errorContext = statementScope.getErrorContext();
errorContext.setActivity("executing query");
errorContext.setObjectId(sql);
PreparedStatement ps = null;
ResultSet rs = null;
setupResultObjectFactory(statementScope);
try {
errorContext.setMoreInfo("Check the SQL Statement (preparation failed).");
Integer rsType = statementScope.getStatement().getResultSetType();
if (rsType != null) {
ps = prepareStatement(statementScope.getSession(), conn, sql, rsType);
} else {
ps = prepareStatement(statementScope.getSession(), conn, sql);
}
setStatementTimeout(statementScope.getStatement(), ps);
Integer fetchSize = statementScope.getStatement().getFetchSize();
if (fetchSize != null) {
ps.setFetchSize(fetchSize.intValue());
}
errorContext.setMoreInfo("Check the parameters (set parameters failed).");
statementScope.getParameterMap().setParameters(statementScope, ps, parameters);
errorContext.setMoreInfo("Check the statement (query failed).");
ps.execute();
errorContext.setMoreInfo("Check the results (failed to retrieve results).");
// Begin ResultSet Handling
rs = handleMultipleResults(ps, statementScope, skipResults, maxResults, callback);
// End ResultSet Handling
} finally {
try {
closeResultSet(rs);
} finally {
closeStatement(statementScope.getSession(), ps);
}
}
}
/**
* Execute a stored procedure that updates data
*
* @param statementScope - the request scope
* @param conn - the database connection
* @param sql - the SQL to call the procedure
* @param parameters - the parameters for the procedure
* @return - the rows impacted by the procedure
* @throws SQLException - if the procedure fails
*/
public int executeUpdateProcedure(StatementScope statementScope, Connection conn, String sql, Object[] parameters) throws SQLException {
ErrorContext errorContext = statementScope.getErrorContext();
errorContext.setActivity("executing update procedure");
errorContext.setObjectId(sql);
CallableStatement cs = null;
setupResultObjectFactory(statementScope);
int rows = 0;
try {
errorContext.setMoreInfo("Check the SQL Statement (preparation failed).");
cs = prepareCall(statementScope.getSession(), conn, sql);
setStatementTimeout(statementScope.getStatement(), cs);
ParameterMap parameterMap = statementScope.getParameterMap();
ParameterMapping[] mappings = parameterMap.getParameterMappings();
errorContext.setMoreInfo("Check the output parameters (register output parameters failed).");
registerOutputParameters(cs, mappings);
errorContext.setMoreInfo("Check the parameters (set parameters failed).");
parameterMap.setParameters(statementScope, cs, parameters);
errorContext.setMoreInfo("Check the statement (update procedure failed).");
cs.execute();
rows = cs.getUpdateCount();
errorContext.setMoreInfo("Check the output parameters (retrieval of output parameters failed).");
retrieveOutputParameters(statementScope, cs, mappings, parameters, null);
} finally {
closeStatement(statementScope.getSession(), cs);
}
return rows;
}
/**
* Execute a stored procedure
*
* @param statementScope - the request scope
* @param conn - the database connection
* @param sql - the sql to call the procedure
* @param parameters - the parameters for the procedure
* @param skipResults - the number of results to skip
* @param maxResults - the maximum number of results to return
* @param callback - a row handler for processing the results
* @throws SQLException - if the procedure fails
*/
public void executeQueryProcedure(StatementScope statementScope, Connection conn, String sql, Object[] parameters, int skipResults, int maxResults, RowHandlerCallback callback) throws SQLException {
ErrorContext errorContext = statementScope.getErrorContext();
errorContext.setActivity("executing query procedure");
errorContext.setObjectId(sql);
CallableStatement cs = null;
ResultSet rs = null;
setupResultObjectFactory(statementScope);
try {
errorContext.setMoreInfo("Check the SQL Statement (preparation failed).");
Integer rsType = statementScope.getStatement().getResultSetType();
if (rsType != null) {
cs = prepareCall(statementScope.getSession(), conn, sql, rsType);
} else {
cs = prepareCall(statementScope.getSession(), conn, sql);
}
setStatementTimeout(statementScope.getStatement(), cs);
Integer fetchSize = statementScope.getStatement().getFetchSize();
if (fetchSize != null) {
cs.setFetchSize(fetchSize.intValue());
}
ParameterMap parameterMap = statementScope.getParameterMap();
ParameterMapping[] mappings = parameterMap.getParameterMappings();
errorContext.setMoreInfo("Check the output parameters (register output parameters failed).");
registerOutputParameters(cs, mappings);
errorContext.setMoreInfo("Check the parameters (set parameters failed).");
parameterMap.setParameters(statementScope, cs, parameters);
errorContext.setMoreInfo("Check the statement (update procedure failed).");
cs.execute();
errorContext.setMoreInfo("Check the results (failed to retrieve results).");
// Begin ResultSet Handling
rs = handleMultipleResults(cs, statementScope, skipResults, maxResults, callback);
// End ResultSet Handling
errorContext.setMoreInfo("Check the output parameters (retrieval of output parameters failed).");
retrieveOutputParameters(statementScope, cs, mappings, parameters, callback);
} finally {
try {
closeResultSet(rs);
} finally {
closeStatement(statementScope.getSession(), cs);
}
}
}
private ResultSet handleMultipleResults(PreparedStatement ps, StatementScope statementScope, int skipResults, int maxResults, RowHandlerCallback callback) throws SQLException {
ResultSet rs;
rs = getFirstResultSet(statementScope, ps);
if (rs != null) {
handleResults(statementScope, rs, skipResults, maxResults, callback);
}
// Multiple ResultSet handling
if (callback.getRowHandler() instanceof DefaultRowHandler) {
MappedStatement statement = statementScope.getStatement();
DefaultRowHandler defaultRowHandler = ((DefaultRowHandler) callback.getRowHandler());
if (statement.hasMultipleResultMaps()) {
List multipleResults = new ArrayList();
multipleResults.add(defaultRowHandler.getList());
ResultMap[] resultMaps = statement.getAdditionalResultMaps();
int i = 0;
while (moveToNextResultsSafely(statementScope, ps)) {
if (i >= resultMaps.length) break;
ResultMap rm = resultMaps[i];
statementScope.setResultMap(rm);
rs = ps.getResultSet();
DefaultRowHandler rh = new DefaultRowHandler();
handleResults(statementScope, rs, skipResults, maxResults, new RowHandlerCallback(rm, null, rh));
multipleResults.add(rh.getList());
i++;
}
defaultRowHandler.setList(multipleResults);
statementScope.setResultMap(statement.getResultMap());
} else {
while (moveToNextResultsSafely(statementScope, ps)) ;
}
}
// End additional ResultSet handling
return rs;
}
private ResultSet getFirstResultSet(StatementScope scope, Statement stmt) throws SQLException {
ResultSet rs = null;
boolean hasMoreResults = true;
while (hasMoreResults) {
rs = stmt.getResultSet();
if (rs != null) {
break;
}
hasMoreResults = moveToNextResultsIfPresent(scope, stmt);
}
return rs;
}
private boolean moveToNextResultsIfPresent(StatementScope scope, Statement stmt) throws SQLException {
boolean moreResults;
// This is the messed up JDBC approach for determining if there are more results
moreResults = !(((moveToNextResultsSafely(scope, stmt) == false) && (stmt.getUpdateCount() == -1)));
return moreResults;
}
private boolean moveToNextResultsSafely(StatementScope scope, Statement stmt) throws SQLException {
if (forceMultipleResultSetSupport(scope) || stmt.getConnection().getMetaData().supportsMultipleResultSets()) {
return stmt.getMoreResults();
}
return false;
}
private boolean forceMultipleResultSetSupport(StatementScope scope) {
return ((SqlMapClientImpl)scope.getSession().getSqlMapClient()).getDelegate().isForceMultipleResultSetSupport();
}
private void handleResults(StatementScope statementScope, ResultSet rs, int skipResults, int maxResults, RowHandlerCallback callback) throws SQLException {
try {
statementScope.setResultSet(rs);
ResultMap resultMap = statementScope.getResultMap();
if (resultMap != null) {
// Skip Results
if (rs.getType() != ResultSet.TYPE_FORWARD_ONLY) {
if (skipResults > 0) {
rs.absolute(skipResults);
}
} else {
for (int i = 0; i < skipResults; i++) {
if (!rs.next()) {
return;
}
}
}
// Get Results
int resultsFetched = 0;
while ((maxResults == SqlExecutor.NO_MAXIMUM_RESULTS || resultsFetched < maxResults) && rs.next()) {
Object[] columnValues = resultMap.resolveSubMap(statementScope, rs).getResults(statementScope, rs);
callback.handleResultObject(statementScope, columnValues, rs);
resultsFetched++;
}
}
} finally {
statementScope.setResultSet(null);
}
}
private void retrieveOutputParameters(StatementScope statementScope, CallableStatement cs, ParameterMapping[] mappings, Object[] parameters, RowHandlerCallback callback) throws SQLException {
for (int i = 0; i < mappings.length; i++) {
ParameterMapping mapping = ((ParameterMapping) mappings[i]);
if (mapping.isOutputAllowed()) {
if ("java.sql.ResultSet".equalsIgnoreCase(mapping.getJavaTypeName())) {
ResultSet rs = (ResultSet) cs.getObject(i + 1);
ResultMap resultMap;
if (mapping.getResultMapName() == null) {
resultMap = statementScope.getResultMap();
handleOutputParameterResults(statementScope, resultMap, rs, callback);
} else {
SqlMapClientImpl client = (SqlMapClientImpl) statementScope.getSession().getSqlMapClient();
resultMap = client.getDelegate().getResultMap(mapping.getResultMapName());
DefaultRowHandler rowHandler = new DefaultRowHandler();
RowHandlerCallback handlerCallback = new RowHandlerCallback(resultMap, null, rowHandler);
handleOutputParameterResults(statementScope, resultMap, rs, handlerCallback);
parameters[i] = rowHandler.getList();
}
rs.close();
} else {
parameters[i] = mapping.getTypeHandler().getResult(cs, i + 1);
}
}
}
}
private void registerOutputParameters(CallableStatement cs, ParameterMapping[] mappings) throws SQLException {
for (int i = 0; i < mappings.length; i++) {
ParameterMapping mapping = ((ParameterMapping) mappings[i]);
if (mapping.isOutputAllowed()) {
if (null != mapping.getTypeName() && !mapping.getTypeName().equals("")) { //@added
cs.registerOutParameter(i + 1, mapping.getJdbcType(), mapping.getTypeName());
} else {
if (mapping.getNumericScale() != null && (mapping.getJdbcType() == Types.NUMERIC || mapping.getJdbcType() == Types.DECIMAL))
{
cs.registerOutParameter(i + 1, mapping.getJdbcType(), mapping.getNumericScale().intValue());
} else {
cs.registerOutParameter(i + 1, mapping.getJdbcType());
}
}
}
}
}
private void handleOutputParameterResults(StatementScope statementScope, ResultMap resultMap, ResultSet rs, RowHandlerCallback callback) throws SQLException {
ResultMap orig = statementScope.getResultMap();
try {
statementScope.setResultSet(rs);
if (resultMap != null) {
statementScope.setResultMap(resultMap);
// Get Results
while (rs.next()) {
Object[] columnValues = resultMap.resolveSubMap(statementScope, rs).getResults(statementScope, rs);
callback.handleResultObject(statementScope, columnValues, rs);
}
}
} finally {
statementScope.setResultSet(null);
statementScope.setResultMap(orig);
}
}
/**
* Clean up any batches on the session
*
* @param sessionScope - the session to clean up
*/
public void cleanup(SessionScope sessionScope) {
Batch batch = (Batch) sessionScope.getBatch();
if (batch != null) {
batch.cleanupBatch(sessionScope);
sessionScope.setBatch(null);
}
}
private PreparedStatement prepareStatement(SessionScope sessionScope, Connection conn, String sql, Integer rsType) throws SQLException {
SqlMapExecutorDelegate delegate = ((SqlMapClientImpl) sessionScope.getSqlMapExecutor()).getDelegate();
if (sessionScope.hasPreparedStatementFor(sql)) {
return sessionScope.getPreparedStatement((sql));
} else {
PreparedStatement ps = conn.prepareStatement(sql, rsType.intValue(), ResultSet.CONCUR_READ_ONLY);
sessionScope.putPreparedStatement(delegate, sql, ps);
return ps;
}
}
private CallableStatement prepareCall(SessionScope sessionScope, Connection conn, String sql, Integer rsType) throws SQLException {
SqlMapExecutorDelegate delegate = ((SqlMapClientImpl) sessionScope.getSqlMapExecutor()).getDelegate();
if (sessionScope.hasPreparedStatementFor(sql)) {
return (CallableStatement) sessionScope.getPreparedStatement((sql));
} else {
CallableStatement cs = conn.prepareCall(sql, rsType.intValue(), ResultSet.CONCUR_READ_ONLY);
sessionScope.putPreparedStatement(delegate, sql, cs);
return cs;
}
}
private static PreparedStatement prepareStatement(SessionScope sessionScope, Connection conn, String sql) throws SQLException {
SqlMapExecutorDelegate delegate = ((SqlMapClientImpl) sessionScope.getSqlMapExecutor()).getDelegate();
if (sessionScope.hasPreparedStatementFor(sql)) {
return sessionScope.getPreparedStatement((sql));
} else {
PreparedStatement ps = conn.prepareStatement(sql);
sessionScope.putPreparedStatement(delegate, sql, ps);
return ps;
}
}
private CallableStatement prepareCall(SessionScope sessionScope, Connection conn, String sql) throws SQLException {
SqlMapExecutorDelegate delegate = ((SqlMapClientImpl) sessionScope.getSqlMapExecutor()).getDelegate();
if (sessionScope.hasPreparedStatementFor(sql)) {
return (CallableStatement) sessionScope.getPreparedStatement((sql));
} else {
CallableStatement cs = conn.prepareCall(sql);
sessionScope.putPreparedStatement(delegate, sql, cs);
return cs;
}
}
private static void closeStatement(SessionScope sessionScope, PreparedStatement ps) {
if (ps != null) {
if (!sessionScope.hasPreparedStatement(ps)) {
try {
ps.close();
} catch (SQLException e) {
// ignore
}
}
}
}
/**
* @param rs
*/
private static void closeResultSet(ResultSet rs) {
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
// ignore
}
}
}
private static void setStatementTimeout(MappedStatement mappedStatement, Statement statement) throws SQLException {
if (mappedStatement.getTimeout() != null) {
statement.setQueryTimeout(mappedStatement.getTimeout().intValue());
}
}
//
// Inner Classes
//
private static class Batch {
private String currentSql;
private List statementList = new ArrayList();
private List batchResultList = new ArrayList();
private int size;
/**
* Create a new batch
*/
public Batch() {
this.size = 0;
}
/**
* Getter for the batch size
*
* @return - the batch size
*/
public int getSize() {
return size;
}
/**
* Add a prepared statement to the batch
*
* @param statementScope - the request scope
* @param conn - the database connection
* @param sql - the SQL to add
* @param parameters - the parameters for the SQL
* @throws SQLException - if the prepare for the SQL fails
*/
public void addBatch(StatementScope statementScope, Connection conn, String sql, Object[] parameters) throws SQLException {
PreparedStatement ps = null;
if (currentSql != null && currentSql.equals(sql)) {
int last = statementList.size() - 1;
ps = (PreparedStatement) statementList.get(last);
} else {
ps = prepareStatement(statementScope.getSession(), conn, sql);
setStatementTimeout(statementScope.getStatement(), ps);
currentSql = sql;
statementList.add(ps);
batchResultList.add(new BatchResult(statementScope.getStatement().getId(), sql));
}
statementScope.getParameterMap().setParameters(statementScope, ps, parameters);
ps.addBatch();
size++;
}
/**
* TODO (Jeff Butler) - maybe this method should be deprecated in some release,
* and then removed in some even later release. executeBatchDetailed gives
* much more complete information.
*
* Execute the current session's batch
*
* @return - the number of rows updated
* @throws SQLException - if the batch fails
*/
public int executeBatch() throws SQLException {
int totalRowCount = 0;
for (int i = 0, n = statementList.size(); i < n; i++) {
PreparedStatement ps = (PreparedStatement) statementList.get(i);
int[] rowCounts = ps.executeBatch();
for (int j = 0; j < rowCounts.length; j++) {
if (rowCounts[j] == Statement.SUCCESS_NO_INFO) {
// do nothing
} else if (rowCounts[j] == Statement.EXECUTE_FAILED) {
throw new SQLException("The batched statement at index " + j + " failed to execute.");
} else {
totalRowCount += rowCounts[j];
}
}
}
return totalRowCount;
}
/**
* Batch execution method that returns all the information
* the driver has to offer.
*
* @return a List of BatchResult objects
* @throws BatchException (an SQLException sub class) if any nested
* batch fails
* @throws SQLException if a database access error occurs, or the drive
* does not support batch statements
* @throws BatchException if the driver throws BatchUpdateException
*/
public List executeBatchDetailed() throws SQLException, BatchException {
List answer = new ArrayList();
for (int i = 0, n = statementList.size(); i < n; i++) {
BatchResult br = (BatchResult) batchResultList.get(i);
PreparedStatement ps = (PreparedStatement) statementList.get(i);
try {
br.setUpdateCounts(ps.executeBatch());
} catch (BatchUpdateException e) {
StringBuffer message = new StringBuffer();
message.append("Sub batch number ");
message.append(i + 1);
message.append(" failed.");
if (i > 0) {
message.append(" ");
message.append(i);
message.append(" prior sub batch(s) completed successfully, but will be rolled back.");
}
throw new BatchException(message.toString(), e, answer, br.getStatementId(), br.getSql());
}
answer.add(br);
}
return answer;
}
/**
* Close all the statements in the batch and clear all the statements
*
* @param sessionScope
*/
public void cleanupBatch(SessionScope sessionScope) {
for (int i = 0, n = statementList.size(); i < n; i++) {
PreparedStatement ps = (PreparedStatement) statementList.get(i);
closeStatement(sessionScope, ps);
}
currentSql = null;
statementList.clear();
batchResultList.clear();
size = 0;
}
}
private void setupResultObjectFactory(StatementScope statementScope) {
SqlMapClientImpl client = (SqlMapClientImpl) statementScope.getSession().getSqlMapClient();
ResultObjectFactoryUtil.setResultObjectFactory(client.getResultObjectFactory());
ResultObjectFactoryUtil.setStatementId(statementScope.getStatement().getId());
}
}
ibatis/src/com/ibatis/sqlmap/engine/impl/ 0000755 0001750 0001750 00000000000 11047641630 020614 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/impl/ExtendedSqlMapClient.java 0000644 0001750 0001750 00000005740 11047641630 025502 0 ustar twerner twerner package com.ibatis.sqlmap.engine.impl;
import com.ibatis.sqlmap.client.*;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.execution.*;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import com.ibatis.sqlmap.engine.mapping.result.ResultObjectFactory;
import com.ibatis.common.util.PaginatedList;
import javax.sql.DataSource;
import java.sql.*;
import java.util.*;
/**
* @deprecated - this class is uneccessary and should be removed as
* soon as possible. Currently spring integration depends on it.
*/
public interface ExtendedSqlMapClient extends SqlMapClient {
Object insert(String id, Object param) throws SQLException;
Object insert(String id) throws SQLException;
int update(String id, Object param) throws SQLException;
int update(String id) throws SQLException;
int delete(String id, Object param) throws SQLException;
int delete(String id) throws SQLException;
Object queryForObject(String id, Object paramObject) throws SQLException;
Object queryForObject(String id) throws SQLException;
Object queryForObject(String id, Object paramObject, Object resultObject) throws SQLException;
List queryForList(String id, Object paramObject) throws SQLException;
List queryForList(String id) throws SQLException;
List queryForList(String id, Object paramObject, int skip, int max) throws SQLException;
List queryForList(String id, int skip, int max) throws SQLException;
PaginatedList queryForPaginatedList(String id, Object paramObject, int pageSize) throws SQLException;
PaginatedList queryForPaginatedList(String id, int pageSize) throws SQLException;
Map queryForMap(String id, Object paramObject, String keyProp) throws SQLException;
Map queryForMap(String id, Object paramObject, String keyProp, String valueProp) throws SQLException;
void queryWithRowHandler(String id, Object paramObject, RowHandler rowHandler) throws SQLException;
void queryWithRowHandler(String id, RowHandler rowHandler) throws SQLException;
void startTransaction() throws SQLException;
void startTransaction(int transactionIsolation) throws SQLException;
void commitTransaction() throws SQLException;
void endTransaction() throws SQLException;
void startBatch() throws SQLException;
int executeBatch() throws SQLException;
List executeBatchDetailed() throws SQLException, BatchException;
void setUserConnection(Connection connection) throws SQLException;
Connection getUserConnection() throws SQLException;
Connection getCurrentConnection() throws SQLException;
DataSource getDataSource();
MappedStatement getMappedStatement(String id);
boolean isLazyLoadingEnabled();
boolean isEnhancementEnabled();
SqlExecutor getSqlExecutor();
SqlMapExecutorDelegate getDelegate();
SqlMapSession openSession();
SqlMapSession openSession(Connection conn);
SqlMapSession getSession();
void flushDataCache();
void flushDataCache(String cacheId);
ResultObjectFactory getResultObjectFactory();
}
ibatis/src/com/ibatis/sqlmap/engine/impl/SqlMapClientImpl.java 0000644 0001750 0001750 00000020450 11047641630 024636 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.impl;
import com.ibatis.common.util.PaginatedList;
import com.ibatis.common.logging.Log;
import com.ibatis.common.logging.LogFactory;
import com.ibatis.sqlmap.client.*;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.execution.BatchException;
import com.ibatis.sqlmap.engine.execution.SqlExecutor;
import com.ibatis.sqlmap.engine.mapping.result.ResultObjectFactory;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
/**
* Implementation of ExtendedSqlMapClient
*/
public class SqlMapClientImpl implements SqlMapClient, ExtendedSqlMapClient {
private static final Log log = LogFactory.getLog(SqlMapClientImpl.class);
/**
* Delegate for SQL execution
*/
public SqlMapExecutorDelegate delegate;
protected ThreadLocal localSqlMapSession = new ThreadLocal();
/**
* Constructor to supply a delegate
*
* @param delegate - the delegate
*/
public SqlMapClientImpl(SqlMapExecutorDelegate delegate) {
this.delegate = delegate;
}
public Object insert(String id, Object param) throws SQLException {
return getLocalSqlMapSession().insert(id, param);
}
public Object insert(String id) throws SQLException {
return getLocalSqlMapSession().insert(id);
}
public int update(String id, Object param) throws SQLException {
return getLocalSqlMapSession().update(id, param);
}
public int update(String id) throws SQLException {
return getLocalSqlMapSession().update(id);
}
public int delete(String id, Object param) throws SQLException {
return getLocalSqlMapSession().delete(id, param);
}
public int delete(String id) throws SQLException {
return getLocalSqlMapSession().delete(id);
}
public Object queryForObject(String id, Object paramObject) throws SQLException {
return getLocalSqlMapSession().queryForObject(id, paramObject);
}
public Object queryForObject(String id) throws SQLException {
return getLocalSqlMapSession().queryForObject(id);
}
public Object queryForObject(String id, Object paramObject, Object resultObject) throws SQLException {
return getLocalSqlMapSession().queryForObject(id, paramObject, resultObject);
}
public List queryForList(String id, Object paramObject) throws SQLException {
return getLocalSqlMapSession().queryForList(id, paramObject);
}
public List queryForList(String id) throws SQLException {
return getLocalSqlMapSession().queryForList(id);
}
public List queryForList(String id, Object paramObject, int skip, int max) throws SQLException {
return getLocalSqlMapSession().queryForList(id, paramObject, skip, max);
}
public List queryForList(String id, int skip, int max) throws SQLException {
return getLocalSqlMapSession().queryForList(id, skip, max);
}
/**
* @deprecated All paginated list features have been deprecated
*/
public PaginatedList queryForPaginatedList(String id, Object paramObject, int pageSize) throws SQLException {
return getLocalSqlMapSession().queryForPaginatedList(id, paramObject, pageSize);
}
/**
* @deprecated All paginated list features have been deprecated
*/
public PaginatedList queryForPaginatedList(String id, int pageSize) throws SQLException {
return getLocalSqlMapSession().queryForPaginatedList(id, pageSize);
}
public Map queryForMap(String id, Object paramObject, String keyProp) throws SQLException {
return getLocalSqlMapSession().queryForMap(id, paramObject, keyProp);
}
public Map queryForMap(String id, Object paramObject, String keyProp, String valueProp) throws SQLException {
return getLocalSqlMapSession().queryForMap(id, paramObject, keyProp, valueProp);
}
public void queryWithRowHandler(String id, Object paramObject, RowHandler rowHandler) throws SQLException {
getLocalSqlMapSession().queryWithRowHandler(id, paramObject, rowHandler);
}
public void queryWithRowHandler(String id, RowHandler rowHandler) throws SQLException {
getLocalSqlMapSession().queryWithRowHandler(id, rowHandler);
}
public void startTransaction() throws SQLException {
getLocalSqlMapSession().startTransaction();
}
public void startTransaction(int transactionIsolation) throws SQLException {
getLocalSqlMapSession().startTransaction(transactionIsolation);
}
public void commitTransaction() throws SQLException {
getLocalSqlMapSession().commitTransaction();
}
public void endTransaction() throws SQLException {
try {
getLocalSqlMapSession().endTransaction();
} finally {
getLocalSqlMapSession().close();
}
}
public void startBatch() throws SQLException {
getLocalSqlMapSession().startBatch();
}
public int executeBatch() throws SQLException {
return getLocalSqlMapSession().executeBatch();
}
public List executeBatchDetailed() throws SQLException, BatchException {
return getLocalSqlMapSession().executeBatchDetailed();
}
public void setUserConnection(Connection connection) throws SQLException {
try {
getLocalSqlMapSession().setUserConnection(connection);
} finally {
if (connection == null) {
getLocalSqlMapSession().close();
}
}
}
/**
* TODO Deprecated
*
* @return Current connection
* @throws SQLException
* @deprecated
*/
public Connection getUserConnection() throws SQLException {
return getCurrentConnection();
}
public Connection getCurrentConnection() throws SQLException {
return getLocalSqlMapSession().getCurrentConnection();
}
public DataSource getDataSource() {
return delegate.getDataSource();
}
public MappedStatement getMappedStatement(String id) {
return delegate.getMappedStatement(id);
}
public boolean isLazyLoadingEnabled() {
return delegate.isLazyLoadingEnabled();
}
public boolean isEnhancementEnabled() {
return delegate.isEnhancementEnabled();
}
public SqlExecutor getSqlExecutor() {
return delegate.getSqlExecutor();
}
public SqlMapExecutorDelegate getDelegate() {
return delegate;
}
public SqlMapSession openSession() {
SqlMapSessionImpl sqlMapSession = new SqlMapSessionImpl(this);
sqlMapSession.open();
return sqlMapSession;
}
public SqlMapSession openSession(Connection conn) {
try {
SqlMapSessionImpl sqlMapSession = new SqlMapSessionImpl(this);
sqlMapSession.open();
sqlMapSession.setUserConnection(conn);
return sqlMapSession;
} catch (SQLException e) {
throw new SqlMapException("Error setting user provided connection. Cause: " + e, e);
}
}
/**
* TODO : DEPRECATED
*
* @deprecated Use openSession()
*/
public SqlMapSession getSession() {
log.warn("Use of a deprecated API detected. SqlMapClient.getSession() is deprecated. Use SqlMapClient.openSession() instead.");
return openSession();
}
public void flushDataCache() {
delegate.flushDataCache();
}
public void flushDataCache(String cacheId) {
delegate.flushDataCache(cacheId);
}
protected SqlMapSessionImpl getLocalSqlMapSession() {
SqlMapSessionImpl sqlMapSession = (SqlMapSessionImpl) localSqlMapSession.get();
if (sqlMapSession == null || sqlMapSession.isClosed()) {
sqlMapSession = new SqlMapSessionImpl(this);
localSqlMapSession.set(sqlMapSession);
}
return sqlMapSession;
}
public ResultObjectFactory getResultObjectFactory() {
return delegate.getResultObjectFactory();
}
}
ibatis/src/com/ibatis/sqlmap/engine/impl/SqlMapExecutorDelegate.java 0000644 0001750 0001750 00000067355 11047641630 026046 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.impl;
import com.ibatis.common.beans.Probe;
import com.ibatis.common.beans.ProbeFactory;
import com.ibatis.common.jdbc.exception.NestedSQLException;
import com.ibatis.common.util.PaginatedList;
import com.ibatis.sqlmap.client.SqlMapException;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.cache.CacheKey;
import com.ibatis.sqlmap.engine.cache.CacheModel;
import com.ibatis.sqlmap.engine.exchange.DataExchangeFactory;
import com.ibatis.sqlmap.engine.execution.BatchException;
import com.ibatis.sqlmap.engine.execution.SqlExecutor;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultObjectFactory;
import com.ibatis.sqlmap.engine.mapping.statement.InsertStatement;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import com.ibatis.sqlmap.engine.mapping.statement.PaginatedDataList;
import com.ibatis.sqlmap.engine.mapping.statement.SelectKeyStatement;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.scope.SessionScope;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import com.ibatis.sqlmap.engine.transaction.TransactionException;
import com.ibatis.sqlmap.engine.transaction.TransactionManager;
import com.ibatis.sqlmap.engine.transaction.TransactionState;
import com.ibatis.sqlmap.engine.transaction.user.UserProvidedTransaction;
import com.ibatis.sqlmap.engine.type.TypeHandlerFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* The workhorse that really runs the SQL
*/
public class SqlMapExecutorDelegate {
private static final Probe PROBE = ProbeFactory.getProbe();
private boolean lazyLoadingEnabled;
private boolean cacheModelsEnabled;
private boolean enhancementEnabled;
private boolean useColumnLabel = true;
private boolean forceMultipleResultSetSupport;
private TransactionManager txManager;
private HashMap mappedStatements;
private HashMap cacheModels;
private HashMap resultMaps;
private HashMap parameterMaps;
protected SqlExecutor sqlExecutor;
private TypeHandlerFactory typeHandlerFactory;
private DataExchangeFactory dataExchangeFactory;
private ResultObjectFactory resultObjectFactory;
private boolean statementCacheEnabled;
/**
* Default constructor
*/
public SqlMapExecutorDelegate() {
mappedStatements = new HashMap();
cacheModels = new HashMap();
resultMaps = new HashMap();
parameterMaps = new HashMap();
sqlExecutor = new SqlExecutor();
typeHandlerFactory = new TypeHandlerFactory();
dataExchangeFactory = new DataExchangeFactory(typeHandlerFactory);
}
/**
* DO NOT DEPEND ON THIS. Here to avoid breaking spring integration.
* @deprecated
*/
public int getMaxTransactions() {
return -1;
}
/**
* Getter for the DataExchangeFactory
*
* @return - the DataExchangeFactory
*/
public DataExchangeFactory getDataExchangeFactory() {
return dataExchangeFactory;
}
/**
* Getter for the TypeHandlerFactory
*
* @return - the TypeHandlerFactory
*/
public TypeHandlerFactory getTypeHandlerFactory() {
return typeHandlerFactory;
}
/**
* Getter for the status of lazy loading
*
* @return - the status
*/
public boolean isLazyLoadingEnabled() {
return lazyLoadingEnabled;
}
/**
* Turn on or off lazy loading
*
* @param lazyLoadingEnabled - the new state of caching
*/
public void setLazyLoadingEnabled(boolean lazyLoadingEnabled) {
this.lazyLoadingEnabled = lazyLoadingEnabled;
}
/**
* Getter for the status of caching
*
* @return - the status
*/
public boolean isCacheModelsEnabled() {
return cacheModelsEnabled;
}
/**
* Turn on or off caching
*
* @param cacheModelsEnabled - the new state of caching
*/
public void setCacheModelsEnabled(boolean cacheModelsEnabled) {
this.cacheModelsEnabled = cacheModelsEnabled;
}
/**
* Getter for the status of CGLib enhancements
*
* @return - the status
*/
public boolean isEnhancementEnabled() {
return enhancementEnabled;
}
/**
* Turn on or off CGLib enhancements
*
* @param enhancementEnabled - the new state
*/
public void setEnhancementEnabled(boolean enhancementEnabled) {
this.enhancementEnabled = enhancementEnabled;
}
public boolean isUseColumnLabel() {
return useColumnLabel;
}
public void setUseColumnLabel(boolean useColumnLabel) {
this.useColumnLabel = useColumnLabel;
}
/**
* Getter for the transaction manager
*
* @return - the transaction manager
*/
public TransactionManager getTxManager() {
return txManager;
}
/**
* Setter for the transaction manager
*
* @param txManager - the transaction manager
*/
public void setTxManager(TransactionManager txManager) {
this.txManager = txManager;
}
/**
* Add a mapped statement
*
* @param ms - the mapped statement to add
*/
public void addMappedStatement(MappedStatement ms) {
if (mappedStatements.containsKey(ms.getId())) {
throw new SqlMapException("There is already a statement named " + ms.getId() + " in this SqlMap.");
}
ms.setBaseCacheKey(hashCode());
mappedStatements.put(ms.getId(), ms);
}
/**
* Get an iterator of the mapped statements
*
* @return - the iterator
*/
public Iterator getMappedStatementNames() {
return mappedStatements.keySet().iterator();
}
/**
* Get a mappedstatement by its ID
*
* @param id - the statement ID
* @return - the mapped statement
*/
public MappedStatement getMappedStatement(String id) {
MappedStatement ms = (MappedStatement) mappedStatements.get(id);
if (ms == null) {
throw new SqlMapException("There is no statement named " + id + " in this SqlMap.");
}
return ms;
}
/**
* Add a cache model
*
* @param model - the model to add
*/
public void addCacheModel(CacheModel model) {
cacheModels.put(model.getId(), model);
}
/**
* Get an iterator of the cache models
*
* @return - the cache models
*/
public Iterator getCacheModelNames() {
return cacheModels.keySet().iterator();
}
/**
* Get a cache model by ID
*
* @param id - the ID
* @return - the cache model
*/
public CacheModel getCacheModel(String id) {
CacheModel model = (CacheModel) cacheModels.get(id);
if (model == null) {
throw new SqlMapException("There is no cache model named " + id + " in this SqlMap.");
}
return model;
}
/**
* Add a result map
*
* @param map - the result map to add
*/
public void addResultMap(ResultMap map) {
resultMaps.put(map.getId(), map);
}
/**
* Get an iterator of the result maps
*
* @return - the result maps
*/
public Iterator getResultMapNames() {
return resultMaps.keySet().iterator();
}
/**
* Get a result map by ID
*
* @param id - the ID
* @return - the result map
*/
public ResultMap getResultMap(String id) {
ResultMap map = (ResultMap) resultMaps.get(id);
if (map == null) {
throw new SqlMapException("There is no result map named " + id + " in this SqlMap.");
}
return map;
}
/**
* Add a parameter map
*
* @param map - the map to add
*/
public void addParameterMap(ParameterMap map) {
parameterMaps.put(map.getId(), map);
}
/**
* Get an iterator of all of the parameter maps
*
* @return - the parameter maps
*/
public Iterator getParameterMapNames() {
return parameterMaps.keySet().iterator();
}
/**
* Get a parameter map by ID
*
* @param id - the ID
* @return - the parameter map
*/
public ParameterMap getParameterMap(String id) {
ParameterMap map = (ParameterMap) parameterMaps.get(id);
if (map == null) {
throw new SqlMapException("There is no parameter map named " + id + " in this SqlMap.");
}
return map;
}
/**
* Flush all of the data caches
*/
public void flushDataCache() {
Iterator models = cacheModels.values().iterator();
while (models.hasNext()) {
((CacheModel) models.next()).flush();
}
}
/**
* Flush a single cache by ID
*
* @param id - the ID
*/
public void flushDataCache(String id) {
CacheModel model = getCacheModel(id);
if (model != null) {
model.flush();
}
}
//-- Basic Methods
/**
* Call an insert statement by ID
*
* @param sessionScope - the session
* @param id - the statement ID
* @param param - the parameter object
* @return - the generated key (or null)
* @throws SQLException - if the insert fails
*/
public Object insert(SessionScope sessionScope, String id, Object param) throws SQLException {
Object generatedKey = null;
MappedStatement ms = getMappedStatement(id);
Transaction trans = getTransaction(sessionScope);
boolean autoStart = trans == null;
try {
trans = autoStartTransaction(sessionScope, autoStart, trans);
SelectKeyStatement selectKeyStatement = null;
if (ms instanceof InsertStatement) {
selectKeyStatement = ((InsertStatement) ms).getSelectKeyStatement();
}
// Here we get the old value for the key property. We'll want it later if for some reason the
// insert fails.
Object oldKeyValue = null;
String keyProperty = null;
boolean resetKeyValueOnFailure = false;
if (selectKeyStatement != null && !selectKeyStatement.isRunAfterSQL()) {
keyProperty = selectKeyStatement.getKeyProperty();
oldKeyValue = PROBE.getObject(param, keyProperty);
generatedKey = executeSelectKey(sessionScope, trans, ms, param);
resetKeyValueOnFailure = true;
}
StatementScope statementScope = beginStatementScope(sessionScope, ms);
try {
ms.executeUpdate(statementScope, trans, param);
}catch (SQLException e){
// uh-oh, the insert failed, so if we set the reset flag earlier, we'll put the old value
// back...
if(resetKeyValueOnFailure) PROBE.setObject(param, keyProperty, oldKeyValue);
// ...and still throw the exception.
throw e;
} finally {
endStatementScope(statementScope);
}
if (selectKeyStatement != null && selectKeyStatement.isRunAfterSQL()) {
generatedKey = executeSelectKey(sessionScope, trans, ms, param);
}
autoCommitTransaction(sessionScope, autoStart);
} finally {
autoEndTransaction(sessionScope, autoStart);
}
return generatedKey;
}
private Object executeSelectKey(SessionScope sessionScope, Transaction trans, MappedStatement ms, Object param) throws SQLException {
Object generatedKey = null;
StatementScope statementScope;
InsertStatement insert = (InsertStatement) ms;
SelectKeyStatement selectKeyStatement = insert.getSelectKeyStatement();
if (selectKeyStatement != null) {
statementScope = beginStatementScope(sessionScope, selectKeyStatement);
try {
generatedKey = selectKeyStatement.executeQueryForObject(statementScope, trans, param, null);
String keyProp = selectKeyStatement.getKeyProperty();
if (keyProp != null) {
PROBE.setObject(param, keyProp, generatedKey);
}
} finally {
endStatementScope(statementScope);
}
}
return generatedKey;
}
/**
* Execute an update statement
*
* @param sessionScope - the session scope
* @param id - the statement ID
* @param param - the parameter object
* @return - the number of rows updated
* @throws SQLException - if the update fails
*/
public int update(SessionScope sessionScope, String id, Object param) throws SQLException {
int rows = 0;
MappedStatement ms = getMappedStatement(id);
Transaction trans = getTransaction(sessionScope);
boolean autoStart = trans == null;
try {
trans = autoStartTransaction(sessionScope, autoStart, trans);
StatementScope statementScope = beginStatementScope(sessionScope, ms);
try {
rows = ms.executeUpdate(statementScope, trans, param);
} finally {
endStatementScope(statementScope);
}
autoCommitTransaction(sessionScope, autoStart);
} finally {
autoEndTransaction(sessionScope, autoStart);
}
return rows;
}
/**
* Execute a delete statement
*
* @param sessionScope - the session scope
* @param id - the statement ID
* @param param - the parameter object
* @return - the number of rows deleted
* @throws SQLException - if the delete fails
*/
public int delete(SessionScope sessionScope, String id, Object param) throws SQLException {
return update(sessionScope, id, param);
}
/**
* Execute a select for a single object
*
* @param sessionScope - the session scope
* @param id - the statement ID
* @param paramObject - the parameter object
* @return - the result of the query
* @throws SQLException - if the query fails
*/
public Object queryForObject(SessionScope sessionScope, String id, Object paramObject) throws SQLException {
return queryForObject(sessionScope, id, paramObject, null);
}
/**
* Execute a select for a single object
*
* @param sessionScope - the session scope
* @param id - the statement ID
* @param paramObject - the parameter object
* @param resultObject - the result object (if not supplied or null, a new object will be created)
* @return - the result of the query
* @throws SQLException - if the query fails
*/
public Object queryForObject(SessionScope sessionScope, String id, Object paramObject, Object resultObject) throws SQLException {
Object object = null;
MappedStatement ms = getMappedStatement(id);
Transaction trans = getTransaction(sessionScope);
boolean autoStart = trans == null;
try {
trans = autoStartTransaction(sessionScope, autoStart, trans);
StatementScope statementScope = beginStatementScope(sessionScope, ms);
try {
object = ms.executeQueryForObject(statementScope, trans, paramObject, resultObject);
} finally {
endStatementScope(statementScope);
}
autoCommitTransaction(sessionScope, autoStart);
} finally {
autoEndTransaction(sessionScope, autoStart);
}
return object;
}
/**
* Execute a query for a list
*
* @param sessionScope - the session scope
* @param id - the statement ID
* @param paramObject - the parameter object
* @return - the data list
* @throws SQLException - if the query fails
*/
public List queryForList(SessionScope sessionScope, String id, Object paramObject) throws SQLException {
return queryForList(sessionScope, id, paramObject, SqlExecutor.NO_SKIPPED_RESULTS, SqlExecutor.NO_MAXIMUM_RESULTS);
}
/**
* Execute a query for a list
*
* @param sessionScope - the session scope
* @param id - the statement ID
* @param paramObject - the parameter object
* @param skip - the number of rows to skip
* @param max - the maximum number of rows to return
* @return - the data list
* @throws SQLException - if the query fails
*/
public List queryForList(SessionScope sessionScope, String id, Object paramObject, int skip, int max) throws SQLException {
List list = null;
MappedStatement ms = getMappedStatement(id);
Transaction trans = getTransaction(sessionScope);
boolean autoStart = trans == null;
try {
trans = autoStartTransaction(sessionScope, autoStart, trans);
StatementScope statementScope = beginStatementScope(sessionScope, ms);
try {
list = ms.executeQueryForList(statementScope, trans, paramObject, skip, max);
} finally {
endStatementScope(statementScope);
}
autoCommitTransaction(sessionScope, autoStart);
} finally {
autoEndTransaction(sessionScope, autoStart);
}
return list;
}
/**
* Execute a query with a row handler.
* The row handler is called once per row in the query results.
*
* @param sessionScope - the session scope
* @param id - the statement ID
* @param paramObject - the parameter object
* @param rowHandler - the row handler
* @throws SQLException - if the query fails
*/
public void queryWithRowHandler(SessionScope sessionScope, String id, Object paramObject, RowHandler rowHandler) throws SQLException {
MappedStatement ms = getMappedStatement(id);
Transaction trans = getTransaction(sessionScope);
boolean autoStart = trans == null;
try {
trans = autoStartTransaction(sessionScope, autoStart, trans);
StatementScope statementScope = beginStatementScope(sessionScope, ms);
try {
ms.executeQueryWithRowHandler(statementScope, trans, paramObject, rowHandler);
} finally {
endStatementScope(statementScope);
}
autoCommitTransaction(sessionScope, autoStart);
} finally {
autoEndTransaction(sessionScope, autoStart);
}
}
/**
* Execute a query and return a paginated list
*
* @param sessionScope - the session scope
* @param id - the statement ID
* @param paramObject - the parameter object
* @param pageSize - the page size
* @return - the data list
* @throws SQLException - if the query fails
* @deprecated All paginated list features have been deprecated
*/
public PaginatedList queryForPaginatedList(SessionScope sessionScope, String id, Object paramObject, int pageSize) throws SQLException {
return new PaginatedDataList(sessionScope.getSqlMapExecutor(), id, paramObject, pageSize);
}
/**
* Execute a query for a map.
* The map has the table key as the key, and the results as the map data
*
* @param sessionScope - the session scope
* @param id - the statement ID
* @param paramObject - the parameter object
* @param keyProp - the key property (from the results for the map)
* @return - the Map
* @throws SQLException - if the query fails
*/
public Map queryForMap(SessionScope sessionScope, String id, Object paramObject, String keyProp) throws SQLException {
return queryForMap(sessionScope, id, paramObject, keyProp, null);
}
/**
* Execute a query for a map.
* The map has the table key as the key, and a property from the results as the map data
*
* @param sessionScope - the session scope
* @param id - the statement ID
* @param paramObject - the parameter object
* @param keyProp - the property for the map key
* @param valueProp - the property for the map data
* @return - the Map
* @throws SQLException - if the query fails
*/
public Map queryForMap(SessionScope sessionScope, String id, Object paramObject, String keyProp, String valueProp) throws SQLException {
Map map = new HashMap();
List list = queryForList(sessionScope, id, paramObject);
for (int i = 0, n = list.size(); i < n; i++) {
Object object = list.get(i);
Object key = PROBE.getObject(object, keyProp);
Object value = null;
if (valueProp == null) {
value = object;
} else {
value = PROBE.getObject(object, valueProp);
}
map.put(key, value);
}
return map;
}
// -- Transaction Control Methods
/**
* Start a transaction on the session
*
* @param sessionScope - the session
* @throws SQLException - if the transaction could not be started
*/
public void startTransaction(SessionScope sessionScope) throws SQLException {
try {
txManager.begin(sessionScope);
} catch (TransactionException e) {
throw new NestedSQLException("Could not start transaction. Cause: " + e, e);
}
}
/**
* Start a transaction on the session with the specified isolation level.
*
* @param sessionScope - the session
* @throws SQLException - if the transaction could not be started
*/
public void startTransaction(SessionScope sessionScope, int transactionIsolation) throws SQLException {
try {
txManager.begin(sessionScope, transactionIsolation);
} catch (TransactionException e) {
throw new NestedSQLException("Could not start transaction. Cause: " + e, e);
}
}
/**
* Commit the transaction on a session
*
* @param sessionScope - the session
* @throws SQLException - if the transaction could not be committed
*/
public void commitTransaction(SessionScope sessionScope) throws SQLException {
try {
// Auto batch execution
if (sessionScope.isInBatch()) {
executeBatch(sessionScope);
}
sqlExecutor.cleanup(sessionScope);
txManager.commit(sessionScope);
} catch (TransactionException e) {
throw new NestedSQLException("Could not commit transaction. Cause: " + e, e);
}
}
/**
* End the transaction on a session
*
* @param sessionScope - the session
* @throws SQLException - if the transaction could not be ended
*/
public void endTransaction(SessionScope sessionScope) throws SQLException {
try {
try {
sqlExecutor.cleanup(sessionScope);
} finally {
txManager.end(sessionScope);
}
} catch (TransactionException e) {
throw new NestedSQLException("Error while ending transaction. Cause: " + e, e);
}
}
/**
* Start a batch for a session
*
* @param sessionScope - the session
*/
public void startBatch(SessionScope sessionScope) {
sessionScope.setInBatch(true);
}
/**
* Execute a batch for a session
*
* @param sessionScope - the session
* @return - the number of rows impacted by the batch
* @throws SQLException - if the batch fails
*/
public int executeBatch(SessionScope sessionScope) throws SQLException {
sessionScope.setInBatch(false);
return sqlExecutor.executeBatch(sessionScope);
}
/**
* Execute a batch for a session
*
* @param sessionScope - the session
* @return - a List of BatchResult objects (may be null if no batch
* has been initiated). There will be one BatchResult object in the
* list for each sub-batch executed
* @throws SQLException if a database access error occurs, or the drive
* does not support batch statements
* @throws BatchException if the driver throws BatchUpdateException
*/
public List executeBatchDetailed(SessionScope sessionScope) throws SQLException, BatchException {
sessionScope.setInBatch(false);
return sqlExecutor.executeBatchDetailed(sessionScope);
}
/**
* Use a user-provided transaction for a session
*
* @param sessionScope - the session scope
* @param userConnection - the user supplied connection
*/
public void setUserProvidedTransaction(SessionScope sessionScope, Connection userConnection) {
if (sessionScope.getTransactionState() == TransactionState.STATE_USER_PROVIDED) {
sessionScope.recallTransactionState();
}
if (userConnection != null) {
Connection conn = userConnection;
sessionScope.saveTransactionState();
sessionScope.setTransaction(new UserProvidedTransaction(conn));
sessionScope.setTransactionState(TransactionState.STATE_USER_PROVIDED);
} else {
sessionScope.setTransaction(null);
sessionScope.closePreparedStatements();
sessionScope.cleanup();
}
}
/**
* Get the DataSource for the session
*
* @return - the DataSource
*/
public DataSource getDataSource() {
DataSource ds = null;
if (txManager != null) {
ds = txManager.getConfig().getDataSource();
}
return ds;
}
/**
* Getter for the SqlExecutor
*
* @return the SqlExecutor
*/
public SqlExecutor getSqlExecutor() {
return sqlExecutor;
}
/**
* Get a transaction for the session
*
* @param sessionScope - the session
* @return - the transaction
*/
public Transaction getTransaction(SessionScope sessionScope) {
return sessionScope.getTransaction();
}
// -- Protected Methods
protected void autoEndTransaction(SessionScope sessionScope, boolean autoStart) throws SQLException {
if (autoStart) {
sessionScope.getSqlMapTxMgr().endTransaction();
}
}
protected void autoCommitTransaction(SessionScope sessionScope, boolean autoStart) throws SQLException {
if (autoStart) {
sessionScope.getSqlMapTxMgr().commitTransaction();
}
}
protected Transaction autoStartTransaction(SessionScope sessionScope, boolean autoStart, Transaction trans) throws SQLException {
Transaction transaction = trans;
if (autoStart) {
sessionScope.getSqlMapTxMgr().startTransaction();
transaction = getTransaction(sessionScope);
}
return transaction;
}
public boolean equals(Object obj) {
return this == obj;
}
public int hashCode() {
CacheKey key = new CacheKey();
if (txManager != null) {
key.update(txManager);
if (txManager.getConfig().getDataSource() != null) {
key.update(txManager.getConfig().getDataSource());
}
}
key.update(System.identityHashCode(this));
return key.hashCode();
}
protected StatementScope beginStatementScope(SessionScope sessionScope, MappedStatement mappedStatement) {
StatementScope statementScope = new StatementScope(sessionScope);
sessionScope.incrementRequestStackDepth();
mappedStatement.initRequest(statementScope);
return statementScope;
}
protected void endStatementScope(StatementScope statementScope) {
statementScope.getSession().decrementRequestStackDepth();
}
protected SessionScope beginSessionScope() {
return new SessionScope();
}
protected void endSessionScope(SessionScope sessionScope) {
sessionScope.cleanup();
}
public ResultObjectFactory getResultObjectFactory() {
return resultObjectFactory;
}
public void setResultObjectFactory(ResultObjectFactory resultObjectFactory) {
this.resultObjectFactory = resultObjectFactory;
}
public boolean isStatementCacheEnabled() {
return statementCacheEnabled;
}
public void setStatementCacheEnabled(boolean statementCacheEnabled) {
this.statementCacheEnabled = statementCacheEnabled;
}
public boolean isForceMultipleResultSetSupport() {
return forceMultipleResultSetSupport;
}
public void setForceMultipleResultSetSupport(boolean forceMultipleResultSetSupport) {
this.forceMultipleResultSetSupport = forceMultipleResultSetSupport;
}
}
ibatis/src/com/ibatis/sqlmap/engine/impl/SqlMapSessionImpl.java 0000644 0001750 0001750 00000017705 11047641630 025054 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.impl;
import com.ibatis.common.jdbc.exception.NestedSQLException;
import com.ibatis.common.util.PaginatedList;
import com.ibatis.sqlmap.client.SqlMapSession;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.execution.BatchException;
import com.ibatis.sqlmap.engine.execution.SqlExecutor;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import com.ibatis.sqlmap.engine.scope.SessionScope;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import com.ibatis.sqlmap.engine.transaction.TransactionException;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
/**
* Implementation of SqlMapSession
*/
public class SqlMapSessionImpl implements SqlMapSession {
protected SqlMapExecutorDelegate delegate;
protected SessionScope sessionScope;
protected boolean closed;
/**
* Constructor
*
* @param client - the client that will use the session
*/
public SqlMapSessionImpl(SqlMapClientImpl client) {
this.delegate = client.getDelegate();
this.sessionScope = this.delegate.beginSessionScope();
this.sessionScope.setSqlMapClient(client);
this.sessionScope.setSqlMapExecutor(client);
this.sessionScope.setSqlMapTxMgr(client);
this.closed = false;
}
/**
* Start the session
*/
public void open() {
sessionScope.setSqlMapTxMgr(this);
}
/**
* Getter to tell if the session is still open
*
* @return - the status of the session
*/
public boolean isClosed() {
return closed;
}
public void close() {
if (delegate != null && sessionScope != null) delegate.endSessionScope(sessionScope);
if (sessionScope != null) sessionScope = null;
if (delegate != null) delegate = null;
if (!closed) closed = true;
}
public Object insert(String id, Object param) throws SQLException {
return delegate.insert(sessionScope, id, param);
}
public Object insert(String id) throws SQLException {
return insert(id, null);
}
public int update(String id, Object param) throws SQLException {
return delegate.update(sessionScope, id, param);
}
public int update(String id) throws SQLException {
return update(id, null);
}
public int delete(String id, Object param) throws SQLException {
return delegate.delete(sessionScope, id, param);
}
public int delete(String id) throws SQLException {
return delete(id, null);
}
public Object queryForObject(String id, Object paramObject) throws SQLException {
return delegate.queryForObject(sessionScope, id, paramObject);
}
public Object queryForObject(String id) throws SQLException {
return queryForObject(id, null);
}
public Object queryForObject(String id, Object paramObject, Object resultObject) throws SQLException {
return delegate.queryForObject(sessionScope, id, paramObject, resultObject);
}
public List queryForList(String id, Object paramObject) throws SQLException {
return delegate.queryForList(sessionScope, id, paramObject);
}
public List queryForList(String id) throws SQLException {
return queryForList(id, null);
}
public List queryForList(String id, Object paramObject, int skip, int max) throws SQLException {
return delegate.queryForList(sessionScope, id, paramObject, skip, max);
}
public List queryForList(String id, int skip, int max) throws SQLException {
return queryForList(id, null, skip, max);
}
/**
* @deprecated All paginated list features have been deprecated
*/
public PaginatedList queryForPaginatedList(String id, Object paramObject, int pageSize) throws SQLException {
return delegate.queryForPaginatedList(sessionScope, id, paramObject, pageSize);
}
/**
* @deprecated All paginated list features have been deprecated
*/
public PaginatedList queryForPaginatedList(String id, int pageSize) throws SQLException {
return queryForPaginatedList(id, null, pageSize);
}
public Map queryForMap(String id, Object paramObject, String keyProp) throws SQLException {
return delegate.queryForMap(sessionScope, id, paramObject, keyProp);
}
public Map queryForMap(String id, Object paramObject, String keyProp, String valueProp) throws SQLException {
return delegate.queryForMap(sessionScope, id, paramObject, keyProp, valueProp);
}
public void queryWithRowHandler(String id, Object paramObject, RowHandler rowHandler) throws SQLException {
delegate.queryWithRowHandler(sessionScope, id, paramObject, rowHandler);
}
public void queryWithRowHandler(String id, RowHandler rowHandler) throws SQLException {
queryWithRowHandler(id, null, rowHandler);
}
public void startTransaction() throws SQLException {
delegate.startTransaction(sessionScope);
}
public void startTransaction(int transactionIsolation) throws SQLException {
delegate.startTransaction(sessionScope, transactionIsolation);
}
public void commitTransaction() throws SQLException {
delegate.commitTransaction(sessionScope);
}
public void endTransaction() throws SQLException {
delegate.endTransaction(sessionScope);
}
public void startBatch() throws SQLException {
delegate.startBatch(sessionScope);
}
public int executeBatch() throws SQLException {
return delegate.executeBatch(sessionScope);
}
public List executeBatchDetailed() throws SQLException, BatchException {
return delegate.executeBatchDetailed(sessionScope);
}
public void setUserConnection(Connection connection) throws SQLException {
delegate.setUserProvidedTransaction(sessionScope, connection);
}
/**
* TODO Deprecated
*
* @return Current connection
* @throws SQLException
* @deprecated
*/
public Connection getUserConnection() throws SQLException {
return getCurrentConnection();
}
public Connection getCurrentConnection() throws SQLException {
try {
Connection conn = null;
Transaction trans = delegate.getTransaction(sessionScope);
if (trans != null) {
conn = trans.getConnection();
}
return conn;
} catch (TransactionException e) {
throw new NestedSQLException("Error getting Connection from Transaction. Cause: " + e, e);
}
}
public DataSource getDataSource() {
return delegate.getDataSource();
}
/**
* Gets a mapped statement by ID
*
* @param id - the ID
* @return - the mapped statement
*/
public MappedStatement getMappedStatement(String id) {
return delegate.getMappedStatement(id);
}
/**
* Get the status of lazy loading
*
* @return - the status
*/
public boolean isLazyLoadingEnabled() {
return delegate.isLazyLoadingEnabled();
}
/**
* Get the status of CGLib enhancements
*
* @return - the status
*/
public boolean isEnhancementEnabled() {
return delegate.isEnhancementEnabled();
}
/**
* Get the SQL executor
*
* @return - the executor
*/
public SqlExecutor getSqlExecutor() {
return delegate.getSqlExecutor();
}
/**
* Get the delegate
*
* @return - the delegate
*/
public SqlMapExecutorDelegate getDelegate() {
return delegate;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/ 0000755 0001750 0001750 00000000000 11047641640 021307 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/mapping/parameter/ 0000755 0001750 0001750 00000000000 11047641640 023267 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/mapping/parameter/InlineParameterMapParser.java 0000644 0001750 0001750 00000023377 11047641640 031040 0 ustar twerner twerner package com.ibatis.sqlmap.engine.mapping.parameter;
import com.ibatis.common.beans.Probe;
import com.ibatis.common.beans.ProbeFactory;
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapException;
import com.ibatis.sqlmap.client.extensions.TypeHandlerCallback;
import com.ibatis.sqlmap.engine.mapping.sql.SqlText;
import com.ibatis.sqlmap.engine.type.CustomTypeHandler;
import com.ibatis.sqlmap.engine.type.DomTypeMarker;
import com.ibatis.sqlmap.engine.type.TypeHandler;
import com.ibatis.sqlmap.engine.type.TypeHandlerFactory;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
public class InlineParameterMapParser {
private static final Probe PROBE = ProbeFactory.getProbe();
private static final String PARAMETER_TOKEN = "#";
private static final String PARAM_DELIM = ":";
public SqlText parseInlineParameterMap(TypeHandlerFactory typeHandlerFactory, String sqlStatement) {
return parseInlineParameterMap(typeHandlerFactory, sqlStatement, null);
}
public SqlText parseInlineParameterMap(TypeHandlerFactory typeHandlerFactory, String sqlStatement, Class parameterClass) {
String newSql = sqlStatement;
List mappingList = new ArrayList();
StringTokenizer parser = new StringTokenizer(sqlStatement, PARAMETER_TOKEN, true);
StringBuffer newSqlBuffer = new StringBuffer();
String token = null;
String lastToken = null;
while (parser.hasMoreTokens()) {
token = parser.nextToken();
if (PARAMETER_TOKEN.equals(lastToken)) {
if (PARAMETER_TOKEN.equals(token)) {
newSqlBuffer.append(PARAMETER_TOKEN);
token = null;
} else {
ParameterMapping mapping = null;
if (token.indexOf(PARAM_DELIM) > -1) {
mapping = oldParseMapping(token, parameterClass, typeHandlerFactory);
} else {
mapping = newParseMapping(token, parameterClass, typeHandlerFactory);
}
mappingList.add(mapping);
newSqlBuffer.append("?");
token = parser.nextToken();
if (!PARAMETER_TOKEN.equals(token)) {
throw new SqlMapException("Unterminated inline parameter in mapped statement (" + "statement.getId()" + ").");
}
token = null;
}
} else {
if (!PARAMETER_TOKEN.equals(token)) {
newSqlBuffer.append(token);
}
}
lastToken = token;
}
newSql = newSqlBuffer.toString();
ParameterMapping[] mappingArray = (ParameterMapping[]) mappingList.toArray(new ParameterMapping[mappingList.size()]);
SqlText sqlText = new SqlText();
sqlText.setText(newSql);
sqlText.setParameterMappings(mappingArray);
return sqlText;
}
private ParameterMapping newParseMapping(String token, Class parameterClass, TypeHandlerFactory typeHandlerFactory) {
ParameterMapping mapping = new ParameterMapping();
// #propertyName,javaType=string,jdbcType=VARCHAR,mode=IN,nullValue=N/A,handler=string,numericScale=2#
StringTokenizer paramParser = new StringTokenizer(token, "=,", false);
mapping.setPropertyName(paramParser.nextToken());
while (paramParser.hasMoreTokens()) {
String field = paramParser.nextToken();
if (paramParser.hasMoreTokens()) {
String value = paramParser.nextToken();
if ("javaType".equals(field)) {
value = typeHandlerFactory.resolveAlias(value);
mapping.setJavaTypeName(value);
} else if ("jdbcType".equals(field)) {
mapping.setJdbcTypeName(value);
} else if ("mode".equals(field)) {
mapping.setMode(value);
} else if ("nullValue".equals(field)) {
mapping.setNullValue(value);
} else if ("handler".equals(field)) {
try {
value = typeHandlerFactory.resolveAlias(value);
Object impl = Resources.instantiate(value);
if (impl instanceof TypeHandlerCallback) {
mapping.setTypeHandler(new CustomTypeHandler((TypeHandlerCallback) impl));
} else if (impl instanceof TypeHandler) {
mapping.setTypeHandler((TypeHandler) impl);
} else {
throw new SqlMapException ("The class " + value + " is not a valid implementation of TypeHandler or TypeHandlerCallback");
}
} catch (Exception e) {
throw new SqlMapException("Error loading class specified by handler field in " + token + ". Cause: " + e, e);
}
} else if ("numericScale".equals(field)) {
try {
Integer numericScale = Integer.valueOf(value);
if (numericScale.intValue() < 0) {
throw new SqlMapException("Value specified for numericScale must be greater than or equal to zero");
}
mapping.setNumericScale(numericScale);
} catch (NumberFormatException e) {
throw new SqlMapException("Value specified for numericScale is not a valid Integer");
}
} else {
throw new SqlMapException("Unrecognized parameter mapping field: '" + field + "' in " + token);
}
} else {
throw new SqlMapException("Incorrect inline parameter map format (missmatched name=value pairs): " + token);
}
}
if (mapping.getTypeHandler() == null) {
TypeHandler handler;
if (parameterClass == null) {
handler = typeHandlerFactory.getUnkownTypeHandler();
} else {
handler = resolveTypeHandler(typeHandlerFactory, parameterClass, mapping.getPropertyName(), mapping.getJavaTypeName(), mapping.getJdbcTypeName());
}
mapping.setTypeHandler(handler);
}
return mapping;
}
private ParameterMapping oldParseMapping(String token, Class parameterClass, TypeHandlerFactory typeHandlerFactory) {
ParameterMapping mapping = new ParameterMapping();
if (token.indexOf(PARAM_DELIM) > -1) {
StringTokenizer paramParser = new StringTokenizer(token, PARAM_DELIM, true);
int n1 = paramParser.countTokens();
if (n1 == 3) {
String name = paramParser.nextToken();
paramParser.nextToken(); //ignore ":"
String type = paramParser.nextToken();
mapping.setPropertyName(name);
mapping.setJdbcTypeName(type);
TypeHandler handler;
if (parameterClass == null) {
handler = typeHandlerFactory.getUnkownTypeHandler();
} else {
handler = resolveTypeHandler(typeHandlerFactory, parameterClass, name, null, type);
}
mapping.setTypeHandler(handler);
return mapping;
} else if (n1 >= 5) {
String name = paramParser.nextToken();
paramParser.nextToken(); //ignore ":"
String type = paramParser.nextToken();
paramParser.nextToken(); //ignore ":"
String nullValue = paramParser.nextToken();
while (paramParser.hasMoreTokens()) {
nullValue = nullValue + paramParser.nextToken();
}
mapping.setPropertyName(name);
mapping.setJdbcTypeName(type);
mapping.setNullValue(nullValue);
TypeHandler handler;
if (parameterClass == null) {
handler = typeHandlerFactory.getUnkownTypeHandler();
} else {
handler = resolveTypeHandler(typeHandlerFactory, parameterClass, name, null, type);
}
mapping.setTypeHandler(handler);
return mapping;
} else {
throw new SqlMapException("Incorrect inline parameter map format: " + token);
}
} else {
mapping.setPropertyName(token);
TypeHandler handler;
if (parameterClass == null) {
handler = typeHandlerFactory.getUnkownTypeHandler();
} else {
handler = resolveTypeHandler(typeHandlerFactory, parameterClass, token, null, null);
}
mapping.setTypeHandler(handler);
return mapping;
}
}
private TypeHandler resolveTypeHandler(TypeHandlerFactory typeHandlerFactory, Class clazz, String propertyName, String javaType, String jdbcType) {
TypeHandler handler = null;
if (clazz == null) {
// Unknown
handler = typeHandlerFactory.getUnkownTypeHandler();
} else if (DomTypeMarker.class.isAssignableFrom(clazz)) {
// DOM
handler = typeHandlerFactory.getTypeHandler(String.class, jdbcType);
} else if (java.util.Map.class.isAssignableFrom(clazz)) {
// Map
if (javaType == null) {
handler = typeHandlerFactory.getUnkownTypeHandler(); //BUG 1012591 - typeHandlerFactory.getTypeHandler(java.lang.Object.class, jdbcType);
} else {
try {
javaType = typeHandlerFactory.resolveAlias(javaType);
Class javaClass = Resources.classForName(javaType);
handler = typeHandlerFactory.getTypeHandler(javaClass, jdbcType);
} catch (Exception e) {
throw new SqlMapException("Error. Could not set TypeHandler. Cause: " + e, e);
}
}
} else if (typeHandlerFactory.getTypeHandler(clazz, jdbcType) != null) {
// Primitive
handler = typeHandlerFactory.getTypeHandler(clazz, jdbcType);
} else {
// JavaBean
if (javaType == null) {
Class type = PROBE.getPropertyTypeForGetter(clazz, propertyName);
handler = typeHandlerFactory.getTypeHandler(type, jdbcType);
} else {
try {
javaType = typeHandlerFactory.resolveAlias(javaType);
Class javaClass = Resources.classForName(javaType);
handler = typeHandlerFactory.getTypeHandler(javaClass, jdbcType);
} catch (Exception e) {
throw new SqlMapException("Error. Could not set TypeHandler. Cause: " + e, e);
}
}
}
return handler;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/parameter/NoParameterMap.java 0000644 0001750 0001750 00000002433 11047641640 027007 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.parameter;
import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
import com.ibatis.sqlmap.engine.scope.StatementScope;
public class NoParameterMap extends ParameterMap {
private static final ParameterMapping[] NO_PARAMETERS = new ParameterMapping[0];
private static final Object[] NO_DATA = new Object[0];
public NoParameterMap(SqlMapExecutorDelegate delegate) {
super(delegate);
}
public ParameterMapping[] getParameterMappings() {
return NO_PARAMETERS;
}
public Object[] getParameterObjectValues(StatementScope statementScope, Object parameterObject) {
return NO_DATA;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/parameter/ParameterMap.java 0000644 0001750 0001750 00000012673 11047641640 026521 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.parameter;
import com.ibatis.sqlmap.engine.cache.CacheKey;
import com.ibatis.sqlmap.engine.exchange.DataExchange;
import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
import com.ibatis.sqlmap.engine.scope.ErrorContext;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.type.CustomTypeHandler;
import com.ibatis.sqlmap.engine.type.JdbcTypeRegistry;
import com.ibatis.sqlmap.engine.type.TypeHandler;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Types;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ParameterMap {
private String id;
private Class parameterClass;
private ParameterMapping[] parameterMappings;
private DataExchange dataExchange;
private String resource;
private Map parameterMappingIndex = new HashMap();
private SqlMapExecutorDelegate delegate;
public ParameterMap(SqlMapExecutorDelegate delegate) {
this.delegate = delegate;
}
public SqlMapExecutorDelegate getDelegate() {
return delegate;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Class getParameterClass() {
return parameterClass;
}
public void setParameterClass(Class parameterClass) {
this.parameterClass = parameterClass;
}
public DataExchange getDataExchange() {
return dataExchange;
}
public void setDataExchange(DataExchange dataExchange) {
this.dataExchange = dataExchange;
}
public ParameterMapping[] getParameterMappings() {
return parameterMappings;
}
public void setParameterMappingList(List parameterMappingList) {
this.parameterMappings = (ParameterMapping[]) parameterMappingList.toArray(new ParameterMapping[parameterMappingList.size()]);
parameterMappingIndex.clear();
for (int i = 0; i < parameterMappings.length; i++) {
parameterMappingIndex.put(parameterMappings[i].getPropertyName(), new Integer(i));
}
Map props = new HashMap();
props.put("map", this);
dataExchange = delegate.getDataExchangeFactory().getDataExchangeForClass(parameterClass);
dataExchange.initialize(props);
}
public int getParameterIndex(String propertyName) {
Integer idx = null;
idx = (Integer) parameterMappingIndex.get(propertyName);
return idx == null ? -1 : idx.intValue();
}
public int getParameterCount() {
return this.parameterMappings.length;
}
/**
* @param ps
* @param parameters
* @throws java.sql.SQLException
*/
public void setParameters(StatementScope statementScope, PreparedStatement ps, Object[] parameters)
throws SQLException {
ErrorContext errorContext = statementScope.getErrorContext();
errorContext.setActivity("applying a parameter map");
errorContext.setObjectId(this.getId());
errorContext.setResource(this.getResource());
errorContext.setMoreInfo("Check the parameter map.");
if (parameterMappings != null) {
for (int i = 0; i < parameterMappings.length; i++) {
ParameterMapping mapping = parameterMappings[i];
errorContext.setMoreInfo(mapping.getErrorString());
if (mapping.isInputAllowed()) {
setParameter(ps, mapping, parameters, i);
}
}
}
}
public Object[] getParameterObjectValues(StatementScope statementScope, Object parameterObject) {
return dataExchange.getData(statementScope, this, parameterObject);
}
public CacheKey getCacheKey(StatementScope statementScope, Object parameterObject) {
return dataExchange.getCacheKey(statementScope, this, parameterObject);
}
public void refreshParameterObjectValues(StatementScope statementScope, Object parameterObject, Object[] values) {
dataExchange.setData(statementScope, this, parameterObject, values);
}
public String getResource() {
return resource;
}
public void setResource(String resource) {
this.resource = resource;
}
protected void setParameter(PreparedStatement ps, ParameterMapping mapping, Object[] parameters, int i) throws SQLException {
Object value = parameters[i];
// Apply Null Value
String nullValueString = mapping.getNullValue();
if (nullValueString != null) {
TypeHandler handler = mapping.getTypeHandler();
if (handler.equals(value, nullValueString)) {
value = null;
}
}
// Set Parameter
TypeHandler typeHandler = mapping.getTypeHandler();
if (value != null) {
typeHandler.setParameter(ps, i + 1, value, mapping.getJdbcTypeName());
} else if (typeHandler instanceof CustomTypeHandler) {
typeHandler.setParameter(ps, i + 1, value, mapping.getJdbcTypeName());
} else {
int jdbcType = mapping.getJdbcType();
if (jdbcType != JdbcTypeRegistry.UNKNOWN_TYPE) {
ps.setNull(i + 1, jdbcType);
} else {
ps.setNull(i + 1, Types.OTHER);
}
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/parameter/ParameterMapping.java 0000644 0001750 0001750 00000010355 11047641640 027372 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.parameter;
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapException;
import com.ibatis.sqlmap.engine.type.JdbcTypeRegistry;
import com.ibatis.sqlmap.engine.type.TypeHandler;
public class ParameterMapping {
private static final String MODE_INOUT = "INOUT";
private static final String MODE_OUT = "OUT";
private static final String MODE_IN = "IN";
private String propertyName;
private TypeHandler typeHandler;
private String typeName; // this is used for REF types or user-defined types
private int jdbcType;
private String jdbcTypeName;
private String nullValue;
private String mode;
private boolean inputAllowed;
private boolean outputAllowed;
private Class javaType;
private String resultMapName;
private Integer numericScale;
private String errorString;
public ParameterMapping() {
mode = "IN";
inputAllowed = true;
outputAllowed = false;
}
public String getNullValue() {
return nullValue;
}
public void setNullValue(String nullValue) {
this.nullValue = nullValue;
}
public String getPropertyName() {
return propertyName;
}
public void setPropertyName(String propertyName) {
this.errorString = "Check the parameter mapping for the '" + propertyName + "' property.";
this.propertyName = propertyName;
}
public String getErrorString() {
return errorString;
}
public TypeHandler getTypeHandler() {
return typeHandler;
}
public void setTypeHandler(TypeHandler typeHandler) {
this.typeHandler = typeHandler;
}
public Class getJavaType() {
return javaType;
}
public void setJavaType(Class javaType) {
this.javaType = javaType;
}
public String getJavaTypeName() {
if (javaType == null) {
return null;
} else {
return javaType.getName();
}
}
public void setJavaTypeName(String javaTypeName) {
try {
if (javaTypeName == null) {
this.javaType = null;
} else {
this.javaType = Resources.classForName(javaTypeName);
}
} catch (ClassNotFoundException e) {
throw new SqlMapException("Error setting javaType property of ParameterMap. Cause: " + e, e);
}
}
public int getJdbcType() {
return jdbcType;
}
public String getJdbcTypeName() {
return jdbcTypeName;
}
public void setJdbcTypeName(String jdbcTypeName) {
this.jdbcTypeName = jdbcTypeName;
this.jdbcType = JdbcTypeRegistry.getType(jdbcTypeName);
}
public String getMode() {
return mode;
}
public void setMode(String mode) {
this.mode = mode;
inputAllowed = MODE_IN.equals(mode) || MODE_INOUT.equals(mode);
outputAllowed = MODE_OUT.equals(mode) || MODE_INOUT.equals(mode);
}
public boolean isInputAllowed() {
return inputAllowed;
}
public boolean isOutputAllowed() {
return outputAllowed;
}
/**
* user-defined or REF types
*
* @return typeName
*/
public String getTypeName() {
return typeName;
}
/**
* for user-defined or REF types
* @param typeName
*/
public void setTypeName(String typeName) {
this.typeName = typeName;
}
public String getResultMapName() {
return resultMapName;
}
public void setResultMapName(String resultMapName) {
this.resultMapName = resultMapName;
}
public Integer getNumericScale() {
return numericScale;
}
public void setNumericScale(Integer numericScale) {
if (numericScale != null && numericScale.intValue() < 0) {
throw new RuntimeException("Error setting numericScale on parameter mapping. Cause: scale must be greater than or equal to zero");
}
this.numericScale = numericScale;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/result/ 0000755 0001750 0001750 00000000000 11047641640 022625 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/mapping/result/loader/ 0000755 0001750 0001750 00000000000 11047641640 024073 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/mapping/result/loader/EnhancedLazyResultLoader.java 0000644 0001750 0001750 00000011725 11047641640 031637 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.result.loader;
import com.ibatis.common.beans.ClassInfo;
import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl;
import com.ibatis.sqlmap.engine.type.DomTypeMarker;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.SQLException;
import java.util.Collection;
import java.util.List;
import java.util.Set;
/**
* Class to lazily load results into objects (uses CGLib to improve performance)
*/
public class EnhancedLazyResultLoader {
private static final Class[] SET_INTERFACES = new Class[]{Set.class};
private static final Class[] LIST_INTERFACES = new Class[]{List.class};
private Object loader;
/**
* Constructor for an enhanced lazy list loader
*
* @param client - the client that is creating the lazy list
* @param statementName - the statement to be used to build the list
* @param parameterObject - the parameter object to be used to build the list
* @param targetType - the type we are putting data into
*/
public EnhancedLazyResultLoader(SqlMapClientImpl client, String statementName, Object parameterObject, Class targetType) {
loader = new EnhancedLazyResultLoaderImpl(client, statementName, parameterObject, targetType);
}
/**
* Loads the result
*
* @return the results - a list or object
*
* @throws SQLException if there is a problem
*/
public Object loadResult() throws SQLException {
return ((EnhancedLazyResultLoaderImpl) loader).loadResult();
}
private static class EnhancedLazyResultLoaderImpl implements InvocationHandler {
protected SqlMapClientImpl client;
protected String statementName;
protected Object parameterObject;
protected Class targetType;
protected boolean loaded;
protected Object resultObject;
/**
* Constructor for an enhanced lazy list loader implementation
*
* @param client - the client that is creating the lazy list
* @param statementName - the statement to be used to build the list
* @param parameterObject - the parameter object to be used to build the list
* @param targetType - the type we are putting data into
*/
public EnhancedLazyResultLoaderImpl(SqlMapClientImpl client, String statementName, Object parameterObject, Class targetType) {
this.client = client;
this.statementName = statementName;
this.parameterObject = parameterObject;
this.targetType = targetType;
}
/**
* Loads the result
*
* @return the results - a list or object
*
* @throws SQLException if there is a problem
*/
public Object loadResult() throws SQLException {
if (DomTypeMarker.class.isAssignableFrom(targetType)) {
return ResultLoader.getResult(client, statementName, parameterObject, targetType);
} else if (Collection.class.isAssignableFrom(targetType)) {
if (Set.class.isAssignableFrom(targetType)) {
return Enhancer.create(Object.class, SET_INTERFACES, this);
} else {
return Enhancer.create(Object.class, LIST_INTERFACES, this);
}
} else if (targetType.isArray() || ClassInfo.isKnownType(targetType)) {
return ResultLoader.getResult(client, statementName, parameterObject, targetType);
} else {
return Enhancer.create(targetType, this);
}
}
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
if ("finalize".hashCode() == method.getName().hashCode()
&& "finalize".equals(method.getName())) {
return null;
} else {
loadObject();
if (resultObject != null) {
try {
return method.invoke(resultObject, objects);
} catch (Throwable t) {
throw ClassInfo.unwrapThrowable(t);
}
} else {
return null;
}
}
}
private synchronized void loadObject() {
if (!loaded) {
try {
loaded = true;
resultObject = ResultLoader.getResult(client, statementName, parameterObject, targetType);
} catch (SQLException e) {
throw new RuntimeException("Error lazy loading result. Cause: " + e, e);
}
}
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/result/loader/LazyResultLoader.java 0000644 0001750 0001750 00000007163 11047641640 030212 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.result.loader;
import com.ibatis.common.beans.ClassInfo;
import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.SQLException;
import java.util.Collection;
import java.util.List;
import java.util.Set;
/**
* Class to lazily load results into objects
*/
public class LazyResultLoader implements InvocationHandler {
private static final Class[] SET_INTERFACES = new Class[]{Set.class};
private static final Class[] LIST_INTERFACES = new Class[]{List.class};
protected SqlMapClientImpl client;
protected String statementName;
protected Object parameterObject;
protected Class targetType;
protected boolean loaded;
protected Object resultObject;
/**
* Constructor for a lazy list loader
*
* @param client - the client that is creating the lazy list
* @param statementName - the statement to be used to build the list
* @param parameterObject - the parameter object to be used to build the list
* @param targetType - the type we are putting data into
*/
public LazyResultLoader(SqlMapClientImpl client, String statementName, Object parameterObject, Class targetType) {
this.client = client;
this.statementName = statementName;
this.parameterObject = parameterObject;
this.targetType = targetType;
}
/**
* Loads the result
*
* @return the results - a list or object
*
* @throws SQLException if there is a problem
*/
public Object loadResult() throws SQLException {
if (Collection.class.isAssignableFrom(targetType)) {
InvocationHandler handler = new LazyResultLoader(client, statementName, parameterObject, targetType);
ClassLoader cl = targetType.getClassLoader();
if (Set.class.isAssignableFrom(targetType)) {
return Proxy.newProxyInstance(cl, SET_INTERFACES, handler);
} else {
return Proxy.newProxyInstance(cl, LIST_INTERFACES, handler);
}
} else {
return ResultLoader.getResult(client, statementName, parameterObject, targetType);
}
}
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
if ("finalize".hashCode() == method.getName().hashCode()
&& "finalize".equals(method.getName())) {
return null;
} else {
loadObject();
if (resultObject != null) {
try {
return method.invoke(resultObject, objects);
} catch (Throwable t) {
throw ClassInfo.unwrapThrowable(t);
}
} else {
return null;
}
}
}
private synchronized void loadObject() {
if (!loaded) {
try {
loaded = true;
resultObject = ResultLoader.getResult(client, statementName, parameterObject, targetType);
} catch (SQLException e) {
throw new RuntimeException("Error lazy loading result. Cause: " + e, e);
}
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/result/loader/ResultLoader.java 0000644 0001750 0001750 00000006474 11047641640 027356 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.result.loader;
import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl;
import com.ibatis.sqlmap.engine.type.DomCollectionTypeMarker;
import java.sql.SQLException;
import java.util.*;
import java.lang.reflect.Array;
/**
* Class to load results into objects
*/
public class ResultLoader {
private ResultLoader() {
}
/**
* Loads a result lazily
*
* @param client - the client creating the object
* @param statementName - the name of the statement to be used
* @param parameterObject - the parameters for the statement
* @param targetType - the target type of the result
* @return the loaded result
* @throws SQLException
*/
public static Object loadResult(SqlMapClientImpl client, String statementName, Object parameterObject, Class targetType)
throws SQLException {
Object value = null;
if (client.isLazyLoadingEnabled()) {
if (client.isEnhancementEnabled()) {
EnhancedLazyResultLoader lazy = new EnhancedLazyResultLoader(client, statementName, parameterObject, targetType);
value = lazy.loadResult();
} else {
LazyResultLoader lazy = new LazyResultLoader(client, statementName, parameterObject, targetType);
value = lazy.loadResult();
}
} else {
value = getResult(client, statementName, parameterObject, targetType);
}
return value;
}
protected static Object getResult(SqlMapClientImpl client, String statementName, Object parameterObject, Class targetType) throws SQLException {
Object value = null;
if (DomCollectionTypeMarker.class.isAssignableFrom(targetType)) {
value = client.queryForList(statementName, parameterObject);
} else if (Set.class.isAssignableFrom(targetType)) {
value = new HashSet(client.queryForList(statementName, parameterObject));
} else if (Collection.class.isAssignableFrom(targetType)) {
value = client.queryForList(statementName, parameterObject);
} else if (targetType.isArray()) {
List list = client.queryForList(statementName, parameterObject);
value = listToArray(list, targetType.getComponentType());
} else {
value = client.queryForObject(statementName, parameterObject);
}
return value;
}
private static Object listToArray(List list, Class type) {
Object array = java.lang.reflect.Array.newInstance(type, list.size());
if (type.isPrimitive()) {
Iterator iter = list.iterator();
int index = 0;
while (iter.hasNext()) {
Array.set(array, index++, iter.next());
}
} else {
array = list.toArray((Object[]) array);
}
return array;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/result/AutoResultMap.java 0000644 0001750 0001750 00000016014 11061034570 026231 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.result;
import com.ibatis.common.beans.*;
import com.ibatis.sqlmap.client.SqlMapException;
import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.type.DomTypeMarker;
import java.sql.*;
import java.util.*;
/**
* An automatic result map for simple stuff
*/
public class AutoResultMap extends ResultMap {
/**
* Constructor to pass in the SqlMapExecutorDelegate
*
* @param delegate - the delegate
*/
public AutoResultMap(SqlMapExecutorDelegate delegate, boolean allowRemapping) {
super(delegate);
this.allowRemapping = allowRemapping;
}
public synchronized Object[] getResults(StatementScope statementScope, ResultSet rs)
throws SQLException {
if (allowRemapping || getResultMappings() == null) {
initialize(rs);
}
return super.getResults(statementScope, rs);
}
public Object setResultObjectValues(StatementScope statementScope, Object resultObject, Object[] values) {
// synchronization is only needed when remapping is enabled
if (allowRemapping) {
synchronized (this) {
return super.setResultObjectValues(statementScope, resultObject, values);
}
}
return super.setResultObjectValues(statementScope, resultObject, values);
}
private void initialize(ResultSet rs) {
if (getResultClass() == null) {
throw new SqlMapException("The automatic ResultMap named " + this.getId() + " had a null result class (not allowed).");
} else if (Map.class.isAssignableFrom(getResultClass())) {
initializeMapResults(rs);
} else if (getDelegate().getTypeHandlerFactory().getTypeHandler(getResultClass()) != null) {
initializePrimitiveResults(rs);
} else if (DomTypeMarker.class.isAssignableFrom(getResultClass())) {
initializeXmlResults(rs);
} else {
initializeBeanResults(rs);
}
}
private void initializeBeanResults(ResultSet rs) {
try {
ClassInfo classInfo = ClassInfo.getInstance(getResultClass());
String[] propertyNames = classInfo.getWriteablePropertyNames();
Map propertyMap = new HashMap();
for (int i = 0; i < propertyNames.length; i++) {
propertyMap.put(propertyNames[i].toUpperCase(java.util.Locale.ENGLISH), propertyNames[i]);
}
List resultMappingList = new ArrayList();
ResultSetMetaData rsmd = rs.getMetaData();
for (int i = 0, n = rsmd.getColumnCount(); i < n; i++) {
String columnName = getColumnIdentifier(rsmd, i + 1);
String upperColumnName = columnName.toUpperCase(java.util.Locale.ENGLISH);
String matchedProp = (String) propertyMap.get(upperColumnName);
Class type = null;
if (matchedProp == null) {
Probe p = ProbeFactory.getProbe(this.getResultClass());
try {
type = p.getPropertyTypeForSetter(this.getResultClass(), columnName);
} catch (Exception e) {
//TODO - add logging to this class?
}
} else {
type = classInfo.getSetterType(matchedProp);
}
if (type != null || matchedProp != null) {
ResultMapping resultMapping = new ResultMapping();
resultMapping.setPropertyName((matchedProp != null ? matchedProp : columnName));
resultMapping.setColumnName(columnName);
resultMapping.setColumnIndex(i + 1);
resultMapping.setTypeHandler(getDelegate().getTypeHandlerFactory().getTypeHandler(type)); //map SQL to JDBC type
resultMappingList.add(resultMapping);
}
}
setResultMappingList(resultMappingList);
} catch (SQLException e) {
throw new RuntimeException("Error automapping columns. Cause: " + e);
}
}
private void initializeXmlResults(ResultSet rs) {
try {
List resultMappingList = new ArrayList();
ResultSetMetaData rsmd = rs.getMetaData();
for (int i = 0, n = rsmd.getColumnCount(); i < n; i++) {
String columnName = getColumnIdentifier(rsmd, i + 1);
ResultMapping resultMapping = new ResultMapping();
resultMapping.setPropertyName(columnName);
resultMapping.setColumnName(columnName);
resultMapping.setColumnIndex(i + 1);
resultMapping.setTypeHandler(getDelegate().getTypeHandlerFactory().getTypeHandler(String.class));
resultMappingList.add(resultMapping);
}
setResultMappingList(resultMappingList);
} catch (SQLException e) {
throw new RuntimeException("Error automapping columns. Cause: " + e);
}
}
private void initializeMapResults(ResultSet rs) {
try {
List resultMappingList = new ArrayList();
ResultSetMetaData rsmd = rs.getMetaData();
for (int i = 0, n = rsmd.getColumnCount(); i < n; i++) {
String columnName = getColumnIdentifier(rsmd, i + 1);
ResultMapping resultMapping = new ResultMapping();
resultMapping.setPropertyName(columnName);
resultMapping.setColumnName(columnName);
resultMapping.setColumnIndex(i + 1);
resultMapping.setTypeHandler(getDelegate().getTypeHandlerFactory().getTypeHandler(Object.class));
resultMappingList.add(resultMapping);
}
setResultMappingList(resultMappingList);
} catch (SQLException e) {
throw new RuntimeException("Error automapping columns. Cause: " + e);
}
}
private void initializePrimitiveResults(ResultSet rs) {
try {
ResultSetMetaData rsmd = rs.getMetaData();
String columnName = getColumnIdentifier(rsmd, 1);
ResultMapping resultMapping = new ResultMapping();
resultMapping.setPropertyName(columnName);
resultMapping.setColumnName(columnName);
resultMapping.setColumnIndex(1);
resultMapping.setTypeHandler(getDelegate().getTypeHandlerFactory().getTypeHandler(getResultClass()));
List resultMappingList = new ArrayList();
resultMappingList.add(resultMapping);
setResultMappingList(resultMappingList);
} catch (SQLException e) {
throw new RuntimeException("Error automapping columns. Cause: " + e);
}
}
private String getColumnIdentifier(ResultSetMetaData rsmd, int i) throws SQLException {
if (delegate.isUseColumnLabel()) {
return rsmd.getColumnLabel(i);
} else {
return rsmd.getColumnName(i);
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/result/Discriminator.java 0000644 0001750 0001750 00000002745 11047641640 026307 0 ustar twerner twerner package com.ibatis.sqlmap.engine.mapping.result;
import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
/**
* Created by IntelliJ IDEA.
* User: cbegin
* Date: May 13, 2005
* Time: 11:11:05 PM
* To change this template use File | Settings | File Templates.
*/
public class Discriminator {
private SqlMapExecutorDelegate delegate;
private ResultMapping resultMapping;
private Map subMaps;
public Discriminator(SqlMapExecutorDelegate delegate, ResultMapping resultMapping) {
this.delegate = delegate;
this.resultMapping = resultMapping;
}
public void setResultMapping(ResultMapping resultMapping) {
this.resultMapping = resultMapping;
}
public ResultMapping getResultMapping() {
return resultMapping;
}
public void addSubMap(String discriminatorValue, String resultMapName) {
if (subMaps == null) {
subMaps = new HashMap();
}
subMaps.put(discriminatorValue, resultMapName);
}
public ResultMap getSubMap(String s) {
return (ResultMap) subMaps.get(s);
}
public void bindSubMaps() {
if (subMaps != null) {
Iterator keys = subMaps.keySet().iterator();
while (keys.hasNext()) {
Object key = keys.next();
Object id = subMaps.get(key);
if(id instanceof String) {
subMaps.put(key, delegate.getResultMap((String)id));
}
}
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/result/ResultMap.java 0000644 0001750 0001750 00000055552 11061034012 025401 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.result;
import com.ibatis.common.beans.Probe;
import com.ibatis.common.beans.ProbeFactory;
import com.ibatis.common.jdbc.exception.NestedSQLException;
import com.ibatis.sqlmap.client.SqlMapException;
import com.ibatis.sqlmap.engine.exchange.DataExchange;
import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl;
import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
import com.ibatis.sqlmap.engine.mapping.result.loader.ResultLoader;
import com.ibatis.sqlmap.engine.mapping.sql.Sql;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import com.ibatis.sqlmap.engine.scope.ErrorContext;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.type.DomCollectionTypeMarker;
import com.ibatis.sqlmap.engine.type.DomTypeMarker;
import com.ibatis.sqlmap.engine.type.TypeHandler;
import com.ibatis.sqlmap.engine.type.TypeHandlerFactory;
import org.w3c.dom.Document;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
/**
* Basic implementation of ResultMap interface
*/
public class ResultMap {
private static final Probe PROBE = ProbeFactory.getProbe();
private static final String KEY_SEPARATOR = "\002";
private String id;
private Class resultClass;
// DO NOT ACCESS EITHER OF THESE OUTSIDE OF THEIR BEAN GETTER/SETTER
private ResultMapping[] resultMappings;
private ThreadLocal remappableResultMappings = new ThreadLocal();
private DataExchange dataExchange;
private List nestedResultMappings;
private Discriminator discriminator;
private Set groupByProps;
private String xmlName;
private String resource;
protected SqlMapExecutorDelegate delegate;
protected boolean allowRemapping = false;
public static final Object NO_VALUE = new Object();
/**
* Constructor to pass a SqlMapExecutorDelegate in
*
* @param delegate - the SqlMapExecutorDelegate
*/
public ResultMap(SqlMapExecutorDelegate delegate) {
this.delegate = delegate;
}
/**
* Getter for the SqlMapExecutorDelegate
*
* @return - the delegate
*/
public SqlMapExecutorDelegate getDelegate() {
return delegate;
}
public String getId() {
return id;
}
/**
* Setter for the ID
*
* @param id - the new ID
*/
public void setId(String id) {
this.id = id;
}
public Class getResultClass() {
return resultClass;
}
public Object getUniqueKey(String keyPrefix, Object[] values) {
if (groupByProps != null) {
StringBuffer keyBuffer;
if ( keyPrefix != null ) keyBuffer = new StringBuffer(keyPrefix);
else keyBuffer = new StringBuffer();
for (int i = 0; i < getResultMappings().length; i++) {
String propertyName = getResultMappings()[i].getPropertyName();
if (groupByProps.contains(propertyName)) {
keyBuffer.append(values[i]);
keyBuffer.append('-');
}
}
if (keyBuffer.length() < 1) {
return null;
} else {
// seperator value not likely to appear in a database
keyBuffer.append(KEY_SEPARATOR);
return keyBuffer.toString();
}
} else {
return null;
}
}
public Object getUniqueKey(Object[] values) {
return getUniqueKey(null, values);
}
/**
* Setter for the result class (what the results will be mapped into)
*
* @param resultClass - the result class
*/
public void setResultClass(Class resultClass) {
this.resultClass = resultClass;
}
/**
* Getter for the DataExchange object to be used
*
* @return - the DataExchange object
*/
public DataExchange getDataExchange() {
return dataExchange;
}
/**
* Setter for the DataExchange object to be used
*
* @param dataExchange - the new DataExchange object
*/
public void setDataExchange(DataExchange dataExchange) {
this.dataExchange = dataExchange;
}
/**
* Getter (used by DomDataExchange) for the xml name of the results
*
* @return - the name
*/
public String getXmlName() {
return xmlName;
}
/**
* Setter (used by the SqlMapBuilder) for the xml name of the results
*
* @param xmlName - the name
*/
public void setXmlName(String xmlName) {
this.xmlName = xmlName;
}
/**
* Getter for the resource (used to report errors)
*
* @return - the resource
*/
public String getResource() {
return resource;
}
/**
* Setter for the resource (used by the SqlMapBuilder)
*
* @param resource - the resource name
*/
public void setResource(String resource) {
this.resource = resource;
}
public void addGroupByProperty(String name) {
if (groupByProps == null) {
groupByProps = new HashSet();
}
groupByProps.add(name);
}
public boolean hasGroupBy() {
return groupByProps != null && groupByProps.size() > 0;
}
public Iterator groupByProps() {
return groupByProps.iterator();
}
public void addNestedResultMappings(ResultMapping mapping) {
if (nestedResultMappings == null) {
nestedResultMappings = new ArrayList();
}
nestedResultMappings.add(mapping);
}
public List getNestedResultMappings() {
return nestedResultMappings;
}
public ResultMapping[] getResultMappings() {
if (allowRemapping) {
return (ResultMapping[]) remappableResultMappings.get();
} else {
return resultMappings;
}
}
public void setDiscriminator (Discriminator discriminator) {
if (this.discriminator != null) {
throw new SqlMapException ("A discriminator may only be set once per result map.");
}
this.discriminator = discriminator;
}
public Discriminator getDiscriminator() {
return discriminator;
}
public ResultMap resolveSubMap (StatementScope statementScope, ResultSet rs) throws SQLException {
ResultMap subMap = this;
if (discriminator != null) {
ResultMapping mapping = (ResultMapping)discriminator.getResultMapping();
Object value = getPrimitiveResultMappingValue(rs, mapping);
if (value == null) {
value = doNullMapping(value, mapping);
}
subMap = discriminator.getSubMap(String.valueOf(value));
if (subMap == null) {
subMap = this;
} else if (subMap != this) {
subMap = subMap.resolveSubMap(statementScope, rs);
}
}
return subMap;
}
/**
* Setter for a list of the individual ResultMapping objects
*
* @param resultMappingList - the list
*/
public void setResultMappingList(List resultMappingList) {
if (allowRemapping) {
this.remappableResultMappings.set((ResultMapping[]) resultMappingList.toArray(new ResultMapping[resultMappingList.size()]));
} else {
this.resultMappings = (ResultMapping[]) resultMappingList.toArray(new ResultMapping[resultMappingList.size()]);
}
Map props = new HashMap();
props.put("map", this);
dataExchange = getDelegate().getDataExchangeFactory().getDataExchangeForClass(resultClass);
dataExchange.initialize(props);
}
/**
* Getter for the number of ResultMapping objects
*
* @return - the count
*/
public int getResultCount() {
return this.getResultMappings().length;
}
/**
* Read a row from a resultset and map results to an array.
*
* @param statementScope scope of the request
* @param rs ResultSet to read from
*
* @return row read as an array of column values.
*
* @throws java.sql.SQLException
*/
public Object[] getResults(StatementScope statementScope, ResultSet rs)
throws SQLException {
ErrorContext errorContext = statementScope.getErrorContext();
errorContext.setActivity("applying a result map");
errorContext.setObjectId(this.getId());
errorContext.setResource(this.getResource());
errorContext.setMoreInfo("Check the result map.");
boolean foundData = false;
Object[] columnValues = new Object[getResultMappings().length];
for (int i = 0; i < getResultMappings().length; i++) {
ResultMapping mapping = (ResultMapping) getResultMappings()[i];
errorContext.setMoreInfo(mapping.getErrorString());
if (mapping.getStatementName() != null) {
if (resultClass == null) {
throw new SqlMapException("The result class was null when trying to get results for ResultMap named " + getId() + ".");
} else if (Map.class.isAssignableFrom(resultClass)) {
Class javaType = mapping.getJavaType();
if (javaType == null) {
javaType = Object.class;
}
columnValues[i] = getNestedSelectMappingValue(statementScope, rs, mapping, javaType);
} else if (DomTypeMarker.class.isAssignableFrom(resultClass)) {
Class javaType = mapping.getJavaType();
if (javaType == null) {
javaType = DomTypeMarker.class;
}
columnValues[i] = getNestedSelectMappingValue(statementScope, rs, mapping, javaType);
} else {
Probe p = ProbeFactory.getProbe(resultClass);
Class type = p.getPropertyTypeForSetter(resultClass, mapping.getPropertyName());
columnValues[i] = getNestedSelectMappingValue(statementScope, rs, mapping, type);
}
foundData = foundData || columnValues[i] != null;
} else if (mapping.getNestedResultMapName() == null) {
columnValues[i] = getPrimitiveResultMappingValue(rs, mapping);
if (columnValues[i] == null) {
columnValues[i] = doNullMapping(columnValues[i], mapping);
} else {
foundData = true;
}
}
}
statementScope.setRowDataFound(foundData);
return columnValues;
}
public Object setResultObjectValues(StatementScope statementScope, Object resultObject, Object[] values) {
final String previousNestedKey = statementScope.getCurrentNestedKey();
String ukey = (String)getUniqueKey(statementScope.getCurrentNestedKey(), values);
Map uniqueKeys = statementScope.getUniqueKeys(this);
statementScope.setCurrentNestedKey(ukey);
if (uniqueKeys != null && uniqueKeys.containsKey(ukey)) {
// Unique key is already known, so get the existing result object and process additional results.
resultObject = uniqueKeys.get(ukey);
applyNestedResultMap(statementScope, resultObject, values);
resultObject = NO_VALUE;
} else if (ukey == null || uniqueKeys == null || !uniqueKeys.containsKey(ukey)) {
// Unique key is NOT known, so create a new result object and then process additional results.
resultObject = dataExchange.setData(statementScope, this, resultObject, values);
// Lazy init key set, only if we're grouped by something (i.e. ukey != null)
if (ukey != null) {
if (uniqueKeys == null) {
uniqueKeys = new HashMap();
statementScope.setUniqueKeys(this, uniqueKeys);
}
uniqueKeys.put(ukey, resultObject);
}
applyNestedResultMap(statementScope, resultObject, values);
} else {
// Otherwise, we don't care about these results.
resultObject = NO_VALUE;
}
statementScope.setCurrentNestedKey(previousNestedKey);
return resultObject;
}
private void applyNestedResultMap(StatementScope statementScope, Object resultObject, Object[] values) {
if (resultObject != null && resultObject != NO_VALUE) {
if (nestedResultMappings != null) {
for (int i = 0, n = nestedResultMappings.size(); i < n; i++) {
ResultMapping resultMapping = (ResultMapping) nestedResultMappings.get(i);
setNestedResultMappingValue(resultMapping, statementScope, resultObject, values);
}
}
}
}
/**
* Some changes in this method for IBATIS-225:
*
* - We no longer require the nested property to be a collection. This
* will allow reuses of resultMaps on 1:1 relationships
* - If the nested property is not a collection, then it will be
* created/replaced by the values generated from the current row.
*
*
* @param mapping
* @param statementScope
* @param resultObject
* @param values
*/
protected void setNestedResultMappingValue(ResultMapping mapping, StatementScope statementScope, Object resultObject, Object[] values) {
try {
String resultMapName = mapping.getNestedResultMapName();
ResultMap resultMap = getDelegate().getResultMap(resultMapName);
// get the discriminated submap if it exists
resultMap = resultMap.resolveSubMap(statementScope, statementScope.getResultSet());
Class type = mapping.getJavaType();
String propertyName = mapping.getPropertyName();
Object obj = PROBE.getObject(resultObject, propertyName);
if (obj == null) {
if (type == null) {
type = PROBE.getPropertyTypeForSetter(resultObject, propertyName);
}
try {
// create the object if is it a Collection. If not a Collection
// then we will just set the property to the object created
// in processing the nested result map
if (Collection.class.isAssignableFrom(type)) {
obj = ResultObjectFactoryUtil.createObjectThroughFactory(type);
PROBE.setObject(resultObject, propertyName, obj);
}
} catch (Exception e) {
throw new SqlMapException("Error instantiating collection property for mapping '" + mapping.getPropertyName() + "'. Cause: " + e, e);
}
}
//JIRA 375 "Provide a way for not creating items from nested ResultMaps when the items contain only null values"
boolean subResultObjectAbsent = false;
if(mapping.getNotNullColumn() != null) {
if(statementScope.getResultSet().getObject(mapping.getNotNullColumn()) == null) {
subResultObjectAbsent = true;
}
}
if(!subResultObjectAbsent) {
values = resultMap.getResults(statementScope, statementScope.getResultSet());
if (statementScope.isRowDataFound()) {
Object o = resultMap.setResultObjectValues(statementScope, null, values);
if (o != NO_VALUE) {
if (obj != null && obj instanceof Collection) {
((Collection) obj).add(o);
} else {
PROBE.setObject(resultObject, propertyName, o);
}
}
}
}
} catch (SQLException e) {
throw new SqlMapException("Error getting nested result map values for '" + mapping.getPropertyName() + "'. Cause: " + e, e);
}
}
protected Object getNestedSelectMappingValue(StatementScope statementScope, ResultSet rs, ResultMapping mapping, Class targetType)
throws SQLException {
try {
TypeHandlerFactory typeHandlerFactory = getDelegate().getTypeHandlerFactory();
String statementName = mapping.getStatementName();
SqlMapClientImpl client = (SqlMapClientImpl) statementScope.getSession().getSqlMapClient();
MappedStatement mappedStatement = client.getMappedStatement(statementName);
Class parameterType = mappedStatement.getParameterClass();
Object parameterObject = null;
if (parameterType == null) {
parameterObject = prepareBeanParameterObject(statementScope, rs, mapping, parameterType);
} else {
if (typeHandlerFactory.hasTypeHandler(parameterType)) {
parameterObject = preparePrimitiveParameterObject(rs, mapping, parameterType);
} else if (DomTypeMarker.class.isAssignableFrom(parameterType)) {
parameterObject = prepareDomParameterObject(rs, mapping);
} else {
parameterObject = prepareBeanParameterObject(statementScope, rs, mapping, parameterType);
}
}
Object result = null;
if (parameterObject != null) {
Sql sql = mappedStatement.getSql();
ResultMap resultMap = sql.getResultMap(statementScope, parameterObject);
Class resultClass = resultMap.getResultClass();
if (resultClass != null && !DomTypeMarker.class.isAssignableFrom(targetType)) {
if (DomCollectionTypeMarker.class.isAssignableFrom(resultClass)) {
targetType = DomCollectionTypeMarker.class;
} else if (DomTypeMarker.class.isAssignableFrom(resultClass)) {
targetType = DomTypeMarker.class;
}
}
result = ResultLoader.loadResult(client, statementName, parameterObject, targetType);
String nullValue = mapping.getNullValue();
if (result == null && nullValue != null) {
TypeHandler typeHandler = typeHandlerFactory.getTypeHandler(targetType);
if (typeHandler != null) {
result = typeHandler.valueOf(nullValue);
}
}
}
return result;
} catch (InstantiationException e) {
throw new NestedSQLException("Error setting nested bean property. Cause: " + e, e);
} catch (IllegalAccessException e) {
throw new NestedSQLException("Error setting nested bean property. Cause: " + e, e);
}
}
private Object preparePrimitiveParameterObject(ResultSet rs, ResultMapping mapping, Class parameterType) throws SQLException {
Object parameterObject;
TypeHandlerFactory typeHandlerFactory = getDelegate().getTypeHandlerFactory();
TypeHandler th = typeHandlerFactory.getTypeHandler(parameterType);
parameterObject = th.getResult(rs, mapping.getColumnName());
return parameterObject;
}
private Document newDocument(String root) {
try {
Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
doc.appendChild(doc.createElement(root));
return doc;
} catch (ParserConfigurationException e) {
throw new RuntimeException("Error creating XML document. Cause: " + e);
}
}
private Object prepareDomParameterObject(ResultSet rs, ResultMapping mapping) throws SQLException {
TypeHandlerFactory typeHandlerFactory = getDelegate().getTypeHandlerFactory();
Document doc = newDocument("parameter");
Probe probe = ProbeFactory.getProbe(doc);
String complexName = mapping.getColumnName();
TypeHandler stringTypeHandler = typeHandlerFactory.getTypeHandler(String.class);
if (complexName.indexOf('=') > -1) {
// old 1.x style multiple params
StringTokenizer parser = new StringTokenizer(complexName, "{}=, ", false);
while (parser.hasMoreTokens()) {
String propName = parser.nextToken();
String colName = parser.nextToken();
Object propValue = stringTypeHandler.getResult(rs, colName);
probe.setObject(doc, propName, propValue.toString());
}
} else {
// single param
Object propValue = stringTypeHandler.getResult(rs, complexName);
probe.setObject(doc, "value", propValue.toString());
}
return doc;
}
private Object prepareBeanParameterObject(StatementScope statementScope, ResultSet rs, ResultMapping mapping, Class parameterType)
throws InstantiationException, IllegalAccessException, SQLException {
TypeHandlerFactory typeHandlerFactory = getDelegate().getTypeHandlerFactory();
Object parameterObject;
if (parameterType == null) {
parameterObject = new HashMap();
} else {
parameterObject = ResultObjectFactoryUtil.createObjectThroughFactory(parameterType);
}
String complexName = mapping.getColumnName();
if (complexName.indexOf('=') > -1
|| complexName.indexOf(',') > -1) {
StringTokenizer parser = new StringTokenizer(complexName, "{}=, ", false);
while (parser.hasMoreTokens()) {
String propName = parser.nextToken();
String colName = parser.nextToken();
Class propType = PROBE.getPropertyTypeForSetter(parameterObject, propName);
TypeHandler propTypeHandler = typeHandlerFactory.getTypeHandler(propType);
Object propValue = propTypeHandler.getResult(rs, colName);
PROBE.setObject(parameterObject, propName, propValue);
}
} else {
// single param
TypeHandler propTypeHandler = typeHandlerFactory.getTypeHandler(parameterType);
if (propTypeHandler == null) {
propTypeHandler = typeHandlerFactory.getUnkownTypeHandler();
}
parameterObject = propTypeHandler.getResult(rs, complexName);
}
return parameterObject;
}
protected Object getPrimitiveResultMappingValue(ResultSet rs, ResultMapping mapping) throws SQLException {
Object value = null;
TypeHandler typeHandler = mapping.getTypeHandler();
if (typeHandler != null) {
String columnName = mapping.getColumnName();
int columnIndex = mapping.getColumnIndex();
if (columnName == null) {
value = typeHandler.getResult(rs, columnIndex);
} else {
value = typeHandler.getResult(rs, columnName);
}
} else {
throw new SqlMapException("No type handler could be found to map the property '" + mapping.getPropertyName() + "' to the column '" + mapping.getColumnName() + "'. One or both of the types, or the combination of types is not supported.");
}
return value;
}
protected Object doNullMapping(Object value, ResultMapping mapping) throws SqlMapException {
if ( value == null ) {
TypeHandler typeHandler = mapping.getTypeHandler();
if (typeHandler != null) {
String nullValue = mapping.getNullValue();
if ( nullValue != null )
value = typeHandler.valueOf(nullValue);
return value;
} else {
throw new SqlMapException("No type handler could be found to map the property '" + mapping.getPropertyName() + "' to the column '" + mapping.getColumnName() + "'. One or both of the types, or the combination of types is not supported.");
}
}
else {
return value;
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/result/ResultMapping.java 0000644 0001750 0001750 00000012245 11047641640 026266 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.result;
import com.ibatis.sqlmap.engine.type.JdbcTypeRegistry;
import com.ibatis.sqlmap.engine.type.TypeHandler;
/**
* Basic implementation of ResultMapping
*/
public class ResultMapping {
private String propertyName;
private String columnName;
private int columnIndex;
private TypeHandler typeHandler;
private int jdbcType;
private String jdbcTypeName;
private String nullValue;
private String notNullColumn;
private String statementName;
private Class javaType;
private String nestedResultMapName;
private String errorString;
public String getPropertyName() {
return propertyName;
}
/**
* Setter for the object property name (used by the automap, and the builder)
*
* @param propertyName - the property name
*/
public void setPropertyName(String propertyName) {
this.errorString = "Check the result mapping for the '" + propertyName + "' property.";
this.propertyName = propertyName;
}
/**
* Getter for the error message when something goes wrong mapping this property
*
* @return - the error message
*/
public String getErrorString() {
return errorString;
}
/**
* Getter for the column name that we are mapping
*
* @return - the column name
*/
public String getColumnName() {
return columnName;
}
/**
* Setter for the column name we are mapping (used by the automap or builder)
*
* @param columnName - the column name
*/
public void setColumnName(String columnName) {
this.columnName = columnName;
}
/**
* Getter for the column index that we are mapping
*
* @return - the column index
*/
public int getColumnIndex() {
return columnIndex;
}
/**
* Setter for the column index we are mapping (used by the automap or builder)
*
* @param columnIndex - the column index
*/
public void setColumnIndex(int columnIndex) {
this.columnIndex = columnIndex;
}
/**
* Getter for the type handler for the column
*
* @return - the type handler
*/
public TypeHandler getTypeHandler() {
return typeHandler;
}
/**
* Setter for the type handler for the column
* @param typeHandler - the type handler
*/
public void setTypeHandler(TypeHandler typeHandler) {
this.typeHandler = typeHandler;
}
/**
* Setter for the Java type of the column
*
* @return - the Java type
*/
public Class getJavaType() {
return javaType;
}
/**
* Setter for the Java type of the column
*
* @param javaType - the Java type
*/
public void setJavaType(Class javaType) {
this.javaType = javaType;
}
/**
* Getter for the JDBC type of the column
*
* @return - the JDBC type
*/
public int getJdbcType() {
return jdbcType;
}
/**
* Getter for the JDBC type name of the column
*
* @return - the JDBC type name
*/
public String getJdbcTypeName() {
return jdbcTypeName;
}
/**
* Setter for the JDBC type name of the column
*
* @param jdbcTypeName - the JDBC type name
*/
public void setJdbcTypeName(String jdbcTypeName) {
this.jdbcTypeName = jdbcTypeName;
this.jdbcType = JdbcTypeRegistry.getType(jdbcTypeName);
}
/**
* Getter for what to return if the column is null
*
* @return - the null substitution
*/
public String getNullValue() {
return nullValue;
}
/**
* Setter for what to return if the column is null
*
* @param nullValue - the null substitution
*/
public void setNullValue(String nullValue) {
this.nullValue = nullValue;
}
/**
* Getter for the name of the column to check for null before instantiating a nested resultMapping value
*
* @return - the null substitution
*/
public String getNotNullColumn() {
return notNullColumn;
}
/**
* Setter for the name of the column to check for null before instantiating a nested resultMapping value
*
* @param notNullColumn - the column name
*/
public void setNotNullColumn(String notNullColumn) {
this.notNullColumn = notNullColumn;
}
/**
* Getter for the name of the statement
*
* @return - the name
*/
public String getStatementName() {
return statementName;
}
/**
* Setter for the name of the statement
*
* @param statementName - the name
*/
public void setStatementName(String statementName) {
this.statementName = statementName;
}
public String getNestedResultMapName() {
return nestedResultMapName;
}
public void setNestedResultMapName(String nestedResultMapName) {
this.nestedResultMapName = nestedResultMapName;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/result/ResultObjectFactory.java 0000644 0001750 0001750 00000010317 11047641640 027427 0 ustar twerner twerner /*
* Copyright 2006 The Apache Software Foundation
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.result;
/**
* iBATIS uses an implementation of this interface to create
* result objects after the execution of a statement. To use, specify
* your implementation class as the type for the "resultObjectFactory"
* element in the SqlMapConfig. Any implementation of this interface
* must have a public no argument constructor.
*
* Note that iBATIS makes use of this interface through the
* ResultObjectFactoryUtil class.
*
* @author Jeff Butler
*
*/
public interface ResultObjectFactory {
/**
* Returns a new instance of the requested class.
* iBATIS will call this method in these circumstances:
*
*
* - When processing a result set - to create new instances of result objects
* - When processing the output parameters of a stored procedure - to create
* instances of OUTPUT parameters
*
* - When processing a nested select - to create instances of parameter
* objects on the nested select
*
* - When processing result maps with nested result maps. iBATIS will
* ask the factory to create an instance of the nested object. If the nested
* object is some implementation of
java.util.Collection
* then iBATIS will supply default implementations of the common interfaces
* if the factory chooses not to create the object. If the
* embedded object is a java.util.List or
* java.util.Collection the default behavior is to
* create an java.util.ArrayList. If the embedded object is a
* java.util.Set the default behavior
* is to create a java.util.HashSet.
*
*
* If you return null from this method, iBATIS will attempt
* to create in instance of the class with it's normal mechanism. This means
* that you can selectively choose which objects to create with this interface.
* In the event that you choose not to create an object, iBATIS will translate some
* common interfaces to their common implementations. If the requested
* class is List or Collection iBATIS will create an ArrayList. If the requested
* class is Set then iBATIS will create a HashSet. But these rules only apply
* if you choose not to create the object. So you can use this factory to
* supply custom implementations of those interfaces if you so desire.
*
* @param statementId the ID of the statement that generated the call to this method
* @param clazz the type of object to create
* @return a new instance of the specified class. The instance must
* be castable to the specified class. If you return null,
* iBATIS will attempt to create the instance using it's normal
* mechanism.
* @throws InstantiationException if the instance cannot be created. If you
* throw this Exception, iBATIS will throw a runtime exception in response and
* will end.
* @throws IllegalAccessException if the constructor cannot be accessed. If you
* throw this Exception, iBATIS will throw a runtime exception in response and
* will end.
*/
Object createInstance(String statementId, Class clazz) throws InstantiationException, IllegalAccessException;
/**
* Called for each property configured in the SqlMapCong file. All the properties
* will be set before any call is made to createInstance
*
* @param name
* @param value
*/
void setProperty(String name, String value);
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/result/ResultObjectFactoryUtil.java 0000644 0001750 0001750 00000013064 11047641640 030267 0 ustar twerner twerner /*
* Copyright 2006 The Apache Software Foundation
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.result;
import com.ibatis.common.resources.*;
import java.util.*;
/**
* This class is used to create instances of result objects. It will
* use the configured ResultObjectFactory if there is one, otherwise
* it will use iBATIS' normal methods.
*
* Note that this class is somewhat tightly coupled with
* SqlExecuter - SqlExecute must call the setStatementId() and
* setResultObjectFactory() methods before executing a statement.
* This is a result of using a ThreadLocal to hold the current
* configuration for the statement under execution. Using a
* ThreadLocal is a solution for IBATIS-366. Without a ThreadLocal,
* the current factory and statement id would have to be added to
* many method signatures - often in inappropriate places.
*
* @author Jeff Butler
*/
public class ResultObjectFactoryUtil {
/**
* Use a ThreadLocal to hold the current statementId and
* factory. This is much easier than passing these
* items all over the place, and it has no measurable impact on
* performance (I did a test with 100000 result rows and found
* no impact - Jeff Butler).
*/
private static ThreadLocal factorySettings = new ThreadLocal();
/**
* Utility class - no instances
*/
private ResultObjectFactoryUtil() {
super();
}
/**
* Algorithm:
*
*
* - If factory is null, then create object internally()
* - Otherwise try to create object through factory
* - If null returned from factory, then create object internally
*
*
* This allows the factory to selectively create objects, also allows for
* the common possibility that a factory is not configured.
*
* @param factory
* the factory to use. May be null!
* @param statementId
* the ID of the statement that generated the call to this method
* @param clazz
* the type of object to create
* @return a new instance of the specified class. The instance must
* be castable to the specified class.
* @throws InstantiationException
* if the instance cannot be created. If you throw this Exception,
* iBATIS will throw a runtime exception in response and will end.
* @throws IllegalAccessException
* if the constructor cannot be accessed. If you throw this
* Exception, iBATIS will throw a runtime exception in response and
* will end.
*/
public static Object createObjectThroughFactory(Class clazz) throws InstantiationException,
IllegalAccessException {
FactorySettings fs = getFactorySettings();
Object obj;
if (fs.getResultObjectFactory() == null) {
obj = createObjectInternally(clazz);
} else {
obj = fs.getResultObjectFactory().createInstance(fs.getStatementId(), clazz);
if (obj == null) {
obj = createObjectInternally(clazz);
}
}
return obj;
}
/**
* This method creates object using iBATIS' normal mechanism. We
* translate List and Collection to ArrayList, and Set to HashSet
* because these interfaces may be requested in nested resultMaps
* and we want to supply default implementations.
*
* @param clazz
* @return
* @throws InstantiationException
* @throws IllegalAccessException
*/
private static Object createObjectInternally(Class clazz) throws InstantiationException, IllegalAccessException {
Class classToCreate;
if (clazz == List.class || clazz == Collection.class) {
classToCreate = ArrayList.class;
} else if (clazz == Set.class) {
classToCreate = HashSet.class;
} else {
classToCreate = clazz;
}
Object obj = Resources.instantiate(classToCreate);
return obj;
}
public static void setResultObjectFactory(ResultObjectFactory resultObjectFactory) {
getFactorySettings().setResultObjectFactory(resultObjectFactory);
}
public static void setStatementId(String statementId) {
getFactorySettings().setStatementId(statementId);
}
private static FactorySettings getFactorySettings() {
FactorySettings fs = (FactorySettings) factorySettings.get();
if (fs == null) {
fs = new FactorySettings();
factorySettings.set(fs);
}
return fs;
}
private static class FactorySettings {
private ResultObjectFactory resultObjectFactory;
private String statementId;
public ResultObjectFactory getResultObjectFactory() {
return resultObjectFactory;
}
public void setResultObjectFactory(ResultObjectFactory resultObjectFactory) {
this.resultObjectFactory = resultObjectFactory;
}
public String getStatementId() {
return statementId;
}
public void setStatementId(String statementId) {
this.statementId = statementId;
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/result/XmlList.java 0000644 0001750 0001750 00000006023 11047641640 025065 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.result;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
* Not really sure what this is...it is not used internally
*/
public class XmlList implements List {
private List list;
/**
* Build a list from another list
*
* @param list - a base list
*/
public XmlList(List list) {
this.list = list;
}
public int size() {
return list.size();
}
public boolean isEmpty() {
return list.isEmpty();
}
public boolean contains(Object o) {
return list.contains(o);
}
public Iterator iterator() {
return list.iterator();
}
public Object[] toArray() {
return list.toArray();
}
public Object[] toArray(Object a[]) {
return list.toArray(a);
}
public boolean add(Object o) {
return list.add(o);
}
public boolean remove(Object o) {
return list.remove(o);
}
public boolean containsAll(Collection c) {
return list.containsAll(c);
}
public boolean addAll(Collection c) {
return list.addAll(c);
}
public boolean addAll(int index, Collection c) {
return list.addAll(index, c);
}
public boolean removeAll(Collection c) {
return list.removeAll(c);
}
public boolean retainAll(Collection c) {
return list.retainAll(c);
}
public void clear() {
list.clear();
}
public Object get(int index) {
return list.get(index);
}
public Object set(int index, Object element) {
return list.set(index, element);
}
public void add(int index, Object element) {
list.add(index, element);
}
public Object remove(int index) {
return list.remove(index);
}
public int indexOf(Object o) {
return list.indexOf(o);
}
public int lastIndexOf(Object o) {
return list.lastIndexOf(o);
}
public ListIterator listIterator() {
return list.listIterator();
}
public ListIterator listIterator(int index) {
return list.listIterator(index);
}
public List subList(int fromIndex, int toIndex) {
return list.subList(fromIndex, toIndex);
}
public String toString() {
StringBuffer buffer = new StringBuffer();
for (int i = 0, n = list.size(); i < n; i++) {
buffer.append(list.get(i));
buffer.append("\r\n");
}
return buffer.toString();
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/ 0000755 0001750 0001750 00000000000 11047641640 022106 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/ 0000755 0001750 0001750 00000000000 11047641636 023537 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/ 0000755 0001750 0001750 00000000000 11047641636 025353 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/BaseTagHandler.java 0000644 0001750 0001750 00000003656 11047641636 031034 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public abstract class BaseTagHandler implements SqlTagHandler {
public int doStartFragment(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
ctx.pushRemoveFirstPrependMarker(tag);
return SqlTagHandler.INCLUDE_BODY;
}
public int doEndFragment(SqlTagContext ctx, SqlTag tag, Object parameterObject, StringBuffer bodyContent) {
if (tag.isCloseAvailable() && !(tag.getHandler() instanceof IterateTagHandler)) {
if (bodyContent.toString().trim().length() > 0) {
bodyContent.append(tag.getCloseAttr());
}
}
return SqlTagHandler.INCLUDE_BODY;
}
public void doPrepend(SqlTagContext ctx, SqlTag tag, Object parameterObject, StringBuffer bodyContent) {
if (tag.isOpenAvailable() && !(tag.getHandler() instanceof IterateTagHandler)) {
if (bodyContent.toString().trim().length() > 0) {
bodyContent.insert(0, tag.getOpenAttr());
}
}
if (tag.isPrependAvailable()) {
if (bodyContent.toString().trim().length() > 0) {
if (tag.getParent() != null && ctx.peekRemoveFirstPrependMarker(tag)) {
ctx.disableRemoveFirstPrependMarker();
}else {
bodyContent.insert(0, tag.getPrependAttr());
}
}
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/ConditionalTagHandler.java 0000644 0001750 0001750 00000013361 11047641636 032417 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
import com.ibatis.common.beans.Probe;
import com.ibatis.common.beans.ProbeFactory;
import com.ibatis.sqlmap.engine.type.SimpleDateFormatter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Date;
public abstract class ConditionalTagHandler extends BaseTagHandler {
private static final Probe PROBE = ProbeFactory.getProbe();
public static final long NOT_COMPARABLE = Long.MIN_VALUE;
private static final String DATE_MASK = "yyyy/MM/dd hh:mm:ss";
private static final String START_INDEX = "[";
public abstract boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject);
public int doStartFragment(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
ctx.pushRemoveFirstPrependMarker(tag);
if (isCondition(ctx, tag, parameterObject)) {
return SqlTagHandler.INCLUDE_BODY;
} else {
return SqlTagHandler.SKIP_BODY;
}
}
public int doEndFragment(SqlTagContext ctx, SqlTag tag, Object parameterObject, StringBuffer bodyContent) {
IterateContext iterate = ctx.peekIterateContext();
if(null != iterate && iterate.isAllowNext()){
iterate.next();
iterate.setAllowNext(false);
if(!iterate.hasNext()) {
iterate.setFinal(true);
}
}
//iteratePropertyReplace(bodyContent,ctx.peekIterateContext());
return super.doEndFragment(ctx,tag,parameterObject,bodyContent);
}
protected long compare(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
String comparePropertyName = tag.getComparePropertyAttr();
String compareValue = tag.getCompareValueAttr();
String prop = getResolvedProperty(ctx, tag);
Object value1;
Class type;
if (prop != null) {
value1 = PROBE.getObject(parameterObject, prop);
type = PROBE.getPropertyTypeForGetter(parameterObject, prop);
} else {
value1 = parameterObject;
if (value1 != null) {
type = parameterObject.getClass();
} else {
type = Object.class;
}
}
if (comparePropertyName != null) {
Object value2 = PROBE.getObject(parameterObject, comparePropertyName);
return compareValues(type, value1, value2);
} else if (compareValue != null) {
return compareValues(type, value1, compareValue);
} else {
throw new RuntimeException("Error comparing in conditional fragment. Uknown 'compare to' values.");
}
}
protected long compareValues(Class type, Object value1, Object value2) {
long result = NOT_COMPARABLE;
if (value1 == null || value2 == null) {
result = value1 == value2 ? 0 : NOT_COMPARABLE;
} else {
if (value2.getClass() != type) {
value2 = convertValue(type, value2.toString());
}
if (value2 instanceof String && type != String.class) {
value1 = value1.toString();
}
if (!(value1 instanceof Comparable && value2 instanceof Comparable)) {
value1 = value1.toString();
value2 = value2.toString();
}
result = ((Comparable) value1).compareTo(value2);
}
return result;
}
protected Object convertValue(Class type, String value) {
if (type == String.class) {
return value;
} else if (type == Byte.class || type == byte.class) {
return Byte.valueOf(value);
} else if (type == Short.class || type == short.class) {
return Short.valueOf(value);
} else if (type == Character.class || type == char.class) {
return new Character(value.charAt(0));
} else if (type == Integer.class || type == int.class) {
return Integer.valueOf(value);
} else if (type == Long.class || type == long.class) {
return Long.valueOf(value);
} else if (type == Float.class || type == float.class) {
return Float.valueOf(value);
} else if (type == Double.class || type == double.class) {
return Double.valueOf(value);
} else if (type == Boolean.class || type == boolean.class) {
return Boolean.valueOf(value);
} else if (type == Date.class) {
return SimpleDateFormatter.format(DATE_MASK, value);
} else if (type == BigInteger.class) {
return new BigInteger(value);
} else if (type == BigDecimal.class) {
return new BigDecimal(value);
} else {
return value;
}
}
/**
* This method will add the proper index values to an indexed property
* string if we are inside an iterate tag
*
* @param ctx
* @param tag
*/
protected String getResolvedProperty(SqlTagContext ctx, SqlTag tag) {
String prop = tag.getPropertyAttr();
IterateContext itCtx = ctx.peekIterateContext();
if (prop != null) {
if(null != itCtx && itCtx.isAllowNext()){
itCtx.next();
itCtx.setAllowNext(false);
if(!itCtx.hasNext()) {
itCtx.setFinal(true);
}
}
if(prop.indexOf(START_INDEX) > -1) {
if (itCtx != null) {
prop = itCtx.addIndexToTagProperty(prop);
}
}
}
return prop;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/DynamicParent.java 0000644 0001750 0001750 00000001473 11047641636 030761 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
import com.ibatis.sqlmap.engine.mapping.sql.SqlChild;
public interface DynamicParent {
public void addChild(SqlChild child);
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/DynamicTagHandler.java 0000644 0001750 0001750 00000001645 11047641636 031542 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public class DynamicTagHandler extends BaseTagHandler {
public int doStartFragment(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
ctx.pushRemoveFirstPrependMarker(tag);
return BaseTagHandler.INCLUDE_BODY;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsEmptyTagHandler.java 0000644 0001750 0001750 00000003207 11047641636 031544 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
import com.ibatis.common.beans.Probe;
import com.ibatis.common.beans.ProbeFactory;
import java.lang.reflect.Array;
import java.util.Collection;
public class IsEmptyTagHandler extends ConditionalTagHandler {
private static final Probe PROBE = ProbeFactory.getProbe();
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
if (parameterObject == null) {
return true;
} else {
String prop = getResolvedProperty(ctx, tag);
Object value;
if (prop != null) {
value = PROBE.getObject(parameterObject, prop);
} else {
value = parameterObject;
}
if (value instanceof Collection) {
return value == null || ((Collection) value).size() < 1;
} else if (value != null && value.getClass().isArray()) {
return Array.getLength(value) == 0;
} else {
return value == null || String.valueOf(value).equals("");
}
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsEqualTagHandler.java 0000644 0001750 0001750 00000001610 11047641636 031511 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public class IsEqualTagHandler extends ConditionalTagHandler {
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
return compare(ctx, tag, parameterObject) == 0;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsGreaterEqualTagHandler.java 0000644 0001750 0001750 00000001715 11047641636 033031 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public class IsGreaterEqualTagHandler extends ConditionalTagHandler {
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
long x = compare(ctx, tag, parameterObject);
return x >= 0 && x != ConditionalTagHandler.NOT_COMPARABLE;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsGreaterThanTagHandler.java 0000644 0001750 0001750 00000001713 11047641636 032652 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public class IsGreaterThanTagHandler extends ConditionalTagHandler {
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
long x = compare(ctx, tag, parameterObject);
return x > 0 && x != ConditionalTagHandler.NOT_COMPARABLE;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsLessEqualTagHandler.java 0000644 0001750 0001750 00000001712 11047641636 032343 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public class IsLessEqualTagHandler extends ConditionalTagHandler {
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
long x = compare(ctx, tag, parameterObject);
return x <= 0 && x != ConditionalTagHandler.NOT_COMPARABLE;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsLessThanTagHandler.java 0000644 0001750 0001750 00000001710 11047641636 032164 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public class IsLessThanTagHandler extends ConditionalTagHandler {
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
long x = compare(ctx, tag, parameterObject);
return x < 0 && x != ConditionalTagHandler.NOT_COMPARABLE;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsNotEmptyTagHandler.java 0000644 0001750 0001750 00000001615 11047641636 032226 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public class IsNotEmptyTagHandler extends IsEmptyTagHandler {
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
return !super.isCondition(ctx, tag, parameterObject);
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsNotEqualTagHandler.java 0000644 0001750 0001750 00000001615 11047641636 032177 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public class IsNotEqualTagHandler extends IsEqualTagHandler {
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
return !super.isCondition(ctx, tag, parameterObject);
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsNotNullTagHandler.java 0000644 0001750 0001750 00000001613 11047641636 032040 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public class IsNotNullTagHandler extends IsNullTagHandler {
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
return !super.isCondition(ctx, tag, parameterObject);
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsNotParameterPresentTagHandler.java ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsNotParameterPresentTagHandler.jav0000644 0001750 0001750 00000001643 11047641636 034251 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public class IsNotParameterPresentTagHandler extends IsParameterPresentTagHandler {
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
return !super.isCondition(ctx, tag, parameterObject);
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsNotPropertyAvailableTagHandler.java ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsNotPropertyAvailableTagHandler.ja0000644 0001750 0001750 00000001645 11047641636 034231 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public class IsNotPropertyAvailableTagHandler extends IsPropertyAvailableTagHandler {
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
return !super.isCondition(ctx, tag, parameterObject);
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsNullTagHandler.java 0000644 0001750 0001750 00000002456 11047641636 031365 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
import com.ibatis.common.beans.Probe;
import com.ibatis.common.beans.ProbeFactory;
public class IsNullTagHandler extends ConditionalTagHandler {
private static final Probe PROBE = ProbeFactory.getProbe();
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
if (parameterObject == null) {
return true;
} else {
String prop = getResolvedProperty(ctx, tag);
Object value;
if (prop != null) {
value = PROBE.getObject(parameterObject, prop);
} else {
value = parameterObject;
}
return value == null;
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsParameterPresentTagHandler.java 0000644 0001750 0001750 00000001603 11047641636 033725 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public class IsParameterPresentTagHandler extends ConditionalTagHandler {
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
return parameterObject != null;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IsPropertyAvailableTagHandler.java 0000644 0001750 0001750 00000004252 11047641636 034074 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
import com.ibatis.common.beans.Probe;
import com.ibatis.common.beans.ProbeFactory;
import java.util.Map;
public class IsPropertyAvailableTagHandler extends ConditionalTagHandler {
private static final Probe PROBE = ProbeFactory.getProbe();
public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
if (parameterObject == null) {
return false;
} else if (parameterObject instanceof Map) {
return ((Map)parameterObject).containsKey(tag.getPropertyAttr());
} else {
String property = getResolvedProperty(ctx, tag);
// if this is a compound property, then we need to get the next to the last
// value from the parameter object, and then see if there is a readable property
// for the last value. This logic was added for IBATIS-281 and IBATIS-293
int lastIndex = property.lastIndexOf('.');
if (lastIndex != -1) {
String firstPart = property.substring(0, lastIndex);
String lastPart = property.substring(lastIndex + 1);
parameterObject = PROBE.getObject(parameterObject, firstPart);
property = lastPart;
}
if (parameterObject instanceof Map) {
// we do this because the PROBE always returns true for
// properties in Maps and that's not the behavior we want here
return ((Map) parameterObject).containsKey(property);
} else {
return PROBE.hasReadableProperty(parameterObject, property);
}
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IterateContext.java 0000644 0001750 0001750 00000020544 11047641636 031165 0 ustar twerner twerner /*
* Created on Apr 17, 2005
*
*/
package com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import com.ibatis.sqlmap.client.SqlMapException;
/**
* @author Brandon Goodin
*/
public class IterateContext implements Iterator {
private static final String PROCESS_INDEX = "ProcessIndex";
private static final String PROCESS_STRING = "ProcessString";
private Iterator iterator;
private int index = -1;
private String property;
private boolean allowNext = true;
private boolean isFinal = false;
private SqlTag tag;
private IterateContext parent;
/**
* This variable is true if some of the sub elements have
* actually produced content. This is used to test
* whether to add the open and conjunction text to the
* generated statement.
*
* This variable is used to replace the deprecated and dangerous
* isFirst method.
*/
private boolean someSubElementsHaveContent;
/**
* This variable is set by the doEndFragment method in IterateTagHandler
* to specify that the first content producing sub element has happened.
* The doPrepend method will test the value to know whether or not
* to process the prepend.
*
* This variable is used to replace the deprecated and dangerous
* isFirst method.
*/
private boolean isPrependEnabled;
public IterateContext(Object collection,SqlTag tag, IterateContext parent) {
this.parent = parent;
this.tag = tag;
if (collection instanceof Collection) {
this.iterator = ((Collection) collection).iterator();
} else if (collection instanceof Iterator) {
this.iterator = ((Iterator) collection);
} else if (collection.getClass().isArray()) {
List list = arrayToList(collection);
this.iterator = list.iterator();
} else {
throw new SqlMapException("ParameterObject or property was not a Collection, Array or Iterator.");
}
}
public boolean hasNext() {
return iterator != null && iterator.hasNext();
}
public Object next() {
index++;
return iterator.next();
}
public void remove() {
iterator.remove();
}
public int getIndex() {
return index;
}
/**
*
* @return
* @deprecated This method should not be used to decide whether or not to
* add prepend and open text to the generated statement. Rather, use the
* methods isPrependEnabled() and someSubElementsHaveContent().
*/
public boolean isFirst() {
return index == 0;
}
public boolean isLast() {
return iterator != null && !iterator.hasNext();
}
private List arrayToList(Object array) {
List list = null;
if (array instanceof Object[]) {
list = Arrays.asList((Object[]) array);
} else {
list = new ArrayList();
for (int i = 0, n = Array.getLength(array); i < n; i++) {
list.add(Array.get(array, i));
}
}
return list;
}
/**
* @return Returns the property.
*/
public String getProperty() {
return property;
}
/**
* This property specifies whether to increment the iterate in
* the doEndFragment. The ConditionalTagHandler has the ability
* to increment the IterateContext, so it is neccessary to avoid
* incrementing in both the ConditionalTag and the IterateTag.
*
* @param property The property to set.
*/
public void setProperty(String property) {
this.property = property;
}
/**
* @return Returns the allowNext.
*/
public boolean isAllowNext() {
return allowNext;
}
/**
* @param performIterate The allowNext to set.
*/
public void setAllowNext(boolean performIterate) {
this.allowNext = performIterate;
}
/**
* @return Returns the tag.
*/
public SqlTag getTag() {
return tag;
}
/**
* @param tag The tag to set.
*/
public void setTag(SqlTag tag) {
this.tag = tag;
}
/**
*
* @return
*/
public boolean isFinal() {
return isFinal;
}
/**
* This attribute is used to mark whether an iterate tag is
* in it's final iteration. Since the ConditionalTagHandler
* can increment the iterate the final iterate in the doEndFragment
* of the IterateTagHandler needs to know it is in it's final iterate.
*
* @param aFinal
*/
public void setFinal(boolean aFinal) {
isFinal = aFinal;
}
/**
* Returns the last property of any bean specified in this IterateContext.
* @return The last property of any bean specified in this IterateContext.
*/
public String getEndProperty() {
if (parent != null) {
int parentPropertyIndex = property.indexOf(parent.getProperty());
if (parentPropertyIndex > -1) {
int endPropertyIndex1 = property.indexOf(']', parentPropertyIndex);
int endPropertyIndex2 = property.indexOf('.', parentPropertyIndex);
return property.substring(parentPropertyIndex + Math.max(endPropertyIndex1, endPropertyIndex2) + 1, property.length());
}
else {
return property;
}
}
else {
return property;
}
}
/**
* Replaces value of a tag property to match it's value with current iteration and all other iterations.
* @param tagProperty the property of a TagHandler.
* @return A Map containing the modified tag property in PROCESS_STRING key and the index where the modification occured in PROCESS_INDEX key.
*/
protected Map processTagProperty(String tagProperty) {
if (parent != null) {
Map parentResult = parent.processTagProperty(tagProperty);
return this.addIndex((String) parentResult.get(PROCESS_STRING), ((Integer) parentResult.get(PROCESS_INDEX)).intValue());
}
else {
return this.addIndex(tagProperty, 0);
}
}
/**
* Replaces value of a tag property to match it's value with current iteration and all other iterations.
* @param tagProperty the property of a TagHandler.
* @return The tag property with all "[]" replaced with the correct iteration value.
*/
public String addIndexToTagProperty(String tagProperty) {
Map map = this.processTagProperty(tagProperty);
return (String) map.get(PROCESS_STRING);
}
/**
* Adds index value to the first found property matching this Iteration starting at index startIndex.
* @param input The input String.
* @param startIndex The index where search for property begins.
* @return A Map containing the modified tag property in PROCESS_STRING key and the index where the modification occured in PROCESS_INDEX key.
*/
protected Map addIndex(String input, int startIndex) {
String endProperty = getEndProperty() + "[";
int propertyIndex = input.indexOf(endProperty, startIndex);
int modificationIndex = 0;
// Is the iterate property in the tag property at all?
if (propertyIndex > -1) {
// Make sure the tag property does not already have a number.
if (input.charAt(propertyIndex + endProperty.length()) == ']') {
// Add iteration number to property.
input = input.substring(0, propertyIndex + endProperty.length()) + this.getIndex() + input.substring(propertyIndex + endProperty.length());
modificationIndex = propertyIndex + endProperty.length();
}
}
Map ret = new HashMap();
ret.put(PROCESS_INDEX, new Integer(modificationIndex));
ret.put(PROCESS_STRING, input);
return ret;
}
public IterateContext getParent() {
return parent;
}
public void setParent(IterateContext parent) {
this.parent = parent;
}
public boolean someSubElementsHaveContent() {
return someSubElementsHaveContent;
}
public void setSomeSubElementsHaveContent(boolean someSubElementsHaveContent) {
this.someSubElementsHaveContent = someSubElementsHaveContent;
}
public boolean isPrependEnabled() {
return isPrependEnabled;
}
public void setPrependEnabled(boolean isPrependEnabled) {
this.isPrependEnabled = isPrependEnabled;
}
} ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/IterateTagHandler.java 0000644 0001750 0001750 00000010621 11047641636 031545 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
import com.ibatis.common.beans.Probe;
import com.ibatis.common.beans.ProbeFactory;
public class IterateTagHandler extends BaseTagHandler {
private static final Probe PROBE = ProbeFactory.getProbe();
public int doStartFragment(SqlTagContext ctx, SqlTag tag, Object parameterObject) {
IterateContext iterate = (IterateContext) ctx.getAttribute(tag);
if (iterate == null) {
IterateContext parentIterate = ctx.peekIterateContext();
ctx.pushRemoveFirstPrependMarker(tag);
Object collection;
String prop = tag.getPropertyAttr();
if (prop != null && !prop.equals("")) {
if(null != parentIterate && parentIterate.isAllowNext()){
parentIterate.next();
parentIterate.setAllowNext(false);
if(!parentIterate.hasNext()) {
parentIterate.setFinal(true);
}
}
if (parentIterate != null) {
prop = parentIterate.addIndexToTagProperty(prop);
}
collection = PROBE.getObject(parameterObject, prop);
} else {
collection = parameterObject;
}
iterate = new IterateContext(collection,tag, parentIterate);
iterate.setProperty( null == prop ? "" : prop );
ctx.setAttribute(tag, iterate);
ctx.pushIterateContext(iterate);
} else if ("iterate".equals(tag.getRemoveFirstPrepend())) {
ctx.reEnableRemoveFirstPrependMarker();
}
if (iterate != null && iterate.hasNext()) {
return INCLUDE_BODY;
} else {
return SKIP_BODY;
}
}
public int doEndFragment(SqlTagContext ctx, SqlTag tag, Object parameterObject, StringBuffer bodyContent) {
IterateContext iterate = (IterateContext) ctx.getAttribute(tag);
if (iterate.hasNext() || iterate.isFinal()) {
if(iterate.isAllowNext()) {
iterate.next();
}
if (bodyContent.toString().trim().length() > 0) {
// the sub element produced a result. If it is the first one
// to produce a result, then we need to add the open
// text. If it is not the first to produce a result then
// we need to add the conjunction text
if (iterate.someSubElementsHaveContent()) {
if (tag.isConjunctionAvailable()) {
bodyContent.insert(0, tag.getConjunctionAttr());
}
} else {
// we need to specify that this is the first content
// producing element so that the doPrepend method will
// add the prepend
iterate.setPrependEnabled(true);
if (tag.isOpenAvailable()) {
bodyContent.insert(0, tag.getOpenAttr());
}
}
iterate.setSomeSubElementsHaveContent(true);
}
if (iterate.isLast() && iterate.someSubElementsHaveContent()) {
if (tag.isCloseAvailable()) {
bodyContent.append(tag.getCloseAttr());
}
}
iterate.setAllowNext(true);
if(iterate.isFinal()) {
return super.doEndFragment(ctx,tag,parameterObject,bodyContent);
} else {
return REPEAT_BODY;
}
} else {
return super.doEndFragment(ctx,tag,parameterObject,bodyContent);
}
}
public void doPrepend(SqlTagContext ctx, SqlTag tag, Object parameterObject, StringBuffer bodyContent) {
IterateContext iterate = (IterateContext) ctx.getAttribute(tag);
if (iterate.isPrependEnabled()) {
super.doPrepend(ctx, tag, parameterObject, bodyContent);
iterate.setPrependEnabled(false); // only do the prepend one time
}
}
public boolean isPostParseRequired() {
return true;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/SqlTag.java 0000644 0001750 0001750 00000010152 11047641636 027410 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
import com.ibatis.sqlmap.engine.mapping.sql.SqlChild;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class SqlTag implements SqlChild, DynamicParent {
private String name;
private SqlTagHandler handler;
// general attributes
private String prependAttr;
private String propertyAttr;
private String removeFirstPrepend;
// conditional attributes
private String comparePropertyAttr;
private String compareValueAttr;
// iterate attributes
private String openAttr;
private String closeAttr;
private String conjunctionAttr;
private SqlTag parent;
private List children = new ArrayList();
private boolean postParseRequired = false;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public SqlTagHandler getHandler() {
return handler;
}
public void setHandler(SqlTagHandler handler) {
this.handler = handler;
}
public boolean isPrependAvailable() {
return prependAttr != null && prependAttr.length() > 0;
}
public boolean isCloseAvailable() {
return closeAttr != null && closeAttr.length() > 0;
}
public boolean isOpenAvailable() {
return openAttr != null && openAttr.length() > 0;
}
public boolean isConjunctionAvailable() {
return conjunctionAttr != null && conjunctionAttr.length() > 0;
}
public String getPrependAttr() {
return prependAttr;
}
public void setPrependAttr(String prependAttr) {
this.prependAttr = prependAttr;
}
public String getPropertyAttr() {
return propertyAttr;
}
public void setPropertyAttr(String propertyAttr) {
this.propertyAttr = propertyAttr;
}
public String getComparePropertyAttr() {
return comparePropertyAttr;
}
public void setComparePropertyAttr(String comparePropertyAttr) {
this.comparePropertyAttr = comparePropertyAttr;
}
public String getCompareValueAttr() {
return compareValueAttr;
}
public void setCompareValueAttr(String compareValueAttr) {
this.compareValueAttr = compareValueAttr;
}
public String getOpenAttr() {
return openAttr;
}
public void setOpenAttr(String openAttr) {
this.openAttr = openAttr;
}
public String getCloseAttr() {
return closeAttr;
}
public void setCloseAttr(String closeAttr) {
this.closeAttr = closeAttr;
}
public String getConjunctionAttr() {
return conjunctionAttr;
}
public void setConjunctionAttr(String conjunctionAttr) {
this.conjunctionAttr = conjunctionAttr;
}
public void addChild(SqlChild child) {
if (child instanceof SqlTag) {
((SqlTag) child).parent = this;
}
children.add(child);
}
public Iterator getChildren() {
return children.iterator();
}
public SqlTag getParent() {
return parent;
}
public String getRemoveFirstPrepend() {
return removeFirstPrepend;
}
public void setRemoveFirstPrepend(String removeFirstPrepend) {
this.removeFirstPrepend = removeFirstPrepend;
}
/**
* @return Returns the postParseRequired.
*/
public boolean isPostParseRequired() {
return postParseRequired;
}
/**
* @param iterateAncestor The postParseRequired to set.
*/
public void setPostParseRequired(boolean iterateAncestor) {
this.postParseRequired = iterateAncestor;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/SqlTagContext.java 0000644 0001750 0001750 00000015460 11047641636 030764 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMapping;
public class SqlTagContext {
private StringWriter sw;
private PrintWriter out;
private HashMap attributes;
private LinkedList removeFirstPrependStack;
private LinkedList iterateContextStack;
private ArrayList parameterMappings = new ArrayList();
public SqlTagContext() {
sw = new StringWriter();
out = new PrintWriter(sw);
attributes = new HashMap();
removeFirstPrependStack = new LinkedList();
iterateContextStack = new LinkedList();
}
public PrintWriter getWriter() {
return out;
}
public String getBodyText() {
out.flush();
return sw.getBuffer().toString();
}
public void setAttribute(Object key, Object value) {
attributes.put(key, value);
}
public Object getAttribute(Object key) {
return attributes.get(key);
}
public void addParameterMapping(ParameterMapping mapping) {
parameterMappings.add(mapping);
}
public List getParameterMappings() {
return parameterMappings;
}
public boolean isEmptyRemoveFirtPrepend() {
return removeFirstPrependStack.size() <= 0;
}
/**
* examine the value of the top RemoveFirstPrependMarker object on the stack.
*
* @return was the first prepend removed
*/
public boolean peekRemoveFirstPrependMarker(SqlTag sqlTag) {
RemoveFirstPrependMarker removeFirstPrepend =
(RemoveFirstPrependMarker) removeFirstPrependStack.get(1);
return removeFirstPrepend.isRemoveFirstPrepend();
}
/**
* pop the first RemoveFirstPrependMarker once the recursion is on it's way out
* of the recursion loop and return it's internal value.
*
* @param tag
*/
public void popRemoveFirstPrependMarker(SqlTag tag) {
RemoveFirstPrependMarker removeFirstPrepend =
(RemoveFirstPrependMarker) removeFirstPrependStack.getFirst();
if(tag == removeFirstPrepend.getSqlTag()) {
removeFirstPrependStack.removeFirst();
}
}
/**
* push a new RemoveFirstPrependMarker object with the specified internal state
*
* @param tag
*/
public void pushRemoveFirstPrependMarker(SqlTag tag) {
if(tag.getHandler() instanceof DynamicTagHandler) {
// this was added to retain default behavior
if(tag.isPrependAvailable()) {
removeFirstPrependStack.addFirst(
new RemoveFirstPrependMarker(tag,true));
} else {
removeFirstPrependStack.addFirst(
new RemoveFirstPrependMarker(tag,false));
}
} else if("true".equals(tag.getRemoveFirstPrepend())
|| "iterate".equals(tag.getRemoveFirstPrepend())){
// you must be specific about the removal otherwise it
// will function as ibatis has always functioned and add
// the prepend
removeFirstPrependStack.addFirst(
new RemoveFirstPrependMarker(tag,true));
} else if(!tag.isPrependAvailable() &&
!"true".equals(tag.getRemoveFirstPrepend()) &&
!"iterate".equals(tag.getRemoveFirstPrepend()) &&
tag.getParent() != null) {
// if no prepend or removeFirstPrepend is specified
// we need to look to the parent tag for default values
if("true".equals(tag.getParent().getRemoveFirstPrepend())
|| "iterate".equals(tag.getParent().getRemoveFirstPrepend())) {
removeFirstPrependStack.addFirst(
new RemoveFirstPrependMarker(tag,true));
}
} else {
removeFirstPrependStack.addFirst(
new RemoveFirstPrependMarker(tag,false));
}
}
/**
* set a new internal state for top RemoveFirstPrependMarker object
*
*/
public void disableRemoveFirstPrependMarker() {
((RemoveFirstPrependMarker) removeFirstPrependStack.get(1)).setRemoveFirstPrepend(false);
}
public void reEnableRemoveFirstPrependMarker() {
((RemoveFirstPrependMarker) removeFirstPrependStack.get(0)).setRemoveFirstPrepend(true);
}
/**
* iterate context is stored here for nested dynamic tags in
* the body of the iterate tag
*
* @param iterateContext
*/
public void pushIterateContext(IterateContext iterateContext) {
iterateContextStack.addFirst(iterateContext);
}
/**
* iterate context is removed here from the stack when iterate tag is finished being
* processed
*
* @return the top element of the context stack
*/
public IterateContext popIterateContext() {
IterateContext retVal = null;
if(!iterateContextStack.isEmpty()) {
retVal = (IterateContext)iterateContextStack.removeFirst();
}
return retVal;
}
/**
* iterate context is removed here from the stack when iterate tag is finished being
* processed
*
* @return the top element on the context stack
*/
public IterateContext peekIterateContext() {
IterateContext retVal = null;
if(!iterateContextStack.isEmpty()) {
retVal = (IterateContext)iterateContextStack.getFirst();
}
return retVal;
}
}
/**
*
* This inner class i used strictly to house whether the
* removeFirstPrepend has been used in a particular nested
* situation.
*
* @author Brandon Goodin
*/
class RemoveFirstPrependMarker {
private boolean removeFirstPrepend;
private SqlTag tag;
/**
*
*/
public RemoveFirstPrependMarker(SqlTag tag, boolean removeFirstPrepend) {
this.removeFirstPrepend = removeFirstPrepend;
this.tag = tag;
}
/**
* @return Returns the removeFirstPrepend.
*/
public boolean isRemoveFirstPrepend() {
return removeFirstPrepend;
}
/**
* @param removeFirstPrepend The removeFirstPrepend to set.
*/
public void setRemoveFirstPrepend(boolean removeFirstPrepend) {
this.removeFirstPrepend = removeFirstPrepend;
}
/**
* @return Returns the sqlTag.
*/
public SqlTag getSqlTag() {
return tag;
}
} ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/SqlTagHandler.java 0000644 0001750 0001750 00000002240 11047641636 030705 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
public interface SqlTagHandler {
// BODY TAG
public static final int SKIP_BODY = 0;
public static final int INCLUDE_BODY = 1;
public static final int REPEAT_BODY = 2;
public int doStartFragment(SqlTagContext ctx, SqlTag tag, Object parameterObject);
public int doEndFragment(SqlTagContext ctx, SqlTag tag, Object parameterObject, StringBuffer bodyContent);
public void doPrepend(SqlTagContext ctx, SqlTag tag, Object parameterObject, StringBuffer bodyContent);
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/elements/SqlTagHandlerFactory.java 0000644 0001750 0001750 00000004076 11047641636 032246 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements;
import java.util.HashMap;
import java.util.Map;
public class SqlTagHandlerFactory {
private static final Map HANDLER_MAP = new HashMap();
static {
HANDLER_MAP.put("isEmpty", new IsEmptyTagHandler());
HANDLER_MAP.put("isEqual", new IsEqualTagHandler());
HANDLER_MAP.put("isGreaterEqual", new IsGreaterEqualTagHandler());
HANDLER_MAP.put("isGreaterThan", new IsGreaterThanTagHandler());
HANDLER_MAP.put("isLessEqual", new IsLessEqualTagHandler());
HANDLER_MAP.put("isLessThan", new IsLessThanTagHandler());
HANDLER_MAP.put("isNotEmpty", new IsNotEmptyTagHandler());
HANDLER_MAP.put("isNotEqual", new IsNotEqualTagHandler());
HANDLER_MAP.put("isNotNull", new IsNotNullTagHandler());
HANDLER_MAP.put("isNotParameterPresent", new IsNotParameterPresentTagHandler());
HANDLER_MAP.put("isNotPropertyAvailable", new IsNotPropertyAvailableTagHandler());
HANDLER_MAP.put("isNull", new IsNullTagHandler());
HANDLER_MAP.put("isParameterPresent", new IsParameterPresentTagHandler());
HANDLER_MAP.put("isPropertyAvailable", new IsPropertyAvailableTagHandler());
HANDLER_MAP.put("iterate", new IterateTagHandler());
HANDLER_MAP.put("dynamic", new DynamicTagHandler());
}
private SqlTagHandlerFactory() {
}
public static SqlTagHandler getSqlTagHandler(String name) {
return (SqlTagHandler) HANDLER_MAP.get(name);
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/dynamic/DynamicSql.java 0000644 0001750 0001750 00000020145 11047641636 026450 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.dynamic;
import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.parameter.InlineParameterMapParser;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMapping;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.sql.Sql;
import com.ibatis.sqlmap.engine.mapping.sql.SqlChild;
import com.ibatis.sqlmap.engine.mapping.sql.SqlText;
import com.ibatis.sqlmap.engine.mapping.sql.dynamic.elements.*;
import com.ibatis.sqlmap.engine.mapping.sql.simple.SimpleDynamicSql;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class DynamicSql implements Sql, DynamicParent {
private static final InlineParameterMapParser PARAM_PARSER = new InlineParameterMapParser();
private List children = new ArrayList();
private SqlMapExecutorDelegate delegate;
public DynamicSql(SqlMapExecutorDelegate delegate) {
this.delegate = delegate;
}
public String getSql(StatementScope statementScope, Object parameterObject) {
String sql = statementScope.getDynamicSql();
if (sql == null) {
process(statementScope, parameterObject);
sql = statementScope.getDynamicSql();
}
return sql;
}
public ParameterMap getParameterMap(StatementScope statementScope, Object parameterObject) {
ParameterMap map = statementScope.getDynamicParameterMap();
if (map == null) {
process(statementScope, parameterObject);
map = statementScope.getDynamicParameterMap();
}
return map;
}
public ResultMap getResultMap(StatementScope statementScope, Object parameterObject) {
return statementScope.getResultMap();
}
public void cleanup(StatementScope statementScope) {
statementScope.setDynamicSql(null);
statementScope.setDynamicParameterMap(null);
}
private void process(StatementScope statementScope, Object parameterObject) {
SqlTagContext ctx = new SqlTagContext();
List localChildren = children;
processBodyChildren(statementScope, ctx, parameterObject, localChildren.iterator());
ParameterMap map = new ParameterMap(delegate);
map.setId(statementScope.getStatement().getId() + "-InlineParameterMap");
map.setParameterClass(((MappedStatement) statementScope.getStatement()).getParameterClass());
map.setParameterMappingList(ctx.getParameterMappings());
String dynSql = ctx.getBodyText();
// Processes $substitutions$ after DynamicSql
if (SimpleDynamicSql.isSimpleDynamicSql(dynSql)) {
dynSql = new SimpleDynamicSql(delegate, dynSql).getSql(statementScope, parameterObject);
}
statementScope.setDynamicSql(dynSql);
statementScope.setDynamicParameterMap(map);
}
private void processBodyChildren(StatementScope statementScope, SqlTagContext ctx, Object parameterObject, Iterator localChildren) {
PrintWriter out = ctx.getWriter();
processBodyChildren(statementScope, ctx, parameterObject, localChildren, out);
}
private void processBodyChildren(StatementScope statementScope, SqlTagContext ctx, Object parameterObject, Iterator localChildren, PrintWriter out) {
while (localChildren.hasNext()) {
SqlChild child = (SqlChild) localChildren.next();
if (child instanceof SqlText) {
SqlText sqlText = (SqlText) child;
String sqlStatement = sqlText.getText();
if (sqlText.isWhiteSpace()) {
out.print(sqlStatement);
} else if (!sqlText.isPostParseRequired()) {
// BODY OUT
out.print(sqlStatement);
ParameterMapping[] mappings = sqlText.getParameterMappings();
if (mappings != null) {
for (int i = 0, n = mappings.length; i < n; i++) {
ctx.addParameterMapping(mappings[i]);
}
}
} else {
IterateContext itCtx = ctx.peekIterateContext();
if(null != itCtx && itCtx.isAllowNext()){
itCtx.next();
itCtx.setAllowNext(false);
if(!itCtx.hasNext()) {
itCtx.setFinal(true);
}
}
if(itCtx!=null) {
StringBuffer sqlStatementBuffer = new StringBuffer(sqlStatement);
iteratePropertyReplace(sqlStatementBuffer, itCtx);
sqlStatement = sqlStatementBuffer.toString();
}
sqlText = PARAM_PARSER.parseInlineParameterMap(delegate.getTypeHandlerFactory(), sqlStatement);
ParameterMapping[] mappings = sqlText.getParameterMappings();
out.print(sqlText.getText());
if (mappings != null) {
for (int i = 0, n = mappings.length; i < n; i++) {
ctx.addParameterMapping(mappings[i]);
}
}
}
} else if (child instanceof SqlTag) {
SqlTag tag = (SqlTag) child;
SqlTagHandler handler = tag.getHandler();
int response = SqlTagHandler.INCLUDE_BODY;
do {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
response = handler.doStartFragment(ctx, tag, parameterObject);
if (response != SqlTagHandler.SKIP_BODY) {
processBodyChildren(statementScope, ctx, parameterObject, tag.getChildren(), pw);
pw.flush();
pw.close();
StringBuffer body = sw.getBuffer();
response = handler.doEndFragment(ctx, tag, parameterObject, body);
handler.doPrepend(ctx, tag, parameterObject, body);
if (response != SqlTagHandler.SKIP_BODY) {
if (body.length() > 0) {
out.print(body.toString());
}
}
}
} while (response == SqlTagHandler.REPEAT_BODY);
ctx.popRemoveFirstPrependMarker(tag);
if(ctx.peekIterateContext()!= null && ctx.peekIterateContext().getTag() == tag) {
ctx.setAttribute(ctx.peekIterateContext().getTag(), null);
ctx.popIterateContext();
}
}
}
}
/**
*
* @param bodyContent
* @param iterate
*/
protected void iteratePropertyReplace(StringBuffer bodyContent, IterateContext iterate) {
if(iterate!=null) {
String[] mappings = new String[] {"#", "$"};
for (int i = 0; i < mappings.length; i++) {
int startIndex = 0;
int endIndex = -1;
while (startIndex > -1 && startIndex < bodyContent.length()) {
startIndex = bodyContent.indexOf(mappings[i], endIndex + 1);
endIndex = bodyContent.indexOf(mappings[i], startIndex + 1);
if (startIndex > -1 && endIndex > -1) {
bodyContent.replace(startIndex + 1, endIndex, iterate.addIndexToTagProperty(bodyContent.substring(startIndex + 1, endIndex)));
}
}
}
}
}
protected static void replace(StringBuffer buffer, String find, String replace) {
int pos = buffer.toString().indexOf(find);
int len = find.length();
while (pos > -1) {
buffer.replace(pos, pos + len, replace);
pos = buffer.toString().indexOf(find);
}
}
public void addChild(SqlChild child) {
children.add(child);
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/raw/ 0000755 0001750 0001750 00000000000 11047641636 022704 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/raw/RawSql.java 0000644 0001750 0001750 00000002106 11047641636 024757 0 ustar twerner twerner package com.ibatis.sqlmap.engine.mapping.sql.raw;
import com.ibatis.sqlmap.engine.mapping.sql.Sql;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.scope.StatementScope;
/**
* A non-executable SQL container simply for
* communicating raw SQL around the framework.
*/
public class RawSql implements Sql {
private String sql;
public RawSql(String sql) {
this.sql = sql;
}
public String getSql(StatementScope statementScope, Object parameterObject) {
return sql;
}
public ParameterMap getParameterMap(StatementScope statementScope, Object parameterObject) {
throw new RuntimeException ("Method not implemented on RawSql.");
}
public ResultMap getResultMap(StatementScope statementScope, Object parameterObject) {
throw new RuntimeException ("Method not implemented on RawSql.");
}
public void cleanup(StatementScope statementScope) {
throw new RuntimeException ("Method not implemented on RawSql.");
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/simple/ 0000755 0001750 0001750 00000000000 11047641636 023404 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/simple/SimpleDynamicSql.java 0000644 0001750 0001750 00000006727 11047641636 027501 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.simple;
import com.ibatis.common.beans.Probe;
import com.ibatis.common.beans.ProbeFactory;
import com.ibatis.sqlmap.client.SqlMapException;
import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.sql.Sql;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import java.util.StringTokenizer;
public class SimpleDynamicSql implements Sql {
private static final Probe PROBE = ProbeFactory.getProbe();
private static final String ELEMENT_TOKEN = "$";
private String sqlStatement;
private SqlMapExecutorDelegate delegate;
public SimpleDynamicSql(SqlMapExecutorDelegate delegate, String sqlStatement) {
this.delegate = delegate;
this.sqlStatement = sqlStatement;
}
public String getSql(StatementScope statementScope, Object parameterObject) {
return processDynamicElements(sqlStatement, parameterObject);
}
public ParameterMap getParameterMap(StatementScope statementScope, Object parameterObject) {
return statementScope.getParameterMap();
}
public ResultMap getResultMap(StatementScope statementScope, Object parameterObject) {
return statementScope.getResultMap();
}
public void cleanup(StatementScope statementScope) {
}
public static boolean isSimpleDynamicSql(String sql) {
return sql != null && sql.indexOf(ELEMENT_TOKEN) > -1;
}
private String processDynamicElements(String sql, Object parameterObject) {
StringTokenizer parser = new StringTokenizer(sql, ELEMENT_TOKEN, true);
StringBuffer newSql = new StringBuffer();
String token = null;
String lastToken = null;
while (parser.hasMoreTokens()) {
token = parser.nextToken();
if (ELEMENT_TOKEN.equals(lastToken)) {
if (ELEMENT_TOKEN.equals(token)) {
newSql.append(ELEMENT_TOKEN);
token = null;
} else {
Object value = null;
if (parameterObject != null) {
if (delegate.getTypeHandlerFactory().hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else {
value = PROBE.getObject(parameterObject, token);
}
}
if (value != null) {
newSql.append(String.valueOf(value));
}
token = parser.nextToken();
if (!ELEMENT_TOKEN.equals(token)) {
throw new SqlMapException("Unterminated dynamic element in sql (" + sql + ").");
}
token = null;
}
} else {
if (!ELEMENT_TOKEN.equals(token)) {
newSql.append(token);
}
}
lastToken = token;
}
return newSql.toString();
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/stat/ 0000755 0001750 0001750 00000000000 11047641640 023061 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/stat/StaticSql.java 0000644 0001750 0001750 00000003054 11047641640 025635 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql.stat;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.sql.Sql;
import com.ibatis.sqlmap.engine.scope.StatementScope;
public class StaticSql implements Sql {
private String sqlStatement;
public StaticSql(String sqlStatement) {
this.sqlStatement = sqlStatement.replace('\r', ' ').replace('\n', ' ');
}
public String getSql(StatementScope statementScope, Object parameterObject) {
return sqlStatement;
}
public ParameterMap getParameterMap(StatementScope statementScope, Object parameterObject) {
return statementScope.getParameterMap();
}
public ResultMap getResultMap(StatementScope statementScope, Object parameterObject) {
return statementScope.getResultMap();
}
public void cleanup(StatementScope statementScope) {
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/Sql.java 0000644 0001750 0001750 00000002270 11047641640 023511 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.scope.StatementScope;
public interface Sql {
public String getSql(StatementScope statementScope, Object parameterObject);
public ParameterMap getParameterMap(StatementScope statementScope, Object parameterObject);
public ResultMap getResultMap(StatementScope statementScope, Object parameterObject);
public void cleanup(StatementScope statementScope);
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/SqlChild.java 0000644 0001750 0001750 00000001301 11047641640 024447 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql;
public interface SqlChild {
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/sql/SqlText.java 0000644 0001750 0001750 00000003203 11047641640 024353 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.sql;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMapping;
public class SqlText implements SqlChild {
private String text;
private boolean isWhiteSpace;
private boolean postParseRequired;
private ParameterMapping[] parameterMappings;
public String getText() {
return text;
}
public void setText(String text) {
this.text = text.replace('\r', ' ').replace('\n', ' ').replace('\t', ' ');
this.isWhiteSpace = text.trim().length() == 0;
}
public boolean isWhiteSpace() {
return isWhiteSpace;
}
public ParameterMapping[] getParameterMappings() {
return parameterMappings;
}
public void setParameterMappings(ParameterMapping[] parameterMappings) {
this.parameterMappings = parameterMappings;
}
public boolean isPostParseRequired() {
return postParseRequired;
}
public void setPostParseRequired(boolean postParseRequired) {
this.postParseRequired = postParseRequired;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/ 0000755 0001750 0001750 00000000000 11047641640 023313 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/CachingStatement.java 0000644 0001750 0001750 00000011702 11047641640 027400 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.statement;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.cache.CacheKey;
import com.ibatis.sqlmap.engine.cache.CacheModel;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.sql.Sql;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import java.sql.SQLException;
import java.util.List;
public class CachingStatement extends MappedStatement {
private MappedStatement statement;
private CacheModel cacheModel;
public CachingStatement(MappedStatement statement, CacheModel cacheModel) {
this.statement = statement;
this.cacheModel = cacheModel;
}
public String getId() {
return statement.getId();
}
public StatementType getStatementType() {
return statement.getStatementType();
}
public Integer getResultSetType() {
return statement.getResultSetType();
}
public Integer getFetchSize() {
return statement.getFetchSize();
}
public ParameterMap getParameterMap() {
return statement.getParameterMap();
}
public ResultMap getResultMap() {
return statement.getResultMap();
}
public int executeUpdate(StatementScope statementScope, Transaction trans, Object parameterObject)
throws SQLException {
int n = statement.executeUpdate(statementScope, trans, parameterObject);
return n;
}
public Object executeQueryForObject(StatementScope statementScope, Transaction trans, Object parameterObject, Object resultObject)
throws SQLException {
CacheKey cacheKey = getCacheKey(statementScope, parameterObject);
cacheKey.update("executeQueryForObject");
Object object = cacheModel.getObject(cacheKey);
if (object == CacheModel.NULL_OBJECT){
// This was cached, but null
object = null;
}else if (object == null) {
object = statement.executeQueryForObject(statementScope, trans, parameterObject, resultObject);
cacheModel.putObject(cacheKey, object);
}
return object;
}
public List executeQueryForList(StatementScope statementScope, Transaction trans, Object parameterObject, int skipResults, int maxResults)
throws SQLException {
CacheKey cacheKey = getCacheKey(statementScope, parameterObject);
cacheKey.update("executeQueryForList");
cacheKey.update(skipResults);
cacheKey.update(maxResults);
Object listAsObject = cacheModel.getObject(cacheKey);
List list;
if(listAsObject == CacheModel.NULL_OBJECT){
// The cached object was null
list = null;
}else if (listAsObject == null) {
list = statement.executeQueryForList(statementScope, trans, parameterObject, skipResults, maxResults);
cacheModel.putObject(cacheKey, list);
}else{
list = (List) listAsObject;
}
return list;
}
public void executeQueryWithRowHandler(StatementScope statementScope, Transaction trans, Object parameterObject, RowHandler rowHandler)
throws SQLException {
statement.executeQueryWithRowHandler(statementScope, trans, parameterObject, rowHandler);
}
public CacheKey getCacheKey(StatementScope statementScope, Object parameterObject) {
CacheKey key = statement.getCacheKey(statementScope, parameterObject);
if (!cacheModel.isReadOnly() && !cacheModel.isSerialize()) {
key.update(statementScope.getSession());
}
return key;
}
public void setBaseCacheKey(int base) {
statement.setBaseCacheKey(base);
}
public void addExecuteListener(ExecuteListener listener) {
statement.addExecuteListener(listener);
}
public void notifyListeners() {
statement.notifyListeners();
}
public void initRequest(StatementScope statementScope) {
statement.initRequest(statementScope);
}
public Sql getSql() {
return statement.getSql();
}
public Class getParameterClass() {
return statement.getParameterClass();
}
public Integer getTimeout() {
return statement.getTimeout();
}
public boolean hasMultipleResultMaps() {
return statement.hasMultipleResultMaps();
}
public ResultMap[] getAdditionalResultMaps() {
return statement.getAdditionalResultMaps();
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/DefaultRowHandler.java 0000644 0001750 0001750 00000002100 11047641640 027521 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.statement;
import com.ibatis.sqlmap.client.event.RowHandler;
import java.util.ArrayList;
import java.util.List;
public class DefaultRowHandler implements RowHandler {
private List list = new ArrayList();
public void handleRow(Object valueObject) {
list.add(valueObject);
}
public List getList() {
return list;
}
public void setList(List list) {
this.list = list;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/DeleteStatement.java 0000644 0001750 0001750 00000003425 11047641640 027251 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.statement;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import java.sql.SQLException;
import java.util.List;
public class DeleteStatement extends MappedStatement {
public StatementType getStatementType() {
return StatementType.DELETE;
}
public Object executeQueryForObject(StatementScope statementScope, Transaction trans, Object parameterObject, Object resultObject)
throws SQLException {
throw new SQLException("Delete statements cannot be executed as a query.");
}
public List executeQueryForList(StatementScope statementScope, Transaction trans, Object parameterObject, int skipResults, int maxResults)
throws SQLException {
throw new SQLException("Delete statements cannot be executed as a query.");
}
public void executeQueryWithRowHandler(StatementScope statementScope, Transaction trans, Object parameterObject, RowHandler rowHandler)
throws SQLException {
throw new SQLException("Delete statements cannot be executed as a query.");
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/ExecuteListener.java 0000644 0001750 0001750 00000001416 11047641640 027270 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.statement;
public interface ExecuteListener {
public void onExecuteStatement(MappedStatement statement);
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/InsertStatement.java 0000644 0001750 0001750 00000004055 11047641640 027313 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.statement;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import java.sql.SQLException;
import java.util.List;
public class InsertStatement extends MappedStatement {
private SelectKeyStatement selectKeyStatement;
public StatementType getStatementType() {
return StatementType.INSERT;
}
public Object executeQueryForObject(StatementScope statementScope, Transaction trans, Object parameterObject, Object resultObject)
throws SQLException {
throw new SQLException("Insert statements cannot be executed as a query.");
}
public List executeQueryForList(StatementScope statementScope, Transaction trans, Object parameterObject, int skipResults, int maxResults)
throws SQLException {
throw new SQLException("Insert statements cannot be executed as a query.");
}
public void executeQueryWithRowHandler(StatementScope statementScope, Transaction trans, Object parameterObject, RowHandler rowHandler)
throws SQLException {
throw new SQLException("Update statements cannot be executed as a query.");
}
public SelectKeyStatement getSelectKeyStatement() {
return selectKeyStatement;
}
public void setSelectKeyStatement(SelectKeyStatement selectKeyStatement) {
this.selectKeyStatement = selectKeyStatement;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/MappedStatement.java 0000644 0001750 0001750 00000034043 11047641640 027255 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.statement;
import com.ibatis.common.jdbc.exception.NestedSQLException;
import com.ibatis.common.io.ReaderInputStream;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.client.*;
import com.ibatis.sqlmap.engine.execution.SqlExecutor;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.sql.Sql;
import com.ibatis.sqlmap.engine.scope.ErrorContext;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import com.ibatis.sqlmap.engine.transaction.TransactionException;
import com.ibatis.sqlmap.engine.type.*;
import com.ibatis.sqlmap.engine.cache.*;
import com.ibatis.sqlmap.engine.impl.*;
import org.w3c.dom.Document;
import javax.xml.parsers.*;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.*;
import java.io.*;
public class MappedStatement {
private String id;
private Integer resultSetType;
private Integer fetchSize;
private ResultMap resultMap;
private ParameterMap parameterMap;
private Class parameterClass;
private Sql sql;
private int baseCacheKey;
private SqlMapClientImpl sqlMapClient;
private Integer timeout;
private ResultMap[] additionalResultMaps = new ResultMap[0];
private List executeListeners = new ArrayList();
private String resource;
public StatementType getStatementType() {
return StatementType.UNKNOWN;
}
public int executeUpdate(StatementScope statementScope, Transaction trans, Object parameterObject)
throws SQLException {
ErrorContext errorContext = statementScope.getErrorContext();
errorContext.setActivity("preparing the mapped statement for execution");
errorContext.setObjectId(this.getId());
errorContext.setResource(this.getResource());
statementScope.getSession().setCommitRequired(true);
try {
parameterObject = validateParameter(parameterObject);
Sql sql = getSql();
errorContext.setMoreInfo("Check the parameter map.");
ParameterMap parameterMap = sql.getParameterMap(statementScope, parameterObject);
errorContext.setMoreInfo("Check the result map.");
ResultMap resultMap = sql.getResultMap(statementScope, parameterObject);
statementScope.setResultMap(resultMap);
statementScope.setParameterMap(parameterMap);
int rows = 0;
errorContext.setMoreInfo("Check the parameter map.");
Object[] parameters = parameterMap.getParameterObjectValues(statementScope, parameterObject);
errorContext.setMoreInfo("Check the SQL statement.");
String sqlString = sql.getSql(statementScope, parameterObject);
errorContext.setActivity("executing mapped statement");
errorContext.setMoreInfo("Check the statement or the result map.");
rows = sqlExecuteUpdate(statementScope, trans.getConnection(), sqlString, parameters);
errorContext.setMoreInfo("Check the output parameters.");
if (parameterObject != null) {
postProcessParameterObject(statementScope, parameterObject, parameters);
}
errorContext.reset();
sql.cleanup(statementScope);
notifyListeners();
return rows;
} catch (SQLException e) {
errorContext.setCause(e);
throw new NestedSQLException(errorContext.toString(), e.getSQLState(), e.getErrorCode(), e);
} catch (Exception e) {
errorContext.setCause(e);
throw new NestedSQLException(errorContext.toString(), e);
}
}
public Object executeQueryForObject(StatementScope statementScope, Transaction trans, Object parameterObject, Object resultObject)
throws SQLException {
try {
Object object = null;
DefaultRowHandler rowHandler = new DefaultRowHandler();
executeQueryWithCallback(statementScope, trans.getConnection(), parameterObject, resultObject, rowHandler, SqlExecutor.NO_SKIPPED_RESULTS, SqlExecutor.NO_MAXIMUM_RESULTS);
List list = rowHandler.getList();
if (list.size() > 1) {
throw new SQLException("Error: executeQueryForObject returned too many results.");
} else if (list.size() > 0) {
object = list.get(0);
}
return object;
} catch (TransactionException e) {
throw new NestedSQLException("Error getting Connection from Transaction. Cause: " + e, e);
}
}
public List executeQueryForList(StatementScope statementScope, Transaction trans, Object parameterObject, int skipResults, int maxResults)
throws SQLException {
try {
DefaultRowHandler rowHandler = new DefaultRowHandler();
executeQueryWithCallback(statementScope, trans.getConnection(), parameterObject, null, rowHandler, skipResults, maxResults);
return rowHandler.getList();
} catch (TransactionException e) {
throw new NestedSQLException("Error getting Connection from Transaction. Cause: " + e, e);
}
}
public void executeQueryWithRowHandler(StatementScope statementScope, Transaction trans, Object parameterObject, RowHandler rowHandler)
throws SQLException {
try {
executeQueryWithCallback(statementScope, trans.getConnection(), parameterObject, null, rowHandler, SqlExecutor.NO_SKIPPED_RESULTS, SqlExecutor.NO_MAXIMUM_RESULTS);
} catch (TransactionException e) {
throw new NestedSQLException("Error getting Connection from Transaction. Cause: " + e, e);
}
}
//
// PROTECTED METHODS
//
protected void executeQueryWithCallback(StatementScope statementScope, Connection conn, Object parameterObject, Object resultObject, RowHandler rowHandler, int skipResults, int maxResults)
throws SQLException {
ErrorContext errorContext = statementScope.getErrorContext();
errorContext.setActivity("preparing the mapped statement for execution");
errorContext.setObjectId(this.getId());
errorContext.setResource(this.getResource());
try {
parameterObject = validateParameter(parameterObject);
Sql sql = getSql();
errorContext.setMoreInfo("Check the parameter map.");
ParameterMap parameterMap = sql.getParameterMap(statementScope, parameterObject);
errorContext.setMoreInfo("Check the result map.");
ResultMap resultMap = sql.getResultMap(statementScope, parameterObject);
statementScope.setResultMap(resultMap);
statementScope.setParameterMap(parameterMap);
errorContext.setMoreInfo("Check the parameter map.");
Object[] parameters = parameterMap.getParameterObjectValues(statementScope, parameterObject);
errorContext.setMoreInfo("Check the SQL statement.");
String sqlString = sql.getSql(statementScope, parameterObject);
errorContext.setActivity("executing mapped statement");
errorContext.setMoreInfo("Check the SQL statement or the result map.");
RowHandlerCallback callback = new RowHandlerCallback(resultMap, resultObject, rowHandler);
sqlExecuteQuery(statementScope, conn, sqlString, parameters, skipResults, maxResults, callback);
errorContext.setMoreInfo("Check the output parameters.");
if (parameterObject != null) {
postProcessParameterObject(statementScope, parameterObject, parameters);
}
errorContext.reset();
sql.cleanup(statementScope);
notifyListeners();
} catch (SQLException e) {
errorContext.setCause(e);
throw new NestedSQLException(errorContext.toString(), e.getSQLState(), e.getErrorCode(), e);
} catch (Exception e) {
errorContext.setCause(e);
throw new NestedSQLException(errorContext.toString(), e);
}
}
protected void postProcessParameterObject(StatementScope statementScope, Object parameterObject, Object[] parameters) {
}
protected int sqlExecuteUpdate(StatementScope statementScope, Connection conn, String sqlString, Object[] parameters) throws SQLException {
if (statementScope.getSession().isInBatch()) {
getSqlExecutor().addBatch(statementScope, conn, sqlString, parameters);
return 0;
} else {
return getSqlExecutor().executeUpdate(statementScope, conn, sqlString, parameters);
}
}
protected void sqlExecuteQuery(StatementScope statementScope, Connection conn, String sqlString, Object[] parameters, int skipResults, int maxResults, RowHandlerCallback callback) throws SQLException {
getSqlExecutor().executeQuery(statementScope, conn, sqlString, parameters, skipResults, maxResults, callback);
}
protected Object validateParameter(Object param)
throws SQLException {
Object newParam = param;
Class parameterClass = getParameterClass();
if (newParam != null && parameterClass != null) {
if (DomTypeMarker.class.isAssignableFrom(parameterClass)) {
if (XmlTypeMarker.class.isAssignableFrom(parameterClass)) {
if (!(newParam instanceof String)
&& !(newParam instanceof Document)) {
throw new SQLException("Invalid parameter object type. Expected '" + String.class.getName() + "' or '" + Document.class.getName() + "' but found '" + newParam.getClass().getName() + "'.");
}
if (!(newParam instanceof Document)) {
newParam = stringToDocument ((String)newParam);
}
} else {
if (!Document.class.isAssignableFrom(newParam.getClass())) {
throw new SQLException("Invalid parameter object type. Expected '" + Document.class.getName() + "' but found '" + newParam.getClass().getName() + "'.");
}
}
} else {
if (!parameterClass.isAssignableFrom(newParam.getClass())) {
throw new SQLException("Invalid parameter object type. Expected '" + parameterClass.getName() + "' but found '" + newParam.getClass().getName() + "'.");
}
}
}
return newParam;
}
private Document stringToDocument (String s) {
try {
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
return documentBuilder.parse(new ReaderInputStream(new StringReader(s)));
} catch (Exception e) {
throw new RuntimeException("Error occurred. Cause: " + e, e);
}
}
public String getId() {
return id;
}
public Integer getResultSetType() {
return resultSetType;
}
public void setResultSetType(Integer resultSetType) {
this.resultSetType = resultSetType;
}
public Integer getFetchSize() {
return fetchSize;
}
public void setFetchSize(Integer fetchSize) {
this.fetchSize = fetchSize;
}
public void setId(String id) {
this.id = id;
}
public Sql getSql() {
return sql;
}
public void setSql(Sql sql) {
this.sql = sql;
}
public ResultMap getResultMap() {
return resultMap;
}
public void setResultMap(ResultMap resultMap) {
this.resultMap = resultMap;
}
public ParameterMap getParameterMap() {
return parameterMap;
}
public void setParameterMap(ParameterMap parameterMap) {
this.parameterMap = parameterMap;
}
public Class getParameterClass() {
return parameterClass;
}
public void setParameterClass(Class parameterClass) {
this.parameterClass = parameterClass;
}
public String getResource() {
return resource;
}
public void setResource(String resource) {
this.resource = resource;
}
public CacheKey getCacheKey(StatementScope statementScope, Object parameterObject) {
Sql sql = statementScope.getSql();
ParameterMap pmap = sql.getParameterMap(statementScope, parameterObject);
CacheKey cacheKey = pmap.getCacheKey(statementScope, parameterObject);
cacheKey.update(id);
cacheKey.update(baseCacheKey);
cacheKey.update(sql.getSql(statementScope, parameterObject)); //Fixes bug 953001
return cacheKey;
}
public void setBaseCacheKey(int base) {
this.baseCacheKey = base;
}
public void addExecuteListener(ExecuteListener listener) {
executeListeners.add(listener);
}
public void notifyListeners() {
for (int i = 0, n = executeListeners.size(); i < n; i++) {
((ExecuteListener) executeListeners.get(i)).onExecuteStatement(this);
}
}
public SqlExecutor getSqlExecutor() {
return sqlMapClient.getSqlExecutor();
}
public SqlMapClient getSqlMapClient() {
return sqlMapClient;
}
public void setSqlMapClient(SqlMapClient sqlMapClient) {
this.sqlMapClient = (SqlMapClientImpl) sqlMapClient;
}
public void initRequest(StatementScope statementScope) {
statementScope.setStatement(this);
statementScope.setParameterMap(parameterMap);
statementScope.setResultMap(resultMap);
statementScope.setSql(sql);
}
public Integer getTimeout() {
return timeout;
}
public void setTimeout(Integer timeout) {
this.timeout = timeout;
}
public void addResultMap(ResultMap resultMap) {
List resultMapList = Arrays.asList(additionalResultMaps);
resultMapList = new ArrayList(resultMapList);
resultMapList.add(resultMap);
additionalResultMaps = (ResultMap[])resultMapList.toArray(new ResultMap[resultMapList.size()]);
}
public boolean hasMultipleResultMaps() {
return additionalResultMaps.length > 0;
}
public ResultMap[] getAdditionalResultMaps() {
return additionalResultMaps;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/PaginatedDataList.java 0000644 0001750 0001750 00000015663 11047641640 027513 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.statement;
import com.ibatis.common.util.PaginatedList;
import com.ibatis.sqlmap.client.SqlMapExecutor;
import java.sql.SQLException;
import java.util.*;
/**
* @deprecated All paginated list features have been deprecated
*/
public class PaginatedDataList implements PaginatedList {
private SqlMapExecutor sqlMapExecutor;
private String statementName;
private Object parameterObject;
private int pageSize;
private int index;
private List prevPageList;
private List currentPageList;
private List nextPageList;
public PaginatedDataList(SqlMapExecutor sqlMapExecutor, String statementName, Object parameterObject, int pageSize)
throws SQLException {
this.sqlMapExecutor = sqlMapExecutor;
this.statementName = statementName;
this.parameterObject = parameterObject;
this.pageSize = pageSize;
this.index = 0;
pageTo(0);
}
private void pageForward() {
try {
prevPageList = currentPageList;
currentPageList = nextPageList;
nextPageList = getList(index + 1, pageSize);
} catch (SQLException e) {
throw new RuntimeException("Unexpected error while repaginating paged list. Cause: " + e, e);
}
}
private void pageBack() {
try {
nextPageList = currentPageList;
currentPageList = prevPageList;
if (index > 0) {
prevPageList = getList(index - 1, pageSize);
} else {
prevPageList = new ArrayList();
}
} catch (SQLException e) {
throw new RuntimeException("Unexpected error while repaginating paged list. Cause: " + e, e);
}
}
private void safePageTo(int idx) {
try {
pageTo(idx);
} catch (SQLException e) {
throw new RuntimeException("Unexpected error while repaginating paged list. Cause: " + e, e);
}
}
public void pageTo(int idx) throws SQLException {
index = idx;
List list;
if (idx < 1) {
list = getList(idx, pageSize * 2);
} else {
list = getList(idx - 1, pageSize * 3);
}
if (list.size() < 1) {
prevPageList = new ArrayList(0);
currentPageList = new ArrayList(0);
nextPageList = new ArrayList(0);
} else {
if (idx < 1) {
prevPageList = new ArrayList(0);
if (list.size() <= pageSize) {
currentPageList = list.subList(0, list.size());
nextPageList = new ArrayList(0);
} else {
currentPageList = list.subList(0, pageSize);
nextPageList = list.subList(pageSize, list.size());
}
} else {
if (list.size() <= pageSize) {
prevPageList = list.subList(0, list.size());
currentPageList = new ArrayList(0);
nextPageList = new ArrayList(0);
} else if (list.size() <= pageSize * 2) {
prevPageList = list.subList(0, pageSize);
currentPageList = list.subList(pageSize, list.size());
nextPageList = new ArrayList(0);
} else {
prevPageList = list.subList(0, pageSize);
currentPageList = list.subList(pageSize, pageSize * 2);
nextPageList = list.subList(pageSize * 2, list.size());
}
}
}
}
private List getList(int idx, int localPageSize) throws SQLException {
return sqlMapExecutor.queryForList(statementName, parameterObject, (idx) * pageSize, localPageSize);
}
public boolean nextPage() {
if (isNextPageAvailable()) {
index++;
pageForward();
return true;
} else {
return false;
}
}
public boolean previousPage() {
if (isPreviousPageAvailable()) {
index--;
pageBack();
return true;
} else {
return false;
}
}
public void gotoPage(int pageNumber) {
safePageTo(pageNumber);
}
public int getPageSize() {
return pageSize;
}
public boolean isFirstPage() {
return index == 0;
}
public boolean isMiddlePage() {
return !(isFirstPage() || isLastPage());
}
public boolean isLastPage() {
return nextPageList.size() < 1;
}
public boolean isNextPageAvailable() {
return nextPageList.size() > 0;
}
public boolean isPreviousPageAvailable() {
return prevPageList.size() > 0;
}
public int size() {
return currentPageList.size();
}
public boolean isEmpty() {
return currentPageList.isEmpty();
}
public boolean contains(Object o) {
return currentPageList.contains(o);
}
public Iterator iterator() {
return currentPageList.iterator();
}
public Object[] toArray() {
return currentPageList.toArray();
}
public Object[] toArray(Object a[]) {
return currentPageList.toArray(a);
}
public boolean containsAll(Collection c) {
return currentPageList.containsAll(c);
}
public Object get(int index) {
return currentPageList.get(index);
}
public int indexOf(Object o) {
return currentPageList.indexOf(o);
}
public int lastIndexOf(Object o) {
return currentPageList.lastIndexOf(o);
}
public ListIterator listIterator() {
return currentPageList.listIterator();
}
public ListIterator listIterator(int index) {
return currentPageList.listIterator(index);
}
public List subList(int fromIndex, int toIndex) {
return currentPageList.subList(fromIndex, toIndex);
}
public boolean add(Object o) {
return currentPageList.add(o);
}
public boolean remove(Object o) {
return currentPageList.remove(o);
}
public boolean addAll(Collection c) {
return currentPageList.addAll(c);
}
public boolean addAll(int index, Collection c) {
return currentPageList.addAll(index, c);
}
public boolean removeAll(Collection c) {
return currentPageList.removeAll(c);
}
public boolean retainAll(Collection c) {
return currentPageList.retainAll(c);
}
public void clear() {
currentPageList.clear();
}
public Object set(int index, Object element) {
return currentPageList.set(index, element);
}
public void add(int index, Object element) {
currentPageList.add(index, element);
}
public Object remove(int index) {
return currentPageList.remove(index);
}
public int getPageIndex() {
return index;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/ProcedureStatement.java 0000644 0001750 0001750 00000003650 11047641640 027777 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.statement;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import java.sql.Connection;
import java.sql.SQLException;
public class ProcedureStatement extends MappedStatement {
protected void postProcessParameterObject(StatementScope statementScope, Object parameterObject, Object[] parameters) {
statementScope.getParameterMap().refreshParameterObjectValues(statementScope, parameterObject, parameters);
}
protected int sqlExecuteUpdate(StatementScope statementScope, Connection conn, String sqlString, Object[] parameters) throws SQLException {
if (statementScope.getSession().isInBatch()) {
getSqlExecutor().addBatch(statementScope, conn, sqlString, parameters);
return 0;
} else {
return getSqlExecutor().executeUpdateProcedure(statementScope, conn, sqlString.trim(), parameters);
}
}
protected void sqlExecuteQuery(StatementScope statementScope, Connection conn, String sqlString, Object[] parameters, int skipResults, int maxResults, RowHandlerCallback callback) throws SQLException {
getSqlExecutor().executeQueryProcedure(statementScope, conn, sqlString.trim(), parameters, skipResults, maxResults, callback);
}
public StatementType getStatementType() {
return StatementType.PROCEDURE;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/RowHandlerCallback.java 0000644 0001750 0001750 00000006551 11047641640 027647 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.statement;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.type.XmlTypeMarker;
import org.w3c.dom.Document;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.StringWriter;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Class to manager row handler access
*/
public class RowHandlerCallback {
private RowHandler rowHandler;
private ResultMap resultMap;
private Object resultObject;
/**
* Constructor
*
* @param resultMap - the result map
* @param resultObject - the result object
* @param rowHandler - the row handler object
*/
public RowHandlerCallback(ResultMap resultMap, Object resultObject, RowHandler rowHandler) {
this.rowHandler = rowHandler;
this.resultMap = resultMap;
this.resultObject = resultObject;
}
/**
* Prepares the row object, and passes it to the row handler
*
* @param statementScope - the request scope
* @param results - the result data
*/
public void handleResultObject(StatementScope statementScope, Object[] results, ResultSet rs) throws SQLException {
Object object;
statementScope.setCurrentNestedKey(null);
object = resultMap.resolveSubMap(statementScope, rs).setResultObjectValues(statementScope, resultObject, results);
if (object != ResultMap.NO_VALUE) {
// XML Only special processing. (converts elements to string for easy insertion).
int stackDepth = statementScope.getSession().getRequestStackDepth();
if (stackDepth == 1) {
Class targetType = statementScope.getResultMap().getResultClass();
if (XmlTypeMarker.class.isAssignableFrom(targetType)
&& object instanceof Document) {
object = documentToString((Document) object);
}
}
rowHandler.handleRow(object);
}
}
private String documentToString(Document document) {
String s = null;
try {
TransformerFactory tFactory = TransformerFactory.newInstance();
Transformer transformer = tFactory.newTransformer();
DOMSource source = new DOMSource(document);
StringWriter writer = new StringWriter();
StreamResult result = new StreamResult(writer);
transformer.transform(source, result);
s = writer.getBuffer().toString();
} catch (TransformerException e) {
throw new RuntimeException("Error occurred. Cause: " + e, e);
}
return s;
}
public RowHandler getRowHandler() {
return rowHandler;
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/SelectKeyStatement.java 0000644 0001750 0001750 00000003541 11047641640 027736 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.statement;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import java.sql.SQLException;
import java.util.List;
public class SelectKeyStatement extends SelectStatement {
private String keyProperty;
private boolean runAfterSQL;
public String getKeyProperty() {
return keyProperty;
}
public void setKeyProperty(String keyProperty) {
this.keyProperty = keyProperty;
}
public boolean isRunAfterSQL() {
return runAfterSQL;
}
public void setRunAfterSQL(boolean runAfterSQL) {
this.runAfterSQL = runAfterSQL;
}
public List executeQueryForList(StatementScope statementScope, Transaction trans, Object parameterObject, int skipResults, int maxResults)
throws SQLException {
throw new SQLException("Select Key statements cannot be executed for a list.");
}
public void executeQueryWithRowHandler(StatementScope statementScope, Transaction trans, Object parameterObject, RowHandler rowHandler)
throws SQLException {
throw new SQLException("Select Key statements cannot be executed with a row handler.");
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/SelectStatement.java 0000644 0001750 0001750 00000002251 11047641640 027262 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.statement;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import java.sql.SQLException;
public class SelectStatement extends MappedStatement {
public StatementType getStatementType() {
return StatementType.SELECT;
}
public int executeUpdate(StatementScope statementScope, Transaction trans, Object parameterObject)
throws SQLException {
throw new SQLException("Select statements cannot be executed as an update.");
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/StatementType.java 0000644 0001750 0001750 00000001034 11047641640 026762 0 ustar twerner twerner package com.ibatis.sqlmap.engine.mapping.statement;
public final class StatementType {
public static final StatementType UNKNOWN = new StatementType();
public static final StatementType INSERT = new StatementType();
public static final StatementType UPDATE = new StatementType();
public static final StatementType DELETE = new StatementType();
public static final StatementType SELECT = new StatementType();
public static final StatementType PROCEDURE = new StatementType();
private StatementType() {
}
}
ibatis/src/com/ibatis/sqlmap/engine/mapping/statement/UpdateStatement.java 0000644 0001750 0001750 00000003427 11047641640 027273 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.mapping.statement;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import java.sql.SQLException;
import java.util.List;
public class UpdateStatement extends MappedStatement {
public StatementType getStatementType() {
return StatementType.UPDATE;
}
public Object executeQueryForObject(StatementScope statementScope, Transaction trans, Object parameterObject, Object resultObject)
throws SQLException {
throw new SQLException("Update statements cannot be executed as a query.");
}
public List executeQueryForList(StatementScope statementScope, Transaction trans, Object parameterObject, int skipResults, int maxResults)
throws SQLException {
throw new SQLException("Update statements cannot be executed as a query.");
}
public void executeQueryWithRowHandler(StatementScope statementScope, Transaction trans, Object parameterObject, RowHandler rowHandler)
throws SQLException {
throw new SQLException("Update statements cannot be executed as a query.");
}
}
ibatis/src/com/ibatis/sqlmap/engine/scope/ 0000755 0001750 0001750 00000000000 11047641632 020766 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/scope/ErrorContext.java 0000644 0001750 0001750 00000007311 11047641632 024271 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.scope;
/**
* An error context to help us create meaningful error messages
*/
public class ErrorContext {
private String resource;
private String activity;
private String objectId;
private String moreInfo;
private Throwable cause;
/**
* Getter for the resource causing the problem
*
* @return - the resource
*/
public String getResource() {
return resource;
}
/**
* Setter for the resource causing the problem
*
* @param resource - the resource
*/
public void setResource(String resource) {
this.resource = resource;
}
/**
* Getter for the activity that was happening when the error happened
*
* @return - the activity
*/
public String getActivity() {
return activity;
}
/**
* Getter for the activity that was happening when the error happened
*
* @param activity - the activity
*/
public void setActivity(String activity) {
this.activity = activity;
}
/**
* Getter for the object ID where the problem happened
*
* @return - the object id
*/
public String getObjectId() {
return objectId;
}
/**
* Setter for the object ID where the problem happened
*
* @param objectId - the object id
*/
public void setObjectId(String objectId) {
this.objectId = objectId;
}
/**
* Getter for more information about the error
*
* @return - more information
*/
public String getMoreInfo() {
return moreInfo;
}
/**
* Setter for more information about the error
*
* @param moreInfo - more information
*/
public void setMoreInfo(String moreInfo) {
this.moreInfo = moreInfo;
}
/**
* Getter for the cause of the error
*
* @return - the cause
*/
public Throwable getCause() {
return cause;
}
/**
* Setter for the cause of the error
*
* @param cause - the cause
*/
public void setCause(Throwable cause) {
this.cause = cause;
}
public String toString() {
StringBuffer message = new StringBuffer();
// resource
if (resource != null) {
message.append(" \n--- The error occurred in ");
message.append(resource);
message.append(".");
}
// activity
if (activity != null) {
message.append(" \n--- The error occurred while ");
message.append(activity);
message.append(".");
}
// object
if (objectId != null) {
message.append(" \n--- Check the ");
message.append(objectId);
message.append(".");
}
// more info
if (moreInfo != null) {
message.append(" \n--- ");
message.append(moreInfo);
}
// cause
if (cause != null) {
message.append(" \n--- Cause: ");
message.append(cause.toString());
}
return message.toString();
}
/**
* Clear the error context
*/
public void reset() {
resource = null;
activity = null;
objectId = null;
moreInfo = null;
cause = null;
}
}
ibatis/src/com/ibatis/sqlmap/engine/scope/SessionScope.java 0000644 0001750 0001750 00000017506 11047641632 024257 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.scope;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapException;
import com.ibatis.sqlmap.client.SqlMapExecutor;
import com.ibatis.sqlmap.client.SqlMapTransactionManager;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import com.ibatis.sqlmap.engine.transaction.TransactionState;
import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
/**
* A Session based implementation of the Scope interface
*/
public class SessionScope {
private static long nextId;
private long id;
// Used by Any
private SqlMapClient sqlMapClient;
private SqlMapExecutor sqlMapExecutor;
private SqlMapTransactionManager sqlMapTxMgr;
private int requestStackDepth;
// Used by TransactionManager
private Transaction transaction;
private TransactionState transactionState;
// Used by SqlMapExecutorDelegate.setUserProvidedTransaction()
private TransactionState savedTransactionState;
// Used by StandardSqlMapClient and GeneralStatement
private boolean inBatch;
// Used by SqlExecutor
private Object batch;
private boolean commitRequired;
private Map preparedStatements;
/**
* Default constructor
*/
public SessionScope() {
this.preparedStatements = new HashMap();
this.inBatch = false;
this.requestStackDepth = 0;
this.id = getNextId();
}
/**
* Get the SqlMapClient for the session
*
* @return - the SqlMapClient
*/
public SqlMapClient getSqlMapClient() {
return sqlMapClient;
}
/**
* Set the SqlMapClient for the session
*
* @param sqlMapClient - the SqlMapClient
*/
public void setSqlMapClient(SqlMapClient sqlMapClient) {
this.sqlMapClient = sqlMapClient;
}
/**
* Get the SQL executor for the session
*
* @return - the SQL executor
*/
public SqlMapExecutor getSqlMapExecutor() {
return sqlMapExecutor;
}
/**
* Get the SQL executor for the session
*
* @param sqlMapExecutor - the SQL executor
*/
public void setSqlMapExecutor(SqlMapExecutor sqlMapExecutor) {
this.sqlMapExecutor = sqlMapExecutor;
}
/**
* Get the transaction manager
*
* @return - the transaction manager
*/
public SqlMapTransactionManager getSqlMapTxMgr() {
return sqlMapTxMgr;
}
/**
* Set the transaction manager
*
* @param sqlMapTxMgr - the transaction manager
*/
public void setSqlMapTxMgr(SqlMapTransactionManager sqlMapTxMgr) {
this.sqlMapTxMgr = sqlMapTxMgr;
}
/**
* Tells us if we are in batch mode or not
*
* @return - true if we are working with a batch
*/
public boolean isInBatch() {
return inBatch;
}
/**
* Turn batch mode on or off
*
* @param inBatch - the switch
*/
public void setInBatch(boolean inBatch) {
this.inBatch = inBatch;
}
/**
* Getter for the session transaction
*
* @return - the transaction
*/
public Transaction getTransaction() {
return transaction;
}
/**
* Setter for the session transaction
*
* @param transaction - the transaction
*/
public void setTransaction(Transaction transaction) {
this.transaction = transaction;
}
/**
* Getter for the transaction state of the session
*
* @return - the state
*/
public TransactionState getTransactionState() {
return transactionState;
}
/**
* Setter for the transaction state of the session
*
* @param transactionState - the new transaction state
*/
public void setTransactionState(TransactionState transactionState) {
this.transactionState = transactionState;
}
/**
* Getter for the batch of the session
*
* @return - the batch
*/
public Object getBatch() {
return batch;
}
/**
* Stter for the batch of the session
*
* @param batch the new batch
*/
public void setBatch(Object batch) {
this.batch = batch;
}
/**
* Get the request stack depth
*
* @return - the stack depth
*/
public int getRequestStackDepth() {
return requestStackDepth;
}
/**
* Increment the stack depth by one.
*/
public void incrementRequestStackDepth() {
requestStackDepth++;
}
/**
* Decrement the stack depth by one.
*/
public void decrementRequestStackDepth() {
requestStackDepth--;
}
/**
* Getter to tell if a commit is required for the session
*
* @return - true if a commit is required
*/
public boolean isCommitRequired() {
return commitRequired;
}
/**
* Setter to tell the session that a commit is required for the session
*
* @param commitRequired - the flag
*/
public void setCommitRequired(boolean commitRequired) {
this.commitRequired = commitRequired;
}
public boolean hasPreparedStatementFor(String sql) {
return preparedStatements.containsKey(sql);
}
public boolean hasPreparedStatement(PreparedStatement ps) {
return preparedStatements.containsValue(ps);
}
public PreparedStatement getPreparedStatement(String sql) throws SQLException {
if (!hasPreparedStatementFor(sql))
throw new SqlMapException("Could not get prepared statement. This is likely a bug.");
PreparedStatement ps = (PreparedStatement) preparedStatements.get(sql);
return ps;
}
public void putPreparedStatement(SqlMapExecutorDelegate delegate, String sql, PreparedStatement ps) {
if (delegate.isStatementCacheEnabled()) {
if (!isInBatch()) {
if (hasPreparedStatementFor(sql))
throw new SqlMapException("Duplicate prepared statement found. This is likely a bug.");
preparedStatements.put(sql, ps);
}
}
}
public void closePreparedStatements() {
Iterator keys = preparedStatements.keySet().iterator();
while (keys.hasNext()) {
PreparedStatement ps = (PreparedStatement) preparedStatements.get(keys.next());
try {
ps.close();
} catch (Exception e) {
// ignore -- we don't care if this fails at this point.
}
}
preparedStatements.clear();
}
public void cleanup() {
closePreparedStatements();
preparedStatements.clear();
}
public boolean equals(Object parameterObject) {
if (this == parameterObject) return true;
if (!(parameterObject instanceof SessionScope)) return false;
final SessionScope sessionScope = (SessionScope) parameterObject;
if (id != sessionScope.id) return false;
return true;
}
public int hashCode() {
return (int) (id ^ (id >>> 32));
}
/**
* Method to get a unique ID
*
* @return - the new ID
*/
public synchronized static long getNextId() {
return nextId++;
}
/**
* Saves the current transaction state
*/
public void saveTransactionState() {
savedTransactionState = transactionState;
}
/**
* Restores the previously saved transaction state
*/
public void recallTransactionState() {
transactionState = savedTransactionState;
}
}
ibatis/src/com/ibatis/sqlmap/engine/scope/StatementScope.java 0000644 0001750 0001750 00000012173 11047641632 024573 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.scope;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.sql.Sql;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import java.sql.ResultSet;
import java.util.Map;
import java.util.HashMap;
/**
* Request based implementation of Scope interface
*/
public class StatementScope {
// Used by Any
private SessionScope sessionScope;
private ErrorContext errorContext;
private MappedStatement statement;
private ParameterMap parameterMap;
private ResultMap resultMap;
private Sql sql;
// Used by DynamicSql
private ParameterMap dynamicParameterMap;
private String dynamicSql;
// Used by N+1 Select solution
private ResultSet resultSet;
private Map uniqueKeys;
private boolean rowDataFound;
private String currentNestedKey;
public StatementScope(SessionScope sessionScope) {
this.errorContext = new ErrorContext();
this.rowDataFound = true;
this.sessionScope = sessionScope;
}
/**
* @return Returns the currentNestedKey.
*/
public String getCurrentNestedKey() {
return currentNestedKey;
}
/**
* @param currentNestedKey The currentNestedKey to set.
*/
public void setCurrentNestedKey(String currentNestedKey) {
this.currentNestedKey = currentNestedKey;
}
/**
* Get the request's error context
*
* @return - the request's error context
*/
public ErrorContext getErrorContext() {
return errorContext;
}
/**
* Get the session of the request
*
* @return - the session
*/
public SessionScope getSession() {
return sessionScope;
}
/**
* Get the statement for the request
*
* @return - the statement
*/
public MappedStatement getStatement() {
return statement;
}
/**
* Set the statement for the request
*
* @param statement - the statement
*/
public void setStatement(MappedStatement statement) {
this.statement = statement;
}
/**
* Get the parameter map for the request
*
* @return - the parameter map
*/
public ParameterMap getParameterMap() {
return parameterMap;
}
/**
* Set the parameter map for the request
*
* @param parameterMap - the new parameter map
*/
public void setParameterMap(ParameterMap parameterMap) {
this.parameterMap = parameterMap;
}
/**
* Get the result map for the request
*
* @return - the result map
*/
public ResultMap getResultMap() {
return resultMap;
}
/**
* Set the result map for the request
*
* @param resultMap - the result map
*/
public void setResultMap(ResultMap resultMap) {
this.resultMap = resultMap;
}
/**
* Get the SQL for the request
*
* @return - the sql
*/
public Sql getSql() {
return sql;
}
/**
* Set the SQL for the request
*
* @param sql - the sql
*/
public void setSql(Sql sql) {
this.sql = sql;
}
/**
* Get the dynamic parameter for the request
*
* @return - the dynamic parameter
*/
public ParameterMap getDynamicParameterMap() {
return dynamicParameterMap;
}
/**
* Set the dynamic parameter for the request
*
* @param dynamicParameterMap - the dynamic parameter
*/
public void setDynamicParameterMap(ParameterMap dynamicParameterMap) {
this.dynamicParameterMap = dynamicParameterMap;
}
/**
* Get the dynamic SQL for the request
*
* @return - the dynamic SQL
*/
public String getDynamicSql() {
return dynamicSql;
}
/**
* Set the dynamic SQL for the request
*
* @param dynamicSql - the dynamic SQL
*/
public void setDynamicSql(String dynamicSql) {
this.dynamicSql = dynamicSql;
}
public ResultSet getResultSet() {
return resultSet;
}
public void setResultSet(ResultSet resultSet) {
this.resultSet = resultSet;
}
public Map getUniqueKeys(ResultMap map) {
if (uniqueKeys == null) {
return null;
}
return (Map) uniqueKeys.get(map);
}
public void setUniqueKeys(ResultMap map, Map keys) {
if (uniqueKeys == null) {
uniqueKeys = new HashMap();
}
this.uniqueKeys.put(map, keys);
}
public boolean isRowDataFound() {
return rowDataFound;
}
public void setRowDataFound(boolean rowDataFound) {
this.rowDataFound = rowDataFound;
}
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/ 0000755 0001750 0001750 00000000000 11047641632 022202 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/transaction/external/ 0000755 0001750 0001750 00000000000 11047641632 024024 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/transaction/external/ExternalTransaction.java 0000644 0001750 0001750 00000006327 11047641632 030667 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction.external;
import com.ibatis.common.jdbc.logging.ConnectionLogProxy;
import com.ibatis.common.logging.Log;
import com.ibatis.common.logging.LogFactory;
import com.ibatis.sqlmap.engine.transaction.IsolationLevel;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import com.ibatis.sqlmap.engine.transaction.TransactionException;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
public class ExternalTransaction implements Transaction {
private static final Log connectionLog = LogFactory.getLog(Connection.class);
private DataSource dataSource;
private boolean defaultAutoCommit;
private boolean setAutoCommitAllowed;
private Connection connection;
private IsolationLevel isolationLevel = new IsolationLevel();
public ExternalTransaction(DataSource ds, boolean defaultAutoCommit, boolean setAutoCommitAllowed, int isolationLevel) throws TransactionException {
// Check Parameters
dataSource = ds;
if (dataSource == null) {
throw new TransactionException("ExternalTransaction initialization failed. DataSource was null.");
}
this.defaultAutoCommit = defaultAutoCommit;
this.setAutoCommitAllowed = setAutoCommitAllowed;
this.isolationLevel.setIsolationLevel(isolationLevel);
}
private void init() throws SQLException, TransactionException {
// Open JDBC Transaction
connection = dataSource.getConnection();
if (connection == null) {
throw new TransactionException("ExternalTransaction could not start transaction. Cause: The DataSource returned a null connection.");
}
// Isolation Level
isolationLevel.applyIsolationLevel(connection);
// AutoCommit
if (setAutoCommitAllowed) {
if (connection.getAutoCommit() != defaultAutoCommit) {
connection.setAutoCommit(defaultAutoCommit);
}
}
// Debug
if (connectionLog.isDebugEnabled()) {
connection = ConnectionLogProxy.newInstance(connection);
}
}
public void commit() throws SQLException, TransactionException {
}
public void rollback() throws SQLException, TransactionException {
}
public void close() throws SQLException, TransactionException {
if (connection != null) {
try {
isolationLevel.restoreIsolationLevel(connection);
} finally {
connection.close();
connection = null;
}
}
}
public Connection getConnection() throws SQLException, TransactionException {
if (connection == null) {
init();
}
return connection;
}
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/external/ExternalTransactionConfig.java 0000644 0001750 0001750 00000003650 11047641632 032011 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction.external;
import com.ibatis.sqlmap.engine.transaction.*;
import java.sql.SQLException;
import java.util.Properties;
public class ExternalTransactionConfig extends BaseTransactionConfig {
private boolean defaultAutoCommit = false;
private boolean setAutoCommitAllowed = true;
public Transaction newTransaction(int transactionIsolation) throws SQLException, TransactionException {
return new ExternalTransaction(dataSource, defaultAutoCommit, setAutoCommitAllowed, transactionIsolation);
}
public boolean isDefaultAutoCommit() {
return defaultAutoCommit;
}
public void setDefaultAutoCommit(boolean defaultAutoCommit) {
this.defaultAutoCommit = defaultAutoCommit;
}
public boolean isSetAutoCommitAllowed() {
return setAutoCommitAllowed;
}
public void setSetAutoCommitAllowed(boolean setAutoCommitAllowed) {
this.setAutoCommitAllowed = setAutoCommitAllowed;
}
public void setProperties(Properties props) throws SQLException, TransactionException {
String dacProp = props.getProperty("DefaultAutoCommit");
String sacaProp = props.getProperty("SetAutoCommitAllowed");
defaultAutoCommit = "true".equals(dacProp);
setAutoCommitAllowed = "true".equals(sacaProp) || sacaProp == null;
}
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/jdbc/ 0000755 0001750 0001750 00000000000 11047641632 023104 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/transaction/jdbc/JdbcTransaction.java 0000644 0001750 0001750 00000006010 11047641632 027014 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction.jdbc;
import com.ibatis.common.jdbc.logging.ConnectionLogProxy;
import com.ibatis.common.logging.Log;
import com.ibatis.common.logging.LogFactory;
import com.ibatis.sqlmap.engine.transaction.IsolationLevel;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import com.ibatis.sqlmap.engine.transaction.TransactionException;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
public class JdbcTransaction implements Transaction {
private static final Log connectionLog = LogFactory.getLog(Connection.class);
private DataSource dataSource;
private Connection connection;
private IsolationLevel isolationLevel = new IsolationLevel();
public JdbcTransaction(DataSource ds, int isolationLevel) throws TransactionException {
// Check Parameters
dataSource = ds;
if (dataSource == null) {
throw new TransactionException("JdbcTransaction initialization failed. DataSource was null.");
}
this.isolationLevel.setIsolationLevel(isolationLevel);
}
private void init() throws SQLException, TransactionException {
// Open JDBC Transaction
connection = dataSource.getConnection();
if (connection == null) {
throw new TransactionException("JdbcTransaction could not start transaction. Cause: The DataSource returned a null connection.");
}
// Isolation Level
isolationLevel.applyIsolationLevel(connection);
// AutoCommit
if (connection.getAutoCommit()) {
connection.setAutoCommit(false);
}
// Debug
if (connectionLog.isDebugEnabled()) {
connection = ConnectionLogProxy.newInstance(connection);
}
}
public void commit() throws SQLException, TransactionException {
if (connection != null) {
connection.commit();
}
}
public void rollback() throws SQLException, TransactionException {
if (connection != null) {
connection.rollback();
}
}
public void close() throws SQLException, TransactionException {
if (connection != null) {
try {
isolationLevel.restoreIsolationLevel(connection);
} finally {
connection.close();
connection = null;
}
}
}
public Connection getConnection() throws SQLException, TransactionException {
if (connection == null) {
init();
}
return connection;
}
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/jdbc/JdbcTransactionConfig.java 0000644 0001750 0001750 00000002165 11047641632 030151 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction.jdbc;
import com.ibatis.sqlmap.engine.transaction.*;
import java.sql.SQLException;
import java.util.Properties;
public class JdbcTransactionConfig extends BaseTransactionConfig {
public Transaction newTransaction(int transactionIsolation) throws SQLException, TransactionException {
return new JdbcTransaction(dataSource, transactionIsolation);
}
public void setProperties(Properties props) throws SQLException, TransactionException {
}
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/jta/ 0000755 0001750 0001750 00000000000 11047641632 022760 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/transaction/jta/JtaTransaction.java 0000644 0001750 0001750 00000010735 11047641632 026555 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction.jta;
import com.ibatis.common.jdbc.logging.ConnectionLogProxy;
import com.ibatis.common.logging.Log;
import com.ibatis.common.logging.LogFactory;
import com.ibatis.sqlmap.engine.transaction.IsolationLevel;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import com.ibatis.sqlmap.engine.transaction.TransactionException;
import javax.sql.DataSource;
import javax.transaction.Status;
import javax.transaction.UserTransaction;
import java.sql.Connection;
import java.sql.SQLException;
public class JtaTransaction implements Transaction {
private static final Log connectionLog = LogFactory.getLog(Connection.class);
private UserTransaction userTransaction;
private DataSource dataSource;
private Connection connection;
private IsolationLevel isolationLevel = new IsolationLevel();
private boolean commmitted = false;
private boolean newTransaction = false;
public JtaTransaction(UserTransaction utx, DataSource ds, int isolationLevel) throws TransactionException {
// Check parameters
userTransaction = utx;
dataSource = ds;
if (userTransaction == null) {
throw new TransactionException("JtaTransaction initialization failed. UserTransaction was null.");
}
if (dataSource == null) {
throw new TransactionException("JtaTransaction initialization failed. DataSource was null.");
}
this.isolationLevel.setIsolationLevel(isolationLevel);
}
private void init() throws TransactionException, SQLException {
// Start JTA Transaction
try {
newTransaction = userTransaction.getStatus() == Status.STATUS_NO_TRANSACTION;
if (newTransaction) {
userTransaction.begin();
}
} catch (Exception e) {
throw new TransactionException("JtaTransaction could not start transaction. Cause: ", e);
}
// Open JDBC Connection
connection = dataSource.getConnection();
if (connection == null) {
throw new TransactionException("JtaTransaction could not start transaction. Cause: The DataSource returned a null connection.");
}
// Isolation Level
isolationLevel.applyIsolationLevel(connection);
// AutoCommit
if (connection.getAutoCommit()) {
connection.setAutoCommit(false);
}
// Debug
if (connectionLog.isDebugEnabled()) {
connection = ConnectionLogProxy.newInstance(connection);
}
}
public void commit() throws SQLException, TransactionException {
if (connection != null) {
if (commmitted) {
throw new TransactionException("JtaTransaction could not commit because this transaction has already been committed.");
}
try {
if (newTransaction) {
userTransaction.commit();
}
} catch (Exception e) {
throw new TransactionException("JtaTransaction could not commit. Cause: ", e);
}
commmitted = true;
}
}
public void rollback() throws SQLException, TransactionException {
if (connection != null) {
if (!commmitted) {
try {
if (userTransaction != null) {
if (newTransaction) {
userTransaction.rollback();
} else {
userTransaction.setRollbackOnly();
}
}
} catch (Exception e) {
throw new TransactionException("JtaTransaction could not rollback. Cause: ", e);
}
}
}
}
public void close() throws SQLException, TransactionException {
if (connection != null) {
try {
isolationLevel.restoreIsolationLevel(connection);
} finally {
connection.close();
connection = null;
}
}
}
public Connection getConnection() throws SQLException, TransactionException {
if (connection == null) {
init();
}
return connection;
}
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/jta/JtaTransactionConfig.java 0000644 0001750 0001750 00000003571 11047641632 027703 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction.jta;
import com.ibatis.sqlmap.client.*;
import com.ibatis.sqlmap.engine.transaction.*;
import javax.naming.*;
import javax.transaction.UserTransaction;
import java.sql.SQLException;
import java.util.Properties;
public class JtaTransactionConfig extends BaseTransactionConfig {
private UserTransaction userTransaction;
public Transaction newTransaction(int transactionIsolation) throws SQLException, TransactionException {
return new JtaTransaction(userTransaction, dataSource, transactionIsolation);
}
public UserTransaction getUserTransaction() {
return userTransaction;
}
public void setUserTransaction(UserTransaction userTransaction) {
this.userTransaction = userTransaction;
}
public void setProperties(Properties props) throws SQLException, TransactionException {
String utxName = null;
try {
utxName = (String) props.get("UserTransaction");
InitialContext initCtx = new InitialContext();
userTransaction = (UserTransaction) initCtx.lookup(utxName);
} catch (NamingException e) {
throw new SqlMapException("Error initializing JtaTransactionConfig while looking up UserTransaction (" + utxName + "). Cause: " + e);
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/user/ 0000755 0001750 0001750 00000000000 11047641632 023160 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/transaction/user/UserProvidedTransaction.java 0000644 0001750 0001750 00000003471 11047641632 030651 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction.user;
import com.ibatis.common.jdbc.logging.ConnectionLogProxy;
import com.ibatis.common.logging.Log;
import com.ibatis.common.logging.LogFactory;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import com.ibatis.sqlmap.engine.transaction.TransactionException;
import java.sql.Connection;
import java.sql.SQLException;
public class UserProvidedTransaction implements Transaction {
private static final Log connectionLog = LogFactory.getLog(Connection.class);
private Connection connection;
public UserProvidedTransaction(Connection connection) {
if (connectionLog.isDebugEnabled()) {
this.connection = ConnectionLogProxy.newInstance(connection);
} else {
this.connection = connection;
}
}
public void commit() throws SQLException, TransactionException {
connection.commit();
}
public void rollback() throws SQLException, TransactionException {
connection.rollback();
}
public void close() throws SQLException, TransactionException {
connection.close();
}
public Connection getConnection() throws SQLException, TransactionException {
return connection;
}
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/BaseTransactionConfig.java 0000644 0001750 0001750 00000003327 11047641632 027260 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction;
import javax.sql.DataSource;
import java.util.Properties;
import java.sql.SQLException;
public abstract class BaseTransactionConfig implements TransactionConfig {
protected DataSource dataSource;
protected boolean forceCommit;
public boolean isForceCommit() {
return forceCommit;
}
public void setForceCommit(boolean forceCommit) {
this.forceCommit = forceCommit;
}
public DataSource getDataSource() {
return dataSource;
}
public void setDataSource(DataSource ds) {
this.dataSource = ds;
}
/**
* @deprecated
* @return -1
*/
public int getMaximumConcurrentTransactions() {
return -1;
}
/**
* @deprecated
* @param maximumConcurrentTransactions - do not use here for Spring integration
*/
public void setMaximumConcurrentTransactions(int maximumConcurrentTransactions) {
}
/**
* @deprecated
* @param props - propertes
*/
public void initialize(Properties props)
throws SQLException, TransactionException {
setProperties(props);
}
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/IsolationLevel.java 0000644 0001750 0001750 00000001677 11047641632 026011 0 ustar twerner twerner package com.ibatis.sqlmap.engine.transaction;
import java.sql.Connection;
import java.sql.SQLException;
public class IsolationLevel {
public static final int UNSET_ISOLATION_LEVEL = -9999;
private int isolationLevel = UNSET_ISOLATION_LEVEL;
private int originalIsolationLevel = UNSET_ISOLATION_LEVEL;
public void setIsolationLevel(int isolationLevel) {
this.isolationLevel = isolationLevel;
}
public void applyIsolationLevel(Connection conn) throws SQLException {
if (isolationLevel != UNSET_ISOLATION_LEVEL) {
originalIsolationLevel = conn.getTransactionIsolation();
if (isolationLevel != originalIsolationLevel) {
conn.setTransactionIsolation(isolationLevel);
}
}
}
public void restoreIsolationLevel(Connection conn) throws SQLException {
if (isolationLevel != originalIsolationLevel) {
conn.setTransactionIsolation(originalIsolationLevel);
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/Transaction.java 0000644 0001750 0001750 00000002044 11047641632 025332 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction;
import java.sql.Connection;
import java.sql.SQLException;
public interface Transaction {
public void commit() throws SQLException, TransactionException;
public void rollback() throws SQLException, TransactionException;
public void close() throws SQLException, TransactionException;
public Connection getConnection() throws SQLException, TransactionException;
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/TransactionConfig.java 0000644 0001750 0001750 00000003461 11047641632 026464 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction;
import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.Properties;
public interface TransactionConfig {
Transaction newTransaction(int transactionIsolation)
throws SQLException, TransactionException;
DataSource getDataSource();
void setDataSource(DataSource ds);
/**
* This should not be used and is here purely to avoid spring integration from breaking
* @deprecated
* @return -1
*/
int getMaximumConcurrentTransactions();
/**
* This should not be used. It does nothing and is here purely to prevent Spring integration from breaking
* @deprecated
* @param maximumConcurrentTransactions
*/
void setMaximumConcurrentTransactions(int maximumConcurrentTransactions);
boolean isForceCommit();
void setForceCommit(boolean forceCommit);
/**
* This method should call setProperties. It is here simply to ease transition
*
* @deprecated
* @param props - Properties
*/
void initialize(Properties props)
throws SQLException, TransactionException;
void setProperties(Properties props)
throws SQLException, TransactionException;
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/TransactionException.java 0000644 0001750 0001750 00000001767 11047641632 027224 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction;
public class TransactionException extends Exception {
public TransactionException() {
}
public TransactionException(String msg) {
super(msg);
}
public TransactionException(Throwable cause) {
super(cause);
}
public TransactionException(String msg, Throwable cause) {
super(msg, cause);
}
}
ibatis/src/com/ibatis/sqlmap/engine/transaction/TransactionManager.java 0000644 0001750 0001750 00000010553 11047641632 026631 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction;
import com.ibatis.sqlmap.engine.scope.SessionScope;
import java.sql.SQLException;
public class TransactionManager {
private TransactionConfig config;
public TransactionManager(TransactionConfig transactionConfig) {
this.config = transactionConfig;
}
public void begin(SessionScope sessionScope) throws SQLException, TransactionException {
begin(sessionScope, IsolationLevel.UNSET_ISOLATION_LEVEL);
}
public void begin(SessionScope sessionScope, int transactionIsolation) throws SQLException, TransactionException {
Transaction trans = sessionScope.getTransaction();
TransactionState state = sessionScope.getTransactionState();
if (state == TransactionState.STATE_STARTED) {
throw new TransactionException("TransactionManager could not start a new transaction. " +
"A transaction is already started.");
} else if (state == TransactionState.STATE_USER_PROVIDED) {
throw new TransactionException("TransactionManager could not start a new transaction. " +
"A user provided connection is currently being used by this session. " +
"The calling .setUserConnection (null) will clear the user provided transaction.");
}
trans = config.newTransaction(transactionIsolation);
sessionScope.setCommitRequired(false);
sessionScope.setTransaction(trans);
sessionScope.setTransactionState(TransactionState.STATE_STARTED);
}
public void commit(SessionScope sessionScope) throws SQLException, TransactionException {
Transaction trans = sessionScope.getTransaction();
TransactionState state = sessionScope.getTransactionState();
if (state == TransactionState.STATE_USER_PROVIDED) {
throw new TransactionException("TransactionManager could not commit. " +
"A user provided connection is currently being used by this session. " +
"You must call the commit() method of the Connection directly. " +
"The calling .setUserConnection (null) will clear the user provided transaction.");
} else if (state != TransactionState.STATE_STARTED && state != TransactionState.STATE_COMMITTED ) {
throw new TransactionException("TransactionManager could not commit. No transaction is started.");
}
if (sessionScope.isCommitRequired() || config.isForceCommit()) {
trans.commit();
sessionScope.setCommitRequired(false);
}
sessionScope.setTransactionState(TransactionState.STATE_COMMITTED);
}
public void end(SessionScope sessionScope) throws SQLException, TransactionException {
Transaction trans = sessionScope.getTransaction();
TransactionState state = sessionScope.getTransactionState();
if (state == TransactionState.STATE_USER_PROVIDED) {
throw new TransactionException("TransactionManager could not end this transaction. " +
"A user provided connection is currently being used by this session. " +
"You must call the rollback() method of the Connection directly. " +
"The calling .setUserConnection (null) will clear the user provided transaction.");
}
try {
if (trans != null) {
try {
if (state != TransactionState.STATE_COMMITTED) {
if (sessionScope.isCommitRequired() || config.isForceCommit()) {
trans.rollback();
sessionScope.setCommitRequired(false);
}
}
} finally {
sessionScope.closePreparedStatements();
trans.close();
}
}
} finally {
sessionScope.setTransaction(null);
sessionScope.setTransactionState(TransactionState.STATE_ENDED);
}
}
public TransactionConfig getConfig() {
return config;
}
} ibatis/src/com/ibatis/sqlmap/engine/transaction/TransactionState.java 0000644 0001750 0001750 00000002064 11047641632 026335 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.transaction;
public class TransactionState {
public static final TransactionState STATE_STARTED = new TransactionState();
public static final TransactionState STATE_COMMITTED = new TransactionState();
public static final TransactionState STATE_ENDED = new TransactionState();
public static final TransactionState STATE_USER_PROVIDED = new TransactionState();
private TransactionState() {
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/ 0000755 0001750 0001750 00000000000 11047641630 020634 5 ustar twerner twerner ibatis/src/com/ibatis/sqlmap/engine/type/BaseTypeHandler.java 0000644 0001750 0001750 00000002010 11047641630 024502 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
/**
* Base type handler for convenience
*/
public abstract class BaseTypeHandler implements TypeHandler {
public boolean equals(Object object, String string) {
if (object == null || string == null) {
return object == string;
} else {
Object castedObject = valueOf(string);
return object.equals(castedObject);
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/BigDecimalTypeHandler.java 0000644 0001750 0001750 00000003672 11047641630 025627 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.math.BigDecimal;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* BigDecimal implementation of TypeHandler
*/
public class BigDecimalTypeHandler extends BaseTypeHandler implements TypeHandler {
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setBigDecimal(i, ((BigDecimal) parameter));
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
Object bigdec = rs.getBigDecimal(columnName);
if (rs.wasNull()) {
return null;
} else {
return bigdec;
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
Object bigdec = rs.getBigDecimal(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return bigdec;
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
Object bigdec = cs.getBigDecimal(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return bigdec;
}
}
public Object valueOf(String s) {
return java.math.BigDecimal.valueOf(Long.valueOf(s).longValue());
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/BlobTypeHandlerCallback.java 0000644 0001750 0001750 00000003277 11047641630 026143 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import com.ibatis.sqlmap.client.extensions.ParameterSetter;
import com.ibatis.sqlmap.client.extensions.ResultGetter;
import com.ibatis.sqlmap.client.extensions.TypeHandlerCallback;
import java.sql.Blob;
import java.sql.SQLException;
import java.sql.Types;
import java.io.ByteArrayInputStream;
public class BlobTypeHandlerCallback implements TypeHandlerCallback {
public Object getResult(ResultGetter getter) throws SQLException {
Blob blob = getter.getBlob();
byte[] returnValue;
if (!getter.wasNull()) {
returnValue = blob.getBytes(1, (int) blob.length());
} else {
returnValue = null;
}
return returnValue;
}
public void setParameter(ParameterSetter setter, Object parameter)
throws SQLException {
if (null != parameter) {
byte[] bytes = (byte[]) parameter;
ByteArrayInputStream bis=new ByteArrayInputStream(bytes);
setter.setBinaryStream(bis,(int)(bytes.length));
} else {
setter.setNull(Types.BLOB);
}
}
public Object valueOf(String s) {
return s;
}
} ibatis/src/com/ibatis/sqlmap/engine/type/BooleanTypeHandler.java 0000644 0001750 0001750 00000003575 11047641630 025230 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Boolean implementation of TypeHandler
*/
public class BooleanTypeHandler extends BaseTypeHandler implements TypeHandler {
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setBoolean(i, ((Boolean) parameter).booleanValue());
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
boolean b = rs.getBoolean(columnName);
if (rs.wasNull()) {
return null;
} else {
return new Boolean(b);
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
boolean b = rs.getBoolean(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return new Boolean(b);
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
boolean b = cs.getBoolean(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return new Boolean(b);
}
}
public Object valueOf(String s) {
return Boolean.valueOf(s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/ByteArrayTypeHandler.java 0000644 0001750 0001750 00000003512 11047641630 025542 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* byte[] implementation of TypeHandler
*/
public class ByteArrayTypeHandler extends BaseTypeHandler implements TypeHandler {
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setBytes(i, (byte[]) parameter);
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
Object bytes = rs.getBytes(columnName);
if (rs.wasNull()) {
return null;
} else {
return bytes;
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
Object bytes = rs.getBytes(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return bytes;
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
Object bytes = cs.getBytes(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return bytes;
}
}
public Object valueOf(String s) {
return s.getBytes();
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/ByteTypeHandler.java 0000644 0001750 0001750 00000003516 11047641630 024547 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Byte implementation of TypeHandler
*/
public class ByteTypeHandler extends BaseTypeHandler implements TypeHandler {
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setByte(i, ((Byte) parameter).byteValue());
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
byte b = rs.getByte(columnName);
if (rs.wasNull()) {
return null;
} else {
return new Byte(b);
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
byte b = rs.getByte(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return new Byte(b);
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
byte b = cs.getByte(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return new Byte(b);
}
}
public Object valueOf(String s) {
return Byte.valueOf(s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/CallableStatementResultSet.java 0000644 0001750 0001750 00000053524 11047641630 026747 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.*;
import java.util.Calendar;
import java.util.Map;
/**
* A way to make a CallableStatement look like a ResultSet
*/
public class CallableStatementResultSet implements ResultSet {
private CallableStatement cs;
/**
* Constructor to stretch a ResultSet interface over a CallableStatement
*
* @param cs - the CallableStatement
*/
public CallableStatementResultSet(CallableStatement cs) {
this.cs = cs;
}
public boolean absolute(int row) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void afterLast() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void beforeFirst() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void cancelRowUpdates() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void clearWarnings() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void close() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void deleteRow() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public int findColumn(String columnName) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean first() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public Array getArray(String colName) throws SQLException {
return cs.getArray(colName);
}
public Array getArray(int i) throws SQLException {
return cs.getArray(i);
}
public InputStream getAsciiStream(int columnIndex) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public InputStream getAsciiStream(String columnName) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
return cs.getBigDecimal(columnIndex);
}
public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public BigDecimal getBigDecimal(String columnName) throws SQLException {
return cs.getBigDecimal(columnName);
}
public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public InputStream getBinaryStream(int columnIndex) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public InputStream getBinaryStream(String columnName) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public Blob getBlob(String colName) throws SQLException {
return cs.getBlob(colName);
}
public Blob getBlob(int i) throws SQLException {
return cs.getBlob(i);
}
public boolean getBoolean(int columnIndex) throws SQLException {
return cs.getBoolean(columnIndex);
}
public boolean getBoolean(String columnName) throws SQLException {
return cs.getBoolean(columnName);
}
public byte getByte(int columnIndex) throws SQLException {
return cs.getByte(columnIndex);
}
public byte getByte(String columnName) throws SQLException {
return cs.getByte(columnName);
}
public byte[] getBytes(int columnIndex) throws SQLException {
return cs.getBytes(columnIndex);
}
public byte[] getBytes(String columnName) throws SQLException {
return cs.getBytes(columnName);
}
public Reader getCharacterStream(int columnIndex) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public Reader getCharacterStream(String columnName) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public Clob getClob(String colName) throws SQLException {
return cs.getClob(colName);
}
public Clob getClob(int i) throws SQLException {
return cs.getClob(i);
}
public int getConcurrency() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public String getCursorName() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public Date getDate(int columnIndex) throws SQLException {
return cs.getDate(columnIndex);
}
public Date getDate(int columnIndex, Calendar cal) throws SQLException {
return cs.getDate(columnIndex, cal);
}
public Date getDate(String columnName) throws SQLException {
return cs.getDate(columnName);
}
public Date getDate(String columnName, Calendar cal) throws SQLException {
return cs.getDate(columnName, cal);
}
public double getDouble(int columnIndex) throws SQLException {
return cs.getDouble(columnIndex);
}
public double getDouble(String columnName) throws SQLException {
return cs.getDouble(columnName);
}
public int getFetchDirection() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public int getFetchSize() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public float getFloat(int columnIndex) throws SQLException {
return cs.getFloat(columnIndex);
}
public float getFloat(String columnName) throws SQLException {
return cs.getFloat(columnName);
}
public int getInt(int columnIndex) throws SQLException {
return cs.getInt(columnIndex);
}
public int getInt(String columnName) throws SQLException {
return cs.getInt(columnName);
}
public long getLong(int columnIndex) throws SQLException {
return cs.getLong(columnIndex);
}
public long getLong(String columnName) throws SQLException {
return cs.getLong(columnName);
}
public ResultSetMetaData getMetaData() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public Object getObject(String colName, Map map) throws SQLException {
return cs.getObject(colName, map);
}
public Object getObject(int columnIndex) throws SQLException {
return cs.getObject(columnIndex);
}
public Object getObject(String columnName) throws SQLException {
return cs.getObject(columnName);
}
public Object getObject(int i, Map map) throws SQLException {
return cs.getObject(i, map);
}
public Ref getRef(String colName) throws SQLException {
return cs.getRef(colName);
}
public Ref getRef(int i) throws SQLException {
return cs.getRef(i);
}
public int getRow() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public short getShort(int columnIndex) throws SQLException {
return cs.getShort(columnIndex);
}
public short getShort(String columnName) throws SQLException {
return cs.getShort(columnName);
}
public Statement getStatement() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public String getString(int columnIndex) throws SQLException {
return cs.getString(columnIndex);
}
public String getString(String columnName) throws SQLException {
return cs.getString(columnName);
}
public Time getTime(int columnIndex) throws SQLException {
return cs.getTime(columnIndex);
}
public Time getTime(int columnIndex, Calendar cal) throws SQLException {
return cs.getTime(columnIndex, cal);
}
public Time getTime(String columnName) throws SQLException {
return cs.getTime(columnName);
}
public Time getTime(String columnName, Calendar cal) throws SQLException {
return cs.getTime(columnName, cal);
}
public Timestamp getTimestamp(int columnIndex) throws SQLException {
return cs.getTimestamp(columnIndex);
}
public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
return cs.getTimestamp(columnIndex, cal);
}
public Timestamp getTimestamp(String columnName) throws SQLException {
return cs.getTimestamp(columnName);
}
public Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException {
return cs.getTimestamp(columnName, cal);
}
public int getType() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public InputStream getUnicodeStream(int columnIndex) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public InputStream getUnicodeStream(String columnName) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public URL getURL(int columnIndex) throws SQLException {
return cs.getURL(columnIndex);
}
public URL getURL(String columnName) throws SQLException {
return cs.getURL(columnName);
}
public SQLWarning getWarnings() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void insertRow() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean isAfterLast() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean isBeforeFirst() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean isFirst() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean isLast() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean last() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void moveToCurrentRow() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void moveToInsertRow() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean next() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean previous() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void refreshRow() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean relative(int rows) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean rowDeleted() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean rowInserted() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean rowUpdated() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void setFetchDirection(int direction) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void setFetchSize(int rows) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateArray(int columnIndex, Array x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateArray(String columnName, Array x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateAsciiStream(String columnName, InputStream x, int length) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateBinaryStream(String columnName, InputStream x, int length) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateBlob(int columnIndex, Blob x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateBlob(String columnName, Blob x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateBoolean(int columnIndex, boolean x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateBoolean(String columnName, boolean x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateByte(int columnIndex, byte x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateByte(String columnName, byte x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateBytes(int columnIndex, byte x[]) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateBytes(String columnName, byte x[]) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateCharacterStream(String columnName, Reader reader, int length) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateClob(int columnIndex, Clob x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateClob(String columnName, Clob x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateDate(int columnIndex, Date x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateDate(String columnName, Date x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateDouble(int columnIndex, double x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateDouble(String columnName, double x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateFloat(int columnIndex, float x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateFloat(String columnName, float x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateInt(int columnIndex, int x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateInt(String columnName, int x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateLong(int columnIndex, long x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateLong(String columnName, long x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateNull(int columnIndex) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateNull(String columnName) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateObject(int columnIndex, Object x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateObject(int columnIndex, Object x, int scale) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateObject(String columnName, Object x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateObject(String columnName, Object x, int scale) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateRef(int columnIndex, Ref x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateRef(String columnName, Ref x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateRow() throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateShort(int columnIndex, short x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateShort(String columnName, short x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateString(int columnIndex, String x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateString(String columnName, String x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateTime(int columnIndex, Time x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateTime(String columnName, Time x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public void updateTimestamp(String columnName, Timestamp x) throws SQLException {
throw new UnsupportedOperationException("CallableStatement does not support this method.");
}
public boolean wasNull() throws SQLException {
return cs.wasNull();
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/ClobTypeHandlerCallback.java 0000644 0001750 0001750 00000003012 11047641630 026127 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import com.ibatis.sqlmap.client.extensions.*;
import java.io.StringReader;
import java.sql.*;
public class ClobTypeHandlerCallback implements TypeHandlerCallback {
public Object getResult(ResultGetter getter)
throws SQLException {
String value;
Clob clob = getter.getClob();
if (!getter.wasNull()) {
int size = (int) clob.length();
value = clob.getSubString(1, size);
} else {
value = null;
}
return value;
}
public void setParameter(ParameterSetter setter, Object parameter)
throws SQLException {
String s = (String) parameter;
if (s != null) {
StringReader reader = new StringReader(s);
setter.setCharacterStream(reader, s.length());
} else {
setter.setNull(Types.CLOB);
}
}
public Object valueOf(String s) {
return s;
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/CustomTypeHandler.java 0000644 0001750 0001750 00000004502 11047641630 025112 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import com.ibatis.sqlmap.client.extensions.ParameterSetter;
import com.ibatis.sqlmap.client.extensions.ResultGetter;
import com.ibatis.sqlmap.client.extensions.TypeHandlerCallback;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Custom type handler for adding a TypeHandlerCallback
*/
public class CustomTypeHandler extends BaseTypeHandler implements TypeHandler {
private TypeHandlerCallback callback;
/**
* Constructor to provide a TypeHandlerCallback instance
*
* @param callback - the TypeHandlerCallback instance
*/
public CustomTypeHandler(TypeHandlerCallback callback) {
this.callback = callback;
}
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ParameterSetter setter = new ParameterSetterImpl(ps, i);
callback.setParameter(setter, parameter);
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
ResultGetter getter = new ResultGetterImpl(rs, columnName);
return callback.getResult(getter);
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
ResultGetter getter = new ResultGetterImpl(rs, columnIndex);
return callback.getResult(getter);
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
ResultGetter getter = new ResultGetterImpl(new CallableStatementResultSet(cs), columnIndex);
return callback.getResult(getter);
}
public Object valueOf(String s) {
return callback.valueOf(s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/DateOnlyTypeHandler.java 0000644 0001750 0001750 00000004127 11047641630 025362 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
/**
* Date only implementation of TypeHandler
*/
public class DateOnlyTypeHandler extends BaseTypeHandler implements TypeHandler {
private static final String DATE_FORMAT = "yyyy/MM/dd";
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setDate(i, new java.sql.Date(((Date) parameter).getTime()));
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
java.sql.Date sqlDate = rs.getDate(columnName);
if (rs.wasNull()) {
return null;
} else {
return new java.util.Date(sqlDate.getTime());
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
java.sql.Date sqlDate = rs.getDate(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return new java.util.Date(sqlDate.getTime());
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
java.sql.Date sqlDate = cs.getDate(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return new java.util.Date(sqlDate.getTime());
}
}
public Object valueOf(String s) {
return SimpleDateFormatter.format(DATE_FORMAT, s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/DateTypeHandler.java 0000644 0001750 0001750 00000004244 11047641630 024520 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
/**
* Date (and time) implementation of TypeHandler
*/
public class DateTypeHandler extends BaseTypeHandler implements TypeHandler {
private static final String DATE_FORMAT = "yyyy/MM/dd hh:mm:ss";
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setTimestamp(i, new java.sql.Timestamp(((Date) parameter).getTime()));
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
java.sql.Timestamp sqlTimestamp = rs.getTimestamp(columnName);
if (rs.wasNull()) {
return null;
} else {
return new java.util.Date(sqlTimestamp.getTime());
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
java.sql.Timestamp sqlTimestamp = rs.getTimestamp(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return new java.util.Date(sqlTimestamp.getTime());
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
java.sql.Timestamp sqlTimestamp = cs.getTimestamp(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return new java.util.Date(sqlTimestamp.getTime());
}
}
public Object valueOf(String s) {
return SimpleDateFormatter.format(DATE_FORMAT, s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/DomCollectionTypeMarker.java 0000644 0001750 0001750 00000001335 11047641630 026240 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
public interface DomCollectionTypeMarker extends DomTypeMarker {
}
ibatis/src/com/ibatis/sqlmap/engine/type/DomTypeMarker.java 0000644 0001750 0001750 00000001275 11047641630 024227 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
public interface DomTypeMarker {
}
ibatis/src/com/ibatis/sqlmap/engine/type/DoubleTypeHandler.java 0000644 0001750 0001750 00000003554 11047641630 025060 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Double implementation of TypeHandler
*/
public class DoubleTypeHandler extends BaseTypeHandler implements TypeHandler {
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setDouble(i, ((Double) parameter).doubleValue());
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
double d = rs.getDouble(columnName);
if (rs.wasNull()) {
return null;
} else {
return new Double(d);
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
double d = rs.getDouble(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return new Double(d);
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
double d = cs.getDouble(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return new Double(d);
}
}
public Object valueOf(String s) {
return Double.valueOf(s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/EnumTypeHandler.java 0000644 0001750 0001750 00000003765 11047641630 024556 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* String implementation of TypeHandler
*/
public class EnumTypeHandler extends BaseTypeHandler implements TypeHandler {
private Class type;
public EnumTypeHandler(Class type) {
this.type = type;
}
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setString(i, parameter.toString());
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
Object s = rs.getString(columnName);
if (rs.wasNull()) {
return null;
} else {
return Enum.valueOf(type, (String)s);
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
Object s = rs.getString(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return Enum.valueOf(type, (String)s);
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
Object s = cs.getString(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return Enum.valueOf(type, (String)s);
}
}
public Object valueOf(String s) {
return Enum.valueOf(type, (String)s);
}
} ibatis/src/com/ibatis/sqlmap/engine/type/FloatTypeHandler.java 0000644 0001750 0001750 00000003535 11047641630 024712 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Float implementation of TypeHandler
*/
public class FloatTypeHandler extends BaseTypeHandler implements TypeHandler {
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setFloat(i, ((Float) parameter).floatValue());
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
float f = rs.getFloat(columnName);
if (rs.wasNull()) {
return null;
} else {
return new Float(f);
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
float f = rs.getFloat(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return new Float(f);
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
float f = cs.getFloat(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return new Float(f);
}
}
public Object valueOf(String s) {
return Float.valueOf(s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/IntegerTypeHandler.java 0000644 0001750 0001750 00000003543 11047641630 025241 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Integer Decimal implementation of TypeHandler
*/
public class IntegerTypeHandler extends BaseTypeHandler implements TypeHandler {
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setInt(i, ((Integer) parameter).intValue());
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
int i = rs.getInt(columnName);
if (rs.wasNull()) {
return null;
} else {
return new Integer(i);
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
int i = rs.getInt(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return new Integer(i);
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
int i = cs.getInt(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return new Integer(i);
}
}
public Object valueOf(String s) {
return Integer.valueOf(s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/JdbcTypeRegistry.java 0000644 0001750 0001750 00000006674 11047641630 024751 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.Types;
import java.util.HashMap;
import java.util.Map;
/**
* Singleton
*/
public class JdbcTypeRegistry {
/**
* Value for the unknown type
*/
public static final int UNKNOWN_TYPE = -99999999;
private static final Map TYPE_MAP = new HashMap();
/**
* Value for a JDBC 3.o datalink type
*/
public final static int JDBC_30_DATALINK = 70;
/**
* Value for a JDBC 3.o boolean type
*/
public final static int JDBC_30_BOOLEAN = 16;
static {
initializeTypes();
}
private JdbcTypeRegistry() {
}
public static void setType(String name, int value) {
TYPE_MAP.put(name, new Integer(value));
}
/**
* Looks up a type by name, and returns it's int value (from java.sql.Types)
*
* @param name - the type name
*
* @return - the int value (from java.sql.Types)
*/
public static int getType(String name) {
if (name == null)
return UNKNOWN_TYPE;
Integer i = (Integer) TYPE_MAP.get(name);
if (i != null) {
return i.intValue();
} else {
return UNKNOWN_TYPE;
}
}
private static void initializeTypes() {
setType("ARRAY", Types.ARRAY);
setType("BIGINT", Types.BIGINT);
setType("BINARY", Types.BINARY);
setType("BIT", Types.BIT);
setType("BLOB", Types.BLOB);
setType("BOOLEAN", JDBC_30_BOOLEAN);
setType("CHAR", Types.CHAR);
setType("CLOB", Types.CLOB);
setType("DATALINK", JDBC_30_DATALINK);
setType("DATE", Types.DATE);
setType("DECIMAL", Types.DECIMAL);
setType("DISTINCT", Types.DISTINCT);
setType("DOUBLE", Types.DOUBLE);
setType("FLOAT", Types.FLOAT);
setType("INTEGER", Types.INTEGER);
setType("JAVA_OBJECT", Types.JAVA_OBJECT);
setType("LONGVARBINARY", Types.LONGVARBINARY);
setType("LONGVARCHAR", Types.LONGVARCHAR);
setType("NULL", Types.NULL);
setType("NUMERIC", Types.NUMERIC);
setType("OTHER", Types.OTHER);
setType("REAL", Types.REAL);
setType("REF", Types.REF);
setType("SMALLINT", Types.SMALLINT);
setType("STRUCT", Types.STRUCT);
setType("TIME", Types.TIME);
setType("TIMESTAMP", Types.TIMESTAMP);
setType("TINYINT", Types.TINYINT);
setType("VARBINARY", Types.VARBINARY);
setType("VARCHAR", Types.VARCHAR);
setType("CH", Types.CHAR);
setType("VC", Types.VARCHAR);
setType("DT", Types.DATE);
setType("TM", Types.TIME);
setType("TS", Types.TIMESTAMP);
setType("NM", Types.NUMERIC);
setType("II", Types.INTEGER);
setType("BI", Types.BIGINT);
setType("SI", Types.SMALLINT);
setType("TI", Types.TINYINT);
setType("DC", Types.DECIMAL);
setType("DB", Types.DOUBLE);
setType("FL", Types.FLOAT);
setType("ORACLECURSOR", -10);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/LongTypeHandler.java 0000644 0001750 0001750 00000003516 11047641630 024543 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Long implementation of TypeHandler
*/
public class LongTypeHandler extends BaseTypeHandler implements TypeHandler {
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setLong(i, ((Long) parameter).longValue());
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
long l = rs.getLong(columnName);
if (rs.wasNull()) {
return null;
} else {
return new Long(l);
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
long l = rs.getLong(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return new Long(l);
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
long l = cs.getLong(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return new Long(l);
}
}
public Object valueOf(String s) {
return Long.valueOf(s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/ObjectTypeHandler.java 0000644 0001750 0001750 00000003475 11047641630 025056 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Object implementation of TypeHandler
*/
public class ObjectTypeHandler extends BaseTypeHandler implements TypeHandler {
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setObject(i, parameter);
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
Object object = rs.getObject(columnName);
if (rs.wasNull()) {
return null;
} else {
return object;
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
Object object = rs.getObject(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return object;
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
Object object = cs.getObject(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return object;
}
}
public Object valueOf(String s) {
return s;
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/ParameterSetterImpl.java 0000644 0001750 0001750 00000010531 11047641630 025430 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import com.ibatis.sqlmap.client.extensions.ParameterSetter;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.*;
import java.util.Calendar;
/**
* A ParameterSetter implementation
*/
public class ParameterSetterImpl implements ParameterSetter {
private PreparedStatement ps;
private int index;
/**
* Creates an instance for a PreparedStatement and column index
*
* @param statement - the PreparedStatement
* @param columnIndex - the column index
*/
public ParameterSetterImpl(PreparedStatement statement, int columnIndex) {
this.ps = statement;
this.index = columnIndex;
}
public void setArray(Array x) throws SQLException {
ps.setArray(index, x);
}
public void setAsciiStream(InputStream x, int length) throws SQLException {
ps.setAsciiStream(index, x, length);
}
public void setBigDecimal(BigDecimal x) throws SQLException {
ps.setBigDecimal(index, x);
}
public void setBinaryStream(InputStream x, int length) throws SQLException {
ps.setBinaryStream(index, x, length);
}
public void setBlob(Blob x) throws SQLException {
ps.setBlob(index, x);
}
public void setBoolean(boolean x) throws SQLException {
ps.setBoolean(index, x);
}
public void setByte(byte x) throws SQLException {
ps.setByte(index, x);
}
public void setBytes(byte x[]) throws SQLException {
ps.setBytes(index, x);
}
public void setCharacterStream(Reader reader, int length) throws SQLException {
ps.setCharacterStream(index, reader, length);
}
public void setClob(Clob x) throws SQLException {
ps.setClob(index, x);
}
public void setDate(Date x) throws SQLException {
ps.setDate(index, x);
}
public void setDate(Date x, Calendar cal) throws SQLException {
ps.setDate(index, x, cal);
}
public void setDouble(double x) throws SQLException {
ps.setDouble(index, x);
}
public void setFloat(float x) throws SQLException {
ps.setFloat(index, x);
}
public void setInt(int x) throws SQLException {
ps.setInt(index, x);
}
public void setLong(long x) throws SQLException {
ps.setLong(index, x);
}
public void setNull(int sqlType) throws SQLException {
ps.setNull(index, sqlType);
}
public void setNull(int sqlType, String typeName) throws SQLException {
ps.setNull(index, sqlType, typeName);
}
public void setObject(Object x) throws SQLException {
ps.setObject(index, x);
}
public void setObject(Object x, int targetSqlType) throws SQLException {
ps.setObject(index, x, targetSqlType);
}
public void setObject(Object x, int targetSqlType, int scale) throws SQLException {
ps.setObject(index, x, scale);
}
public void setRef(Ref x) throws SQLException {
ps.setRef(index, x);
}
public void setShort(short x) throws SQLException {
ps.setShort(index, x);
}
public void setString(String x) throws SQLException {
ps.setString(index, x);
}
public void setTime(Time x) throws SQLException {
ps.setTime(index, x);
}
public void setTime(Time x, Calendar cal) throws SQLException {
ps.setTime(index, x, cal);
}
public void setTimestamp(Timestamp x) throws SQLException {
ps.setTimestamp(index, x);
}
public void setTimestamp(Timestamp x, Calendar cal) throws SQLException {
ps.setTimestamp(index, x, cal);
}
public void setURL(URL x) throws SQLException {
ps.setURL(index, x);
}
public PreparedStatement getPreparedStatement() {
return ps;
}
public int getParameterIndex() {
return index;
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/ResultGetterImpl.java 0000644 0001750 0001750 00000013364 11047641630 024761 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import com.ibatis.sqlmap.client.extensions.ResultGetter;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.*;
import java.util.Calendar;
import java.util.Map;
/**
* A ResultGetter implementation
*/
public class ResultGetterImpl implements ResultGetter {
private ResultSet rs;
private String name;
private int index;
/**
* Creates an instance for a PreparedStatement and column index
*
* @param resultSet - the result set
* @param columnIndex - the column index
*/
public ResultGetterImpl(ResultSet resultSet, int columnIndex) {
this.rs = resultSet;
this.index = columnIndex;
}
/**
* Creates an instance for a PreparedStatement and column name
*
* @param resultSet - the result set
* @param columnName - the column index
*/
public ResultGetterImpl(ResultSet resultSet, String columnName) {
this.rs = resultSet;
this.name = columnName;
}
public Array getArray() throws SQLException {
if (name != null) {
return rs.getArray(name);
} else {
return rs.getArray(index);
}
}
public BigDecimal getBigDecimal() throws SQLException {
if (name != null) {
return rs.getBigDecimal(name);
} else {
return rs.getBigDecimal(index);
}
}
public Blob getBlob() throws SQLException {
if (name != null) {
return rs.getBlob(name);
} else {
return rs.getBlob(index);
}
}
public boolean getBoolean() throws SQLException {
if (name != null) {
return rs.getBoolean(name);
} else {
return rs.getBoolean(index);
}
}
public byte getByte() throws SQLException {
if (name != null) {
return rs.getByte(name);
} else {
return rs.getByte(index);
}
}
public byte[] getBytes() throws SQLException {
if (name != null) {
return rs.getBytes(name);
} else {
return rs.getBytes(index);
}
}
public Clob getClob() throws SQLException {
if (name != null) {
return rs.getClob(name);
} else {
return rs.getClob(index);
}
}
public Date getDate() throws SQLException {
if (name != null) {
return rs.getDate(name);
} else {
return rs.getDate(index);
}
}
public Date getDate(Calendar cal) throws SQLException {
if (name != null) {
return rs.getDate(name, cal);
} else {
return rs.getDate(index, cal);
}
}
public double getDouble() throws SQLException {
if (name != null) {
return rs.getDouble(name);
} else {
return rs.getDouble(index);
}
}
public float getFloat() throws SQLException {
if (name != null) {
return rs.getFloat(name);
} else {
return rs.getFloat(index);
}
}
public int getInt() throws SQLException {
if (name != null) {
return rs.getInt(name);
} else {
return rs.getInt(index);
}
}
public long getLong() throws SQLException {
if (name != null) {
return rs.getLong(name);
} else {
return rs.getLong(index);
}
}
public Object getObject() throws SQLException {
if (name != null) {
return rs.getObject(name);
} else {
return rs.getObject(index);
}
}
public Object getObject(Map map) throws SQLException {
if (name != null) {
return rs.getObject(name, map);
} else {
return rs.getObject(index, map);
}
}
public Ref getRef() throws SQLException {
if (name != null) {
return rs.getRef(name);
} else {
return rs.getRef(index);
}
}
public short getShort() throws SQLException {
if (name != null) {
return rs.getShort(name);
} else {
return rs.getShort(index);
}
}
public String getString() throws SQLException {
if (name != null) {
return rs.getString(name);
} else {
return rs.getString(index);
}
}
public Time getTime() throws SQLException {
if (name != null) {
return rs.getTime(name);
} else {
return rs.getTime(index);
}
}
public Time getTime(Calendar cal) throws SQLException {
if (name != null) {
return rs.getTime(name);
} else {
return rs.getTime(index);
}
}
public Timestamp getTimestamp() throws SQLException {
if (name != null) {
return rs.getTimestamp(name);
} else {
return rs.getTimestamp(index);
}
}
public Timestamp getTimestamp(Calendar cal) throws SQLException {
if (name != null) {
return rs.getTimestamp(name, cal);
} else {
return rs.getTimestamp(index, cal);
}
}
public URL getURL() throws SQLException {
if (name != null) {
return rs.getURL(name);
} else {
return rs.getURL(index);
}
}
public boolean wasNull() throws SQLException {
return rs.wasNull();
}
public ResultSet getResultSet() {
return rs;
}
public int getColumnIndex() {
return index;
}
public String getColumnName() {
return name;
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/ShortTypeHandler.java 0000644 0001750 0001750 00000003535 11047641630 024744 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Short implementation of TypeHandler
*/
public class ShortTypeHandler extends BaseTypeHandler implements TypeHandler {
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setShort(i, ((Short) parameter).shortValue());
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
short s = rs.getShort(columnName);
if (rs.wasNull()) {
return null;
} else {
return new Short(s);
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
short s = rs.getShort(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return new Short(s);
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
short s = cs.getShort(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return new Short(s);
}
}
public Object valueOf(String s) {
return Short.valueOf(s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/SimpleDateFormatter.java 0000644 0001750 0001750 00000001025 11047641630 025410 0 ustar twerner twerner package com.ibatis.sqlmap.engine.type;
import com.ibatis.sqlmap.client.SqlMapException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatter {
public static Date format(String format, String datetime) {
try {
return new SimpleDateFormat(format).parse(datetime);
} catch (ParseException e) {
throw new SqlMapException("Error parsing default null value date. Format must be '" + format + "'. Cause: " + e);
}
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/SqlDateTypeHandler.java 0000644 0001750 0001750 00000003664 11047641630 025205 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* SQL Date implementation of TypeHandler
*/
public class SqlDateTypeHandler extends BaseTypeHandler implements TypeHandler {
private static final String DATE_FORMAT = "yyyy/MM/dd";
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setDate(i, (java.sql.Date) parameter);
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
Object sqlDate = rs.getDate(columnName);
if (rs.wasNull()) {
return null;
} else {
return sqlDate;
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
Object sqlDate = rs.getDate(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return sqlDate;
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
Object sqlDate = cs.getDate(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return sqlDate;
}
}
public Object valueOf(String s) {
return SimpleDateFormatter.format(DATE_FORMAT, s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/SqlTimestampTypeHandler.java 0000644 0001750 0001750 00000003776 11047641630 026277 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* SQL timestamp implementation of TypeHandler
*/
public class SqlTimestampTypeHandler extends BaseTypeHandler implements TypeHandler {
private static final String DATE_FORMAT = "yyyy/MM/dd hh:mm:ss";
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setTimestamp(i, (java.sql.Timestamp) parameter);
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
Object sqlTimestamp = rs.getTimestamp(columnName);
if (rs.wasNull()) {
return null;
} else {
return sqlTimestamp;
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
Object sqlTimestamp = rs.getTimestamp(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return sqlTimestamp;
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
Object sqlTimestamp = cs.getTimestamp(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return sqlTimestamp;
}
}
public Object valueOf(String s) {
return SimpleDateFormatter.format(DATE_FORMAT, s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/SqlTimeTypeHandler.java 0000644 0001750 0001750 00000003662 11047641630 025224 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* SQL time implementation of TypeHandler
*/
public class SqlTimeTypeHandler extends BaseTypeHandler implements TypeHandler {
private static final String DATE_FORMAT = "hh:mm:ss";
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setTime(i, (java.sql.Time) parameter);
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
Object sqlTime = rs.getTime(columnName);
if (rs.wasNull()) {
return null;
} else {
return sqlTime;
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
Object sqlTime = rs.getTime(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return sqlTime;
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
Object sqlTime = cs.getTime(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return sqlTime;
}
}
public Object valueOf(String s) {
return SimpleDateFormatter.format(DATE_FORMAT, s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/StringTypeHandler.java 0000644 0001750 0001750 00000003452 11047641630 025111 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* String implementation of TypeHandler
*/
public class StringTypeHandler extends BaseTypeHandler implements TypeHandler {
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setString(i, ((String) parameter));
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
Object s = rs.getString(columnName);
if (rs.wasNull()) {
return null;
} else {
return s;
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
Object s = rs.getString(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return s;
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
Object s = cs.getString(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return s;
}
}
public Object valueOf(String s) {
return s;
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/TimeOnlyTypeHandler.java 0000644 0001750 0001750 00000004123 11047641630 025377 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
/**
* Time (only) implementation of TypeHandler
*/
public class TimeOnlyTypeHandler extends BaseTypeHandler implements TypeHandler {
private static final String DATE_FORMAT = "hh:mm:ss";
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
ps.setTime(i, new java.sql.Time(((Date) parameter).getTime()));
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
java.sql.Time sqlTime = rs.getTime(columnName);
if (rs.wasNull()) {
return null;
} else {
return new java.util.Date(sqlTime.getTime());
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
java.sql.Time sqlTime = rs.getTime(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return new java.util.Date(sqlTime.getTime());
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
java.sql.Time sqlTime = cs.getTime(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return new java.util.Date(sqlTime.getTime());
}
}
public Object valueOf(String s) {
return SimpleDateFormatter.format(DATE_FORMAT, s);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/TypeHandler.java 0000644 0001750 0001750 00000005447 11047641630 023730 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Interface for getting data into, and out of a mapped statement
*/
public interface TypeHandler {
/**
* Sets a parameter on a prepared statement
*
* @param ps - the prepared statement
* @param i - the parameter index
* @param parameter - the parameter value
* @param jdbcType - the JDBC type of the parameter
*
* @throws SQLException if setting the parameter fails
*/
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException;
/**
* Gets a column from a result set
*
* @param rs - the result set
* @param columnName - the column name to get
*
* @return - the column value
*
* @throws SQLException if getting the value fails
*/
public Object getResult(ResultSet rs, String columnName)
throws SQLException;
/**
* Gets a column from a result set
*
* @param rs - the result set
* @param columnIndex - the column to get (by index)
*
* @return - the column value
*
* @throws SQLException if getting the value fails
*/
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException;
/**
* Gets a column from a callable statement
*
* @param cs - the statement
* @param columnIndex - the column to get (by index)
*
* @return - the column value
*
* @throws SQLException if getting the value fails
*/
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException;
/**
* Converts the String to the type that this handler deals with
*
* @param s - the String value
*
* @return - the converted value
*/
public Object valueOf(String s);
/**
* Compares two values (that this handler deals with) for equality
*
* @param object - one of the objects
* @param string - the other object as a String
*
* @return - true if they are equal
*/
public boolean equals(Object object, String string);
}
ibatis/src/com/ibatis/sqlmap/engine/type/TypeHandlerFactory.java 0000644 0001750 0001750 00000017340 11047641630 025253 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import com.ibatis.sqlmap.client.SqlMapException;
import java.math.BigDecimal;
import java.util.*;
/**
* Not much of a suprise, this is a factory class for TypeHandler objects.
*/
public class TypeHandlerFactory {
private final Map typeHandlerMap = new HashMap();
private final TypeHandler unknownTypeHandler = new UnknownTypeHandler(this);
private final HashMap typeAliases = new HashMap();
private static final Map reversePrimitiveMap = new HashMap() {{
put(Byte.class, byte.class);
put(Short.class, short.class);
put(Integer.class, int.class);
put(Long.class, long.class);
put(Float.class, float.class);
put(Double.class, double.class);
put(Boolean.class, boolean.class);
}};
/* Constructor */
/**
* Default constructor
*/
public TypeHandlerFactory() {
TypeHandler handler;
handler = new BooleanTypeHandler();
register(Boolean.class, handler);
register(boolean.class, handler);
handler = new ByteTypeHandler();
register(Byte.class, handler);
register(byte.class, handler);
handler = new ShortTypeHandler();
register(Short.class, handler);
register(short.class, handler);
handler = new IntegerTypeHandler();
register(Integer.class, handler);
register(int.class, handler);
handler = new LongTypeHandler();
register(Long.class, handler);
register(long.class, handler);
handler = new FloatTypeHandler();
register(Float.class, handler);
register(float.class, handler);
handler = new DoubleTypeHandler();
register(Double.class, handler);
register(double.class, handler);
register(String.class, new StringTypeHandler());
register(String.class, "CLOB", new CustomTypeHandler(new ClobTypeHandlerCallback()));
register(String.class, "LONGVARCHAR", new CustomTypeHandler(new ClobTypeHandlerCallback()));
register(BigDecimal.class, new BigDecimalTypeHandler());
register(byte[].class, new ByteArrayTypeHandler());
register(byte[].class, "BLOB", new CustomTypeHandler(new BlobTypeHandlerCallback()));
register(byte[].class, "LONGVARBINARY", new CustomTypeHandler(new BlobTypeHandlerCallback()));
register(Object.class, new ObjectTypeHandler());
register(Object.class, "OBJECT", new ObjectTypeHandler());
register(Date.class, new DateTypeHandler());
register(Date.class, "DATE", new DateOnlyTypeHandler());
register(Date.class, "TIME", new TimeOnlyTypeHandler());
register(java.sql.Date.class, new SqlDateTypeHandler());
register(java.sql.Time.class, new SqlTimeTypeHandler());
register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());
putTypeAlias("string", String.class.getName());
putTypeAlias("byte", Byte.class.getName());
putTypeAlias("long", Long.class.getName());
putTypeAlias("short", Short.class.getName());
putTypeAlias("int", Integer.class.getName());
putTypeAlias("integer", Integer.class.getName());
putTypeAlias("double", Double.class.getName());
putTypeAlias("float", Float.class.getName());
putTypeAlias("boolean", Boolean.class.getName());
putTypeAlias("date", Date.class.getName());
putTypeAlias("decimal", BigDecimal.class.getName());
putTypeAlias("object", Object.class.getName());
putTypeAlias("map", Map.class.getName());
putTypeAlias("hashmap", HashMap.class.getName());
putTypeAlias("list", List.class.getName());
putTypeAlias("arraylist", ArrayList.class.getName());
putTypeAlias("collection", Collection.class.getName());
putTypeAlias("iterator", Iterator.class.getName());
putTypeAlias("cursor", java.sql.ResultSet.class.getName());
}
/* Public Methods */
/**
* Get a TypeHandler for a class
*
* @param type - the class you want a TypeHandler for
*
* @return - the handler
*/
public TypeHandler getTypeHandler(Class type) {
return getTypeHandler(type, null);
}
/**
* Get a TypeHandler for a class and a JDBC type
*
* @param type - the class
* @param jdbcType - the jdbc type
*
* @return - the handler
*/
public TypeHandler getTypeHandler(Class type, String jdbcType) {
Map jdbcHandlerMap = (Map) typeHandlerMap.get(type);
TypeHandler handler = null;
if (jdbcHandlerMap != null) {
handler = (TypeHandler) jdbcHandlerMap.get(jdbcType);
if (handler == null) {
handler = (TypeHandler) jdbcHandlerMap.get(null);
}
}
if (handler == null && type != null && Enum.class.isAssignableFrom(type)) {
handler = new EnumTypeHandler(type);
}
return handler;
}
/**
* When in doubt, get the "unknown" type handler
*
* @return - if I told you, it would not be unknown, would it?
*/
public TypeHandler getUnkownTypeHandler() {
return unknownTypeHandler;
}
/**
* Tells you if a particular class has a TypeHandler
*
* @param type - the class
*
* @return - true if there is a TypeHandler
*/
public boolean hasTypeHandler(Class type) {
return type != null && (getTypeHandler(type) != null || Enum.class.isAssignableFrom(type));
}
/**
* Register (add) a type handler for a class
*
* @param type - the class
* @param handler - the handler instance
*/
public void register(Class type, TypeHandler handler) {
register(type, null, handler);
}
/**
* Register (add) a type handler for a class and JDBC type
*
* @param type - the class
* @param jdbcType - the JDBC type
* @param handler - the handler instance
*/
public void register(Class type, String jdbcType, TypeHandler handler) {
Map map = (Map) typeHandlerMap.get(type);
if (map == null) {
map = new HashMap();
typeHandlerMap.put(type, map);
}
map.put(jdbcType, handler);
if (reversePrimitiveMap.containsKey(type)) {
register((Class)reversePrimitiveMap.get(type),jdbcType,handler);
}
}
/**
* Lookup an aliased class and return it's REAL name
*
* @param string - the alias
*
* @return - the REAL name
*/
public String resolveAlias(String string) {
String key = null;
if(string != null)
key = string.toLowerCase();
String value = null;
if (typeAliases.containsKey(key)) {
value = (String) typeAliases.get(key);
} else {
value = string;
}
return value;
}
/**
* Adds a type alias that is case insensitive. All of the following String, string, StRiNg will equate to the same alias.
* @param alias - the alias
* @param value - the real class name
*/
public void putTypeAlias(String alias, String value) {
String key = null;
if(alias != null)
key = alias.toLowerCase();
if (typeAliases.containsKey(key) && !typeAliases.get(key).equals(value)) {
throw new SqlMapException("Error in XmlSqlMapClientBuilder. Alias name conflict occurred. The alias '" + key + "' is already mapped to the value '" + typeAliases.get(alias) + "'.");
}
typeAliases.put(key, value);
}
}
ibatis/src/com/ibatis/sqlmap/engine/type/UnknownTypeHandler.java 0000644 0001750 0001750 00000010032 11047641630 025272 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
import java.lang.reflect.Method;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.lang.NoSuchMethodException;
/**
* Implementation of TypeHandler for dealing with unknown types
*/
public class UnknownTypeHandler extends BaseTypeHandler implements TypeHandler {
private TypeHandlerFactory factory;
static private boolean usingJavaPre5 = false;
static {
try {
// try getBaseClass, if it throws no exception
// were in Java <5
getBaseClass(Class.class);
usingJavaPre5 = false;
} catch ( NoSuchMethodException ex ) {
usingJavaPre5 = true;
}
};
/**
* Constructor to create via a factory
*
* @param factory - the factory to associate this with
*/
public UnknownTypeHandler(TypeHandlerFactory factory) {
this.factory = factory;
}
public void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType)
throws SQLException {
Class searchClass = parameter.getClass();
if ( usingJavaPre5 ) {
try {
searchClass = getBaseClass(searchClass);
}
catch ( Exception ex ) {
searchClass = null;
}
}
if ( searchClass == null ) {
searchClass = parameter.getClass();
}
TypeHandler handler = factory.getTypeHandler(searchClass, jdbcType);
handler.setParameter(ps, i, parameter, jdbcType);
}
public Object getResult(ResultSet rs, String columnName)
throws SQLException {
Object object = rs.getObject(columnName);
if (rs.wasNull()) {
return null;
} else {
return object;
}
}
public Object getResult(ResultSet rs, int columnIndex)
throws SQLException {
Object object = rs.getObject(columnIndex);
if (rs.wasNull()) {
return null;
} else {
return object;
}
}
public Object getResult(CallableStatement cs, int columnIndex)
throws SQLException {
Object object = cs.getObject(columnIndex);
if (cs.wasNull()) {
return null;
} else {
return object;
}
}
public Object valueOf(String s) {
return s;
}
public boolean equals(Object object, String string) {
if (object == null || string == null) {
return object == string;
} else {
TypeHandler handler = factory.getTypeHandler(object.getClass());
Object castedObject = handler.valueOf(string);
return object.equals(castedObject);
}
}
/**
* Get the base class of classParam, for top level classes
* this returns null. For enums, inner and anonymous
* classes it returns the enclosing class. The intent
* is to use this for enum support in Java 5+.
*
* @param classParam class to get enclosing class of
* @return Enclosing class
* @throws NoSuchMethodException when run in pre Java 5.
*/
private static Class getBaseClass(Class classParam)
throws NoSuchMethodException {
String methodName = "getEnclosingClass";
Method method = null;
Class result = null;
try {
method = classParam.getClass().getMethod(methodName, (Class[])null);
result = (Class)method.invoke(classParam, (Object[])null);
}
catch ( Exception ex ) {
throw new NoSuchMethodException(ex.getMessage());
}
return result;
}
} ibatis/src/com/ibatis/sqlmap/engine/type/XmlCollectionTypeMarker.java 0000644 0001750 0001750 00000001366 11047641630 026265 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
public interface XmlCollectionTypeMarker extends XmlTypeMarker, DomCollectionTypeMarker {
}
ibatis/src/com/ibatis/sqlmap/engine/type/XmlTypeMarker.java 0000644 0001750 0001750 00000001323 11047641630 024242 0 ustar twerner twerner /*
* Copyright 2004 Clinton Begin
*
* Licensed 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 com.ibatis.sqlmap.engine.type;
public interface XmlTypeMarker extends DomTypeMarker {
}
ibatis/src/license.txt 0000644 0001750 0001750 00000026450 11061424422 015244 0 ustar twerner twerner Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed 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.
ibatis/src/release.txt 0000644 0001750 0001750 00000061302 11061424422 015235 0 ustar twerner twerner Build Date: 2008/09/09 09:43
Build Number: 726
------------------------------
Next Version
------------------------------
o
------------------------------
2.3.4
------------------------------
o iBATIS-519 Autoresultmap thead safety
------------------------------
2.3.3
------------------------------
o Reintroduced fully defined ExtendedSqlMapClient interface for Spring compatibility
o iBATIS-522 -- Null type causing TypeHandlerFactory to throw NPE
o iBATIS-511 -- Added values to error messages
o iBATIS-515 -- Added comments to DTD
o iBATIS-244 -- configured type handler not used for insert
------------------------------
2.3.2
------------------------------
o Updated this release.txt file for 2.3.1
o Made DTD backward compatible again.
o Applied consistent lazy loading Set fix to all lazy loader implementations
o Note that version 2.3.1 and beyond will throws exception for java bean specification violations
------------------------------
2.3.1
------------------------------
o Removed maxTransactions, maxRequests, maxSessions from configuration, all are now controlled by the resource providers
o Fixed BATIS-391 - Cannot access Lists within custom objects.
o Fixed IBATIS-388 - Add methods to unwrap all proxied objects
o Fixed IBATIS-484 - Make setType method in JdbcTypeRegistry public
o Fixed IBATIS-490 - Improper use of getColumnLabel()
o Fixed IBATIS-494 - Improper NULL handling in Blob and Clob Type Handlers
o Fixed IBATIS-497 - Improper use of hashCode in SqlExecuter
o Fixed IBATIS-406 Bug in Ibatis sqlMap when one resultMap has multiple results that are resultMaps... then the groupby attribute only seems to work for the first embedded resultMap.
o Fixed IBATIS-456 ClassCastException when mapping primitive arrays due to attempts to cast to object arrays made by iBatis
o Fixed IBATIS-441 Multiple result sets support broken
o Fixed IBATIS-497 Bug when add two same length and hashCode SQLs to a batch executor
o Fixed IBATIS-484 oracle's user-defined objects not fully supported
o Fixed IBATIS-391 Can not access Lists within custom objects.
o Fixed IBATIS-359 Performance Improvement when No SecurityManager installed
o Fixed IBATIS-439 Batching of statements does not work for stored procedures
o Fixed IBATIS-435 Bug Using iBATIS 2.3.0 And Spring Framework
o Fixed IBATIS-489 CacheModel.NULL_OBJECT should be Serializable to be used with non-in-memory caches
o Fixed IBATIS-494 ClobTypeHandlerCallback handles NULLs incorrectly
o Fixed IBATIS-419 LazyLoad object is not serializable.
o Fixed IBATIS-490 When using implicit resultmap, the code fails throwing exception "Undefined Column Name"
o Fixed IBATIS-487 lazy loading support java.util.Set interface
o Fixed IBATIS-491 resultMap support java 5 enum to jdbcType VARCHAR
o Fixed IBATIS-388 Add methods to unwrap all Proxied Objects
o Fixed IBATIS-433 ResultSetLogProxy doesn't log null value incorrectly
o Fixed IBATIS-445 SqlText setText function and tab (\t) character in text definition
o Fixed IBATIS-479 Typo on com.ibatis.sqlmap.engine.conifg package
o Fixed IBATIS-387 bug in Jdk14LoggingImpl
o Fixed IBATIS-458 maxWait in Throttle can fail.
o Fixed IBATIS-467 flushInterval is limited to hours
------------------------------
2.3.0 - Dec 01, 2006
------------------------------
o DEPRECATED All PaginatedList related features due to misuse, minimal applicability and inflexibility
o DEPRECATED DAO Framework -- Removed from primary distribution, available as a separate download
o Removed DAO framework from Subversion source tree (tagged before removal)
o Changed deployment file naming convention, dropped "DBL" and lowercased all
o Merged common and sqlmap jar files (no more DAO means there's no point in keeping commons separate)
o Implemented transaction level PreparedStatement caching
o Fixed IBATIS-335 - Don't call setQueryTimeout if no value specified
o Fixed IBATIS-338 - NestedSqlException stack overflow
o Fixed IBATIS-340 - Provide ability to override the default encoding in the Resources class
o Fixed IBATIS-353 - Probe exception when using inheritance hierarchies
o Fixed IBATIS-366 - Use ResultObjectFactory to create nested classes
o Fixed IBATIS-367 - Inner class type handler is not handled correctly within maps
o Fixed IBATIS-373 - Allow iBATIS to build SqlMapClient from InputStream
o Fixed IBATIS-374 - Allow with no - must extend another
------------------------------
2.2.0 - Aug 15, 2006
------------------------------
o Removed iBATIS 1.x compatibility libraries, they are no longer supported.
o Removed deprectated JtaDaoTemplate
o Removed custom nested transactions (JDBC 1.4 now required)
o Added support for ResultSet OUT params from stored procs (e.g. Oracle Ref Cursor)
o Added support for Multiple ResultSets mapped to corresponding ResultMaps or ResultClasses.
o Added support for private properties.
o Fixed IBATIS-320 - openSession() returns same object
o Fixed IBATIS-325 - DateTypeHandler uses static SimpleDateFormat instance. Not thread-safe.
o Fixed IBATIS-224 - isNotNull node causes typehandler mappings in statement to fail
o Fixed IBATIS-249 - Race conditions in Throttle lead to thread blockage popping items from ThrottledPools under stress
o Fixed IBATIS-250 - CLONE -SELECT statement returns unexpected result when 'groupBy' and 'nullValue' are specified in resultMaps.
o Fixed IBATIS-258 - Invalid DOCTYPE instruction in example SQL Map file in documentation bundle.
o Fixed IBATIS-260 - Hash conflict with groupBy resultMaps
o Fixed IBATIS-261 - CLONE -The method executor.executeBatch() always returns 0.
o Fixed IBATIS-269 - SqlExecutor calls getMoreResults without checking supportsMultipleResultSets
o Fixed IBATIS-281 - Nested iterate tags does not work
o Fixed IBATIS-286 - close session upon null user connection
o Fixed IBATIS-293 - Fix use of list[]-notation in propertyattributes of dynamic tags
o Fixed IBATIS-322 - consistently use the Resources class methods rather than Class.forName()
o Fixed IBATIS-323 - JDBC driver properties not added to driver/connection when using DBCP
o Fixed IBATIS-331 - nested result mappings not propagated to extended result maps
o Added IBATIS-22 - Specify Query Timeout
o Added IBATIS-50 - Ability to override the default bean creation mechanism
o Added IBATIS-109 - Make PaginatedList work with IBM's broken JDBC driver
o Added IBATIS-127 - PropertyAccessPlan should put more context information when throwing an exception
o Added IBATIS-128 - Detect illegal overloaded JavaBeans properties methods (e.g. setters)
o Added IBATIS-150 - Requirement and benefit of groupBy attribute is not clear in SQL Maps Dev Guide
o Added IBATIS-159 - A new executeBatchDetailed() method that returns all driver information from batch execution
o Added IBATIS-166 - Add overloads for common SqlMapClient methods without parameterObject parameter
o Added IBATIS-167 - Improvements in SimpleDataSource
o Added IBATIS-176 - Add support for DECIMAL/NUMERIC scale on Stored Procedure Output Parameters
o Added IBATIS-204 - Cache layer does no logging of puts, gets, flushes, or removals.
o Added IBATIS-205 - Change access modifiers from private to protected in many classes to allow developers to create extensions and subclasses to the iBatis classes
o Added IBATIS-209 - Inline TypeHandler Support
o Added IBATIS-225 - Reuse resultmap for single bean property
o Added IBATIS-230 - Warn when two ids of a tag are identical
o Added IBATIS-242 - Add property getters for ParameterSetter index and ResultGetter name and index
o Added IBATIS-263 - Ignore case on type aliases
o Added IBATIS-271 - Create no arg methods in the SqlMapDaoTemplate
o Added IBATIS-277 - selectKey execution order attribute
o Added IBATIS-210 - Enum within Collection is not mapped to custom TypeHandler
o Added IBATIS-217 - I would like to see korean document on iBATIS website's document page
o Fixed IBATIS-275 - Add comments only to indicate flushDataCache(string) always uses namespace.
o Added IBATIS-308 - fetchSize for procedures
o Added IBATIS-305 - corrected the documentation about logging, and added some methods to select specific log implementations
o Added IBATIS-311 - Allow removeFirstPrepend to fire repeatedly in an tag
o Added IBATIS-321 - Add logging of prepare operations
------------------------------
2.1.7 - Jan 21, 2006
------------------------------
o Fixed IBATIS-218 'i' character in property names, with Turkish locale
o Fixed IBATIS-219 NoClassDefFoundError: oracle/toplink/sessions/UnitOfWork
o Fixed IBATIS-228 Exception is thrown by TransactionManager when multiple commits are issued against a started transaction.
o Fixed IBATIS-229 Method getWriteablePropertyNames in com.ibatis.common.beans.ComplexBeanProbe gets the readable property names
o Fixed IBATIS-220 Null Pointer in SqlExecutor.handleResults where ResultSet is null.
o Fixed IBATIS-213 SELECT statement returns unexpected result when 'groupBy' and 'nullValue' are specified in resultMaps.
o Fixed IBATIS-221 Can't store a List in a Map
o Fixed IBATIS-223 Thread deadlock due to CacheModel.flush()
------------------------------
2.1.6 - Nov 5, 2005
------------------------------
o Fixed IBATIS-198 Call "getDataSource()" of SqlMapClientImpl will cause application to hang
o Fixed IBATIS-179 Binaries on webpage use old Hibernate
o Fixed IBATIS-174 CacheModel does not support caching null results
o Fixed IBATIS-197 Call "getDataSource()" of SqlMapClientImpl will cause application to hang
o Fixed IBATIS-131 Fix use of list[]-notation in propertyattributes of dynamic tags
o Fixed IBATIS-173 Incorrect resultset retrieve when calling stored procedure
o Fixed IBATIS-194 No resultSet found when executing SQL Server stored procedure.
o Fixed IBATIS-196 can't use dynamic replace data-source-type over IBATIS ver 2.0.9 library
o Fixed IBATIS-191 operation(insert and update) Oracle's(OCI) CLOB and BLOB fail, CLOB will close tomcat, BLOB will miss any DATA
o Fixed IBATIS-193 Hidden jar dependicity for iBatis DBL 2.1.5
o Fixed IBATIS-175 ResultSetLogProxy doesn't log the result properly
o Fixed IBATIS-195 Sqlmap DTD: include tag not permitted in selectKey element
o Fixed IBATIS-172 implicit mapping fails on nested column aliases
o Fixed IBATIS-185 SqlMapClasspathEntityResolver - Offline public ID resolution value ignored
------------------------------
2.1.5 - July 17, 2005
------------------------------
o Fixed IBATIS-136 groupBy not carried forward to extended result maps
o Fixed IBATIS-139 discriminator being applied to too many result maps (thanks Sven)
o Fixed IBATIS-152, 149, 116 null result sets now handled properly by JDBC logging classes (thanks Sven)
o Fixed IBATIS-146 consumes additional result sets before retrieving output params (JTDS fix)
o Fixed IBATIS-130 parameter maps don't allow for complete TypeHandler implementations
o Fixed IBATIS-148 parameter maps don't allow for complete TypeHandler implementations
o Removed dependency on Commons Logging, will autodetect and use Commons Logging, Log4J, JDK 1.4 or no logging
o Improved entity resolvers to be smarter, checks both system and public IDs, and both ibatis.com and apache.org
------------------------------
2.1.0 - May 16, 2005
------------------------------
o Added and tags for class inheritance support
o Added IBATIS-95 removeFirstPrepend attribute to all tags
o Added IBATIS-95 open and close attributes to all dynamic tags to handle complex queries with bracketing
o Added IBATIS-35 to allow duplicate type aliases
o Fixed IBATIS-45 Removed JavaBeanProbe/MapProbe in favor of ComplexBeanProbe
o Fixed IBATIS-79 Problem with nested groupBy resultMaps
o Fixed IBATIS-78 JDBC driver properties does not work when using DBCP
o Fixed IBATIS-42 bug that prevented dynamic tags from being nested inside an iterate tag
o Fixed IBATIS-112 bug that will now allow for the $[]$ notation to be used.
o Fixed IBATIS-45 ProbeExceptions with complex beans
o Fixed IBATIS-79 Problem with nested groupBy resultMaps
o Fixed IBATIS-46 xml parsing issue using jdk 1.3
o Fixed IBATIS-102 duplicate code in the SqlMapConfigParser.java
o Fixed IBATIS-101 add remapResults attribute to procedure tag in sql-map-2.dtd
o Changed SQL executor to always call .execute instead of .executeQuery and .executeUpdate
------------------------------
2.0.9B - Feb 20, 2005
------------------------------
o Rebuilt on Feb 20th to fix incomplete ZIP file
o Fixed IBATIS-24 Add use="true" to javadoc tasks
o Fixed IBATIS-25 Included com.ibatis.common not included in JavaDoc
o Fixed IBATIS-57 Deprecated ScriptRunner
o Fixed IBATIS-47 Add Table of Contents to SqlMaps developer guide
o Fixed IBATIS-68 Add PrameterSetter's interface ( getPreparedStatement() )
o Fixed IBATIS-55 Throws ArrayIndexOutOfBoundsException when call queryForObject
o Fixed IBATIS-41 Sql fragments donīt use namespaces
o Fixed IBATIS-51 isParameterAvailable for Maps always returns true
o Fixed IBATIS-66 com.ibatis.common.util.Throttle not decrementing Session counter causes application to hang
o Fixed IBATIS-61 Inconsistent type handler handling
o Fixed IBATIS-70 iBatis Caching Should Not Rely on hashCode Alone
o Fixed IBATIS-72 Placeholders in sqlmap are not resolved in config
o Fixed IBATIS-74 Problem using a "url" based properties file
o Fixed IBATIS-34 Exception while serializable NULL value (CacheModel)
------------------------------
2.0.9 - Dec 31, 2004
------------------------------
o Added solution for N+1 selects for any number of 1:M and M:N relationships.
o Added groupBy="..." for Result Maps to deal with repeating groups.
o Added resultMap="..." to result mapping to deal with sub groups.
o Added remapResults="true|false" remapping of dynamic result set metadata.
o Added support for isolation levels specified in .startTransaction()
o Added support for SQL "includes" to reduce/eliminate repeated SQL
o Added default CLOB/BLOB support that should work for most databases (thanks to Alexander and Martin)
o Added TopLink DAO Transaction Manager and Template (thanks to Wayne Gentile!)
o Custom type handlers can now directly implement the TypeHandler interface
o Refactored Builder/Parser to be more maintainable (nodelets)
o Verified that duplicate statement names throw an exception. [982534]
o SqlExecutor now always exhausts result sets with ps.getMoreResults()
o Fixed new format inline parameter parsing error [ibatis-23]
------------------------------
2.0.8 - Nov 26, 2004
------------------------------
o Probes now always return true for hasReadable/hasWriteable property checks.
o Fixed OUT/INOUT parameters to proc not retrieved properly (ibatis-12)
o Verified missing columns throw an exception (ibatis-16)
o Completely $supplied$ SQL statements are not supported (ibatis-17)
o Verified parameter type handlers are applied (ibatis-ll)
o Fixed cache model size of 1 disables caching (ibatis-7)
o Fixed LRU cache memory leak (ibatis-1)
o Added commitRequired attribute to transactionManager to force commit even on query (ibatis-10,3)
------------------------------
2.0.7 - Oct 03, 2004
------------------------------
o Added new inline parameter map format (#columnName,javaType=string,jdbcType=VARCHAR# etc.)
o Added direct Set type property support
o Added "OBJECT" type handler mapping to help deal with unsupported types
o Added better exception messages and improved OJB DAO transaction support
o Fixed complex properties being instantiated, even if ultimate value is null
o Fixed DAO builder so that parameter properties override file props
o Fixed CTH so nulls are now sent to custom setParameter
o Fixed DAO unclosed Connection in JTA transaction
o Fixed DAO possible (unlikely) unclosed JDBC connection
------------------------------
2.0.6 - Sep 18, 2004
------------------------------
o Changed complex props so select won't be executed if param null
o Fixed non-caching null cache result bug
o Fixed removeObject bug from fifo and lifo cache
o Fixed locale issue with JavaBean property matching
o Fixed unclosed statement if result set fails in MS SQL Server
o Fixed comments within dao.xml
o Fixed undetected duplicate statement names in a single sql map
o Fixed inconsistent type handler for Map params without paramclass
o Fixed SQLExceptin when populating complex properties
o Fixed setters being called for non-OUT parameter objects
------------------------------
2.0.5 - Aug 11, 2004
------------------------------
o Added Custom Type Handlers! (see TypeHandlerCallback)
o Added OJB DAO support (Thanks to Pedro Salgado)
o Added passthrough methods for Hibernate DAO template
o Added JdbcDaoTemplate support to most DAO TX managers
o Deprecated JtaDaoTemplate, use JdbcDaoTemplate instead
o Fixed reserved XML character encoding for XML types
o Fixed Autocommit (true) in JdbcDaoTransaction
o Fixed Expanded entity references in XML (for > etc.)
o Fixed base probe indexed property accessor
o Fixed doubled-up property element for complex DOM props
------------------------------
2.0.4 - Jul 25, 2004
------------------------------
o Deprecated getUserConnection() (use getCurrentConnection())
o Added getCurrentConnection()
o Added openSession(Connection) for easier user connections
o Improved user provided connection implementation
o Fixed logging bug that prevented SQL from being logged
o Fixed resultSetType prepareStatement overloaded method call
o Fixed nullValue replacement when used with dynamic statements
------------------------------
2.0.3 - Jul 16, 2004
------------------------------
o Added fetchSize and resultSetType attributes to statement and select
o Added parameter count to CacheKey equals for paranoid equality
o Removed redundant bit shift in CacheKey update
o Refactored cache locking pattern to improve concurrent access to cache models
o Improved caching to avoid redundant connection reservations
o New property to stop autocommit from being called in EXTERNAL TX Manager
o Fixed JDBC types being ignored for hashmap parameter classes
o Fixed some rare misleading error messages
------------------------------
2.0.2 - Jun 22, 2004
------------------------------
o Fixed nested List in Map parameter (e.g. #list[].id#)
------------------------------
2.0.1 - Jun 21, 2004
------------------------------
o Added DefaultAutoCommit property to EXTERNAL transaction manager
o Removed redundant throws from template methods
------------------------------
2.0.0 Final - Jun 18, 2004
------------------------------
o Added SqlMapDaoTemplate wrapper methods (wraps SqlMapExecutor methods)
o Fixed "double.nested" complex properties (no WRITEABLE prop found)
o Fixed finalizer triggering lazy loader
o Fixed Paginated List caching
o Fixed NPE on complex prop without parameter class
o Fixed default serialize setting on cache model and improved error msg
------------------------------
2.0.0 RC5 - May 24, 2004
------------------------------
o Fixed NPE when no DataSource configured (for Spring)
o Fixed uppercase bean property support
o Fixed result map getter based typing vs. setter
o Fixed javaType attribute support for JavaBeans
o Fixed caching of statements containing $simple$ dynamic sql
o Fixed List in Map iterate tag problem
o Fixed nullValue for primitive result classes of nested select statements
------------------------------
2.0.0 RC4 - May 11, 2004
------------------------------
o IMPORTANT: Renamed queryForList(String, Object, RowHandler) BACK TO queryWithRowHandler
o Added serialize option to cache model to improve concurrent R/W cache performance
o Added DOM type support for results and parameters.
o Added DaoManager.getDao(class, contextId) to support for multiple DAO impls
o Added access to SqlMapTransactionManager from SQL Map DAOs
o Released all DTD constraints for pluggable components (cache, datasource, txmgr, daotx)
o Fixed threading issue with StandardDaoManager
------------------------------
2.0.0 RC3 - Apr 19, 2004
------------------------------
o Updated DBCP support and centralized config
o Newlines (\r, \n) are now stripped from SQL
o Properties are passed from DAO builder to SQL Maps builder
o Improved OSCache key uniqueness
------------------------------
2.0.0 RC2 - Apr 11, 2004
------------------------------
o Added SqlMapClient.flushDataCache()
o Added "context." prefix for JNDI InitialContext properties
o Added Resources.setDefaultClassLoader()
o Fixed specified JDBC type problem with DATE etc.
o Fixed DAO JDBC connection not being returned
o Fixed queries with no result map error message
o Fixed cache key parameter order problem
o Fixed multiple calls to ResultSet when logging (ODBC/MSAccess problem)
o Fixed unwrapping of proxy exceptions
o Fixed convert task temp file bug
o Fixed specific statement elements using cache model
------------------------------
2.0.0 RC1 - Mar 20, 2004
------------------------------
o Commit/rollback is now only applied if an update occurs.
o Improved error messages (please comment if they still suck)
o Fixed dynamic SQL with multiple params via result mapped statement
o Fixed statement w/ cache models fail with class Cast Exception
o Fixed procedure parameterMap instead of resultMap JavaBeanDataExchange.setData()
o Fixed procedure calls with no params fails with NPE
o Fixed duplicate parameters (#value#...#value#) causes out of bounds exception
------------------------------
2.0.0 Beta 5 - Mar 8, 2004
------------------------------
o Added DAO properties forwarding to transaction managers (e.g. SQL Map config)
o Added support for both file prop config and prog. properties (file overrides prog.)
o Fixed SQL Map statement conversion issue (empty SQL)
o Fixed DAO passthrough methods
o Fixed DAO commit/close connection
o Fixed Property name reuse in parameter maps (PropertyAccessPlan)
------------------------------
2.0.0 Beta 4 - Mar 2, 2004
------------------------------
o Includes first "sneak peek" of DAO 2.0 Framework
o Added DAO 1.x TX Pool classes for real SQL Maps 2.0 support
o Added SqlMapSession.close()
o Refactored SqlMapSession and SqlMapClient interfaces
o Renamed SqlMapClient.getSession() to .openSession()
o Renamed files to ibatis-sqlmap-2.jar, ibatis-common-2.jar and ibatis-dao-2.jar
o Moved compatibilitiy JARs and DAO 1.x to lib/optional/compatibility
o Fixed hasReadable/WriteableProperty check bug
o Fixed addBatch Bug
o Fixed Result Map nullValue type conversion
------------------------------
2.0.0 Beta 3 - Feb 18, 2004
------------------------------
o Added new namespaces
o Renamed output="true" to mode="IN|OUT|INOUT"
o Renamed queryWithRowHandler to queryForList(String, Object, RowHandler)
o Upgraded DAO JAR to version 1.3.1
o Fixed iterative $substitutions[]$
o Fixed multiple iterations in a mapped statement
o Fixed pure output parameters for stored procs
o Fixed stored proc trimming problem
------------------------------
2.0.0 Beta 2 - Jan 18, 2004
------------------------------
o Changed (IMPORTANT) cacheModel attribute readWrite="true" to readOnly="false" (more accurate)
o Ant task to convert SQL Maps
o Updated example log4j.properties and included in /debug directory.
o Implemented session based caching
o Moved ErrorContext to request scope
o Implemented reset methods for scopes
o Skipped records use rs.absolute() if ResultSet type is not TYPE_FORWARD_ONLY
o Fixed connection proxy logging bug (no output).
o Fixed insert element without selectKey (NPE)
o Fixed LRU/FIFO aliases (swapped)
o Fixed legacy properties left in converted map files
------------------------------
2.0.0 Beta 1 - Jan 11, 2004
------------------------------
IMPORTANT: 2.0 initially focuses on compatibility, stability and quality. Very
few new features have been added, but the new architecture should make
make possible the addition of many great new features.
o Complete, from the ground up rewrite.
o Completely new, but familiar API and XML document structure
o Compatibility API for 99% 1.x backward compatibility
o New and improved array[] support
o New and improved stored proc support (including output params)
o New support for auto-gen keys
o New URL resource loading of config files
o New type aliases for more concise mappings
o New XML data types for mappings (direct XML to DB)
o New and improved lazy loading of all complex types
o Improved overall performance
o Reduced library dependencies
o Much more...and more yet to come
ibatis/jar-dependencies.txt 0000644 0001750 0001750 00000001667 11061424422 016236 0 ustar twerner twerner JAR File Dependencies
---------------------
iBATIS 2.0 requires JDK 1.4
All other libraries and JAR files are completely optional. Here's
a summary of those libraries and when you need to use them. The versions
listed here are simply the version tested. Higher versions may or may not
work.
* If you want to use bytecode enhancement for advanced lazy loading:
CGLIB 2.0 (http://cglib.sf.net)
* If you want to use the Jakarta DBCP connection pool you'll need:
DBCP 1.1 (http://jakarta.apache.org/commons/dbcp/)
* If you want to use distributed caching you'll need:
OSCache 2.0.1 (http://www.opensymphony.com/oscache/)
* If you want to use advanced logging you'll need one or both of the following:
Commons Logging (http://jakarta.apache.org/commons/)
Log4J 1.2.8 (http://logging.apache.org/log4j/docs/)
That's it!
-- ibatis/license.txt 0000644 0001750 0001750 00000026450 11061424422 014455 0 ustar twerner twerner Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed 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.
ibatis/notice.txt 0000644 0001750 0001750 00000012051 11061424422 014304 0 ustar twerner twerner This product includes software developed by
The Apache Software Foundation (http://www.apache.org/).
/* Copyright (c) 1995-2000, The Hypersonic SQL Group.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of the Hypersonic SQL Group nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE HYPERSONIC SQL GROUP,
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This software consists of voluntary contributions made by many individuals
* on behalf of the Hypersonic SQL Group.
*
*
* For work added by the HSQL Development Group:
*
* Copyright (c) 2001-2004, The HSQL Development Group
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of the HSQL Development Group nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* Copyright (c) 2001-2004, The HSQL Development Group
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of the HSQL Development Group nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
ibatis/release.txt 0000644 0001750 0001750 00000061302 11061424422 014446 0 ustar twerner twerner Build Date: 2008/09/09 09:43
Build Number: 726
------------------------------
Next Version
------------------------------
o
------------------------------
2.3.4
------------------------------
o iBATIS-519 Autoresultmap thead safety
------------------------------
2.3.3
------------------------------
o Reintroduced fully defined ExtendedSqlMapClient interface for Spring compatibility
o iBATIS-522 -- Null type causing TypeHandlerFactory to throw NPE
o iBATIS-511 -- Added values to error messages
o iBATIS-515 -- Added comments to DTD
o iBATIS-244 -- configured type handler not used for insert
------------------------------
2.3.2
------------------------------
o Updated this release.txt file for 2.3.1
o Made DTD backward compatible again.
o Applied consistent lazy loading Set fix to all lazy loader implementations
o Note that version 2.3.1 and beyond will throws exception for java bean specification violations
------------------------------
2.3.1
------------------------------
o Removed maxTransactions, maxRequests, maxSessions from configuration, all are now controlled by the resource providers
o Fixed BATIS-391 - Cannot access Lists within custom objects.
o Fixed IBATIS-388 - Add methods to unwrap all proxied objects
o Fixed IBATIS-484 - Make setType method in JdbcTypeRegistry public
o Fixed IBATIS-490 - Improper use of getColumnLabel()
o Fixed IBATIS-494 - Improper NULL handling in Blob and Clob Type Handlers
o Fixed IBATIS-497 - Improper use of hashCode in SqlExecuter
o Fixed IBATIS-406 Bug in Ibatis sqlMap when one resultMap has multiple results that are resultMaps... then the groupby attribute only seems to work for the first embedded resultMap.
o Fixed IBATIS-456 ClassCastException when mapping primitive arrays due to attempts to cast to object arrays made by iBatis
o Fixed IBATIS-441 Multiple result sets support broken
o Fixed IBATIS-497 Bug when add two same length and hashCode SQLs to a batch executor
o Fixed IBATIS-484 oracle's user-defined objects not fully supported
o Fixed IBATIS-391 Can not access Lists within custom objects.
o Fixed IBATIS-359 Performance Improvement when No SecurityManager installed
o Fixed IBATIS-439 Batching of statements does not work for stored procedures
o Fixed IBATIS-435 Bug Using iBATIS 2.3.0 And Spring Framework
o Fixed IBATIS-489 CacheModel.NULL_OBJECT should be Serializable to be used with non-in-memory caches
o Fixed IBATIS-494 ClobTypeHandlerCallback handles NULLs incorrectly
o Fixed IBATIS-419 LazyLoad object is not serializable.
o Fixed IBATIS-490 When using implicit resultmap, the code fails throwing exception "Undefined Column Name"
o Fixed IBATIS-487 lazy loading support java.util.Set interface
o Fixed IBATIS-491 resultMap support java 5 enum to jdbcType VARCHAR
o Fixed IBATIS-388 Add methods to unwrap all Proxied Objects
o Fixed IBATIS-433 ResultSetLogProxy doesn't log null value incorrectly
o Fixed IBATIS-445 SqlText setText function and tab (\t) character in text definition
o Fixed IBATIS-479 Typo on com.ibatis.sqlmap.engine.conifg package
o Fixed IBATIS-387 bug in Jdk14LoggingImpl
o Fixed IBATIS-458 maxWait in Throttle can fail.
o Fixed IBATIS-467 flushInterval is limited to hours
------------------------------
2.3.0 - Dec 01, 2006
------------------------------
o DEPRECATED All PaginatedList related features due to misuse, minimal applicability and inflexibility
o DEPRECATED DAO Framework -- Removed from primary distribution, available as a separate download
o Removed DAO framework from Subversion source tree (tagged before removal)
o Changed deployment file naming convention, dropped "DBL" and lowercased all
o Merged common and sqlmap jar files (no more DAO means there's no point in keeping commons separate)
o Implemented transaction level PreparedStatement caching
o Fixed IBATIS-335 - Don't call setQueryTimeout if no value specified
o Fixed IBATIS-338 - NestedSqlException stack overflow
o Fixed IBATIS-340 - Provide ability to override the default encoding in the Resources class
o Fixed IBATIS-353 - Probe exception when using inheritance hierarchies
o Fixed IBATIS-366 - Use ResultObjectFactory to create nested classes
o Fixed IBATIS-367 - Inner class type handler is not handled correctly within maps
o Fixed IBATIS-373 - Allow iBATIS to build SqlMapClient from InputStream
o Fixed IBATIS-374 - Allow with no - must extend another
------------------------------
2.2.0 - Aug 15, 2006
------------------------------
o Removed iBATIS 1.x compatibility libraries, they are no longer supported.
o Removed deprectated JtaDaoTemplate
o Removed custom nested transactions (JDBC 1.4 now required)
o Added support for ResultSet OUT params from stored procs (e.g. Oracle Ref Cursor)
o Added support for Multiple ResultSets mapped to corresponding ResultMaps or ResultClasses.
o Added support for private properties.
o Fixed IBATIS-320 - openSession() returns same object
o Fixed IBATIS-325 - DateTypeHandler uses static SimpleDateFormat instance. Not thread-safe.
o Fixed IBATIS-224 - isNotNull node causes typehandler mappings in statement to fail
o Fixed IBATIS-249 - Race conditions in Throttle lead to thread blockage popping items from ThrottledPools under stress
o Fixed IBATIS-250 - CLONE -SELECT statement returns unexpected result when 'groupBy' and 'nullValue' are specified in resultMaps.
o Fixed IBATIS-258 - Invalid DOCTYPE instruction in example SQL Map file in documentation bundle.
o Fixed IBATIS-260 - Hash conflict with groupBy resultMaps
o Fixed IBATIS-261 - CLONE -The method executor.executeBatch() always returns 0.
o Fixed IBATIS-269 - SqlExecutor calls getMoreResults without checking supportsMultipleResultSets
o Fixed IBATIS-281 - Nested iterate tags does not work
o Fixed IBATIS-286 - close session upon null user connection
o Fixed IBATIS-293 - Fix use of list[]-notation in propertyattributes of dynamic tags
o Fixed IBATIS-322 - consistently use the Resources class methods rather than Class.forName()
o Fixed IBATIS-323 - JDBC driver properties not added to driver/connection when using DBCP
o Fixed IBATIS-331 - nested result mappings not propagated to extended result maps
o Added IBATIS-22 - Specify Query Timeout
o Added IBATIS-50 - Ability to override the default bean creation mechanism
o Added IBATIS-109 - Make PaginatedList work with IBM's broken JDBC driver
o Added IBATIS-127 - PropertyAccessPlan should put more context information when throwing an exception
o Added IBATIS-128 - Detect illegal overloaded JavaBeans properties methods (e.g. setters)
o Added IBATIS-150 - Requirement and benefit of groupBy attribute is not clear in SQL Maps Dev Guide
o Added IBATIS-159 - A new executeBatchDetailed() method that returns all driver information from batch execution
o Added IBATIS-166 - Add overloads for common SqlMapClient methods without parameterObject parameter
o Added IBATIS-167 - Improvements in SimpleDataSource
o Added IBATIS-176 - Add support for DECIMAL/NUMERIC scale on Stored Procedure Output Parameters
o Added IBATIS-204 - Cache layer does no logging of puts, gets, flushes, or removals.
o Added IBATIS-205 - Change access modifiers from private to protected in many classes to allow developers to create extensions and subclasses to the iBatis classes
o Added IBATIS-209 - Inline TypeHandler Support
o Added IBATIS-225 - Reuse resultmap for single bean property
o Added IBATIS-230 - Warn when two ids of a tag are identical
o Added IBATIS-242 - Add property getters for ParameterSetter index and ResultGetter name and index
o Added IBATIS-263 - Ignore case on type aliases
o Added IBATIS-271 - Create no arg methods in the SqlMapDaoTemplate
o Added IBATIS-277 - selectKey execution order attribute
o Added IBATIS-210 - Enum within Collection is not mapped to custom TypeHandler
o Added IBATIS-217 - I would like to see korean document on iBATIS website's document page
o Fixed IBATIS-275 - Add comments only to indicate flushDataCache(string) always uses namespace.
o Added IBATIS-308 - fetchSize for procedures
o Added IBATIS-305 - corrected the documentation about logging, and added some methods to select specific log implementations
o Added IBATIS-311 - Allow removeFirstPrepend to fire repeatedly in an tag
o Added IBATIS-321 - Add logging of prepare operations
------------------------------
2.1.7 - Jan 21, 2006
------------------------------
o Fixed IBATIS-218 'i' character in property names, with Turkish locale
o Fixed IBATIS-219 NoClassDefFoundError: oracle/toplink/sessions/UnitOfWork
o Fixed IBATIS-228 Exception is thrown by TransactionManager when multiple commits are issued against a started transaction.
o Fixed IBATIS-229 Method getWriteablePropertyNames in com.ibatis.common.beans.ComplexBeanProbe gets the readable property names
o Fixed IBATIS-220 Null Pointer in SqlExecutor.handleResults where ResultSet is null.
o Fixed IBATIS-213 SELECT statement returns unexpected result when 'groupBy' and 'nullValue' are specified in resultMaps.
o Fixed IBATIS-221 Can't store a List in a Map
o Fixed IBATIS-223 Thread deadlock due to CacheModel.flush()
------------------------------
2.1.6 - Nov 5, 2005
------------------------------
o Fixed IBATIS-198 Call "getDataSource()" of SqlMapClientImpl will cause application to hang
o Fixed IBATIS-179 Binaries on webpage use old Hibernate
o Fixed IBATIS-174 CacheModel does not support caching null results
o Fixed IBATIS-197 Call "getDataSource()" of SqlMapClientImpl will cause application to hang
o Fixed IBATIS-131 Fix use of list[]-notation in propertyattributes of dynamic tags
o Fixed IBATIS-173 Incorrect resultset retrieve when calling stored procedure
o Fixed IBATIS-194 No resultSet found when executing SQL Server stored procedure.
o Fixed IBATIS-196 can't use dynamic replace data-source-type over IBATIS ver 2.0.9 library
o Fixed IBATIS-191 operation(insert and update) Oracle's(OCI) CLOB and BLOB fail, CLOB will close tomcat, BLOB will miss any DATA
o Fixed IBATIS-193 Hidden jar dependicity for iBatis DBL 2.1.5
o Fixed IBATIS-175 ResultSetLogProxy doesn't log the result properly
o Fixed IBATIS-195 Sqlmap DTD: include tag not permitted in selectKey element
o Fixed IBATIS-172 implicit mapping fails on nested column aliases
o Fixed IBATIS-185 SqlMapClasspathEntityResolver - Offline public ID resolution value ignored
------------------------------
2.1.5 - July 17, 2005
------------------------------
o Fixed IBATIS-136 groupBy not carried forward to extended result maps
o Fixed IBATIS-139 discriminator being applied to too many result maps (thanks Sven)
o Fixed IBATIS-152, 149, 116 null result sets now handled properly by JDBC logging classes (thanks Sven)
o Fixed IBATIS-146 consumes additional result sets before retrieving output params (JTDS fix)
o Fixed IBATIS-130 parameter maps don't allow for complete TypeHandler implementations
o Fixed IBATIS-148 parameter maps don't allow for complete TypeHandler implementations
o Removed dependency on Commons Logging, will autodetect and use Commons Logging, Log4J, JDK 1.4 or no logging
o Improved entity resolvers to be smarter, checks both system and public IDs, and both ibatis.com and apache.org
------------------------------
2.1.0 - May 16, 2005
------------------------------
o Added and tags for class inheritance support
o Added IBATIS-95 removeFirstPrepend attribute to all tags
o Added IBATIS-95 open and close attributes to all dynamic tags to handle complex queries with bracketing
o Added IBATIS-35 to allow duplicate type aliases
o Fixed IBATIS-45 Removed JavaBeanProbe/MapProbe in favor of ComplexBeanProbe
o Fixed IBATIS-79 Problem with nested groupBy resultMaps
o Fixed IBATIS-78 JDBC driver properties does not work when using DBCP
o Fixed IBATIS-42 bug that prevented dynamic tags from being nested inside an iterate tag
o Fixed IBATIS-112 bug that will now allow for the $[]$ notation to be used.
o Fixed IBATIS-45 ProbeExceptions with complex beans
o Fixed IBATIS-79 Problem with nested groupBy resultMaps
o Fixed IBATIS-46 xml parsing issue using jdk 1.3
o Fixed IBATIS-102 duplicate code in the SqlMapConfigParser.java
o Fixed IBATIS-101 add remapResults attribute to procedure tag in sql-map-2.dtd
o Changed SQL executor to always call .execute instead of .executeQuery and .executeUpdate
------------------------------
2.0.9B - Feb 20, 2005
------------------------------
o Rebuilt on Feb 20th to fix incomplete ZIP file
o Fixed IBATIS-24 Add use="true" to javadoc tasks
o Fixed IBATIS-25 Included com.ibatis.common not included in JavaDoc
o Fixed IBATIS-57 Deprecated ScriptRunner
o Fixed IBATIS-47 Add Table of Contents to SqlMaps developer guide
o Fixed IBATIS-68 Add PrameterSetter's interface ( getPreparedStatement() )
o Fixed IBATIS-55 Throws ArrayIndexOutOfBoundsException when call queryForObject
o Fixed IBATIS-41 Sql fragments donīt use namespaces
o Fixed IBATIS-51 isParameterAvailable for Maps always returns true
o Fixed IBATIS-66 com.ibatis.common.util.Throttle not decrementing Session counter causes application to hang
o Fixed IBATIS-61 Inconsistent type handler handling
o Fixed IBATIS-70 iBatis Caching Should Not Rely on hashCode Alone
o Fixed IBATIS-72 Placeholders in sqlmap are not resolved in config
o Fixed IBATIS-74 Problem using a "url" based properties file
o Fixed IBATIS-34 Exception while serializable NULL value (CacheModel)
------------------------------
2.0.9 - Dec 31, 2004
------------------------------
o Added solution for N+1 selects for any number of 1:M and M:N relationships.
o Added groupBy="..." for Result Maps to deal with repeating groups.
o Added resultMap="..." to result mapping to deal with sub groups.
o Added remapResults="true|false" remapping of dynamic result set metadata.
o Added support for isolation levels specified in .startTransaction()
o Added support for SQL "includes" to reduce/eliminate repeated SQL
o Added default CLOB/BLOB support that should work for most databases (thanks to Alexander and Martin)
o Added TopLink DAO Transaction Manager and Template (thanks to Wayne Gentile!)
o Custom type handlers can now directly implement the TypeHandler interface
o Refactored Builder/Parser to be more maintainable (nodelets)
o Verified that duplicate statement names throw an exception. [982534]
o SqlExecutor now always exhausts result sets with ps.getMoreResults()
o Fixed new format inline parameter parsing error [ibatis-23]
------------------------------
2.0.8 - Nov 26, 2004
------------------------------
o Probes now always return true for hasReadable/hasWriteable property checks.
o Fixed OUT/INOUT parameters to proc not retrieved properly (ibatis-12)
o Verified missing columns throw an exception (ibatis-16)
o Completely $supplied$ SQL statements are not supported (ibatis-17)
o Verified parameter type handlers are applied (ibatis-ll)
o Fixed cache model size of 1 disables caching (ibatis-7)
o Fixed LRU cache memory leak (ibatis-1)
o Added commitRequired attribute to transactionManager to force commit even on query (ibatis-10,3)
------------------------------
2.0.7 - Oct 03, 2004
------------------------------
o Added new inline parameter map format (#columnName,javaType=string,jdbcType=VARCHAR# etc.)
o Added direct Set type property support
o Added "OBJECT" type handler mapping to help deal with unsupported types
o Added better exception messages and improved OJB DAO transaction support
o Fixed complex properties being instantiated, even if ultimate value is null
o Fixed DAO builder so that parameter properties override file props
o Fixed CTH so nulls are now sent to custom setParameter
o Fixed DAO unclosed Connection in JTA transaction
o Fixed DAO possible (unlikely) unclosed JDBC connection
------------------------------
2.0.6 - Sep 18, 2004
------------------------------
o Changed complex props so select won't be executed if param null
o Fixed non-caching null cache result bug
o Fixed removeObject bug from fifo and lifo cache
o Fixed locale issue with JavaBean property matching
o Fixed unclosed statement if result set fails in MS SQL Server
o Fixed comments within dao.xml
o Fixed undetected duplicate statement names in a single sql map
o Fixed inconsistent type handler for Map params without paramclass
o Fixed SQLExceptin when populating complex properties
o Fixed setters being called for non-OUT parameter objects
------------------------------
2.0.5 - Aug 11, 2004
------------------------------
o Added Custom Type Handlers! (see TypeHandlerCallback)
o Added OJB DAO support (Thanks to Pedro Salgado)
o Added passthrough methods for Hibernate DAO template
o Added JdbcDaoTemplate support to most DAO TX managers
o Deprecated JtaDaoTemplate, use JdbcDaoTemplate instead
o Fixed reserved XML character encoding for XML types
o Fixed Autocommit (true) in JdbcDaoTransaction
o Fixed Expanded entity references in XML (for > etc.)
o Fixed base probe indexed property accessor
o Fixed doubled-up property element for complex DOM props
------------------------------
2.0.4 - Jul 25, 2004
------------------------------
o Deprecated getUserConnection() (use getCurrentConnection())
o Added getCurrentConnection()
o Added openSession(Connection) for easier user connections
o Improved user provided connection implementation
o Fixed logging bug that prevented SQL from being logged
o Fixed resultSetType prepareStatement overloaded method call
o Fixed nullValue replacement when used with dynamic statements
------------------------------
2.0.3 - Jul 16, 2004
------------------------------
o Added fetchSize and resultSetType attributes to statement and select
o Added parameter count to CacheKey equals for paranoid equality
o Removed redundant bit shift in CacheKey update
o Refactored cache locking pattern to improve concurrent access to cache models
o Improved caching to avoid redundant connection reservations
o New property to stop autocommit from being called in EXTERNAL TX Manager
o Fixed JDBC types being ignored for hashmap parameter classes
o Fixed some rare misleading error messages
------------------------------
2.0.2 - Jun 22, 2004
------------------------------
o Fixed nested List in Map parameter (e.g. #list[].id#)
------------------------------
2.0.1 - Jun 21, 2004
------------------------------
o Added DefaultAutoCommit property to EXTERNAL transaction manager
o Removed redundant throws from template methods
------------------------------
2.0.0 Final - Jun 18, 2004
------------------------------
o Added SqlMapDaoTemplate wrapper methods (wraps SqlMapExecutor methods)
o Fixed "double.nested" complex properties (no WRITEABLE prop found)
o Fixed finalizer triggering lazy loader
o Fixed Paginated List caching
o Fixed NPE on complex prop without parameter class
o Fixed default serialize setting on cache model and improved error msg
------------------------------
2.0.0 RC5 - May 24, 2004
------------------------------
o Fixed NPE when no DataSource configured (for Spring)
o Fixed uppercase bean property support
o Fixed result map getter based typing vs. setter
o Fixed javaType attribute support for JavaBeans
o Fixed caching of statements containing $simple$ dynamic sql
o Fixed List in Map iterate tag problem
o Fixed nullValue for primitive result classes of nested select statements
------------------------------
2.0.0 RC4 - May 11, 2004
------------------------------
o IMPORTANT: Renamed queryForList(String, Object, RowHandler) BACK TO queryWithRowHandler
o Added serialize option to cache model to improve concurrent R/W cache performance
o Added DOM type support for results and parameters.
o Added DaoManager.getDao(class, contextId) to support for multiple DAO impls
o Added access to SqlMapTransactionManager from SQL Map DAOs
o Released all DTD constraints for pluggable components (cache, datasource, txmgr, daotx)
o Fixed threading issue with StandardDaoManager
------------------------------
2.0.0 RC3 - Apr 19, 2004
------------------------------
o Updated DBCP support and centralized config
o Newlines (\r, \n) are now stripped from SQL
o Properties are passed from DAO builder to SQL Maps builder
o Improved OSCache key uniqueness
------------------------------
2.0.0 RC2 - Apr 11, 2004
------------------------------
o Added SqlMapClient.flushDataCache()
o Added "context." prefix for JNDI InitialContext properties
o Added Resources.setDefaultClassLoader()
o Fixed specified JDBC type problem with DATE etc.
o Fixed DAO JDBC connection not being returned
o Fixed queries with no result map error message
o Fixed cache key parameter order problem
o Fixed multiple calls to ResultSet when logging (ODBC/MSAccess problem)
o Fixed unwrapping of proxy exceptions
o Fixed convert task temp file bug
o Fixed specific statement elements using cache model
------------------------------
2.0.0 RC1 - Mar 20, 2004
------------------------------
o Commit/rollback is now only applied if an update occurs.
o Improved error messages (please comment if they still suck)
o Fixed dynamic SQL with multiple params via result mapped statement
o Fixed statement w/ cache models fail with class Cast Exception
o Fixed procedure parameterMap instead of resultMap JavaBeanDataExchange.setData()
o Fixed procedure calls with no params fails with NPE
o Fixed duplicate parameters (#value#...#value#) causes out of bounds exception
------------------------------
2.0.0 Beta 5 - Mar 8, 2004
------------------------------
o Added DAO properties forwarding to transaction managers (e.g. SQL Map config)
o Added support for both file prop config and prog. properties (file overrides prog.)
o Fixed SQL Map statement conversion issue (empty SQL)
o Fixed DAO passthrough methods
o Fixed DAO commit/close connection
o Fixed Property name reuse in parameter maps (PropertyAccessPlan)
------------------------------
2.0.0 Beta 4 - Mar 2, 2004
------------------------------
o Includes first "sneak peek" of DAO 2.0 Framework
o Added DAO 1.x TX Pool classes for real SQL Maps 2.0 support
o Added SqlMapSession.close()
o Refactored SqlMapSession and SqlMapClient interfaces
o Renamed SqlMapClient.getSession() to .openSession()
o Renamed files to ibatis-sqlmap-2.jar, ibatis-common-2.jar and ibatis-dao-2.jar
o Moved compatibilitiy JARs and DAO 1.x to lib/optional/compatibility
o Fixed hasReadable/WriteableProperty check bug
o Fixed addBatch Bug
o Fixed Result Map nullValue type conversion
------------------------------
2.0.0 Beta 3 - Feb 18, 2004
------------------------------
o Added new namespaces
o Renamed output="true" to mode="IN|OUT|INOUT"
o Renamed queryWithRowHandler to queryForList(String, Object, RowHandler)
o Upgraded DAO JAR to version 1.3.1
o Fixed iterative $substitutions[]$
o Fixed multiple iterations in a mapped statement
o Fixed pure output parameters for stored procs
o Fixed stored proc trimming problem
------------------------------
2.0.0 Beta 2 - Jan 18, 2004
------------------------------
o Changed (IMPORTANT) cacheModel attribute readWrite="true" to readOnly="false" (more accurate)
o Ant task to convert SQL Maps
o Updated example log4j.properties and included in /debug directory.
o Implemented session based caching
o Moved ErrorContext to request scope
o Implemented reset methods for scopes
o Skipped records use rs.absolute() if ResultSet type is not TYPE_FORWARD_ONLY
o Fixed connection proxy logging bug (no output).
o Fixed insert element without selectKey (NPE)
o Fixed LRU/FIFO aliases (swapped)
o Fixed legacy properties left in converted map files
------------------------------
2.0.0 Beta 1 - Jan 11, 2004
------------------------------
IMPORTANT: 2.0 initially focuses on compatibility, stability and quality. Very
few new features have been added, but the new architecture should make
make possible the addition of many great new features.
o Complete, from the ground up rewrite.
o Completely new, but familiar API and XML document structure
o Compatibility API for 99% 1.x backward compatibility
o New and improved array[] support
o New and improved stored proc support (including output params)
o New support for auto-gen keys
o New URL resource loading of config files
o New type aliases for more concise mappings
o New XML data types for mappings (direct XML to DB)
o New and improved lazy loading of all complex types
o Improved overall performance
o Reduced library dependencies
o Much more...and more yet to come