/// <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>
/// 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>
/// 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);
}
/// <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 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>
/// 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>
/// Get the parameter properties child for the xmlNode parameter.
/// </summary>
/// <param name="configScope"></param>
public void BuildProperties(ConfigurationScope configScope)
{
ParameterProperty property = null;
foreach (XmlNode parameterNode in configScope.NodeContext.SelectNodes(DomSqlMapBuilder.ApplyMappingNamespacePrefix(XML_PARAMATER), configScope.XmlNamespaceManager))
{
property = ParameterPropertyDeSerializer.Deserialize(parameterNode, configScope);
property.Initialize(configScope, _parameterClass);
AddParameterProperty(property);
}
}
/// <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>
/// 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 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>
/// 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>
/// 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>
/// 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);
}