public async Task <T> ExecuteFunctionAsync <T>(string function, OracleUdtInfo udtInfo, params IParam[] parameters)
{
MetadataBase returnMetadata = null;
OracleParameter retOra = null;
try
{
using (var connection = _DbFactory.CreateConnection())
{
var builder = _BuilderFactory.CreateBuilder(connection);
await ExecuteAsync(builder, connection, function, parameters,
(info) => Task.FromResult(FunctionBeforeQuery <T>(builder, info, udtInfo, out returnMetadata,
out retOra)),
(info) =>
{
if (returnMetadata is MetadataOracleObject <T> metadata)
{
return(Task.FromResult(
ReturnValueAdditionalInformation(info, udtInfo, metadata, out retOra)));
}
else if (returnMetadata is MetadataOracleBoolean metadataBoolean)
{
return(Task.FromResult(
ReturnValueAdditionalInformationBoolean <T>(info, metadataBoolean, out retOra)));
}
else
{
return(Task.FromResult <AdditionalInformation>(null));
}
}).ConfigureAwait(false);
return(GetReturnParameterOtuputValue <T>(retOra, returnMetadata));
}
}
finally { _DbFactory.Dispose(); }
}
internal void SetOutputValue_Works(Mock <MetadataBuilder> builder, TestClass model, ParameterDirection direction, OracleUdtInfo info, Mock <MetadataOracleObject <TestClass> > metadataObject)
{
var refCursor = FormatterServices.GetUninitializedObject(
typeof(OracleRefCursor));
builder.Setup(b => b.GetOrRegisterMetadataOracleObject <TestClass>(info))
.Returns(metadataObject.Object);
metadataObject.Setup(b => b.GetValueFromRefCursor(typeof(TestClass), It.IsAny <OracleRefCursorWrapper>()))
.Returns(model)
.Verifiable();
var param = new ParamObject <TestClass>(model, direction, info);
param.LoadObjectMetadata(builder.Object);
param.SetOutputValue(refCursor);
metadataObject.Verify();
Assert.Equal(model, param.Value);
}
internal void GetOtherUdtInfo_GetsEntryInCache(Mock <IMemoryCache> memoryCache, string name, OracleUdtInfo info, UdtPropertyNetPropertyMap[] props, bool fuzzyNameMatch)
{
var cache = new ServForOracleCache(memoryCache.Object);
var expectedValue = (info, props, fuzzyNameMatch);
object validParameter = expectedValue;
memoryCache.Setup(m => m.TryGetValue($"udt-{name}", out validParameter))
.Returns(true);
var actualValue = cache.GetOtherUdtInfo(name);
Assert.Equal(expectedValue, actualValue);
}
internal void PresetGetValueOrDefault_IsObject_Default(Mock <IMemoryCache> memoryMock, OracleUdtInfo info, UdtPropertyNetPropertyMap[] props, bool fuzzyNameMatch)
{
var expectedValue = (info, props, fuzzyNameMatch);
object validParameter = expectedValue;
var type = typeof(TestClass);
memoryMock.Setup(m => m.TryGetValue($"udt-{type.FullName}", out validParameter)).Returns(true);
var cache = new ServForOracleCache(memoryMock.Object);
var actualValue = cache.PresetGetValueOrDefault(type);
Assert.Equal(expectedValue, actualValue);
}
internal void GetUdtInfoFromAttributeOrPresetCache_FromCache_IsCollection(Mock <IMemoryCache> memoryMock, Type type, OracleUdtInfo info)
{
var colType = type.CreateListType();
(OracleUdtInfo Info, UdtPropertyNetPropertyMap[], bool)expectedValue = (info, default, default);
internal void PrepareOutputParameter_Works(Mock <MetadataBuilder> builder, TestClass model, ParameterDirection direction, OracleUdtInfo info, Mock <MetadataOracleObject <TestClass> > metadataObject, int startNumber, string query, OracleParameter oracleParameter)
{
builder.Setup(b => b.GetOrRegisterMetadataOracleObject <TestClass>(info))
.Returns(metadataObject.Object);
metadataObject.Setup(m => m.GetRefCursorQuery(startNumber, null))
.Returns(query)
.Verifiable();
metadataObject.Setup(b => b.GetOracleParameterForRefCursor(startNumber))
.Returns(oracleParameter)
.Verifiable();
var param = new ParamObject <TestClass>(model, direction, info);
param.LoadObjectMetadata(builder.Object);
var actual = param.PrepareOutputParameter(startNumber);
metadataObject.Verify();
Assert.NotNull(actual);
Assert.Equal(param, actual.Parameter);
Assert.Equal(query, actual.OutputString);
Assert.Equal(oracleParameter, actual.OracleParameter);
}
public void AbstractBase_PropertiesSet(TestClass model, ParameterDirection direction, OracleUdtInfo info)
{
var param = new ParamObject <TestClass>(model, direction, info);
ParamObject paramObjBase = param;
Assert.NotNull(paramObjBase);
Assert.Equal(info, paramObjBase.UDTInfo);
}
private MetadataOracleTypeDefinition GetOrCreateOracleTypeMetadata(DbConnection connection, OracleUdtInfo udtInfo)
{
var exists = Cache.GetTypeDefinition(udtInfo.FullObjectName);
if (exists != null)
{
return(exists);
}
if (OracleConnection.State != ConnectionState.Open)
{
OracleConnection.Open();
}
var cmd = CreateCommand(connection, udtInfo);
var properties = ExecuteReaderAndLoadTypeDefinition(cmd);
return(CreateAndSaveMetadata(udtInfo, properties));
}
public virtual MetadataOracleObject <T> GetOrRegisterMetadataOracleObject <T>(OracleUdtInfo udtInfo)
{
GetTypeAndCachedMetadata <T>(out var type, out var metadata);
if (metadata == null)
{
if (udtInfo != null)
{
return(Register(type, OracleConnection, udtInfo) as MetadataOracleObject <T>);
}
else
{
return(Register(type, OracleConnection) as MetadataOracleObject <T>);
}
}
else
{
return(metadata as MetadataOracleObject <T>);
}
}
public void Constructor_FourParameter_Works(string schema, string objectName, string colSchema, string colName)
{
var udt = new OracleUdtInfo(schema, objectName, colSchema, colName);
AssertUDTInfo(udt, schema, objectName, colSchema, colName);
}
private async Task <MetadataOracleTypeDefinition> GetOrCreateOracleTypeMetadataAsync(DbConnection connection, OracleUdtInfo udtInfo)
{
var exists = Cache.GetTypeDefinition(udtInfo.FullObjectName);
if (exists != null)
{
return(exists);
}
if (connection.State != ConnectionState.Open)
{
await connection.OpenAsync().ConfigureAwait(false);
}
var cmd = CreateCommand(connection, udtInfo);
var properties = await ExecuteReaderAndLoadTypeDefinitionAsync(cmd).ConfigureAwait(false);
return(CreateAndSaveMetadata(udtInfo, properties));
}
public void Constructor_OneParameter_Collection_Works(string schema, string objectName, string colName)
{
var udt = new OracleUdtInfo($"{schema}.{objectName}|{schema}.{colName}");
AssertUDTInfo(udt, $"{schema}.{objectName}|{schema}.{colName}");
}
private string FunctionBeforeQuery <T>(MetadataBuilder builder, ExecutionInformation info, OracleUdtInfo udt, out MetadataBase metadata, out OracleParameter parameter)
{
if (typeof(T).IsBoolean())
{
metadata = _MetadataFactory.CreateBoolean();
parameter = null;
return("ret := ");
}
else if (typeof(T).IsClrType())
{
metadata = new MetadataBase();
parameter = FunctionReturnOracleParameter <T>(info, metadata);
return($"{parameter.ParameterName} := ");
}
else
{
metadata = builder.GetOrRegisterMetadataOracleObject <T>(udt);
parameter = null;
return("ret := ");
}
}
private AdditionalInformation ReturnValueAdditionalInformation <T>(ExecutionInformation info, OracleUdtInfo udt,
MetadataOracleObject <T> metadata, out OracleParameter parameter)
{
var returnType = typeof(T);
parameter = FunctionReturnOracleParameter <T>(info, metadata);
var name = "ret";
var returnInfo = new AdditionalInformation
{
Declare = metadata.GetDeclareLine(returnType, name, udt ?? metadata.OracleTypeNetMetadata.UDTInfo),
Output = metadata.GetRefCursorQuery(info.ParameterCounter, name)
};
return(returnInfo);
}
internal void GetOracleParameters_Works(Mock <MetadataBuilder> builder, TestClass model, ParameterDirection direction, OracleUdtInfo info, Mock <MetadataOracleObject <TestClass> > metadataObject, OracleParameter[] parameters, int startNumber)
{
builder.Setup(b => b.GetOrRegisterMetadataOracleObject <TestClass>(info))
.Returns(metadataObject.Object);
metadataObject.Setup(b => b.GetOracleParameters(model, startNumber))
.Returns(parameters)
.Verifiable();
var param = new ParamObject <TestClass>(model, direction, info);
param.LoadObjectMetadata(builder.Object);
var actual = param.GetOracleParameters(startNumber);
metadataObject.Verify();
Assert.Equal(parameters, actual);
}
internal void GetDeclareLine_Object_Simple(MetadataOracleNetTypeDefinition typedef, MetadataOracleCommon common, string parameterName, OracleUdtInfo udtInfo)
{
var type = typeof(SimpleTestClass);
var metadata = new MetadataOracleObject <SimpleTestClass>(typedef, common);
var declareLine = metadata.GetDeclareLine(type, parameterName, udtInfo);
Assert.Equal($"{parameterName} {udtInfo.FullObjectName};" + Environment.NewLine, declareLine);
}
internal void BuildQueryConstructorString_Works(Mock <MetadataBuilder> builder, TestClass model, ParameterDirection direction, OracleUdtInfo info, Mock <MetadataOracleObject <TestClass> > metadataObject, int lastNumber, string constructor, string name, int startNumber)
{
builder.Setup(b => b.GetOrRegisterMetadataOracleObject <TestClass>(info))
.Returns(metadataObject.Object);
metadataObject.Setup(b => b.BuildQueryConstructorString(model, name, startNumber))
.Returns((constructor, lastNumber))
.Verifiable();
var param = new ParamObject <TestClass>(model, direction, info);
param.LoadObjectMetadata(builder.Object);
param.SetParameterName(name);
var actual = param.BuildQueryConstructorString(startNumber);
metadataObject.Verify();
Assert.Equal((constructor, lastNumber), actual);
}
internal void GetDeclareLine_Object_WithMetadata(MetadataOracleNetTypeDefinition typedef, MetadataOracleNetTypeDefinition subTypeDef, MetadataOracleCommon common, string parameterName, OracleUdtInfo udtInfo)
{
var type = typeof(ComplexTestClass);
var prop = typedef.Properties.First();
prop.PropertyMetadata = subTypeDef;
prop.NETProperty = type.GetProperty(nameof(ComplexTestClass.ObjectProp));
var metadata = new MetadataOracleObject <ComplexTestClass>(typedef, common);
var declareLine = metadata.GetDeclareLine(type, parameterName, udtInfo);
var expected = $"{parameterName}_0 {subTypeDef.UDTInfo.FullObjectName};" + Environment.NewLine
+ $"{parameterName} {udtInfo.FullObjectName};" + Environment.NewLine;
Assert.Equal(expected, declareLine);
}
public void Constructor_ThreeParameters(TestClass model, ParameterDirection direction, OracleUdtInfo info)
{
var param = new ParamObject <TestClass>(model, direction, info);
Assert.Equal(model, param.Value);
Assert.Equal(direction, param.Direction);
}
internal void GetDeclareLine_Collection(MetadataOracleNetTypeDefinition typedef, MetadataOracleCommon common, string parameterName, OracleUdtInfo udtInfo)
{
var type = typeof(ComplexTestClass[]);
var metadata = new MetadataOracleObject <ComplexTestClass[]>(typedef, common);
var declareLine = metadata.GetDeclareLine(type, parameterName, udtInfo);
var expected = $"{parameterName} {udtInfo.FullCollectionName} := {udtInfo.FullCollectionName}();" + Environment.NewLine;
Assert.Equal(expected, declareLine);
}
internal async Task LoadObjectMetadataAsync_Works(Mock <MetadataBuilder> builder, TestClass model, ParameterDirection direction, OracleUdtInfo info, MetadataOracleObject <TestClass> metadataObject)
{
builder.Setup(b => b.GetOrRegisterMetadataOracleObjectAsync <TestClass>(info))
.ReturnsAsync(metadataObject)
.Verifiable();
var param = new ParamObject <TestClass>(model, direction, info);
await param.LoadObjectMetadataAsync(builder.Object);
builder.Verify();
Assert.True(param.MetadataLoaded);
}
internal async Task GetMetadataOracleObjectAsync_NotInCache_CallsDb_PlainType(OracleUdtInfo info, int order, string name,
(OracleUdtInfo Info, UdtPropertyNetPropertyMap[] Props, bool FuzzyMatch) preset)
internal void AddOracleUDTPresets_CreatesEntryInCache(Mock <IMemoryCache> memoryCache, Mock <ICacheEntry> entry, Mock <Type> type, string fullName, OracleUdtInfo info, UdtPropertyNetPropertyMap[] props, bool fuzzyNameMatch)
{
var cache = new ServForOracleCache(memoryCache.Object);
memoryCache.Setup(m => m.CreateEntry($"udt-{fullName}")).Returns(entry.Object);
type.Setup(t => t.FullName).Returns(fullName);
entry.SetupSet((e) => e.Value = (info, props, fuzzyNameMatch)).Verifiable();
cache.AddOracleUDTPresets(type.Object, info, props, fuzzyNameMatch);
entry.Verify();
}
internal virtual void AddOracleUDTPresets(Type type, OracleUdtInfo info, UdtPropertyNetPropertyMap[] props, bool fuzzyNameMatch = true)
{
SaveUdtInfo(type.FullName, info, props, fuzzyNameMatch);
}
internal void CreateSaveUdtInfo_CreatesEntryInCache(Mock <IMemoryCache> memoryCache, Mock <ICacheEntry> entry, string name, OracleUdtInfo info, UdtPropertyNetPropertyMap[] props, bool fuzzyNameMatch)
{
var cache = new ServForOracleCache(memoryCache.Object);
memoryCache.Setup(m => m.CreateEntry($"udt-{name}")).Returns(entry.Object);
entry.SetupSet((e) => e.Value = (info, props, fuzzyNameMatch)).Verifiable();
cache.SaveUdtInfo(name, info, props, fuzzyNameMatch);
Console.WriteLine("entry: " + entry.Invocations);
entry.Verify();
}
internal void GetDeclareLine_Works(Mock <MetadataBuilder> builder, TestClass model, ParameterDirection direction, OracleUdtInfo info, Mock <MetadataOracleObject <TestClass> > metadataObject, string name, string line)
{
builder.Setup(b => b.GetOrRegisterMetadataOracleObject <TestClass>(info))
.Returns(metadataObject.Object);
metadataObject.Setup(b => b.GetDeclareLine(typeof(TestClass), name, metadataObject.Object.OracleTypeNetMetadata.UDTInfo))
.Returns(line)
.Verifiable();
var param = new ParamObject <TestClass>(model, direction, info);
param.LoadObjectMetadata(builder.Object);
param.SetParameterName(name);
var result = param.GetDeclareLine();
metadataObject.Verify();
Assert.Equal(line, result);
}
internal void PresetGetValueOrDefault_IsCollection(Mock <Type> typeMock, Mock <Type> type, Mock <IMemoryCache> memoryMock, OracleUdtInfo info, UdtPropertyNetPropertyMap[] props, bool fuzzyNameMatch, string fullName)
{
var expectedValue = (info, props, fuzzyNameMatch);
object validParameter = expectedValue;
typeMock.SetReturnsDefault(true);
typeMock.Setup(t => t.GetGenericArguments()).Returns(new[] { type.Object });
type.Setup(t => t.FullName).Returns(fullName);
memoryMock.Setup(m => m.TryGetValue($"udt-{fullName}", out validParameter)).Returns(true);
var cache = new ServForOracleCache(memoryMock.Object);
var actualValue = cache.PresetGetValueOrDefault(typeMock.Object);
Assert.Equal(expectedValue, actualValue);
}
public virtual string GetDeclareLine(Type type, string parameterName, OracleUdtInfo udtInfo)
{
return(GetDeclareLine(type, parameterName, udtInfo, OracleTypeNetMetadata));
}
