/// <summary>
/// Constructs a new <c>HsqlCommand</c> instance that
/// is a copy of the given command object.
/// </summary>
/// <param name="srcCommand">The source command.</param>
private HsqlCommand(HsqlCommand srcCommand) : this()
{
m_commandTextHasParameters
= srcCommand.m_commandTextHasParameters;
if (srcCommand.m_commandTextHasParameters &&
(srcCommand.m_tokenList != null))
{
m_tokenList = srcCommand.m_tokenList.Clone();
}
this.CommandText = srcCommand.CommandText;
this.CommandTimeout = srcCommand.CommandTimeout;
this.CommandType = srcCommand.CommandType;
this.Connection = srcCommand.Connection;
this.DesignTimeVisible = srcCommand.DesignTimeVisible;
this.Transaction = srcCommand.Transaction; // CHECKME
this.UpdatedRowSource = srcCommand.UpdatedRowSource;
HsqlParameterCollection parameters = this.Parameters;
foreach (HsqlParameter parameter in srcCommand.Parameters)
{
parameters.Add(parameter.Clone());
}
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="HsqlParameterCollection"/> class that is a copy
/// of the given collection.
/// </summary>
/// <param name="from">The collection to copy</param>
internal HsqlParameterCollection(HsqlParameterCollection from)
: this()
{
int count = from.Count;
m_parameters = new List <HsqlParameter>(count);
for (int i = 0; i < count; i++)
{
SetParameter(i, from[i].Clone());
}
}
internal void DeriveParametersInternal()
{
if (CommandType != CommandType.StoredProcedure)
{
throw new InvalidOperationException(string.Format(
"Operation not supported for CommandType: "
+ CommandType.ToString()));
}
Prepare();
HsqlStatement statement = m_statement;
ParameterMetaData pmd = statement.ParameterDescriptor.metaData;
string[] parameterNames = pmd.colNames;
int count = parameterNames.Length;
HsqlParameter[] parameters = new HsqlParameter[count];
for (int i = 0; i < count; i++)
{
string name = parameterNames[i];
ParameterMode mode = (ParameterMode)pmd.paramMode[i];
int type = pmd.colTypes[i];
int precision = pmd.colSizes[i];
int scale = pmd.colScales[i];
int nullability = pmd.colNullable[i];
HsqlProviderType providerType = (HsqlProviderType)type;
DbType dbType = HsqlConvert.ToDbType(providerType);
ParameterDirection?direction = HsqlConvert.ToParameterDirection(mode);
bool?isNullable = IsNullable(nullability);
bool isCharacter = IsCharacterType(type);
bool isNumber = (!isCharacter) && IsNumberType(type);
bool isTemporal = !(isCharacter || isNumber) && IsTemporalType(type);
int size = ToBufferSize(type, precision);
if (isCharacter)
{
precision = 0;
scale = 0;
}
else if (isNumber || isTemporal)
{
if (precision == 0)
{
precision = ToDefaultPrecision(type);
}
}
HsqlParameter parameter = new HsqlParameter();
parameter.DbType = dbType;
if (direction != null)
{
parameter.Direction = direction.Value;
}
if (isNullable != null)
{
parameter.IsNullable = isNullable.Value;
}
parameter.ParameterName = name;
parameter.Precision = (byte)Math.Min(byte.MaxValue, precision);
parameter.ProviderType = providerType;
parameter.Scale = (byte)Math.Min(byte.MaxValue, scale);
parameter.Size = size;
parameter.SourceVersion = DataRowVersion.Default;
parameters[i] = parameter;
}
HsqlParameterCollection pc = Parameters;
pc.Clear();
foreach (HsqlParameter parameter in parameters)
{
pc.Add(parameter);
}
}
/// <summary>
/// Applies the current values in this object's parameter collection
/// to the internal statement object, if any, that represents the
/// prepared form of this command.
/// </summary>
/// <remarks>
/// <para>
/// If this command is not presently prepared, no action is taken.
/// </para>
/// <para>
/// On the other hand, this operation is invoked internally whenever
/// an <c>ExecuteXXX</c> operation is invoked on a prepared
/// <c>HsqlCommand</c> instance.
/// </para>
/// </remarks>
/// <param name="batch">
/// <c>true</c> to apply the parameters toward batch execution
/// </param>
/// <exception cref="HsqlDataSourceException">
/// When unbound parameters exist. An unbound parameter condition
/// occurs when a parameter's existence is declared in the command
/// text using a marker or can be inferred from
/// the signature of the stored procedure to be executed, and
/// the parameter collection of this <c>HsqlCommand</c> contains
/// no corresponding <c>HsqlParameter</c> instance or the
/// corresponding <c>HsqlParameter</c> instance exists, but either
/// it represents an explicitly required (non-defaulted) value binding
/// site and the value has not explicitly been set or it represents a
/// non-nullable binding site and its present value is either
/// implicitly null or has explicily been set null.
/// </exception>
internal void ApplyParameters(bool batch)
{
HsqlStatement statement = m_statement;
if (statement == null)
{
return;
}
HsqlParameterCollection parameters = m_dbParameterCollection;
if (parameters == null || parameters.Count == 0)
{
int expectedCount = statement.ParameterCount;
if (expectedCount == 0)
{
statement.SetParameterValues(s_noParameters);
return;
}
throw new HsqlDataSourceException(string.Format(
"{0} unbound parameters exist.",
expectedCount)); // NOI18N
}
TokenList tokenList = TokenList;
int[] bindTypes = statement.ParameterTypes;
object[] values = new object[tokenList.ParameterCount];
int boundValueCount = 0;
foreach (HsqlParameter parameter in parameters)
{
switch (parameter.Direction)
{
case ParameterDirection.Input:
case ParameterDirection.InputOutput:
{
string name = parameter.ParameterName;
int[] bindPositions = tokenList
.GetNamedParameterBindPositionsInternal(name);
for (int i = 0; i < bindPositions.Length; i++)
{
int bindPosition = bindPositions[i];
int bindType = bindTypes[bindPosition];
object value = HsqlConvert.FromDotNet.ToObject(
parameter.Value, bindType);
values[bindPosition] = value;
boundValueCount++;
}
break;
}
}
}
if (boundValueCount < values.Length)
{
int unboundCount = (values.Length - boundValueCount);
throw new HsqlDataSourceException(string.Format(
"{0} unbound Parameters Exist.", unboundCount)); // NOI18N
}
if (batch)
{
statement.AddBatch(values);
}
else
{
statement.SetParameterValues(values);
}
}
