GraphReference.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content.Semantic;
using Waher.Content.Semantic.Model;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.Collections;
using Waher.Runtime.Counters;
 
namespace Waher.Script.Persistence.SPARQL.Sources
{
    [CollectionName("GraphStore")]
    [TypeName(TypeNameSerialization.None)]
    [Index("GraphUri")]
    [Index("Created")]
    public class GraphReference
    {
        public const int DatabaseMinFileCount = 10;
 
        public GraphReference()
        {
        }
 
        [ObjectId]
        public string ObjectId { get; set; }
 
        public CaseInsensitiveString GraphUri { get; set; }
 
        public CaseInsensitiveString GraphDigest { get; set; }
 
        public string Folder { get; set; }
 
        public DateTime Created { get; set; }
 
        public DateTime Updated { get; set; }
 
        public int NrFiles { get; set; }
 
        public string[] Creators { get; set; }
 
        [DefaultValue(false)]
        public bool InDatabase { get; set; }
 
        [DefaultValue(0L)]
        public long DatabaseKey { get; set; }
 
        public async Task<IGraphSource> GetGraphSource()
        {
            if (this.InDatabase)
                return new GraphStoreDbSource(this);
 
            GraphStoreFileSource FileSource = new GraphStoreFileSource(this);
 
            if (this.NrFiles <= DatabaseMinFileCount)
                return FileSource;
 
            ISemanticCube Model = await FileSource.LoadGraph(new Uri(this.GraphUri), true);
 
            this.DatabaseKey = await RuntimeCounters.IncrementCounter("GraphStore.LastGraphKey");
            this.InDatabase = true;
 
            await Database.Update(this);
            await this.AddTriplesToDatabase(new IEnumerable<ISemanticTriple>[] { Model });
 
            return new GraphStoreDbSource(this);
        }
 
        public async Task ModelsAdded(ChunkedList<ISemanticModel> Models)
        {
            if (!this.InDatabase && this.NrFiles > DatabaseMinFileCount)
            {
                GraphStoreFileSource FileSource = new GraphStoreFileSource(this);
                ISemanticCube Model = await FileSource.LoadGraph(new Uri(this.GraphUri), true);
 
                this.DatabaseKey = await RuntimeCounters.IncrementCounter("GraphStore.LastGraphKey");
                this.InDatabase = true;
 
                await Database.Update(this);
 
                Models.Clear();
                if (!(Model is null))
                    Models.Add(Model);
            }
 
            await this.AddTriplesToDatabase(Models);
        }
 
        public async Task AddTriplesToDatabase(IEnumerable<IEnumerable<ISemanticTriple>> Models)
        {
            ChunkedList<DatabaseTriple> ToSave = new ChunkedList<DatabaseTriple>();
            int c = 0;
 
            foreach (IEnumerable<ISemanticTriple> Model in Models)
            {
                foreach (ISemanticTriple T in Model)
                {
                    if (T.Subject is SemanticElement S &&
                        T.Predicate is SemanticElement P &&
                        T.Object is SemanticElement O)
                    {
                        ToSave.Add(new DatabaseTriple()
                        {
                            GraphKey = this.DatabaseKey,
                            S = S,
                            P = P,
                            O = O
                        });
 
                        c++;
 
                        if (c >= 1000)
                        {
                            await Database.Insert(ToSave.ToArray());
                            ToSave.Clear();
                            c = 0;
                        }
                    }
                }
            }
 
            if (c > 0)
                await Database.Insert(ToSave.ToArray());
        }
    }
}