Attempting to use the new query syntax in llblgen for the first time. The docs (The predicate system) suggests I can do something like this:

Example 1 IPredicateExpression filter = (UserFields.userId == program.userid); // problem here IRelationPredictateBucket bucket = new RelationPredicateBucket(filter); adapter.FetchEntity(user, bucket);

The above generates an error:

Cannot implicitly convert type 'SD.LLBLGen.Pro.ORMSupportClasses.Predicate' to 'SD.LLBLGen.Pro.ORMSupportClasses.IPredicateExpression'. An explicit conversion exists (are you missing a cast?)

However if I do the following, everything works fine

Example 2 IPredicateExpression filter = new PredicateExpression(); filter.Add(UserFields.userid = program.userid); adapter.FetchEntity(user, bucket);

I know it's something obvious but what am I doing wrong using the first example. Please note that if I change IPredicateExpression to IPredicate in Example 1, everything works fine.

erichar11 wrote:

Attempting to use the new query syntax in llblgen for the first time. The docs (The predicate system) suggests I can do something like this:

Example 1 IPredicateExpression filter = (UserFields.userId == program.userid); // problem here IRelationPredictateBucket bucket = new RelationPredicateBucket(filter); adapter.FetchEntity(user, bucket);

The above generates an error:

Cannot implicitly convert type 'SD.LLBLGen.Pro.ORMSupportClasses.Predicate' to 'SD.LLBLGen.Pro.ORMSupportClasses.IPredicateExpression'. An explicit conversion exists (are you missing a cast?)

Correct. (UserFields.userId == program.userid) returns a FieldCompareValuePredicate, which derives from Predicate. You can't equal it to a predicateexpression. You should do: IRelationPredictateBucket bucket = new RelationPredicateBucket((UserFields.userId == program.userid)); adapter.FetchEntity(user, bucket);

Hi Otis,

The latest v2 documention still suggests you can do what the poster had originally shown, which returns an error. Is this an error in the documentation or some very subtle difference between the example in the documentation (The predicate system, Constructing Predicate Expressions) and the example the original poster had used?

Hi,

I can't find in the documentation what you are referring to. Can you give us a pointer?

But now maybe you're referring to lines like:

IPredicateExpression B = ((Table1Fields.Foo == "One") & (Table1Fields.Bar == "Two")) // A
    | !(Table2Fields.Bar2 == "Three");

This is valid because the & and | operator overloads will implicitely build the predicate expression

Hi Jesse,

Actually, that is the example I'm referring to. I think it would be useful to at least two newbies (myself and the original poster) if an example using a single field was either shown in this part of the documentation or at least referred to in some way here (perhaps saying something like -- if building a single field comparison search, see the section FieldCompareExpressionPredicate further below). The documentation certainly states that the overloaded operators "&" and "|" will create predicate expressions, but to someone just getting up to speed on how to create filters, what this means when trying to create a filter using a single field might not be clear.

Thanks for responding so quickly!

Could an implicit operator conversion method be added to predicates to convert them into predicate expressions? Something like this:

In PredicateExpression's implementation:

public static implicit operator IPredicateExpression(IPredicate predicate)
{
  IPredicateExpression predicateExpression = new PredicateExpression(predicate);
  return predicateExpression;
}

In RelationPredicateBucket's implementation:

public static implicit operator IRelationPredicateBucket(IPredicateExpression predicateExpression)
{
  IRelationPredicateBucket bucket = new RelationPredicateBucket(predicateExpression);
  return bucket;
}

Then, for example, instead of having to do this:

adapter.FetchEntity(user, bucket);

you could do this:

adapter.FetchEntity(user, UserFields.Username = "foo");

I didn't try this out, but I think it could work? It'd be nice to not have to create buckets when I don't have relations and not to have to create predicate expressions manually when I have one predicate (which is an expression, just with one predicate).

-- Robert

Good suggestion, but I guess you ment FetchNewEntity() or FetchEntityCollection() rather than FetchEntity()

I'll try, but I have my doubts it will work due to the interfaces specified.

It won't work, you can't convert to / from an interface: error CS0552: 'SD.LLBLGen.Pro.ORMSupportClasses.PredicateExpression.implicit operator SD.LLBLGen.Pro.ORMSupportClasses.PredicateExpression(SD.LLBLGen.Pro.ORMSupportClasses.IPredicate)': user-defined conversion to/from interface

I already had to change IPredicateExpression in the first method to PredicateExpression to get rid of the error that you have to convert to/from the containing type.

If I change IPredicate to Predicate, it also doesn't compile: error CS0553: 'SD.LLBLGen.Pro.ORMSupportClasses.PredicateExpression.implicit operator SD.LLBLGen.Pro.ORMSupportClasses.PredicateExpression(SD.LLBLGen.Pro.ORMSupportClasses.Predicate)': user-defined conversion to/from base class

So that's the end of the line for this one. It was a nice suggestion though

Walla: correct, I just copied what was above without thinking

Otis: I tried this earlier today and yeah, it won't work for the Predicate -> PredicateExpression conversion because PredicateExpression derives from Predicate and C# doesn't allow you to define an operator (implicit or explicit) that converts from a base class or interface.

However, you can do this for a Predicate -> RelationPredicateBucket like so:

        public static implicit operator RelationPredicateBucket(Predicate predicate)
        {
            RelationPredicateBucket bucket = new RelationPredicateBucket(predicate);
            return bucket;
        }

            // works
            RelationPredicateBucket bucket = CarFields.Initials == "CSXT";
            a.FetchEntityCollection(c, bucket);

            // works
            a.FetchEntityCollection(c, (RelationPredicateBucket) (CarFields.Initials == "CSXT"));

            // doesn't work, can't implicitly cast
            a.FetchEntityCollection(c, CarFields.Initials == "CSXT");

Now, is that the correct thing to do anyway? Pulling back a little, I'm wondering if it is abuse of the language features. It doesn't seem so for the Predicate -> PredicateExpression conversion, to me, but it does seem a little dirty for the Predicate -> RelationPrediacteBucket.

Anyway, it's very easy to just do this anyway:

a.FetchEntityCollection(c, new RelationPredicateBucket(CarFields.Initials == "CSXT"));

Waiting for LINQ ...

I indeed find it a bit abusive, as the relation between a predicate like a FieldCompareValuePredicate and a relationpredicatebucket is IMHO too loose to make it logical to have the conversion (compared to int<->byte for example).

Yeah linq... . I've requested from MS the information needed to write a Linq compatible conversion layer for llblgen pro. Let's see what they come up with