public SqlText ParseInlineParameterMap(IScope scope, IStatement statement, string sqlStatement)
{
string str = sqlStatement;
ArrayList list = new ArrayList();
Type parameterClassType = null;
if (statement != null)
{
parameterClassType = statement.ParameterClass;
}
StringTokenizer tokenizer = new StringTokenizer(sqlStatement, "#", true);
StringBuilder builder = new StringBuilder();
string current = null;
string str3 = null;
IEnumerator enumerator = tokenizer.GetEnumerator();
while (enumerator.MoveNext())
{
current = (string)enumerator.Current;
if ("#".Equals(str3))
{
if ("#".Equals(current))
{
builder.Append("#");
current = null;
}
else
{
ParameterProperty property = null;
if (current.IndexOf(":") > -1)
{
property = this.OldParseMapping(current, parameterClassType, scope);
}
else
{
property = this.NewParseMapping(current, parameterClassType, scope);
}
list.Add(property);
builder.Append("? ");
enumerator.MoveNext();
current = (string)enumerator.Current;
if (!"#".Equals(current))
{
throw new DataMapperException("Unterminated inline parameter in mapped statement (" + statement.Id + ").");
}
current = null;
}
}
else if (!"#".Equals(current))
{
builder.Append(current);
}
str3 = current;
}
str = builder.ToString();
ParameterProperty[] propertyArray = (ParameterProperty[])list.ToArray(typeof(ParameterProperty));
return(new SqlText {
Text = str, Parameters = propertyArray
});
}
public int Add(ParameterProperty value)
{
this.Resize(this._count + 1);
int index = this._count++;
this._innerList[index] = value;
return(index);
}
/// <summary>
/// Add an ParameterProperty
/// </summary>
/// <param name="value"></param>
/// <returns>Index</returns>
public int Add(ParameterProperty value)
{
Resize(_count + 1);
int index = _count++;
_innerList[index] = value;
return(index);
}
public void AddParameterProperty(ParameterProperty property)
{
this._propertiesMap[property.PropertyName] = property;
this._properties.Add(property);
if (!this._propertiesList.Contains(property))
{
this._propertiesList.Add(property);
}
}
public void InsertParameterProperty(int index, ParameterProperty property)
{
this._propertiesMap[property.PropertyName] = property;
this._properties.Insert(index, property);
if (!this._propertiesList.Contains(property))
{
this._propertiesList.Insert(index, property);
}
}
public override bool Equals(object obj)
{
if ((obj == null) || (base.GetType() != obj.GetType()))
{
return(false);
}
ParameterProperty property = (ParameterProperty)obj;
return(this.PropertyName == property.PropertyName);
}
public void Insert(int index, ParameterProperty value)
{
if ((index < 0) || (index > this._count))
{
throw new ArgumentOutOfRangeException("index");
}
this.Resize(this._count + 1);
Array.Copy(this._innerList, index, this._innerList, index + 1, this._count - index);
this._innerList[index] = value;
this._count++;
}
/// <summary>
/// Indicate if a ParameterProperty is in the collection
/// </summary>
/// <param name="value">A ParameterProperty</param>
/// <returns>True fi is in</returns>
public bool Contains(ParameterProperty value)
{
for (int i = 0; i < _count; i++)
{
if (_innerList[i].PropertyName == value.PropertyName)
{
return(true);
}
}
return(false);
}
public void BuildProperties(ConfigurationScope configScope)
{
ParameterProperty property = null;
foreach (XmlNode node in configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix("parameter"), configScope.XmlNamespaceManager))
{
property = ParameterPropertyDeSerializer.Deserialize(node, configScope);
property.Initialize(configScope, this._parameterClass);
this.AddParameterProperty(property);
}
}
public void SetParameter(ParameterProperty mapping, IDataParameter dataParameter, object parameterValue)
{
object data = this._dataExchange.GetData(mapping, parameterValue);
ITypeHandler typeHandler = mapping.TypeHandler;
if (mapping.HasNullValue && typeHandler.Equals(data, mapping.NullValue))
{
data = null;
}
typeHandler.SetParameter(dataParameter, data, mapping.DbType);
}
/// <summary>
/// Remove a ParameterProperty of the collection.
/// </summary>
public void Remove(ParameterProperty value)
{
for (int i = 0; i < _count; i++)
{
if (_innerList[i].PropertyName == value.PropertyName)
{
RemoveAt(i);
return;
}
}
}
/// <summary>
/// Determines whether the specified <see cref="System.Object"></see> is equal to the current <see cref="System.Object"></see>.
/// </summary>
/// <param name="obj">The <see cref="System.Object"></see> to compare with the current <see cref="System.Object"></see>.</param>
/// <returns>
/// true if the specified <see cref="System.Object"></see> is equal to the current <see cref="System.Object"></see>; otherwise, false.
/// </returns>
public override bool Equals(object obj)
{
//Check for null and compare run-time types.
if (obj == null || GetType() != obj.GetType())
{
return(false);
}
ParameterProperty p = (ParameterProperty)obj;
return(this.PropertyName == p.PropertyName);
}
/// <summary>
/// Insert a ParameterProperty ine the ParameterProperty list at the specified index..
/// </summary>
/// <param name="index">
/// The zero-based index at which ParameterProperty should be inserted.
/// </param>
/// <param name="property">The ParameterProperty to insert. </param>
public void InsertParameterProperty(int index, ParameterProperty property)
{
// These mappings will replace any mappings that this map
// had for any of the keys currently in the specified map.
_propertiesMap[property.PropertyName] = property;
_properties.Insert(index, property);
if (_propertiesList.Contains(property) == false)
{
_propertiesList.Insert(index, property);
}
}
/// <summary>
/// Gets the data to be set into a IDataParameter.
/// </summary>
/// <param name="mapping"></param>
/// <param name="parameterObject"></param>
public override object GetData(ParameterProperty mapping, object parameterObject)
{
if (mapping.IsComplexMemberName || _parameterClass!=parameterObject.GetType())
{
return ObjectProbe.GetMemberValue(parameterObject, mapping.PropertyName,
this.DataExchangeFactory.AccessorFactory);
}
else
{
return mapping.GetAccessor.Get(parameterObject);
}
}
/// <summary>
/// Insert a ParameterProperty in the collection.
/// </summary>
/// <param name="index">Index where to insert.</param>
/// <param name="value">A ParameterProperty</param>
public void Insert(int index, ParameterProperty value)
{
if (index < 0 || index > _count)
{
throw new ArgumentOutOfRangeException("index");
}
Resize(_count + 1);
Array.Copy(_innerList, index, _innerList, index + 1, _count - index);
_innerList[index] = value;
_count++;
}
/// <summary>
/// Set parameter value, replace the null value if any.
/// </summary>
/// <param name="mapping"></param>
/// <param name="dataParameter"></param>
/// <param name="parameterValue"></param>
public void SetParameter(ParameterProperty mapping, IDataParameter dataParameter, object parameterValue)
{
object value = _dataExchange.GetData(mapping, parameterValue);
ITypeHandler typeHandler = mapping.TypeHandler;
// Apply Null Value
if (mapping.HasNullValue)
{
if (typeHandler.Equals(value, mapping.NullValue))
{
value = null;
}
}
typeHandler.SetParameter(dataParameter, value, mapping.DbType);
}
/// <summary>
/// Clones this instance.
/// </summary>
/// <returns>An <see cref="ParameterProperty"/></returns>
public ParameterProperty Clone()
{
ParameterProperty property = new ParameterProperty();
property.CallBackName = this.CallBackName;
property.CLRType = this.CLRType;
property.ColumnName = this.ColumnName;
property.DbType = this.DbType;
property.DirectionAttribute = this.DirectionAttribute;
property.NullValue = this.NullValue;
property.PropertyName = this.PropertyName;
property.Precision = this.Precision;
property.Scale = this.Scale;
property.Size = this.Size;
return(property);
}
/// <summary>
/// Gets the data to be set into a IDataParameter.
/// </summary>
/// <param name="mapping"></param>
/// <param name="parameterObject"></param>
public override object GetData(ParameterProperty mapping, object parameterObject)
{
if (parameterObject!=null)
{
if (this.DataExchangeFactory.TypeHandlerFactory.IsSimpleType(parameterObject.GetType()))
{
return parameterObject;
}
else
{
return ObjectProbe.GetMemberValue(parameterObject, mapping.PropertyName, this.DataExchangeFactory.AccessorFactory);
}
}
else
{
return null;
}
}
/// <summary>
/// Deserialize a ResultMap object
/// </summary>
/// <param name="node"></param>
/// <param name="configScope"></param>
/// <returns></returns>
public static ParameterProperty Deserialize(XmlNode node, ConfigurationScope configScope)
{
ParameterProperty property = new ParameterProperty();
NameValueCollection prop = NodeUtils.ParseAttributes(node, configScope.Properties);
configScope.ErrorContext.MoreInfo = "ParameterPropertyDeSerializer";
property.CallBackName = NodeUtils.GetStringAttribute(prop, "typeHandler");
property.CLRType = NodeUtils.GetStringAttribute(prop, "type");
property.ColumnName = NodeUtils.GetStringAttribute(prop, "column");
property.DbType = NodeUtils.GetStringAttribute(prop, "dbType", null);
property.DirectionAttribute = NodeUtils.GetStringAttribute(prop, "direction");
property.NullValue = prop["nullValue"];
property.PropertyName = NodeUtils.GetStringAttribute(prop, "property");
property.Precision = NodeUtils.GetByteAttribute(prop, "precision", 0);
property.Scale = NodeUtils.GetByteAttribute(prop, "scale", 0);
property.Size = NodeUtils.GetIntAttribute(prop, "size", -1);
return property;
}
private IDbDataParameter Search(ISqlMapSession session,IDbDataParameter[] parameters, ParameterProperty property, int index)
{
if (property.ColumnName.Length>0)
{
for (int i = 0; i < parameters.Length; i++)
{
string parameterName = parameters[i].ParameterName;
if (session.DataSource.DbProvider.UseParameterPrefixInParameter)
{
if (parameterName.StartsWith(session.DataSource.DbProvider.ParameterPrefix))
{
int prefixLength = session.DataSource.DbProvider.ParameterPrefix.Length;
parameterName = parameterName.Substring(prefixLength);
}
}
if (property.ColumnName.Equals(parameterName))
{
return parameters[i];
}
}
throw new IndexOutOfRangeException("The parameter '" + property.ColumnName + "' does not exist in the stored procedure '" +_statement.Id+"'. Check your parameterMap.");
}
else
{
return parameters[index];
}
}
/// <summary>
/// Sets the value to the parameter property.
/// </summary>
/// <remarks>Use to set value on output parameter</remarks>
/// <param name="mapping"></param>
/// <param name="target"></param>
/// <param name="dataBaseValue"></param>
public override void SetData(ref object target, ParameterProperty mapping, object dataBaseValue)
{
if (mapping.IsComplexMemberName)
{
ObjectProbe.SetMemberValue(target, mapping.PropertyName, dataBaseValue,
this.DataExchangeFactory.ObjectFactory,
this.DataExchangeFactory.AccessorFactory);
}
else
{
ISetAccessorFactory setAccessorFactory = this.DataExchangeFactory.AccessorFactory.SetAccessorFactory;
ISetAccessor _setAccessor = setAccessorFactory.CreateSetAccessor(_parameterClass, mapping.PropertyName);
_setAccessor.Set(target, dataBaseValue);
}
}
/// <summary>
/// Parse inline parameter with syntax as
/// #propertyName:dbType:nullValue#
/// </summary>
/// <param name="token"></param>
/// <param name="parameterClassType"></param>
/// <param name="scope"></param>
/// <returns></returns>
private ParameterProperty OldParseMapping(string token, Type parameterClassType, IScope scope)
{
ParameterProperty mapping = new ParameterProperty();
if (token.IndexOf(PARAM_DELIM) > -1)
{
StringTokenizer paramParser = new StringTokenizer(token, PARAM_DELIM, true);
IEnumerator enumeratorParam = paramParser.GetEnumerator();
int n1 = paramParser.TokenNumber;
if (n1 == 3)
{
enumeratorParam.MoveNext();
string propertyName = ((string)enumeratorParam.Current).Trim();
mapping.PropertyName = propertyName;
enumeratorParam.MoveNext();
enumeratorParam.MoveNext(); //ignore ":"
string dBType = ((string)enumeratorParam.Current).Trim();
mapping.DbType = dBType;
ITypeHandler handler = null;
if (parameterClassType == null)
{
handler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
else
{
handler = ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, propertyName, null, dBType);
}
mapping.TypeHandler = handler;
mapping.Initialize(scope, parameterClassType);
}
else if (n1 >= 5)
{
enumeratorParam.MoveNext();
string propertyName = ((string)enumeratorParam.Current).Trim();
enumeratorParam.MoveNext();
enumeratorParam.MoveNext(); //ignore ":"
string dBType = ((string)enumeratorParam.Current).Trim();
enumeratorParam.MoveNext();
enumeratorParam.MoveNext(); //ignore ":"
string nullValue = ((string)enumeratorParam.Current).Trim();
while (enumeratorParam.MoveNext())
{
nullValue = nullValue + ((string)enumeratorParam.Current).Trim();
}
mapping.PropertyName = propertyName;
mapping.DbType = dBType;
mapping.NullValue = nullValue;
ITypeHandler handler = null;
if (parameterClassType == null)
{
handler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
else
{
handler = ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, propertyName, null, dBType);
}
mapping.TypeHandler = handler;
mapping.Initialize(scope, parameterClassType);
}
else
{
throw new ConfigurationException("Incorrect inline parameter map format: " + token);
}
}
else
{
mapping.PropertyName = token;
ITypeHandler handler = null;
if (parameterClassType == null)
{
handler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
else
{
handler = ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, token, null, null);
}
mapping.TypeHandler = handler;
mapping.Initialize(scope, parameterClassType);
}
return(mapping);
}
private ParameterProperty NewParseMapping(string token, Type parameterClassType, IScope scope)
{
ParameterProperty property = new ParameterProperty();
IEnumerator enumerator = new StringTokenizer(token, "=,", false).GetEnumerator();
enumerator.MoveNext();
property.PropertyName = ((string)enumerator.Current).Trim();
while (enumerator.MoveNext())
{
string current = (string)enumerator.Current;
if (!enumerator.MoveNext())
{
throw new DataMapperException("Incorrect inline parameter map format (missmatched name=value pairs): " + token);
}
string str2 = (string)enumerator.Current;
if (!"type".Equals(current))
{
if (!"dbType".Equals(current))
{
if (!"direction".Equals(current))
{
if (!"nullValue".Equals(current))
{
if (!"handler".Equals(current))
{
throw new DataMapperException("Unrecognized parameter mapping field: '" + current + "' in " + token);
}
property.CallBackName = str2;
}
else
{
property.NullValue = str2;
}
}
else
{
property.DirectionAttribute = str2;
}
continue;
}
property.DbType = str2;
}
else
{
property.CLRType = str2;
continue;
}
}
if (property.CallBackName.Length > 0)
{
property.Initialize(scope, parameterClassType);
return(property);
}
ITypeHandler unkownTypeHandler = null;
if (parameterClassType == null)
{
unkownTypeHandler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
else
{
unkownTypeHandler = this.ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, property.PropertyName, property.CLRType, property.DbType);
}
property.TypeHandler = unkownTypeHandler;
property.Initialize(scope, parameterClassType);
return(property);
}
/// <summary>
/// Sets the value to the parameter property.
/// </summary>
/// <remarks>Use to set value on output parameter</remarks>
/// <param name="mapping"></param>
/// <param name="target"></param>
/// <param name="dataBaseValue"></param>
public override void SetData(ref object target, ParameterProperty mapping, object dataBaseValue)
{
target = dataBaseValue;
}
/// <summary> /// Gets the data to be set into a IDataParameter. /// </summary> /// <param name="mapping"></param> /// <param name="parameterObject"></param> public abstract object GetData(ParameterProperty mapping, object parameterObject);
/// <summary>
/// Remove a ParameterProperty of the collection.
/// </summary>
public void Remove(ParameterProperty value)
{
for(int i = 0; i < _count; i++)
{
if(_innerList[i].PropertyName==value.PropertyName)
{
RemoveAt(i);
return;
}
}
}
/// <summary>
/// Insert a ParameterProperty in the collection.
/// </summary>
/// <param name="index">Index where to insert.</param>
/// <param name="value">A ParameterProperty</param>
public void Insert(int index, ParameterProperty value)
{
if (index < 0 || index > _count)
{
throw new ArgumentOutOfRangeException("index");
}
Resize(_count + 1);
Array.Copy(_innerList, index, _innerList, index + 1, _count - index);
_innerList[index] = value;
_count++;
}
/// <summary>
/// Set output parameter value.
/// </summary>
/// <param name="mapping"></param>
/// <param name="dataBaseValue"></param>
/// <param name="target"></param>
public void SetOutputParameter(ref object target, ParameterProperty mapping, object dataBaseValue)
{
_dataExchange.SetData(ref target, mapping, dataBaseValue);
}
/// <summary>
/// Gets the data to be set into a IDataParameter.
/// </summary>
/// <param name="mapping"></param>
/// <param name="parameterObject"></param>
public override object GetData(ParameterProperty mapping, object parameterObject)
{
return ObjectProbe.GetMemberValue(parameterObject, mapping.PropertyName,
this.DataExchangeFactory.AccessorFactory);
}
/// <summary>
/// Add an ParameterProperty
/// </summary>
/// <param name="value"></param>
/// <returns>Index</returns>
public int Add(ParameterProperty value)
{
Resize(_count + 1);
int index = _count++;
_innerList[index] = value;
return index;
}
/// <summary>
/// Parse Inline ParameterMap
/// </summary>
/// <param name="statement"></param>
/// <param name="sqlStatement"></param>
/// <returns>A new sql command text.</returns>
/// <param name="scope"></param>
public SqlText ParseInlineParameterMap(IScope scope, IStatement statement, string sqlStatement)
{
string newSql = sqlStatement;
ArrayList mappingList = new ArrayList();
Type parameterClassType = null;
if (statement != null)
{
parameterClassType = statement.ParameterClass;
}
StringTokenizer parser = new StringTokenizer(sqlStatement, PARAMETER_TOKEN, true);
StringBuilder newSqlBuffer = new StringBuilder();
string token = null;
string lastToken = null;
IEnumerator enumerator = parser.GetEnumerator();
while (enumerator.MoveNext())
{
token = (string)enumerator.Current;
if (PARAMETER_TOKEN.Equals(lastToken))
{
if (PARAMETER_TOKEN.Equals(token))
{
newSqlBuffer.Append(PARAMETER_TOKEN);
token = null;
}
else
{
ParameterProperty mapping = null;
if (token.IndexOf(PARAM_DELIM) > -1)
{
mapping = OldParseMapping(token, parameterClassType, scope);
}
else
{
mapping = NewParseMapping(token, parameterClassType, scope);
}
mappingList.Add(mapping);
newSqlBuffer.Append("? ");
enumerator.MoveNext();
token = (string)enumerator.Current;
if (!PARAMETER_TOKEN.Equals(token))
{
throw new DataMapperException("Unterminated inline parameter in mapped statement (" + statement.Id + ").");
}
token = null;
}
}
else
{
if (!PARAMETER_TOKEN.Equals(token))
{
newSqlBuffer.Append(token);
}
}
lastToken = token;
}
newSql = newSqlBuffer.ToString();
ParameterProperty[] mappingArray = (ParameterProperty[])mappingList.ToArray(typeof(ParameterProperty));
SqlText sqlText = new SqlText();
sqlText.Text = newSql;
sqlText.Parameters = mappingArray;
return(sqlText);
}
/// <summary>
/// Clones this instance.
/// </summary>
/// <returns>An <see cref="ParameterProperty"/></returns>
public ParameterProperty Clone()
{
ParameterProperty property = new ParameterProperty();
property.CallBackName = this.CallBackName;
property.CLRType = this.CLRType;
property.ColumnName = this.ColumnName;
property.DbType = this.DbType;
property.DirectionAttribute = this.DirectionAttribute;
property.NullValue = this.NullValue;
property.PropertyName = this.PropertyName;
property.Precision = this.Precision;
property.Scale = this.Scale;
property.Size = this.Size;
return property;
}
/// <summary>
///
/// </summary>
/// <param name="mapping"></param>
public void AddParameterMapping(ParameterProperty mapping)
{
_parameterMappings.Add(mapping);
}
/// <summary>
/// Insert a ParameterProperty ine the ParameterProperty list at the specified index..
/// </summary>
/// <param name="index">
/// The zero-based index at which ParameterProperty should be inserted.
/// </param>
/// <param name="property">The ParameterProperty to insert. </param>
public void InsertParameterProperty(int index, ParameterProperty property)
{
// These mappings will replace any mappings that this map
// had for any of the keys currently in the specified map.
_propertiesMap[property.PropertyName] = property;
_properties.Insert( index, property );
if (_propertiesList.Contains(property) == false)
{
_propertiesList.Insert( index, property );
}
}
/// <summary> /// Sets the value to the parameter property. /// </summary> /// <remarks>Use to set value on output parameter</remarks> /// <param name="mapping"></param> /// <param name="target"></param> /// <param name="dataBaseValue"></param> public abstract void SetData(ref object target, ParameterProperty mapping, object dataBaseValue);
/// <summary>
/// Set output parameter value.
/// </summary>
/// <param name="mapping"></param>
/// <param name="dataBaseValue"></param>
/// <param name="target"></param>
public void SetOutputParameter(ref object target, ParameterProperty mapping, object dataBaseValue )
{
_dataExchange.SetData(ref target, mapping, dataBaseValue);
}
/// <summary>
/// Set parameter value, replace the null value if any.
/// </summary>
/// <param name="mapping"></param>
/// <param name="dataParameter"></param>
/// <param name="parameterValue"></param>
public void SetParameter(ParameterProperty mapping, IDataParameter dataParameter, object parameterValue)
{
object value = _dataExchange.GetData(mapping, parameterValue);
ITypeHandler typeHandler = mapping.TypeHandler;
// Apply Null Value
if (mapping.HasNullValue)
{
if (typeHandler.Equals(value, mapping.NullValue))
{
value = null;
}
}
typeHandler.SetParameter(dataParameter, value, mapping.DbType);
}
/// <summary>
/// Parse inline parameter with syntax as
/// #propertyName,type=string,dbype=Varchar,direction=Input,nullValue=N/A,handler=string#
/// </summary>
/// <param name="token"></param>
/// <param name="parameterClassType"></param>
/// <param name="scope"></param>
/// <returns></returns>
private ParameterProperty NewParseMapping(string token, Type parameterClassType, IScope scope)
{
ParameterProperty mapping = new ParameterProperty();
StringTokenizer paramParser = new StringTokenizer(token, "=,", false);
IEnumerator enumeratorParam = paramParser.GetEnumerator();
enumeratorParam.MoveNext();
mapping.PropertyName = ((string)enumeratorParam.Current).Trim();
while (enumeratorParam.MoveNext())
{
string field = (string)enumeratorParam.Current;
if (enumeratorParam.MoveNext())
{
string value = (string)enumeratorParam.Current;
if ("type".Equals(field))
{
mapping.CLRType = value;
}
else if ("dbType".Equals(field))
{
mapping.DbType = value;
}
else if ("direction".Equals(field))
{
mapping.DirectionAttribute = value;
}
else if ("nullValue".Equals(field))
{
mapping.NullValue = value;
}
else if ("handler".Equals(field))
{
mapping.CallBackName = value;
}
else
{
throw new DataMapperException("Unrecognized parameter mapping field: '" + field + "' in " + token);
}
}
else
{
throw new DataMapperException("Incorrect inline parameter map format (missmatched name=value pairs): " + token);
}
}
if (mapping.CallBackName.Length >0)
{
mapping.Initialize( scope, parameterClassType );
}
else
{
ITypeHandler handler = null;
if (parameterClassType == null)
{
handler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
else
{
handler = ResolveTypeHandler( scope.DataExchangeFactory.TypeHandlerFactory,
parameterClassType, mapping.PropertyName,
mapping.CLRType, mapping.DbType );
}
mapping.TypeHandler = handler;
mapping.Initialize( scope, parameterClassType );
}
return mapping;
}
private ParameterProperty OldParseMapping(string token, Type parameterClassType, IScope scope)
{
ParameterProperty property = new ParameterProperty();
if (token.IndexOf(":") > -1)
{
StringTokenizer tokenizer = new StringTokenizer(token, ":", true);
IEnumerator enumerator = tokenizer.GetEnumerator();
int tokenNumber = tokenizer.TokenNumber;
if (tokenNumber == 3)
{
enumerator.MoveNext();
string str = ((string)enumerator.Current).Trim();
property.PropertyName = str;
enumerator.MoveNext();
enumerator.MoveNext();
string str2 = ((string)enumerator.Current).Trim();
property.DbType = str2;
ITypeHandler unkownTypeHandler = null;
if (parameterClassType == null)
{
unkownTypeHandler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
else
{
unkownTypeHandler = this.ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, str, null, str2);
}
property.TypeHandler = unkownTypeHandler;
property.Initialize(scope, parameterClassType);
return(property);
}
if (tokenNumber < 5)
{
throw new ConfigurationException("Incorrect inline parameter map format: " + token);
}
enumerator.MoveNext();
string propertyName = ((string)enumerator.Current).Trim();
enumerator.MoveNext();
enumerator.MoveNext();
string dbType = ((string)enumerator.Current).Trim();
enumerator.MoveNext();
enumerator.MoveNext();
string str5 = ((string)enumerator.Current).Trim();
while (enumerator.MoveNext())
{
str5 = str5 + ((string)enumerator.Current).Trim();
}
property.PropertyName = propertyName;
property.DbType = dbType;
property.NullValue = str5;
ITypeHandler handler2 = null;
if (parameterClassType == null)
{
handler2 = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
else
{
handler2 = this.ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, propertyName, null, dbType);
}
property.TypeHandler = handler2;
property.Initialize(scope, parameterClassType);
return(property);
}
property.PropertyName = token;
ITypeHandler handler3 = null;
if (parameterClassType == null)
{
handler3 = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
else
{
handler3 = this.ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, token, null, null);
}
property.TypeHandler = handler3;
property.Initialize(scope, parameterClassType);
return(property);
}
/// <summary>
/// Parse inline parameter with syntax as
/// #propertyName:dbType:nullValue#
/// </summary>
/// <param name="token"></param>
/// <param name="parameterClassType"></param>
/// <param name="scope"></param>
/// <returns></returns>
private ParameterProperty OldParseMapping(string token, Type parameterClassType, IScope scope)
{
ParameterProperty mapping = new ParameterProperty();
if (token.IndexOf(PARAM_DELIM) > -1)
{
StringTokenizer paramParser = new StringTokenizer(token, PARAM_DELIM, true);
IEnumerator enumeratorParam = paramParser.GetEnumerator();
int n1 = paramParser.TokenNumber;
if (n1 == 3)
{
enumeratorParam.MoveNext();
string propertyName = ((string)enumeratorParam.Current).Trim();
mapping.PropertyName = propertyName;
enumeratorParam.MoveNext();
enumeratorParam.MoveNext(); //ignore ":"
string dBType = ((string)enumeratorParam.Current).Trim();
mapping.DbType = dBType;
ITypeHandler handler = null;
if (parameterClassType == null)
{
handler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
else
{
handler = ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, propertyName, null, dBType);
}
mapping.TypeHandler = handler;
mapping.Initialize( scope, parameterClassType );
}
else if (n1 >= 5)
{
enumeratorParam.MoveNext();
string propertyName = ((string)enumeratorParam.Current).Trim();
enumeratorParam.MoveNext();
enumeratorParam.MoveNext(); //ignore ":"
string dBType = ((string)enumeratorParam.Current).Trim();
enumeratorParam.MoveNext();
enumeratorParam.MoveNext(); //ignore ":"
string nullValue = ((string)enumeratorParam.Current).Trim();
while (enumeratorParam.MoveNext())
{
nullValue = nullValue + ((string)enumeratorParam.Current).Trim();
}
mapping.PropertyName = propertyName;
mapping.DbType = dBType;
mapping.NullValue = nullValue;
ITypeHandler handler = null;
if (parameterClassType == null)
{
handler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
else
{
handler = ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, propertyName, null, dBType);
}
mapping.TypeHandler = handler;
mapping.Initialize( scope, parameterClassType );
}
else
{
throw new ConfigurationException("Incorrect inline parameter map format: " + token);
}
}
else
{
mapping.PropertyName = token;
ITypeHandler handler = null;
if (parameterClassType == null)
{
handler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
else
{
handler = ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, token, null, null);
}
mapping.TypeHandler = handler;
mapping.Initialize( scope, parameterClassType );
}
return mapping;
}
/// <summary>
/// Add a list of ParameterProperty to the collection
/// </summary>
/// <param name="value"></param>
public void AddRange(ParameterProperty[] value)
{
for (int i = 0; i < value.Length; i++)
{
Add(value[i]);
}
}
/// <summary>
/// Parse inline parameter with syntax as
/// #propertyName,type=string,dbype=Varchar,direction=Input,nullValue=N/A,handler=string#
/// </summary>
/// <param name="token"></param>
/// <param name="parameterClassType"></param>
/// <param name="scope"></param>
/// <returns></returns>
private ParameterProperty NewParseMapping(string token, Type parameterClassType, IScope scope)
{
ParameterProperty mapping = new ParameterProperty();
StringTokenizer paramParser = new StringTokenizer(token, "=,", false);
IEnumerator enumeratorParam = paramParser.GetEnumerator();
enumeratorParam.MoveNext();
mapping.PropertyName = ((string)enumeratorParam.Current).Trim();
while (enumeratorParam.MoveNext())
{
string field = (string)enumeratorParam.Current;
if (enumeratorParam.MoveNext())
{
string value = (string)enumeratorParam.Current;
if ("type".Equals(field))
{
mapping.CLRType = value;
}
else if ("dbType".Equals(field))
{
mapping.DbType = value;
}
else if ("direction".Equals(field))
{
mapping.DirectionAttribute = value;
}
else if ("nullValue".Equals(field))
{
mapping.NullValue = value;
}
else if ("handler".Equals(field))
{
mapping.CallBackName = value;
}
else
{
throw new DataMapperException("Unrecognized parameter mapping field: '" + field + "' in " + token);
}
}
else
{
throw new DataMapperException("Incorrect inline parameter map format (missmatched name=value pairs): " + token);
}
}
if (mapping.CallBackName.Length > 0)
{
mapping.Initialize(scope, parameterClassType);
}
else
{
ITypeHandler handler = null;
if (parameterClassType == null)
{
handler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
else
{
handler = ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory,
parameterClassType, mapping.PropertyName,
mapping.CLRType, mapping.DbType);
}
mapping.TypeHandler = handler;
mapping.Initialize(scope, parameterClassType);
}
return(mapping);
}
/// <summary>
/// Sets the value to the parameter property.
/// </summary>
/// <remarks>Use to set value on output parameter</remarks>
/// <param name="mapping"></param>
/// <param name="target"></param>
/// <param name="dataBaseValue"></param>
public override void SetData(ref object target, ParameterProperty mapping, object dataBaseValue)
{
ObjectProbe.SetMemberValue(target, mapping.PropertyName, dataBaseValue,
this.DataExchangeFactory.ObjectFactory,
this.DataExchangeFactory.AccessorFactory);
}
/// <summary>
/// Indicate if a ParameterProperty is in the collection
/// </summary>
/// <param name="value">A ParameterProperty</param>
/// <returns>True fi is in</returns>
public bool Contains(ParameterProperty value)
{
for (int i = 0; i < _count; i++)
{
if(_innerList[i].PropertyName==value.PropertyName)
{
return true;
}
}
return false;
}
