No method 'Contains' exists on type 'System.Data.Linq.DataQuery`1[System.Object]'

This is just syntactic sugar getting the better of you :)

The problem is that Contains indeed is not a method on DataQuery<T> - it's a static method in System.Linq.Queryable. The C# compiler handles this for you via extension methods, but that's just the C# compiler - it's not a feature of IL, it's a feature of C#. So when you're manipulating expression trees or emitting raw IL, you have to handle it yourself:

private Expression<Func<T, bool>> Contains<T, V>
 (string property, IQueryable<V> values, T item)
{
        ParameterExpression pe = Expression.Parameter(item.GetType(), "c");
        Expression columnNameProperty = Expression.Property(pe, property);
        var someValueContain = Expression.Constant(values, values.GetType());
        var convertExpression = Expression.Convert(columnNameProperty, typeof(V));
        Expression expression = 
          Expression.Call
          (
            (
             ((Expression<Func<bool>>)
             (() => Queryable.Contains(default(IQueryable<V>), default(V)))
            )
            .Body as MethodCallExpression).Method, 
            someValueContain, 
            convertExpression
          );

        return Expression.Lambda<Func<T, bool>>(expression, pe);
}

I'd avoid using dynamic in LINQ queries as well - the way you're using it, it's no better than having IEnumerable<object>, and if you want it to always be Guid anyway, just make it generic :)

This method assumes that whatever type of the column is convertible to the type of the items in the enumerable you're passing, of course, but it will work for any type, not just Guid.

However, this will not solve the second problem you have - it's quite explicit. The enumerable you're passing has way too many items to pass. Unless your LINQ provider has a better way of passing the values, you'll have to resort to splitting the query into multiple separate queries, each for e.g. 1000 items, and then joining the results back together. Unless of course, my guess is right, and the values you're passing is in fact a queryable as well - in that case, the code should work just fine.

EDIT:

The best way I've found of getting the proper MethodInfo is a set of methods like this:

public static MethodInfo Method<TR>(Expression<Func<TR>> expression)
{
    return (expression.Body as MethodCallExpression).Method;
}

public static MethodInfo Method<T1, TR>(Expression<Func<T1, TR>> expression)
{
    return (expression.Body as MethodCallExpression).Method;
}

(autogenerated the same way the actual Func<...> delegates are)

This allows simplifying getting the method info to this:

Method((IQueryable<T> queryable, T item) => queryable.Contains(item))

Or alternatively (to avoid having to generate all the possible overloads):

Method(() => default(IQueryable<T>).Contains(default(T)))