/// <summary>
/// Perform the bind operation for an individual parameter
/// </summary>
/// <param name="index">The index of the parameter to bind</param>
/// <param name="param">The parameter we're binding</param>
private void BindParameter(int index, SQLiteParameter param)
{
if (param == null)
throw new SQLiteException("Insufficient parameters supplied to the command");
object obj = param.Value;
DbType objType = param.DbType;
if ((obj != null) && (objType == DbType.Object))
objType = SQLiteConvert.TypeToDbType(obj.GetType());
if ((_flags & SQLiteConnectionFlags.LogPreBind) == SQLiteConnectionFlags.LogPreBind)
{
IntPtr handle = _sqlite_stmt;
SQLiteLog.LogMessage(String.Format(
"Binding statement {0} paramter #{1} with database type {2} and raw value {{{3}}}...",
handle, index, objType, obj));
}
if ((obj == null) || Convert.IsDBNull(obj))
{
_sql.Bind_Null(this, _flags, index);
return;
}
CultureInfo invariantCultureInfo = CultureInfo.InvariantCulture;
bool invariantText = ((_flags & SQLiteConnectionFlags.BindInvariantText)
== SQLiteConnectionFlags.BindInvariantText);
if ((_flags & SQLiteConnectionFlags.BindAllAsText) == SQLiteConnectionFlags.BindAllAsText)
{
if (obj is DateTime)
{
_sql.Bind_DateTime(this, _flags, index, (DateTime)obj);
}
else
{
_sql.Bind_Text(this, _flags, index, invariantText ?
SQLiteConvert.ToStringWithProvider(obj, invariantCultureInfo) :
obj.ToString());
}
return;
}
CultureInfo cultureInfo = CultureInfo.CurrentCulture;
if ((_flags & SQLiteConnectionFlags.ConvertInvariantText) == SQLiteConnectionFlags.ConvertInvariantText)
cultureInfo = invariantCultureInfo;
switch (objType)
{
case DbType.Date:
case DbType.Time:
case DbType.DateTime:
//
// NOTE: The old method (commented below) does not honor the selected date format
// for the connection.
// _sql.Bind_DateTime(this, index, Convert.ToDateTime(obj, cultureInfo));
_sql.Bind_DateTime(this, _flags, index, (obj is string) ?
_sql.ToDateTime((string)obj) : Convert.ToDateTime(obj, cultureInfo));
break;
case DbType.Boolean:
_sql.Bind_Int32(this, _flags, index, SQLiteConvert.ToBoolean(obj, cultureInfo, true) ? 1 : 0);
break;
case DbType.SByte:
_sql.Bind_Int32(this, _flags, index, Convert.ToSByte(obj, cultureInfo));
break;
case DbType.Int16:
_sql.Bind_Int32(this, _flags, index, Convert.ToInt16(obj, cultureInfo));
break;
case DbType.Int32:
_sql.Bind_Int32(this, _flags, index, Convert.ToInt32(obj, cultureInfo));
break;
case DbType.Int64:
_sql.Bind_Int64(this, _flags, index, Convert.ToInt64(obj, cultureInfo));
break;
case DbType.Byte:
_sql.Bind_UInt32(this, _flags, index, Convert.ToByte(obj, cultureInfo));
break;
case DbType.UInt16:
_sql.Bind_UInt32(this, _flags, index, Convert.ToUInt16(obj, cultureInfo));
break;
case DbType.UInt32:
_sql.Bind_UInt32(this, _flags, index, Convert.ToUInt32(obj, cultureInfo));
break;
case DbType.UInt64:
_sql.Bind_UInt64(this, _flags, index, Convert.ToUInt64(obj, cultureInfo));
break;
case DbType.Single:
case DbType.Double:
case DbType.Currency:
//case DbType.Decimal: // Dont store decimal as double ... loses precision
_sql.Bind_Double(this, _flags, index, Convert.ToDouble(obj, cultureInfo));
break;
case DbType.Binary:
_sql.Bind_Blob(this, _flags, index, (byte[])obj);
break;
case DbType.Guid:
if (_command.Connection._binaryGuid == true)
{
_sql.Bind_Blob(this, _flags, index, ((Guid)obj).ToByteArray());
}
else
{
_sql.Bind_Text(this, _flags, index, invariantText ?
SQLiteConvert.ToStringWithProvider(obj, invariantCultureInfo) :
obj.ToString());
}
break;
case DbType.Decimal: // Dont store decimal as double ... loses precision
_sql.Bind_Text(this, _flags, index, Convert.ToDecimal(obj, cultureInfo).ToString(invariantCultureInfo));
break;
default:
_sql.Bind_Text(this, _flags, index, invariantText ?
SQLiteConvert.ToStringWithProvider(obj, invariantCultureInfo) :
obj.ToString());
break;
}
}
/// <summary>
/// Clones a parameter
/// </summary>
/// <returns>A new, unassociated SQLiteParameter</returns>
public object Clone()
{
SQLiteParameter newparam = new SQLiteParameter(this);
return newparam;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Called by SQLiteParameterCollection, this function determines if the specified parameter name belongs to
/// this statement, and if so, keeps a reference to the parameter so it can be bound later.
/// </summary>
/// <param name="s">The parameter name to map</param>
/// <param name="p">The parameter to assign it</param>
internal bool MapParameter(string s, SQLiteParameter p)
{
if (_paramNames == null) return false;
int startAt = 0;
if (s.Length > 0)
{
if (":$@;".IndexOf(s[0]) == -1)
startAt = 1;
}
int x = _paramNames.Length;
for (int n = 0; n < x; n++)
{
if (String.Compare(_paramNames[n], startAt, s, 0, Math.Max(_paramNames[n].Length - startAt, s.Length), StringComparison.OrdinalIgnoreCase) == 0)
{
_paramValues[n] = p;
return true;
}
}
return false;
}
/// <summary>
/// Adds an array of parameters to the collection
/// </summary>
/// <param name="values">The array of parameters to add</param>
public void AddRange(SQLiteParameter[] values)
{
int x = values.Length;
for (int n = 0; n < x; n++)
Add(values[n]);
}
private SQLiteParameter(SQLiteParameter source)
: this(source.ParameterName, (DbType)source._dbType, 0, source.Direction, source.IsNullable, 0, 0, source.SourceColumn, source.SourceVersion, source.Value)
{
_nullMapping = source._nullMapping;
}
/// <summary>
/// Adds a named/unnamed parameter and its value to the parameter collection.
/// </summary>
/// <param name="parameterName">Name of the parameter, or null to indicate an unnamed parameter</param>
/// <param name="value">The initial value of the parameter</param>
/// <returns>Returns the SQLiteParameter object created during the call.</returns>
public SQLiteParameter AddWithValue(string parameterName, object value)
{
SQLiteParameter param = new SQLiteParameter(parameterName, value);
Add(param);
return param;
}
/// <summary>
/// Adds a parameter to the collection
/// </summary>
/// <param name="parameter">The parameter to add</param>
/// <returns>A zero-based index of where the parameter is located in the array</returns>
public int Add(SQLiteParameter parameter)
{
int n = -1;
if (String.IsNullOrEmpty(parameter.ParameterName) == false)
{
n = IndexOf(parameter.ParameterName);
}
if (n == -1)
{
n = _parameterList.Count;
_parameterList.Add((SQLiteParameter)parameter);
}
SetParameter(n, parameter);
return n;
}
/// <summary>
/// Adds a parameter to the collection
/// </summary>
/// <param name="parameterName">The parameter name</param>
/// <param name="parameterType">The data type</param>
/// <returns>A SQLiteParameter object</returns>
public SQLiteParameter Add(string parameterName, DbType parameterType)
{
SQLiteParameter param = new SQLiteParameter(parameterName, parameterType);
Add(param);
return param;
}
/// <summary>
/// Adds a parameter to the collection
/// </summary>
/// <param name="parameterName">The parameter name</param>
/// <param name="parameterType">The data type</param>
/// <param name="parameterSize">The size of the value</param>
/// <param name="sourceColumn">The source column</param>
/// <returns>A SQLiteParameter object</returns>
public SQLiteParameter Add(string parameterName, DbType parameterType, int parameterSize, string sourceColumn)
{
SQLiteParameter param = new SQLiteParameter(parameterName, parameterType, parameterSize, sourceColumn);
Add(param);
return param;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Minimal amount of parameter processing. Primarily sets the DbType for the parameter equal to the provider type in the schema
/// </summary>
/// <param name="parameter">The parameter to use in applying custom behaviors to a row</param>
/// <param name="row">The row to apply the parameter to</param>
/// <param name="statementType">The type of statement</param>
/// <param name="whereClause">Whether the application of the parameter is part of a WHERE clause</param>
protected override void ApplyParameterInfo(DbParameter parameter, DataRow row, StatementType statementType, bool whereClause)
{
SQLiteParameter param = (SQLiteParameter)parameter;
param.DbType = (DbType)row[SchemaTableColumn.ProviderType];
}