//private static readonly LoggerFactory MyLoggerFactory = new LoggerFactory(new[] {new ConsoleLoggerProvider((category, level)
// => true, true) });
public static EdmModel BuildEdmModel(Db.OeDataAdapter dataAdapter, ModelBuilder.OeEdmModelMetadataProvider metadataProvider)
{
var order2DataAdapter = new Order2DataAdapter(false, true, "test2");
var refModel = new ModelBuilder.OeEdmModelBuilder(dataAdapter, metadataProvider).BuildEdmModel();
return(order2DataAdapter.BuildEdmModel(refModel));
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (node.Arguments.Count > 0 && node.Arguments[0] is MemberExpression navigationPropertyExpression)
{
Type?innerItemType = OeExpressionHelper.GetCollectionItemTypeOrNull(navigationPropertyExpression.Type);
if (innerItemType != null)
{
IEdmModel edmModel = _edmModel.GetEdmModel(innerItemType) ?? throw new InvalidOperationException("Cannot find IEdmModel for type " + innerItemType.FullName);
Db.OeDataAdapter dataAdapter = edmModel.GetDataAdapter(edmModel.EntityContainer);
Db.OeEntitySetAdapter?innerEntitySetAdapter = dataAdapter.EntitySetAdapters.Find(innerItemType);
if (innerEntitySetAdapter == null)
{
throw new InvalidOperationException("OeEntitySetAdapter not found for type " + innerItemType.Name);
}
IEdmEntitySet entitySet = edmModel.FindDeclaredEntitySet(innerEntitySetAdapter.EntitySetName);
ConstantExpression innerSource = OeEnumerableStub.CreateEnumerableStubExpression(innerEntitySetAdapter.EntityType, entitySet);
IEdmNavigationProperty navigationProperty = GetEdmNavigationProperty(dataAdapter, navigationPropertyExpression);
Expression[] arguments = node.Arguments.ToArray();
arguments[0] = GetJoin(innerSource, navigationProperty);
return(node.Update(node.Object !, arguments));
}
}
return(base.VisitMethodCall(node));
}
public async Task BoundFunctionSingle()
{
int orderId;
List <int> expectedResult;
using (var dbContext = Fixture.CreateContext())
{
orderId = dbContext.Orders.Single(i => i.Name == "Order 1").Id;
expectedResult = dbContext.OrderItems.Where(i => i.OrderId == orderId).Select(i => i.Id).ToList();
}
Db.OeDataAdapter dataAdapter = Fixture.EdmModel.GetDataAdapter(Fixture.EdmModel.EntityContainer);
String request = $"Orders({orderId})/{dataAdapter.DataContextType.Namespace}.BoundFunctionSingle(customerNames=['Natasha','Ivan','Sasha'])";
ODataUri odataUri = Fixture.ParseUri(request);
IEdmModel edmModel = Fixture.EdmModel.GetEdmModel(odataUri.Path);
var parser = new OeParser(odataUri.ServiceRoot, edmModel);
var uri = new Uri(odataUri.ServiceRoot, request);
var response = new MemoryStream();
await parser.ExecuteQueryAsync(odataUri, OeRequestHeaders.JsonDefault, response, CancellationToken.None).ConfigureAwait(false);
response.Position = 0;
List <Object> fromOe = new ResponseReader(edmModel).Read(response).Cast <Object>().ToList();
Assert.Equal(expectedResult, fromOe.Select(i => (int)((dynamic)i).Id).OrderBy(id => id));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvcCore();
_dataAdapter = new OrderOeDataAdapter(true, true, null);
services.AddSingleton(typeof(Db.OeDataAdapter), _dataAdapter);
}
private MethodCallExpression?GetJoin(Expression outer, MemberExpression navigationProperty)
{
Type outerType = outer.Type;
Type innerType = navigationProperty.Type;
IEdmModel?edmModel = _edmModel.GetEdmModel(outerType);
if (edmModel == null)
{
return(null);
}
Db.OeDataAdapter dataAdapter = edmModel.GetDataAdapter(edmModel.EntityContainer);
Db.OeEntitySetAdapter?outerEntitySetAdapter = dataAdapter.EntitySetAdapters.Find(outerType);
if (outerEntitySetAdapter == null)
{
throw new InvalidOperationException("OeEntitySetAdapter not found for type " + outerType.Name);
}
IEdmEntitySet outerEntitySet = OeEdmClrHelper.GetEntitySet(_edmModel, outerEntitySetAdapter.EntitySetName);
IEdmNavigationProperty edmNavigationProperty = outerEntitySet.EntityType().NavigationProperties().Single(p => p.Name == navigationProperty.Member.Name);
Db.OeEntitySetAdapter?innerEntitySetAdapter = dataAdapter.EntitySetAdapters.Find(innerType);
if (innerEntitySetAdapter == null)
{
throw new InvalidOperationException("OeEntitySetAdapter not found for type " + innerType.Name);
}
IEdmEntitySet entitySet = edmModel.FindDeclaredEntitySet(innerEntitySetAdapter.EntitySetName);
ConstantExpression innerSource = OeEnumerableStub.CreateEnumerableStubExpression(innerType, entitySet);
return(GetJoin(outer, innerSource, edmNavigationProperty));
}
private IAsyncEnumerable <Object> GetAsyncEnumerator(IQueryable source = null)
{
_httpContext.Response.RegisterForDispose(this);
ODataUri odataUri = OeParser.ParseUri(_edmModel, UriHelper.GetBaseUri(_httpContext.Request), UriHelper.GetUri(_httpContext.Request));
IEdmModel refModel = _edmModel.GetEdmModel(odataUri.Path);
_dataAdapter = refModel.GetDataAdapter(refModel.EntityContainer);
if (_dataContext == null)
{
_dataContext = _dataAdapter.CreateDataContext();
}
var requestHeaders = (HttpRequestHeaders)_httpContext.Request.Headers;
OeRequestHeaders headers = GetRequestHeaders(requestHeaders, _httpContext.Response);
if (odataUri.Path.LastSegment is OperationImportSegment)
{
return(ExecutePost(refModel, odataUri, headers, _httpContext.Request.Body));
}
else
{
return(ExecuteGet(refModel, odataUri, headers, source));
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvcCore();
_dataAdapter = new OrderOeDataAdapter(Test.Model.OrderContext.GenerateDatabaseName());
services.AddSingleton(typeof(Db.OeDataAdapter), _dataAdapter);
}
public IEnumerable <Dictionary <String, Object> > Resolve(ResolveFieldContext context)
{
var results = new List <Dictionary <String, Object> >();
var translator = new OeGraphqlAstToODataUri(_edmModel, context);
ODataUri odataUri = translator.Translate(context.Document.OriginalQuery);
IEdmModel refModel = _edmModel.GetEdmModel(odataUri.Path);
Db.OeDataAdapter dataAdapter = refModel.GetDataAdapter(refModel.EntityContainer);
context.UserContext = dataAdapter.CreateDataContext();
try
{
var queryContext = new Parsers.OeQueryContext(refModel, odataUri);
IAsyncEnumerator <Object> asyncEnumerator = dataAdapter.Execute(context.UserContext, queryContext).GetEnumerator();
using (var entityAsyncEnumerator = new OeGraphqlAsyncEnumerator(asyncEnumerator, queryContext.EntryFactory))
{
while (entityAsyncEnumerator.MoveNext().GetAwaiter().GetResult())
{
results.Add(entityAsyncEnumerator.Current);
}
}
}
finally
{
if (context.UserContext != null)
{
dataAdapter.CloseDataContext(context.UserContext);
}
}
return(results);
}
public async Task ExecuteAsync(ODataUri odataUri, OeRequestHeaders headers, Stream stream, CancellationToken cancellationToken)
{
OeQueryContext queryContext = CreateQueryContext(odataUri, headers.MaxPageSize, headers.NavigationNextLink, headers.MetadataLevel);
Db.OeDataAdapter dataAdapter = _edmModel.GetDataAdapter(queryContext.EdmModel.EntityContainer);
Object dataContext = null;
try
{
dataContext = dataAdapter.CreateDataContext();
if (queryContext.IsCountSegment)
{
headers.ResponseContentType = OeRequestHeaders.TextDefault.ContentType;
int count = dataAdapter.ExecuteScalar <int>(dataContext, queryContext);
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(count.ToString(CultureInfo.InvariantCulture));
stream.Write(buffer, 0, buffer.Length);
}
else
{
using (Db.OeAsyncEnumerator asyncEnumerator = dataAdapter.ExecuteEnumerator(dataContext, queryContext, cancellationToken))
await Writers.OeGetWriter.SerializeAsync(queryContext, asyncEnumerator, headers.ContentType, stream).ConfigureAwait(false);
}
}
finally
{
if (dataContext != null)
{
dataAdapter.CloseDataContext(dataContext);
}
}
}
public override Object CreateDataContext()
{
var dataContext = Infrastructure.FastActivator.CreateInstance <T>();
dataContext.DataContext = new OeLinq2DbDataContext(GetEdmModel(_edmModel), _entitySetAdapters);
return(dataContext);
IEdmModel GetEdmModel(IEdmModel edmModel)
{
Db.OeDataAdapter dataAdapter = edmModel.GetAnnotationValue <Db.OeDataAdapter>(edmModel.EntityContainer);
if (dataAdapter.DataContextType == typeof(T))
{
return(edmModel);
}
foreach (IEdmModel refModel in edmModel.ReferencedModels)
{
if (refModel.EntityContainer != null && refModel is EdmModel)
{
return(GetEdmModel(edmModel));
}
}
throw new InvalidOperationException("EdmModel not found for data context type " + typeof(T).FullName);
}
}
public async Task BoundFunctionSingle()
{
List <int> expectedResult;
using (var dbContext = Fixture.CreateContext())
expectedResult = dbContext.OrderItems.Where(i =>
(i.Order.Name == "Order 1" || i.Order.Name == "Order 2") && i.Order.Customer.Country == "RU" && i.Order.Customer.Id == 1)
.Select(i => i.Id).ToList();
Db.OeDataAdapter dataAdapter = Fixture.OeEdmModel.GetDataAdapter(Fixture.OeEdmModel.EntityContainer);
String request = $"Customers('RU',1)/{dataAdapter.DataContextType.Namespace}.BoundFunctionSingle(orderNames=['Order 1','Order 2'])?$expand=Customer,Items&$select=Name";
ODataUri odataUri = Fixture.ParseUri(request);
IEdmModel edmModel = Fixture.OeEdmModel.GetEdmModel(odataUri.Path);
var parser = new OeParser(odataUri.ServiceRoot, edmModel);
var response = new MemoryStream();
await parser.ExecuteQueryAsync(odataUri, OeRequestHeaders.JsonDefault, response, CancellationToken.None).ConfigureAwait(false);
response.Position = 0;
List <Object> fromOe = new ResponseReader(edmModel).Read(response).Cast <Object>().ToList();
Assert.Equal(expectedResult, fromOe.SelectMany(c => (IEnumerable <dynamic>)((dynamic)c).Items).Select(i => (int)i.Id).OrderBy(id => id));
}
public static EdmModel BuildEdmModel(Db.OeDataAdapter dataAdapter, ModelBuilder.OeEdmModelMetadataProvider metadataProvider)
{
bool allowCache = TestHelper.GetQueryCache(dataAdapter).AllowCache;
var order2DataAdapter = new Order2DataAdapter(allowCache, true, "test2");
var refModel = new ModelBuilder.OeEdmModelBuilder(dataAdapter, metadataProvider).BuildEdmModel();
return(order2DataAdapter.BuildEdmModel(refModel));
}
public ResponseReader(IEdmModel edmModel, Db.OeDataAdapter dataAdapter)
{
EdmModel = edmModel;
_dataAdapter = dataAdapter;
NavigationProperties = new Dictionary <IEnumerable, ODataResourceSetBase>();
NavigationPropertyEntities = new Dictionary <Object, Dictionary <PropertyInfo, ODataResourceSetBase> >();
}
public static EdmModel BuildEdmModelFromEf6Model(this Db.OeDataAdapter dataAdapter)
{
using (var context = (DbContext)dataAdapter.CreateDataContext())
{
var modelBuilder = new OeEdmModelBuilder(dataAdapter, new OeEf6EdmModelMetadataProvider(context));
return(modelBuilder.BuildEdmModel());
}
}
protected DbFixture(Db.OeDataAdapter dataAdapter1, Db.OeDataAdapter dataAdapter2)
{
EdmModel refModel = dataAdapter2.BuildEdmModelFromEfCoreModel();
EdmModel = dataAdapter1.BuildEdmModelFromEfCoreModel(refModel);
Schema = new OeSchemaBuilder(EdmModel).Build();
_graphqlParser = new OeGraphqlParser(EdmModel);
}
public OeEdmModelBuilder(Db.OeDataAdapter dataAdapter, OeEdmModelMetadataProvider metadataProvider)
{
_dataAdapter = dataAdapter;
_metadataProvider = metadataProvider;
_complexTypes = new Dictionary <Type, EdmComplexType>();
_enumTypes = new Dictionary <Type, EdmEnumType>();
_operationConfigurations = new List <OeOperationConfiguration>();
}
private static async Task InitializeAsync(Db.OeDataAdapter dataAdapter, IEdmModel edmModel)
{
var parser = new OeParser(new Uri("http://dummy/"), dataAdapter, edmModel);
String fileName = Directory.EnumerateFiles(".", "Add.batch", SearchOption.AllDirectories).First();
byte[] bytes = File.ReadAllBytes(fileName);
var responseStream = new MemoryStream();
await parser.ExecuteBatchAsync(new MemoryStream(bytes), responseStream, CancellationToken.None).ConfigureAwait(false);
}
public static EdmModel BuildEdmModelFromEf6Model(this Db.OeDataAdapter dataAdapter)
{
using (var context = (DbContext)dataAdapter.CreateDataContext())
{
var metadataProvider = new OeEf6EdmModelMetadataProvider(context);
var modelBuilder = new OeEdmModelBuilder(metadataProvider);
modelBuilder.AddEntitySetRange(dataAdapter.EntitySetMetaAdapters.GetEntitySetNamesEntityTypes());
OeDataAdapterExtension.BuildOperations(dataAdapter, modelBuilder);
return(modelBuilder.BuildEdmModel());
}
}
private IEdmNavigationProperty GetEdmNavigationProperty(Db.OeDataAdapter dataAdapter, MemberExpression navigationProperty)
{
Type outerItemType = OeExpressionHelper.GetCollectionItemType(_outerSource.Type);
Db.OeEntitySetAdapter?outerEntitySetAdapter = dataAdapter.EntitySetAdapters.Find(outerItemType);
if (outerEntitySetAdapter == null)
{
throw new InvalidOperationException("OeEntitySetAdapter not found for type " + outerItemType.Name);
}
IEdmEntitySet outerEntitySet = OeEdmClrHelper.GetEntitySet(_edmModel, outerEntitySetAdapter.EntitySetName);
return(outerEntitySet.EntityType().NavigationProperties().Single(p => p.Name == navigationProperty.Member.Name));
}
public static IList ExecuteDb <T, TResult>(Db.OeDataAdapter dataAdapter, DbContext dataContext,
Expression <Func <IQueryable <T>, IQueryable <TResult> > > expression, out IReadOnlyList <EfInclude> includes)
{
var visitor = new QueryVisitor <T>(dataAdapter.EntitySetAdapters, dataContext);
Expression call = visitor.Visit(expression.Body);
var metadataProvider = new OdataToEntity.EfCore.OeEfCoreEdmModelMetadataProvider(dataContext.Model);
var includeVisitor = new IncludeVisitor(metadataProvider, dataAdapter.IsDatabaseNullHighestValue);
call = includeVisitor.Visit(call);
includes = includeVisitor.Includes;
return(visitor.Query.Provider.CreateQuery <TResult>(call).ToList());
}
public static bool GetUseRelationalNulls(Db.OeDataAdapter dataAdapter)
{
var serviceProvider = (IInfrastructure <IServiceProvider>)dataAdapter.CreateDataContext();
try
{
RelationalOptionsExtension options = serviceProvider.GetService <IDbContextOptions>().Extensions.OfType <RelationalOptionsExtension>().Single();
return(options.UseRelationalNulls);
}
finally
{
dataAdapter.CloseDataContext(serviceProvider);
}
}
public TDataContext GetDbContext <TDataContext>() where TDataContext : class
{
if (_dataContext == null)
{
Db.OeDataAdapter dataAdapter = _edmModel.GetDataAdapter(typeof(TDataContext));
if (dataAdapter == null)
{
return(null);
}
_dataContext = dataAdapter.CreateDataContext();
}
return((TDataContext)_dataContext);
}
public static EdmModel BuildEdmModelFromEfCoreModel(this Db.OeDataAdapter dataAdapter, Type[] excludeTypes, params IEdmModel[] refModels)
{
var context = (DbContext)dataAdapter.CreateDataContext();
try
{
var modelBuilder = new OeEdmModelBuilder(dataAdapter, new OeEfCoreEdmModelMetadataProvider(context.Model));
return(modelBuilder.BuildEdmModel(excludeTypes, refModels));
}
finally
{
dataAdapter.CloseDataContext(context);
}
}
public override OrderContext CreateContext()
{
Db.OeDataAdapter dataAdapter = OeEdmModel.GetDataAdapter(OeEdmModel.EntityContainer);
var dbContext = (DbContext)dataAdapter.CreateDataContext();
try
{
DbContextOptions options = TestHelper.CreateOptions <OrderContext>(dbContext);
return(new OrderContext(options));
}
finally
{
dataAdapter.CloseDataContext(dbContext);
}
}
public ODataResult <Model.OrderItem> WithItems(String itemIds)
{
List <int> ids = JArray.Parse(itemIds).Select(j => j.Value <int>()).ToList();
var edmModel = (IEdmModel)_httpContextAccessor.HttpContext.RequestServices.GetService(typeof(IEdmModel));
Db.OeDataAdapter dataAdapter = edmModel.GetDataAdapter(typeof(Model.OrderContext));
var orderContext = (Model.OrderContext)dataAdapter.CreateDataContext();
List <Model.OrderItem> orderItems = orderContext.OrderItems.Where(i => ids.Contains(i.Id)).ToList();
dataAdapter.CloseDataContext(orderContext);
return(_httpContextAccessor.HttpContext.OData(orderItems));
}
public static IEnumerable <OrderItem> BoundFunctionSingle(IEdmModel edmModel, Order order, IEnumerable <String> customerNames)
{
var customerNameSet = new HashSet <String>(customerNames);
Db.OeDataAdapter dataAdapter = edmModel.GetDataAdapter(typeof(OrderEf6Context));
var orderContext = (OrderEf6Context)dataAdapter.CreateDataContext();
Customer customer = orderContext.Customers.Find(new Object[] { order.CustomerCountry, order.CustomerId });
if (customerNameSet.Contains(customer.Name))
{
foreach (OrderItem orderItem in orderContext.OrderItems.Where(i => i.OrderId == order.Id))
{
yield return(orderItem);
}
}
}
protected static void EnsureCreated(IEdmModel edmModel)
{
Db.OeDataAdapter dataAdapter = edmModel.GetDataAdapter(edmModel.EntityContainer);
var dbContext = (DbContext)dataAdapter.CreateDataContext();
dbContext.Database.EnsureCreated();
dataAdapter.CloseDataContext(dbContext);
foreach (IEdmModel refModel in edmModel.ReferencedModels)
{
if (refModel.EntityContainer != null)
{
EnsureCreated(refModel);
}
}
}
public static EdmModel BuildEdmModelFromEfCorePgSqlModel(this Db.OeDataAdapter dataAdapter, String schema, params IEdmModel[] refModels)
{
var context = (DbContext)dataAdapter.CreateDataContext();
try
{
var model = (Model)context.Model;
model.Relational().DefaultSchema = schema;
var modelBuilder = new OeEdmModelBuilder(dataAdapter, new OeEfCoreEdmModelMetadataProvider(model));
return(modelBuilder.BuildEdmModel(refModels));
}
finally
{
dataAdapter.CloseDataContext(context);
}
}
private static Db.OeEntitySetAdapter GetEntitySetAdapter(IEdmModel edmModel, Type entityType)
{
Db.OeDataAdapter dataAdapter = edmModel.GetDataAdapter(edmModel.EntityContainer);
Db.OeEntitySetAdapter entitySetAdapter = dataAdapter.EntitySetAdapters.Find(entityType);
if (entitySetAdapter != null)
{
return(entitySetAdapter);
}
foreach (IEdmModel refModel in edmModel.ReferencedModels)
{
return(GetEntitySetAdapter(refModel, entityType));
}
throw new InvalidOperationException("Entity type " + entityType.FullName + " not found in edm model");
}
private OeEntryFactory CreateEntryFactory(OeExpressionBuilder expressionBuilder)
{
IEdmEntitySet entitySet = EntitySet;
if (expressionBuilder.EntityType != EntitySetAdapter.EntityType)
{
String typeName = expressionBuilder.EntityType.FullName;
Db.OeDataAdapter dataAdapter = EntitySetAdapter.DataAdapter;
Db.OeEntitySetMetaAdapter entitySetMetaAdapter = dataAdapter.EntitySetMetaAdapters.FindByTypeName(typeName);
if (entitySetMetaAdapter != null)
{
entitySet = EdmModel.FindDeclaredEntitySet(entitySetMetaAdapter.EntitySetName);
}
}
return(expressionBuilder.CreateEntryFactory(entitySet));
}
