public IQueryResult Query(sones.Library.Commons.Security.SecurityToken mySecurityToken, Int64 myTransactionToken, string myQueryString, string myQueryLanguageName) { IGraphQL queryLanguage; if (_QueryLanguages.TryGetValue(myQueryLanguageName, out queryLanguage)) { // drain every query (before the query) foreach (KeyValuePair <String, IDrainPipe> _drainpipe in _DrainPipes) { _drainpipe.Value.Query(mySecurityToken, myTransactionToken, myQueryString, myQueryLanguageName); } IQueryResult result = queryLanguage.Query(mySecurityToken, myTransactionToken, myQueryString); // drain every query result (after the query) foreach (KeyValuePair <String, IDrainPipe> _drainpipe in _DrainPipes) { _drainpipe.Value.DrainQueryResult(result); } return(result); } else { throw new QueryLanguageNotFoundException(String.Format("The GraphDS server does not support the query language {0}", myQueryLanguageName)); } }
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, TransactionToken myTransactionToken) { _query = myQuery; var vertexType = myGraphDB.GetVertexType<IVertexType>( mySecurityToken, myTransactionToken, new RequestGetVertexType(_typeName), (stats, vType) => vType); _WhereExpression.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, vertexType); var expressionGraph = _WhereExpression.Calculon(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, new CommonUsageGraph(myGraphDB, mySecurityToken, myTransactionToken)); var toBeDeletedVertices = expressionGraph.Select( new LevelKey(vertexType.ID, myGraphDB, mySecurityToken, myTransactionToken), null, true); //TODO: do sth that is better than that: ew RequestDelete(new RequestGetVertices(_typeName, toBeDeletedVertices.Select(_ => _.VertexID))). return myGraphDB.Delete<QueryResult>( mySecurityToken, myTransactionToken, new RequestDelete(new RequestGetVertices(_typeName, toBeDeletedVertices.Select(_ => _.VertexID))).AddAttributes(_toBeDeletedAttributes), CreateQueryResult); }
public override QueryResult GetResult( GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken) { var resultingVertices = new List<IVertexView>(); ASonesException error = null; #region Specific index var request = new RequestDescribeIndex(_TypeName, _IndexName, _IndexEdition); var indices = myGraphDB.DescribeIndex<IEnumerable<IIndexDefinition>>(mySecurityToken, myTransactionToken, request, (stats, definitions) => definitions); if (indices == null) { error = new IndexTypeDoesNotExistException(_TypeName, _IndexName); } if (String.IsNullOrEmpty(_IndexEdition)) { //_IndexEdition = DBConstants.DEFAULTINDEX; } resultingVertices = new List<IVertexView>() { GenerateOutput(indices, _IndexName) }; #endregion if(error != null) return new QueryResult("", SonesGQLConstants.GQL, 0L, ResultType.Failed, resultingVertices, error); else return new QueryResult("", SonesGQLConstants.GQL, 0L, ResultType.Successful, resultingVertices); }
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams) { if (!(myCallingObject is String)) { throw new FunctionParameterTypeMismatchException(typeof(String), myCallingObject.GetType()); } var pos = Convert.ToInt32(myParams[0].Value); StringBuilder resString = new StringBuilder(); bool dontInsert = false; if (pos > (myCallingObject as String).Length) { dontInsert = true; resString.Append((myCallingObject as String).ToString()); } else { resString.Append((myCallingObject as String).ToString().Substring(0, pos)); } foreach (FuncParameter fp in myParams.Skip(1)) { resString.Append(fp.Value as String); } if(!dontInsert) resString.Append((myCallingObject as String).ToString().Substring(pos)); return new FuncParameter(resString.ToString()); }
/// <summary> /// Executes the function on myCallingObject /// </summary> public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams) { var currentInnerEdgeType = ((IOutgoingEdgeDefinition)myAttributeDefinition).InnerEdgeType; if (myCallingObject is IHyperEdge && currentInnerEdgeType.HasProperty("Weight")) { var hyperEdge = myCallingObject as IHyperEdge; if (currentInnerEdgeType.HasProperty("Weight")) { var weightProperty = currentInnerEdgeType.GetPropertyDefinition("Weight"); var maxWeight = hyperEdge.InvokeHyperEdgeFunc<Double>(singleEdges => { return Convert.ToDouble( weightProperty.GetValue( singleEdges .OrderByDescending(edge => weightProperty.GetValue(edge)) .First())); }); return new FuncParameter(maxWeight); } } throw new InvalidTypeException(myCallingObject.GetType().ToString(), "Weighted IHyperEdge"); }
public TResult Update <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, Int64 myTransactionToken, RequestUpdate myRequestUpdate, Converter.UpdateResultConverter <TResult> myOutputconverter) { return(_iGraphDB.Update <TResult>(mySecurityToken, myTransactionToken, myRequestUpdate, myOutputconverter)); }
/// <summary> Конструктор класса GraphDBTest /// Создается база данных graphDB и сервер GraphDSServer /// </summary> public GraphDBTest() { var graphDB = new SonesGraphDB(); List<PluginDefinition> QueryLanguagePATH = new List<PluginDefinition>(); Dictionary<string, object> GQL_Parameters = new Dictionary<string, object>(); GQL_Parameters.Add("GraphDB", graphDB); QueryLanguagePATH.Add(new PluginDefinition("sones.gql", GQL_Parameters)); //adding the QueryLanguage as a GraphDSPlugin GraphDSPlugins PluginsAndParameters = new GraphDSPlugins(QueryLanguagePATH); GraphDSServer = new GraphDS_Server(graphDB, PluginsAndParameters); SecToken = GraphDSServer.LogOn(new UserPasswordCredentials("User", "test")); TransactionID = GraphDSServer.BeginTransaction(SecToken); edge_list = new List<List< KeyValuePair<long, Int32> >>(); Dictionary<string, object> RestParameter = new Dictionary<string, object>(); RestParameter.Add("IPAddress", IPAddress.Any); RestParameter.Add("Port", 9975); RestParameter.Add("Username", "test"); RestParameter.Add("Password", "test"); GraphDSServer.StartService("sones.RESTService", RestParameter); }
public TResult GetAllEdgeTypes <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, Int64 myTransactionToken, RequestGetAllEdgeTypes myRequestGetAllEdgeTypes, Converter.GetAllEdgeTypesResultConverter <TResult> myOutputconverter) { return(_iGraphDB.GetAllEdgeTypes <TResult>(mySecurityToken, myTransactionToken, myRequestGetAllEdgeTypes, myOutputconverter)); }
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams) { if (myCallingObject is IHyperEdge) { return new FuncParameter((UInt64)((IHyperEdge)myCallingObject).GetAllEdges().Count()); } else if (myCallingObject is ISingleEdge) { UInt64 count = 1; return new FuncParameter(count); } else if (myCallingObject is IncomingEdgeCollection) { return new FuncParameter((UInt64)(myCallingObject as IncomingEdgeCollection).LongCount()); } else if (myCallingObject is IEnumerable<long>) { return new FuncParameter((UInt64)(myCallingObject as IEnumerable<long>).LongCount()); } else if (myCallingObject is IEnumerable<IVertex>) { return new FuncParameter((UInt64)(myCallingObject as IEnumerable<IVertex>).LongCount()); } else { throw new UnknownDBException("Unexpected input for COUNT aggregate."); } }
public TResult RebuildIndices <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, Int64 myTransactionToken, RequestRebuildIndices myRequestRebuildIndices, Converter.RebuildIndicesResultConverter <TResult> myOutputconverter) { return(_iGraphDB.RebuildIndices <TResult>(mySecurityToken, myTransactionToken, myRequestRebuildIndices, myOutputconverter)); }
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken) { _queryString = myQuery; QueryResult result; try { result = myGraphDB.Insert<QueryResult>( mySecurityToken, myTransactionToken, CreateRequest(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken), CreateQueryResult); } catch (ASonesException e) { result = new QueryResult(_queryString, SonesGQLConstants.GQL, 0, ResultType.Failed, null, e); } return result; }
public override IEnumerable<IVertex> GetVertices(RequestGetVertices _request, Int64 Int64, SecurityToken SecurityToken) { #region case 1 - Expression if (_request.Expression != null) { if (!_queryPlanManager.IsValidExpression(_request.Expression)) { throw new InvalidExpressionException(_request.Expression); } } #endregion #region case 2 - No Expression else if (_request.VertexTypeName != null) { //2.1 typeName as string _vertexTypeManager.CheckManager.GetType(_request.VertexTypeName, Int64, SecurityToken); } else { //2.2 type as id _vertexTypeManager.CheckManager.GetType(_request.VertexTypeID, Int64, SecurityToken); } #endregion return null; }
public TResult DropEdgeType <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, Int64 myTransactionToken, RequestDropEdgeType myRequestDropType, Converter.DropEdgeTypeResultConverter <TResult> myOutputconverter) { return(_iGraphDB.DropEdgeType <TResult>(mySecurityToken, myTransactionToken, myRequestDropType, myOutputconverter)); }
/// <summary> /// Creates a query plan using a logic expression /// </summary> /// <param name="myExpression">The logic expression</param> /// <param name="myIsLongRunning">Determines whether it is anticipated that the request could take longer</param> /// <param name="myTransaction">The current transaction token</param> /// <param name="mySecurity">The current security token</param> /// <returns>A query plan</returns> public IQueryPlan CreateQueryPlan(IExpression myExpression, Boolean myIsLongRunning, Int64 myTransaction, SecurityToken mySecurity) { IQueryPlan result; switch (myExpression.TypeOfExpression) { case TypeOfExpression.Binary: result = GenerateFromBinaryExpression((BinaryExpression) myExpression, myIsLongRunning, myTransaction, mySecurity); break; case TypeOfExpression.Unary: result = GenerateFromUnaryExpression((UnaryExpression)myExpression, myTransaction, mySecurity); break; case TypeOfExpression.Property: result = GenerateFromPropertyExpression((PropertyExpression)myExpression, myTransaction, mySecurity); break; default: throw new ArgumentOutOfRangeException(); } return result; }
public TResult Insert <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, Int64 myTransactionToken, RequestInsertVertex myRequestInsert, Converter.InsertResultConverter <TResult> myOutputconverter) { return(_iGraphDB.Insert <TResult>(mySecurityToken, myTransactionToken, myRequestInsert, myOutputconverter)); }
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, TransactionToken myTransactionToken) { Query = myQuery; var indexDef = new IndexPredefinition(_IndexName); indexDef.SetIndexType(_IndexType); indexDef.SetVertexType(_DBType); indexDef.SetEdition(_IndexEdition); //to be indices attributes foreach (var aIndexedProperty in _AttributeList) { indexDef.AddProperty(aIndexedProperty.IndexAttribute.ContentString); } //options for the index if (_options != null) { foreach (var aKV in _options) { indexDef.AddOption(aKV.Key, aKV.Value); } } return myGraphDB.CreateIndex<QueryResult>(mySecurityToken, myTransactionToken, new RequestCreateIndex(indexDef), GenerateResult); }
public IVertex AddVertex(RequestInsertVertex myInsertDefinition, TransactionToken myTransaction, SecurityToken mySecurity) { IVertexType vertexType = GetVertexType(myInsertDefinition.VertexTypeName, myTransaction, mySecurity); if (vertexType.IsAbstract) throw new AbstractConstraintViolationException(myInsertDefinition.VertexTypeName); ConvertUnknownProperties(myInsertDefinition, vertexType); ConvertDefaultValues(myInsertDefinition, vertexType); if (myInsertDefinition.OutgoingEdges != null) CheckOutgoingEdges(myInsertDefinition.OutgoingEdges, vertexType); if (myInsertDefinition.StructuredProperties != null) { CheckAddStructuredProperties(myInsertDefinition.StructuredProperties, vertexType); } CheckMandatoryConstraint(myInsertDefinition, vertexType); if (myInsertDefinition.BinaryProperties != null) CheckAddBinaryProperties(myInsertDefinition, vertexType); return null; }
public TResult CreateIndex <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, Int64 myTransactionToken, RequestCreateIndex myRequestCreateIndex, Converter.CreateIndexResultConverter <TResult> myOutputconverter) { return(_iGraphDB.CreateIndex <TResult>(mySecurityToken, myTransactionToken, myRequestCreateIndex, myOutputconverter)); }
public List<Int64> Clear(SecurityToken mySecurityToken, Int64 myTransactionToken) { var Request = ServiceRequestFactory.MakeRequestClear(); var Response = this.GraphDS.Clear(mySecurityToken, myTransactionToken, Request, ServiceReturnConverter.ConvertOnlyVertexTypeIDs); return Response.ToList(); }
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, TransactionToken myTransactionToken) { var sw = Stopwatch.StartNew(); QueryResult result = null; if (_DumpFormat.ToString().ToUpper().Equals("GQL")) { var plugin = myPluginManager.GetAndInitializePlugin<IGraphDBExport>("GQLEXPORT"); if (plugin != null) { result = plugin.Export(_DumpDestination, _DumpableGrammar, myGraphDB, myGraphQL, mySecurityToken, myTransactionToken, _TypesToDump, _DumpType); } } sw.Stop(); if (result != null) { return new QueryResult(myQuery, _DumpFormat.ToString(), (ulong)sw.ElapsedMilliseconds, result.TypeOfResult, result.Vertices, result.Error); } else return null; }
public TResult Truncate <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.RequestTruncate myRequestTruncate, sones.GraphDB.Request.Converter.TruncateResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); _GraphDSService.TruncateVertexType(mySecurityToken, myTransactionID, myRequestTruncate.VertexTypeName); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)))); }
public ServiceVertexType AlterVertexType(SecurityToken mySecurityToken, Int64 myTransactionToken, ServiceVertexType myVertexType, ServiceAlterVertexChangeset myChangeset) { var Request = ServiceRequestFactory.MakeRequestAlterVertexType(myVertexType, myChangeset); var Response = this.GraphDS.AlterVertexType<IVertexType>(mySecurityToken, myTransactionToken, Request, ServiceReturnConverter.ConvertOnlyVertexType); return new ServiceVertexType(Response); }
public TResult DropIndex <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestDropIndex myRequestDropIndex, sones.GraphDB.Request.Converter.DropIndexResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); _GraphDSService.DropIndex(mySecurityToken, myTransactionID, new ServiceVertexType(myRequestDropIndex.TypeName), myRequestDropIndex.IndexName, myRequestDropIndex.Edition); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)))); }
/// <summary> /// Constructor /// </summary> public CommonUsageGraph(IGraphDB myIGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken) : this() { _iGraphDB = myIGraphDB; _securityToken = mySecurityToken; _transactionToken = myTransactionToken; _Levels = new Dictionary<int, IExpressionLevel>(); }
public TResult DropEdgeType <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestDropEdgeType myRequestDropType, sones.GraphDB.Request.Converter.DropEdgeTypeResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); var result = _GraphDSService.DropEdgeType(mySecurityToken, myTransactionID, new ServiceEdgeType(myRequestDropType.TypeName)); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), result)); }
public override IEnumerable<IVertex> GetVertices(IVertexType myVertexType, Int64 myTransaction, SecurityToken mySecurity, Boolean myIncludeSubtypes) { if (myVertexType == null) { throw new ArgumentNullException("myVertexType"); } return null; }
public TResult Clear <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestClear myRequestClear, sones.GraphDB.Request.Converter.ClearResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); var result = _GraphDSService.Clear(mySecurityToken, myTransactionID); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), result)); }
public TResult RebuildIndices <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestRebuildIndices myRequestRebuildIndices, sones.GraphDB.Request.Converter.RebuildIndicesResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); _GraphDSService.RebuildIndices(mySecurityToken, myTransactionID, myRequestRebuildIndices.Types.ToList()); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)))); }
public TResult GetVertexCount <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestGetVertexCount myRequestGetVertexCount, sones.GraphDB.Request.Converter.GetVertexCountResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); var vertexCount = _GraphDSService.GetVertexCount(mySecurityToken, myTransactionID, new ServiceVertexType(myRequestGetVertexCount.VertexTypeName)); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), vertexCount)); }
public LevelKey(IEnumerable<EdgeKey> myEdgeKey, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken) { Edges = new List<EdgeKey>(); foreach (var aEdgeKey in myEdgeKey) { if (aEdgeKey.IsAttributeSet) { var vertexType = myGraphDB.GetVertexType<IVertexType> (mySecurityToken, myTransactionToken, new RequestGetVertexType(aEdgeKey.VertexTypeID), (stats, type) => type); var attribute = vertexType.GetAttributeDefinition(aEdgeKey.AttributeID); if (attribute != null && attribute.Kind != AttributeType.Property) { //so there is an edge Edges.Add(aEdgeKey); Level++; AddHashCodeFromSingleEdge(ref _hashcode, aEdgeKey); } else { if (Level == 0) { var newEdgeKey = new EdgeKey(aEdgeKey.VertexTypeID); Edges.Add(newEdgeKey); AddHashCodeFromSingleEdge(ref _hashcode, newEdgeKey); break; } else { break; } } } else { if (Level == 0) { Edges.Add(aEdgeKey); AddHashCodeFromSingleEdge(ref _hashcode, aEdgeKey); break; } else { break; } } } }
public override QueryResult GetResult( GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken) { var resultingVertices = new List<IVertexView>(); ASonesException error = null; if (!String.IsNullOrEmpty(_EdgeName)) { #region Specific edge var request = new RequestGetEdgeType(_EdgeName); var edge = myGraphDB.GetEdgeType<IEdgeType>(mySecurityToken, myTransactionToken, request, (stats, edgeType) => edgeType); if (edge != null) { resultingVertices = new List<IVertexView>() { GenerateOutput(edge, _EdgeName) }; } else { error = new EdgeTypeDoesNotExistException(_EdgeName); } #endregion } else { #region All edges var resultingReadouts = new List<IVertexView>(); var request = new RequestGetAllEdgeTypes(); foreach (var edge in myGraphDB.GetAllEdgeTypes<IEnumerable<IEdgeType>>(mySecurityToken, myTransactionToken, request, (stats, edgeTypes) => edgeTypes)) { resultingReadouts.Add(GenerateOutput(edge, edge.Name)); } #endregion } if(error != null) return new QueryResult("", SonesGQLConstants.GQL, 0L, ResultType.Failed, resultingVertices, error); else return new QueryResult("", SonesGQLConstants.GQL, 0L, ResultType.Successful, resultingVertices); }
/// <summary> /// This will receive a query and store it to the log /// </summary> public IQueryResult Query(sones.Library.Commons.Security.SecurityToken mySecurityToken, Int64 myTransactionID, string myQueryString, string myQueryLanguageName) { byte[] Part1, Part2, Part3, Part4 = null; System.IO.MemoryStream stream = new System.IO.MemoryStream(); System.Runtime.Serialization.Formatters.Binary.BinaryFormatter Formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter(); #region Generate byte represenation of query if (mySecurityToken != null) { Formatter.Serialize(stream, mySecurityToken); } else { Formatter.Serialize(stream, new SecurityToken()); } Part1 = stream.ToArray(); if (myTransactionID != null) { Formatter.Serialize(stream, myTransactionID); } else { Formatter.Serialize(stream, long.MaxValue); } Part2 = stream.ToArray(); if (myQueryString != null) { Formatter.Serialize(stream, myQueryString); } else { Formatter.Serialize(stream, ""); } Part3 = stream.ToArray(); if (myQueryLanguageName != null) { Formatter.Serialize(stream, myQueryLanguageName); } else { Formatter.Serialize(stream, ""); } Part4 = stream.ToArray(); #endregion byte[] Data = new byte[Part1.Length + Part2.Length + Part3.Length + Part4.Length]; System.Buffer.BlockCopy(Part1, 0, Data, 0, Part1.Length); System.Buffer.BlockCopy(Part2, 0, Data, Part1.Length, Part2.Length); System.Buffer.BlockCopy(Part3, 0, Data, Part1.Length + Part2.Length, Part3.Length); System.Buffer.BlockCopy(Part4, 0, Data, Part1.Length + Part2.Length + Part3.Length, Part4.Length); Write(Data); return(null); }
public SecurityToken LogOn(IUserCredentials myUserCredentials) { if (myUserCredentials is RemoteUserPasswordCredentials) { _SecurityToken = _GraphDSService.LogOn(((RemoteUserPasswordCredentials)myUserCredentials).ServiceObject); return(_SecurityToken); } return(null); }
/// <summary> /// Creates a new comparative operator /// </summary> /// <param name="myProperty">The interesting property</param> /// <param name="myConstant">The constant value</param> /// <param name="myIsLongrunning">Determines whether it is anticipated that the request could take longer</param> /// <param name="mySecurityToken">The current security token</param> /// <param name="myTransactionToken">The current transaction token</param> /// <param name="myVertexStore">The vertex store that is needed to load the vertices</param> protected AComparativeOperator(QueryPlanProperty myProperty, ILiteralExpression myConstant, Boolean myIsLongrunning, SecurityToken mySecurityToken, Int64 myTransactionToken, IVertexStore myVertexStore) { _property = myProperty; _constant = myConstant; _isLongrunning = myIsLongrunning; _vertexStore = myVertexStore; _securityToken = mySecurityToken; _transactionToken = myTransactionToken; }
public TResult DescribeIndices <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestDescribeIndex myRequestDescribeIndex, sones.GraphDB.Request.Converter.DescribeIndicesResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); var svcIndices = _GraphDSService.DescribeIndices(mySecurityToken, myTransactionID, myRequestDescribeIndex.TypeName); var indices = svcIndices.Select(x => new RemoteIndexDefinition(x, this)); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), indices)); }
public TResult GetAllEdgeTypes <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestGetAllEdgeTypes myRequestGetAllEdgeTypes, sones.GraphDB.Request.Converter.GetAllEdgeTypesResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); var svcEdgeTypes = _GraphDSService.GetAllEdgeTypes(mySecurityToken, myTransactionID, myRequestGetAllEdgeTypes.Edition); var edgeTypes = svcEdgeTypes.Select(x => new RemoteEdgeType(x, this)); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), edgeTypes)); }
public TResult CreateVertexType <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestCreateVertexType myRequestCreateVertexType, sones.GraphDB.Request.Converter.CreateVertexTypeResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); var svcVertexType = _GraphDSService.CreateVertexType(mySecurityToken, myTransactionID, new ServiceVertexTypePredefinition(myRequestCreateVertexType.VertexTypeDefinition)); var vertexType = new RemoteVertexType(svcVertexType, this); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), vertexType)); }
public TResult CreateIndex <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestCreateIndex myRequestCreateIndex, sones.GraphDB.Request.Converter.CreateIndexResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); var svcIndexDef = _GraphDSService.CreateIndex(mySecurityToken, myTransactionID, new ServiceIndexPredefinition(myRequestCreateIndex.IndexDefinition)); var indexDef = new RemoteIndexDefinition(svcIndexDef, this); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), indexDef)); }
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken) { _query = myQuery; return myGraphDB.AlterVertexType<QueryResult>( mySecurityToken, myTransactionToken, CreateNewRequest(myGraphDB, myPluginManager, mySecurityToken, myTransactionToken), CreateOutput); }
public List<TypeWithProperty> StringParser(String current_string, IGraphDB myDB, SecurityToken mySecurityToken, Int64 myTransactionToken) { current_string = current_string.Replace(" ",""); List<TypeWithProperty> list = new List<TypeWithProperty>(); bool endFlag = false; int EndPos = 0; do { EndPos = current_string.IndexOf(','); if (EndPos == -1) { EndPos = current_string.Length; endFlag = true; } var typeVertexString = current_string.Substring(0, current_string.IndexOf('.')); IVertexType typeVertex = null; try { typeVertex = myDB.GetVertexType<IVertexType>( mySecurityToken, myTransactionToken, new sones.GraphDB.Request.RequestGetVertexType(typeVertexString), (statistics, type) => type); } catch { throw new InvalidFunctionParameterException("edgeType", "Object reference not set to an instance of an object.", "null"); } var propertyIDString = current_string.Substring(current_string.IndexOf('.') + 1, EndPos - current_string.IndexOf('.') - 1); var property = typeVertex.GetPropertyDefinition(propertyIDString); if (property==null) throw new InvalidFunctionParameterException("Property", "Property: " + propertyIDString + " not exist in VertexType:" + typeVertexString, "null"); TypeWithProperty value = new TypeWithProperty(); value.propertyDifinition = property; value.type = typeVertex; if (!list.Contains(value)) list.Add(value); if (!endFlag) current_string = current_string.Substring(EndPos + 1); } while (endFlag != true); return list; }
public override IEnumerable<IVertexView> GetResult( GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken) { var resultingVertices = new List<IVertexView>(); if (!String.IsNullOrEmpty(_EdgeName)) { #region Specific edge var request = new RequestGetEdgeType(_EdgeName); var edge = myGraphDB.GetEdgeType<IEdgeType>(mySecurityToken, myTransactionToken, request, (stats, edgeType) => edgeType); if (edge != null) { resultingVertices = new List<IVertexView>() { GenerateOutput(edge, _EdgeName) }; } else { throw new EdgeTypeDoesNotExistException(_EdgeName); } #endregion } else { #region All edges var resultingReadouts = new List<IVertexView>(); var request = new RequestGetAllEdgeTypes(); foreach (var edge in myGraphDB.GetAllEdgeTypes<IEnumerable<IEdgeType>>(mySecurityToken, myTransactionToken, request, (stats, edgeTypes) => edgeTypes)) { resultingReadouts.Add(GenerateOutput(edge, edge.Name)); } #endregion } return resultingVertices; }
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams) { if (myCallingObject != null) { return new FuncParameter(true); } else { return new FuncParameter(false); } }
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken, params FuncParameter[] myParams) { if (!(myCallingObject is String)) { throw new FunctionParameterTypeMismatchException(typeof(String), myCallingObject.GetType()); } var substring = myCallingObject.ToString().Substring(Convert.ToInt32(myParams[0].Value), Convert.ToInt32(myParams[1].Value)); return new FuncParameter(substring); }
public override IEnumerable<IVertexType> AddVertexTypes(IEnumerable<VertexTypePredefinition> myVertexTypeDefinitions, TransactionToken myTransaction, SecurityToken mySecurity) { #region check arguments myVertexTypeDefinitions.CheckNull("myVertexTypeDefinitions"); #endregion CheckAdd(myVertexTypeDefinitions); return null; }
public TResult AlterEdgeType <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestAlterEdgeType myRequestAlterEdgeType, sones.GraphDB.Request.Converter.AlterEdgeTypeResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); var svcEdgeType = _GraphDSService.AlterEdgeType(mySecurityToken, myTransactionID, new ServiceEdgeType(myRequestAlterEdgeType.TypeName), new ServiceAlterEdgeChangeset(myRequestAlterEdgeType)); var edgeType = new RemoteEdgeType(svcEdgeType, this); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), edgeType)); }
public TResult Delete <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestDelete myRequestDelete, sones.GraphDB.Request.Converter.DeleteResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); var result = _GraphDSService.Delete(mySecurityToken, myTransactionID, new ServiceVertexType(myRequestDelete.ToBeDeletedVertices.VertexTypeName), myRequestDelete.ToBeDeletedVertices.VertexIDs.ToList(), new ServiceDeletePayload(myRequestDelete)); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), result.Item1.Select(x => (IComparable)x), result.Item2.Select(x => (IComparable)x))); }
public QueryResult Import(String myLocation, IGraphDB myGraphDB, IGraphQL myGraphQL, SecurityToken mySecurityToken, TransactionToken myTransactionToken, UInt32 myParallelTasks = 1U, IEnumerable<string> myComments = null, UInt64? myOffset = null, UInt64? myLimit = null, VerbosityTypes myVerbosityType = VerbosityTypes.Silent) { ASonesException error; Stream stream = null; QueryResult result; #region Read querie lines from location try { #region file if (myLocation.ToLower().StartsWith(@"file:\\")) { //lines = ReadFile(location.Substring(@"file:\\".Length)); stream = GetStreamFromFile(myLocation.Substring(@"file:\\".Length)); } #endregion #region http else if (myLocation.ToLower().StartsWith("http://")) { stream = GetStreamFromHttp(myLocation); } #endregion else { error = new InvalidImportLocationException(myLocation, @"file:\\", "http://"); result = new QueryResult("", ImportFormat, 0L, ResultType.Failed, null, error); return result; } #region Start import using the AGraphDBImport implementation and return the result return Import(stream, myGraphDB, myGraphQL, mySecurityToken, myTransactionToken, myParallelTasks, myComments, myOffset, myLimit, myVerbosityType); #endregion } catch (Exception ex) { #region throw new exception error = new ImportFailedException(ex); result = new QueryResult("", ImportFormat, 0L, ResultType.Failed, null, error); return result; #endregion } finally { if (stream != null) { stream.Dispose(); } } #endregion }
public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken, params FuncParameter[] myParams) { if (myCallingObject is String) { return new FuncParameter(((String)myCallingObject).ToLower()); } else { throw new FunctionParameterTypeMismatchException(typeof(String), myCallingObject.GetType()); } }
public TResult Update <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestUpdate myRequestUpdate, sones.GraphDB.Request.Converter.UpdateResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); var svcVertices = _GraphDSService.Update( mySecurityToken, myTransactionID, new ServiceUpdateChangeset(myRequestUpdate)); var vertices = svcVertices.Select(x => new RemoteVertex(x, this)); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), vertices)); }
public List<ServiceEdgeInstance> GetAllOutgoingEdges(SecurityToken mySecurityToken, Int64 myTransToken, ServiceVertexInstance myVertex) { var Request = ServiceRequestFactory.MakeRequestGetVertex(myVertex.TypeID, myVertex.VertexID); var Response = this.GraphDS.GetVertex<IVertex>(mySecurityToken, myTransToken, Request, ServiceReturnConverter.ConvertOnlyVertexInstance); return Response.GetAllOutgoingEdges().Select<Tuple<long, IEdge>, ServiceEdgeInstance>(x => { if (x.Item2 is ISingleEdge) return new ServiceSingleEdgeInstance(x.Item2 as ISingleEdge, x.Item1); else return new ServiceHyperEdgeInstance(x.Item2 as IHyperEdge, x.Item1); }).ToList(); }
public List<ServiceIncomingVerticesContainer> GetAllIncomingVertices(SecurityToken mySecurityToken, Int64 myTransToken, ServiceVertexInstance myVertex) { var Request = ServiceRequestFactory.MakeRequestGetVertex(myVertex.TypeID, myVertex.VertexID); var Response = this.GraphDS.GetVertex<IVertex>(mySecurityToken, myTransToken, Request, ServiceReturnConverter.ConvertOnlyVertexInstance); return Response.GetAllIncomingVertices().Select( x => new ServiceIncomingVerticesContainer { VertexTypeID = x.VertexTypeID, EdgePropertyID = x.EdgePropertyID, IncomingVertices = x.IncomingVertices.Select(y => new ServiceVertexInstance(y)).ToList() } ).ToList(); }
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken) { var sw = Stopwatch.StartNew(); QueryResult result = null; _query = myQuery; String myAction = ""; IEnumerable<IVertex> myToBeUpdatedVertices = null; //prepare var vertexType = myGraphDB.GetVertexType<IVertexType>( mySecurityToken, myTransactionToken, new RequestGetVertexType(_Type), (stats, vtype) => vtype); if (_WhereExpression != null) { //validate _WhereExpression.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, vertexType); //calculate var expressionGraph = _WhereExpression.Calculon(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, new CommonUsageGraph(myGraphDB, mySecurityToken, myTransactionToken), false); //extract myToBeUpdatedVertices = expressionGraph.Select(new LevelKey(vertexType.ID, myGraphDB, mySecurityToken, myTransactionToken), null, true).ToList(); } if (myToBeUpdatedVertices != null && myToBeUpdatedVertices.Count() > 0) { //update result = ProcessUpdate(myToBeUpdatedVertices, myGraphDB, myPluginManager, mySecurityToken, myTransactionToken); myAction = "Updated"; } else { //insert result = ProcessInsert(myGraphDB, myPluginManager, mySecurityToken, myTransactionToken); myAction = "Inserted"; } if (result.Error != null) throw result.Error; sw.Stop(); return GenerateResult(sw.Elapsed.TotalMilliseconds, result, myAction); }
/// <summary> /// Shutdown of this plugin / GraphDS interface handling /// </summary> /// <param name="mySecurityToken"></param> public void Shutdown(sones.Library.Commons.Security.SecurityToken mySecurityToken) { WriteThreadInstance.Shutdown(); if (AsynchronousMode) { while (!WriteThreadInstance.ShutdownComplete) { Thread.Sleep(1); } } // flush and close up if (_AppendLog != null) { _AppendLog.Shutdown(); } }
public TResult GetEdgeType <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestGetEdgeType myRequestGetEdgeType, sones.GraphDB.Request.Converter.GetEdgeTypeResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); ServiceEdgeType svcEdgeType; if (myRequestGetEdgeType.EdgeTypeName != null) { svcEdgeType = _GraphDSService.GetEdgeTypeByName(mySecurityToken, myTransactionID, myRequestGetEdgeType.EdgeTypeName, myRequestGetEdgeType.Edition); } else { svcEdgeType = _GraphDSService.GetEdgeTypeByID(mySecurityToken, myTransactionID, myRequestGetEdgeType.EdgeTypeID, myRequestGetEdgeType.Edition); } var edgeType = new RemoteEdgeType(svcEdgeType, this); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), edgeType)); }
public TResult Insert <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestInsertVertex myRequestInsert, sones.GraphDB.Request.Converter.InsertResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); var svcVertex = _GraphDSService.Insert(mySecurityToken, myTransactionID, myRequestInsert.VertexTypeName, new ServiceInsertPayload(myRequestInsert)); if (myRequestInsert.BinaryProperties != null) { foreach (var item in myRequestInsert.BinaryProperties) { _StreamedService.SetBinaryProperty(new SetBinaryPropertyMessage(item.Key, _SecurityToken, _TransactionToken, svcVertex.VertexID, svcVertex.TypeID, item.Value)); } } var vertex = new RemoteVertex(svcVertex, this); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), vertex)); }
public void Shutdown(sones.Library.Commons.Security.SecurityToken mySecurityToken) { _iGraphDB.Shutdown(mySecurityToken); foreach (var aDrainPipe in _DrainPipes) { aDrainPipe.Value.Shutdown(mySecurityToken); } foreach (var aUsageDataCollector in _usagedatacollectors) { aUsageDataCollector.Value.Shutdown(); } foreach (var aService in _graphDSServices) { aService.Value.Stop(); } }
public TResult GetVertices <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestGetVertices myRequestGetVertices, sones.GraphDB.Request.Converter.GetVerticesResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); List <ServiceVertexInstance> svcVertices; if (myRequestGetVertices.VertexTypeName != null) { svcVertices = _GraphDSService.GetVerticesByType(mySecurityToken, myTransactionID, new ServiceVertexType(myRequestGetVertices.VertexTypeName)); } else if (myRequestGetVertices.VertexTypeID != null) { svcVertices = _GraphDSService.GetVerticesByType(mySecurityToken, myTransactionID, new ServiceVertexType(myRequestGetVertices.VertexTypeID)); } else { svcVertices = _GraphDSService.GetVerticesByExpression(mySecurityToken, myTransactionID, ConvertHelper.ToServiceExpression(myRequestGetVertices.Expression)); } var vertices = svcVertices.Select(x => new RemoteVertex(x, this)); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), vertices)); }
}//method #endregion #region the actual example public void Run() { GraphDSClient = new GraphDS_RemoteClient(new Uri("http://localhost:9970/rpc")); SecToken = GraphDSClient.LogOn(new RemoteUserPasswordCredentials("test", "test")); TransToken = GraphDSClient.BeginTransaction(SecToken); GraphDSClient.Clear <IRequestStatistics>(SecToken, TransToken, new RequestClear(), (Statistics, DeletedTypes) => Statistics); #region create types, create instances and additional work using the GraphDB API GraphDSClient.Clear <IRequestStatistics>(SecToken, TransToken, new RequestClear(), (Statistics, DeletedTypes) => Statistics); Console.WriteLine("Press enter to start example"); Console.ReadLine(); GraphDBRequests(); #endregion //clear the DB (delete all created types) to create them again using the QueryLanguage GraphDSClient.Clear <IRequestStatistics>(SecToken, TransToken, new RequestClear(), (Statistics, DeletedTypes) => Statistics); #region create some types and insert values using the SonesQueryLanguage GraphQLQueries(); #endregion #region make some SELECTS SELECTS(); #endregion Console.WriteLine(); Console.WriteLine("Finished Example. Type a key to finish!"); Console.ReadKey(); }
public void RollbackTransaction(sones.Library.Commons.Security.SecurityToken mySecurityToken, Int64 myTransactionToken) { _iGraphDB.RollbackTransaction(mySecurityToken, myTransactionToken); }
public void LogOff(sones.Library.Commons.Security.SecurityToken toBeLoggedOfToken) { _iGraphDB.LogOff(toBeLoggedOfToken); }