private string GetColumnDataType(MsAccessColumnSchema column)
{
switch (column.OleDbType)
{
case OleDbType.Boolean:
return("Bit");
case OleDbType.TinyInt:
case OleDbType.UnsignedTinyInt:
return("Byte");
case OleDbType.SmallInt:
case OleDbType.UnsignedSmallInt:
return("Short");
case OleDbType.Integer:
case OleDbType.BigInt:
case OleDbType.UnsignedInt:
case OleDbType.UnsignedBigInt:
return("Long");
case OleDbType.Decimal:
case OleDbType.Numeric:
return("Decimal");
case OleDbType.Currency:
return("Currency");
case OleDbType.Single:
return("Single");
case OleDbType.Double:
return("Double");
case OleDbType.Date:
return("DateTime");
case OleDbType.Guid:
return("Text");
case OleDbType.Char:
case OleDbType.WChar:
case OleDbType.VarChar:
case OleDbType.VarWChar:
case OleDbType.LongVarWChar:
case OleDbType.LongVarChar:
if (column.Size > 0)
{
return($"Text Width {column.Size}");
}
else
{
return("Memo");
}
default:
throw new InvalidOperationException(
$"Nepodporovaný dátový typ pre MsAccessBulkInsert: OleDbType.{column.OleDbType}");
}
}
private static void CheckColumnSchema(
ColumnSchema column,
OleDbType oleDbType,
object defaultValue,
bool allowNull,
int?size,
byte?precision,
byte?scale)
{
MsAccessColumnSchema msAccessColumn = (MsAccessColumnSchema)column;
string columnName = msAccessColumn.Name;
msAccessColumn.OleDbType.Should().Be(oleDbType, $"{columnName} should have correct OleDbType.");
msAccessColumn.AllowNull.Should().Be(allowNull, $"{columnName} should allow NULL.");
if (defaultValue != null)
{
msAccessColumn.DefaultValue.Should().Be(defaultValue, $"{columnName} should have correct default value.");
}
if (size.HasValue)
{
msAccessColumn.Size.Should().Be(size, $"{columnName} should have correct size.");
}
if (precision.HasValue)
{
msAccessColumn.Precision.Should().Be(precision, $"{columnName} should have correct precision.");
}
if (scale.HasValue)
{
msAccessColumn.Scale.Should().Be(scale, $"{columnName} should have correct scale.");
}
}
// Returns type of the column for bulk insert based on column's data type.
private static BulkInsertColumnType GetColumnType(MsAccessColumnSchema column)
{
if ((column.OleDbType == OleDbType.VarChar) ||
(column.OleDbType == OleDbType.VarWChar) ||
(column.OleDbType == OleDbType.LongVarChar) ||
(column.OleDbType == OleDbType.LongVarWChar) ||
(column.OleDbType == OleDbType.Char) ||
(column.OleDbType == OleDbType.WChar))
{
return(BulkInsertColumnType.Text);
}
return(BulkInsertColumnType.Undefined);
}
private void InitBulkInsert(string dataFilePath, IDataReader data)
{
using (StreamWriter schemaFile = InitSchemaFile(dataFilePath))
{
var schemaLoader = new MsAccessSchemaLoader();
TableSchema tableSchema = schemaLoader.LoadTableSchema(_connection, DestinationTableName);
for (int i = 0; i < data.FieldCount; i++)
{
MsAccessColumnSchema column = tableSchema.Columns[data.GetName(i)] as MsAccessColumnSchema;
Columns.Add(column);
int colNumber = i + 1;
schemaFile.WriteLine($"Col{colNumber}=F{colNumber} {GetColumnDataType(column)}");
}
}
}
private void InitExplicitSchemaColumns(StreamWriter schemaFile)
{
var schemaLoader = new MsAccessSchemaLoader();
TableSchema tableSchema = schemaLoader.LoadTableSchema(_connection, DestinationTableName);
for (int columnNumber = 0; columnNumber < ColumnMappings.Count; columnNumber++)
{
MsAccessColumnSchema databaseColumn = null;
MsAccessBulkInsertColumn bulkInsertColumn = _columns[columnNumber];
BulkInsertColumnMapping mapping = bulkInsertColumn.Mapping;
if (!string.IsNullOrWhiteSpace(mapping.DestinationName))
{
if (tableSchema.Columns.Contains(mapping.DestinationName))
{
databaseColumn = (MsAccessColumnSchema)tableSchema.Columns[mapping.DestinationName];
}
else
{
ThrowExceptionInvalidDestinationColumnMapping(columnNumber, null, mapping.DestinationName);
}
}
else if (mapping.DestinationOrdinal >= 0)
{
if (mapping.DestinationOrdinal >= tableSchema.Columns.Count)
{
ThrowExceptionInvalidDestinationColumnMapping(columnNumber, mapping.DestinationOrdinal);
}
else
{
databaseColumn = (MsAccessColumnSchema)tableSchema.Columns[mapping.DestinationOrdinal];
}
}
else
{
ThrowExceptionInvalidDestinationColumnMapping(columnNumber);
}
bulkInsertColumn.DestinationColumnName = databaseColumn.Name;
bulkInsertColumn.ColumnType = GetBulkInsertColumnType(databaseColumn);
WriteSchemaColumnInfo(schemaFile, columnNumber + 1, databaseColumn);
}
}
private void InitImplicitSchemaColumns(StreamWriter schemaFile, IDataReader data)
{
var schemaLoader = new MsAccessSchemaLoader();
TableSchema tableSchema = schemaLoader.LoadTableSchema(_connection, DestinationTableName);
for (int columnNumber = 0; columnNumber < data.FieldCount; columnNumber++)
{
string columnName = data.GetName(columnNumber);
if (tableSchema.Columns.Contains(columnName))
{
MsAccessColumnSchema column = (MsAccessColumnSchema)tableSchema.Columns[columnName];
_columns.Add(new MsAccessBulkInsertColumn(columnName, column.Name, GetBulkInsertColumnType(column)));
WriteSchemaColumnInfo(schemaFile, columnNumber + 1, column);
}
else
{
throw new InvalidOperationException(
string.Format(Resources.BulkInsertColumnDoesNotExistInDestination, columnName));
}
}
}
/// <summary>
/// Adds column based on database column schema <paramref name="column"/>.
/// </summary>
/// <param name="column">Database column schema.</param>
public void Add(MsAccessColumnSchema column)
{
Add(new MsAccessBulkInsertColumn(column.Name, GetColumnType(column)));
}
private void WriteSchemaColumnInfo(StreamWriter schemaFile, int columnNumber, MsAccessColumnSchema column)
{
schemaFile.WriteLine($"Col{columnNumber}=F{columnNumber} {GetColumnDataType(column)}");
}
