public object CastCLRValue(
[CanBeNull] object value,
[NotNull] Type clrType,
TypeConstraintMode mode = TypeConstraintMode.Warn)
{
return(Type.CastCLRValue(value, clrType, mode));
}
/// <summary>
/// Sets the SQL parameter value.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="parameter">The parameter.</param>
/// <param name="value">The value.</param>
/// <param name="mode">The mode.</param>
/// <exception cref="ArgumentNullException"><paramref name="parameter"/> is <see langword="null" />.</exception>
/// <exception cref="DatabaseSchemaException"><para>The type <typeparamref name="T" /> is invalid for the <see cref="Direction" />.</para>
/// <para>-or-</para>
/// <para>The type <typeparamref name="T" /> was unsupported.</para>
/// <para>-or-</para>
/// <para>A fatal error occurred.</para>
/// <para>-or-</para>
/// <para>The object exceeded the SQL type's maximum <see cref="SqlTypeSize">size</see>.</para>
/// <para>-or-</para>
/// <para>The serialized object was truncated.</para>
/// <para>-or-</para>
/// <para>Unicode characters were found and only ASCII characters are supported in the SQL type.</para>
/// <para>-or-</para>
/// <para>The date was outside the range of accepted dates for the SQL type.</para></exception>
public void SetSqlParameterValue <T>(
[NotNull] SqlParameter parameter,
T value,
TypeConstraintMode mode = TypeConstraintMode.Warn)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (value == null)
{
parameter.Value = Type.IsTable ? null : DBNull.Value;
return;
}
IOut output = value as IOut;
if (output != null)
{
bool hasInput = output?.InputValue.IsAssigned ?? false;
string dir = hasInput ? "input/output" : "output";
switch (Direction)
{
case ParameterDirection.Input:
throw new DatabaseSchemaException(
LoggingLevel.Error,
() => "Cannot pass {0} value to input only parameter {1}",
dir,
FullName);
case ParameterDirection.Output:
case ParameterDirection.ReturnValue:
if (hasInput)
{
throw new DatabaseSchemaException(
LoggingLevel.Error,
() => "Cannot pass {0} value to output only parameter {1}",
dir,
FullName);
}
break;
}
output.SetParameter(parameter);
if (hasInput)
{
parameter.Value = Type.CastCLRValue(output.InputValue.Value, output.Type, mode);
}
}
else
{
parameter.Value = Type.CastCLRValue(value, mode);
}
}
public object CastCLRValue <T>(T value, TypeConstraintMode mode = TypeConstraintMode.Warn)
{
// TODO What about SqlMetaData.Adjust()?
return(Type.CastCLRValue(value, mode));
}
public async Task<SqlProgram> GetSqlProgram(
[NotNull] string name,
[CanBeNull] IEnumerable<KeyValuePair<string, Type>> parameters = null,
bool? ignoreValidationErrors = null,
bool? checkOrder = null,
TimeSpan? defaultCommandTimeout = null,
TypeConstraintMode? constraintMode = null,
CancellationToken cancellationToken = default(CancellationToken))
{
if (name == null) throw new ArgumentNullException(nameof(name));
// Grab the default load balanced connection for the database.
// ReSharper disable once PossibleNullReferenceException
LoadBalancedConnectionElement connectionElement = Connections.FirstOrDefault(c => c.Enabled);
if (connectionElement == null)
throw new LoggingException(
() => Resources.DatabaseElement_GetSqlProgram_DefaultLoadBalanceConnectionNotFound,
Id);
// Look for program mapping information
ProgramElement prog = Programs[name];
if (prog != null)
{
// Check for name mapping
if (!String.IsNullOrWhiteSpace(prog.MapTo))
// ReSharper disable once AssignNullToNotNullAttribute
name = prog.MapTo;
// Set options if not already set.
ignoreValidationErrors = ignoreValidationErrors ?? prog.IgnoreValidationErrors;
checkOrder = checkOrder ?? prog.CheckOrder;
defaultCommandTimeout = defaultCommandTimeout ?? prog.DefaultCommandTimeout;
constraintMode = constraintMode ?? prog.ConstraintMode;
if (!String.IsNullOrEmpty(prog.Connection))
{
// ReSharper disable once AssignNullToNotNullAttribute
connectionElement = Connections[prog.Connection];
if ((connectionElement == null) ||
(!connectionElement.Enabled))
throw new LoggingException(
() => Resources.DatabaseElement_GetSqlProgram_LoadBalanceConnectionNotFound,
prog.Connection,
Id,
name);
}
// Check for parameter mappings
if ((parameters != null) &&
prog.Parameters.Any())
parameters = parameters
.Select(
kvp =>
{
// ReSharper disable once AssignNullToNotNullAttribute
ParameterElement param = prog.Parameters[kvp.Key];
if (param == null) return kvp;
if (String.IsNullOrWhiteSpace(param.MapTo))
throw new LoggingException(
() => Resources.DatabaseElement_GetSqlProgram_MappingNotSpecified,
kvp.Key,
prog.Name);
return new KeyValuePair<string, Type>(param.MapTo, kvp.Value);
}).ToList();
}
if (ignoreValidationErrors == null) ignoreValidationErrors = false;
if (checkOrder == null) checkOrder = false;
if (constraintMode == null) constraintMode = TypeConstraintMode.Warn;
if (connectionElement == null)
throw new LoggingException(
() => Resources.DatabaseElement_GetSchemas_No_Connection,
Id);
LoadBalancedConnection connection =
await connectionElement.GetLoadBalancedConnection(cancellationToken).ConfigureAwait(false);
Debug.Assert(connection != null);
Debug.Assert(name != null);
return await SqlProgram.Create(
connection,
name,
parameters,
ignoreValidationErrors.Value,
checkOrder.Value,
defaultCommandTimeout,
(TypeConstraintMode)constraintMode,
cancellationToken).ConfigureAwait(false);
}
public object CastSQLValue <T>(T value, TypeConstraintMode mode = TypeConstraintMode.Warn)
{
return(Type.CastSQLValue(value, mode));
}
public object CastCLRValue <T>([CanBeNull] T value, TypeConstraintMode mode = TypeConstraintMode.Warn)
{
return(Type.CastCLRValue(value, mode));
}
