private void InsertDocument(DocumentDbContext dbContext, ResourceChange change)
{
var collection = dbContext.Database.GetCollection(change.CollectionName);
var document = DocumentDbDSPConverter.CreateJsonDocument(change.Resource, this.dbMetadata, change.CollectionName);
//collection.Insert(document);
//change.Resource.SetValue(DocumentDbMetadata.MappedObjectIdName, document.GetValue(DocumentDbMetadata.ProviderObjectIdName).ToString());
}
private void PopulateMetadata(DocumentDbContext context)
{
lock (this.instanceMetadataCache)
{
foreach (var collectionName in GetCollectionNames(context))
{
var resourceSet = this.instanceMetadataCache.ResolveResourceSet(collectionName);
if (this.Configuration.PrefetchRows == 0)
{
if (resourceSet == null)
{
AddResourceSet(context, collectionName);
}
}
else
{
PopulateMetadataFromCollection(context, collectionName, resourceSet);
}
}
foreach (var prop in this.unresolvedProperties)
{
var providerType = typeof(string);
var propertyName = NormalizeResourcePropertyName(prop.PropertyName);
this.instanceMetadataCache.AddPrimitiveProperty(prop.CollectionType, propertyName, providerType);
this.instanceMetadataCache.ProviderTypes.Add(
GetQualifiedPropertyName(prop.CollectionType.Name, propertyName), providerType);
}
}
}
internal void RegisterResourceProperty(DocumentDbContext context, ResourceType resourceType, JProperty element)
{
var collectionProperty = new CollectionProperty {
CollectionType = resourceType, PropertyName = element.Name
};
var resourceProperty = ResolveResourceProperty(resourceType, element);
if (resourceProperty == null)
{
lock (unresolvedProperties)
{
var unresolvedEarlier = unresolvedProperties.Contains(collectionProperty);
var resolvedNow = ResolveProviderType(element, IsObjectId(element)) != null;
if (!unresolvedEarlier && !resolvedNow)
{
this.unresolvedProperties.Add(collectionProperty);
}
else if (unresolvedEarlier && resolvedNow)
{
this.unresolvedProperties.Remove(collectionProperty);
}
if (resolvedNow)
{
AddResourceProperty(context, resourceType.Name, resourceType, element, resourceType.ResourceTypeKind == ResourceTypeKind.EntityType);
}
}
}
}
private void UpdateResourceSet(DocumentDbContext context, ResourceSet resourceSet, JToken document)
{
foreach (var element in document)
{
RegisterDocumentProperty(context, resourceSet.ResourceType, element as JProperty);
}
}
private void UpdateDocument(DocumentDbContext dbContext, ResourceChange change)
{
if (!change.ModifiedProperties.Any())
{
return;
}
var collection = dbContext.Database.GetCollection(change.CollectionName);
//var query = Query.EQ(DocumentDbMetadata.ProviderObjectIdName, ObjectId.Parse(change.Resource.GetValue(DocumentDbMetadata.MappedObjectIdName).ToString()));
//UpdateBuilder update = null;
//foreach (var resourceProperty in change.ModifiedProperties)
//{
// if (update == null)
// {
// if (resourceProperty.Value != null)
// update = Update.Set(resourceProperty.Key, JsonValue.Create(resourceProperty.Value));
// else
// update = Update.Unset(resourceProperty.Key);
// }
// else
// {
// if (resourceProperty.Value != null)
// update = update.Set(resourceProperty.Key, JsonValue.Create(resourceProperty.Value));
// else
// update = update.Unset(resourceProperty.Key);
// }
//}
//collection.Update(query, update);
}
private void PopulateMetadataFromCollection(DocumentDbContext context, string collectionName, ResourceSet resourceSet)
{
var collection = context.Database.GetCollection(collectionName);
// TODO: fetch first or last documents once sort is supported
var documents = context.Client.CreateDocumentQuery <JObject>(collection.DocumentsLink);
int rowCount = 0;
foreach (var document in documents)
{
if (resourceSet == null)
{
resourceSet = AddResourceSet(context, collectionName, document);
}
else
{
UpdateResourceSet(context, resourceSet, document);
}
++rowCount;
if (this.Configuration.PrefetchRows >= 0 && rowCount >= this.Configuration.PrefetchRows)
{
break;
}
}
}
private void RegisterArrayProperty(DocumentDbContext context, ResourceType collectionType, JProperty element)
{
var propertyName = GetResourcePropertyName(element, ResourceTypeKind.EntityType);
foreach (var arrayValue in element.Value)
{
if (arrayValue.Type == JTokenType.Null)
{
continue;
}
if (arrayValue.Type == JTokenType.Object)
{
RegisterDocumentProperties(context, collectionType, new JProperty((element as JProperty).Name, arrayValue));
}
else if (ResolveResourceProperty(collectionType, propertyName) == null)
{
// OData protocol doesn't support collections of collections
if (arrayValue.Type != JTokenType.Array)
{
var mappedType = MapToDotNetType(arrayValue);
this.instanceMetadataCache.AddCollectionProperty(collectionType, propertyName, mappedType);
}
}
}
}
public DocumentDbMetadata(string connectionString, DocumentDbConfiguration.Metadata metadata = null)
{
this.connectionString = connectionString;
this.Configuration = metadata ?? DocumentDbConfiguration.Metadata.Default;
lock (MetadataCache)
{
this.instanceMetadataCache = GetOrCreateMetadataCache();
}
using (var context = new DocumentDbContext(connectionString))
{
PopulateMetadata(context);
}
}
public override void SaveChanges()
{
base.SaveChanges();
using (DocumentDbContext dbContext = new DocumentDbContext(connectionString))
{
foreach (var pendingChange in this.pendingChanges)
{
var action = pendingChange.Action;
action(dbContext, pendingChange);
}
}
this.pendingChanges.Clear();
}
private void RegisterDocumentProperty(DocumentDbContext context, ResourceType resourceType, JProperty element)
{
var resourceProperty = ResolveResourceProperty(resourceType, element);
if (resourceProperty == null)
{
RegisterResourceProperty(context, resourceType, element);
}
else if ((resourceProperty.Kind & ResourcePropertyKind.ComplexType) != 0 && element.Value.Type != JTokenType.Null)
{
RegisterDocumentProperties(context, resourceType, element);
}
else if ((resourceProperty.Kind & ResourcePropertyKind.Collection) != 0 && element.Value.Type != JTokenType.Null)
{
RegisterArrayProperty(context, resourceType, element);
}
}
private void RegisterDocumentProperties(DocumentDbContext context, ResourceType collectionType, JProperty element)
{
var resourceName = GetResourcePropertyName(element, ResourceTypeKind.EntityType);
var resourceType = ResolveResourceType(resourceName, collectionType.Name);
if (resourceType == null)
{
AddDocumentProperty(context, collectionType.Name, collectionType, resourceName, element, true);
}
else
{
foreach (var documentElement in element.Value)
{
RegisterDocumentProperty(context, resourceType, documentElement as JProperty);
}
}
}
private void AddResourceProperty(DocumentDbContext context, string collectionName, ResourceType collectionType,
JProperty element, bool treatObjectIdAsKey = false)
{
var elementType = GetElementType(element, treatObjectIdAsKey);
var propertyName = GetResourcePropertyName(element, collectionType.ResourceTypeKind);
var propertyValue = element.Value;
if (string.IsNullOrEmpty(propertyName))
{
return;
}
var isKey = false;
if (IsObjectId(element))
{
if (treatObjectIdAsKey)
{
this.instanceMetadataCache.AddKeyProperty(collectionType, propertyName, elementType);
}
else
{
this.instanceMetadataCache.AddPrimitiveProperty(collectionType, propertyName, elementType);
}
isKey = true;
}
else if (elementType == typeof(JObject) || elementType == typeof(JProperty))
{
AddDocumentProperty(context, collectionName, collectionType, propertyName, element);
}
else if (elementType == typeof(JArray))
{
RegisterArrayProperty(context, collectionType, element);
}
else
{
this.instanceMetadataCache.AddPrimitiveProperty(collectionType, propertyName, elementType);
}
if (!string.IsNullOrEmpty(propertyName))
{
AddProviderType(collectionName, IsObjectId(element) ? ProviderObjectIdName : propertyName, element, isKey);
}
}
private void AddDocumentProperty(DocumentDbContext context, string collectionName, ResourceType collectionType, string propertyName, JProperty element, bool isCollection = false)
{
ResourceType resourceType = null;
var resourceSet = this.instanceMetadataCache.ResolveResourceSet(collectionName);
if (resourceSet != null)
{
resourceType = resourceSet.ResourceType;
}
else
{
resourceType = AddDocumentType(context, GetQualifiedTypeName(collectionName, propertyName),
element.Value, ResourceTypeKind.ComplexType);
}
if (isCollection && ResolveResourceProperty(collectionType, propertyName) == null)
{
this.instanceMetadataCache.AddCollectionProperty(collectionType, propertyName, resourceType);
}
else
{
this.instanceMetadataCache.AddComplexProperty(collectionType, propertyName, resourceType);
}
}
private ResourceType AddDocumentType(DocumentDbContext context, string collectionName, JToken document, ResourceTypeKind resourceTypeKind)
{
var collectionType = resourceTypeKind == ResourceTypeKind.EntityType
? this.instanceMetadataCache.AddEntityType(collectionName)
: this.instanceMetadataCache.AddComplexType(collectionName);
bool hasObjectId = false;
if (document != null)
{
foreach (var element in document)
{
var property = element as JProperty;
RegisterResourceProperty(context, collectionType, property);
if (IsObjectId(property))
{
hasObjectId = true;
}
}
}
if (!hasObjectId)
{
if (resourceTypeKind == ResourceTypeKind.EntityType)
{
this.instanceMetadataCache.AddKeyProperty(collectionType, MappedObjectIdName, MappedObjectIdType);
}
AddProviderType(collectionName, ProviderObjectIdName, new JProperty(ProviderObjectIdName, string.Empty), true); // TODO
}
if (resourceTypeKind == ResourceTypeKind.EntityType)
{
this.instanceMetadataCache.AddResourceSet(collectionName, collectionType);
}
return(collectionType);
}
private IEnumerable <string> GetCollectionNames(DocumentDbContext context)
{
return(context.Database.GetCollections()
.Select(x => x.Id)
.Where(x => !x.StartsWith("system.")));
}
private void RemoveDocument(DocumentDbContext dbContext, ResourceChange change)
{
var collection = dbContext.Database.GetCollection(change.CollectionName);
//var query = Query.EQ(DocumentDbMetadata.ProviderObjectIdName, ObjectId.Parse(change.Resource.GetValue(DocumentDbMetadata.MappedObjectIdName).ToString()));
//collection.Remove(query);
}
private ResourceSet AddResourceSet(DocumentDbContext context, string collectionName, JToken document = null)
{
AddDocumentType(context, collectionName, document, ResourceTypeKind.EntityType);
return(this.instanceMetadataCache.ResolveResourceSet(collectionName));
}
