Exemple #1
0
        public IConstraint FormulateFieldConstraints(IQuery query, OMQueryClause clause)
        {
            try
            {
                IConstraint cons = null;
                string[]    str  = clause.Fieldname.Split('.');
                IQuery      q    = AddAsDescends(query, str);
                IType       type = Db4oClient.TypeResolver.Resolve(clause.FieldType);


                switch (type.DisplayName)
                {
                case BusinessConstants.DATETIME:
                {
                    IConstraint        c1 = null, c2 = null;
                    DateTimeFormatInfo dateTimeFormatterProvider = DateTimeFormatInfo.CurrentInfo.Clone() as DateTimeFormatInfo;
                    dateTimeFormatterProvider.ShortDatePattern = "MM/dd/yyyy hh:mm:ss tt";
                    DateTime dt = DateTime.Parse(clause.Value.Trim(), dateTimeFormatterProvider);

                    DateTime dt1 = dt.AddDays(-1);
                    DateTime dt2 = dt.AddDays(1);
                    if (clause.Operator.Equals(BusinessConstants.CONDITION_EQUALS))
                    {
                        cons = q.Constrain(dt2).Smaller().And(q.Constrain(dt1).Greater());
                    }

                    else if (clause.Operator.Equals(BusinessConstants.CONDITION_GREATERTHAN))
                    {
                        c1   = q.Constrain(dt2).Greater();
                        c2   = q.Constrain(dt2.AddDays(1)).Smaller().And(q.Constrain(dt).Greater());
                        cons = c1.Or(c2);
                        c1   = null;
                        c2   = null;
                    }
                    else if (clause.Operator.Equals(BusinessConstants.CONDITION_LESSTHAN))
                    {
                        c1   = q.Constrain(dt1).Smaller();
                        c2   = q.Constrain(dt).Smaller().And(q.Constrain(dt1.AddDays(-1)).Greater());
                        cons = c1.Or(c2);
                    }
                    break;
                }

                default:
                    cons = q.Constrain(type.Cast(clause.Value));
                    break;
                }

                return(cons);
            }
            catch (Exception oEx)
            {
                LoggingHelper.HandleException(oEx);
                return(null);
            }
        }
Exemple #2
0
        public virtual void TestImplicitAndOnOrs()
        {
            IQuery      query = CreateItemQuery();
            IConstraint c1    = query.Descend("foo").Constrain(4).Smaller();
            IConstraint c2    = query.Descend("foo").Constrain(3).Greater();
            IConstraint c3    = query.Descend("foo").Constrain(4).Greater();

            c1.Or(c2);
            c1.Or(c3);
            AssertExpectedFoos(typeof(FieldIndexItem), new int[] { 3, 4, 7, 9 }, query);
        }
        public virtual void TestTwoJoinLegs()
        {
            IQuery query = NewQuery(typeof(CollectionIndexedJoinTestCase.DataHolder)).Descend
                               (Collectionfieldname);
            IConstraint left = query.Descend(Idfieldname).Constrain(0);

            left.Or(query.Descend(Idfieldname).Constrain(1));
            IConstraint right = query.Descend(Idfieldname).Constrain(2);

            right.Or(query.Descend(Idfieldname).Constrain(-1));
            left.Or(right);
            IObjectSet result = query.Execute();

            Assert.AreEqual(3, result.Count);
        }
Exemple #4
0
        private IConstraint AddInterfaceConstraint(IReflectClass claxx)
        {
            Collection4 classes = Stream().ClassCollection().ForInterface(claxx);

            if (classes.Size() == 0)
            {
                QConClass qcc = new QConClass(_trans, null, null, claxx);
                AddConstraint(qcc);
                return(qcc);
            }
            IEnumerator i      = classes.GetEnumerator();
            IConstraint constr = null;

            while (i.MoveNext())
            {
                ClassMetadata classMetadata      = (ClassMetadata)i.Current;
                IReflectClass classMetadataClaxx = classMetadata.ClassReflector();
                if (classMetadataClaxx != null)
                {
                    if (!classMetadataClaxx.IsInterface())
                    {
                        if (constr == null)
                        {
                            constr = Constrain(classMetadataClaxx);
                        }
                        else
                        {
                            constr = constr.Or(Constrain(classMetadata.ClassReflector()));
                        }
                    }
                }
            }
            return(constr);
        }
        public virtual void AssertIndexedOr(int[] values, int expectedResultCount, int rootIdx
                                            , bool connectLeft)
        {
            IQuery query = NewQuery(typeof(CollectionIndexedJoinTestCase.DataHolder)).Descend
                               (Collectionfieldname);
            IConstraint constraint = query.Descend(Idfieldname).Constrain(values[rootIdx]);

            for (int idx = 0; idx < values.Length; idx++)
            {
                if (idx != rootIdx)
                {
                    IConstraint curConstraint = query.Descend(Idfieldname).Constrain(values[idx]);
                    if (connectLeft)
                    {
                        constraint.Or(curConstraint);
                    }
                    else
                    {
                        curConstraint.Or(constraint);
                    }
                }
            }
            IObjectSet result = query.Execute();

            Assert.AreEqual(expectedResultCount, result.Count);
        }
            public void Constrain(IQuery query)
            {
                IConstraint icon1 = query.Descend(InterfaceQueryTestCase.FieldA).Constrain(10);
                IConstraint icon2 = query.Descend(InterfaceQueryTestCase.FieldB).Constrain(10);

                icon1.Or(icon2);
            }
        public virtual void Test()
        {
            IQuery qBooks = NewQuery();

            qBooks.Constrain(typeof(MultiFieldIndexQueryTestCase.Book));
            qBooks.Descend("title").Constrain("Persistence").Like();
            IQuery      qAuthors   = qBooks.Descend("authors");
            IQuery      qFirstName = qAuthors.Descend("firstName");
            IQuery      qLastName  = qAuthors.Descend("lastName");
            IConstraint cAaron     = qFirstName.Constrain("Aaron").And(qLastName.Constrain("OneOK"
                                                                                           ));
            IConstraint cBill = qFirstName.Constrain("Bill").And(qLastName.Constrain("TwoOK")
                                                                 );

            cAaron.Or(cBill);
            IObjectSet results = qAuthors.Execute();

            Assert.AreEqual(4, results.Count);
            while (results.HasNext())
            {
                MultiFieldIndexQueryTestCase.Person person = (MultiFieldIndexQueryTestCase.Person
                                                              )results.Next();
                Assert.IsTrue(person.lastName.EndsWith("OK"));
            }
        }
Exemple #8
0
        public virtual void TestTwoLevelDescendOr()
        {
            IQuery      query = CreateComplexItemQuery();
            IConstraint c1    = query.Descend("child").Descend("foo").Constrain(4).Smaller();
            IConstraint c2    = query.Descend("child").Descend("foo").Constrain(4).Greater();

            c1.Or(c2);
            AssertExpectedFoos(typeof(ComplexFieldIndexItem), new int[] { 4, 9 }, query);
        }
        public virtual void TestSimpleOrExpectNone()
        {
            IQuery      q  = NewItemQuery();
            IConstraint c1 = q.Descend("_id").Constrain(11);
            IConstraint c2 = q.Descend("_id").Constrain(13);

            c1.Or(c2);
            AssertResultSize(q, 0);
        }
Exemple #10
0
        public virtual void _testOrOnDifferentFields()
        {
            IQuery      query = CreateComplexItemQuery();
            IConstraint c1    = query.Descend("foo").Constrain(3);
            IConstraint c2    = query.Descend("bar").Constrain(8);

            c1.Or(c2);
            AssertExpectedFoos(typeof(ComplexFieldIndexItem), new int[] { 3, 7, 9 }, query);
        }
Exemple #11
0
        public virtual void TestCantOptimizeDifferentLevels()
        {
            IQuery      query = CreateComplexItemQuery();
            IConstraint c1    = query.Descend("child").Descend("foo").Constrain(4).Smaller();
            IConstraint c2    = query.Descend("foo").Constrain(7).Greater();

            c1.Or(c2);
            AssertCantOptimize(query);
        }
Exemple #12
0
        public virtual void TestCantOptimizeJoinOnNonIndexedFields()
        {
            IQuery      query = CreateQuery(typeof(NonIndexedFieldIndexItem));
            IConstraint c1    = query.Descend("foo").Constrain(1);
            IConstraint c2    = query.Descend("foo").Constrain(2);

            c1.Or(c2);
            AssertCantOptimize(query);
        }
Exemple #13
0
        public virtual void TestSingleIndexOr()
        {
            IQuery      query = CreateItemQuery();
            IConstraint c1    = query.Descend("foo").Constrain(4).Smaller();
            IConstraint c2    = query.Descend("foo").Constrain(7).Greater();

            c1.Or(c2);
            AssertExpectedFoos(typeof(FieldIndexItem), new int[] { 3, 9 }, query);
        }
Exemple #14
0
            public virtual void Visit(OrExpression expression)
            {
                expression.Left().Accept(this);
                IConstraint left = _constraint;

                expression.Right().Accept(this);
                left.Or(_constraint);
                _constraint = left;
            }
Exemple #15
0
        public virtual void TestTwoLevelDescendOr()
        {
            IQuery      query = CreateComplexItemQuery();
            IConstraint c1    = query.Descend("child").Descend("foo").Constrain(4).Smaller();
            IConstraint c2    = query.Descend("child").Descend("foo").Constrain(4).Greater();

            c1.Or(c2);
            AssertSingleOrNode(query);
        }
        public virtual void TestAndOr()
        {
            IQuery      q  = NewItemQuery();
            IConstraint c1 = q.Descend("_id").Constrain(1);
            IConstraint c2 = q.Descend("_id").Constrain(2);
            IConstraint c3 = q.Descend("_name").Constrain("A");

            c1.Or(c2).And(c3);
            AssertResultSize(q, 2);
        }
        public virtual void TestThreeOrsExpectTen()
        {
            IQuery      q  = NewItemQuery();
            IConstraint c1 = q.Descend("_name").Constrain("A");
            IConstraint c2 = q.Descend("_name").Constrain("B");
            IConstraint c3 = q.Descend("_name").Constrain("C");

            c1.Or(c2).Or(c3);
            AssertResultSize(q, 10);
        }
Exemple #18
0
        public virtual void TestThreeOrs()
        {
            IQuery      query = CreateItemQuery();
            IConstraint c1    = query.Descend("foo").Constrain(3);
            IConstraint c2    = query.Descend("foo").Constrain(4);
            IConstraint c3    = query.Descend("foo").Constrain(7);

            c1.Or(c2).Or(c3);
            AssertExpectedFoos(typeof(FieldIndexItem), new int[] { 3, 4, 7 }, query);
        }
Exemple #19
0
 public static IConstraint GetJointByType(IConstraint own, IConstraint with, JoinType type)
 {
     if (type == JoinType.And)
     {
         return(own.And(with));
     }
     if (type == JoinType.Or)
     {
         return(own.Or(with));
     }
     throw new NotSupportedException();
 }
Exemple #20
0
        public virtual void TestMultipleOrs()
        {
            IQuery      query = CreateComplexItemQuery();
            IConstraint c1    = query.Descend("foo").Constrain(4).Smaller();

            for (int i = 0; i < 5; i++)
            {
                IConstraint c2 = query.Descend("foo").Constrain(4).Greater();
                c1 = c1.Or(c2);
            }
            AssertSingleOrNode(query);
        }
Exemple #21
0
        public virtual void TestOrChildId()
        {
            IQuery      q      = NewQuery(typeof(DescendIndexQueryTestCase.Parent));
            IQuery      qChild = q.Descend("_child");
            IQuery      qId    = qChild.Descend("_id");
            IConstraint c1     = qId.Constrain(0);
            IConstraint c2     = qId.Constrain(10);
            IConstraint c3     = qId.Constrain(100);

            c1.Or(c2).Or(c3);
            AssertResultSize(q, 6);
        }
Exemple #22
0
        public virtual void TestSingleIndexOrRange()
        {
            IQuery      query = CreateItemQuery();
            IConstraint c1    = query.Descend("foo").Constrain(1).Greater();
            IConstraint c2    = query.Descend("foo").Constrain(4).Smaller();
            IConstraint c3    = query.Descend("foo").Constrain(4).Greater();
            IConstraint c4    = query.Descend("foo").Constrain(10).Smaller();
            IConstraint cc1   = c1.And(c2);
            IConstraint cc2   = c3.And(c4);

            cc1.Or(cc2);
            AssertExpectedFoos(typeof(FieldIndexItem), new int[] { 3, 7, 9 }, query);
        }
        /// <summary>
        /// adds a constraint to the passed Query to query only for objects that were
        /// modified since the last replication process between this and the other
        /// ObjectContainer involved in the current replication process.
        /// </summary>
        /// <remarks>
        /// adds a constraint to the passed Query to query only for objects that were
        /// modified since the last replication process between this and the other
        /// ObjectContainer involved in the current replication process.
        /// </remarks>
        /// <param name="query">the Query to be constrained</param>
        public virtual void WhereModified(IQuery query)
        {
            IQuery      qTimestamp = query.Descend(VirtualField.CommitTimestamp);
            IConstraint constraint = qTimestamp.Constrain(GetLastReplicationVersion()).Greater
                                         ();

            long[] concurrentTimestamps = _replicationRecord._concurrentTimestamps;
            if (concurrentTimestamps != null)
            {
                for (int i = 0; i < concurrentTimestamps.Length; i++)
                {
                    constraint = constraint.Or(qTimestamp.Constrain(concurrentTimestamps[i]));
                }
            }
        }
Exemple #24
0
        private void AssertAndOverOrQuery(bool explicitAnd)
        {
            IQuery      query = CreateItemQuery();
            IConstraint c1    = query.Descend("foo").Constrain(3);
            IConstraint c2    = query.Descend("foo").Constrain(9);
            IConstraint c3    = query.Descend("foo").Constrain(3);
            IConstraint c4    = query.Descend("foo").Constrain(7);
            IConstraint cc1   = c1.Or(c2);
            IConstraint cc2   = c3.Or(c4);

            if (explicitAnd)
            {
                cc1.And(cc2);
            }
            AssertExpectedFoos(typeof(FieldIndexItem), new int[] { 3 }, query);
        }
        public virtual void Test()
        {
            IQuery      query = NewQuery(typeof(OrderedOrConstraintTestCase.Item));
            IConstraint c1    = query.Descend("_int").Constrain(9).Greater();
            IConstraint c2    = query.Descend("_boolean").Constrain(true);

            c1.Or(c2);
            query.Descend("_int").OrderAscending();
            IObjectSet objectSet = query.Execute();

            Assert.AreEqual(2, objectSet.Count);
            OrderedOrConstraintTestCase.Item item = ((OrderedOrConstraintTestCase.Item)objectSet
                                                     .Next());
            Assert.AreEqual(4, item._int);
            item = ((OrderedOrConstraintTestCase.Item)objectSet.Next());
            Assert.AreEqual(10, item._int);
        }
Exemple #26
0
        public virtual void Test()
        {
            IQuery barQuery = Db().Query();

            barQuery.Constrain(typeof(PreserveJoinsTestCase.Child));
            barQuery.Descend("name").Constrain("bar");
            object barObj = barQuery.Execute().Next();
            IQuery query  = Db().Query();

            query.Constrain(typeof(PreserveJoinsTestCase.Parent));
            IConstraint c1        = query.Descend("value").Constrain("dontexist");
            IConstraint c2        = query.Descend("child").Constrain(barObj);
            IConstraint c1_and_c2 = c1.And(c2);
            IConstraint cParent   = query.Descend("value").Constrain("parent");

            c1_and_c2.Or(cParent);
            Assert.AreEqual(1, query.Execute().Count);
        }
        protected IObjectSet RetrieveHoldersWith(params T[] values)
        {
            IConstraint lastConstraint = null;

            var query = NewQuery(typeof(ValueTypeHolder));

            foreach (var value in values)
            {
                var constraint = query.Descend("Value").Constrain(value);
                if (lastConstraint != null)
                {
                    lastConstraint.Or(constraint);
                }

                lastConstraint = constraint;
            }

            return(query.Execute());
        }
Exemple #28
0
        protected override ICollection <TEdge> EdgesOf(TItem item)
        {
            ICollection <TEdge> result = null;

            try {
                // this doesn't optimize; it seems that the easiest way is to
                // override Graphs with concrete classes
                //result = _session.Query<TEdge>(delegate(TEdge e) {
                //    return e.Leaf.Equals(item) || e.Root.Equals(item);
                //});

                IQuery query = Session.Query();
                query.Constrain(typeof(TEdge));
                IConstraint constr = query.Descend("_root").Constrain(item);
                constr.Or(query.Descend("_leaf").Constrain(item));


                result = new NativeQueryWrapper <TEdge>(query.Execute());
            } catch (Exception e) {
                throw e;
            } finally { }
            return(result);
        }
Exemple #29
0
        public IObjectSet ExecuteOMQueryList()
        {
            try
            {
                IConstraint ConCatClauses = null;
                IConstraint buildClause;
                IConstraint conCatGroup = null;

                objectContainer = Db4oClient.Client;
                IQuery query = objectContainer.Query();

                //ToCheckQueryDirectly();

                FormulateRootConstraints(query, m_OmQuery.BaseClass);
                int Groupcount = 0;
                foreach (OMQueryGroup qmGroup in m_OmQuery.ListQueryGroup)
                {
                    int clausecount = 0;
                    Groupcount++;
                    buildClause = null;
                    foreach (OMQueryClause qmclause in qmGroup.ListQueryClauses)
                    {
                        clausecount++;
                        buildClause = FormulateFieldConstraints(query, qmclause);//.Classname, qmclause.Fieldname, qmclause.Value);
                        if (qmclause.Operator != null)
                        {
                            if (qmclause.FieldType != BusinessConstants.DATETIME)
                            {
                                buildClause = ApplyOperator(buildClause, qmclause.Operator);
                            }
                        }

                        if (qmclause.ClauseLogicalOperator == CommonValues.LogicalOperators.OR)
                        {
                            if (buildClause != null)
                            {
                                if (clausecount == 1)
                                {
                                    ConCatClauses = buildClause;
                                }
                                if (clausecount > 1)
                                {
                                    ConCatClauses = buildClause.Or(ConCatClauses);
                                }
                            }
                        }
                        if (qmclause.ClauseLogicalOperator == CommonValues.LogicalOperators.AND)
                        {
                            if (buildClause != null)
                            {
                                if (clausecount == 1)
                                {
                                    ConCatClauses = buildClause;
                                }
                                if (clausecount > 1)
                                {
                                    ConCatClauses = buildClause.And(ConCatClauses);
                                }
                            }
                        }
                    }

                    IConstraint buildGroup = ConCatClauses ?? buildClause;
                    if (qmGroup.GroupLogicalOperator != CommonValues.LogicalOperators.EMPTY)
                    {
                        if (qmGroup.GroupLogicalOperator == CommonValues.LogicalOperators.OR)
                        {
                            if (buildGroup != null)
                            {
                                conCatGroup = conCatGroup.Or(buildGroup);
                            }
                        }
                        if (qmGroup.GroupLogicalOperator == CommonValues.LogicalOperators.AND)
                        {
                            if (buildGroup != null)
                            {
                                conCatGroup = conCatGroup.And(buildGroup);
                            }
                        }
                    }
                    else
                    {
                        conCatGroup = buildGroup;
                    }
                }
                IObjectSet objSet = query.Execute();
                return(objSet);
            }
            catch (Exception oEx)
            {
                LoggingHelper.HandleException(oEx);
                return(null);
            }
        }