private Value ProcessSelect(LogicalQueryOperationValue operand, Value annotation, LocalCodeExecutionContext localCodeExecutionContext)
        {
#if DEBUG
            //Log($"operand = {operand}");
            //Log($"annotation = {annotation}");
#endif

            if (operand.Target == null)
            {
                throw new NotImplementedException();
            }

            if (operand.Source != null)
            {
                throw new NotImplementedException();
            }

            if (operand.Dest != null)
            {
                throw new NotImplementedException();
            }

            var target = operand.Target;

            if (!target.IsRuleInstanceValue)
            {
                throw new NotImplementedException();
            }

            var query = target.AsRuleInstanceValue.RuleInstance;

#if DEBUG
            //Log($"query = {query}");
            //Log($"query = {DebugHelperForRuleInstance.ToString(query)}");
#endif

            var searchOptions = new LogicalSearchOptions();
            searchOptions.QueryExpression           = query;
            searchOptions.LocalCodeExecutionContext = localCodeExecutionContext;

#if DEBUG
            //Log($"searchOptions = {searchOptions}");
#endif

            var searchResult = _searcher.Run(searchOptions);

#if DEBUG
            //Log($"searchResult = {searchResult}");
            //Log($"result = {DebugHelperForLogicalSearchResult.ToString(searchResult, _engineContext.Dictionary)}");
#endif

            return(new LogicalSearchResultValue(searchResult));
        }
Ejemplo n.º 2
0
        private bool CheckSEH()
        {
            var ruleInstance = _currentError.RuleInstance;

#if DEBUG
            //Log($"ruleInstance = {ruleInstance}");
#endif

            var searchOptions = new LogicalSearchOptions();
            searchOptions.TargetStorage             = ruleInstance;
            searchOptions.LocalCodeExecutionContext = _currentCodeFrame.LocalContext;

            foreach (var sehItem in _currentCodeFrame.CurrentSEHGroup.Items)
            {
#if DEBUG
                //Log($"sehItem = {sehItem}");
#endif

                if (sehItem.Condition != null)
                {
                    searchOptions.QueryExpression = sehItem.Condition;

                    if (!_logicalSearchResolver.IsTruth(searchOptions))
                    {
                        continue;
                    }
                }

#if DEBUG
                //Log("NEXT");
#endif

                if (sehItem.VariableName != null && !sehItem.VariableName.IsEmpty)
                {
                    _currentVarStorage.SetValue(sehItem.VariableName, _currentError);
                }

                _currentError = null;

                _currentCodeFrame.CurrentPosition = sehItem.TargetPosition;

                return(true);
            }

            _currentError = null;

            _currentCodeFrame.CurrentPosition = _currentCodeFrame.CurrentSEHGroup.AfterPosition;

            return(true);
        }
Ejemplo n.º 3
0
        private void Search(string queryStr)
        {
            _logger.Log($"queryStr = {queryStr}");

            var result = new CodeFile();

            result.IsMain   = false;
            result.FileName = "Hi!";

            var internalParserContext = new InternalParserContext(queryStr, result, _context);

            var globalStorage = _context.Storage.GlobalStorage;

            internalParserContext.SetCurrentDefaultSetings(globalStorage.DefaultSettingsOfCodeEntity);

            var parser = new LogicalQueryParser(internalParserContext);

            parser.Run();

            var parsedQuery = parser.Result;

            //_logger.Log($"parsedQuery = {parsedQuery}");

            _logger.Log($"DebugHelperForRuleInstance.ToString(parsedQuery) = {DebugHelperForRuleInstance.ToString(parsedQuery)}");

            //var indexedQuery = parsedQuery.GetIndexed(_context);

            //_logger.Log($"indexedQuery = {indexedQuery}");

            //_logger.Log($"DebugHelperForIndexedRuleInstance.ToString(indexedQuery) = {DebugHelperForIndexedRuleInstance.ToString(indexedQuery, dictionary)}");

            var searcher = _context.DataResolversFactory.GetLogicalSearchResolver();

            var searchOptions = new LogicalSearchOptions();

            searchOptions.QueryExpression = parsedQuery;

            var localCodeExecutionContext = new LocalCodeExecutionContext();

            searchOptions.LocalCodeExecutionContext = localCodeExecutionContext;
            localCodeExecutionContext.Storage       = _context.Storage.GlobalStorage;
            localCodeExecutionContext.Holder        = _context.CommonNamesStorage.DefaultHolder;

            //_logger.Log($"searchOptions = {searchOptions}");

            var searchResult = searcher.Run(searchOptions);

            //_logger.Log($"searchResult = {searchResult}");

            _logger.Log($"searchResult.IsSuccess = {searchResult.IsSuccess}");
            _logger.Log($"searchResult.Items.Count = {searchResult.Items.Count}");

            _logger.Log(DebugHelperForLogicalSearchResult.ToString(searchResult));

            foreach (var item in searchResult.Items)
            {
                _logger.Log($"item.ResultOfVarOfQueryToRelationList.Count = {item.ResultOfVarOfQueryToRelationList.Count}");

                foreach (var resultOfVarOfQueryToRelation in item.ResultOfVarOfQueryToRelationList)
                {
                    var varName = resultOfVarOfQueryToRelation.NameOfVar;

                    _logger.Log($"varName = {varName}");

                    var foundNode = resultOfVarOfQueryToRelation.FoundExpression;

                    _logger.Log($"DebugHelperForRuleInstance.ToString(foundNode) = {DebugHelperForRuleInstance.ToString(foundNode)}");
                }

                //_logger.Log($" = {}");
            }
        }
        private void DoSearch()
        {
            var searchOptions = new LogicalSearchOptions();

            searchOptions.QueryExpression           = _condition;
            searchOptions.LocalCodeExecutionContext = _localCodeExecutionContext;

#if DEBUG
            //Log($"searchOptions = {searchOptions}");
#endif

            var searchResult = _searcher.Run(searchOptions);

#if DEBUG
            //Log($"searchResult = {searchResult}");
            //Log($"result = {DebugHelperForLogicalSearchResult.ToString(searchResult)}");
            //foreach(var usedKey in searchResult.UsedKeysList)
            //{
            //    Log($"usedKey = {usedKey}");
            //    Log($"_context.Dictionary.GetName(usedKey) = {_context.Dictionary.GetName(usedKey)}");
            //}
#endif

            _usedKeysList = searchResult.UsedKeysList;

#if DEBUG
            //Log($"_isOn = {_isOn}");
#endif

            if (_isOn)
            {
                if (!searchResult.IsSuccess)
                {
                    _isOn = false;
                }
            }
            else
            {
                if (searchResult.IsSuccess)
                {
                    _isOn = true;

#if DEBUG
                    //Log($"searchResult = {searchResult}");
                    //Log($"result = {DebugHelperForLogicalSearchResult.ToString(searchResult)}");
#endif

                    var localCodeExecutionContext = new LocalCodeExecutionContext();
                    var localStorageSettings      = RealStorageSettingsHelper.Create(_context, _storage);
                    var storage = new LocalStorage(localStorageSettings);
                    localCodeExecutionContext.Storage = storage;
                    localCodeExecutionContext.Holder  = _parent.Name;

                    var varStorage = storage.VarStorage;

                    var bindingVariables = _trigger.BindingVariables;

                    if (bindingVariables.Any())
                    {
                        var foundResultItem = searchResult.Items.FirstOrDefault();

                        if (foundResultItem == null)
                        {
                            throw new NotImplementedException();
                        }

                        var resultVarsList = foundResultItem.ResultOfVarOfQueryToRelationList;

#if DEBUG
                        //Log($"resultVarsList.Count = {resultVarsList.Count}");
#endif

                        if (bindingVariables.Count != resultVarsList.Count)
                        {
                            throw new NotImplementedException();
                        }

                        foreach (var resultVar in resultVarsList)
                        {
#if DEBUG
                            //Log($"resultVar = {resultVar}");
#endif

                            Value value = null;

                            var foundExpression = resultVar.FoundExpression;

                            var kindOfFoundExpression = foundExpression.Kind;

                            switch (kindOfFoundExpression)
                            {
                            case KindOfLogicalQueryNode.Entity:
                                value = foundExpression.Name;
                                break;

                            case KindOfLogicalQueryNode.Value:
                                value = foundExpression.Value;
                                break;

                            default:
                                throw new ArgumentOutOfRangeException(nameof(kindOfFoundExpression), kindOfFoundExpression, null);
                            }

#if DEBUG
                            //Log($"value = {value}");
#endif

                            var destVar = bindingVariables.GetDest(resultVar.NameOfVar);

#if DEBUG
                            //Log($"destVar = {destVar}");
#endif

                            varStorage.SetValue(destVar, value);
                        }
                    }

                    var processInitialInfo = new ProcessInitialInfo();
                    processInitialInfo.CompiledFunctionBody = _trigger.CompiledFunctionBody;
                    processInitialInfo.LocalContext         = localCodeExecutionContext;
                    processInitialInfo.Metadata             = _trigger.CodeEntity;

                    var task = _context.CodeExecutor.ExecuteAsync(processInitialInfo);
                }
            }

#if DEBUG
            //Log($"_isOn (after) = {_isOn}");
#endif
        }