Question

I have a LINQ to SQL class, we’ll call it Test, and I want to be able to access properties with LINQ queries but I get the famed “No Supported Translation to SQL” runtime error. I’m interested in the conceptual problem. Here is my simplified class:

public class Test
{ 
  public int ID {get; set;} // Stored in Database
  public int NonForeignKeyValue {get; set;} // Stored in Database
}

Here is sort of an example of what I’m trying to accomplish, but I don’t want the overhead of always explicitly writing the join in LINQ:

var db = (new DataContext()).GetTable<Test>();
var q = (from t in db.GetTable<Test>()
         join o in db.GetTable<OtherTable>() on o.ID equals t.ID
         where t.OtherStuff
         select t)

I’d like to be able to add a property to Test that tells me if there are any rows in OtherTable that could be joined with Test:

  public bool IsInOtherTable
  {
    get
    {
       return (new DataContext())
              .GetTable<OtherTabke>()
              .Any(x => x.NonForeignKeyValue == this.NonForeignKeyValue));
    }
  }

Ultimately this is what I want my code to look like, but it errors. I basically want to return all entries that contain some database computed value:

using (DataContext db =  new DataContext())
{
   var q = db.GetTable<Test>()
             .Where(x => x.IsInOtherTable && x.OtherStuff); //Error
}       

I’m basically trying to save myself from writing this code every single time I want to check if Test has certain information in another table. I’m not that interested in the exact problem I described, I’m more interested in how to conceptually add the join part to the SQL and still use LINQ. I’m guessing I use Linq.Expression, but I really don’t know and I’m not aware of how to do it.

As an aside, I could just write the actual SQL, as its not that complicated, but I’d like to know how to get around this and still use LINQ.

Edit: I tried this property, but I get the same error. Its more complicated that just changing the return type to Expression…

public System.Linq.Expressions.Expression<Func<Article3, bool>> Exists
{
    get
    {
       using (DataContext db =  new DataContext())
       {
         return i => db.GetTable<OtherTable>()
                       .Any(x => x.NonForeignKeyValue == i.NonForeignKeyValue));
       }
    }
}        

Answer 1

Firstly, I think you may be overestimating “the overhead of always explicitly writing the join in LINQ”. It’s an extra line of code which has the advantage of being relatively self-documenting as to just what you are doing (always a nice thing), and any other approach is going to be turned first into SQL and then into a query plan that will be at least as expensive to execute, possibly more expensive (SQLServer is good a joins!)

Still, there are two alternatives I can thinkof.

One is to have an EntityRef property on the class that defines this relationship with the other table. You can then test if it is null in your query (or EntitySet if it’s on the other side of a one-to-many relationship).

The other is to define a SQL function that returns a bit result indicating whether an id refers to a row that does or doesn’t relate to the other table.

Then define a protected method on your DataContext-derived class that matches the signature in C# terms, and has a Function attribute mapping it to that SQL function. (Since this isn’t something that you can give a sensible non-db-using version of in the C# version, you can implement the C# function by calling ExecuteMethodCall).

Then you can use that method instead of the join.

Still, this is likely less self-explanatory in the code and at risk of being less efficient than just keeping the join.