예제 #1
0
        /// <summary>
        /// Retrieve objects of the predicates of the entity and store them to particular lists
        /// </summary>
        /// <param name="subjectIri">An IRI of the entity we are describing</param>
        /// <param name="language">The language of the search</param>
        /// <param name="endpoint">An endpoint where to search</param>
        /// <param name="count">If positive, set limit according to this value; if negative, retrieve all objects</param>
        public static Task RetrieveObjects(PredicateResultWrapperList predicateWrapperList, string subjectIri, string language, int count = -1)
        {
            Config.AssertAbsoluteUri(subjectIri);

            if (!predicateWrapperList.HasPredicates)
            {
                return(Task.CompletedTask);
            }
            SparqlParameterizedString template;

            if (count < 0)
            {
                template = QueryCreating.GetQueryTemplateCopy(QueryTemplates.SelectObjectsOfPredicate);
            }
            else
            {
                template = QueryCreating.GetQueryTemplateCopy(QueryTemplates.SelectObjectsOfPredicateWithLimit);
                template.SetLimit(count);
            }
            template.SetLanguage(language);
            template.SetSubject(subjectIri);
            List <Task> tasks = new List <Task>();

            foreach (var predicate in predicateWrapperList)
            {
                var task = RetrieveObjectsOfPredicate(predicate, template);
                tasks.Add(task);
            }
            return(Task.WhenAll(tasks));
            //var x = Parallel.ForEach(list, async predicate => await RetrieveObjectsOfPredicate(predicate, template, endpoint));
        }
예제 #2
0
        /// <summary>
        /// Get all the predicates from the triples with given subject IRI, sorted according to the popularity of predicates
        /// </summary>
        public static async Task RetrievePredicatesAndObjectCounts(PredicateResultWrapperList list, string subjectIri, string language, SparqlRemoteEndpoint endpoint)
        {
            Config.AssertAbsoluteUri(subjectIri);

            SparqlQuery query = QueryCreating.CreateQuery(QueryTemplates.SelectDistinctPredicateAndObjectCount, subjectIri, language);

            var holder = await RetrieveResultHolder(query, endpoint);

            foreach (var result in holder.QueryResultSet)
            {
                var predicate = await CreatePredicateNodeFromSparqlResult(subjectIri, holder.QueryEndpoint, result);

                list.InsertPredicateWrapper(predicate);
            }
            list.Sort();
        }
예제 #3
0
        /// <summary>
        /// Get all the predicates from the triples with given subject IRI from multiple endpoints, sorted according to the popularity of predicates
        /// </summary>
        public static async Task RetrievePredicatesAndObjectCounts(PredicateResultWrapperList list, string subjectIri, string language, List <SparqlRemoteEndpoint> endpoints)
        {
            Config.AssertAbsoluteUri(subjectIri);

            SparqlQuery query = QueryCreating.CreateQuery(QueryTemplates.SelectDistinctPredicateAndObjectCount, subjectIri, language);

            /*** create tasks ***/
            List <Task <ResultHolder> > tasks = new List <Task <ResultHolder> >(capacity: endpoints.Count);

            try
            {
                foreach (var endpoint in endpoints)
                {
                    tasks.Add(RetrieveResultHolder(query, endpoint));
                }
            }
            catch (Exception)
            {
                throw;
            }
            /*** process results ***/
            try
            {
                foreach (var task in tasks)
                {
                    var endpoint = task.Result.QueryEndpoint;
                    foreach (var result in task.Result.QueryResultSet)
                    {
                        var predicate = await CreatePredicateNodeFromSparqlResult(subjectIri, endpoint, result);

                        list.InsertPredicateWrapper(predicate);
                    }
                }
            }
            catch (AggregateException)
            {
                throw;
            }
            catch (Exception)
            {
                throw;
            }

            list.Sort();
            //TODO: handle duplicates
        }