mcs/class/referencesource/System.Data/System/Data/Common/DBSchemaRow.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="DBSchemaRow.cs" company="Microsoft">
   3 //      Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 // <owner current="true" primary="true">Microsoft</owner>
   6 // <owner current="true" primary="false">Microsoft</owner>
   7 //------------------------------------------------------------------------------
   8
   9 namespace System.Data.Common {
  10
  11     using System;
  12     using System.ComponentModel;
  13     using System.Data;
  14     using System.Diagnostics;
  15     using System.Globalization;
  16
  17     sealed internal class DbSchemaRow {
  18         internal const string SchemaMappingUnsortedIndex = "SchemaMapping Unsorted Index";
  19         DbSchemaTable schemaTable;
  20         DataRow dataRow;
  21
  22         static internal DbSchemaRow[] GetSortedSchemaRows(DataTable dataTable, bool returnProviderSpecificTypes) { // MDAC 60609
  23             DataColumn sortindex= dataTable.Columns[SchemaMappingUnsortedIndex];
  24             if (null == sortindex) { // WebData 100390
  25                 sortindex = new DataColumn(SchemaMappingUnsortedIndex, typeof(Int32)); // MDAC 67050
  26                 dataTable.Columns.Add(sortindex);
  27             }
  28             int count = dataTable.Rows.Count;
  29             for (int i = 0; i < count; ++i) {
  30                 dataTable.Rows[i][sortindex] = i;
  31             };
  32             DbSchemaTable schemaTable = new DbSchemaTable(dataTable, returnProviderSpecificTypes);
  33
  34             const DataViewRowState rowStates = DataViewRowState.Unchanged | DataViewRowState.Added | DataViewRowState.ModifiedCurrent;
  35             DataRow[] dataRows = dataTable.Select(null, "ColumnOrdinal ASC", rowStates);
  36             Debug.Assert(null != dataRows, "GetSchemaRows: unexpected null dataRows");
  37
  38             DbSchemaRow[] schemaRows = new DbSchemaRow[dataRows.Length];
  39
  40             for (int i = 0; i < dataRows.Length; ++i) {
  41                 schemaRows[i] = new DbSchemaRow(schemaTable, dataRows[i]);
  42             }
  43             return schemaRows;
  44         }
  45
  46         internal DbSchemaRow(DbSchemaTable schemaTable, DataRow dataRow) {
  47             this.schemaTable = schemaTable;
  48             this.dataRow = dataRow;
  49         }
  50
  51         internal DataRow DataRow {
  52             get {
  53                 return dataRow;
  54             }
  55         }
  56
  57         internal string ColumnName {
  58             get {
  59                 Debug.Assert(null != schemaTable.ColumnName, "no column ColumnName");
  60                 object value = dataRow[schemaTable.ColumnName, DataRowVersion.Default];
  61                 if (!Convert.IsDBNull(value)) {
  62                     return Convert.ToString(value, CultureInfo.InvariantCulture);
  63                 }
  64                 return "";
  65             }
  66             /*set {
  67                 Debug.Assert(null != schemaTable.ColumnName, "missing column ColumnName");
  68                 dataRow[schemaTable.ColumnName] = value;
  69             }*/
  70         }
  71
  72         //internal Int32 Ordinal {
  73             /*get {
  74                 Debug.Assert(null != schemaTable.Ordinal, "no column Ordinal");
  75                 return Convert.ToInt32(dataRow[schemaTable.Ordinal, DataRowVersion.Default], CultureInfo.InvariantCulture);
  76             }*/
  77             /*set {
  78                 Debug.Assert(null != schemaTable.Ordinal, "missing column Ordinal");
  79                 dataRow[schemaTable.Ordinal] = value;
  80             }*/
  81
  82         //}
  83
  84         internal Int32 Size {
  85             get {
  86                 Debug.Assert(null != schemaTable.Size, "no column Size");
  87                 object value = dataRow[schemaTable.Size, DataRowVersion.Default];
  88                 if (!Convert.IsDBNull(value)) {
  89                     return Convert.ToInt32(value, CultureInfo.InvariantCulture);
  90                 }
  91                 return 0;
  92             }
  93             /*set {
  94                 Debug.Assert(null != schemaTable.Size, "missing column Size");
  95                 dataRow[schemaTable.Size] = value;
  96             }*/
  97         }
  98
  99         internal string BaseColumnName {
 100             get {
 101                 if (null != schemaTable.BaseColumnName) {
 102                     object value = dataRow[schemaTable.BaseColumnName, DataRowVersion.Default];
 103                     if (!Convert.IsDBNull(value)) {
 104                         return Convert.ToString(value, CultureInfo.InvariantCulture);
 105                     }
 106                 }
 107                 return "";
 108             }
 109             /*set {
 110                 Debug.Assert(null != schemaTable.BaseColumnName, "missing column BaseColumnName");
 111                 dataRow[schemaTable.BaseColumnName] = value;
 112             }*/
 113         }
 114
 115         internal string BaseServerName {
 116             get {
 117                 if (null != schemaTable.BaseServerName) {
 118                     object value = dataRow[schemaTable.BaseServerName, DataRowVersion.Default];
 119                     if (!Convert.IsDBNull(value)) {
 120                         return Convert.ToString(value, CultureInfo.InvariantCulture);
 121                     }
 122                 }
 123                 return "";
 124             }
 125             /*set {
 126                 Debug.Assert(null != schemaTable.BaseServerName, "missing column BaseServerName");
 127                 dataRow[schemaTable.BaseServerName] = value;
 128             }*/
 129         }
 130
 131
 132         internal string BaseCatalogName {
 133             get {
 134                 if (null != schemaTable.BaseCatalogName) {
 135                     object value = dataRow[schemaTable.BaseCatalogName, DataRowVersion.Default];
 136                     if (!Convert.IsDBNull(value)) {
 137                         return Convert.ToString(value, CultureInfo.InvariantCulture);
 138                     }
 139                 }
 140                 return "";
 141             }
 142             /*set {
 143                 Debug.Assert(null != schemaTable.BaseCatalogName, "missing column BaseCatalogName");
 144                 dataRow[schemaTable.BaseCatalogName] = value;
 145             }*/
 146         }
 147
 148         internal string BaseSchemaName {
 149             get {
 150                 if (null != schemaTable.BaseSchemaName) {
 151                     object value = dataRow[schemaTable.BaseSchemaName, DataRowVersion.Default];
 152                     if (!Convert.IsDBNull(value)) {
 153                         return Convert.ToString(value, CultureInfo.InvariantCulture);
 154                     }
 155                 }
 156                 return "";
 157             }
 158             /*set {
 159                 Debug.Assert(null != schemaTable.BaseSchemaName, "missing column BaseSchemaName");
 160                 dataRow[schemaTable.BaseSchemaName] = value;
 161             }*/
 162         }
 163
 164         internal string BaseTableName {
 165             get {
 166                 if (null != schemaTable.BaseTableName) {
 167                     object value = dataRow[schemaTable.BaseTableName, DataRowVersion.Default];
 168                     if (!Convert.IsDBNull(value)) {
 169                         return Convert.ToString(value, CultureInfo.InvariantCulture);
 170                     }
 171                 }
 172                 return "";
 173             }
 174             /*set {
 175                 Debug.Assert(null != schemaTable.BaseTableName, "missing column BaseTableName");
 176                 dataRow[schemaTable.BaseTableName] = value;
 177             }*/
 178         }
 179
 180         internal bool IsAutoIncrement {
 181             get {
 182                 if (null != schemaTable.IsAutoIncrement) {
 183                     object value = dataRow[schemaTable.IsAutoIncrement, DataRowVersion.Default];
 184                     if (!Convert.IsDBNull(value)) {
 185                         return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
 186                     }
 187                 }
 188                 return false;
 189             }
 190             /*set {
 191                 Debug.Assert(null != schemaTable.IsAutoIncrement, "missing column IsAutoIncrement");
 192                 dataRow[schemaTable.IsAutoIncrement] = (bool)value;
 193             }*/
 194         }
 195
 196         internal bool IsUnique {
 197             get {
 198                 if (null != schemaTable.IsUnique) {
 199                     object value = dataRow[schemaTable.IsUnique, DataRowVersion.Default];
 200                     if (!Convert.IsDBNull(value)) {
 201                         return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
 202                     }
 203                 }
 204                 return false;
 205             }
 206             /*set {
 207                 Debug.Assert(null != schemaTable.IsUnique, "missing column IsUnique");
 208                 dataRow[schemaTable.IsUnique] = (bool)value;
 209             }*/
 210         }
 211
 212         internal bool IsRowVersion {
 213             get {
 214                 if (null != schemaTable.IsRowVersion) {
 215                     object value = dataRow[schemaTable.IsRowVersion, DataRowVersion.Default];
 216                     if (!Convert.IsDBNull(value)) {
 217                         return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
 218                     }
 219                 }
 220                 return false;
 221             }
 222             /*set {
 223                 Debug.Assert(null != schemaTable.IsRowVersion, "missing column IsRowVersion");
 224                 dataRow[schemaTable.IsRowVersion] = value;
 225             }*/
 226         }
 227
 228         internal bool IsKey {
 229             get {
 230                 if (null != schemaTable.IsKey) {
 231                     object value = dataRow[schemaTable.IsKey, DataRowVersion.Default];
 232                     if (!Convert.IsDBNull(value)) {
 233                         return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
 234                     }
 235                 }
 236                 return false;
 237             }
 238             /*set {
 239                 Debug.Assert(null != schemaTable.IsKey, "missing column IsKey");
 240                 dataRow[schemaTable.IsKey] = value;
 241             }*/
 242         }
 243
 244         // consider:  just do comparison directly -> (object)(baseColumnName) == (object)(columnName)
 245         //internal bool IsAliased {
 246             /*get {
 247                 if (null != schemaTable.IsAliased) { // MDAC 62336
 248                     object value = dataRow[schemaTable.IsAliased, DataRowVersion.Default];
 249                     if (!Convert.IsDBNull(value)) {
 250                         return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
 251                     }
 252                 }
 253                 return false;
 254             }*/
 255             /*set {
 256                 Debug.Assert(null != schemaTable.IsAliased, "missing column IsAliased");
 257                 dataRow[schemaTable.IsAliased] = value;
 258             }*/
 259         //}
 260
 261         internal bool IsExpression {
 262             get {
 263                 if (null != schemaTable.IsExpression) { // MDAC 62336
 264                     object value = dataRow[schemaTable.IsExpression, DataRowVersion.Default];
 265                     if (!Convert.IsDBNull(value)) {
 266                         return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
 267                     }
 268                 }
 269                 return false;
 270             }
 271             /*set {
 272                 Debug.Assert(null != schemaTable.IsExpression, "missing column IsExpression");
 273                 dataRow[schemaTable.IsExpression] = value;
 274             }*/
 275         }
 276
 277         //internal bool IsIdentity {
 278             /*get {
 279                 if (null != schemaTable.IsIdentity) { // MDAC 62336
 280                     object value = dataRow[schemaTable.IsIdentity, DataRowVersion.Default];
 281                     if (!Convert.IsDBNull(value)) {
 282                         return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
 283                     }
 284                 }
 285                 return false;
 286             }*/
 287             /*set {
 288                 Debug.Assert(null != schemaTable.IsIdentity, "missing column IsIdentity");
 289                 dataRow[schemaTable.IsIdentity] = value;
 290             }*/
 291         //}
 292
 293         internal bool IsHidden {
 294             get {
 295                 if (null != schemaTable.IsHidden) { // MDAC 62336
 296                     object value = dataRow[schemaTable.IsHidden, DataRowVersion.Default];
 297                     if (!Convert.IsDBNull(value)) {
 298                         return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
 299                     }
 300                 }
 301                 return false;
 302             }
 303             /*set {
 304                 Debug.Assert(null != schemaTable.IsHidden, "missing column IsHidden");
 305                 dataRow[schemaTable.IsHidden] = value;
 306             }*/
 307         }
 308
 309         internal bool IsLong {
 310             get {
 311                 if (null != schemaTable.IsLong) { // MDAC 62336
 312                     object value = dataRow[schemaTable.IsLong, DataRowVersion.Default];
 313                     if (!Convert.IsDBNull(value)) {
 314                         return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
 315                     }
 316                 }
 317                 return false;
 318             }
 319             /*set {
 320                 Debug.Assert(null != schemaTable.IsLong, "missing column IsHidden");
 321                 dataRow[schemaTable.IsLong] = value;
 322             }*/
 323         }
 324
 325         internal bool IsReadOnly {
 326             get {
 327                 if (null != schemaTable.IsReadOnly) { // MDAC 62336
 328                     object value = dataRow[schemaTable.IsReadOnly, DataRowVersion.Default];
 329                     if (!Convert.IsDBNull(value)) {
 330                         return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
 331                     }
 332                 }
 333                 return false;
 334             }
 335             /*set {
 336                 Debug.Assert(null != schemaTable.IsReadOnly, "missing column IsReadOnly");
 337                 dataRow[schemaTable.IsReadOnly] = value;
 338             }*/
 339         }
 340
 341         internal System.Type DataType {
 342             get {
 343                 if (null != schemaTable.DataType) {
 344                     object value = dataRow[schemaTable.DataType, DataRowVersion.Default];
 345                     if (!Convert.IsDBNull(value)) {
 346                         return(System.Type) value;
 347                     }
 348                 }
 349                 return null;
 350             }
 351             /*set {
 352                 Debug.Assert(null != schemaTable.DataType, "missing column DataType");
 353                 dataRow[schemaTable.DataType] = value;
 354             }*/
 355         }
 356
 357         internal bool AllowDBNull {
 358             get {
 359                 if (null != schemaTable.AllowDBNull) {
 360                     object value = dataRow[schemaTable.AllowDBNull, DataRowVersion.Default];
 361                     if (!Convert.IsDBNull(value)) {
 362                         return Convert.ToBoolean(value, CultureInfo.InvariantCulture);
 363                     }
 364                 }
 365                 return true;
 366             }
 367             /*set {
 368                 Debug.Assert(null != schemaTable.AllowDBNull, "missing column MaybeNull");
 369                 dataRow[schemaTable.AllowDBNull] = value;
 370             }*/
 371         }
 372
 373         /*internal Int32 ProviderType {
 374             get {
 375                 if (null != schemaTable.ProviderType) {
 376                     object value = dataRow[schemaTable.ProviderType, DataRowVersion.Default];
 377                     if (!Convert.IsDBNull(value)) {
 378                         return Convert.ToInt32(value);
 379                     }
 380                 }
 381                 return 0;
 382             }
 383             set {
 384                 Debug.Assert(null != schemaTable.ProviderType, "missing column ProviderType");
 385                 dataRow[schemaTable.ProviderType] = value;
 386             }
 387         }*/
 388
 389         internal Int32 UnsortedIndex {
 390             get {
 391                 return (Int32) dataRow[schemaTable.UnsortedIndex, DataRowVersion.Default];
 392             }
 393         }
 394     }
 395 }