using System.Runtime.InteropServices;
namespace System.Data.Common {
+#if NET_2_0
+ public abstract class DbDataAdapter : DataAdapter, IDbDataAdapter, IDataAdapter, ICloneable
+#else
public abstract class DbDataAdapter : DataAdapter, ICloneable
+#endif
{
#region Fields
public const string DefaultSourceTableName = "Table";
const string DefaultSourceColumnName = "Column";
+#if NET_2_0
+ IDbCommand _selectCommand;
+ internal IDbCommand _updateCommand;
+ internal IDbCommand _deleteCommand;
+ internal IDbCommand _insertCommand;
+#endif
+
#endregion // Fields
#region Constructors
{
}
- [MonoTODO]
protected DbDataAdapter(DbDataAdapter adapter) : base(adapter)
{
}
#region Properties
#if NET_2_0
- [MonoTODO]
- protected virtual IDbConnection BaseConnection {
+ protected internal CommandBehavior FillCommandBehavior {
get { throw new NotImplementedException (); }
set { throw new NotImplementedException (); }
}
- public IDbConnection Connection {
- get { return BaseConnection; }
- set { BaseConnection = value; }
+ IDbCommand IDbDataAdapter.SelectCommand {
+ get { return _selectCommand; }
+ set { _selectCommand = value; }
}
-#endif
- IDbCommand DeleteCommand {
- get { return ((IDbDataAdapter) this).DeleteCommand; }
+ IDbCommand IDbDataAdapter.UpdateCommand{
+ get { return _updateCommand; }
+ set { _updateCommand = value; }
}
-#if NET_2_0
- protected internal CommandBehavior FillCommandBehavior {
- get { throw new NotImplementedException (); }
- set { throw new NotImplementedException (); }
+ IDbCommand IDbDataAdapter.DeleteCommand{
+ get { return _deleteCommand; }
+ set { _deleteCommand = value; }
}
-#endif
- IDbCommand InsertCommand {
- get { return ((IDbDataAdapter) this).InsertCommand; }
+ IDbCommand IDbDataAdapter.InsertCommand{
+ get { return _insertCommand; }
+ set { _insertCommand = value; }
}
-
-#if NET_2_0
- [MonoTODO]
- protected virtual IDbCommand this [[Optional] StatementType statementType] {
- get { throw new NotImplementedException (); }
- set { throw new NotImplementedException (); }
+
+ [Browsable (false)]
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ public DbCommand SelectCommand {
+ get { return (DbCommand) ((IDbDataAdapter) this).SelectCommand; }
+ set { ((IDbDataAdapter) this).SelectCommand = value; }
}
- protected virtual DbProviderFactory ProviderFactory {
- get { throw new NotImplementedException (); }
+ [Browsable (false)]
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ public DbCommand DeleteCommand {
+ get { return (DbCommand) ((IDbDataAdapter) this).DeleteCommand; }
+ set { ((IDbDataAdapter) this).DeleteCommand = value; }
}
-#endif
- IDbCommand SelectCommand {
- get { return ((IDbDataAdapter) this).SelectCommand; }
+ [Browsable (false)]
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ public DbCommand InsertCommand {
+ get { return (DbCommand) ((IDbDataAdapter) this).InsertCommand; }
+ set { ((IDbDataAdapter) this).InsertCommand = value; }
}
-#if NET_2_0
- [MonoTODO]
- public IDbTransaction Transaction {
- get { throw new NotImplementedException (); }
- set { throw new NotImplementedException (); }
+ [Browsable (false)]
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ public DbCommand UpdateCommand {
+ get { return (DbCommand) ((IDbDataAdapter) this).UpdateCommand; }
+ set { ((IDbDataAdapter) this).UpdateCommand = value; }
}
[MonoTODO]
- public int UpdateBatchSize {
- get { throw new NotImplementedException (); }
- set { throw new NotImplementedException (); }
+ [DefaultValue (1)]
+ public virtual int UpdateBatchSize {
+ get { return 1; }
+ set { throw new NotSupportedException (); }
+ }
+#else
+ IDbCommand SelectCommand {
+ get { return ((IDbDataAdapter) this).SelectCommand; }
}
-#endif
IDbCommand UpdateCommand {
get { return ((IDbDataAdapter) this).UpdateCommand; }
}
+ IDbCommand DeleteCommand {
+ get { return ((IDbDataAdapter) this).DeleteCommand; }
+ }
+
+ IDbCommand InsertCommand {
+ get { return ((IDbDataAdapter) this).InsertCommand; }
+ }
+#endif
+
#endregion // Properties
#region Events
#region Methods
#if NET_2_0
+ protected virtual RowUpdatedEventArgs CreateRowUpdatedEvent (DataRow dataRow, IDbCommand command,
+ StatementType statementType,
+ DataTableMapping tableMapping)
+ {
+ return new RowUpdatedEventArgs (dataRow, command, statementType, tableMapping);
+ }
+
+ protected virtual RowUpdatingEventArgs CreateRowUpdatingEvent (DataRow dataRow, IDbCommand command,
+ StatementType statementType,
+ DataTableMapping tableMapping)
+ {
+ return new RowUpdatingEventArgs (dataRow, command, statementType, tableMapping);
+ }
+
[MonoTODO]
- public virtual void BeginInit ()
+ protected virtual void OnRowUpdated (RowUpdatedEventArgs value)
{
throw new NotImplementedException ();
}
+
+ [MonoTODO]
+ protected virtual void OnRowUpdating (RowUpdatingEventArgs value)
+ {
+ throw new NotImplementedException ();
+ }
+#else
+ protected abstract RowUpdatedEventArgs CreateRowUpdatedEvent (DataRow dataRow, IDbCommand command,
+ StatementType statementType,
+ DataTableMapping tableMapping);
+
+ protected abstract RowUpdatingEventArgs CreateRowUpdatingEvent (DataRow dataRow, IDbCommand command,
+ StatementType statementType,
+ DataTableMapping tableMapping);
+
+ protected abstract void OnRowUpdated (RowUpdatedEventArgs value);
+ protected abstract void OnRowUpdating (RowUpdatingEventArgs value);
#endif
- protected abstract RowUpdatedEventArgs CreateRowUpdatedEvent (DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping);
- protected abstract RowUpdatingEventArgs CreateRowUpdatingEvent (DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping);
private FillErrorEventArgs CreateFillErrorEvent (DataTable dataTable, object[] values, Exception e)
{
}
}
-#if NET_2_0
- [MonoTODO]
- public virtual void EndInit ()
- {
- throw new NotImplementedException ();
- }
-#endif
-
public override int Fill (DataSet dataSet)
{
- return Fill (dataSet, 0, 0, DefaultSourceTableName, SelectCommand, CommandBehavior.Default);
+ return Fill (dataSet, 0, 0, DefaultSourceTableName, ((IDbDataAdapter) this).SelectCommand, CommandBehavior.Default);
}
public int Fill (DataTable dataTable)
{
if (dataTable == null)
- throw new NullReferenceException ();
+ throw new ArgumentNullException ("DataTable");
- return Fill (dataTable, SelectCommand, CommandBehavior.Default);
+ return Fill (dataTable, ((IDbDataAdapter) this).SelectCommand, CommandBehavior.Default);
}
public int Fill (DataSet dataSet, string srcTable)
{
- return Fill (dataSet, 0, 0, srcTable, SelectCommand, CommandBehavior.Default);
+ return Fill (dataSet, 0, 0, srcTable, ((IDbDataAdapter) this).SelectCommand, CommandBehavior.Default);
}
#if NET_2_0
- protected override int Fill (DataTable dataTable, IDataReader dataReader)
+ [MonoTODO ("This needs to be moved to DataAdapter.For now, just override")]
+ protected override
#else
- protected virtual int Fill (DataTable dataTable, IDataReader dataReader)
+ protected virtual
#endif
+ int Fill (DataTable dataTable, IDataReader dataReader)
{
if (dataReader.FieldCount == 0) {
dataReader.Close ();
protected virtual int Fill (DataTable dataTable, IDbCommand command, CommandBehavior behavior)
{
CommandBehavior commandBehavior = behavior;
+
// first see that the connection is not close.
if (command.Connection.State == ConnectionState.Closed)
{
return Fill (dataTable, command.ExecuteReader (commandBehavior));
}
+ public int Fill (DataSet dataSet, int startRecord, int maxRecords, string srcTable)
+ {
+ return this.Fill (dataSet, startRecord, maxRecords, srcTable, ((IDbDataAdapter) this).SelectCommand, CommandBehavior.Default);
+ }
+
#if NET_2_0
[MonoTODO]
public int Fill (int startRecord, int maxRecords, DataTable[] dataTables)
{
throw new NotImplementedException ();
}
-#endif
- public int Fill (DataSet dataSet, int startRecord, int maxRecords, string srcTable)
- {
- return this.Fill (dataSet, startRecord, maxRecords, srcTable, SelectCommand, CommandBehavior.Default);
- }
-
-#if NET_2_0
[MonoTODO]
protected virtual int Fill (DataTable[] dataTables, int startRecord, int maxRecords, IDbCommand command, CommandBehavior behavior)
{
throw new NotImplementedException ();
}
#endif
-
+
+
#if NET_2_0
- protected override int Fill (DataSet dataSet, string srcTable, IDataReader dataReader, int startRecord, int maxRecords)
+ [MonoTODO ("This needs to be moved to DataAdapter.For now, just override")]
+ protected override
#else
- protected virtual int Fill (DataSet dataSet, string srcTable, IDataReader dataReader, int startRecord, int maxRecords)
+ protected virtual
#endif
+ int Fill (DataSet dataSet, string srcTable, IDataReader dataReader, int startRecord, int maxRecords)
{
+ if (dataSet == null)
+ throw new ArgumentNullException ("DataSet");
+
if (startRecord < 0)
throw new ArgumentException ("The startRecord parameter was less than 0.");
if (maxRecords < 0)
throw new ArgumentException ("The maxRecords parameter was less than 0.");
- DataTable dataTable;
+ DataTable dataTable = null;
int resultIndex = 0;
int count = 0;
{
tableName = SetupSchema (SchemaType.Mapped, tableName);
if (tableName != null) {
-
+
// check if the table exists in the dataset
if (dataSet.Tables.Contains (tableName))
// get the table from the dataset
dataTable = dataSet.Tables [tableName];
else {
- dataTable = new DataTable(tableName);
- dataSet.Tables.Add (dataTable);
+ // Do not create schema if MissingSchemAction is set to Ignore
+ if (this.MissingSchemaAction == MissingSchemaAction.Ignore)
+ continue;
+ dataTable = dataSet.Tables.Add (tableName);
}
if (!FillTable (dataTable, dataReader, startRecord, maxRecords, ref count)) {
if (MissingSchemaAction == MissingSchemaAction.AddWithKey)
behavior |= CommandBehavior.KeyInfo;
CommandBehavior commandBehavior = behavior;
+
if (command.Connection.State == ConnectionState.Closed) {
command.Connection.Open ();
commandBehavior |= CommandBehavior.CloseConnection;
int counterStart = counter;
int[] mapping = BuildSchema (dataReader, dataTable, SchemaType.Mapped);
-
+
int[] sortedMapping = new int[mapping.Length];
int length = sortedMapping.Length;
for(int i=0; i < sortedMapping.Length; i++) {
dataReader.Read ();
}
+ dataTable.BeginLoadData ();
while (dataReader.Read () && (maxRecords == 0 || (counter - counterStart) < maxRecords)) {
try {
- dataTable.BeginLoadData ();
dataTable.LoadDataRow (dataReader, sortedMapping, length, AcceptChangesDuringFill);
- dataTable.EndLoadData ();
counter++;
- }
+ }
catch (Exception e) {
object[] readerArray = new object[dataReader.FieldCount];
object[] tableArray = new object[mapping.Length];
}
FillErrorEventArgs args = CreateFillErrorEvent (dataTable, tableArray, e);
OnFillError (args);
- if(!args.Continue) {
- return false;
- }
+
+ // if args.Continue is not set to true or if a handler is not set, rethrow the error..
+ if(!args.Continue)
+ throw e;
}
}
+ dataTable.EndLoadData ();
return true;
}
#if NET_2_0
- /// <summary>
- /// Fills the given datatable using values from reader. if a value
- /// for a column is null, that will be filled with default value.
- /// </summary>
- /// <returns>No. of rows affected </returns>
+ /// <summary>
+ /// Fills the given datatable using values from reader. if a value
+ /// for a column is null, that will be filled with default value.
+ /// </summary>
+ /// <returns>No. of rows affected </returns>
internal static int FillFromReader (DataTable table,
IDataReader reader,
int start,
return counter;
}
+ internal static int FillFromReader (DataTable table,
+ IDataReader reader,
+ int start,
+ int length,
+ int [] mapping,
+ LoadOption loadOption,
+ FillErrorEventHandler errorHandler)
+ {
+ if (reader.FieldCount == 0)
+ return 0 ;
+
+ for (int i = 0; i < start; i++)
+ reader.Read ();
+
+ int counter = 0;
+ object [] values = new object [mapping.Length];
+ while (reader.Read () &&
+ (length == 0 || counter < length)) {
+
+ for (int i = 0 ; i < mapping.Length; i++)
+ values [i] = mapping [i] < 0 ? null : reader [mapping [i]];
+
+ table.BeginLoadData ();
+ try {
+ table.LoadDataRow (values, loadOption);
+ } catch (Exception e) {
+ FillErrorEventArgs args = new FillErrorEventArgs (table, values);
+ args.Errors = e;
+ args.Continue = false;
+ errorHandler (table, args);
+ // if args.Continue is not set to true or if a handler is not set, rethrow the error..
+ if(!args.Continue)
+ throw e;
+ }
+ table.EndLoadData ();
+ counter++;
+ }
+ return counter;
+ }
+
#endif // NET_2_0
public override DataTable[] FillSchema (DataSet dataSet, SchemaType schemaType)
{
- return FillSchema (dataSet, schemaType, SelectCommand, DefaultSourceTableName, CommandBehavior.Default);
+ return FillSchema (dataSet, schemaType, ((IDbDataAdapter) this).SelectCommand, DefaultSourceTableName, CommandBehavior.Default);
}
public DataTable FillSchema (DataTable dataTable, SchemaType schemaType)
{
- return FillSchema (dataTable, schemaType, SelectCommand, CommandBehavior.Default);
+ return FillSchema (dataTable, schemaType, ((IDbDataAdapter) this).SelectCommand, CommandBehavior.Default);
}
public DataTable[] FillSchema (DataSet dataSet, SchemaType schemaType, string srcTable)
{
- return FillSchema (dataSet, schemaType, SelectCommand, srcTable, CommandBehavior.Default);
+ return FillSchema (dataSet, schemaType, ((IDbDataAdapter) this).SelectCommand, srcTable, CommandBehavior.Default);
}
- [MonoTODO ("Verify")]
protected virtual DataTable FillSchema (DataTable dataTable, SchemaType schemaType, IDbCommand command, CommandBehavior behavior)
{
+ if (dataTable == null)
+ throw new ArgumentNullException ("DataTable");
+
behavior |= CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo;
if (command.Connection.State == ConnectionState.Closed) {
command.Connection.Open ();
string tableName = SetupSchema (schemaType, dataTable.TableName);
if (tableName != null)
{
- BuildSchema (reader, dataTable, schemaType);
+ // FillSchema should add the KeyInfo unless MissingSchemaAction
+ // is set to Ignore or Error.
+ MissingSchemaAction schemaAction = MissingSchemaAction;
+ if (!(schemaAction == MissingSchemaAction.Ignore ||
+ schemaAction == MissingSchemaAction.Error))
+ schemaAction = MissingSchemaAction.AddWithKey;
+
+ BuildSchema (reader, dataTable, schemaType, schemaAction,
+ MissingMappingAction, TableMappings);
}
}
finally
return dataTable;
}
- [MonoTODO ("Verify")]
protected virtual DataTable[] FillSchema (DataSet dataSet, SchemaType schemaType, IDbCommand command, string srcTable, CommandBehavior behavior)
{
+ if (dataSet == null)
+ throw new ArgumentNullException ("DataSet");
+
behavior |= CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo;
if (command.Connection.State == ConnectionState.Closed) {
command.Connection.Open ();
DataTable table;
try
{
- tableName = SetupSchema (schemaType, tableName);
- if (tableName != null)
- {
- if (dataSet.Tables.Contains (tableName))
- table = dataSet.Tables [tableName];
- else
+ // FillSchema should add the KeyInfo unless MissingSchemaAction
+ // is set to Ignore or Error.
+ MissingSchemaAction schemaAction = MissingSchemaAction;
+ if (!(MissingSchemaAction == MissingSchemaAction.Ignore ||
+ MissingSchemaAction == MissingSchemaAction.Error))
+ schemaAction = MissingSchemaAction.AddWithKey;
+
+ do {
+ tableName = SetupSchema (schemaType, tableName);
+ if (tableName != null)
{
- table = new DataTable(tableName);
- dataSet.Tables.Add (table);
+ if (dataSet.Tables.Contains (tableName))
+ table = dataSet.Tables [tableName];
+ else
+ {
+ // Do not create schema if MissingSchemAction is set to Ignore
+ if (this.MissingSchemaAction == MissingSchemaAction.Ignore)
+ continue;
+ table = dataSet.Tables.Add (tableName);
+ }
+
+ BuildSchema (reader, table, schemaType, schemaAction,
+ MissingMappingAction, TableMappings);
+ output.Add (table);
+ tableName = String.Format ("{0}{1}", srcTable, ++index);
}
- BuildSchema (reader, table, schemaType);
- output.Add (table);
- tableName = String.Format ("{0}{1}", srcTable, ++index);
- }
+ }while (reader.NextResult ());
}
finally
{
return (DataTable[]) output.ToArray (typeof (DataTable));
}
-#if NET_2_0
- [MonoTODO]
- public DataSet GetDataSet ()
- {
- throw new NotImplementedException ();
- }
-
- [MonoTODO]
- public DataTable GetDataTable ()
- {
- throw new NotImplementedException ();
- }
-#endif
-
private string SetupSchema (SchemaType schemaType, string sourceTableName)
{
DataTableMapping tableMapping = null;
if (schemaType == SchemaType.Mapped)
{
tableMapping = DataTableMappingCollection.GetTableMappingBySchemaAction (TableMappings, sourceTableName, sourceTableName, MissingMappingAction);
-
if (tableMapping != null)
return tableMapping.DataSetTable;
return null;
[EditorBrowsable (EditorBrowsableState.Advanced)]
public override IDataParameter[] GetFillParameters ()
{
- IDataParameter[] parameters = new IDataParameter[SelectCommand.Parameters.Count];
+ IDataParameter[] parameters = new IDataParameter [SelectCommand.Parameters.Count];
SelectCommand.Parameters.CopyTo (parameters, 0);
return parameters;
}
// "array[ordinal of datatable column] == index of source column in data reader".
// each column in the datatable has a mapping to a specific column in the datareader,
// the int array represents this match.
- [MonoTODO ("Test")]
private int[] BuildSchema (IDataReader reader, DataTable table, SchemaType schemaType)
{
return BuildSchema (reader, table, schemaType, MissingSchemaAction,
bool createPrimaryKey = true;
DataTable schemaTable = reader.GetSchemaTable ();
- int colIndex;
- DataColumn ColumnNameCol = ((colIndex = schemaTable.Columns.IndexOf("ColumnName")) >= 0) ? schemaTable.Columns[colIndex] : null;
- DataColumn DataTypeCol = ((colIndex = schemaTable.Columns.IndexOf("DataType")) >= 0) ? schemaTable.Columns[colIndex] : null;
- DataColumn IsAutoIncrementCol = ((colIndex = schemaTable.Columns.IndexOf("IsAutoIncrement")) >= 0) ? schemaTable.Columns[colIndex] : null;
- DataColumn AllowDBNullCol = ((colIndex = schemaTable.Columns.IndexOf("AllowDBNull")) >= 0) ? schemaTable.Columns[colIndex] : null;
- DataColumn IsReadOnlyCol = ((colIndex = schemaTable.Columns.IndexOf("IsReadOnly")) >= 0) ? schemaTable.Columns[colIndex] : null;
- DataColumn IsKeyCol = ((colIndex = schemaTable.Columns.IndexOf("IsKey")) >= 0) ? schemaTable.Columns[colIndex] : null;
- DataColumn IsUniqueCol = ((colIndex = schemaTable.Columns.IndexOf("IsUnique")) >= 0) ? schemaTable.Columns[colIndex] : null;
- DataColumn ColumnSizeCol = ((colIndex = schemaTable.Columns.IndexOf("ColumnSize")) >= 0) ? schemaTable.Columns[colIndex] : null;
+
+ DataColumn ColumnNameCol = schemaTable.Columns["ColumnName"];
+ DataColumn DataTypeCol = schemaTable.Columns["DataType"];
+ DataColumn IsAutoIncrementCol = schemaTable.Columns["IsAutoIncrement"];
+ DataColumn AllowDBNullCol = schemaTable.Columns["AllowDBNull"];
+ DataColumn IsReadOnlyCol = schemaTable.Columns["IsReadOnly"];
+ DataColumn IsKeyCol = schemaTable.Columns["IsKey"];
+ DataColumn IsUniqueCol = schemaTable.Columns["IsUnique"];
+ DataColumn ColumnSizeCol = schemaTable.Columns["ColumnSize"];
foreach (DataRow schemaRow in schemaTable.Rows) {
// generate a unique column name in the source table.
string sourceColumnName;
- if (ColumnNameCol == null || schemaRow.IsNull(ColumnNameCol))
+ string realSourceColumnName ;
+ if (ColumnNameCol == null || schemaRow.IsNull(ColumnNameCol) || (string)schemaRow [ColumnNameCol] == String.Empty) {
sourceColumnName = DefaultSourceColumnName;
- else
+ realSourceColumnName = DefaultSourceColumnName + "1";
+ }
+ else {
sourceColumnName = (string) schemaRow [ColumnNameCol];
-
- string realSourceColumnName = sourceColumnName;
+ realSourceColumnName = sourceColumnName;
+ }
for (int i = 1; sourceColumns.Contains (realSourceColumnName); i += 1)
realSourceColumnName = String.Format ("{0}{1}", sourceColumnName, i);
// generate DataSetColumnName from DataTableMapping, if any
string dsColumnName = realSourceColumnName;
DataTableMapping tableMapping = null;
- tableMapping = DataTableMappingCollection.GetTableMappingBySchemaAction (dtMapping, table.TableName, table.TableName, missingMapAction);
- if (tableMapping != null)
+
+ //FIXME : The sourcetable name shud get passed as a parameter..
+ int index = dtMapping.IndexOfDataSetTable (table.TableName);
+ string srcTable = (index != -1 ? dtMapping[index].SourceTable : table.TableName);
+ tableMapping = DataTableMappingCollection.GetTableMappingBySchemaAction (dtMapping, srcTable, table.TableName, missingMapAction);
+ if (tableMapping != null)
{
-
table.TableName = tableMapping.DataSetTable;
// check to see if the column mapping exists
DataColumnMapping columnMapping = DataColumnMappingCollection.GetColumnMappingBySchemaAction(tableMapping.ColumnMappings, realSourceColumnName, missingMapAction);
mapping = tmp;
}
- object value = (AllowDBNullCol != null) ? schemaRow[AllowDBNullCol] : null;
- bool allowDBNull = value is bool ? (bool)value : true;
- col.AllowDBNull = allowDBNull;
- value = (IsKeyCol != null) ? schemaRow[IsKeyCol] : null;
- bool isKey = value is bool ? (bool)value : false;
if (missingSchAction == MissingSchemaAction.AddWithKey) {
+ object value = (AllowDBNullCol != null) ? schemaRow[AllowDBNullCol] : null;
+ bool allowDBNull = value is bool ? (bool)value : true;
+
+ value = (IsKeyCol != null) ? schemaRow[IsKeyCol] : null;
+ bool isKey = value is bool ? (bool)value : false;
+
value = (IsAutoIncrementCol != null) ? schemaRow[IsAutoIncrementCol] : null;
bool isAutoIncrement = value is bool ? (bool)value : false;
+
value = (IsReadOnlyCol != null) ? schemaRow[IsReadOnlyCol] : null;
bool isReadOnly = value is bool ? (bool)value : false;
+
value = (IsUniqueCol != null) ? schemaRow[IsUniqueCol] : null;
bool isUnique = value is bool ? (bool)value : false;
+ col.AllowDBNull = allowDBNull;
// fill woth key info
if (isAutoIncrement && DataColumn.CanAutoIncrement(columnType)) {
col.AutoIncrement = true;
if (!allowDBNull)
col.AllowDBNull = false;
}
- }
+
+ // This might not be set by all DataProviders
+ bool isHidden = false;
+ if (schemaTable.Columns.Contains ("IsHidden")) {
+ value = schemaRow["IsHidden"];
+ isHidden = ((value is bool) ? (bool)value : false);
+ }
- if (isKey) {
- primaryKey.Add (col);
- if (allowDBNull)
- createPrimaryKey = false;
+ if (isKey && !isHidden) {
+ primaryKey.Add (col);
+ if (allowDBNull)
+ createPrimaryKey = false;
+ }
}
-
// add the ordinal of the column as a key and the index of the column in the datareader as a value.
mapping[col.Ordinal] = readerIndex++;
}
table.Constraints.Add(uConstraint);
}
}
-
return mapping;
-
}
[MonoTODO]
throw new NotImplementedException ();
}
- [MonoTODO]
public int Update (DataRow[] dataRows)
{
if (dataRows == null)
return Update (rows, tableMapping);
}
- [MonoTODO]
protected virtual int Update (DataRow[] dataRows, DataTableMapping tableMapping)
{
int updateCount = 0;
switch (row.RowState) {
case DataRowState.Added:
statementType = StatementType.Insert;
- command = InsertCommand;
+ command = ((IDbDataAdapter) this).InsertCommand;
commandName = "Insert";
break;
case DataRowState.Deleted:
statementType = StatementType.Delete;
- command = DeleteCommand;
+ command = ((IDbDataAdapter) this).DeleteCommand;
commandName = "Delete";
break;
case DataRowState.Modified:
statementType = StatementType.Update;
- command = UpdateCommand;
+ command = ((IDbDataAdapter) this).UpdateCommand;
commandName = "Update";
break;
case DataRowState.Unchanged:
try {
if (command != null) {
DataColumnMappingCollection columnMappings = tableMapping.ColumnMappings;
+ IDataParameter nullCheckParam = null;
foreach (IDataParameter parameter in command.Parameters) {
if ((parameter.Direction & ParameterDirection.Input) != 0) {
string dsColumnName = parameter.SourceColumn;
if (columnMappings.Contains(parameter.SourceColumn))
dsColumnName = columnMappings [parameter.SourceColumn].DataSetColumn;
- if (dsColumnName == null || dsColumnName.Length <= 0)
+ if (dsColumnName == null || dsColumnName.Length <= 0) {
+ nullCheckParam = parameter;
continue;
-
+ }
+
DataRowVersion rowVersion = parameter.SourceVersion;
// Parameter version is ignored for non-update commands
if (statementType == StatementType.Delete)
rowVersion = DataRowVersion.Original;
parameter.Value = row [dsColumnName, rowVersion];
+ if (nullCheckParam != null && (parameter.Value != null
+ && parameter.Value != DBNull.Value)) {
+ nullCheckParam.Value = 0;
+ nullCheckParam = null;
+ }
}
}
}
case UpdateStatus.SkipAllRemainingRows:
return updateCount;
}
+#if NET_2_0
+ if (!AcceptChangesDuringUpdate)
+ continue;
+#endif
row.AcceptChanges ();
} catch(Exception e) {
row.RowError = e.Message;
sourceTable));
return Update (dataTable, tableMapping);
}
+
+#if NET_2_0
+ // All the batch methods, should be implemented, if supported,
+ // by individual providers
+
+ protected virtual int AddToBatch (IDbCommand cmd)
+ {
+ throw new NotSupportedException ();
+ }
+
+ protected virtual void ClearBatch ()
+ {
+ throw new NotSupportedException ();
+ }
+
+ protected virtual int ExecuteBatch ()
+ {
+ throw new NotSupportedException ();
+ }
+
+ protected virtual IDataParameter GetBatchedParameter (int commandIdentifier, int parameterIdentifer)
+ {
+ throw new NotSupportedException ();
+ }
+
+ protected virtual void InitializeBatching ()
+ {
+ throw new NotSupportedException ();
+ }
+
+ protected virtual void TerminateBatching ()
+ {
+ throw new NotSupportedException ();
+ }
+#endif
#if ONLY_1_0 || ONLY_1_1
protected virtual void OnFillError (FillErrorEventArgs value)
}
#endif
- protected abstract void OnRowUpdated (RowUpdatedEventArgs value);
- protected abstract void OnRowUpdating (RowUpdatingEventArgs value);
-
#endregion // Methods
}
}
projects / mono.git / blobdiff