static internal DbSchemaRow[] GetSortedSchemaRows(DataTable dataTable, bool returnProviderSpecificTypes) // MDAC 60609
{
DataColumn sortindex = dataTable.Columns[SchemaMappingUnsortedIndex];
if (null == sortindex) // WebData 100390
{
sortindex = new DataColumn(SchemaMappingUnsortedIndex, typeof(Int32)); // MDAC 67050
dataTable.Columns.Add(sortindex);
}
int count = dataTable.Rows.Count;
for (int i = 0; i < count; ++i)
{
dataTable.Rows[i][sortindex] = i;
}
;
DbSchemaTable schemaTable = new DbSchemaTable(dataTable, returnProviderSpecificTypes);
const DataViewRowState rowStates = DataViewRowState.Unchanged | DataViewRowState.Added | DataViewRowState.ModifiedCurrent;
DataRow[] dataRows = dataTable.Select(null, "ColumnOrdinal ASC", rowStates);
Debug.Assert(null != dataRows, "GetSchemaRows: unexpected null dataRows");
DbSchemaRow[] schemaRows = new DbSchemaRow[dataRows.Length];
for (int i = 0; i < dataRows.Length; ++i)
{
schemaRows[i] = new DbSchemaRow(schemaTable, dataRows[i]);
}
return(schemaRows);
}
internal static DbSchemaRow[] GetSortedSchemaRows(DataTable dataTable, bool returnProviderSpecificTypes)
{
DataColumn?sortindex = dataTable.Columns[SchemaMappingUnsortedIndex];
if (null == sortindex)
{
sortindex = new DataColumn(SchemaMappingUnsortedIndex, typeof(int));
dataTable.Columns.Add(sortindex);
}
int count = dataTable.Rows.Count;
for (int i = 0; i < count; ++i)
{
dataTable.Rows[i][sortindex] = i;
}
;
DbSchemaTable schemaTable = new DbSchemaTable(dataTable, returnProviderSpecificTypes);
DataRow[] dataRows = SelectRows(dataTable, returnProviderSpecificTypes);
Debug.Assert(null != dataRows, "GetSchemaRows: unexpected null dataRows");
DbSchemaRow[] schemaRows = new DbSchemaRow[dataRows.Length];
for (int i = 0; i < dataRows.Length; ++i)
{
schemaRows[i] = new DbSchemaRow(schemaTable, dataRows[i]);
}
return(schemaRows);
}
internal static DbSchemaRow[] GetSortedSchemaRows(DataTable dataTable, bool returnProviderSpecificTypes)
{
DataColumn column = dataTable.Columns["SchemaMapping Unsorted Index"];
if (column == null)
{
column = new DataColumn("SchemaMapping Unsorted Index", typeof(int));
dataTable.Columns.Add(column);
}
int count = dataTable.Rows.Count;
for (int i = 0; i < count; i++)
{
dataTable.Rows[i][column] = i;
}
DbSchemaTable schemaTable = new DbSchemaTable(dataTable, returnProviderSpecificTypes);
System.Data.DataRow[] rowArray = dataTable.Select(null, "ColumnOrdinal ASC", DataViewRowState.CurrentRows);
DbSchemaRow[] rowArray2 = new DbSchemaRow[rowArray.Length];
for (int j = 0; j < rowArray.Length; j++)
{
rowArray2[j] = new DbSchemaRow(schemaTable, rowArray[j]);
}
return(rowArray2);
}
internal static DbSchemaRow[] GetSortedSchemaRows(DataTable dataTable, bool returnProviderSpecificTypes)
{
DataColumn sortindex = dataTable.Columns[SchemaMappingUnsortedIndex];
if (null == sortindex)
{
sortindex = new DataColumn(SchemaMappingUnsortedIndex, typeof(int));
dataTable.Columns.Add(sortindex);
}
int count = dataTable.Rows.Count;
for (int i = 0; i < count; ++i)
{
dataTable.Rows[i][sortindex] = i;
};
DbSchemaTable schemaTable = new DbSchemaTable(dataTable, returnProviderSpecificTypes);
const DataViewRowState rowStates = DataViewRowState.Unchanged | DataViewRowState.Added | DataViewRowState.ModifiedCurrent;
DataRow[] dataRows = dataTable.Select(null, "ColumnOrdinal ASC", rowStates);
Debug.Assert(null != dataRows, "GetSchemaRows: unexpected null dataRows");
DbSchemaRow[] schemaRows = new DbSchemaRow[dataRows.Length];
for (int i = 0; i < dataRows.Length; ++i)
{
schemaRows[i] = new DbSchemaRow(schemaTable, dataRows[i]);
}
return schemaRows;
}
internal static DbSchemaRow[] GetSortedSchemaRows(DataTable dataTable, bool returnProviderSpecificTypes)
{
DataColumn column = dataTable.Columns["SchemaMapping Unsorted Index"];
if (column == null)
{
column = new DataColumn("SchemaMapping Unsorted Index", typeof(int));
dataTable.Columns.Add(column);
}
int count = dataTable.Rows.Count;
for (int i = 0; i < count; i++)
{
dataTable.Rows[i][column] = i;
}
DbSchemaTable schemaTable = new DbSchemaTable(dataTable, returnProviderSpecificTypes);
System.Data.DataRow[] rowArray = dataTable.Select(null, "ColumnOrdinal ASC", DataViewRowState.CurrentRows);
DbSchemaRow[] rowArray2 = new DbSchemaRow[rowArray.Length];
for (int j = 0; j < rowArray.Length; j++)
{
rowArray2[j] = new DbSchemaRow(schemaTable, rowArray[j]);
}
return rowArray2;
}
private string CreateParameterForValue(
DbCommand command,
string parameterName,
string sourceColumn,
DataRowVersion version,
int parameterCount,
object value,
DbSchemaRow row,
StatementType statementType,
bool whereClause
) {
DbParameter p = GetNextParameter(command, parameterCount);
if (null == parameterName) {
p.ParameterName = GetParameterName(1 + parameterCount);
}
else {
p.ParameterName = parameterName;
}
p.Direction = ParameterDirection.Input;
p.SourceColumn = sourceColumn;
p.SourceVersion = version;
p.SourceColumnNullMapping = false;
p.Value = value;
p.Size = 0; // don't specify parameter.Size so that we don't silently truncate to the metadata size
ApplyParameterInfo(p, row.DataRow, statementType, whereClause);
if (!command.Parameters.Contains(p)) {
command.Parameters.Add(p);
}
if (null == parameterName) {
return GetParameterPlaceholder(1 + parameterCount);
}
else {
Debug.Assert(null != _parameterNames, "How can we have a parameterName without a _parameterNames collection?");
Debug.Assert(null != _parameterMarkerFormat, "How can we have a _parameterNames collection but no _parameterMarkerFormat?");
return String.Format(CultureInfo.InvariantCulture, _parameterMarkerFormat, parameterName);
}
}
internal ParameterNames(DbCommandBuilder dbCommandBuilder, DbSchemaRow[] schemaRows) {
_dbCommandBuilder = dbCommandBuilder;
_baseParameterNames = new string[schemaRows.Length];
_originalParameterNames = new string[schemaRows.Length];
_nullParameterNames = new string[schemaRows.Length];
_isMutatedName = new bool[schemaRows.Length];
_count = schemaRows.Length;
_parameterNameParser = new Regex(_dbCommandBuilder.ParameterNamePattern, RegexOptions.ExplicitCapture | RegexOptions.Singleline);
SetAndValidateNamePrefixes();
_adjustedParameterNameMaxLength = GetAdjustedParameterNameMaxLength();
// Generate the baseparameter names and remove conflicting names
// No names will be generated for any name that is rejected due to invalid prefix, regex violation or
// name conflict after mutation.
// All null values will be replaced with generic parameter names
//
for (int i = 0; i < schemaRows.Length; i++) {
if (null == schemaRows[i]) {
continue;
}
bool isMutatedName = false;
string columnName = schemaRows[i].ColumnName;
// all names that start with original- or isNullPrefix are invalid
if (null != _originalPrefix) {
if (columnName.StartsWith(_originalPrefix, StringComparison.OrdinalIgnoreCase)) {
continue;
}
}
if (null != _isNullPrefix) {
if (columnName.StartsWith(_isNullPrefix, StringComparison.OrdinalIgnoreCase)) {
continue;
}
}
// Mutate name if it contains space(s)
if (columnName.IndexOf(' ') >= 0) {
columnName = columnName.Replace(' ', '_');
isMutatedName = true;
}
// Validate name against regular expression
if (!_parameterNameParser.IsMatch(columnName)) {
continue;
}
// Validate name against adjusted max parametername length
if (columnName.Length > _adjustedParameterNameMaxLength) {
continue;
}
_baseParameterNames[i] = columnName;
_isMutatedName[i] = isMutatedName;
}
EliminateConflictingNames();
// Generate names for original- and isNullparameters
// no names will be generated if the prefix failed parametername validation
for (int i = 0; i < schemaRows.Length; i++) {
if (null != _baseParameterNames[i]) {
if (null != _originalPrefix) {
_originalParameterNames[i] = _originalPrefix + _baseParameterNames[i];
}
if (null != _isNullPrefix) {
// don't bother generating an 'IsNull' name if it's not used
if (schemaRows[i].AllowDBNull) {
_nullParameterNames[i] = _isNullPrefix + _baseParameterNames[i];
}
}
}
}
ApplyProviderSpecificFormat();
GenerateMissingNames(schemaRows);
}
// Generates parameternames that couldn't be generated from columnname
internal void GenerateMissingNames(DbSchemaRow[] schemaRows) {
// foreach name in base names
// if base name is null
// for base, original and nullnames (null names only if nullable)
// do
// generate name based on current index
// increment index
// search name in base names
// loop while name occures in base names
// end for
// end foreach
string name;
for (int i = 0; i < _baseParameterNames.Length; i++) {
name = _baseParameterNames[i];
if (null == name) {
_baseParameterNames[i] = GetNextGenericParameterName();
_originalParameterNames[i] = GetNextGenericParameterName();
// don't bother generating an 'IsNull' name if it's not used
if ((null != schemaRows[i]) && schemaRows[i].AllowDBNull) {
_nullParameterNames[i] = GetNextGenericParameterName();
}
}
}
}
private bool IncrementWhereCount(DbSchemaRow row) {
ConflictOption value = ConflictOption;
switch(value) {
case ConflictOption.CompareAllSearchableValues:
case ConflictOption.OverwriteChanges:
// find the primary key
return (row.IsKey || row.IsUnique) && !row.IsLong && !row.IsRowVersion;
case ConflictOption.CompareRowVersion:
// or the row version
return (((row.IsKey || row.IsUnique) && !_hasPartialPrimaryKey) || row.IsRowVersion) && !row.IsLong;
default:
throw ADP.InvalidConflictOptions(value);
}
}
private bool IncludeInWhereClause(DbSchemaRow row, bool isUpdate) {
bool flag = IncrementWhereCount(row);
if (flag && row.IsHidden) { // MDAC 52564
if (ConflictOption.CompareRowVersion == ConflictOption) {
throw ADP.DynamicSQLNoKeyInfoRowVersionUpdate();
}
throw ADP.DynamicSQLNoKeyInfoUpdate();
}
if (!flag && (ConflictOption.CompareAllSearchableValues == ConflictOption)) {
// include other searchable values
flag = !row.IsLong && !row.IsRowVersion && !row.IsHidden;
}
return flag;
}
private bool IncludeInUpdateSet(DbSchemaRow row) {
//
return (!row.IsAutoIncrement && !row.IsRowVersion && !row.IsHidden && !row.IsReadOnly);
}
private bool IncludeInInsertValues(DbSchemaRow row) {
//
return (!row.IsAutoIncrement && !row.IsHidden && !row.IsExpression && !row.IsRowVersion && !row.IsReadOnly);
}
private bool IncrementWhereCount(DbSchemaRow row)
{
System.Data.ConflictOption conflictOption = this.ConflictOption;
switch (conflictOption)
{
case System.Data.ConflictOption.CompareAllSearchableValues:
case System.Data.ConflictOption.OverwriteChanges:
return (((row.IsKey || row.IsUnique) && !row.IsLong) && !row.IsRowVersion);
case System.Data.ConflictOption.CompareRowVersion:
if (((!row.IsKey && !row.IsUnique) || this._hasPartialPrimaryKey) && !row.IsRowVersion)
{
return false;
}
return !row.IsLong;
}
throw ADP.InvalidConflictOptions(conflictOption);
}
private bool IncludeInWhereClause(DbSchemaRow row, bool isUpdate)
{
bool flag = this.IncrementWhereCount(row);
if (flag && row.IsHidden)
{
if (System.Data.ConflictOption.CompareRowVersion == this.ConflictOption)
{
throw ADP.DynamicSQLNoKeyInfoRowVersionUpdate();
}
throw ADP.DynamicSQLNoKeyInfoUpdate();
}
if (!flag && (System.Data.ConflictOption.CompareAllSearchableValues == this.ConflictOption))
{
flag = (!row.IsLong && !row.IsRowVersion) && !row.IsHidden;
}
return flag;
}
private string CreateParameterForValue(DbCommand command, string parameterName, string sourceColumn, DataRowVersion version, int parameterCount, object value, DbSchemaRow row, StatementType statementType, bool whereClause)
{
DbParameter nextParameter = GetNextParameter(command, parameterCount);
if (parameterName == null)
{
nextParameter.ParameterName = this.GetParameterName((int) (1 + parameterCount));
}
else
{
nextParameter.ParameterName = parameterName;
}
nextParameter.Direction = ParameterDirection.Input;
nextParameter.SourceColumn = sourceColumn;
nextParameter.SourceVersion = version;
nextParameter.SourceColumnNullMapping = false;
nextParameter.Value = value;
nextParameter.Size = 0;
this.ApplyParameterInfo(nextParameter, row.DataRow, statementType, whereClause);
if (!command.Parameters.Contains(nextParameter))
{
command.Parameters.Add(nextParameter);
}
if (parameterName == null)
{
return this.GetParameterPlaceholder(1 + parameterCount);
}
return string.Format(CultureInfo.InvariantCulture, this._parameterMarkerFormat, new object[] { parameterName });
}
internal void GenerateMissingNames(DbSchemaRow[] schemaRows)
{
for (int i = 0; i < this._baseParameterNames.Length; i++)
{
if (this._baseParameterNames[i] == null)
{
this._baseParameterNames[i] = this.GetNextGenericParameterName();
this._originalParameterNames[i] = this.GetNextGenericParameterName();
if ((schemaRows[i] != null) && schemaRows[i].AllowDBNull)
{
this._nullParameterNames[i] = this.GetNextGenericParameterName();
}
}
}
}
internal ParameterNames(DbCommandBuilder dbCommandBuilder, DbSchemaRow[] schemaRows)
{
this._dbCommandBuilder = dbCommandBuilder;
this._baseParameterNames = new string[schemaRows.Length];
this._originalParameterNames = new string[schemaRows.Length];
this._nullParameterNames = new string[schemaRows.Length];
this._isMutatedName = new bool[schemaRows.Length];
this._count = schemaRows.Length;
this._parameterNameParser = new Regex(this._dbCommandBuilder.ParameterNamePattern, RegexOptions.Singleline | RegexOptions.ExplicitCapture);
this.SetAndValidateNamePrefixes();
this._adjustedParameterNameMaxLength = this.GetAdjustedParameterNameMaxLength();
for (int i = 0; i < schemaRows.Length; i++)
{
if (schemaRows[i] != null)
{
bool flag = false;
string columnName = schemaRows[i].ColumnName;
if (((this._originalPrefix == null) || !columnName.StartsWith(this._originalPrefix, StringComparison.OrdinalIgnoreCase)) && ((this._isNullPrefix == null) || !columnName.StartsWith(this._isNullPrefix, StringComparison.OrdinalIgnoreCase)))
{
if (columnName.IndexOf(' ') >= 0)
{
columnName = columnName.Replace(' ', '_');
flag = true;
}
if (this._parameterNameParser.IsMatch(columnName) && (columnName.Length <= this._adjustedParameterNameMaxLength))
{
this._baseParameterNames[i] = columnName;
this._isMutatedName[i] = flag;
}
}
}
}
this.EliminateConflictingNames();
for (int j = 0; j < schemaRows.Length; j++)
{
if (this._baseParameterNames[j] != null)
{
if (this._originalPrefix != null)
{
this._originalParameterNames[j] = this._originalPrefix + this._baseParameterNames[j];
}
if ((this._isNullPrefix != null) && schemaRows[j].AllowDBNull)
{
this._nullParameterNames[j] = this._isNullPrefix + this._baseParameterNames[j];
}
}
}
this.ApplyProviderSpecificFormat();
this.GenerateMissingNames(schemaRows);
}
private bool IncludeInUpdateSet(DbSchemaRow row)
{
// NOTE: Include ignore condition - i.e. ignore if 'row' is IsReadOnly else include
return (!row.IsAutoIncrement && !row.IsRowVersion && !row.IsHidden && !row.IsReadOnly);
}