Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Data / System / Data / OleDb / OleDbParameter.cs / 1305376 / OleDbParameter.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
namespace System.Data.OleDb {
using System;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Data.ProviderBase;
using System.Diagnostics;
using System.Globalization;
[
System.ComponentModel.TypeConverterAttribute(typeof(System.Data.OleDb.OleDbParameter.OleDbParameterConverter))
]
public sealed partial class OleDbParameter : DbParameter, ICloneable, IDbDataParameter {
private NativeDBType _metaType;
private int _changeID;
private string _parameterName;
private byte _precision;
private byte _scale;
private bool _hasScale;
private NativeDBType _coerceMetaType;
public OleDbParameter() : base() { // V1.0 nothing
}
public OleDbParameter(string name, object value) : this() { // MDAC 59521
Debug.Assert(!(value is OleDbType), "use OleDbParameter(string, OleDbType)");
Debug.Assert(!(value is SqlDbType), "use OleDbParameter(string, OleDbType)");
ParameterName = name;
Value = value;
}
public OleDbParameter(string name, OleDbType dataType) : this() {
ParameterName = name;
OleDbType = dataType;
}
public OleDbParameter(string name, OleDbType dataType, int size) : this() {
ParameterName = name;
OleDbType = dataType;
Size = size;
}
public OleDbParameter(string name, OleDbType dataType, int size, string srcColumn) : this() {
ParameterName = name;
OleDbType = dataType;
Size = size;
SourceColumn = srcColumn;
}
[ EditorBrowsableAttribute(EditorBrowsableState.Advanced) ] // MDAC 69508
public OleDbParameter(string parameterName,
OleDbType dbType, int size,
ParameterDirection direction, Boolean isNullable,
Byte precision, Byte scale,
string srcColumn, DataRowVersion srcVersion,
object value) : this() { // V1.0 everything
ParameterName = parameterName;
OleDbType = dbType;
Size = size;
Direction = direction;
IsNullable = isNullable;
PrecisionInternal = precision;
ScaleInternal = scale;
SourceColumn = srcColumn;
SourceVersion = srcVersion;
Value = value;
}
[ EditorBrowsableAttribute(EditorBrowsableState.Advanced) ] // MDAC 69508
public OleDbParameter(string parameterName,
OleDbType dbType, int size,
ParameterDirection direction,
Byte precision, Byte scale,
string sourceColumn, DataRowVersion sourceVersion, bool sourceColumnNullMapping,
object value) : this() { // V2.0 everything - round trip all browsable properties + precision/scale
ParameterName = parameterName;
OleDbType = dbType;
Size = size;
Direction = direction;
PrecisionInternal = precision;
ScaleInternal = scale;
SourceColumn = sourceColumn;
SourceVersion = sourceVersion;
SourceColumnNullMapping = sourceColumnNullMapping;
Value = value;
}
internal int ChangeID {
get {
return _changeID;
}
}
override public DbType DbType {
get {
return GetBindType(Value).enumDbType;
}
set {
NativeDBType dbtype = _metaType;
if ((null == dbtype) || (dbtype.enumDbType != value)) { // MDAC 63571
PropertyTypeChanging();
_metaType = NativeDBType.FromDbType(value);
}
}
}
public override void ResetDbType() {
ResetOleDbType();
}
[
RefreshProperties(RefreshProperties.All),
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.OleDbParameter_OleDbType),
System.Data.Common.DbProviderSpecificTypePropertyAttribute(true),
]
public OleDbType OleDbType {
get {
return GetBindType(Value).enumOleDbType;
}
set {
NativeDBType dbtype = _metaType;
if ((null == dbtype) || (dbtype.enumOleDbType != value)) { // MDAC 63571
PropertyTypeChanging();
_metaType = NativeDBType.FromDataType(value);
}
}
}
private bool ShouldSerializeOleDbType() {
return (null != _metaType);
}
public void ResetOleDbType() {
if (null != _metaType) {
PropertyTypeChanging();
_metaType = null;
}
}
[
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.DbParameter_ParameterName),
]
override public string ParameterName { // V1.2.3300, XXXParameter V1.0.3300
get {
string parameterName = _parameterName;
return ((null != parameterName) ? parameterName : ADP.StrEmpty);
}
set {
if (_parameterName != value) {
PropertyChanging();
_parameterName = value;
}
}
}
[DefaultValue((Byte)0)] // MDAC 65862
[ResCategoryAttribute(Res.DataCategory_Data)]
[ResDescriptionAttribute(Res.DbDataParameter_Precision)]
public Byte Precision {
get {
return PrecisionInternal;
}
set {
PrecisionInternal = value;
}
}
internal byte PrecisionInternal {
get {
byte precision = _precision;
if (0 == precision) {
precision = ValuePrecision(Value);
}
return precision;
}
set {
if (_precision != value) {
PropertyChanging();
_precision = value;
}
}
}
private bool ShouldSerializePrecision() {
return (0 != _precision);
}
[DefaultValue((Byte)0)] // MDAC 65862
[ResCategoryAttribute(Res.DataCategory_Data)]
[ResDescriptionAttribute(Res.DbDataParameter_Scale)]
public Byte Scale {
get {
return ScaleInternal;
}
set {
ScaleInternal = value;
}
}
internal byte ScaleInternal {
get {
byte scale = _scale;
if (!ShouldSerializeScale(scale)) { // WebData 94688
scale = ValueScale(Value);
}
return scale;
}
set {
if (_scale != value || !_hasScale) {
PropertyChanging();
_scale = value;
_hasScale = true;
}
}
}
private bool ShouldSerializeScale() {
return ShouldSerializeScale(_scale);
}
private bool ShouldSerializeScale(byte scale) {
return _hasScale && ((0 != scale) || ShouldSerializePrecision());
}
object ICloneable.Clone() {
return new OleDbParameter(this);
}
private void CloneHelper(OleDbParameter destination) {
CloneHelperCore(destination);
destination._metaType = _metaType;
destination._parameterName = _parameterName;
destination._precision = _precision;
destination._scale = _scale;
destination._hasScale = _hasScale;
}
private void PropertyChanging() {
unchecked { _changeID++; }
}
private void PropertyTypeChanging() {
PropertyChanging();
_coerceMetaType = null;
CoercedValue = null;
}
// goal: call virtual property getters only once per parameter
internal bool BindParameter(int index, Bindings bindings) {
int changeID = _changeID;
object value = Value;
NativeDBType dbtype = GetBindType(value);
if (OleDbType.Empty == dbtype.enumOleDbType) {
throw ODB.UninitializedParameters(index, dbtype.enumOleDbType);
}
_coerceMetaType = dbtype;
value = CoerceValue(value, dbtype);
CoercedValue = value;
ParameterDirection direction = Direction;
byte precision;
if (ShouldSerializePrecision()) {
precision = PrecisionInternal;
}
else {
precision = ValuePrecision(value);
}
if (0 == precision) {
precision = dbtype.maxpre;
}
byte scale;
if (ShouldSerializeScale()) {
scale = ScaleInternal;
}
else {
scale = ValueScale(value);
}
int wtype = dbtype.wType;
int bytecount, size;
if (dbtype.islong) { // long data (image, text, ntext)
bytecount = ADP.PtrSize;
if (ShouldSerializeSize()) {
size = Size;
}
else {
if (NativeDBType.STR == dbtype.dbType) {
size = Int32.MaxValue; // WebData 98940
}
else if (NativeDBType.WSTR == dbtype.dbType) {
size = Int32.MaxValue/2;
}
else {
size = Int32.MaxValue;
}
}
wtype |= NativeDBType.BYREF;
}
else if (dbtype.IsVariableLength) { // variable length data (varbinary, varchar, nvarchar)
if (!ShouldSerializeSize() && ADP.IsDirection(this, ParameterDirection.Output)) {
throw ADP.UninitializedParameterSize(index, _coerceMetaType.dataType);
}
bool computedSize;
if (ShouldSerializeSize()) {
size = Size;
computedSize = false;
}
else {
size = ValueSize(value);
computedSize = true;
}
if (0 < size) {
if (NativeDBType.WSTR == dbtype.wType) {
// maximum 0x3FFFFFFE characters, computed this way to avoid overflow exception
bytecount = Math.Min(size, 0x3FFFFFFE) * 2 + 2;
}
else {
Debug.Assert(NativeDBType.STR != dbtype.wType, "should have ANSI binding, describing is okay");
bytecount = size;
}
if (computedSize) {
if (NativeDBType.STR == dbtype.dbType) { // WebData 98140
// maximum 0x7ffffffe characters, computed this way to avoid overflow exception
size = Math.Min(size, 0x3FFFFFFE) * 2;
}
}
if (ODB.LargeDataSize < bytecount) {
bytecount = ADP.PtrSize;
wtype |= NativeDBType.BYREF;
}
}
else if (0 == size) {
if (NativeDBType.WSTR == wtype) { // allow space for null termination character
bytecount = 2;
// 0 == size, okay for (STR == dbType)
}
else {
Debug.Assert(NativeDBType.STR != dbtype.wType, "should have ANSI binding, describing is okay");
bytecount = 0;
}
}
else if (-1 == size) {
bytecount = ADP.PtrSize;
wtype |= NativeDBType.BYREF;
}
else {
throw ADP.InvalidSizeValue(size);
}
}
else { // fixed length data
bytecount = dbtype.fixlen;
size = bytecount;
}
bindings.CurrentIndex = index;
// tagDBPARAMBINDINFO info for SetParameterInfo
bindings.DataSourceType = dbtype.dbString.DangerousGetHandle(); // NOTE: This is a constant and isn't exposed publicly, so there really isn't a potential for Handle Recycling.
bindings.Name = ADP.PtrZero;
bindings.ParamSize = new IntPtr(size);
bindings.Flags = GetBindFlags(direction);
//bindings.Precision = precision;
//bindings.Scale = scale;
// tagDBBINDING info for CreateAccessor
bindings.Ordinal = (IntPtr)(index+1);
bindings.Part = dbtype.dbPart;
bindings.ParamIO = GetBindDirection(direction);
bindings.Precision = precision;
bindings.Scale = scale;
bindings.DbType = wtype;
bindings.MaxLen = bytecount; // also increments databuffer size (uses DbType)
//bindings.ValueOffset = bindings.DataBufferSize; // set via MaxLen
//bindings.LengthOffset = i * sizeof_int64;
//bindings.StatusOffset = i * sizeof_int64 + sizeof_int32;
//bindings.TypeInfoPtr = 0;
//bindings.ObjectPtr = 0;
//bindings.BindExtPtr = 0;
//bindings.MemOwner = /*DBMEMOWNER_CLIENTOWNED*/0;
//bindings.Flags = 0;
//bindings.ParameterChangeID = changeID; // bind until something changes
Debug.Assert(_changeID == changeID, "parameter has unexpectedly changed");
if (Bid.AdvancedOn) {
Bid.Trace(" index=%d, parameterName='%ls'\n", index, ParameterName);//, bindings.BindInfo[index]);
Bid.Trace("\n");//, bindings.DBBinding[index]);
}
return IsParameterComputed();
}
private static object CoerceValue(object value, NativeDBType destinationType) {
Debug.Assert(null != destinationType, "null destinationType");
if ((null != value) && (DBNull.Value != value) && (typeof(object) != destinationType.dataType)) {
Type currentType = value.GetType();
if (currentType != destinationType.dataType) {
try {
if ((typeof(string) == destinationType.dataType) && (typeof(char[]) == currentType)) {
}
else if ((NativeDBType.CY == destinationType.dbType) && (typeof(string) == currentType)) {
value = Decimal.Parse((string)value, NumberStyles.Currency, (IFormatProvider)null); // WebData 99376
}
else {
value = Convert.ChangeType(value, destinationType.dataType, (IFormatProvider)null);
}
}
catch (Exception e) {
//
if (!ADP.IsCatchableExceptionType(e)) {
throw;
}
throw ADP.ParameterConversionFailed(value, destinationType.dataType, e); // WebData 75433
}
}
}
return value;
}
private NativeDBType GetBindType(object value) {
NativeDBType dbtype = _metaType;
if (null == dbtype) {
if (ADP.IsNull(value)) {
dbtype = OleDb.NativeDBType.Default;
}
else {
dbtype = NativeDBType.FromSystemType(value);
}
}
return dbtype;
}
internal object GetCoercedValue() {
object value = CoercedValue; // will also be set during binding, will rebind everytime if _metaType not set
if (null == value) {
value = CoerceValue(Value, _coerceMetaType);
CoercedValue = value;
}
return value;
}
internal bool IsParameterComputed() {
NativeDBType metaType = _metaType;
return ((null == metaType)
|| (!ShouldSerializeSize() && metaType.IsVariableLength)
|| ((NativeDBType.DECIMAL == metaType.dbType) || (NativeDBType.NUMERIC == metaType.dbType)
&& (!ShouldSerializeScale() || !ShouldSerializePrecision())
)
); // MDAC 69299
}
// @devnote: use IsParameterComputed which is called in the normal case
// only to call Prepare to throw the specialized error message
// reducing the overall number of methods to actually jit
internal void Prepare(OleDbCommand cmd) { // MDAC 70232
Debug.Assert(IsParameterComputed(), "Prepare computed parameter");
if (null == _metaType) {
throw ADP.PrepareParameterType(cmd);
}
else if (!ShouldSerializeSize() && _metaType.IsVariableLength) {
throw ADP.PrepareParameterSize(cmd);
}
else if (!ShouldSerializePrecision() && !ShouldSerializeScale() && ((NativeDBType.DECIMAL == _metaType.wType) || (NativeDBType.NUMERIC == _metaType.wType))) { // MDAC 71441
throw ADP.PrepareParameterScale(cmd, _metaType.wType.ToString("G", CultureInfo.InvariantCulture));
}
Debug.Assert(false, "OleDbParameter.Prepare didn't throw");
}
[
RefreshProperties(RefreshProperties.All),
ResCategoryAttribute(Res.DataCategory_Data),
ResDescriptionAttribute(Res.DbParameter_Value),
TypeConverterAttribute(typeof(StringConverter)),
]
override public object Value { // V1.2.3300, XXXParameter V1.0.3300
get {
return _value;
}
set {
_coercedValue = null;
_value = value;
}
}
private byte ValuePrecision(object value) {
return ValuePrecisionCore(value);
}
private byte ValueScale(object value) {
return ValueScaleCore(value);
}
private int ValueSize(object value) {
return ValueSizeCore(value);
}
static private int GetBindDirection(ParameterDirection direction) {
return (ODB.ParameterDirectionFlag & (int)direction);
/*switch(Direction) {
default:
case ParameterDirection.Input:
return ODB.DBPARAMIO_INPUT;
case ParameterDirection.Output:
case ParameterDirection.ReturnValue:
return ODB.DBPARAMIO_OUTPUT;
case ParameterDirection.InputOutput:
return (ODB.DBPARAMIO_INPUT | ODB.DBPARAMIO_OUTPUT);
}*/
}
static private int GetBindFlags(ParameterDirection direction) {
return (ODB.ParameterDirectionFlag & (int)direction);
/*switch(Direction) {
default:
case ParameterDirection.Input:
return ODB.DBPARAMFLAGS_ISINPUT;
case ParameterDirection.Output:
case ParameterDirection.ReturnValue:
return ODB.DBPARAMFLAGS_ISOUTPUT;
case ParameterDirection.InputOutput:
return (ODB.DBPARAMFLAGS_ISINPUT | ODB.DBPARAMFLAGS_ISOUTPUT);
}*/
}
// implemented as nested class to take advantage of the private/protected ShouldSerializeXXX methods
sealed internal class OleDbParameterConverter : System.ComponentModel.ExpandableObjectConverter {
// converter classes should have public ctor
public OleDbParameterConverter() {
}
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) {
if (typeof(System.ComponentModel.Design.Serialization.InstanceDescriptor) == destinationType) {
return true;
}
return base.CanConvertTo(context, destinationType);
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) {
if (null == destinationType) {
throw ADP.ArgumentNull("destinationType");
}
if ((typeof(System.ComponentModel.Design.Serialization.InstanceDescriptor) == destinationType) && (value is OleDbParameter)) {
return ConvertToInstanceDescriptor(value as OleDbParameter);
}
return base.ConvertTo(context, culture, value, destinationType);
}
private System.ComponentModel.Design.Serialization.InstanceDescriptor ConvertToInstanceDescriptor(OleDbParameter p) {
int flags = 0;
if (p.ShouldSerializeOleDbType()) {
flags |= 1;
}
if (p.ShouldSerializeSize()) {
flags |= 2;
}
if (!ADP.IsEmpty(p.SourceColumn)) {
flags |= 4;
}
if (null != p.Value) {
flags |= 8;
}
if ((ParameterDirection.Input != p.Direction) || p.IsNullable
|| p.ShouldSerializePrecision() || p.ShouldSerializeScale()
|| (DataRowVersion.Current != p.SourceVersion)) {
flags |= 16; // V1.0 everything
}
if (p.SourceColumnNullMapping) {
flags |= 32; // v2.0 everything
}
Type[] ctorParams;
object[] ctorValues;
switch(flags) {
case 0: // ParameterName
case 1: // OleDbType
ctorParams = new Type[] { typeof(string), typeof(OleDbType) };
ctorValues = new object[] { p.ParameterName, p.OleDbType };
break;
case 2: // Size
case 3: // Size, OleDbType
ctorParams = new Type[] { typeof(string), typeof(OleDbType), typeof(int) };
ctorValues = new object[] { p.ParameterName, p.OleDbType, p.Size };
break;
case 4: // SourceColumn
case 5: // SourceColumn, OleDbType
case 6: // SourceColumn, Size
case 7: // SourceColumn, Size, OleDbType
ctorParams = new Type[] { typeof(string), typeof(OleDbType), typeof(int), typeof(string) };
ctorValues = new object[] { p.ParameterName, p.OleDbType, p.Size, p.SourceColumn };
break;
case 8: // Value
ctorParams = new Type[] { typeof(string), typeof(object) };
ctorValues = new object[] { p.ParameterName, p.Value };
break;
default: // everything else
if (0 == (32 & flags)) { // V1.0 everything
ctorParams = new Type[] {
typeof(string), typeof(OleDbType), typeof(int), typeof(ParameterDirection),
typeof(bool), typeof(byte), typeof(byte), typeof(string),
typeof(DataRowVersion), typeof(object) };
ctorValues = new object[] {
p.ParameterName, p.OleDbType, p.Size, p.Direction,
p.IsNullable, p.PrecisionInternal, p.ScaleInternal, p.SourceColumn,
p.SourceVersion, p.Value };
}
else { // v2.0 everything - round trip all browsable properties + precision/scale
ctorParams = new Type[] {
typeof(string), typeof(OleDbType), typeof(int), typeof(ParameterDirection),
typeof(byte), typeof(byte),
typeof(string), typeof(DataRowVersion), typeof(bool),
typeof(object) };
ctorValues = new object[] {
p.ParameterName, p.OleDbType, p.Size, p.Direction,
p.PrecisionInternal, p.ScaleInternal,
p.SourceColumn, p.SourceVersion, p.SourceColumnNullMapping,
p.Value };
}
break;
}
System.Reflection.ConstructorInfo ctor = typeof(OleDbParameter).GetConstructor(ctorParams);
return new System.ComponentModel.Design.Serialization.InstanceDescriptor(ctor, ctorValues);
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- PasswordPropertyTextAttribute.cs
- TcpStreams.cs
- ExpressionPrefixAttribute.cs
- FontResourceCache.cs
- BlockUIContainer.cs
- InputBinding.cs
- ClientUtils.cs
- PrimitiveXmlSerializers.cs
- SmtpTransport.cs
- MultiPropertyDescriptorGridEntry.cs
- FullTextLine.cs
- BooleanAnimationBase.cs
- DispatcherEventArgs.cs
- QueryContinueDragEvent.cs
- WebRequestModuleElementCollection.cs
- CodeExpressionCollection.cs
- ConditionalAttribute.cs
- DataTableCollection.cs
- XmlWrappingWriter.cs
- DispatcherBuilder.cs
- FaultDesigner.cs
- ProfileParameter.cs
- MultiBinding.cs
- XmlExpressionDumper.cs
- MaterializeFromAtom.cs
- FormViewInsertEventArgs.cs
- TableLayoutRowStyleCollection.cs
- WhereQueryOperator.cs
- XmlNamespaceManager.cs
- _ShellExpression.cs
- AffineTransform3D.cs
- ClientBuildManager.cs
- RectAnimationUsingKeyFrames.cs
- ExtendedPropertyCollection.cs
- ResourceAttributes.cs
- WebPartEditorApplyVerb.cs
- SetterTriggerConditionValueConverter.cs
- ToolBarPanel.cs
- Oci.cs
- WindowsRegion.cs
- MasterPageCodeDomTreeGenerator.cs
- ListParagraph.cs
- DefaultValidator.cs
- ImplicitInputBrush.cs
- FactoryGenerator.cs
- DataSourceProvider.cs
- NextPreviousPagerField.cs
- PrimitiveSchema.cs
- PersonalizationProvider.cs
- DataContractSet.cs
- SqlProcedureAttribute.cs
- AstTree.cs
- OleDbTransaction.cs
- X509AudioLogo.cs
- SqlBooleanMismatchVisitor.cs
- ToolStripButton.cs
- LicenseManager.cs
- FlagsAttribute.cs
- HighlightVisual.cs
- AttributeConverter.cs
- ByteStream.cs
- WebBrowsableAttribute.cs
- BamlStream.cs
- InputElement.cs
- WebBrowser.cs
- ValidationErrorEventArgs.cs
- RelationshipSet.cs
- DataList.cs
- FixedHyperLink.cs
- ObjectDataSourceEventArgs.cs
- ExpressionBindings.cs
- Error.cs
- SimpleMailWebEventProvider.cs
- SerializableAttribute.cs
- ModelItemKeyValuePair.cs
- XmlSchemaExporter.cs
- DataControlButton.cs
- DataViewManager.cs
- AutomationPatternInfo.cs
- TraceEventCache.cs
- XmlSchemaException.cs
- SizeIndependentAnimationStorage.cs
- DecimalStorage.cs
- SchemaLookupTable.cs
- TimerTable.cs
- CollectionViewGroup.cs
- SwitchElementsCollection.cs
- DispatcherEventArgs.cs
- XmlObjectSerializerWriteContext.cs
- AccessViolationException.cs
- DrawingCollection.cs
- ScriptingWebServicesSectionGroup.cs
- DataGridViewCellStyleChangedEventArgs.cs
- glyphs.cs
- _OverlappedAsyncResult.cs
- BuildProvider.cs
- XamlToRtfParser.cs
- PointCollection.cs
- ReflectTypeDescriptionProvider.cs
- GridSplitterAutomationPeer.cs