/// <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); } }