/// <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;
}
