public async Task Initialize_is_idempotent(bool async)
{
var reader = new FakeDbDataReader(new[] { "name" }, new[] { new[] { new object() } });
var columns = new ReaderColumn[] { new ReaderColumn <object>(true, null, (r, _) => r.GetValue(0)) };
var bufferedReader = new BufferedDataReader(reader);
Assert.False(reader.IsClosed);
if (async)
{
await bufferedReader.InitializeAsync(columns, CancellationToken.None);
}
else
{
bufferedReader.Initialize(columns);
}
Assert.True(reader.IsClosed);
if (async)
{
await bufferedReader.InitializeAsync(columns, CancellationToken.None);
}
else
{
bufferedReader.Initialize(columns);
}
}
private async Task Verify_method_result <T>(
Func <BufferedDataReader, T> method, bool async, T expectedResult,
params object[][] dataReaderContents)
{
var reader = new FakeDbDataReader(new[] { "name" }, dataReaderContents);
var columnType = typeof(T);
if (!columnType.IsValueType)
{
columnType = typeof(object);
}
var columns = new[]
{
ReaderColumn.Create(columnType, true, null, (Func <DbDataReader, int[], T>)((r, _) => r.GetFieldValue <T>(0)))
};
var bufferedReader = new BufferedDataReader(reader);
if (async)
{
await bufferedReader.InitializeAsync(columns, CancellationToken.None);
Assert.True(await bufferedReader.ReadAsync());
}
else
{
bufferedReader.Initialize(columns);
Assert.True(bufferedReader.Read());
}
Assert.Equal(expectedResult, method(bufferedReader));
}
public RelationalProjectionBindingRemovingExpressionVisitor(
SelectExpression selectExpression,
ParameterExpression dbDataReaderParameter,
ParameterExpression indexMapParameter,
bool buffer)
{
_selectExpression = selectExpression;
_dbDataReaderParameter = dbDataReaderParameter;
_indexMapParameter = indexMapParameter;
if (buffer)
{
ProjectionColumns = new ReaderColumn[selectExpression.Projection.Count];
}
}
public async Task Metadata_methods_return_expected_results(bool async)
{
var reader = new FakeDbDataReader(new[] { "columnName" }, new[] { new[] { new object() }, new[] { new object() } });
var columns = new ReaderColumn[] { new ReaderColumn <object>(true, null, (r, _) => r.GetValue(0)) };
var bufferedDataReader = new BufferedDataReader(reader);
if (async)
{
await bufferedDataReader.InitializeAsync(columns, CancellationToken.None);
}
else
{
bufferedDataReader.Initialize(columns);
}
Assert.Equal(1, bufferedDataReader.FieldCount);
Assert.Equal(0, bufferedDataReader.GetOrdinal("columnName"));
Assert.Equal(typeof(object).Name, bufferedDataReader.GetDataTypeName(0));
Assert.Equal(typeof(object), bufferedDataReader.GetFieldType(0));
Assert.Equal("columnName", bufferedDataReader.GetName(0));
Assert.Equal(2, bufferedDataReader.RecordsAffected);
}
public async Task Manipulation_methods_perform_expected_actions(bool async)
{
var reader = new FakeDbDataReader(
new[] { "id", "name" },
new List <IList <object[]> > {
new[] { new object[] { 1, "a" } }, new object[0][]
});
var columns = new ReaderColumn[]
{
new ReaderColumn <int>(false, null, (r, _) => r.GetInt32(0)),
new ReaderColumn <object>(true, null, (r, _) => r.GetValue(1))
};
var bufferedDataReader = new BufferedDataReader(reader);
Assert.False(bufferedDataReader.IsClosed);
if (async)
{
await bufferedDataReader.InitializeAsync(columns, CancellationToken.None);
}
else
{
bufferedDataReader.Initialize(columns);
}
Assert.False(bufferedDataReader.IsClosed);
Assert.True(bufferedDataReader.HasRows);
if (async)
{
Assert.True(await bufferedDataReader.ReadAsync());
Assert.False(await bufferedDataReader.ReadAsync());
}
else
{
Assert.True(bufferedDataReader.Read());
Assert.False(bufferedDataReader.Read());
}
Assert.True(bufferedDataReader.HasRows);
if (async)
{
Assert.True(await bufferedDataReader.NextResultAsync());
}
else
{
Assert.True(bufferedDataReader.NextResult());
}
Assert.False(bufferedDataReader.HasRows);
if (async)
{
Assert.False(await bufferedDataReader.ReadAsync());
Assert.False(await bufferedDataReader.NextResultAsync());
}
else
{
Assert.False(bufferedDataReader.Read());
Assert.False(bufferedDataReader.NextResult());
}
Assert.False(bufferedDataReader.IsClosed);
bufferedDataReader.Close();
Assert.True(bufferedDataReader.IsClosed);
}
private Expression CreateGetValueExpression(
ParameterExpression dbDataReader,
int index,
bool nullable,
RelationalTypeMapping typeMapping,
Type clrType)
{
var getMethod = typeMapping.GetDataReaderMethod();
Expression indexExpression = Expression.Constant(index);
if (_indexMapParameter != null)
{
indexExpression = Expression.ArrayIndex(_indexMapParameter, indexExpression);
}
Expression valueExpression
= Expression.Call(
getMethod.DeclaringType != typeof(DbDataReader)
? Expression.Convert(dbDataReader, getMethod.DeclaringType)
: (Expression)dbDataReader,
getMethod,
indexExpression);
if (ProjectionColumns != null)
{
var columnType = valueExpression.Type;
if (!columnType.IsValueType ||
!BufferedDataReader.IsSupportedValueType(columnType))
{
columnType = typeof(object);
valueExpression = Expression.Convert(valueExpression, typeof(object));
}
if (ProjectionColumns[index] == null)
{
ProjectionColumns[index] = ReaderColumn.Create(
columnType,
nullable,
_indexMapParameter != null ? ((ColumnExpression)_selectExpression.Projection[index].Expression).Name : null,
Expression.Lambda(
valueExpression,
dbDataReader,
_indexMapParameter ?? Expression.Parameter(typeof(int[]))).Compile());
}
if (getMethod.DeclaringType != typeof(DbDataReader))
{
valueExpression
= Expression.Call(
dbDataReader,
RelationalTypeMapping.GetDataReaderMethod(columnType),
indexExpression);
}
}
valueExpression = typeMapping.CustomizeDataReaderExpression(valueExpression);
var converter = typeMapping.Converter;
if (converter != null)
{
if (valueExpression.Type != converter.ProviderClrType)
{
valueExpression = Expression.Convert(valueExpression, converter.ProviderClrType);
}
valueExpression = ReplacingExpressionVisitor.Replace(
converter.ConvertFromProviderExpression.Parameters.Single(),
valueExpression,
converter.ConvertFromProviderExpression.Body);
}
if (valueExpression.Type != clrType)
{
valueExpression = Expression.Convert(valueExpression, clrType);
}
//var exceptionParameter
// = Expression.Parameter(typeof(Exception), name: "e");
//var property = materializationInfo.Property;
//if (detailedErrorsEnabled)
//{
// var catchBlock
// = Expression
// .Catch(
// exceptionParameter,
// Expression.Call(
// _throwReadValueExceptionMethod
// .MakeGenericMethod(valueExpression.Type),
// exceptionParameter,
// Expression.Call(
// dataReaderExpression,
// _getFieldValueMethod.MakeGenericMethod(typeof(object)),
// indexExpression),
// Expression.Constant(property, typeof(IPropertyBase))));
// valueExpression = Expression.TryCatch(valueExpression, catchBlock);
//}
//if (box && valueExpression.Type.GetTypeInfo().IsValueType)
//{
// valueExpression = Expression.Convert(valueExpression, typeof(object));
//}
if (nullable)
{
valueExpression
= Expression.Condition(
Expression.Call(dbDataReader, _isDbNullMethod, indexExpression),
Expression.Default(valueExpression.Type),
valueExpression);
}
return(valueExpression);
}
