コード例 #1
0
        public void RecordsetGroup_Constructor_WhenDefinitionsNull_ExpectException()
        {
            //------------Setup for test--------------------------

            var entry = Dev2BinaryDataListFactory.CreateEntry(string.Empty, string.Empty, Guid.NewGuid());

            //------------Execute Test---------------------------
            var recordsetGroup = new RecordsetGroup(entry, null, definition => null, definition => null);
        }
コード例 #2
0
        /// <summary>
        /// Binds the compiled expression.
        /// </summary>
        /// <returns></returns>
        public IBinaryDataListEntry BindCompiledExpression()
        {
            // very short circuit if no items ;)
            if (_internalKeyMap.Keys.Count == 0)
            {
                CompiledExpression = null;
                return(null);
            }

            // short circuit the long eval for mix mode data ;)
            if (_internalMap.Keys.Count <= 1 && FetchEvaluationIterationCount(Expression) == 1 && CompiledExpression.Length == 3)
            {
                return(_internalKeyMap.Values.FirstOrDefault());
            }

            var replaceValue = string.Empty;

            // Right now we assume there are not ;)
            foreach (var idx in _internalMap.Keys)
            {
                var token    = BuildSubToken(idx);
                var otherKey = _internalMap[idx];
                IBinaryDataListEntry value;
                if (_internalKeyMap.TryGetValue(otherKey, out value))
                {
                    if (value != null)
                    {
                        if (!value.IsRecordset)
                        {
                            var scalar = value.FetchScalar();
                            if (scalar != null)
                            {
                                if (_result == null)
                                {
                                    var toReplace = scalar.TheValue;
                                    CompiledExpression = CompiledExpression.Replace(token, toReplace);
                                }
                                else
                                {
                                    var    itr = _result.FetchRecordsetIndexes();
                                    string replaceVal;
                                    try
                                    {
                                        replaceVal = scalar.TheValue;
                                    }
                                    catch (NullValueInVariableException)
                                    {
                                        replaceVal = null;
                                    }

                                    while (itr.HasMore())
                                    {
                                        var val = itr.FetchNextIndex();

                                        // Fetch the next value from result ;)
                                        try
                                        {
                                            string error;
                                            string template = _result.TryFetchRecordsetColumnAtIndex(GlobalConstants.EvaluationRsField, val, out error).TheValue;
                                            Errors.AddError(error);

                                            template = template.Replace(token, replaceVal);
                                            _result.TryPutRecordItemAtIndex(new BinaryDataListItem(template, _ns, GlobalConstants.EvaluationRsField, val), val, out error);
                                            Errors.AddError(error);
                                        }
                                        catch (NullValueInVariableException)
                                        {
                                            //Do nothing got null
                                        }
                                    }

                                    CompiledExpression = CompiledExpression.Replace(token, replaceVal);
                                }
                            }
                        }
                        else
                        {
                            string error;
                            // build up the complex expression result - this means debug will be out of sync of complex expressions ;)
                            if (_result == null)
                            {
                                IList <Dev2Column> cols = new List <Dev2Column> {
                                    new Dev2Column(GlobalConstants.EvaluationRsField, enDev2ColumnArgumentDirection.Both)
                                };
                                _result = Dev2BinaryDataListFactory.CreateEntry(_ns, string.Empty, cols, BinaryDataList.UID);

                                var max = _internalKeyMap.Values.OrderByDescending(c => c.ItemCollectionSize()).FirstOrDefault();

                                if (max != null)
                                {
                                    var itrToVal = max.ItemCollectionSize();
                                    if (itrToVal == 0)
                                    {
                                        itrToVal = 1;
                                    }

                                    for (int i = 0; i < itrToVal; i++)
                                    {
                                        int idxT = (i + 1);
                                        _result.TryPutRecordItemAtIndex(new BinaryDataListItem(CompiledExpression, _ns, GlobalConstants.EvaluationRsField, idxT), idxT, out error);
                                        Errors.AddError(error);
                                    }
                                }

                                if (IsDebug)
                                {
                                    // attach audit object for debug ;)
                                    _result.ComplexExpressionAuditor = new ComplexExpressionAuditor();
                                }
                            }

                            var idxItr = value.FetchRecordsetIndexes();
                            int expIdx = 1;

                            // we need to treat this as a scalar ;)
                            if (idxItr.Count == 1)
                            {
                                int curVal = idxItr.FetchNextIndex();
                                int amt    = _result.ItemCollectionSize();
                                // ensure we always iterate once ;)
                                if (amt == 0)
                                {
                                    amt = 1;
                                }

                                idxItr = new LoopedIndexIterator(curVal, amt);
                            }

                            // else iterate across the recordset cuz it had a star ;)
                            while (idxItr.HasMore())
                            {
                                try
                                {
                                    var val = idxItr.FetchNextIndex();

                                    // Fetch the next value from result ;)
                                    var template = _result.TryFetchRecordsetColumnAtIndex(GlobalConstants.EvaluationRsField,
                                                                                          expIdx, out error).TheValue;
                                    Errors.AddError(error);

                                    var binaryValue = value.TryFetchIndexedRecordsetUpsertPayload(val, out error);
                                    Errors.AddError(error);

                                    // now bind this result row with the correct data list data ;)
                                    if (binaryValue != null)
                                    {
                                        var preTemplate = template;
                                        var toReplace   = binaryValue.TheValue;
                                        template = template.Replace(token, toReplace);

                                        // In cases when [[[{0}]] is the result, we need to inject the template value
                                        // In cases when [[rec({0}).a]] we need to replace the template pattern ;)
                                        var tmp = CompiledExpression.Replace("[", "").Replace("]", "").Replace(token, string.Empty);
                                        // ReSharper disable ConvertIfStatementToConditionalTernaryExpression
                                        if (tmp.Length > 0)
                                        // ReSharper restore ConvertIfStatementToConditionalTernaryExpression
                                        {
                                            // we have a [[rec({0}.a]] case ;)
                                            replaceValue = toReplace;
                                        }
                                        else
                                        {
                                            replaceValue = template;
                                        }

                                        _result.TryPutRecordItemAtIndex(new BinaryDataListItem(template, _ns, GlobalConstants.EvaluationRsField, expIdx), expIdx, out error);
                                        Errors.AddError(error);

                                        if (IsDebug)
                                        {
                                            var displayValue = DataListUtil.AddBracketsToValueIfNotExist(binaryValue.DisplayValue);
                                            _result.ComplexExpressionAuditor.AddAuditStep(preTemplate, displayValue, token, idx, template, Expression);
                                            _result.ComplexExpressionAuditor.SetMaxIndex(expIdx);
                                        }
                                    }

                                    expIdx++; // inc result index ;)
                                }
                                catch (NullValueInVariableException)
                                {
                                    //Do Nothing got null value
                                }
                            }

                            replaceValue       = DataListUtil.RemoveLanguageBrackets(replaceValue);
                            CompiledExpression = CompiledExpression.Replace(token, replaceValue);
                        }
                    }
                    else
                    {
                        CompiledExpression = CompiledExpression.Replace(token, string.Empty);
                    }
                }
            }

            return(_result);
        }