Beispiel #1
0
        /// <summary>
        /// Allows this <see cref="HsqlCommandBuilder"/>
        /// to handle additional parameter properties.
        /// </summary>
        /// <param name="parameter">
        /// A <see cref="DbParameter"/> to which the additional
        /// modifications are applied.
        /// </param>
        /// <param name="row">
        /// The <see cref="DataRow"/> from the schema table
        /// provided by <see cref="DbDataReader.GetSchemaTable"/>.
        /// </param>
        /// <param name="statementType">
        /// The type of command being generated; INSERT, UPDATE or DELETE.
        /// </param>
        /// <param name="whereClause">
        /// <c>true</c> if the parameter is part of the update or delete
        /// <c>WHERE</c> clause; <c>false</c> if it is part of the insert
        /// or update values.
        /// </param>
        protected override void ApplyParameterInfo(
            DbParameter parameter,
            DataRow row,
            StatementType statementType,
            bool whereClause)
        {
            HsqlParameter parm = (HsqlParameter)parameter;

            int?providerType = row[SchemaTableColumn.ProviderType] as int?;

            if (providerType != null)
            {
                parm.ProviderType = (HsqlProviderType)providerType;
            }
        }
        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>
        /// Returns a new cloned instance of this parameter.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Special handling is provided when <c>Value</c> is
        /// of type <c>byte[]</c>, <c>char[]</c> or <c>ICloneable</c>.
        /// </para>
        /// <para>
        /// Case 1:
        /// </para>
        /// <para>
        /// When the source <c>Value</c> is of type <c>byte[]</c> or
        /// <c>char[]</c>, then the source <c>Offset</c> and <c>Size</c>
        /// properties are taken into consideration.  Specifically, the
        /// destination <c>Offset</c> is assigned zero (0) and the destination
        /// <c>Value</c> is assigned a copy of the source <c>Value</c> that
        /// starts from the source <c>Offset</c>.  When the source <c>Size</c>
        /// is zero (0), then <c>Value.Length - Offset</c> elements are
        /// copied; otherwise, the lower of <c>Size</c> or <c>Value.Length
        /// - Offset</c> elements are copied.
        /// </para>
        /// <para>
        /// Case 2:
        /// </para>
        /// <para>
        /// When the source <c>Value</c> is <c>ICloneable</c> then the target
        /// <c>Value</c> is assigned a clone of the source <c>Value</c>.
        /// </para>
        /// <para>
        /// Case 3:
        /// </para>
        /// <para>
        /// The target <c>Value</c> is assigned directly from the source
        /// <c>Value</c>.
        /// </para>
        /// </remarks>
        /// <returns>
        /// The cloned <see cref="HsqlParameter"/> instance.
        /// </returns>
        public HsqlParameter Clone()
        {
            HsqlParameter parameter = new HsqlParameter();

            parameter.m_assigned = m_assigned;
            parameter.m_dataRowVersion = m_dataRowVersion;
            parameter.m_dbType = m_dbType;
            parameter.m_direction = m_direction;
            parameter.m_forceSize = m_forceSize;
            parameter.m_hsqlDbType = m_hsqlDbType;
            parameter.m_inferProviderType = m_inferProviderType;
            parameter.m_name = m_name;
            parameter.m_nullable = m_nullable;
            parameter.m_precision = m_precision;
            parameter.m_scale = m_scale;
            parameter.m_size = m_size;
            parameter.m_sourceColumn = m_sourceColumn;
            parameter.m_sourceColumnNullMapping = m_sourceColumnNullMapping;
            parameter.m_suppressed = m_suppressed;

            byte[] bytes;
            char[] chars;

            if (null != (bytes = m_value as byte[]))
            {
                int targetLength = bytes.Length - m_offset;

                if ((m_size != 0) && (m_size < targetLength))
                {
                    targetLength = m_size;
                }

                byte[] targetValue = new byte[Math.Max(targetLength, 0)];

                Buffer.BlockCopy(
                    bytes,
                    m_offset,
                    targetValue,
                    0,
                    targetValue.Length);

                parameter.m_offset = 0;
                parameter.m_value = targetValue;
            }
            else if (null != (chars = m_value as char[]))
            {
                int targetLength = chars.Length - m_offset;

                if ((m_size != 0) && (m_size < targetLength))
                {
                    targetLength = m_size;
                }

                char[] targetValue = new char[Math.Max(targetLength, 0)];

                Buffer.BlockCopy(
                    chars,
                    m_offset,
                    targetValue,
                    0,
                    targetValue.Length * 2);

                parameter.m_offset = 0;
                parameter.m_value = targetValue;
            }
            else
            {
                parameter.m_offset = m_offset;

                ICloneable cloneable = m_value as ICloneable;

                parameter.m_value = (cloneable == null)
                    ? m_value
                    : cloneable.Clone();
            }

            return parameter;
        }
Beispiel #4
0
        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);
            }
        }
Beispiel #5
0
        /// <summary>
        /// Returns a new cloned instance of this parameter.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Special handling is provided when <c>Value</c> is
        /// of type <c>byte[]</c>, <c>char[]</c> or <c>ICloneable</c>.
        /// </para>
        /// <para>
        /// Case 1:
        /// </para>
        /// <para>
        /// When the source <c>Value</c> is of type <c>byte[]</c> or
        /// <c>char[]</c>, then the source <c>Offset</c> and <c>Size</c>
        /// properties are taken into consideration.  Specifically, the
        /// destination <c>Offset</c> is assigned zero (0) and the destination
        /// <c>Value</c> is assigned a copy of the source <c>Value</c> that
        /// starts from the source <c>Offset</c>.  When the source <c>Size</c>
        /// is zero (0), then <c>Value.Length - Offset</c> elements are
        /// copied; otherwise, the lower of <c>Size</c> or <c>Value.Length
        /// - Offset</c> elements are copied.
        /// </para>
        /// <para>
        /// Case 2:
        /// </para>
        /// <para>
        /// When the source <c>Value</c> is <c>ICloneable</c> then the target
        /// <c>Value</c> is assigned a clone of the source <c>Value</c>.
        /// </para>
        /// <para>
        /// Case 3:
        /// </para>
        /// <para>
        /// The target <c>Value</c> is assigned directly from the source
        /// <c>Value</c>.
        /// </para>
        /// </remarks>
        /// <returns>
        /// The cloned <see cref="HsqlParameter"/> instance.
        /// </returns>
        public HsqlParameter Clone()
        {
            HsqlParameter parameter = new HsqlParameter();

            parameter.m_assigned          = m_assigned;
            parameter.m_dataRowVersion    = m_dataRowVersion;
            parameter.m_dbType            = m_dbType;
            parameter.m_direction         = m_direction;
            parameter.m_forceSize         = m_forceSize;
            parameter.m_hsqlDbType        = m_hsqlDbType;
            parameter.m_inferProviderType = m_inferProviderType;
            parameter.m_name                    = m_name;
            parameter.m_nullable                = m_nullable;
            parameter.m_precision               = m_precision;
            parameter.m_scale                   = m_scale;
            parameter.m_size                    = m_size;
            parameter.m_sourceColumn            = m_sourceColumn;
            parameter.m_sourceColumnNullMapping = m_sourceColumnNullMapping;
            parameter.m_suppressed              = m_suppressed;

            byte[] bytes;
            char[] chars;

            if (null != (bytes = m_value as byte[]))
            {
                int targetLength = bytes.Length - m_offset;

                if ((m_size != 0) && (m_size < targetLength))
                {
                    targetLength = m_size;
                }

                byte[] targetValue = new byte[Math.Max(targetLength, 0)];

                Buffer.BlockCopy(
                    bytes,
                    m_offset,
                    targetValue,
                    0,
                    targetValue.Length);

                parameter.m_offset = 0;
                parameter.m_value  = targetValue;
            }
            else if (null != (chars = m_value as char[]))
            {
                int targetLength = chars.Length - m_offset;

                if ((m_size != 0) && (m_size < targetLength))
                {
                    targetLength = m_size;
                }

                char[] targetValue = new char[Math.Max(targetLength, 0)];

                Buffer.BlockCopy(
                    chars,
                    m_offset,
                    targetValue,
                    0,
                    targetValue.Length * 2);

                parameter.m_offset = 0;
                parameter.m_value  = targetValue;
            }
            else
            {
                parameter.m_offset = m_offset;

                ICloneable cloneable = m_value as ICloneable;

                parameter.m_value = (cloneable == null)
                    ? m_value
                    : cloneable.Clone();
            }

            return(parameter);
        }