[TestCase("5,000", typeof(int), "de-de", 5, 1, 0, 5)] //germans swap commas and dots
public void Test_OneString_IsType(string guessFor, Type expectedGuess, string culture, int expectedStringLength, int expectedBefore, int expectedAfter, object expectedParseValue)
{
var cultureInfo = new CultureInfo(culture);
var guesser = new Guesser()
{
Culture = cultureInfo
};
guesser.AdjustToCompensateForValue(guessFor);
Assert.AreEqual(expectedGuess, guesser.Guess.CSharpType, "Guessed Type did not match");
Assert.AreEqual(expectedStringLength, guesser.Guess.Width, "String length guessed didn't match");
Assert.AreEqual(expectedBefore, guesser.Guess.Size.NumbersBeforeDecimalPlace, "BeforeDecimalPlace didn't match");
Assert.AreEqual(expectedAfter, guesser.Guess.Size.NumbersAfterDecimalPlace, "AfterDecimalPlace didn't match");
TypeDeciderFactory factory = new TypeDeciderFactory(cultureInfo);
if (factory.IsSupported(guesser.Guess.CSharpType))
{
Assert.AreEqual(expectedParseValue, factory.Create(guesser.Guess.CSharpType).Parse(guessFor));
}
else
{
Assert.AreEqual(expectedParseValue, guessFor);
}
}
public static DbParameter GetParameter(string paramName, IQuerySyntaxHelper syntaxHelper, DiscoveredColumn discoveredColumn, object value)
{
var p = GetParameter(paramName, syntaxHelper.DatabaseType);
var tt = syntaxHelper.TypeTranslater;
p.DbType = tt.GetDbTypeForSQLDBType(discoveredColumn.DataType.SQLType);
var cSharpType = tt.GetCSharpTypeForSQLDBType(discoveredColumn.DataType.SQLType);
if (syntaxHelper.IsBasicallyNull(value))
{
p.Value = DBNull.Value;
}
else
if (value is string && typeDeciderFactory.IsSupported(cSharpType)) //if the input is a string and it's for a hard type e.g. TimeSpan
{
var o = typeDeciderFactory.Create(cSharpType).Parse((string)value);
//Apparently everyone in Microsoft hates TimeSpans - see test MicrosoftHatesDbTypeTime
if (o is TimeSpan && syntaxHelper.DatabaseType == DatabaseType.MicrosoftSQLServer)
{
o = Convert.ToDateTime(o.ToString());
}
p.Value = o;
}
else
{
p.Value = value;
}
return(p);
}
public DataTable StronglyTypeTable(DataTable workingTable, ExplicitTypingCollection explicitTypingCollection)
{
Dictionary <int, IDecideTypesForStrings> deciders = new Dictionary <int, IDecideTypesForStrings>();
var factory = new TypeDeciderFactory(_culture);
if (!string.IsNullOrWhiteSpace(_explicitDateTimeFormat))
{
factory.Settings.ExplicitDateFormats = new [] { _explicitDateTimeFormat }
}
;
DataTable dtCloned = workingTable.Clone();
bool typeChangeNeeded = false;
foreach (DataColumn col in workingTable.Columns)
{
//if we have already handled it
if (explicitTypingCollection != null && explicitTypingCollection.ExplicitTypesCSharp.ContainsKey(col.ColumnName))
{
continue;
}
//let's make a decision about the data type to use based on the contents
var computedType = new Guesser();
computedType.AdjustToCompensateForValues(col);
//Type based on the contents of the column
if (computedType.ShouldDowngradeColumnTypeToMatchCurrentEstimate(col))
{
dtCloned.Columns[col.ColumnName].DataType = computedType.Guess.CSharpType;
//if we have a type decider to parse this data type
if (factory.IsSupported(computedType.Guess.CSharpType))
{
deciders.Add(col.Ordinal, factory.Create(computedType.Guess.CSharpType)); //record column index and parser
}
typeChangeNeeded = true;
}
}
if (typeChangeNeeded)
{
foreach (DataRow row in workingTable.Rows)
{
dtCloned.Rows.Add(row.ItemArray.Select((v, idx) =>
deciders.ContainsKey(idx) && v is string s?
deciders[idx].Parse(s) :
v).ToArray());
}
return(dtCloned);
}
return(workingTable);
}
private void ThrowIfNotSupported(Type currentEstimate)
{
if (currentEstimate == typeof(string))
{
return;
}
if (!_typeDeciders.IsSupported(CurrentEstimate))
{
throw new NotSupportedException("We do not have a type decider for type:" + CurrentEstimate);
}
}
protected override void UpdateTag(DicomTag dicomTag, DicomDataset dataset, string cellValue)
{
var cSharpType = DicomTypeTranslater.GetNaturalTypeForVr(dicomTag.DictionaryEntry.ValueRepresentations,
dicomTag.DictionaryEntry.ValueMultiplicity)?.CSharpType;
object writeValue = cellValue;
//if it's a supported type e.g. DateTime parse it
if (cSharpType != null && _factory.IsSupported(cSharpType))
{
if (_factory.Dictionary[cSharpType].IsAcceptableAsType(cellValue, Ignore.Me))
{
writeValue = _factory.Dictionary[cSharpType].Parse(cellValue);
}
}
dataset.Remove(dicomTag);
DicomTypeTranslaterWriter.SetDicomTag(dataset, dicomTag, writeValue);
}
public DbParameter GetParameter(DbParameter p, DiscoveredColumn discoveredColumn, object value, CultureInfo culture)
{
try
{
var tt = TypeTranslater;
p.DbType = tt.GetDbTypeForSQLDBType(discoveredColumn.DataType.SQLType);
var cSharpType = tt.GetCSharpTypeForSQLDBType(discoveredColumn.DataType.SQLType);
if (IsBasicallyNull(value))
{
p.Value = DBNull.Value;
}
else
if (value is string strVal && typeDeciderFactory.IsSupported(cSharpType)) //if the input is a string and it's for a hard type e.g. TimeSpan
{
var decider = typeDeciderFactory.Create(cSharpType);
if (decider is DateTimeTypeDecider dt)
{
if (culture != null)
{
dt.Culture = culture;
}
}
var o = decider.Parse(strVal);
//Not all DBMS support DBParameter.Value = new TimeSpan(...);
if (o is TimeSpan)
{
o = FormatTimespanForDbParameter((TimeSpan)o);
}
p.Value = o;
}
else
{
p.Value = value;
}
}