public GremlinQueryExecutionPipelineImpl( IGremlinQuerySerializer serializer, IGremlinQueryExecutor executor, IGremlinQueryExecutionResultDeserializer deserializer) { Executor = executor; Serializer = serializer; Deserializer = deserializer; }
public static IGremlinQuerySerializer ToGroovy(this IGremlinQuerySerializer serializer, GroovyFormatting formatting = GroovyFormatting.BindingsOnly) { return(serializer .Select(serialized => serialized switch { GroovyGremlinQuery serializedQuery => formatting == GroovyFormatting.AllowInlining ? serializedQuery.Inline() : serializedQuery, Bytecode byteCode => byteCode.ToGroovy(formatting), _ => throw new NotSupportedException($"Can't convert serialized query of type {serialized.GetType()} to {nameof(GroovyGremlinQuery)}.") }));
public static IGremlinQuerySerializer ToGroovy(this IGremlinQuerySerializer serializer) { return(serializer .Select(serialized => { return serialized switch { GroovyGremlinQuery serializedQuery => serializedQuery, Bytecode bytecode => bytecode.ToGroovy(), _ => throw new NotSupportedException($"Can't convert serialized query of type {serialized.GetType()} to {nameof(GroovyGremlinQuery)}.") }; })); }
public GremlinQueryEnvironmentImpl( IGraphModel model, IGremlinQuerySerializer serializer, IGremlinQueryExecutor executor, IGremlinQueryExecutionResultDeserializer deserializer, IGremlinQueryDebugger debugger, IFeatureSet featureSet, IGremlinqOptions options, ILogger logger) { Model = model; Logger = logger; Options = options; Executor = executor; Debugger = debugger; FeatureSet = featureSet; Serializer = serializer; Deserializer = deserializer; }
public static IGremlinQuerySerializer UseCosmosDbWorkarounds(this IGremlinQuerySerializer serializer) { return(serializer .OverrideFragmentSerializer <CosmosDbKey>((key, overridden, recurse) => recurse(key.PartitionKey != null ? new[] { key.PartitionKey, key.Id } : (object)key.Id)) .OverrideFragmentSerializer <SkipStep>((step, overridden, recurse) => recurse(new RangeStep(step.Count, -1))) .OverrideFragmentSerializer <LimitStep>((step, overridden, recurse) => { // Workaround for https://feedback.azure.com/forums/263030-azure-cosmos-db/suggestions/33998623-cosmosdb-s-implementation-of-the-tinkerpop-dsl-has if (step.Count > int.MaxValue) { throw new ArgumentOutOfRangeException(nameof(step), "CosmosDb doesn't currently support values for 'Limit' outside the range of a 32-bit-integer."); } return overridden(step); }) .OverrideFragmentSerializer <TailStep>((step, overridden, recurse) => { // Workaround for https://feedback.azure.com/forums/263030-azure-cosmos-db/suggestions/33998623-cosmosdb-s-implementation-of-the-tinkerpop-dsl-has if (step.Count > int.MaxValue) { throw new ArgumentOutOfRangeException(nameof(step), "CosmosDb doesn't currently support values for 'Tail' outside the range of a 32-bit-integer."); } return overridden(step); }) .OverrideFragmentSerializer <RangeStep>((step, overridden, recurse) => { // Workaround for https://feedback.azure.com/forums/263030-azure-cosmos-db/suggestions/33998623-cosmosdb-s-implementation-of-the-tinkerpop-dsl-has if (step.Lower > int.MaxValue || step.Upper > int.MaxValue) { throw new ArgumentOutOfRangeException(nameof(step), "CosmosDb doesn't currently support values for 'Range' outside the range of a 32-bit-integer."); } return overridden(step); }) .OverrideFragmentSerializer <long>((l, overridden, recurse) => { // Workaround for https://feedback.azure.com/forums/263030-azure-cosmos-db/suggestions/33998623-cosmosdb-s-implementation-of-the-tinkerpop-dsl-has return recurse((int)l); })); }
public static IGremlinQueryEnvironment UseSerializer(this IGremlinQueryEnvironment environment, IGremlinQuerySerializer serializer) => environment.ConfigureSerializer(_ => serializer);
public static IGremlinQuerySerializer Select(this IGremlinQuerySerializer serializer, Func <object, object> projection) { return(new SelectGremlinQuerySerializer(serializer, projection)); }
public SelectGremlinQuerySerializer(IGremlinQuerySerializer baseSerializer, Func <object, object> projection) { _baseSerializer = baseSerializer; _projection = projection; }
public static IGremlinQuerySerializer ToGroovy(this IGremlinQuerySerializer serializer) { return(serializer .Select(serialized => { if (serialized is GroovySerializedGremlinQuery serializedQuery) { return serializedQuery; } var builder = new StringBuilder(); var bindings = new Dictionary <object, string>(); var variables = new Dictionary <string, object>(); void Append(object obj, bool allowEnumerableExpansion = false) { if (obj is Bytecode bytecode) { if (builder.Length > 0) { builder.Append("__"); } foreach (var instruction in bytecode.StepInstructions) { builder.Append(builder.Length != 0 ? $".{instruction.OperatorName}(" : $"{instruction.OperatorName}("); Append(instruction.Arguments, true); builder.Append(")"); } } else if (obj is P p) { if (p.Value is P p1) { Append(p1); builder.Append($".{p.OperatorName}("); Append(p.Other); builder.Append(")"); } else { builder.Append($"{p.OperatorName}("); Append(p.Value, true); builder.Append(")"); } } else if (obj is EnumWrapper t) { builder.Append($"{t.EnumValue}"); } else if (obj is ILambda lambda) { builder.Append($"{{{lambda.LambdaExpression}}}"); } else if (obj is string str && allowEnumerableExpansion) { Append(str); }
public static IGremlinQuerySerializer UseDefaultGremlinStepSerializationHandlers(this IGremlinQuerySerializer serializer) { return(serializer .OverrideFragmentSerializer <AddEStep>((step, overridden, recurse) => CreateInstruction("addE", recurse, step.Label)) .OverrideFragmentSerializer <AddEStep.ToLabelStep>((step, overridden, recurse) => CreateInstruction("to", recurse, step.StepLabel)) .OverrideFragmentSerializer <AddEStep.ToTraversalStep>((step, overridden, recurse) => CreateInstruction("to", recurse, step.Traversal)) .OverrideFragmentSerializer <AddVStep>((step, overridden, recurse) => CreateInstruction("addV", recurse, step.Label)) .OverrideFragmentSerializer <AndStep>((step, overridden, recurse) => CreateInstruction("and", recurse, step.Traversals.SelectMany(FlattenLogicalTraversals <AndStep>).ToArray())) .OverrideFragmentSerializer <AggregateStep>((step, overridden, recurse) => CreateInstruction("aggregate", recurse, step.StepLabel)) .OverrideFragmentSerializer <AsStep>((step, overridden, recurse) => CreateInstruction("as", recurse, step.StepLabels)) .OverrideFragmentSerializer <BarrierStep>((step, overridden, recurse) => CreateInstruction("barrier", recurse)) .OverrideFragmentSerializer <BothStep>((step, overridden, recurse) => CreateInstruction("both", recurse, step.Labels)) .OverrideFragmentSerializer <BothEStep>((step, overridden, recurse) => CreateInstruction("bothE", recurse, step.Labels)) .OverrideFragmentSerializer <BothVStep>((step, overridden, recurse) => CreateInstruction("bothV", recurse)) .OverrideFragmentSerializer <BuildStep>((step, overridden, recurse) => CreateInstruction("build", recurse)) .OverrideFragmentSerializer <ChooseOptionTraversalStep>((step, overridden, recurse) => CreateInstruction("choose", recurse, step.Traversal)) .OverrideFragmentSerializer <ChoosePredicateStep>((step, overridden, recurse) => { return step.ElseTraversal.Match( elseTraversal => CreateInstruction( "choose", recurse, step.Predicate, step.ThenTraversal, elseTraversal), () => CreateInstruction( "choose", recurse, step.Predicate, step.ThenTraversal)); }) .OverrideFragmentSerializer <ChooseTraversalStep>((step, overridden, recurse) => { return step.ElseTraversal.Match( elseTraversal => CreateInstruction( "choose", recurse, step.IfTraversal, step.ThenTraversal, elseTraversal), () => CreateInstruction( "choose", recurse, step.IfTraversal, step.ThenTraversal)); }) .OverrideFragmentSerializer <CoalesceStep>((step, overridden, recurse) => CreateInstruction("coalesce", recurse, step.Traversals.ToArray())) .OverrideFragmentSerializer <CoinStep>((step, overridden, recurse) => CreateInstruction("coin", recurse, step.Probability)) .OverrideFragmentSerializer <ConstantStep>((step, overridden, recurse) => CreateInstruction("constant", recurse, step.Value)) .OverrideFragmentSerializer <CountStep>((step, overridden, recurse) => step.Scope.Equals(Scope.Local) ? CreateInstruction("count", recurse, step.Scope) : CreateInstruction("count", recurse)) .OverrideFragmentSerializer <CreateStep>((step, overridden, recurse) => CreateInstruction("create", recurse)) .OverrideFragmentSerializer <DedupStep>((step, overridden, recurse) => CreateInstruction("dedup", recurse)) .OverrideFragmentSerializer <DropStep>((step, overridden, recurse) => CreateInstruction("drop", recurse)) .OverrideFragmentSerializer <EdgesStep>((step, overridden, recurse) => CreateInstruction("edges", recurse, step.Traversal)) .OverrideFragmentSerializer <EmitStep>((step, overridden, recurse) => CreateInstruction("emit", recurse)) .OverrideFragmentSerializer <EnumWrapper>((enumValue, overridden, recurse) => enumValue) .OverrideFragmentSerializer <EStep>((step, overridden, recurse) => CreateInstruction("E", recurse, step.Ids)) .OverrideFragmentSerializer <ExplainStep>((step, overridden, recurse) => CreateInstruction("explain", recurse)) .OverrideFragmentSerializer <FoldStep>((step, overridden, recurse) => CreateInstruction("fold", recurse)) .OverrideFragmentSerializer <FilterStep>((step, overridden, recurse) => CreateInstruction("filter", recurse, step.Lambda)) .OverrideFragmentSerializer <FlatMapStep>((step, overridden, recurse) => CreateInstruction("flatMap", recurse, step.Traversal)) .OverrideFragmentSerializer <FromLabelStep>((step, overridden, recurse) => CreateInstruction("from", recurse, step.StepLabel)) .OverrideFragmentSerializer <FromTraversalStep>((step, overridden, recurse) => CreateInstruction("from", recurse, step.Traversal)) .OverrideFragmentSerializer <GroupStep>((step, overridden, recurse) => CreateInstruction("group", recurse)) .OverrideFragmentSerializer <GroupStep.ByTraversalStep>((step, overridden, recurse) => CreateInstruction("by", recurse, step.Traversal)) .OverrideFragmentSerializer <HasStep>((step, overridden, recurse) => { if (step.Value is P p1 && p1.EqualsConstant(false)) { return recurse(NoneStep.Instance); } var stepName = "has"; var argument = (object?)step.Value; if (argument is P p2) { if (p2.EqualsConstant(true)) { argument = null; } else { if (p2.Value == null) { if (p2.OperatorName == "eq") { stepName = "hasNot"; } else if (p2.OperatorName == "neq") { argument = null; } } if (p2.OperatorName == "eq") { argument = p2.Value; } } } return argument != null ? CreateInstruction(stepName, recurse, step.Key, argument) : CreateInstruction(stepName, recurse, step.Key); }) .OverrideFragmentSerializer <HasLabelStep>((step, overridden, recurse) => CreateInstruction("hasLabel", recurse, step.Labels)) .OverrideFragmentSerializer <HasNotStep>((step, overridden, recurse) => CreateInstruction("hasNot", recurse, step.Key)) .OverrideFragmentSerializer <HasValueStep>((step, overridden, recurse) => CreateInstruction( "hasValue", recurse, step.Argument is P p && p.OperatorName == "eq" ? p.Value : step.Argument)) .OverrideFragmentSerializer <IdentityStep>((step, overridden, recurse) => CreateInstruction("identity", recurse)) .OverrideFragmentSerializer <IdStep>((step, overridden, recurse) => CreateInstruction("id", recurse)) .OverrideFragmentSerializer <IGremlinQueryBase>((query, overridden, recurse) => { var steps = query.AsAdmin().Steps.HandleAnonymousQueries(); if (query.AsAdmin().Environment.Options.GetValue(WorkaroundTinkerpop2112)) { steps = steps.WorkaroundTINKERPOP_2112(); } var byteCode = new Bytecode(); foreach (var step in steps) { if (recurse(step) is Instruction instruction) { byteCode.StepInstructions.Add(instruction); } } if (query is GremlinQueryBase gremlinQueryBase && gremlinQueryBase.SurfaceVisible) { switch (gremlinQueryBase.Semantics) { case QuerySemantics.Vertex: { byteCode.StepInstructions.AddRange(VertexProjectionInstructions); break; } case QuerySemantics.Edge: { byteCode.StepInstructions.AddRange(EdgeProjectionInstructions); break; } } } return byteCode; }) .OverrideFragmentSerializer <ILambda>((lambda, overridden, recurse) => lambda) .OverrideFragmentSerializer <InjectStep>((step, overridden, recurse) => CreateInstruction("inject", recurse, step.Elements)) .OverrideFragmentSerializer <InEStep>((step, overridden, recurse) => CreateInstruction("inE", recurse, step.Labels)) .OverrideFragmentSerializer <InStep>((step, overridden, recurse) => CreateInstruction("in", recurse, step.Labels)) .OverrideFragmentSerializer <InVStep>((step, overridden, recurse) => CreateInstruction("inV", recurse)) .OverrideFragmentSerializer <IsStep>((step, overridden, recurse) => CreateInstruction( "is", recurse, step.Argument is P p && p.OperatorName == "eq" ? p.Value : step.Argument)) .OverrideFragmentSerializer <KeyStep>((step, overridden, recurse) => CreateInstruction("key", recurse)) .OverrideFragmentSerializer <LabelStep>((step, overridden, recurse) => CreateInstruction("label", recurse)) .OverrideFragmentSerializer <LimitStep>((step, overridden, recurse) => step.Scope.Equals(Scope.Local) ? CreateInstruction("limit", recurse, step.Scope, step.Count) : CreateInstruction("limit", recurse, step.Count)) .OverrideFragmentSerializer <LocalStep>((step, overridden, recurse) => CreateInstruction("local", recurse, step.Traversal)) .OverrideFragmentSerializer <MatchStep>((step, overridden, recurse) => CreateInstruction("match", recurse, step.Traversals.ToArray())) .OverrideFragmentSerializer <MapStep>((step, overridden, recurse) => CreateInstruction("map", recurse, step.Traversal)) .OverrideFragmentSerializer <NoneStep>((step, overridden, recurse) => recurse(GremlinQueryEnvironment.NoneWorkaround)) .OverrideFragmentSerializer <NotStep>((step, overridden, recurse) => { var traversalSteps = step.Traversal.AsAdmin().Steps; return !(traversalSteps.Count > 0 && traversalSteps[traversalSteps.Count - 1] is HasStep hasStep && hasStep.Value is P p && p.EqualsConstant(false)) ? CreateInstruction("not", recurse, step.Traversal) : null; }) .OverrideFragmentSerializer <OptionalStep>((step, overridden, recurse) => CreateInstruction("optional", recurse, step.Traversal)) .OverrideFragmentSerializer <OptionTraversalStep>((step, overridden, recurse) => CreateInstruction("option", recurse, step.Guard ?? Pick.None, step.OptionTraversal)) .OverrideFragmentSerializer <OrderStep>((step, overridden, recurse) => CreateInstruction("order", recurse)) .OverrideFragmentSerializer <OrderStep.ByLambdaStep>((step, overridden, recurse) => CreateInstruction("by", recurse, step.Lambda)) .OverrideFragmentSerializer <OrderStep.ByMemberStep>((step, overridden, recurse) => CreateInstruction("by", recurse, step.Key, step.Order)) .OverrideFragmentSerializer <OrderStep.ByTraversalStep>((step, overridden, recurse) => CreateInstruction("by", recurse, step.Traversal, step.Order)) .OverrideFragmentSerializer <OrStep>((step, overridden, recurse) => CreateInstruction("or", recurse, step.Traversals.SelectMany(FlattenLogicalTraversals <OrStep>).ToArray())) .OverrideFragmentSerializer <OutStep>((step, overridden, recurse) => CreateInstruction("out", recurse, step.Labels)) .OverrideFragmentSerializer <OutEStep>((step, overridden, recurse) => CreateInstruction("outE", recurse, step.Labels)) .OverrideFragmentSerializer <OutVStep>((step, overridden, recurse) => CreateInstruction("outV", recurse)) .OverrideFragmentSerializer <OtherVStep>((step, overridden, recurse) => CreateInstruction("otherV", recurse)) .OverrideFragmentSerializer <P>((p, overridden, recurse) => new P( p.OperatorName, !(p.Value is string) && p.Value is IEnumerable enumerable ? enumerable.Cast <object>().Select(recurse).ToArray() : recurse(p.Value), (P)recurse(p.Other))) .OverrideFragmentSerializer <ProfileStep>((step, overridden, recurse) => CreateInstruction("profile", recurse)) .OverrideFragmentSerializer <PropertiesStep>((step, overridden, recurse) => CreateInstruction("properties", recurse, step.Keys)) .OverrideFragmentSerializer <PropertyStep>((step, overridden, recurse) => { if (T.Id.Equals(step.Key)) { if (!Cardinality.Single.Equals(step.Cardinality ?? Cardinality.Single)) { throw new NotSupportedException("Cannot have an id property on non-single cardinality."); } return CreateInstruction("property", recurse, step.MetaProperties.Prepend(step.Value).Prepend(step.Key).ToArray()); } return (step.Cardinality != null) ? CreateInstruction("property", recurse, step.MetaProperties.Prepend(step.Value).Prepend(step.Key).Prepend(step.Cardinality).ToArray()) : CreateInstruction("property", recurse, step.MetaProperties.Prepend(step.Value).Prepend(step.Key).ToArray()); }) .OverrideFragmentSerializer <ProjectStep.ByTraversalStep>((step, overridden, recurse) => CreateInstruction("by", recurse, step.Traversal)) .OverrideFragmentSerializer <ProjectStep>((step, overridden, recurse) => CreateInstruction("project", recurse, step.Projections)) .OverrideFragmentSerializer <RangeStep>((step, overridden, recurse) => CreateInstruction("range", recurse, step.Lower, step.Upper)) .OverrideFragmentSerializer <RepeatStep>((step, overridden, recurse) => CreateInstruction("repeat", recurse, step.Traversal)) .OverrideFragmentSerializer <SelectStep>((step, overridden, recurse) => CreateInstruction("select", recurse, step.StepLabels)) .OverrideFragmentSerializer <SideEffectStep>((step, overridden, recurse) => CreateInstruction("sideEffect", recurse, step.Traversal)) .OverrideFragmentSerializer <SkipStep>((step, overridden, recurse) => CreateInstruction("skip", recurse, step.Count)) .OverrideFragmentSerializer <SumStep>((step, overridden, recurse) => CreateInstruction("sum", recurse, step.Scope)) .OverrideFragmentSerializer <TextP>((textP, overridden, recurse) => textP) .OverrideFragmentSerializer <TailStep>((step, overridden, recurse) => step.Scope.Equals(Scope.Local) ? CreateInstruction("tail", recurse, step.Scope, step.Count) : CreateInstruction("tail", recurse, step.Count)) .OverrideFragmentSerializer <TimesStep>((step, overridden, recurse) => CreateInstruction("times", recurse, step.Count)) .OverrideFragmentSerializer <Type>((type, overridden, recurse) => type) .OverrideFragmentSerializer <UnfoldStep>((step, overridden, recurse) => CreateInstruction("unfold", recurse)) .OverrideFragmentSerializer <UnionStep>((step, overridden, recurse) => CreateInstruction("union", recurse, step.Traversals.ToArray())) .OverrideFragmentSerializer <UntilStep>((step, overridden, recurse) => CreateInstruction("until", recurse, step.Traversal)) .OverrideFragmentSerializer <ValueStep>((step, overridden, recurse) => CreateInstruction("value", recurse)) .OverrideFragmentSerializer <ValueMapStep>((step, overridden, recurse) => CreateInstruction("valueMap", recurse, step.Keys)) .OverrideFragmentSerializer <ValuesStep>((step, overridden, recurse) => CreateInstruction("values", recurse, step.Keys)) .OverrideFragmentSerializer <VerticesStep>((step, overridden, recurse) => CreateInstruction("vertices", recurse, step.Traversal)) .OverrideFragmentSerializer <VStep>((step, overridden, recurse) => CreateInstruction("V", recurse, step.Ids)) .OverrideFragmentSerializer <WhereTraversalStep>((step, overridden, recurse) => CreateInstruction("where", recurse, step.Traversal)) .OverrideFragmentSerializer <WithStrategiesStep>((step, overridden, recurse) => CreateInstruction("withStrategies", recurse, step.Traversal)) .OverrideFragmentSerializer <WithoutStrategiesStep>((step, overridden, recurse) => CreateInstruction("withoutStrategies", recurse, step.StrategyTypes)) .OverrideFragmentSerializer <WherePredicateStep>((step, overridden, recurse) => CreateInstruction("where", recurse, step.Predicate))); }
public static IGremlinQueryExecutionPipeline UseSerializer(this IGremlinQueryExecutionPipeline pipeline, IGremlinQuerySerializer serializer) { return(pipeline.ConfigureSerializer(_ => serializer)); }
public IGremlinQueryExecutionPipeline UseSerializer(IGremlinQuerySerializer serializer) { return(new GremlinQueryExecutionPipelineImpl(serializer, GremlinQueryExecutor.Invalid, Deserializer)); }