/// <summary> /// Executes the statement /// </summary> /// <param name="myGraphDBSession">The DBSession to start new transactions</param> /// <param name="dbContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="myGraphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession myGraphDBSession) { DBTransaction _GraphDBTransaction; if (CommandType == Transaction.CommandType.Commit) { _GraphDBTransaction = myGraphDBSession.CommitTransaction(); } else { _GraphDBTransaction = myGraphDBSession.RollbackTransaction(); } if (_GraphDBTransaction.Success()) { var _ReturnValues = new Dictionary<String, Object>(); _ReturnValues.Add("UUID", _GraphDBTransaction.UUID); _ReturnValues.Add("Created", _GraphDBTransaction.Created); _ReturnValues.Add("Finished", _GraphDBTransaction.Finished); _ReturnValues.Add("Distributed", _GraphDBTransaction.Distributed); _ReturnValues.Add("IsolationLevel", _GraphDBTransaction.IsolationLevel); _ReturnValues.Add("LongRunning", _GraphDBTransaction.LongRunning); _ReturnValues.Add("Name", _GraphDBTransaction.Name); _ReturnValues.Add("State", _GraphDBTransaction.State); return new QueryResult(new Vertex(_ReturnValues)).PushIExceptional(ParsingResult); } return new QueryResult(_GraphDBTransaction).PushIExceptional(ParsingResult); }
public QueryResult Import(String location, IGraphDBSession graphDBSession, DBContext myDBContext, UInt32 parallelTasks = 1, IEnumerable<string> comments = null, UInt64? offset = null, UInt64? limit = null, VerbosityTypes verbosityType = VerbosityTypes.Errors) { IEnumerable<String> lines = null; #region Read querie lines from location try { if (location.ToLower().StartsWith(@"file:\\")) { lines = ReadFile(location.Substring(@"file:\\".Length)); } else if (location.ToLower().StartsWith("http://")) { lines = ReadHttpResource(location); } else { return new QueryResult(new Exceptional(new Error_InvalidImportLocation(location, @"file:\\", "http://"))); } } catch (Exception ex) { return new QueryResult(new Exceptional(new Error_ImportFailed(ex))); } #endregion #region Start import using the AGraphDBImport implementation return Import(lines, graphDBSession, myDBContext, parallelTasks, comments, offset, limit, verbosityType); #endregion }
public override QueryResult Import(IEnumerable<String> myLines, IGraphDBSession myIGraphDBSession, DBContext myDBContext, UInt32 parallelTasks = 1, IEnumerable<String> comments = null, ulong? offset = null, ulong? limit = null, VerbosityTypes verbosityTypes = VerbosityTypes.Errors) { var gqlQuery = new GraphQLQuery(myDBContext.DBPluginManager); #region Evaluate Limit and Offset if (offset != null) { myLines = myLines.SkipULong(offset.Value); } if (limit != null) { myLines = myLines.TakeULong(limit.Value); } #endregion var queryResult = new QueryResult(); #region Import queries if (parallelTasks > 1) { queryResult = ExecuteAsParallel(myLines, myIGraphDBSession, gqlQuery, verbosityTypes, parallelTasks, comments); } else { queryResult = ExecuteAsSingleThread(myLines, myIGraphDBSession, gqlQuery, verbosityTypes, comments); } #endregion return queryResult; }
public override QueryResult Execute(IGraphDBSession graphDBSession) { var result = graphDBSession.Update(_SourceType.TypeName, _Sources, _Condition); result.PushIExceptional(ParsingResult); return result; }
/// <summary> /// Create a new BulkInsert. /// </summary> /// <param name="myGraphDBSession">The DB Reference</param> /// <param name="myGraphFSSession">The FS reference</param> /// <param name="myType">The type of the ne DBObjects</param> public BulkInsert(IGraphDBSession myGraphDBSession, IGraphFSSession myGraphFSSession, String myType) { _GraphDBSession = myGraphDBSession; _GraphFSSession = myGraphFSSession; (_GraphFSSession.SessionToken.SessionInfo as FSSessionInfo).FSSettings.ReflushAllocationMap = false; _DBTransaction = _GraphDBSession.BeginTransaction(myLongRunning: true, myIsolationLevel: IsolationLevel.Serializable); _Type = ((DBContext)_DBTransaction.GetDBContext()).DBTypeManager.GetTypeByName(myType); }
/// <summary> /// Create a new BulkInsert. /// </summary> /// <param name="myGraphDBSession">The DB Reference</param> /// <param name="myGraphFSSession">The FS reference</param> /// <param name="myType">The type of the ne DBObjects</param> public BulkInsert(IGraphDBSession myGraphDBSession, IGraphFSSession myGraphFSSession, GraphDBType myType) { _GraphDBSession = myGraphDBSession; _GraphFSSession = myGraphFSSession; _Type = myType; (_GraphFSSession.SessionToken.SessionInfo as FSSessionInfo).FSSettings.ReflushAllocationMap = false; _DBTransaction = _GraphDBSession.BeginTransaction(myLongRunning: true, myIsolationLevel: IsolationLevel.Serializable); }
/// <summary> /// /// </summary> /// <param name="myQueryScript"></param> /// <param name="myGraphDBSession">Needed for BeginTransaction inside any AStatementNode</param> /// <returns></returns> public QueryResult Query(String myQueryScript, IGraphDBSession myGraphDBSession) { #region Data QueryResult _QueryResult; #endregion _QueryResult = ExecuteQuery(myQueryScript, myGraphDBSession); _QueryResult.Query = myQueryScript; return _QueryResult; }
/// <summary> /// Executes the statement /// </summary> /// <param name="graphDBSession">The DBSession to start new transactions</param> /// <param name="dbContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="graphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession graphDBSession) { if (String.IsNullOrEmpty(_TypeName)) { var aError = new Error_TypeDoesNotExist(""); return new QueryResult(aError); } var qresult = graphDBSession.DropIndex(_TypeName, _IndexName, _IndexEdition); qresult.PushIExceptional(ParsingResult); return qresult; }
public QueryResult Import(String location, IGraphDBSession graphDBSession, DBContext myDBContext, UInt32 parallelTasks = 1, IEnumerable<string> comments = null, UInt64? offset = null, UInt64? limit = null, VerbosityTypes verbosityType = VerbosityTypes.Errors) { QueryResult result = new QueryResult(); Stream stream = null; #region Read querie lines from location try { if (location.ToLower().StartsWith(@"file:\\")) { //lines = ReadFile(location.Substring(@"file:\\".Length)); stream = GetStreamFromFile(location.Substring(@"file:\\".Length)); } else if (location.ToLower().StartsWith("http://")) { stream = GetStreamFromHttp(location); } else { return new QueryResult(new Exceptional(new Error_InvalidImportLocation(location, @"file:\\", "http://"))); } #region Start import using the AGraphDBImport implementation and return the result return Import(stream, graphDBSession, myDBContext, parallelTasks, comments, offset, limit, verbosityType); #endregion } catch (Exception ex) { return new QueryResult(new Exceptional(new Error_ImportFailed(ex))); } finally { if (stream != null) { stream.Dispose(); } } #endregion }
public override QueryResult Import(System.IO.Stream myInputStream, IGraphDBSession myIGraphDBSession, DBContext myDBContext, UInt32 myParallelTasks = 1, IEnumerable<String> myComments = null, ulong? myOffset = null, ulong? myLimit = null, VerbosityTypes myVerbosityType = VerbosityTypes.Errors) { var gqlQuery = new GraphQLQuery(myDBContext.DBPluginManager); var lines = ReadLinesFromStream(myInputStream); #region Evaluate Limit and Offset if (myOffset != null) { lines = lines.SkipULong(myOffset.Value); } if (myLimit != null) { lines = lines.TakeULong(myLimit.Value); } #endregion var queryResult = new QueryResult(); #region Import queries if (myParallelTasks > 1) { queryResult = ExecuteAsParallel(lines, myIGraphDBSession, gqlQuery, myVerbosityType, myParallelTasks, myComments); } else { queryResult = ExecuteAsSingleThread(lines, myIGraphDBSession, gqlQuery, myVerbosityType, myComments); } #endregion return queryResult; }
/// <summary> /// Executes the statement /// </summary> /// <param name="graphDBSession">The DBSession to start new transactions</param> /// <param name="dbContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="graphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession graphDBSession) { var qresult = graphDBSession.AlterType(_TypeName, _AlterTypeCommand); qresult.PushIExceptional(ParsingResult); return qresult; }
/// <summary> /// This will close the BulkInsert and flushes all DBObjects. /// </summary> public void Dispose() { Flush(); _LastDBO = null; _LastBackwardEdge = null; _GraphDBSession = null; _GraphFSSession = null; _Type = null; }
/// <summary> /// Executes the statement /// </summary> /// <param name="graphDBSession">The DBSession to start new transactions</param> /// <param name="dbContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="graphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession graphDBSession) { var qresult = graphDBSession.Delete(_TypeReferenceDefinitions, _IDChainDefinitions, _WhereExpression); qresult.PushIExceptional(ParsingResult); return qresult; }
public abstract QueryResult Import(Stream myInputStream, IGraphDBSession myGraphDBSession, DBContext myDBContext, UInt32 myParallelTasks = 1, IEnumerable<string> myComments = null, UInt64? myOffset = null, UInt64? myLimit = null, VerbosityTypes myVerbosityType = VerbosityTypes.Errors);
/// <summary> /// Executes the statement /// </summary> /// <param name="graphDBSession">The DBSession to start new transactions</param> /// <param name="dbContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="graphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession graphDBSession) { var qresult = graphDBSession.CreateTypes(_TypeDefinitions); qresult.PushIExceptional(ParsingResult); return qresult; }
/// <summary> /// Executes the statement /// </summary> /// <param name="graphDBSession">The DBSession to start new transactions</param> /// <param name="dbContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="graphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession graphDBSession) { var qresult = graphDBSession.Replace(_TypeName, _AttributeAssignList, _whereExpression); qresult.PushIExceptional(ParsingResult); return qresult; }
private QueryResult ExecuteQuery(String myQuery, IGraphDBSession myIGraphDBSession, GraphQLQuery myGQLQuery) { return myGQLQuery.Query(myQuery, myIGraphDBSession); }
/// <summary> /// Executes the statement /// </summary> /// <param name="myIGraphDBSession">The DBSession to start new transactions</param> /// <param name="myDBContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="myIGraphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession myIGraphDBSession) { var qresult = myIGraphDBSession.Export(_DumpFormat.ToString().ToUpper(), _DumpDestination, _DumpableGrammar, _TypesToDump, _DumpType); qresult.PushIExceptional(ParsingResult); return qresult; }
/// <summary> /// Executes the statement /// </summary> /// <param name="myIGraphDBSession">The DBSession to start new transactions</param> /// <param name="transactionContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="myIGraphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession myIGraphDBSession) { var createIdxResult = myIGraphDBSession.CreateIndex(_DBType, _IndexName, _IndexEdition, _IndexType, _AttributeList); createIdxResult.PushIExceptional(ParsingResult); return createIdxResult; }
public QueryResult ExecuteQuery(IGraphDBSession myGraphDBSession) { return myGraphDBSession.Select(SelectDefinition.SelectedElements, SelectDefinition.TypeList, SelectDefinition.WhereExpressionDefinition, SelectDefinition.GroupByIDs, SelectDefinition.Having, SelectDefinition.OrderByDefinition, SelectDefinition.Limit, SelectDefinition.Offset, SelectDefinition.ResolutionDepth); }
/// <summary> /// Executes the statement /// </summary> /// <param name="myIGraphDBSession">The DBSession to start new transactions</param> /// <param name="myDBContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="myIGraphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession myIGraphDBSession) { var qresult = myIGraphDBSession.Update(_TypeName, _listOfUpdates, _WhereExpression); qresult.PushIExceptional(ParsingResult); return qresult; }
private bool ExecuteAQuery(string query, IGraphDBSession dbSession, GraphQLQuery myGQLQuery) { if (query.Length != 0) { //execute query QueryResult myQueryResult = myGQLQuery.Query(query, dbSession); WriteLine(query); HandleQueryResult(myQueryResult, false); if (myQueryResult.ResultType != ResultType.Successful) { WriteLine(myQueryResult.GetIErrorsAsString()); return false; } else { return true; } } else { return true; } }
/// <summary> /// Executes the statement /// </summary> /// <param name="myIGraphDBSession">The DBSession to start new transactions</param> /// <param name="myDBContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="myIGraphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession myIGraphDBSession) { var qresult = myIGraphDBSession.Describe(_DescribeDefinition); qresult.PushIExceptional(ParsingResult); return qresult; }
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; }
/// <summary> /// Executes the statement /// </summary> /// <param name="myIGraphDBSession">The DBSession to start new transactions</param> /// <param name="myDBContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="myIGraphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession myIGraphDBSession) { var qresult = myIGraphDBSession.Truncate(_TypeName); qresult.PushIExceptional(ParsingResult); return qresult; }
/// <summary> /// Executes the statement /// </summary> /// <param name="graphDBSession">The DBSession to start new transactions</param> /// <param name="dbContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="graphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession graphDBSession) { var qresult = graphDBSession.InsertOrUpdate(_Type, _AttributeAssignList, _WhereExpression); qresult.PushIExceptional(ParsingResult); return qresult; }
/// <summary> /// Executes the statement /// </summary> /// <param name="graphDBSession">The DBSession to start new transactions</param> /// <param name="dbContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="graphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession graphDBSession) { #region Start select var runThreaded = DBConstants.UseThreadedSelect; #if DEBUG runThreaded = false; #endif var qresult = graphDBSession.Select(SelectedElements, TypeList, WhereExpressionDefinition, GroupByIDs, Having, OrderByDefinition, Limit, Offset, ResolutionDepth, runThreaded); qresult.PushIExceptional(ParsingResult); return qresult; #endregion }
/// <summary> /// Executes the statement /// </summary> /// <param name="graphDBSession">The DBSession to start new transactions</param> /// <param name="dbContext">The current dbContext inside an readonly transaction. For any changes, you need to start a new transaction using <paramref name="graphDBSession"/></param> /// <returns>The result of the query</returns> public override QueryResult Execute(IGraphDBSession graphDBSession) { var qresult = graphDBSession.Setting(_TypeOfSettingOperation, _Settings, _ASettingDefinition); qresult.PushIExceptional(ParsingResult); return qresult; }
public override QueryResult Execute(IGraphDBSession graphDBSession) { var qresult = graphDBSession.RebuildIndices(_Types); qresult.PushIExceptional(ParsingResult); return qresult; }
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; }