internal virtual void Compile(FunctionalId functionalId, CompileState state) { if (PersistenceProvider is Neo4jPersistenceProvider neo4j && neo4j.Major < 4) { throw new NotSupportedException("Setting functional-id's on (batch) queries is not supported for Neo4j versions before v4.0.0"); } if (!HasBlueprint41FunctionalidFnNext.Value || !HasBlueprint41FunctionalidFnNextNumeric.Value) { throw new NotSupportedException("Setting functional-id's on (batch) queries is not supported if the Blueprint41 plug-in is not installed or a lower version than 'blueprint41-4.0.2.jar'."); } if (functionalId.Guid == Guid.Empty) { state.Text.Append(FnUuidCreate); } if (functionalId.Format == IdFormat.Hash) { state.Text.AppendFormat(FnFunctionalIdNextHash, functionalId.Label); } else { state.Text.AppendFormat(FnFunctionalIdNextNumeric, functionalId.Label); } }
private void ReportCompileState(CompileState compileState) { if (compileState.HasErrors) { statusBar.BackColor = Color.Red; statusBar.ForeColor = Color.White; statusStrip1.BackColor = Color.Red; statusBar.Text = "Error during compiling"; var sbErr = new StringBuilder("Compiling file: "); sbErr.AppendLine(); sbErr.AppendLine(); foreach (string error in compileState.Errors) { sbErr.AppendLine(error); } errorWindow.Text = sbErr.ToString(); tabControl.SelectedIndex = 1; } else { statusStrip1.BackColor = Color.Green; statusBar.BackColor = Color.Green; statusBar.ForeColor = Color.White; statusBar.Text = "Compiled Succesfully"; errorWindow.Text = ""; } }
internal virtual void Compile(AliasResult alias, CompileState state) { if (alias.AliasName is null) { alias.AliasName = string.Format("n{0}", state.patternSeq++); } string?functionText = alias.FunctionText.Invoke(state.Translator); if (functionText is null) { state.Text.Append(alias.AliasName); } else { string[] compiledArgs = alias.FunctionArgs.Select(arg => state.Preview(GetCompile(arg), state)).ToArray(); string compiledText = string.Format(functionText.Replace("{base}", "{{base}}"), compiledArgs); if ((object?)alias.Alias is not null) { string[] split = compiledText.Split(new string[] { "{base}" }, StringSplitOptions.None); if (split.Length == 0) { throw new NotSupportedException("Functions have to include compilation of the base they are derived from."); } string baseText = state.Preview(alias.Alias.Compile, state); state.Text.Append(string.Join(baseText, split)); } else { state.Text.Append(compiledText); } } }
internal virtual void Compile(RelationFieldResult field, CompileState state) { if (!(field.Alias is null)) { field.Alias.Compile(state); state.Text.Append("."); } state.Text.Append(field.FieldName); }
public LangVisitor(CompileState ts) { if (ts == null) { ts = new CompileState(); } state = ts; context = ts.Context; }
public IValueVisitor(CompileState ts) { if (ts == null) { throw new ArgumentNullException("ts"); } state = ts; context = ts.Context; }
internal virtual void Compile(FieldResult field, CompileState state) { string?functionText = field.FunctionText.Invoke(state.Translator); if (functionText is null) { if ((object?)field.Alias is not null) { field.Alias.Compile(state); if (!string.IsNullOrEmpty(field.FieldName)) { state.Text.Append("."); state.Text.Append(field.FieldName); } } else if (!string.IsNullOrEmpty(field.FieldName)) { state.Text.Append(field.FieldName); } } else { string[] compiledArgs = field.FunctionArgs.Select(arg => state.Preview(GetCompile(arg), state)).ToArray(); string compiledText = string.Format(functionText.Replace("{base}", "{{base}}"), compiledArgs); if ((object?)field.Field is not null) { string[] split = compiledText.Split(new string[] { "{base}" }, StringSplitOptions.None); if (split.Length == 0) { throw new NotSupportedException("Functions have to include compilation of the base they are derived from."); } string baseText = state.Preview(field.Field.Compile, state); state.Text.Append(string.Join(baseText, split)); } else if ((object?)field.Alias is not null) { string[] split = compiledText.Split(new string[] { "{base}" }, StringSplitOptions.None); if (split.Length == 0) { throw new NotSupportedException("Functions have to include compilation of the base they are derived from."); } string baseText = state.Preview(field.Alias.Compile, state); state.Text.Append(string.Join(baseText, split)); } else { state.Text.Append(compiledText); } } }
private Type[] GetKnownTypes() { if (CompiledAssembly == null) { throw new Exception("Assembly is not compiled yet"); } var assemblies = _cSharpProject.MetadataReferences.Select(i => { if (i is PortableExecutableReference g) { return(Sandbox.LoadByFullFilename(g.FilePath).WrappedAssembly); } throw new NotSupportedException(i.GetType().FullName); }).ToList(); assemblies.Add(CompiledAssembly); return(CompileState.GetAllTypes(assemblies)); }
public TranslationInfo ParseCsSource() { // must be public var knownTypes = GetKnownTypes(); CheckRequiredTranslator(); var translationInfo = new TranslationInfo(Sandbox); translationInfo.TranslationAssemblies.AddRange(_translationAssemblies); translationInfo.Prepare(); // Console.WriteLine("======================"); foreach (var tree in ProjectCompilation.SyntaxTrees) { var now = DateTime.Now; Console.WriteLine("parse file {0}", tree.FilePath); var root = (CompilationUnitSyntax)tree.GetRoot(); var state = new CompileState { Context = { RoslynCompilation = ProjectCompilation, RoslynModel = ProjectCompilation.GetSemanticModel(tree) } }; translationInfo.State = state; var langVisitor = new LangVisitor(state) { throwNotImplementedException = true }; state.Context.KnownTypes = knownTypes; var compilationUnit = langVisitor.Visit(root) as CompilationUnit; translationInfo.Compiled.Add(compilationUnit); Console.WriteLine(" {0:0.0} sek", DateTime.Now.Subtract(now).TotalSeconds); } Console.WriteLine("Parsowanie c# skończone, mamy drzewo definicji"); translationInfo.FillClassTranslations(knownTypes); return(translationInfo); }
internal override void Compile(Parameter parameter, CompileState state) { if (!state.Parameters.Contains(parameter)) { state.Parameters.Add(parameter); } if (parameter.IsConstant && !state.Values.Contains(parameter)) { state.Values.Add(parameter); } if (parameter.Name == Parameter.CONSTANT_NAME) { parameter.Name = $"param{state.paramSeq}"; state.paramSeq++; } state.Text.Append("$"); state.Text.Append(parameter.Name); }
internal virtual void Compile(AsResult result, CompileState state) { result.Result.Compile(state); state.Text.Append(" AS "); state.Text.Append(result.AliasName); }
internal virtual void Compile(Node node, CompileState state, bool suppressAliases) { //find the root Node root = node; while (root.FromRelationship is not null) { root = root.FromRelationship.FromNode; } Node?current = root; do { GetDirection(current, state.Text); if (!(current.NodeAlias is null)) { if (current.NodeAlias.AliasName is null) { current.NodeAlias.AliasName = string.Format("n{0}", state.patternSeq++); } if (current.IsReference || current.Neo4jLabel is null) { state.Text.Append("("); state.Text.Append(current.NodeAlias.AliasName); state.Text.Append(")"); } else { state.Text.Append("("); if (!suppressAliases) { state.Text.Append(current.NodeAlias.AliasName); } state.Text.Append(":"); state.Text.Append(current.Neo4jLabel); InlineConditions(current, state); state.Text.Append(")"); } } else { if (current.Neo4jLabel is null) { state.Text.Append("()"); } else { state.Text.Append("("); state.Text.Append(":"); state.Text.Append(current.Neo4jLabel); InlineConditions(current, state); state.Text.Append(")"); } } if (current.ToRelationship is not null) { current.ToRelationship.Compile(state); current = current.ToRelationship.ToNode; if (current is null) { break; } } else { break; } } while (true);
internal virtual void Compile(QueryCondition condition, CompileState state) { condition.Left = Substitute(state, condition.Left); condition.Right = Substitute(state, condition.Right); if (condition.Operator == Operator.Boolean) { state.Text.Append("("); switch (condition.Left) { case BooleanResult boolean: boolean.Compile(state); break; case Literal literal: literal.Compile(state); break; } state.Text.Append(")"); return; } Type?leftType = GetOperandType(condition.Left); Type?rightType = GetOperandType(condition.Right); if (leftType is not null && rightType is not null) { if (leftType != rightType) { if (condition.Operator == Operator.In) { if (rightType.GetInterface(nameof(IEnumerable)) is null) { state.Errors.Add($"The types of the fields {state.Preview(s => CompileOperand(s, condition.Right))} should be a collection."); } rightType = GetEnumeratedType(rightType); } if (GetConversionGroup(leftType, state.TypeMappings) != GetConversionGroup(rightType, state.TypeMappings)) { state.Errors.Add($"The types of the fields {state.Preview(s => CompileOperand(s, condition.Left))} and {state.Preview(s => CompileOperand(s, condition.Right))} are not compatible."); } } } state.Text.Append("("); if (condition.Operator == Operator.Not || condition.Operator == Operator.NotPattern) { state.Text.Append("NOT("); } else if (condition.Operator != Operator.Pattern) { CompileOperand(state, condition.Left); } if (condition.Right is Parameter) { Parameter rightParameter = (Parameter)condition.Right; if (rightParameter.IsConstant && rightParameter.Value is null) { condition.Operator.Compile(state, true); CompileOperand(state, null); } else { condition.Operator.Compile(state, false); CompileOperand(state, condition.Right); } } else { condition.Operator.Compile(state, condition.Right is null); CompileOperand(state, condition.Right); } if (condition.Operator == Operator.Not || condition.Operator == Operator.NotPattern) { state.Text.Append(")"); } state.Text.Append(")"); }
internal virtual void Compile(PathResult path, CompileState state) { Compile(path.Alias, state); }
public void Execute(byte c, ref CompileState state) { state = _executor[(int)state].Execute((char)c); }
internal virtual void Compile(Literal litheral, CompileState state) { state.Text.Append(litheral.Text); }
internal virtual void Compile(q.Query query, CompileState state) { switch (query.Type) { case PartType.Search: string search = $"replace(trim(replace(replace(replace({state.Preview(query.SearchWords!.Compile, state)}, 'AND', '\"AND\"'), 'OR', '\"OR\"'), ' ', ' ')), ' ', ' {query.SearchOperator!.ToString().ToUpperInvariant()} ')"; Node node = query.Patterns.First(); AliasResult alias = node.NodeAlias !; AliasResult? weight = query.Aliases?.FirstOrDefault(); FieldResult[] fields = query.Fields !; List <string> queries = new List <string>(); foreach (var property in fields) { queries.Add(string.Format("({0}.{1}:' + {2} + ')", node.Neo4jLabel, property.FieldName, search)); } state.Text.Append("CALL apoc.index.search('fts', '"); state.Text.Append(string.Join(" OR ", queries)); state.Text.Append("') YIELD node AS "); Compile(alias, state); if ((object?)weight != null) { state.Text.Append(", weight AS "); Compile(weight, state); } state.Text.Append(" WHERE ("); Compile(alias, state); state.Text.Append(":"); state.Text.Append(node.Neo4jLabel); state.Text.Append(")"); break; case PartType.Match: state.Text.Append("MATCH "); query.ForEach(query.Patterns, state.Text, ", ", item => item?.Compile(state)); break; case PartType.OptionalMatch: state.Text.Append("OPTIONAL MATCH "); query.ForEach(query.Patterns, state.Text, ", ", item => item?.Compile(state)); break; case PartType.UsingScan: state.Text.Append("USING SCAN "); query.ForEach(query.Aliases, state.Text, "\r\nUSING SCAN ", item => { if (item.Node is null) { return; } item.Compile(state); state.Text.Append(":" + item.Node.Neo4jLabel); }); break; case PartType.UsingIndex: state.Text.Append("USING INDEX "); query.ForEach(query.Fields, state.Text, "\r\nUSING INDEX ", item => { if (item.Alias is null || item.Alias.Node is null) { return; } state.Text.Append(string.Format("{0}:{1}({2})", item.Alias.AliasName, item.Alias.Node.Neo4jLabel, item.FieldName)); });