public static IGremlinQuery EmitProperty(this IGremlinQuery query,
string propertyName)
{
IGremlinQuery newQuery = query.AddBlock(string.Format(".{0}", propertyName));
return(newQuery);
}
public IGremlinQuery Apply(IGremlinQuery query)
{
var environment = query.AsAdmin().Environment;
var anonymous = GremlinQuery.Anonymous(environment);
var vertexCriterionTraversal = _vertexCriterion(anonymous.AsAdmin().ChangeQueryType <IVertexGremlinQuery <IVertex> >());
var edgeCriterionTraversal = _edgeCriterion(anonymous.AsAdmin().ChangeQueryType <IEdgeGremlinQuery <IEdge> >());
if (vertexCriterionTraversal.AsAdmin().Steps.Count > 1 || edgeCriterionTraversal.AsAdmin().Steps.Count > 1)
{
var strategy = GremlinQuery.Create <Unit>("SubgraphStrategy", environment)
.AddStep(BuildStep.Instance);
if (vertexCriterionTraversal.AsAdmin().Steps.Count > 1)
{
strategy = strategy.AddStep(new VerticesStep(vertexCriterionTraversal));
}
if (edgeCriterionTraversal.AsAdmin().Steps.Count > 1)
{
strategy = strategy.AddStep(new EdgesStep(edgeCriterionTraversal));
}
return(query
.AddStep(new WithStrategiesStep(strategy.AddStep(CreateStep.Instance))));
}
return(query);
}
public IAsyncEnumerable <TElement> Execute <TElement>(IGremlinQuery <TElement> query)
{
return(AsyncEnumerable
.Return(JToken.Parse(_json))
.GraphsonDeserialize <TElement[]>(new GraphsonDeserializer(query.AsAdmin().Model))
.SelectMany(x => x.ToAsyncEnumerable()));
}
private IGremlinQuery Create()
{
var startQuery = Volatile.Read(ref _startQuery);
if (startQuery != null)
{
return(startQuery);
}
IGremlinQuery ret = GremlinQuery.Create(
Model,
Executor,
Name,
Logger);
if (!ExcludedStrategyNames.IsEmpty)
{
ret = ret.AddStep(new WithoutStrategiesStep(ExcludedStrategyNames.ToArray()));
}
foreach (var strategy in IncludedStrategies)
{
ret = strategy.Apply(ret);
}
return(Interlocked.CompareExchange(ref _startQuery, ret, null) ?? ret);
}
public static IEnumerable <TResult> Table <TResult>(
this IGremlinQuery query) where TResult : new()
{
var newQuery = query.AddBlock(".table(new Table()).cap");
return(new GremlinProjectionEnumerable <TResult>(newQuery));
}
public static IGremlinNodeQuery <TNode> In <TNode>(this IGremlinQuery query, string label, IEnumerable <Filter> filters, StringComparison comparison = StringComparison.OrdinalIgnoreCase)
{
var newQuery = query.AddBlock(@in, label);
var filterQuery = newQuery.AddFilterBlock(string.Empty, filters, comparison);
return(new GremlinNodeEnumerable <TNode>(filterQuery));
}
public static IGremlinRelationshipQuery <TData> OutE <TData>(this IGremlinQuery query, string label, Expression <Func <TData, bool> > filter, StringComparison comparison = StringComparison.OrdinalIgnoreCase)
where TData : class, new()
{
var filters = FilterFormatters.TranslateFilter(filter);
return(query.OutE <TData>(label, filters, comparison));
}
public static IGremlinRelationshipQuery <TData> BackE <TData>(this IGremlinQuery query, string label)
where TData : class, new()
{
var newQuery = query.AddBlock(".back({0})", label);
return(new GremlinRelationshipEnumerable <TData>(newQuery));
}
public GremlinProjectionEnumerable(IGremlinQuery query)
{
queryDeclarations = query.QueryDeclarations;
client = query.Client;
queryText = query.QueryText;
queryParameters = query.QueryParameters;
}
public static IGremlinQuery <T> AddE <T>(this IGremlinQuery query, string edgeName)
where T : new()
{
return(query
.AddStep <T>(new AddEStringGremlinStep(edgeName))
.AddStep <T>(new AddElementPropertiesStep(new T())));
}
public IGremlinQuery Apply(IGremlinQuery query)
{
var admin = query.AsAdmin();
var anonymous = GremlinQuery.Anonymous(admin.Model);
var vertexCriterionTraversal = _vertexCriterion(anonymous.AsAdmin().ChangeQueryType <IVertexGremlinQuery <IVertex> >());
var edgeCriterionTraversal = _edgeCriterion(anonymous.AsAdmin().ChangeQueryType <IEdgeGremlinQuery <IEdge> >());
if (vertexCriterionTraversal.AsAdmin().Steps.Count > 0 || edgeCriterionTraversal.AsAdmin().Steps.Count > 0)
{
var strategy = GremlinQuery.Create <Unit>(admin.Model, GremlinQueryExecutor.Invalid, "SubgraphStrategy")
.AddStep(BuildStep.Instance);
if (vertexCriterionTraversal.AsAdmin().Steps.Count > 0)
{
strategy = strategy.AddStep(new VerticesStep(vertexCriterionTraversal));
}
if (edgeCriterionTraversal.AsAdmin().Steps.Count > 0)
{
strategy = strategy.AddStep(new EdgesStep(edgeCriterionTraversal));
}
return(query
.AddStep(new WithStrategiesStep(strategy.AddStep(CreateStep.Instance))));
}
return(query);
}
private static void Main()
{
ICayleyClient client = new CayleyClient("http://localhost:64210/api/v1/query/gremlin");
IGraphObject g = new GraphObject();
IGremlinQuery query = g.V().Has("name", "Casablanca")
.Out("/film/film/starring")
.Out("/film/performance/actor")
.Out("name")
.All();
CayleyResponse response = client.Send(query);
System.Console.WriteLine(response.Content);
System.Console.WriteLine("--------------------------------------------------------------------------------");
var filmToActor = g.Morphism().Out("/film/film/starring").Out("/film/performance/actor");
IGremlinQuery queryWithMorphism = g.V()
.Has("name", "Casablanca")
.Follow(filmToActor)
.Out("name")
.All();
CayleyResponse morpResponse = client.Send(queryWithMorphism);
System.Console.WriteLine(morpResponse.Content);
System.Console.WriteLine("--------------------------------------------------------------------------------");
string emitQuery = g.Emit(new { name = "John Doe", age = 25, hasRoom = true });
CayleyResponse emitResponse = client.Send(emitQuery);
System.Console.WriteLine(emitResponse.Content);
System.Console.ReadLine();
}
public GremlinRelationshipEnumerable(IGremlinQuery query)
{
client = query.Client;
queryText = query.QueryText;
queryParameters = query.QueryParameters;
queryDeclarations = query.QueryDeclarations;
}
public void Vertext_HasStep_Test()
{
IGremlinQuery query = g.V().Has("name", "Casablanca");
query.Build().Should().NotBeNullOrWhiteSpace();
query.Build().Should().Be(@"g.V().Has('name','Casablanca')");
}
public void Vertext_Out_Step_Test()
{
IGremlinQuery query = g.V().Has("name", "Casablanca").Out("/film/film/starring").Out("/film/performance/actor").Out("name");
query.Build().Should().NotBeNullOrWhiteSpace();
query.Build().Should().Be(@"g.V().Has('name','Casablanca').Out('/film/film/starring').Out('/film/performance/actor').Out('name')");
}
public static IGremlinRelationshipQuery <TData> LoopE <TData>(this IGremlinQuery query, string label, uint loopCount)
where TData : class, new()
{
var newQuery = query.AddBlock(".loop({0}){{ it.loops < {1} }}", label, loopCount);
return(new GremlinRelationshipEnumerable <TData>(newQuery));
}
public static IGremlinRelationshipQuery <TData> ExceptE <TData>(this IGremlinQuery query, string variable)
where TData : class, new()
{
var newQuery = query.AddBlock(string.Format(".except({0})", variable));
return(new GremlinRelationshipEnumerable <TData>(newQuery));
}
static string RebuildParametersAndDeclarations(IGremlinQuery query, Dictionary <string, object> paramsDictionary,
List <string> declarations, ref int nextParamaterIndex, ref string rootQuery)
{
var updatedIndex = nextParamaterIndex;
var paramNames = new List <string>();
declarations.AddRange(query.QueryDeclarations);
var modifiedQueryText = ParameterReferenceRegex.Replace(
query.QueryText,
m =>
{
var parameterIndex = updatedIndex;
updatedIndex++;
var oldParamKey = m.Value;
var newParamKey = string.Format("p{0}", parameterIndex);
paramNames.Add(newParamKey);
paramsDictionary.Add(newParamKey, query.QueryParameters[oldParamKey]);
return(newParamKey);
});
nextParamaterIndex = updatedIndex;
foreach (var declareStatement in query.QueryDeclarations)
{
rootQuery = declareStatement + rootQuery;
modifiedQueryText = modifiedQueryText.Replace(declareStatement, string.Empty);
}
return(modifiedQueryText);
}
public static IGremlinRelationshipQuery <TData> OutE <TData>(this IGremlinQuery query, IEnumerable <Filter> filters, StringComparison comparison = StringComparison.OrdinalIgnoreCase)
where TData : class, new()
{
var newQuery = query.AddFilterBlock(outE, filters, comparison);
return(new GremlinRelationshipEnumerable <TData>(newQuery));
}
public static IGremlinQuery PrependVariablesToBlock(this IGremlinQuery baseQuery, IGremlinQuery query)
{
var declarations = query
.QueryDeclarations
.Aggregate(string.Empty, (current, declaration) => !baseQuery.QueryText.Contains(declaration) ? declaration + current : current);
return new GremlinQuery(baseQuery.Client, declarations + baseQuery.QueryText, baseQuery.QueryParameters, query.QueryDeclarations);
}
public static IGremlinRelationshipQuery IfThenElse(this IGremlinQuery baseQuery, IGremlinQuery ifExpression, IGremlinQuery ifThen, IGremlinQuery ifElse)
{
ifThen = ifThen ?? new GremlinQuery(baseQuery.Client, string.Empty, new Dictionary<string, object>(), new List<string>());
ifElse = ifElse ?? new GremlinQuery(baseQuery.Client, string.Empty, new Dictionary<string, object>(), new List<string>());
if (ifExpression.GetType() == typeof(IdentityPipe))
((IdentityPipe)ifExpression).Client = ifExpression.Client;
if (ifExpression.GetType() == typeof(GremlinIterator))
((GremlinIterator)ifExpression).Client = ifExpression.Client;
if (ifThen.GetType() == typeof(IdentityPipe))
((IdentityPipe)ifThen).Client = ifThen.Client;
if (ifThen.GetType() == typeof(GremlinIterator))
((GremlinIterator)ifThen).Client = ifThen.Client;
if (ifElse.GetType() == typeof(IdentityPipe))
((IdentityPipe)ifElse).Client = ifElse.Client;
if (ifElse.GetType() == typeof(GremlinIterator))
((GremlinIterator)ifElse).Client = ifElse.Client;
baseQuery = baseQuery.AddIfThenElseBlock(".ifThenElse{{{0}}}{{{1}}}{{{2}}}", ifExpression, ifThen, ifElse);
return new GremlinRelationshipEnumerable(baseQuery);
}
public static IGremlinQuery BothE(this IGremlinQuery query,
IEnumerable <Filter> filters, StringComparison comparison = StringComparison.OrdinalIgnoreCase)
{
IGremlinQuery newQuery = query.AddFilterBlock(BOTH_E, filters, comparison);
return(newQuery);
}
public static Task <T> FirstAsync <T>(this IGremlinQuery <T> query, ITypedGremlinQueryProvider provider, CancellationToken ct = default(CancellationToken))
{
return(query
.Limit(1)
.Execute(provider)
.First(ct));
}
public static IGremlinRelationshipQuery <TData> InE <TData>(this IGremlinQuery query)
where TData : class, new()
{
var newQuery = query.AddBlock(inE);
return(new GremlinRelationshipEnumerable <TData>(newQuery));
}
public static IEnumerable <TResult> Table <TResult, TClosure1, TClosure2, TClosure3, TClosure4, TClosure5, TClosure6, TClosure7, TClosure8, TClosure9, TClosure10>(
this IGremlinQuery query,
Expression <Func <TClosure1, object> > closure1,
Expression <Func <TClosure2, object> > closure2,
Expression <Func <TClosure3, object> > closure3,
Expression <Func <TClosure4, object> > closure4,
Expression <Func <TClosure5, object> > closure5,
Expression <Func <TClosure6, object> > closure6,
Expression <Func <TClosure7, object> > closure7,
Expression <Func <TClosure8, object> > closure8,
Expression <Func <TClosure9, object> > closure9,
Expression <Func <TClosure10, object> > closure10) where TResult : new()
{
var newQuery = query.AddBlock(".table(new Table())");
newQuery = AddClosure(newQuery, closure1);
newQuery = AddClosure(newQuery, closure2);
newQuery = AddClosure(newQuery, closure3);
newQuery = AddClosure(newQuery, closure4);
newQuery = AddClosure(newQuery, closure5);
newQuery = AddClosure(newQuery, closure6);
newQuery = AddClosure(newQuery, closure7);
newQuery = AddClosure(newQuery, closure8);
newQuery = AddClosure(newQuery, closure9);
newQuery = AddClosure(newQuery, closure10);
newQuery = newQuery.AddBlock(".cap");
return(new GremlinProjectionEnumerable <TResult>(newQuery));
}
public static IGremlinQuery PrependVariablesToBlock(this IGremlinQuery baseQuery, IGremlinQuery query)
{
var declarations = query
.QueryDeclarations
.Aggregate(string.Empty, (current, declaration) => !baseQuery.QueryText.Contains(declaration) ? declaration + current : current);
return(new GremlinQuery(baseQuery.Client, declarations + baseQuery.QueryText, baseQuery.QueryParameters, query.QueryDeclarations));
}
public static IGremlinRelationshipQuery InE(this IGremlinQuery query, string label)
{
var filter = GetFilter(label);
var newQuery = query.AddFilterBlock(inE, new[] { filter }, StringComparison.Ordinal);
return(new GremlinRelationshipEnumerable(newQuery));
}
public static IGremlinNodeQuery <TNode> In <TNode>(this IGremlinQuery query, string label, Expression <Func <TNode, bool> > filter, StringComparison comparison = StringComparison.OrdinalIgnoreCase)
{
var newQuery = query.AddBlock(@in, label);
var filters = FilterFormatters.TranslateFilter(filter);
var filterQuery = newQuery.AddFilterBlock(string.Empty, filters, comparison);
return(new GremlinNodeEnumerable <TNode>(filterQuery));
}
public static IGremlinNodeQuery <TNode> AggregateV <TNode>(this IGremlinQuery query, string variable)
{
var newQuery = query.AddBlock(string.Format(".aggregate({0})", variable));
newQuery.QueryDeclarations.Add(string.Format("{0} = [];", variable));
newQuery = newQuery.PrependVariablesToBlock(newQuery);
return(new GremlinNodeEnumerable <TNode>(newQuery));
}
public static IGremlinQuery <TTarget> As <TSource, TTarget>(this IGremlinQuery <TSource> query, Func <IGremlinQuery <TSource>, StepLabel <TSource>, IGremlinQuery <TTarget> > continuation)
{
var stepLabel = query.IdentifierFactory.CreateStepLabel <TSource>();
return(continuation(
query.As(stepLabel),
stepLabel));
}
public static IGremlinQuery BothE(this IGremlinQuery query, string label)
{
Filter filter = GetFilter(label);
IGremlinQuery newQuery = query.AddFilterBlock(BOTH_E, new[] { filter }, StringComparison.Ordinal);
return(newQuery);
}
public static IGremlinRelationshipQuery AggregateE(this IGremlinQuery query, string variable)
{
var newQuery = query.AddBlock(string.Format(".aggregate({0})", variable));
newQuery.QueryDeclarations.Add(string.Format("{0} = [];", variable));
newQuery = newQuery.PrependVariablesToBlock(newQuery);
return(new GremlinRelationshipEnumerable(newQuery));
}
public static IGremlinQuery IfThenElse(this IGremlinQuery baseQuery, IGremlinQuery ifExpression,
IGremlinQuery ifThen, IGremlinQuery ifElse)
{
ifThen = ifThen ?? new GremlinQuery(string.Empty, new Dictionary<string, object>(), new List<string>());
ifElse = ifElse ?? new GremlinQuery(string.Empty, new Dictionary<string, object>(), new List<string>());
baseQuery = baseQuery.AddIfThenElseBlock(".ifThenElse{{{0}}}{{{1}}}{{{2}}}", ifExpression, ifThen, ifElse);
return baseQuery;
}
public static IGremlinQuery AddIfThenElseBlock(this IGremlinQuery baseQuery, string ifThenElseText, IGremlinQuery ifExpression, IGremlinQuery ifThen, IGremlinQuery ifElse)
{
var declarations = new List<string>();
var rootQuery = baseQuery.QueryText;
var paramsDictionary = new Dictionary<string, object>(baseQuery.QueryParameters);
var nextParameterIndex = baseQuery.QueryParameters.Count;
var modifiedQueryTextifExpression = RebuildParametersAndDeclarations(ifExpression, paramsDictionary, declarations, ref nextParameterIndex, ref rootQuery);
var modifiedQueryTextifThen = RebuildParametersAndDeclarations(ifThen, paramsDictionary, declarations, ref nextParameterIndex, ref rootQuery);
var modifiedQueryTextifElse = RebuildParametersAndDeclarations(ifElse, paramsDictionary, declarations, ref nextParameterIndex, ref rootQuery);
var newQueryText = string.Format(ifThenElseText, modifiedQueryTextifExpression, modifiedQueryTextifThen, modifiedQueryTextifElse);
return new GremlinQuery(baseQuery.Client, rootQuery + newQueryText, paramsDictionary, declarations);
}
public static IGremlinQuery AddCopySplitBlock(this IGremlinQuery baseQuery, string text, IGremlinQuery[] queries)
{
var declarations = new List<string>();
var rootQuery = baseQuery.QueryText;
var inlineQueries = new List<string>();
var paramsDictionary = new Dictionary<string, object>(baseQuery.QueryParameters);
var nextParameterIndex = baseQuery.QueryParameters.Count;
foreach (var query in queries)
{
var modifiedQueryText = RebuildParametersAndDeclarations(query, paramsDictionary, declarations, ref nextParameterIndex, ref rootQuery);
inlineQueries.Add(modifiedQueryText);
}
var splitBlockQueries = string.Format(text, inlineQueries.ToArray());
return new GremlinQuery(baseQuery.Client, rootQuery + splitBlockQueries, paramsDictionary, declarations);
}
public static IGremlinQuery Follow(this IGremlinQuery query, IGremlinQuery morphismQuery)
{
IGremlinQuery newQuery = query.AddBlock(string.Format(".Follow({0})", morphismQuery.Build()));
return newQuery;
}
static string RebuildParametersAndDeclarations(IGremlinQuery query, Dictionary<string, object> paramsDictionary,
List<string> declarations, ref int nextParamaterIndex, ref string rootQuery)
{
var updatedIndex = nextParamaterIndex;
var paramNames = new List<string>();
declarations.AddRange(query.QueryDeclarations);
var modifiedQueryText = ParameterReferenceRegex.Replace(
query.QueryText,
m =>
{
var parameterIndex = updatedIndex;
updatedIndex++;
var oldParamKey = m.Value;
var newParamKey = string.Format("p{0}", parameterIndex);
paramNames.Add(newParamKey);
paramsDictionary.Add(newParamKey, query.QueryParameters[oldParamKey]);
return newParamKey;
});
nextParamaterIndex = updatedIndex;
foreach (var declareStatement in query.QueryDeclarations)
{
rootQuery = declareStatement + rootQuery;
modifiedQueryText = modifiedQueryText.Replace(declareStatement, string.Empty);
}
return modifiedQueryText;
}
public GremlinNodeEnumerable(IGremlinQuery query)
{
queryText = query.QueryText;
queryParameters = query.QueryParameters;
queryDeclarations = query.QueryDeclarations;
}
public CayleyResponse Send(IGremlinQuery query)
{
string queryText = query.Build();
return Send(queryText);
}
