public void DetailInFunctionTest()
        {
            var dvd = new DetailVariableDef();

            dvd.ConnectMasterPorp = "Берлога";
            dvd.OwnerConnectProp  = new[] { SQLWhereLanguageDef.StormMainObjectKey };
            dvd.View = Information.GetView("МедведьE", typeof(Медведь));
            dvd.Type = langdef.GetObjectType("Details");

            var function = langdef.GetFunction(langdef.funcExist, dvd, langdef.GetFunction(langdef.funcEQ, new VariableDef(langdef.GuidType, "Наименование"), string.Empty));

            var expectedPropertiesUsedInFunction = new List <string> {
                "Наименование"
            };

            var propertiesUsedInFunction = new List <string>();
            var detailList = new List <ViewPropertyAppender.DetailVariableDefContainer>();

            ViewPropertyAppender.FindPropertiesUsedInFunction(function, propertiesUsedInFunction, detailList);
            Assert.Equal(0, propertiesUsedInFunction.Count);
            Assert.Equal(1, detailList.Count);

            var intersection = expectedPropertiesUsedInFunction.Intersect(detailList[0].DetailVariablesList).ToList();

            Assert.Equal(expectedPropertiesUsedInFunction.Count, intersection.Count);
        }
        public void GetLcsByPseudoDetailLimitTestSimpleAnyWithCmp()
        {
            var testProvider = new TestLcsQueryProvider <Порода>();

            // Все породы, для которых определены кошки
            new Query <Порода>(testProvider).Where <Порода, Кошка>(
                Information.GetView("КошкаE", typeof(Кошка)),
                Information.ExtractPropertyPath <Кошка>(x => x.Порода),
                x => x.Any(),
                "SomeCmp").ToList();

            Expression queryExpression = testProvider.InnerExpression;

            var dvd = new DetailVariableDef(
                this.ldef.GetObjectType("Details"),
                "SomeCmp",
                Information.GetView("КошкаE", typeof(Кошка)),
                "Порода",
                new[] { SQLWhereLanguageDef.StormMainObjectKey });

            var expected = new LoadingCustomizationStruct(null)
            {
                LimitFunction = this.ldef.GetFunction("Exist", dvd, ldef.GetFunction(ldef.paramTrue))
            };

            LoadingCustomizationStruct actual = LinqToLcs.GetLcs(queryExpression, Utils.GetDefaultView(typeof(Порода)));

            Assert.True(Equals(expected, actual));
        }
Пример #3
0
        public void GetLcsTestAny()
        {
            var testProvider = new TestLcsQueryProvider <Кошка>();

            // Все кошки с лапами
            new Query <Кошка>(testProvider).Where(o => o.Лапа.Cast <Лапа>().Any()).ToArray();
            Expression queryExpression = testProvider.InnerExpression;

            var dvd = new DetailVariableDef
            {
                ConnectMasterPorp = "Кошка",
                OwnerConnectProp  = new[] { SQLWhereLanguageDef.StormMainObjectKey },
                View = Information.GetView("ЛапаE", typeof(Лапа)),
                Type = this.ldef.GetObjectType("Details")
            };

            var expected = new LoadingCustomizationStruct(null)
            {
                LimitFunction = this.ldef.GetFunction("Exist", dvd, true)
            };

            LoadingCustomizationStruct actual = LinqToLcs.GetLcs(queryExpression, Utils.GetDefaultView(typeof(Кошка)));

            Assert.True(Equals(expected, actual));
        }
        public void GetLcsByPseudoDetailLimitTestConditionAllWithCmp()
        {
            var testProvider = new TestLcsQueryProvider <Порода>();

            // Все породы, в которые входят только кошки, не носящие клички ни "Барсик", ни "Мурзик"
            new Query <Порода>(testProvider).Where <Порода, Кошка>(
                Information.GetView("КошкаE", typeof(Кошка)),
                Information.ExtractPropertyPath <Кошка>(x => x.Порода),
                y => y.All(x => x.Кличка != "Барсик" && x.Кличка != "Мурзик"),
                "SomeCmp").ToList();

            Expression queryExpression = testProvider.InnerExpression;

            var dvd = new DetailVariableDef(
                this.ldef.GetObjectType("Details"),
                "SomeCmp",
                Information.GetView("КошкаE", typeof(Кошка)),
                "Порода",
                new[] { SQLWhereLanguageDef.StormMainObjectKey });

            var lf = ldef.GetFunction(
                ldef.funcAND,
                ldef.GetFunction(ldef.funcNEQ, new VariableDef(ldef.StringType, "Кличка"), "Барсик"),
                ldef.GetFunction(ldef.funcNEQ, new VariableDef(ldef.StringType, "Кличка"), "Мурзик"));

            var expected = new LoadingCustomizationStruct(null)
            {
                LimitFunction = this.ldef.GetFunction(ldef.funcExistExact, dvd, lf)
            };

            LoadingCustomizationStruct actual = LinqToLcs.GetLcs(queryExpression, Utils.GetDefaultView(typeof(Порода)));

            Assert.True(Equals(expected, actual));
        }
Пример #5
0
        public void GetLcsTestDetailAllWithLimit()
        {
            var testProvider = new TestLcsQueryProvider <Кошка>();

            // Только те кошки у которых переломаны все лапы
            new Query <Кошка>(testProvider).Where(o => o.Лапа.Cast <Лапа>().All(obj => obj.БылиЛиПереломы)).ToArray();
            Expression queryExpression = testProvider.InnerExpression;

            var dvd = new DetailVariableDef
            {
                ConnectMasterPorp = "Кошка",
                OwnerConnectProp  = new[] { SQLWhereLanguageDef.StormMainObjectKey },
                View = Information.GetView("ЛапаE", typeof(Лапа)),
                Type = this.ldef.GetObjectType("Details")
            };

            var lf       = ldef.GetFunction(ldef.funcEQ, new VariableDef(ldef.BoolType, "БылиЛиПереломы"));
            var expected = new LoadingCustomizationStruct(null)
            {
                LimitFunction = this.ldef.GetFunction("ExistExact", dvd, lf)
            };

            LoadingCustomizationStruct actual = LinqToLcs.GetLcs(queryExpression, Utils.GetDefaultView(typeof(Кошка)));

            Assert.True(Equals(expected, actual));
        }
Пример #6
0
        public void GetLcsTestDetailWithCustomOwnerConnectProp()
        {
            var testProvider = new TestLcsQueryProvider <Котенок>();

            new Query <Котенок>(testProvider).Where(
                x => x.Кошка.Лапа.Cast <Лапа>().Any(o => o.ТипЛапы.Название == "передняя")).ToList();
            Expression queryExpression = testProvider.InnerExpression;

            var dvd = new DetailVariableDef
            {
                ConnectMasterPorp = "Кошка",
                OwnerConnectProp  = new[] { "Кошка" },
                View = Information.GetView("ЛапаE", typeof(Лапа)),
                Type = this.ldef.GetObjectType("Details")
            };

            var lf = ldef.GetFunction(ldef.funcEQ, new VariableDef(ldef.StringType, "ТипЛапы.Название"), "передняя");

            var expected = new LoadingCustomizationStruct(null)
            {
                LimitFunction =
                    this.ldef.GetFunction("Exist", dvd, lf)
            };

            LoadingCustomizationStruct actual = LinqToLcs.GetLcs(
                queryExpression, Utils.GetDefaultView(typeof(Котенок)), new[] { Utils.GetDefaultView(typeof(Кошка)) });

            Assert.True(Equals(expected, actual));

            // В сравнении Function DetailVariableDef не учитывается, поэтому проверим руками
            var expectedDvd = (DetailVariableDef)expected.LimitFunction.Parameters[0];
            var actualDvd   = (DetailVariableDef)actual.LimitFunction.Parameters[0];

            Assert.True(Equals(expectedDvd.OwnerConnectProp[0], actualDvd.OwnerConnectProp[0]));
        }
Пример #7
0
        public void GetLcsTestDetailAnyConjunction()
        {
            var testProvider = new TestLcsQueryProvider <Кошка>();

            new Query <Кошка>(testProvider).Where(x => x.Лапа.Cast <Лапа>().Any(o => o.Номер == 1 && o.Кошка.Кличка.Contains("кличка"))).ToList();
            Expression queryExpression = testProvider.InnerExpression;

            var dvd = new DetailVariableDef
            {
                ConnectMasterPorp = "Кошка",
                OwnerConnectProp  = new[] { SQLWhereLanguageDef.StormMainObjectKey },
                View = Information.GetView("ЛапаE", typeof(Лапа)),
                Type = this.ldef.GetObjectType("Details")
            };

            var lf = ldef.GetFunction(
                ldef.funcAND,
                ldef.GetFunction(ldef.funcEQ, new VariableDef(ldef.NumericType, "Номер"), 1),
                ldef.GetFunction(ldef.funcLike, new VariableDef(ldef.StringType, "Кошка.Кличка"), "%кличка%"));
            var expected = new LoadingCustomizationStruct(null)
            {
                LimitFunction = this.ldef.GetFunction("Exist", dvd, lf)
            };

            LoadingCustomizationStruct actual = LinqToLcs.GetLcs(queryExpression, Utils.GetDefaultView(typeof(Кошка)));

            Assert.True(Equals(expected, actual));
        }
        public void GetLcsByDetailLimitTestSpecialVariant()
        {
            var testProvider = new TestLcsQueryProvider <Кошка>();

            // Все кошки с лапами
            new Query <Кошка>(testProvider).Where <Кошка, Лапа>(
                Information.GetView("ЛапаE", typeof(Лапа)),
                x => x.Any()).ToArray();

            Expression queryExpression = testProvider.InnerExpression;

            var dvd = new DetailVariableDef(
                this.ldef.GetObjectType("Details"),
                "Лапа__Кошка",
                Information.GetView("ЛапаE", typeof(Лапа)),
                "Кошка",
                new[] { SQLWhereLanguageDef.StormMainObjectKey });

            var expected = new LoadingCustomizationStruct(null)
            {
                LimitFunction = this.ldef.GetFunction("Exist", dvd, ldef.GetFunction(ldef.paramTrue))
            };
            LoadingCustomizationStruct actual = LinqToLcs.GetLcs(queryExpression, Utils.GetDefaultView(typeof(Кошка)));

            Assert.True(Equals(expected, actual));
        }
Пример #9
0
        /// <summary>
        ///     Проверить DetailVariableDef на валидность.
        /// </summary>
        /// <param name="dvd">Переменная ограничения.</param>
        /// <exception cref="ArgumentNullException">Переменная ограничения пуста.</exception>
        /// <exception cref="ArgumentException">dvd.Type - пусто.</exception>
        /// <exception cref="ArgumentException">dvd.View - пусто.</exception>
        internal static void ValidateDetailVariableDef(DetailVariableDef dvd)
        {
            if (dvd == null)
            {
                throw new ArgumentNullException(nameof(dvd));
            }

            if (dvd.Type == null)
            {
                throw new ArgumentException(nameof(dvd.Type), $"{nameof(dvd)}.{nameof(dvd.Type)} - пусто.");
            }

            if (dvd.View == null)
            {
                throw new ArgumentException(nameof(dvd.View), $"{nameof(dvd)}.{nameof(dvd.View)} - пусто.");
            }

            if (string.IsNullOrEmpty(dvd.ConnectMasterPorp))
            {
                throw new ArgumentException(nameof(dvd.ConnectMasterPorp), $"{nameof(dvd)}.{nameof(dvd.ConnectMasterPorp)} - пусто.");
            }

            if (dvd.OwnerConnectProp == null)
            {
                throw new ArgumentException(nameof(dvd.OwnerConnectProp), $"{nameof(dvd)}.{nameof(dvd.OwnerConnectProp)} - пусто.");
            }
        }
        public void GetLcsByPseudoDetailLimitTestSimpleAny3()
        {
            var dvd = new DetailVariableDef(
                this.ldef.GetObjectType("Details"),
                "Кошка__Порода",
                Information.GetView("КошкаE", typeof(Кошка)),
                "Порода",
                new[] { SQLWhereLanguageDef.StormMainObjectKey });

            // Все породы, для которых есть кошки, кличка которых не Мурзик.
            CompareLcsWithLimitCommon(
                y => new PseudoDetail <Порода, Кошка>(
                    Information.GetView("КошкаE", typeof(Кошка)),
                    Information.ExtractPropertyPath <Кошка>(x => x.Порода))
                .Any(x => x.Кличка != "Мурзик"),
                this.ldef.GetFunction("Exist", dvd, ldef.GetFunction(ldef.funcNEQ, new VariableDef(ldef.StringType, "Кличка"), "Мурзик")));
        }
        public void Test_InsertedFuncExist()
        {
            // TODO Удалить данную строчку, как исправят баг 94309.
            IDataService dataService = DataServices.First();

            // TODO Вернуть данную строчку, как исправят баг 94309.
            //foreach (IDataService dataService in DataServices)
            {
                SQLDataService ds = (SQLDataService)dataService;

                updateTestObjects(ds);

                var detVar = new DetailVariableDef
                {
                    Type              = langDef.DetailsType,
                    View              = ИФХозДоговора.Views.ИФХозДоговораE,
                    OwnerConnectProp  = new[] { Information.ExtractPropertyName <УчастникХозДоговора>(x => x.ХозДоговор) },
                    ConnectMasterPorp = Information.ExtractPropertyName <ИФХозДоговора>(x => x.ХозДоговор)
                };

                var func = langDef.GetFunction(
                    langDef.funcExist,
                    detVar,
                    langDef.GetFunction(
                        langDef.funcEQ,
                        new VariableDef(
                            langDef.NumericType,
                            Information.ExtractPropertyName <ИсточникФинансирования>(x => x.НомерИсточникаФинансирования)),
                        3));

                var lcs = LoadingCustomizationStruct.GetSimpleStruct(typeof(Личность), Личность.Views.ЛичностьL);

                var dvd = new DetailVariableDef
                {
                    Type              = langDef.DetailsType,
                    View              = УчастникХозДоговора.Views.УчастникХозДоговораE,
                    OwnerConnectProp  = new[] { SQLWhereLanguageDef.StormMainObjectKey },
                    ConnectMasterPorp = Information.ExtractPropertyName <УчастникХозДоговора>(x => x.Личность)
                };

                lcs.LimitFunction = langDef.GetFunction(langDef.funcExist, dvd, func);

                ds.LoadObjects(lcs);
            }
        }
        public void GetLcsByPseudoDetailLimitTestCondition()
        {
            var testProvider = new TestLcsQueryProvider <Порода>();

            // Все породы, для которых существуют кошки, у которых кличка не "Барсик" и не "Мурзик"
            new Query <Порода>(testProvider).Where <Порода, Кошка>(
                Information.GetView("КошкаE", typeof(Кошка)),
                Information.ExtractPropertyPath <Кошка>(x => x.Порода),
                y => y.Any(x => x.Кличка != "Барсик" && x.Кличка != "Мурзик")).ToList();

            Expression queryExpression = testProvider.InnerExpression;

            var dvd = new DetailVariableDef(
                this.ldef.GetObjectType("Details"),
                "Кошка__Порода",
                Information.GetView("КошкаE", typeof(Кошка)),
                "Порода",
                new[] { SQLWhereLanguageDef.StormMainObjectKey });

            var lf = ldef.GetFunction(
                ldef.funcAND,
                ldef.GetFunction(ldef.funcNEQ, new VariableDef(ldef.StringType, "Кличка"), "Барсик"),
                ldef.GetFunction(ldef.funcNEQ, new VariableDef(ldef.StringType, "Кличка"), "Мурзик"));

            var expected = new LoadingCustomizationStruct(null)
            {
                LimitFunction = this.ldef.GetFunction("Exist", dvd, lf)
            };

            LoadingCustomizationStruct actual = LinqToLcs.GetLcs(queryExpression, Utils.GetDefaultView(typeof(Порода)));

            Assert.True(Equals(expected, actual));

            // Совершенно аналогично должно работать, если вместо Information.ExtractPropertyPath<Кошка>(x => x.Порода) передать просто x => x.Порода
            new Query <Порода>(testProvider).Where <Порода, Кошка>(
                Information.GetView("КошкаE", typeof(Кошка)),
                x => x.Порода,
                y => y.Any(x => x.Кличка != "Барсик" && x.Кличка != "Мурзик")).ToList();
            Expression queryExpression2        = testProvider.InnerExpression;
            LoadingCustomizationStruct actual2 = LinqToLcs.GetLcs(queryExpression2, Utils.GetDefaultView(typeof(Порода)));

            Assert.True(Equals(expected, actual2));
        }
        public void GetLcsByPseudoDetailLimitTestConditionAll2()
        {
            var pseudoDetail = new PseudoDetail <Порода, Кошка>(
                Information.GetView("КошкаE", typeof(Кошка)),
                Information.ExtractPropertyPath <Кошка>(x => x.Порода));

            var dvd = new DetailVariableDef(
                this.ldef.GetObjectType("Details"),
                "Кошка__Порода",
                Information.GetView("КошкаE", typeof(Кошка)),
                "Порода",
                new[] { SQLWhereLanguageDef.StormMainObjectKey });

            var lf = ldef.GetFunction(
                ldef.funcAND,
                ldef.GetFunction(ldef.funcNEQ, new VariableDef(ldef.StringType, "Кличка"), "Барсик"),
                ldef.GetFunction(ldef.funcNEQ, new VariableDef(ldef.StringType, "Кличка"), "Мурзик"));

            // Все породы, в которые входят только кошки, не носящие клички ни "Барсик", ни "Мурзик".
            CompareLcsWithLimitCommon(y => pseudoDetail.All(x => x.Кличка != "Барсик" && x.Кличка != "Мурзик"), this.ldef.GetFunction(ldef.funcExistExact, dvd, lf));
        }
        private Function GetSomeDetailFunction(string detailName, string comparer)
        {
            var dvd = new DetailVariableDef(
                ldef.GetObjectType("Details"),
                detailName,
                Выплаты.Views.ВыплатыViewE,
                Information.ExtractPropertyPath <Выплаты>(x => x.Кредит1),
                new[] { SQLWhereLanguageDef.StormMainObjectKey });

            Function lf = ldef.GetFunction(
                ldef.funcExistExact,
                dvd,
                ldef.GetFunction(
                    comparer,
                    new VariableDef(
                        ldef.NumericType,
                        Information.ExtractPropertyPath <Выплаты>(x => x.Кредит1.СрокКредита)),
                    20));

            return(lf);
        }
        public void GetLcsByDetailLimitTestSimpleAny()
        {
            var testProvider = new TestLcsQueryProvider <Кошка>();

            // Все кошки с лапами
            new Query <Кошка>(testProvider).Where <Кошка, Лапа>(
                Information.GetView("ЛапаE", typeof(Лапа)),
                Information.ExtractPropertyPath <Лапа>(x => x.Кошка),
                x => x.Any()).ToArray();

            Expression queryExpression = testProvider.InnerExpression;

            var dvd = new DetailVariableDef(
                this.ldef.GetObjectType("Details"),
                "Лапа__Кошка",
                Information.GetView("ЛапаE", typeof(Лапа)),
                "Кошка",
                new[] { SQLWhereLanguageDef.StormMainObjectKey });

            var expected = new LoadingCustomizationStruct(null)
            {
                LimitFunction = this.ldef.GetFunction("Exist", dvd, ldef.GetFunction(ldef.paramTrue))
            };
            LoadingCustomizationStruct actual = LinqToLcs.GetLcs(queryExpression, Utils.GetDefaultView(typeof(Кошка)));

            Assert.True(Equals(expected, actual));

            // Совершенно аналогично должно работать, если вместо Information.ExtractPropertyPath<Кошка>(x => x.Порода) передать просто x => x.Порода
            new Query <Кошка>(testProvider).Where <Кошка, Лапа>(
                Information.GetView("ЛапаE", typeof(Лапа)),
                x => x.Кошка,
                x => x.Any()).ToArray();
            Expression queryExpression2        = testProvider.InnerExpression;
            LoadingCustomizationStruct actual2 = LinqToLcs.GetLcs(queryExpression2, Utils.GetDefaultView(typeof(Порода)));

            Assert.True(Equals(expected, actual2));
        }
        public void EnrichDetailViewTest()
        {
            var dvd = new DetailVariableDef();

            dvd.ConnectMasterPorp = Information.ExtractPropertyPath <Выплаты>(x => x.Кредит1);
            dvd.OwnerConnectProp  = new[] { SQLWhereLanguageDef.StormMainObjectKey };
            dvd.View = new View {
                DefineClassType = typeof(Выплаты)
            };
            dvd.Type = langdef.GetObjectType("Details");

            var function = langdef.GetFunction(
                langdef.funcExist,
                dvd,
                langdef.GetFunction(
                    langdef.funcAND,
                    langdef.GetFunction(langdef.funcEQ, new VariableDef(langdef.DateTimeType, Information.ExtractPropertyPath <Выплаты>(x => x.ДатаВыплаты)), DateTime.Now),
                    langdef.GetFunction(langdef.funcEQ, new VariableDef(langdef.NumericType, Information.ExtractPropertyPath <Выплаты>(x => x.СуммаВыплаты)), 123)));

            ViewPropertyAppender.EnrichDetailViewInLimitFunction(function, DataServiceProvider.DataService);
            Assert.Equal(2, dvd.View.Properties.Count());
            Assert.Equal(Information.ExtractPropertyPath <Выплаты>(x => x.ДатаВыплаты), dvd.View.Properties[0].Name);
            Assert.Equal(Information.ExtractPropertyPath <Выплаты>(x => x.СуммаВыплаты), dvd.View.Properties[1].Name);
        }
 public void GetViewMayByDynamic()
 {
     Assert.NotNull(DetailVariableDef.GetPossibleDynamicView("КошкаL", typeof(Кошка)));
 }
 /// <summary>
 /// Проверяем генерацию <see cref="DetailVariableDef"/> из PseudoDetail.
 /// </summary>
 /// <param name="pseudoDetail">Псевдодетейл из linq.</param>
 /// <param name="detailVariableDef">Детейл из lcs</param>
 private void ComparePseudoDetailWithDetailVariableDef(PseudoDetail <Порода, Кошка> pseudoDetail, DetailVariableDef detailVariableDef)
 {
     CompareLcsWithLimitCommon(y => pseudoDetail.Any(), this.ldef.GetFunction(ldef.funcExist, detailVariableDef, true));
 }
 public void GetViewMayByDynamic2()
 {
     Assert.Null(DetailVariableDef.GetPossibleDynamicView("NotExistingView", typeof(Кошка)));
 }
        public void Test_funcExistDetails()
        {
            // TODO Удалить данную строчку, как исправят баг 94309.
            // IDataService dataService = DataServices[0];

            // TODO Вернуть данную строчку, как исправят баг 94309.
            foreach (IDataService dataService in DataServices)
            {
                // Arrange.
                var ds = (SQLDataService)dataService;

                // Контрольные значене.
                const int controlInt = 1;

                // Сначала создаём структуру данных, требуемую для теста.
                var testMasterObject = new FullTypesMaster1();

                var testFullTypesMainAgregator = new FullTypesMainAgregator
                {
                    FullTypesMaster1 = testMasterObject
                };

                // Создание детейлов, которые не подходят под условие ограничения.
                testFullTypesMainAgregator.FullTypesDetail1.Add(new FullTypesDetail1 {
                    PoleInt = controlInt
                });
                testFullTypesMainAgregator.FullTypesDetail2.Add(new FullTypesDetail2 {
                    PoleInt = 2
                });

                var updateObjectsArray = new DataObject[] { testMasterObject, testFullTypesMainAgregator };

                // Сохранение данных.
                ds.UpdateObjects(ref updateObjectsArray);

                // Выбор представления.
                var view  = FullTypesMainAgregator.Views.FullViewWithDetail1;
                var view2 = FullTypesDetail1.Views.FullDetailView;
                var view3 = FullTypesDetail2.Views.FullTypesDetail2E;
                var lcs   = LoadingCustomizationStruct.GetSimpleStruct(typeof(FullTypesMainAgregator), view);

                string cmp   = Information.ExtractPropertyPath <FullTypesDetail1>(x => x.FullTypesMainAgregator);
                string name1 = Information.ExtractPropertyPath <FullTypesMainAgregator>(x => x.FullTypesDetail1);
                string name2 = Information.ExtractPropertyPath <FullTypesMainAgregator>(x => x.FullTypesDetail2);

                var detail  = new DetailVariableDef(_ldef.GetObjectType("Details"), name1, view2, cmp, new[] { SQLWhereLanguageDef.StormMainObjectKey });
                var detail2 = new DetailVariableDef(_ldef.GetObjectType("Details"), name2, view3, cmp, new[] { SQLWhereLanguageDef.StormMainObjectKey });
                // Проверка существования детейлов такого, что:
                lcs.LimitFunction = _ldef.GetFunction(_ldef.funcExistDetails,
                                                      detail,
                                                      detail2,
                                                      _ldef.GetFunction(
                                                          // Равны.
                                                          _ldef.funcEQ,
                                                          // Хотя бы одно значение в поле Int у первого детейла.
                                                          new VariableDef(_ldef.NumericType, Information.ExtractPropertyPath <FullTypesDetail1>(x => x.PoleInt)),
                                                          // И значение в поле Int у второго детейла.
                                                          new VariableDef(_ldef.NumericType, Information.ExtractPropertyPath <FullTypesDetail2>(x => x.PoleInt))));

                // Act.
                var dos = ds.LoadObjects(lcs);

                // Assert.
                Assert.Equal(dos.Length, 0);

                // Создание детейла, который подходит под условте ограничения.
                testFullTypesMainAgregator.FullTypesDetail2.Add(new FullTypesDetail2 {
                    PoleInt = controlInt
                });

                // Сохранение новых данных.
                ds.UpdateObjects(ref updateObjectsArray);

                // Act.
                var dos2 = ds.LoadObjects(lcs);

                // Assert.
                Assert.Equal(dos2.Length, 1);
            }
        }
        /// <summary>
        /// Преобразовать значение в SQL строку
        /// </summary>
        /// <param name="function">Функция</param>
        /// <param name="convertValue">делегат для преобразования констант</param>
        /// <param name="convertIdentifier">делегат для преобразования идентификаторов</param>
        /// <returns></returns>
        public override string FunctionToSql(
            SQLWhereLanguageDef sqlLangDef,
            Function value,
            delegateConvertValueToQueryValueString convertValue,
            delegatePutIdentifierToBrackets convertIdentifier)
        {
            ExternalLangDef langDef = sqlLangDef as ExternalLangDef;

            if (value.FunctionDef.StringedView == "TODAY")
            {
                return("sysdate");
            }

            if (
                value.FunctionDef.StringedView == "YearPart" ||
                value.FunctionDef.StringedView == "MonthPart" ||
                value.FunctionDef.StringedView == "DayPart")
            {
                return(string.Format("EXTRACT ({0} FROM {1})", value.FunctionDef.StringedView.Substring(0, value.FunctionDef.StringedView.Length - 4),
                                     langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier)));
            }

            if (
                value.FunctionDef.StringedView == "hhPart")
            {
                return(string.Format("TO_CHAR({1}, \'{0}\')", "HH24",
                                     langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier)));
            }

            if (value.FunctionDef.StringedView == "miPart")
            {
                return(string.Format("TO_CHAR({1}, \'{0}\')", "MI",
                                     langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier)));
            }

            if (value.FunctionDef.StringedView == "DayOfWeek")
            {
                // здесь требуется преобразование из DATASERVICE
                return(string.Format("TO_CHAR({1}, \'{0}\')", "D",
                                     langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier)));
            }

            if (value.FunctionDef.StringedView == langDef.funcDayOfWeekZeroBased)
            {
                throw new NotImplementedException(string.Format("Function {0} is not implemented for Oracle", langDef.funcDayOfWeekZeroBased));
            }

            if (value.FunctionDef.StringedView == langDef.funcDaysInMonth)
            {
                // здесь требуется преобразование из DATASERVICE
                string.Format("to_char(last_day(to_date('01.'||{0}||'.'||{1},'dd.mm.yyyy')),'dd')", langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier), langDef.SQLTranslSwitch(value.Parameters[1], convertValue, convertIdentifier));
                return(string.Empty);
            }

            if (value.FunctionDef.StringedView == "OnlyDate")
            {
                return(string.Format("TRUNC({0})",
                                     langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier)));
            }

            if (value.FunctionDef.StringedView == "CurrentUser")
            {
                return(string.Format("'{0}'", CurrentUserService.CurrentUser.FriendlyName));

                // у нее нет параметров
                // langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier));
            }

            if (value.FunctionDef.StringedView == "OnlyTime")
            {
                return(string.Format("TRUNC({0})",
                                     langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier)));
            }

            if (value.FunctionDef.StringedView == "DATEDIFF")
            {
                var ret = string.Empty;
                if (langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier) == "Year")
                {
                    ret = string.Format("EXTRACT (YEAR FROM {1}) - EXTRACT (YEAR FROM {0})",
                                        langDef.SQLTranslSwitch(value.Parameters[1], convertValue, convertIdentifier),
                                        langDef.SQLTranslSwitch(value.Parameters[2], convertValue, convertIdentifier));
                }
                else if (langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier) == "Month")
                {
                    ret = string.Format("(EXTRACT (YEAR FROM {1}) - EXTRACT (YEAR FROM {0})) * 12 + (EXTRACT (MONTH FROM {1}) - EXTRACT (MONTH FROM {0}))",
                                        langDef.SQLTranslSwitch(value.Parameters[1], convertValue, convertIdentifier),
                                        langDef.SQLTranslSwitch(value.Parameters[2], convertValue, convertIdentifier));
                }
                else if (langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier) == "Week")
                {
                    ret = string.Format("(TRUNC({1},'DAY') - TRUNC({0},'DAY'))/7",
                                        langDef.SQLTranslSwitch(value.Parameters[1], convertValue, convertIdentifier),
                                        langDef.SQLTranslSwitch(value.Parameters[2], convertValue, convertIdentifier));
                }
                else if (langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier) == "Day")
                {
                    ret = string.Format("TRUNC({1}) - TRUNC({0})",
                                        langDef.SQLTranslSwitch(value.Parameters[1], convertValue, convertIdentifier),
                                        langDef.SQLTranslSwitch(value.Parameters[2], convertValue, convertIdentifier));
                }
                else if (langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier) == "quarter")
                {
                    ret = string.Format("(EXTRACT (YEAR FROM {1}) - EXTRACT (YEAR FROM {0})) * 4 + (TO_CHAR({1}, 'Q') - TO_CHAR({0}, 'Q'))",
                                        langDef.SQLTranslSwitch(value.Parameters[1], convertValue, convertIdentifier),
                                        langDef.SQLTranslSwitch(value.Parameters[2], convertValue, convertIdentifier));
                }

                return(ret);
            }

            if (value.FunctionDef.StringedView == "SUM" ||
                value.FunctionDef.StringedView == "AVG" ||
                value.FunctionDef.StringedView == "MAX" ||
                value.FunctionDef.StringedView == "MIN")
            {
                ICSSoft.STORMNET.Business.LoadingCustomizationStruct lcs = new ICSSoft.STORMNET.Business.LoadingCustomizationStruct(null);
                DetailVariableDef dvd = (DetailVariableDef)value.Parameters[0];
                lcs.LoadingTypes         = new Type[] { dvd.View.DefineClassType };
                lcs.View                 = new View();
                lcs.View.DefineClassType = dvd.View.DefineClassType;
                lcs.View.AddProperty(dvd.ConnectMasterPorp);
                string[] prevRetVars = langDef.retVars;
                langDef.retVars = new string[] { dvd.ConnectMasterPorp };
                ArrayList al  = new ArrayList();
                object    par = langDef.TransformObject(value.Parameters[1], dvd.StringedView, al);
                foreach (string s in al)
                {
                    lcs.View.AddProperty(s);
                }

                string Slct            = GenerateSQLSelect(lcs, false).Replace("STORMGENERATEDQUERY", "SGQ" + Guid.NewGuid().ToString().Replace("-", string.Empty));
                string CountIdentifier = convertIdentifier("g" + Guid.NewGuid().ToString().Replace("-", string.Empty).Substring(0, 29));

                // FunctionalLanguage.Function numFunc = (value.Parameters[1] as FunctionalLanguage.Function);

                string sumExpression = langDef.SQLTranslSwitch(par, convertValue, convertIdentifier);

                string res = string.Empty;
                res = string.Format(
                    "( SELECT {0} From ( " +
                    "SELECT {6}({5}) {0},{1} from ( {4} )pip group by {1} ) " +
                    " ahh where {1} in ({3}",
                    CountIdentifier,
                    convertIdentifier(dvd.ConnectMasterPorp),
                    convertIdentifier(Information.GetClassStorageName(dvd.View.DefineClassType)),
                    convertIdentifier("STORMGENERATEDQUERY") + "." + convertIdentifier(dvd.OwnerConnectProp[0]),

                    // convertIdentifier(dvd.OwnerConnectProp),
                    Slct,

                    // ВНИМАНИЕ ЗДЕСЬ ТРЕБУЕТСЯ ИЗМЕНИТь ISNULL на вычислитель в определенном DATASERVICE
                    "NVL(" + sumExpression + ",0)", value.FunctionDef.StringedView);
                for (int k = 0; k < dvd.OwnerConnectProp.Length; k++)
                {
                    res += "," + convertIdentifier("STORMGENERATEDQUERY") + "." + convertIdentifier(dvd.OwnerConnectProp[k]);
                }

                res += "))";

                langDef.retVars = prevRetVars;
                return(res);
            }

            if (value.FunctionDef.StringedView == langDef.funcCountWithLimit || value.FunctionDef.StringedView == "Count")
            {
                var lcs = new ICSSoft.STORMNET.Business.LoadingCustomizationStruct(null);
                var dvd = (DetailVariableDef)value.Parameters[0];
                lcs.LoadingTypes  = new Type[] { dvd.View.DefineClassType };
                lcs.View          = dvd.View.Clone();
                lcs.LimitFunction = value.FunctionDef.StringedView == langDef.funcCountWithLimit
                    ? langDef.TransformVariables((FunctionalLanguage.Function)value.Parameters[1], dvd.StringedView, null)
                    : langDef.GetFunction("True");
                var prevRetVars = langDef.retVars;
                langDef.retVars = new string[] { dvd.ConnectMasterPorp };
                var Slct            = GenerateSQLSelect(lcs, true);
                var CountIdentifier = convertIdentifier("g" + Guid.NewGuid().ToString().Replace("-", string.Empty).Substring(0, 29));

                var res = string.Format(
                    "( NVL(  ( SELECT {0} From ( " +
                    "SELECT Count(*) {0},{1} from ( {4} )pip group by {1} ) " +
                    " ahh where {1} in ({3}",
                    CountIdentifier,
                    convertIdentifier(dvd.ConnectMasterPorp),
                    convertIdentifier(Information.GetClassStorageName(dvd.View.DefineClassType)),
                    convertIdentifier("STORMGENERATEDQUERY") + "." + convertIdentifier(dvd.OwnerConnectProp[0]),
                    Slct);
                for (int k = 1; k < dvd.OwnerConnectProp.Length; k++)
                {
                    res += "," + convertIdentifier("STORMGENERATEDQUERY") + "." + convertIdentifier(dvd.OwnerConnectProp[k]);
                }

                res += ")),0))";

                langDef.retVars = prevRetVars;
                return(res);
            }

            if (value.FunctionDef.StringedView == langDef.funcToChar)
            {
                if (value.Parameters.Count == 2)
                {
                    return(string.Format(
                               "SUBSTR(TO_CHAR({0}), 1, {1})",
                               langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier),
                               value.Parameters[1]));
                }

                if (value.Parameters.Count == 3)
                {
                    return(string.Format(
                               "SUBSTR(TO_CHAR({0}, {2}), 1, {1})",
                               langDef.SQLTranslSwitch(value.Parameters[0], convertValue, convertIdentifier),
                               value.Parameters[1],
                               DateFormats.GetOracleDateFormat((int)value.Parameters[2])));
                }
            }
            else
            {
                throw new NotImplementedException(string.Format(
                                                      "Функция {0} не реализована для Oracle", value.FunctionDef.StringedView));
            }

            return(string.Empty);
        }
        public void Test_funcExistAll()
        {
            // TODO Удалить данную строчку, как исправят баг 94309.
            // IDataService dataService = DataServices[0];

            // TODO Вернуть данную строчку, как исправят баг 94309.
            foreach (IDataService dataService in DataServices)
            {
                // Arrange.
                var ds = (SQLDataService)dataService;

                // Контрольные значене.
                const int  controlInt  = 1;
                const bool controlBool = true;

                // Сначала создаём структуру данных, требуемую для теста.
                var testMasterObject = new FullTypesMaster1();

                var testFullTypesMainAgregator = new FullTypesMainAgregator
                {
                    FullTypesMaster1 = testMasterObject
                };

                // Создание детейла, который не подходит под условие ограничения.
                testFullTypesMainAgregator.FullTypesDetail1.Add(new FullTypesDetail1 {
                    PoleInt = 2, PoleBool = false
                });

                var updateObjectsArray = new DataObject[] { testMasterObject, testFullTypesMainAgregator };

                // Сохранение данных.
                ds.UpdateObjects(ref updateObjectsArray);

                // Выбор представления.
                var view  = FullTypesMainAgregator.Views.FullViewWithDetail1;
                var view2 = FullTypesDetail1.Views.FullDetailView;
                var lcs   = LoadingCustomizationStruct.GetSimpleStruct(typeof(FullTypesMainAgregator), view);

                string cmp  = Information.ExtractPropertyPath <FullTypesDetail1>(x => x.FullTypesMainAgregator);
                string name = Information.ExtractPropertyPath <FullTypesMainAgregator>(x => x.FullTypesDetail1);

                var detail = new DetailVariableDef(_ldef.GetObjectType("Details"), name, view2, cmp, new[] { SQLWhereLanguageDef.StormMainObjectKey });
                // Проверка существования детейла такого, что:
                lcs.LimitFunction = _ldef.GetFunction(_ldef.funcExistAll,
                                                      detail,
                                                      // Поле int в детейле равно контрольному значению(controlInt = 1).
                                                      _ldef.GetFunction(_ldef.funcEQ,
                                                                        new VariableDef(_ldef.NumericType,
                                                                                        Information.ExtractPropertyPath <FullTypesDetail1>(x => x.PoleInt)),
                                                                        controlInt),
                                                      // Или поле bool в детейле равно контрольному значению (controlBool=true).
                                                      _ldef.GetFunction(_ldef.funcEQ,
                                                                        new VariableDef(_ldef.BoolType,
                                                                                        Information.ExtractPropertyPath <FullTypesDetail1>(x => x.PoleBool)),
                                                                        controlBool));

                // Act.
                var dos = ds.LoadObjects(lcs);

                // Assert.
                Assert.Equal(dos.Length, 0);

                // Создание детейла, который подходит под условие ограничения.
                testFullTypesMainAgregator.FullTypesDetail1.Add(new FullTypesDetail1 {
                    PoleInt = controlInt, PoleBool = controlBool
                });

                // Сохранение новых данных.
                ds.UpdateObjects(ref updateObjectsArray);

                // Act.
                var dos2 = ds.LoadObjects(lcs);

                // Assert.
                Assert.Equal(dos2.Length, 1);
            }
        }