Ejemplo n.º 1
0
 /// <summary>
 /// Gets a Graph from the Dataset
 /// </summary>
 /// <param name="graphUri">Graph URI</param>
 /// <returns></returns>
 /// <remarks>
 /// If the Graph has been modified during the active Transaction the modified version is returned rather than the original version
 /// </remarks>
 public sealed override IGraph this[Uri graphUri]
 {
     get
     {
         if (graphUri == null || graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri))
         {
             if (this.DefaultGraph != null)
             {
                 return this.DefaultGraph;
             }
             else if (this._modifiableGraphs.HasGraph(graphUri))
             {
                 return this._modifiableGraphs.Graph(graphUri);
             }
             else
             {
                 return this.GetGraphInternal(null);
             }
         }
         else if (this._modifiableGraphs.HasGraph(graphUri))
         {
             return this._modifiableGraphs.Graph(graphUri);
         }
         else
         {
             return this.GetGraphInternal(graphUri);
         }
     }
 }
 /// <summary>
 /// Sends a HEAD Command to the Protocol Server to determine whether a given Graph exists
 /// </summary>
 /// <param name="graphUri">URI of the Graph to check for</param>
 public virtual bool GraphExists(Uri graphUri)
 {
     return this.GraphExists(graphUri.ToSafeString());
 }
Ejemplo n.º 3
0
        /// <summary>
        /// Loads a Graph from the SQL Store into a Graph object
        /// </summary>
        /// <param name="graphUri">Uri of the Graph to load</param>
        /// <returns></returns>
        public IGraph Load(Uri graphUri)
        {
            Graph g = new Graph();
            try
            {
                //Get the Database Connection
                this._manager.Open(true);

                //Retrieve the existing Graph ID if any
                if (!this._manager.Exists(graphUri))
                {
                    throw new RdfStorageException("The Graph '" + graphUri.ToSafeString() + "' does not exist in the underlying Store");
                }
                String graphID = this._manager.GetGraphID(graphUri);

                g.BaseUri = graphUri;

                //Load Namespaces
                this._manager.LoadNamespaces(g, graphID);

                //Load Triples
                this._manager.LoadTriples(g, graphID);

                this._manager.Close(true);
            }
            catch
            {
                this._manager.Close(true, true);
                throw;
            }
            return g;
        }
Ejemplo n.º 4
0
 /// <summary>
 /// Removes a Graph from the Dataset
 /// </summary>
 /// <param name="graphUri">Graph URI</param>
 public override sealed void RemoveGraph(Uri graphUri)
 {
     if (graphUri == null || graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri))
     {
         if (this.DefaultGraphUris.Any())
         {
             foreach (Uri u in this.DefaultGraphUris)
             {
                 if (this.IsDefaultGraph(u))
                 {
                     //Default Graph gets cleared
                     GraphPersistenceWrapper wrapper = new GraphPersistenceWrapper(this[u]);
                     wrapper.Clear();
                     this._actions.Add(new GraphPersistenceAction(wrapper, GraphPersistenceActionType.Modified));
                 }
                 else
                 {
                     //Other Graphs get actually deleted
                     this._actions.Add(new GraphPersistenceAction(this[u], GraphPersistenceActionType.Deleted));
                 }
             }
         }
         else if (this.HasGraph(graphUri))
         {
             this._actions.Add(new GraphPersistenceAction(this[graphUri], GraphPersistenceActionType.Deleted));
             this.RemoveGraphInternal(graphUri);
         }
     }
     else if (this.HasGraph(graphUri))
     {
         this._actions.Add(new GraphPersistenceAction(this[graphUri], GraphPersistenceActionType.Deleted));
         this.RemoveGraphInternal(graphUri);
     }
 }
Ejemplo n.º 5
0
 /// <summary>
 /// Loads a Graph from the Store
 /// </summary>
 /// <param name="handler">RDF Handler</param>
 /// <param name="graphUri">Uri of the Graph to load</param>
 /// <remarks>If a Null Uri is specified then the default graph (statements with no context in Sesame parlance) will be loaded</remarks>
 public virtual void LoadGraph(IRdfHandler handler, Uri graphUri)
 {
     this.LoadGraph(handler, graphUri.ToSafeString());
 }
Ejemplo n.º 6
0
 /// <summary>
 /// Gets whether this Command affects the given Graph
 /// </summary>
 /// <param name="graphUri">Graph URI</param>
 /// <returns></returns>
 public override bool AffectsGraph(Uri graphUri)
 {
     switch (this._mode)
     {
         case ClearMode.All:
             return true;
         case ClearMode.Default:
             return graphUri == null || graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri);
         case ClearMode.Named:
             return graphUri != null && !graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri);
         case ClearMode.Graph:
             if (this._graphUri == null)
             {
                 return graphUri == null || graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri);
             }
             else
             {
                 return this._graphUri.ToString().Equals(graphUri.ToSafeString());
             }
         default:
             //No Other Clear Modes but have to keep the compiler happy
             return true;
     }
 }
Ejemplo n.º 7
0
 /// <summary>
 /// Creates a new connection to a Fuseki Server
 /// </summary>
 /// <param name="serviceUri">The /data URI of the Fuseki Server</param>
 public FusekiConnector(Uri serviceUri)
     : this(serviceUri.ToSafeString())
 {
 }
Ejemplo n.º 8
0
 /// <summary>
 /// Deletes a Graph from the Sesame store
 /// </summary>
 /// <param name="graphUri">URI of the Graph to delete</param>
 public virtual void DeleteGraph(Uri graphUri)
 {
     this.DeleteGraph(graphUri.ToSafeString());
 }
Ejemplo n.º 9
0
 /// <summary>
 /// Determines whether a given String is a valid Plain Literal for the given Datatype
 /// </summary>
 /// <param name="value">Value</param>
 /// <param name="dt">Datatype</param>
 /// <param name="syntax">Turtle Syntax</param>
 /// <returns></returns>
 public static bool IsValidPlainLiteral(String value, Uri dt, TurtleSyntax syntax)
 {
     StringComparison comparison = (syntax == TurtleSyntax.Original ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase);
     if ((value.Equals("true", comparison) || value.Equals("false", comparison)) && dt.ToSafeString().Equals(XmlSpecsHelper.XmlSchemaDataTypeBoolean))
     {
         return true;
     }
     else if (_validDecimal.IsMatch(value) && dt.ToSafeString().Equals(XmlSpecsHelper.XmlSchemaDataTypeDecimal))
     {
         return true;
     }
     else if (_validInteger.IsMatch(value) && dt.ToSafeString().Equals(XmlSpecsHelper.XmlSchemaDataTypeInteger))
     {
         return true;
     }
     else if (_validDouble.IsMatch(value) && dt.ToSafeString().Equals(XmlSpecsHelper.XmlSchemaDataTypeDouble))
     {
         return true;
     }
     else
     {
         return false;
     }
 }
Ejemplo n.º 10
0
 /// <summary>
 /// Removes a Graph from the Dataset
 /// </summary>
 /// <param name="graphUri">Graph URI</param>
 protected override void RemoveGraphInternal(Uri graphUri)
 {
     if (graphUri == null || graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri))
     {
         if (this._store.HasGraph(null))
         {
             this._store.Graphs[null].Clear();
         }
     }
     else
     {
         this._store.Remove(graphUri);
     }
 }
Ejemplo n.º 11
0
 public override bool Contains(Uri graphUri)
 {
     if (base.Contains(graphUri))
     {
         return true;
     }
     else if (!this._removedGraphs.Contains(graphUri.ToSafeString()))
     {
         //Try and load the Graph and return true if anything is returned
         Graph g = new Graph();
         try
         {
             this._manager.LoadGraph(g, graphUri);
             if (g.Triples.Count > 0)
             {
                 //If we're going to return true we must also store the Graph in the collection
                 //for later use
                 g.BaseUri = graphUri;
                 this.Add(g, true);
                 return true;
             }
             else
             {
                 return false;
             }
         }
         catch
         {
             //If trying to load the Graph errors then it doesn't exist so return false
             return false;
         }
     }
     else
     {
         return false;
     }
 }
Ejemplo n.º 12
0
 /// <summary>
 /// Gets the Graph describing the given resource from the Store
 /// </summary>
 /// <param name="handler">RDF Handler</param>
 /// <param name="resourceUri">URI of Resource to Describe</param>
 public void Describe(IRdfHandler handler, Uri resourceUri)
 {
     if (!resourceUri.Equals(String.Empty))
     {
         this.DescribeInternal(handler, resourceUri.ToSafeString(), "meta");
     }
 }
Ejemplo n.º 13
0
 /// <summary>
 /// Creates a new SPARQL Graph Store HTTP Protocol Connector
 /// </summary>
 /// <param name="serviceUri">URI of the Protocol Server</param>
 /// <param name="proxy">Proxy Server</param>
 public SparqlHttpProtocolConnector(Uri serviceUri, WebProxy proxy)
     : this(serviceUri.ToSafeString(), proxy)
 {
 }
 /// <summary>
 /// Creates a new SPARQL Graph Store HTTP Protocol Connector
 /// </summary>
 /// <param name="serviceUri">URI of the Protocol Server</param>
 public SparqlHttpProtocolConnector(Uri serviceUri)
     : this(serviceUri.ToSafeString()) { }
Ejemplo n.º 15
0
 /// <summary>
 /// Creates a new connection to a Fuseki Server
 /// </summary>
 /// <param name="serviceUri">The /data URI of the Fuseki Server</param>
 /// <param name="proxy">Proxy Server</param>
 public FusekiConnector(Uri serviceUri, WebProxy proxy)
     : this(serviceUri.ToSafeString(), proxy)
 {
 }
Ejemplo n.º 16
0
 /// <summary>
 /// Determines whether a given String is a valid Plain Literal for the given Datatype
 /// </summary>
 /// <param name="value">Value</param>
 /// <param name="dt">Datatype</param>
 /// <returns></returns>
 public static bool IsValidPlainLiteral(String value, Uri dt)
 {
     if ((value.Equals("true") || value.Equals("false")) && dt.ToSafeString().Equals(XmlSpecsHelper.XmlSchemaDataTypeBoolean))
     {
         return true;
     }
     else if (_validDecimal.IsMatch(value) && dt.ToSafeString().Equals(XmlSpecsHelper.XmlSchemaDataTypeDecimal))
     {
         return true;
     }
     else if (_validInteger.IsMatch(value) && dt.ToSafeString().Equals(XmlSpecsHelper.XmlSchemaDataTypeInteger))
     {
         return true;
     }
     else if (_validDouble.IsMatch(value) && dt.ToSafeString().Equals(XmlSpecsHelper.XmlSchemaDataTypeDouble))
     {
         return true;
     }
     else
     {
         return false;
     }
 }
Ejemplo n.º 17
0
 /// <summary>
 /// Removes a Graph from the Dataset
 /// </summary>
 /// <param name="graphUri">Graph URI</param>
 public virtual void RemoveGraph(Uri graphUri)
 {
     if (graphUri == null || graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri))
     {
         if (this._defaultGraph != null)
         {
             this._defaultGraph.Value.Clear();
         }
         else if (this.HasGraph(graphUri))
         {
             this.RemoveGraphInternal(graphUri);
         }
     }
     else if (this.HasGraph(graphUri))
     {
         this.RemoveGraphInternal(graphUri);
     }
 }
Ejemplo n.º 18
0
 /// <summary>
 /// Loads a Graph from the Store
 /// </summary>
 /// <param name="g">Graph to load into</param>
 /// <param name="graphUri">Uri of the Graph to load</param>
 /// <remarks>If a Null Uri is specified then the default graph (statements with no context in Sesame parlance) will be loaded</remarks>
 public virtual void LoadGraph(IGraph g, Uri graphUri)
 {
     this.LoadGraph(g, graphUri.ToSafeString());
 }
Ejemplo n.º 19
0
 /// <summary>
 /// Gets whether a Graph with the given URI is the Dataset
 /// </summary>
 /// <param name="graphUri">Graph URI</param>
 /// <returns></returns>
 public bool HasGraph(Uri graphUri)
 {
     if (graphUri == null || graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri))
     {
         if (this._defaultGraph != null)
         {
             return true;
         }
         else
         {
             return this.HasGraphInternal(null);
         }
     }
     else
     {
         return this.HasGraphInternal(graphUri);
     }
 }
Ejemplo n.º 20
0
 /// <summary>
 /// Updates a Graph
 /// </summary>
 /// <param name="graphUri">Uri of the Graph to update</param>
 /// <param name="additions">Triples to be added</param>
 /// <param name="removals">Triples to be removed</param>
 public virtual void UpdateGraph(Uri graphUri, IEnumerable<Triple> additions, IEnumerable<Triple> removals)
 {
     this.UpdateGraph(graphUri.ToSafeString(), additions, removals);
 }
Ejemplo n.º 21
0
 /// <summary>
 /// Gets the Graph with the given URI from the Dataset
 /// </summary>
 /// <param name="graphUri">Graph URI</param>
 /// <returns></returns>
 /// <remarks>
 /// <para>
 /// This property need only return a read-only view of the Graph, code which wishes to modify Graphs should use the <see cref="ISparqlDataset.GetModifiableGraph">GetModifiableGraph()</see> method to guarantee a Graph they can modify and will be persisted to the underlying storage
 /// </para>
 /// </remarks>
 public virtual IGraph this[Uri graphUri]
 {
     get
     {
         if (graphUri == null || graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri))
         {
             if (this._defaultGraph != null)
             {
                 return this._defaultGraph.Value;
             }
             else
             {
                 return this.GetGraphInternal(null);
             }
         }
         else
         {
             return this.GetGraphInternal(graphUri);
         }
     }
 }
Ejemplo n.º 22
0
        /// <summary>
        /// Gets whether the Command affects a given Graph
        /// </summary>
        /// <param name="graphUri">Graph URI</param>
        /// <returns></returns>
        public override bool AffectsGraph(Uri graphUri)
        {
            if (graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri)) graphUri = null;

            List<String> affectedUris = new List<string>();
            if (this._pattern.IsGraph)
            {
                affectedUris.Add(this._pattern.GraphSpecifier.Value);
            }
            else
            {
                affectedUris.Add(String.Empty);
            }
            if (this._pattern.HasChildGraphPatterns)
            {
                affectedUris.AddRange(from p in this._pattern.ChildGraphPatterns
                                      where p.IsGraph
                                      select p.GraphSpecifier.Value);
            }
            if (affectedUris.Any(u => u != null && u.Equals(GraphCollection.DefaultGraphUri))) affectedUris.Add(String.Empty);

            return affectedUris.Contains(graphUri.ToSafeString());
        }
Ejemplo n.º 23
0
 /// <summary>
 /// Removes a Graph from the Dataset
 /// </summary>
 /// <param name="graphUri">Graph URI</param>
 public sealed override void RemoveGraph(Uri graphUri)
 {
     if (graphUri == null || graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri))
     {
         if (this.DefaultGraph != null)
         {
             GraphPersistenceWrapper wrapper = new GraphPersistenceWrapper(DefaultGraph);
             wrapper.Clear();
             this._actions.Add(new GraphPersistenceAction(wrapper, GraphPersistenceActionType.Modified));
         }
         else if (this.HasGraph(graphUri))
         {
             this._actions.Add(new GraphPersistenceAction(this[graphUri], GraphPersistenceActionType.Deleted));
             this.RemoveGraphInternal(graphUri);
         }
     }
     else if (this.HasGraph(graphUri))
     {
         this._actions.Add(new GraphPersistenceAction(this[graphUri], GraphPersistenceActionType.Deleted));
         this.RemoveGraphInternal(graphUri);
     }
 }
Ejemplo n.º 24
0
 /// <summary>
 /// Gets whether the Command affects a given Graph
 /// </summary>
 /// <param name="graphUri">Graph URI</param>
 /// <returns></returns>
 public override bool AffectsGraph(Uri graphUri)
 {
     if (this._graphUri == null)
     {
         return graphUri == null || graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri);
     }
     else
     {
         return this._graphUri.ToString().Equals(graphUri.ToSafeString());
     }
 }
Ejemplo n.º 25
0
 /// <summary>
 /// Gets a Graph from the dataset
 /// </summary>
 /// <param name="graphUri">Graph URI</param>
 /// <returns></returns>
 public override IGraph this[Uri graphUri]
 {
     get
     {
         if (graphUri == null || graphUri.ToSafeString().Equals(GraphCollection.DefaultGraphUri))
         {
             if (this.DefaultGraphUris.Any())
             {
                 if (this.DefaultGraphUris.Count() == 1)
                 {
                     return new Graph(new QuadDatasetTripleCollection(this, this.DefaultGraphUris.First()));
                 }
                 else
                 {
                     IEnumerable<IGraph> gs = (from u in this.DefaultGraphUris
                                               select new Graph(new QuadDatasetTripleCollection(this, u))).OfType<IGraph>();
                     return new UnionGraph(gs.First(), gs.Skip(1));
                 }
             }
             else if (this._modifiableGraphs.HasGraph(graphUri))
             {
                 return this._modifiableGraphs.Graph(graphUri);
             }
             else
             {
                 return this.GetGraphInternal(null);
             }
         }
         else if (this._modifiableGraphs.HasGraph(graphUri))
         {
             return this._modifiableGraphs.Graph(graphUri);
         }
         else
         {
             return this.GetGraphInternal(graphUri);
         }
     }
 }