Exemplo n.º 1
0
        private QueryResult ExecuteAsParallel(IEnumerable<String> myLines, IGraphDBSession myIGraphDBSession, GraphQLQuery myGQLQuery, VerbosityTypes verbosityTypes, UInt32 parallelTasks = 1, IEnumerable<String> comments = null)
        {
            var queryResult       = new QueryResult();
            var aggregatedResults = new List<IEnumerable<Vertex>>();

            #region Create parallel options

            var parallelOptions = new ParallelOptions()
            {
                MaxDegreeOfParallelism = (int)parallelTasks
            };

            #endregion

            Int64 numberOfLine = 0;

            Parallel.ForEach(myLines, parallelOptions, (line, state) =>
            {

                if (!IsComment(line, comments))
                {

                    Interlocked.Add(ref numberOfLine, 1L);

                    if (!IsComment(line, comments)) // Skip comments
                    {

                        var qresult = ExecuteQuery(line, myIGraphDBSession, myGQLQuery);

                        #region VerbosityTypes.Full: Add result

                        if (verbosityTypes == VerbosityTypes.Full)
                        {
                            lock (aggregatedResults)
                            {
                                aggregatedResults.Add(qresult.Vertices);
                            }
                        }

                        #endregion

                        #region !VerbosityTypes.Silent: Add errors and break execution

                        if (qresult.ResultType != ResultType.Successful && verbosityTypes != VerbosityTypes.Silent)
                        {
                            lock (queryResult)
                            {
                                queryResult.PushIErrors(new[] { new Errors.Error_ImportFailed(line, numberOfLine) });
                                queryResult.PushIErrors(qresult.Errors);
                                queryResult.PushIWarnings(qresult.Warnings);
                            }
                            state.Break();
                        }

                        #endregion

                    }

                }

            });

            //add the results of each query into the queryResult
            queryResult.Vertices = AggregateListOfListOfVertices(aggregatedResults);

            return queryResult;
        }
Exemplo n.º 2
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="myWhereExpression"></param>
        /// <param name="_dbContext"></param>
        /// <param name="myTypeWithUndefAttrs">Type, List of undef attrs</param>
        /// <param name="myDBTypeAttributeToDelete">Type, List of attributes</param>
        /// <param name="myReferenceTypeLookup">reference, _graphDBType</param>
        /// <returns></returns>
        public QueryResult Delete(BinaryExpressionDefinition myWhereExpression, Dictionary<GraphDBType, List<string>> myTypeWithUndefAttrs, Dictionary<GraphDBType, List<TypeAttribute>> myDBTypeAttributeToDelete, Dictionary<String, GraphDBType> myReferenceTypeLookup)
        {
            QueryResult result = new QueryResult();

            try
            {

                #region get UUIDs

                if (myWhereExpression != null)
                {

                    #region _WhereExpression

                    myWhereExpression.Validate(_dbContext);
                    if (myWhereExpression.ValidateResult.Failed())
                    {
                        return new QueryResult(myWhereExpression.ValidateResult);
                    }

                    var resultGraph = myWhereExpression.Calculon(_dbContext, new CommonUsageGraph(_dbContext), false);
                    if (resultGraph.Failed())
                    {
                        return new QueryResult(resultGraph.IErrors);
                    }

                    IEnumerable<Exceptional<DBObjectStream>> _dbobjects;

                    #region undefined attributes

                    foreach (var type in myTypeWithUndefAttrs)
                    {
                        _dbobjects = resultGraph.Value.Select(new LevelKey(type.Key, _dbContext.DBTypeManager), null, false);

                        foreach (var dbObj in _dbobjects)
                        {
                            foreach (var undefAttr in type.Value)
                            {
                                var removeExcept = _dbContext.DBObjectManager.RemoveUndefinedAttribute(undefAttr, dbObj.Value);

                                if (removeExcept.Failed())
                                    return new QueryResult(removeExcept.IErrors);
                            }
                        }
                    }

                    #endregion

                    #region TypeAttributes to delete

                    Boolean generateLevel = true;

                    foreach (var aToBeDeletedAttribute in myDBTypeAttributeToDelete)
                    {
                        if (!resultGraph.Value.ContainsRelevantLevelForType(aToBeDeletedAttribute.Key))
                        {
                            generateLevel = false;
                        }
                        else
                        {
                            generateLevel = true;
                        }

                        var deleteResult = DeleteDBObjects(aToBeDeletedAttribute.Key, aToBeDeletedAttribute.Value, resultGraph.Value.Select(new LevelKey(aToBeDeletedAttribute.Key, _dbContext.DBTypeManager), null, generateLevel));

                        if (deleteResult.Failed())
                        {
                            return new QueryResult(deleteResult.IErrors);
                        }
                        else
                        {

                            if (!deleteResult.Success())
                            {
                                result.PushIWarnings(deleteResult.IWarnings);
                            }

                            result.Vertices = deleteResult.Value;

                        }

                    }

                    #endregion

                    #region expressionGraph error handling

                    result.PushIWarnings(resultGraph.Value.GetWarnings());

                    #endregion

                    #endregion
                }
                else
                {

                    if (myDBTypeAttributeToDelete.Count == 0)
                    {

                        #region delete only undefined attributes of types

                        foreach (var type in myTypeWithUndefAttrs)
                        {
                            var listOfAffectedDBObjects = _dbContext.DBObjectCache.SelectDBObjectsForLevelKey(new LevelKey(type.Key, _dbContext.DBTypeManager), _dbContext);
                            RemoveUndefAttrs(listOfAffectedDBObjects, type.Value);
                        }

                        #endregion

                    }
                    else
                    {
                        #region get guids via guid-idx

                        foreach (var attributeToDelete in myDBTypeAttributeToDelete)
                        {
                            var listOfAffectedDBObjects = _dbContext.DBObjectCache.SelectDBObjectsForLevelKey(new LevelKey(attributeToDelete.Key, _dbContext.DBTypeManager), _dbContext).ToList();

                            if (myTypeWithUndefAttrs.ContainsKey(attributeToDelete.Key))
                                RemoveUndefAttrs(listOfAffectedDBObjects, myTypeWithUndefAttrs[attributeToDelete.Key]);

                            List<TypeAttribute> attributes = new List<TypeAttribute>();
                            foreach (var attr in attributeToDelete.Value)
                            {
                                attributes.Add(attr);
                            }

                            var Result = DeleteDBObjects(attributeToDelete.Key, attributes, listOfAffectedDBObjects);

                            if (Result.Failed())
                            {
                                return new QueryResult(Result.IErrors);
                            }

                        }

                        #endregion
                    }
                }

                #endregion
            }
            catch (GraphDBException gdbEx)
            {
                return new QueryResult(gdbEx.GraphDBErrors);
            }
            catch (Exception e)
            {
                return new QueryResult(new Error_UnknownDBError(e));
            }

            return result;
        }
Exemplo n.º 3
0
        private QueryResult ExecuteAsSingleThread(IEnumerable<String> myLines, IGraphDBSession myIGraphDBSession, GraphQLQuery myGQLQuery, VerbosityTypes verbosityTypes, IEnumerable<String> comments = null)
        {
            var queryResult1 = new QueryResult();
            Int64 numberOfLine = 0;
            var query = String.Empty;
            var aggregatedResults = new List<IEnumerable<Vertex>>();

            foreach (var _Line in myLines)
            {

                numberOfLine++;

                #region Skip comments

                if (IsComment(_Line, comments))
                {
                    continue;
                }

                #endregion

                query += _Line;

                var qresult = ExecuteQuery(query, myIGraphDBSession, myGQLQuery);

                #region VerbosityTypes.Full: Add result

                if (verbosityTypes == VerbosityTypes.Full)
                {
                    aggregatedResults.Add(qresult.Vertices);
                }

                #endregion

                #region !VerbosityTypes.Silent: Add errors and break execution

                if (qresult.ResultType == ResultType.Failed)
                {

                    if (qresult.Errors.Any(e => (e is Error_GqlSyntax) && (e as Error_GqlSyntax).SyntaxErrorMessage.Equals("Mal-formed  string literal - cannot find termination symbol.")))
                    {
                        Debug.WriteLine("Query at line [" + numberOfLine + "] [" + query + "] failed with " + qresult.GetIErrorsAsString() + " add next line...");
                        continue;
                    }

                    if (verbosityTypes != VerbosityTypes.Silent)
                    {
                        queryResult1.PushIError(new Error_ImportFailed(query, numberOfLine));
                        queryResult1.PushIErrors(qresult.Errors);
                        queryResult1.PushIWarnings(qresult.Warnings);
                    }

                    break;

                }
                else if (qresult.ResultType == ResultType.PartialSuccessful && verbosityTypes != VerbosityTypes.Silent)
                {
                    queryResult1.PushIWarning(new Warning_ImportWarning(query, numberOfLine));
                    queryResult1.PushIWarnings(qresult.Warnings);
                }

                #endregion

                query = String.Empty;

            }

            //add the results of each query into the queryResult
            queryResult1.Vertices = AggregateListOfListOfVertices(aggregatedResults);

            return queryResult1;
        }