/// <summary>
/// Creates the parameterized query.
/// </summary>
/// <param name="source">The nodes.</param>
/// <param name="tableName">Name of the table.</param>
/// <param name="commandTextType">Type of the command text.</param>
/// <returns>
/// Returns a <see cref="String" /> representing the parameterized query.
/// </returns>
public static string CreateCommandText(this DbParameterCollection source, string tableName, CommandTextType commandTextType)
{
if (source == null)
{
return(null);
}
string commandText;
if (commandTextType == CommandTextType.InsertCommand)
{
string values = string.Join(", ", source.Cast <DbParameter>().Select(o => ":" + o.ParameterName).ToArray());
string columns = string.Join(", ", source.Cast <DbParameter>().Select(o => o.ParameterName).ToArray());
commandText = string.Format("INSERT INTO {0} ({1}) VALUES ({2})", tableName, columns, values);
}
else if (commandTextType == CommandTextType.UpdateCommand)
{
string values = string.Join(", ", source.Cast <DbParameter>().Select(o => o + " = :" + o.ParameterName).ToArray());
commandText = string.Format("UPDATE {0} SET {1}", tableName, values);
}
else
{
string values = string.Join(" AND ", source.Cast <DbParameter>().Select(o => o + " = :" + o.ParameterName).ToArray());
commandText = string.Format("DELETE FROM {0} WHERE {1}", tableName, values);
}
foreach (DbParameter parameter in source)
{
parameter.ParameterName = string.Format(":{0}", parameter.ParameterName.ToUpperInvariant());
}
return(commandText);
}
public IReadOnlyDictionary <ParameterType, object> GetParameterLookup(bool async, CancellationToken cancellationToken)
{
var parameters = DbParameterCollection.Cast <DbParameter>().ToArray();
var lookup = new Dictionary <ParameterType, object>
{
{ ParameterType.Buffered, GetBufferedParameter(async) },
{ ParameterType.CommandTimeout, CommandTimeout == 0 ? default(int?) : CommandTimeout },
{ ParameterType.CommandType, CommandType == 0 ? default(CommandType?) : CommandType },
{ ParameterType.Map, GetMap() },
{ ParameterType.SplitOn, GetSplitOn() },
{ ParameterType.SqlParameters, _settings.SqlParametersBuilder.FromParameters(parameters) },
{ ParameterType.SqlText, _settings.CommandTextHelper.ConvertDapperParametersToUserParameters(CommandText) },
{ ParameterType.SqlTransaction, DbTransaction },
{ ParameterType.Type, _identity.Value.type },
{ ParameterType.Types, GetDataTypes() }
};
lookup[ParameterType.CommandDefinition] = new CommandDefinition(
(string)lookup[ParameterType.SqlText],
lookup[ParameterType.SqlParameters],
(IDbTransaction)lookup[ParameterType.SqlTransaction],
(int?)lookup[ParameterType.CommandTimeout],
(CommandType?)lookup[ParameterType.CommandType],
GetBufferedParameter(async)
? CommandFlags.Buffered
: CommandFlags.None,
cancellationToken
);
return(lookup);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public static string FormatParameters(
[NotNull] this DbParameterCollection parameters,
bool logParameterValues)
=> parameters
.Cast <DbParameter>()
.Select(
p => FormatParameter(
p.ParameterName,
logParameterValues ? p.Value : "?",
logParameterValues,
p.Direction,
p.DbType,
p.IsNullable,
p.Size,
p.Precision,
p.Scale))
.Join();
private void SortParameters(string query, DbParameterCollection parameters)
{
if (parameters.Count == 0)
{
return;
}
var parameterArray = parameters.Cast <OleDbParameter>().ToArray();
// ReSharper disable once CoVariantArrayConversion
Array.Sort(parameterArray, new ParameterPositionComparer(query));
parameters.Clear();
foreach (OleDbParameter parameter in parameterArray)
{
parameters.Add(new OleDbParameter(parameter.ParameterName, parameter.Value));
}
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public static IEnumerable <string> FormatParameterList(
[NotNull] this DbParameterCollection parameters,
bool logParameterValues)
{
return(parameters
.Cast <DbParameter>()
.Select(
p => FormatParameter(
p.ParameterName,
logParameterValues ? p.Value : "?",
logParameterValues,
p.Direction,
p.DbType,
p.IsNullable,
p.Size,
p.Precision,
p.Scale)));
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public static string FormatParameters(
[NotNull] this DbParameterCollection parameters,
bool logParameterValues)
=> parameters
.Cast <DbParameter>()
.Select(p => FormatParameter(p, logParameterValues)).Join();
public static string ToString(this DbParameterCollection parameters, string sqlQuery)
{
return(parameters.Cast <DbParameter>().Aggregate(sqlQuery, (current, p) => current.Replace(p.ParameterName, p.Value.ToString())));
}
public static DbParameter GetParameter(this DbParameterCollection parameters, string name)
{
return(parameters.Cast <DbParameter>().FirstOrDefault(item => item.ParameterName == name));
}
public static bool ContainsParameter(this DbParameterCollection parameters, string name)
{
return(parameters.Cast <DbParameter>().Any(item => item.ParameterName == name));
}
