Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Data / System / Data / OleDb / OleDbCommandBuilder.cs / 1305376 / OleDbCommandBuilder.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;
using System.Text;
public sealed class OleDbCommandBuilder : DbCommandBuilder {
public OleDbCommandBuilder() : base() {
GC.SuppressFinalize(this);
}
public OleDbCommandBuilder(OleDbDataAdapter adapter) : this() {
DataAdapter = adapter;
}
[
DefaultValue(null),
ResCategoryAttribute(Res.DataCategory_Update),
ResDescriptionAttribute(Res.OleDbCommandBuilder_DataAdapter), // MDAC 60524
]
new public OleDbDataAdapter DataAdapter {
get {
return (base.DataAdapter as OleDbDataAdapter);
}
set {
base.DataAdapter = value;
}
}
private void OleDbRowUpdatingHandler(object sender, OleDbRowUpdatingEventArgs ruevent) {
RowUpdatingHandler(ruevent);
}
new public OleDbCommand GetInsertCommand() {
return (OleDbCommand) base.GetInsertCommand();
}
new public OleDbCommand GetInsertCommand(bool useColumnsForParameterNames) {
return (OleDbCommand) base.GetInsertCommand(useColumnsForParameterNames);
}
new public OleDbCommand GetUpdateCommand() {
return (OleDbCommand) base.GetUpdateCommand();
}
new public OleDbCommand GetUpdateCommand(bool useColumnsForParameterNames) {
return (OleDbCommand) base.GetUpdateCommand(useColumnsForParameterNames);
}
new public OleDbCommand GetDeleteCommand() {
return (OleDbCommand) base.GetDeleteCommand();
}
new public OleDbCommand GetDeleteCommand(bool useColumnsForParameterNames) {
return (OleDbCommand) base.GetDeleteCommand(useColumnsForParameterNames);
}
override protected string GetParameterName(int parameterOrdinal) {
return "p" + parameterOrdinal.ToString(System.Globalization.CultureInfo.InvariantCulture);
}
override protected string GetParameterName(string parameterName) {
return parameterName;
}
override protected string GetParameterPlaceholder(int parameterOrdinal) {
return "?";
}
override protected void ApplyParameterInfo(DbParameter parameter, DataRow datarow, StatementType statementType, bool whereClause) {
OleDbParameter p = (OleDbParameter) parameter;
object valueType = datarow[SchemaTableColumn.ProviderType];
p.OleDbType = (OleDbType) valueType;
object bvalue = datarow[SchemaTableColumn.NumericPrecision];
if (DBNull.Value != bvalue) {
byte bval = (byte)(short)bvalue;
p.PrecisionInternal = ((0xff != bval) ? bval : (byte)0);
}
bvalue = datarow[SchemaTableColumn.NumericScale];
if (DBNull.Value != bvalue) {
byte bval = (byte)(short)bvalue;
p.ScaleInternal = ((0xff != bval) ? bval : (byte)0);
}
}
static public void DeriveParameters(OleDbCommand command) { // MDAC 65927
OleDbConnection.ExecutePermission.Demand();
if (null == command) {
throw ADP.ArgumentNull("command");
}
switch (command.CommandType) {
case System.Data.CommandType.Text:
throw ADP.DeriveParametersNotSupported(command);
case System.Data.CommandType.StoredProcedure:
break;
case System.Data.CommandType.TableDirect:
// CommandType.TableDirect - do nothing, parameters are not supported
throw ADP.DeriveParametersNotSupported(command);
default:
throw ADP.InvalidCommandType(command.CommandType);
}
if (ADP.IsEmpty(command.CommandText)) {
throw ADP.CommandTextRequired(ADP.DeriveParameters);
}
OleDbConnection connection = command.Connection;
if (null == connection) {
throw ADP.ConnectionRequired(ADP.DeriveParameters);
}
ConnectionState state = connection.State;
if (ConnectionState.Open != state) {
throw ADP.OpenConnectionRequired(ADP.DeriveParameters, state);
}
OleDbParameter[] list = DeriveParametersFromStoredProcedure(connection, command);
OleDbParameterCollection parameters = command.Parameters;
parameters.Clear();
for(int i = 0; i < list.Length; ++i) {
parameters.Add(list[i]);
}
}
// known difference: when getting the parameters for a sproc, the
// return value gets marked as a return value but for a sql stmt
// the return value gets marked as an output parameter.
static private OleDbParameter[] DeriveParametersFromStoredProcedure(OleDbConnection connection, OleDbCommand command) {
OleDbParameter[] plist = new OleDbParameter[0];
if (connection.SupportSchemaRowset(OleDbSchemaGuid.Procedure_Parameters)) {
string quotePrefix, quoteSuffix;
connection.GetLiteralQuotes(ADP.DeriveParameters, out quotePrefix, out quoteSuffix);
Object[] parsed = MultipartIdentifier.ParseMultipartIdentifier(command.CommandText, quotePrefix, quoteSuffix, '.', 4, true, Res.OLEDB_OLEDBCommandText, false); // MDAC 70930
if (null == parsed[3]) {
throw ADP.NoStoredProcedureExists(command.CommandText);
}
Object[] restrictions = new object[4];
object value;
// Parse returns an enforced 4 part array
// 0) Server - ignored but removal would be a run-time breaking change from V1.0
// 1) Catalog
// 2) Schema
// 3) ProcedureName
// Restrictions array which is passed to OleDb API expects:
// 0) Catalog
// 1) Schema
// 2) ProcedureName
// 3) ParameterName (leave null)
// Copy from Parse format to OleDb API format
Array.Copy(parsed, 1, restrictions, 0, 3);
//if (cmdConnection.IsServer_msdaora) {
// restrictions[1] = Convert.ToString(cmdConnection.UserId).ToUpper();
//}
DataTable table = connection.GetSchemaRowset(OleDbSchemaGuid.Procedure_Parameters, restrictions);
if (null != table) {
DataColumnCollection columns = table.Columns;
DataColumn parameterName = null;
DataColumn parameterDirection = null;
DataColumn dataType = null;
DataColumn maxLen = null;
DataColumn numericPrecision = null;
DataColumn numericScale = null;
DataColumn backendtype = null;
int index = columns.IndexOf(ODB.PARAMETER_NAME);
if (-1 != index) parameterName = columns[index];
index = columns.IndexOf(ODB.PARAMETER_TYPE);
if (-1 != index) parameterDirection = columns[index];
index = columns.IndexOf(ODB.DATA_TYPE);
if (-1 != index) dataType = columns[index];
index = columns.IndexOf(ODB.CHARACTER_MAXIMUM_LENGTH);
if (-1 != index) maxLen = columns[index];
index = columns.IndexOf(ODB.NUMERIC_PRECISION);
if (-1 != index) numericPrecision = columns[index];
index = columns.IndexOf(ODB.NUMERIC_SCALE);
if (-1 != index) numericScale = columns[index];
index = columns.IndexOf(ODB.TYPE_NAME); // MDAC 72315
if (-1 != index) backendtype = columns[index];
DataRow[] dataRows = table.Select(null, ODB.ORDINAL_POSITION_ASC, DataViewRowState.CurrentRows); // MDAC 70928
plist = new OleDbParameter[dataRows.Length];
for(index = 0; index < dataRows.Length; ++index) {
DataRow dataRow = dataRows[index];
OleDbParameter parameter = new OleDbParameter();
if ((null != parameterName) && !dataRow.IsNull(parameterName, DataRowVersion.Default)) {
// $
parameter.ParameterName = Convert.ToString(dataRow[parameterName, DataRowVersion.Default], CultureInfo.InvariantCulture).TrimStart(new char[] { '@', ' ', ':'});
}
if ((null != parameterDirection) && !dataRow.IsNull(parameterDirection, DataRowVersion.Default)) {
short direction = Convert.ToInt16(dataRow[parameterDirection, DataRowVersion.Default], CultureInfo.InvariantCulture);
parameter.Direction = ConvertToParameterDirection(direction);
}
if ((null != dataType) && !dataRow.IsNull(dataType, DataRowVersion.Default)) {
// need to ping FromDBType, otherwise WChar->WChar when the user really wants VarWChar
short wType = Convert.ToInt16(dataRow[dataType, DataRowVersion.Default], CultureInfo.InvariantCulture);
parameter.OleDbType = NativeDBType.FromDBType(wType, false, false).enumOleDbType;
}
if ((null != maxLen) && !dataRow.IsNull(maxLen, DataRowVersion.Default)) {
parameter.Size = Convert.ToInt32(dataRow[maxLen, DataRowVersion.Default], CultureInfo.InvariantCulture);
}
switch(parameter.OleDbType) {
case OleDbType.Decimal:
case OleDbType.Numeric:
case OleDbType.VarNumeric:
if ((null != numericPrecision) && !dataRow.IsNull(numericPrecision, DataRowVersion.Default)) {
// @devnote: unguarded cast from Int16 to Byte
parameter.PrecisionInternal = (Byte) Convert.ToInt16(dataRow[numericPrecision], CultureInfo.InvariantCulture);
}
if ((null != numericScale) && !dataRow.IsNull(numericScale, DataRowVersion.Default)) {
// @devnote: unguarded cast from Int16 to Byte
parameter.ScaleInternal = (Byte) Convert.ToInt16(dataRow[numericScale], CultureInfo.InvariantCulture);
}
break;
case OleDbType.VarBinary: // MDAC 72315
case OleDbType.VarChar:
case OleDbType.VarWChar:
value = dataRow[backendtype, DataRowVersion.Default];
if (value is string) {
string backendtypename = ((string) value).ToLower(CultureInfo.InvariantCulture);
switch(backendtypename) {
case "binary":
parameter.OleDbType = OleDbType.Binary;
break;
//case "varbinary":
// parameter.OleDbType = OleDbType.VarBinary;
// break;
case "image":
parameter.OleDbType = OleDbType.LongVarBinary;
break;
case "char":
parameter.OleDbType = OleDbType.Char;
break;
//case "varchar":
//case "varchar2":
// parameter.OleDbType = OleDbType.VarChar;
// break;
case "text":
parameter.OleDbType = OleDbType.LongVarChar;
break;
case "nchar":
parameter.OleDbType = OleDbType.WChar;
break;
//case "nvarchar":
// parameter.OleDbType = OleDbType.VarWChar;
case "ntext":
parameter.OleDbType = OleDbType.LongVarWChar;
break;
}
}
break;
}
//if (AdapterSwitches.OleDbSql.TraceVerbose) {
// ADP.Trace_Parameter("StoredProcedure", parameter);
//}
plist[index] = parameter;
}
}
if ((0 == plist.Length) && connection.SupportSchemaRowset(OleDbSchemaGuid.Procedures)) {
restrictions = new Object[4] { null, null, command.CommandText, null};
table = connection.GetSchemaRowset(OleDbSchemaGuid.Procedures, restrictions);
if (0 == table.Rows.Count) {
throw ADP.NoStoredProcedureExists(command.CommandText);
}
}
}
else if (connection.SupportSchemaRowset(OleDbSchemaGuid.Procedures)) {
Object[] restrictions = new Object[4] { null, null, command.CommandText, null};
DataTable table = connection.GetSchemaRowset(OleDbSchemaGuid.Procedures, restrictions);
if (0 == table.Rows.Count) {
throw ADP.NoStoredProcedureExists(command.CommandText);
}
// we don't ever expect a procedure with 0 parameters, they should have at least a return value
throw ODB.NoProviderSupportForSProcResetParameters(connection.Provider); // MDAC 71968
}
else {
throw ODB.NoProviderSupportForSProcResetParameters(connection.Provider); // MDAC 70918
}
return plist;
}
static private ParameterDirection ConvertToParameterDirection(int value) {
switch (value) {
case ODB.DBPARAMTYPE_INPUT:
return System.Data.ParameterDirection.Input;
case ODB.DBPARAMTYPE_INPUTOUTPUT:
return System.Data.ParameterDirection.InputOutput;
case ODB.DBPARAMTYPE_OUTPUT:
return System.Data.ParameterDirection.Output;
case ODB.DBPARAMTYPE_RETURNVALUE:
return System.Data.ParameterDirection.ReturnValue;
default:
return System.Data.ParameterDirection.Input;
}
}
public override string QuoteIdentifier(string unquotedIdentifier){
return QuoteIdentifier(unquotedIdentifier, null /* use DataAdapter.SelectCommand.Connection if available */);
}
public string QuoteIdentifier( string unquotedIdentifier, OleDbConnection connection){
ADP.CheckArgumentNull(unquotedIdentifier, "unquotedIdentifier");
// if the user has specificed a prefix use the user specified prefix and suffix
// otherwise get them from the provider
string quotePrefix = QuotePrefix;
string quoteSuffix = QuoteSuffix;
if (ADP.IsEmpty(quotePrefix) == true) {
if (connection == null) {
// VSTFDEVDIV 479567: use the adapter's connection if QuoteIdentifier was called from
// DbCommandBuilder instance (which does not have an overload that gets connection object)
connection = base.GetConnection() as OleDbConnection;
if (connection == null) {
throw ADP.QuotePrefixNotSet(ADP.QuoteIdentifier);
}
}
connection.GetLiteralQuotes(ADP.QuoteIdentifier, out quotePrefix, out quoteSuffix);
// if the quote suffix is null assume that it is the same as the prefix (See OLEDB spec
// IDBInfo::GetLiteralInfo DBLITERAL_QUOTE_SUFFIX.)
if (quoteSuffix == null) {
quoteSuffix = quotePrefix;
}
}
return ADP.BuildQuotedString(quotePrefix,quoteSuffix,unquotedIdentifier);
}
override protected void SetRowUpdatingHandler(DbDataAdapter adapter) {
Debug.Assert(adapter is OleDbDataAdapter, "!OleDbDataAdapter");
if (adapter == base.DataAdapter) { // removal case
((OleDbDataAdapter)adapter).RowUpdating -= OleDbRowUpdatingHandler;
}
else { // adding case
((OleDbDataAdapter)adapter).RowUpdating += OleDbRowUpdatingHandler;
}
}
public override string UnquoteIdentifier( string quotedIdentifier){
return UnquoteIdentifier(quotedIdentifier, null /* use DataAdapter.SelectCommand.Connection if available */);
}
public string UnquoteIdentifier(string quotedIdentifier, OleDbConnection connection){
ADP.CheckArgumentNull(quotedIdentifier, "quotedIdentifier");
// if the user has specificed a prefix use the user specified prefix and suffix
// otherwise get them from the provider
string quotePrefix = QuotePrefix;
string quoteSuffix = QuoteSuffix;
if (ADP.IsEmpty(quotePrefix) == true) {
if (connection == null) {
// VSTFDEVDIV 479567: use the adapter's connection if UnquoteIdentifier was called from
// DbCommandBuilder instance (which does not have an overload that gets connection object)
connection = base.GetConnection() as OleDbConnection;
if (connection == null) {
throw ADP.QuotePrefixNotSet(ADP.UnquoteIdentifier);
}
}
connection.GetLiteralQuotes(ADP.UnquoteIdentifier, out quotePrefix, out quoteSuffix);
// if the quote suffix is null assume that it is the same as the prefix (See OLEDB spec
// IDBInfo::GetLiteralInfo DBLITERAL_QUOTE_SUFFIX.)
if (quoteSuffix == null) {
quoteSuffix = quotePrefix;
}
}
String unquotedIdentifier;
// ignoring the return value because it is acceptable for the quotedString to not be quoted in this
// context.
ADP.RemoveStringQuotes(quotePrefix, quoteSuffix, quotedIdentifier, out unquotedIdentifier);
return unquotedIdentifier;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// 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;
using System.Text;
public sealed class OleDbCommandBuilder : DbCommandBuilder {
public OleDbCommandBuilder() : base() {
GC.SuppressFinalize(this);
}
public OleDbCommandBuilder(OleDbDataAdapter adapter) : this() {
DataAdapter = adapter;
}
[
DefaultValue(null),
ResCategoryAttribute(Res.DataCategory_Update),
ResDescriptionAttribute(Res.OleDbCommandBuilder_DataAdapter), // MDAC 60524
]
new public OleDbDataAdapter DataAdapter {
get {
return (base.DataAdapter as OleDbDataAdapter);
}
set {
base.DataAdapter = value;
}
}
private void OleDbRowUpdatingHandler(object sender, OleDbRowUpdatingEventArgs ruevent) {
RowUpdatingHandler(ruevent);
}
new public OleDbCommand GetInsertCommand() {
return (OleDbCommand) base.GetInsertCommand();
}
new public OleDbCommand GetInsertCommand(bool useColumnsForParameterNames) {
return (OleDbCommand) base.GetInsertCommand(useColumnsForParameterNames);
}
new public OleDbCommand GetUpdateCommand() {
return (OleDbCommand) base.GetUpdateCommand();
}
new public OleDbCommand GetUpdateCommand(bool useColumnsForParameterNames) {
return (OleDbCommand) base.GetUpdateCommand(useColumnsForParameterNames);
}
new public OleDbCommand GetDeleteCommand() {
return (OleDbCommand) base.GetDeleteCommand();
}
new public OleDbCommand GetDeleteCommand(bool useColumnsForParameterNames) {
return (OleDbCommand) base.GetDeleteCommand(useColumnsForParameterNames);
}
override protected string GetParameterName(int parameterOrdinal) {
return "p" + parameterOrdinal.ToString(System.Globalization.CultureInfo.InvariantCulture);
}
override protected string GetParameterName(string parameterName) {
return parameterName;
}
override protected string GetParameterPlaceholder(int parameterOrdinal) {
return "?";
}
override protected void ApplyParameterInfo(DbParameter parameter, DataRow datarow, StatementType statementType, bool whereClause) {
OleDbParameter p = (OleDbParameter) parameter;
object valueType = datarow[SchemaTableColumn.ProviderType];
p.OleDbType = (OleDbType) valueType;
object bvalue = datarow[SchemaTableColumn.NumericPrecision];
if (DBNull.Value != bvalue) {
byte bval = (byte)(short)bvalue;
p.PrecisionInternal = ((0xff != bval) ? bval : (byte)0);
}
bvalue = datarow[SchemaTableColumn.NumericScale];
if (DBNull.Value != bvalue) {
byte bval = (byte)(short)bvalue;
p.ScaleInternal = ((0xff != bval) ? bval : (byte)0);
}
}
static public void DeriveParameters(OleDbCommand command) { // MDAC 65927
OleDbConnection.ExecutePermission.Demand();
if (null == command) {
throw ADP.ArgumentNull("command");
}
switch (command.CommandType) {
case System.Data.CommandType.Text:
throw ADP.DeriveParametersNotSupported(command);
case System.Data.CommandType.StoredProcedure:
break;
case System.Data.CommandType.TableDirect:
// CommandType.TableDirect - do nothing, parameters are not supported
throw ADP.DeriveParametersNotSupported(command);
default:
throw ADP.InvalidCommandType(command.CommandType);
}
if (ADP.IsEmpty(command.CommandText)) {
throw ADP.CommandTextRequired(ADP.DeriveParameters);
}
OleDbConnection connection = command.Connection;
if (null == connection) {
throw ADP.ConnectionRequired(ADP.DeriveParameters);
}
ConnectionState state = connection.State;
if (ConnectionState.Open != state) {
throw ADP.OpenConnectionRequired(ADP.DeriveParameters, state);
}
OleDbParameter[] list = DeriveParametersFromStoredProcedure(connection, command);
OleDbParameterCollection parameters = command.Parameters;
parameters.Clear();
for(int i = 0; i < list.Length; ++i) {
parameters.Add(list[i]);
}
}
// known difference: when getting the parameters for a sproc, the
// return value gets marked as a return value but for a sql stmt
// the return value gets marked as an output parameter.
static private OleDbParameter[] DeriveParametersFromStoredProcedure(OleDbConnection connection, OleDbCommand command) {
OleDbParameter[] plist = new OleDbParameter[0];
if (connection.SupportSchemaRowset(OleDbSchemaGuid.Procedure_Parameters)) {
string quotePrefix, quoteSuffix;
connection.GetLiteralQuotes(ADP.DeriveParameters, out quotePrefix, out quoteSuffix);
Object[] parsed = MultipartIdentifier.ParseMultipartIdentifier(command.CommandText, quotePrefix, quoteSuffix, '.', 4, true, Res.OLEDB_OLEDBCommandText, false); // MDAC 70930
if (null == parsed[3]) {
throw ADP.NoStoredProcedureExists(command.CommandText);
}
Object[] restrictions = new object[4];
object value;
// Parse returns an enforced 4 part array
// 0) Server - ignored but removal would be a run-time breaking change from V1.0
// 1) Catalog
// 2) Schema
// 3) ProcedureName
// Restrictions array which is passed to OleDb API expects:
// 0) Catalog
// 1) Schema
// 2) ProcedureName
// 3) ParameterName (leave null)
// Copy from Parse format to OleDb API format
Array.Copy(parsed, 1, restrictions, 0, 3);
//if (cmdConnection.IsServer_msdaora) {
// restrictions[1] = Convert.ToString(cmdConnection.UserId).ToUpper();
//}
DataTable table = connection.GetSchemaRowset(OleDbSchemaGuid.Procedure_Parameters, restrictions);
if (null != table) {
DataColumnCollection columns = table.Columns;
DataColumn parameterName = null;
DataColumn parameterDirection = null;
DataColumn dataType = null;
DataColumn maxLen = null;
DataColumn numericPrecision = null;
DataColumn numericScale = null;
DataColumn backendtype = null;
int index = columns.IndexOf(ODB.PARAMETER_NAME);
if (-1 != index) parameterName = columns[index];
index = columns.IndexOf(ODB.PARAMETER_TYPE);
if (-1 != index) parameterDirection = columns[index];
index = columns.IndexOf(ODB.DATA_TYPE);
if (-1 != index) dataType = columns[index];
index = columns.IndexOf(ODB.CHARACTER_MAXIMUM_LENGTH);
if (-1 != index) maxLen = columns[index];
index = columns.IndexOf(ODB.NUMERIC_PRECISION);
if (-1 != index) numericPrecision = columns[index];
index = columns.IndexOf(ODB.NUMERIC_SCALE);
if (-1 != index) numericScale = columns[index];
index = columns.IndexOf(ODB.TYPE_NAME); // MDAC 72315
if (-1 != index) backendtype = columns[index];
DataRow[] dataRows = table.Select(null, ODB.ORDINAL_POSITION_ASC, DataViewRowState.CurrentRows); // MDAC 70928
plist = new OleDbParameter[dataRows.Length];
for(index = 0; index < dataRows.Length; ++index) {
DataRow dataRow = dataRows[index];
OleDbParameter parameter = new OleDbParameter();
if ((null != parameterName) && !dataRow.IsNull(parameterName, DataRowVersion.Default)) {
// $
parameter.ParameterName = Convert.ToString(dataRow[parameterName, DataRowVersion.Default], CultureInfo.InvariantCulture).TrimStart(new char[] { '@', ' ', ':'});
}
if ((null != parameterDirection) && !dataRow.IsNull(parameterDirection, DataRowVersion.Default)) {
short direction = Convert.ToInt16(dataRow[parameterDirection, DataRowVersion.Default], CultureInfo.InvariantCulture);
parameter.Direction = ConvertToParameterDirection(direction);
}
if ((null != dataType) && !dataRow.IsNull(dataType, DataRowVersion.Default)) {
// need to ping FromDBType, otherwise WChar->WChar when the user really wants VarWChar
short wType = Convert.ToInt16(dataRow[dataType, DataRowVersion.Default], CultureInfo.InvariantCulture);
parameter.OleDbType = NativeDBType.FromDBType(wType, false, false).enumOleDbType;
}
if ((null != maxLen) && !dataRow.IsNull(maxLen, DataRowVersion.Default)) {
parameter.Size = Convert.ToInt32(dataRow[maxLen, DataRowVersion.Default], CultureInfo.InvariantCulture);
}
switch(parameter.OleDbType) {
case OleDbType.Decimal:
case OleDbType.Numeric:
case OleDbType.VarNumeric:
if ((null != numericPrecision) && !dataRow.IsNull(numericPrecision, DataRowVersion.Default)) {
// @devnote: unguarded cast from Int16 to Byte
parameter.PrecisionInternal = (Byte) Convert.ToInt16(dataRow[numericPrecision], CultureInfo.InvariantCulture);
}
if ((null != numericScale) && !dataRow.IsNull(numericScale, DataRowVersion.Default)) {
// @devnote: unguarded cast from Int16 to Byte
parameter.ScaleInternal = (Byte) Convert.ToInt16(dataRow[numericScale], CultureInfo.InvariantCulture);
}
break;
case OleDbType.VarBinary: // MDAC 72315
case OleDbType.VarChar:
case OleDbType.VarWChar:
value = dataRow[backendtype, DataRowVersion.Default];
if (value is string) {
string backendtypename = ((string) value).ToLower(CultureInfo.InvariantCulture);
switch(backendtypename) {
case "binary":
parameter.OleDbType = OleDbType.Binary;
break;
//case "varbinary":
// parameter.OleDbType = OleDbType.VarBinary;
// break;
case "image":
parameter.OleDbType = OleDbType.LongVarBinary;
break;
case "char":
parameter.OleDbType = OleDbType.Char;
break;
//case "varchar":
//case "varchar2":
// parameter.OleDbType = OleDbType.VarChar;
// break;
case "text":
parameter.OleDbType = OleDbType.LongVarChar;
break;
case "nchar":
parameter.OleDbType = OleDbType.WChar;
break;
//case "nvarchar":
// parameter.OleDbType = OleDbType.VarWChar;
case "ntext":
parameter.OleDbType = OleDbType.LongVarWChar;
break;
}
}
break;
}
//if (AdapterSwitches.OleDbSql.TraceVerbose) {
// ADP.Trace_Parameter("StoredProcedure", parameter);
//}
plist[index] = parameter;
}
}
if ((0 == plist.Length) && connection.SupportSchemaRowset(OleDbSchemaGuid.Procedures)) {
restrictions = new Object[4] { null, null, command.CommandText, null};
table = connection.GetSchemaRowset(OleDbSchemaGuid.Procedures, restrictions);
if (0 == table.Rows.Count) {
throw ADP.NoStoredProcedureExists(command.CommandText);
}
}
}
else if (connection.SupportSchemaRowset(OleDbSchemaGuid.Procedures)) {
Object[] restrictions = new Object[4] { null, null, command.CommandText, null};
DataTable table = connection.GetSchemaRowset(OleDbSchemaGuid.Procedures, restrictions);
if (0 == table.Rows.Count) {
throw ADP.NoStoredProcedureExists(command.CommandText);
}
// we don't ever expect a procedure with 0 parameters, they should have at least a return value
throw ODB.NoProviderSupportForSProcResetParameters(connection.Provider); // MDAC 71968
}
else {
throw ODB.NoProviderSupportForSProcResetParameters(connection.Provider); // MDAC 70918
}
return plist;
}
static private ParameterDirection ConvertToParameterDirection(int value) {
switch (value) {
case ODB.DBPARAMTYPE_INPUT:
return System.Data.ParameterDirection.Input;
case ODB.DBPARAMTYPE_INPUTOUTPUT:
return System.Data.ParameterDirection.InputOutput;
case ODB.DBPARAMTYPE_OUTPUT:
return System.Data.ParameterDirection.Output;
case ODB.DBPARAMTYPE_RETURNVALUE:
return System.Data.ParameterDirection.ReturnValue;
default:
return System.Data.ParameterDirection.Input;
}
}
public override string QuoteIdentifier(string unquotedIdentifier){
return QuoteIdentifier(unquotedIdentifier, null /* use DataAdapter.SelectCommand.Connection if available */);
}
public string QuoteIdentifier( string unquotedIdentifier, OleDbConnection connection){
ADP.CheckArgumentNull(unquotedIdentifier, "unquotedIdentifier");
// if the user has specificed a prefix use the user specified prefix and suffix
// otherwise get them from the provider
string quotePrefix = QuotePrefix;
string quoteSuffix = QuoteSuffix;
if (ADP.IsEmpty(quotePrefix) == true) {
if (connection == null) {
// VSTFDEVDIV 479567: use the adapter's connection if QuoteIdentifier was called from
// DbCommandBuilder instance (which does not have an overload that gets connection object)
connection = base.GetConnection() as OleDbConnection;
if (connection == null) {
throw ADP.QuotePrefixNotSet(ADP.QuoteIdentifier);
}
}
connection.GetLiteralQuotes(ADP.QuoteIdentifier, out quotePrefix, out quoteSuffix);
// if the quote suffix is null assume that it is the same as the prefix (See OLEDB spec
// IDBInfo::GetLiteralInfo DBLITERAL_QUOTE_SUFFIX.)
if (quoteSuffix == null) {
quoteSuffix = quotePrefix;
}
}
return ADP.BuildQuotedString(quotePrefix,quoteSuffix,unquotedIdentifier);
}
override protected void SetRowUpdatingHandler(DbDataAdapter adapter) {
Debug.Assert(adapter is OleDbDataAdapter, "!OleDbDataAdapter");
if (adapter == base.DataAdapter) { // removal case
((OleDbDataAdapter)adapter).RowUpdating -= OleDbRowUpdatingHandler;
}
else { // adding case
((OleDbDataAdapter)adapter).RowUpdating += OleDbRowUpdatingHandler;
}
}
public override string UnquoteIdentifier( string quotedIdentifier){
return UnquoteIdentifier(quotedIdentifier, null /* use DataAdapter.SelectCommand.Connection if available */);
}
public string UnquoteIdentifier(string quotedIdentifier, OleDbConnection connection){
ADP.CheckArgumentNull(quotedIdentifier, "quotedIdentifier");
// if the user has specificed a prefix use the user specified prefix and suffix
// otherwise get them from the provider
string quotePrefix = QuotePrefix;
string quoteSuffix = QuoteSuffix;
if (ADP.IsEmpty(quotePrefix) == true) {
if (connection == null) {
// VSTFDEVDIV 479567: use the adapter's connection if UnquoteIdentifier was called from
// DbCommandBuilder instance (which does not have an overload that gets connection object)
connection = base.GetConnection() as OleDbConnection;
if (connection == null) {
throw ADP.QuotePrefixNotSet(ADP.UnquoteIdentifier);
}
}
connection.GetLiteralQuotes(ADP.UnquoteIdentifier, out quotePrefix, out quoteSuffix);
// if the quote suffix is null assume that it is the same as the prefix (See OLEDB spec
// IDBInfo::GetLiteralInfo DBLITERAL_QUOTE_SUFFIX.)
if (quoteSuffix == null) {
quoteSuffix = quotePrefix;
}
}
String unquotedIdentifier;
// ignoring the return value because it is acceptable for the quotedString to not be quoted in this
// context.
ADP.RemoveStringQuotes(quotePrefix, quoteSuffix, quotedIdentifier, out unquotedIdentifier);
return unquotedIdentifier;
}
}
}
// 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
- AsyncResult.cs
- TypeNameConverter.cs
- ExtensionElementCollection.cs
- DbBuffer.cs
- dsa.cs
- RuntimeEnvironment.cs
- DbParameterCollection.cs
- EtwTrackingParticipant.cs
- Single.cs
- GPRECT.cs
- ActivationServices.cs
- RelOps.cs
- CodeGenerator.cs
- ResXResourceWriter.cs
- HttpApplication.cs
- ActivityTypeDesigner.xaml.cs
- PKCS1MaskGenerationMethod.cs
- WSDualHttpSecurity.cs
- HtmlInputSubmit.cs
- CodeGenerator.cs
- DownloadProgressEventArgs.cs
- Grid.cs
- ItemCheckedEvent.cs
- IteratorDescriptor.cs
- ObjectHelper.cs
- EntitySetBaseCollection.cs
- ChangeBlockUndoRecord.cs
- _TransmitFileOverlappedAsyncResult.cs
- FirstMatchCodeGroup.cs
- XhtmlBasicCalendarAdapter.cs
- recordstate.cs
- CheckBox.cs
- DeferrableContentConverter.cs
- WebBrowserHelper.cs
- ConnectionPointCookie.cs
- DebugView.cs
- Common.cs
- FileLoadException.cs
- QueryContinueDragEvent.cs
- PrintPreviewGraphics.cs
- RuleConditionDialog.Designer.cs
- StructuredType.cs
- OdbcUtils.cs
- SHA1.cs
- MouseGesture.cs
- PropertyChangedEventArgs.cs
- ADMembershipUser.cs
- ToolboxItem.cs
- AdornerHitTestResult.cs
- UpdateRecord.cs
- DbUpdateCommandTree.cs
- COAUTHINFO.cs
- MissingMemberException.cs
- MenuItemCollection.cs
- AlternateView.cs
- LabelExpression.cs
- XmlComment.cs
- FilterableData.cs
- RegisteredHiddenField.cs
- SettingsContext.cs
- WCFServiceClientProxyGenerator.cs
- XPathDescendantIterator.cs
- ChangeProcessor.cs
- TraceContextEventArgs.cs
- ListContractAdapter.cs
- XmlMemberMapping.cs
- XsltInput.cs
- SqlCacheDependencyDatabase.cs
- assertwrapper.cs
- DiscoveryClientChannelFactory.cs
- OverflowException.cs
- __Error.cs
- DecimalAnimationBase.cs
- IApplicationTrustManager.cs
- RuleSettingsCollection.cs
- Random.cs
- SqlCommand.cs
- NamespaceInfo.cs
- HttpHandlersSection.cs
- OutOfMemoryException.cs
- ListViewCommandEventArgs.cs
- _SslStream.cs
- ListDesigner.cs
- FaultContractAttribute.cs
- ActivityExecutorSurrogate.cs
- WaitHandleCannotBeOpenedException.cs
- AsyncContentLoadedEventArgs.cs
- TextEffectResolver.cs
- TemplatedControlDesigner.cs
- Grant.cs
- FlowDocumentReader.cs
- SafeSecurityHandles.cs
- HandlerMappingMemo.cs
- SafeFileMapViewHandle.cs
- GeneralTransform3DGroup.cs
- BorderSidesEditor.cs
- EventLogInternal.cs
- ListenerPerfCounters.cs
- VoiceObjectToken.cs
- WindowsFormsSynchronizationContext.cs