(It is my personal comment, not as a part of the Mono team.)
> But I just can't give up. Some projects are still waiting for DbLinq,
> and we're not far from something usable (for a professional use).
> Leaving the project would also be unfair for people like Pablo and the
> mono team.
Basically it is up to you whether you stop hacking dblinq or not.
You did a lot of good hacking and we appreciate much for you to have
opened the door to implement System.Data.Linq feature in Mono land.
Nothing is unfair. At least we didn't pay for you ;-)
IF you stopped hacking and the Mono project needs Linq to SQL
functionality within certain timeframe, we will have to assign
ourselves to work on dblinq. (But I rather find it difficult and
will give up to delay our timeframe.) Such work would have happened
no matter whether there was dblinq or not.
Having said that, the above are all for letting you to feel more
free about deciding which to go ;) We'd love you to continue your
dblinq hacking, especially people like Pablo. And there is not
many people who can drive a project that rocks.
We can also ask the mono community widely to help dblinq effort.
Let me know if you want. That may increase your project management
mess though ;)
Atsushi Eno
What do you think of that?
Matt's new work is ugly hack.
Andrus.
Pascal Craponne wrote:
> Hi Atsushi Eno,
>
> you are the best politician I've met: if I analyze your text below, here
> what's to be read:
> 1. Pascal is good
> 2. We need him
> 3. It's easier if he doesn't ask for help (even if help can be provided)
> Conclusion: carry on, dude ;)
Haha. But 3 is not really. I was just afraid that managing contributor
work than hacking is not so lovely for you. I'll ask community for
their interest.
> Now for the serious part (we are serious people, aren't we):
> I was thinking recently to support other databases than SQL server on
> mono. I read somewhere in MSDN documentation that if no
> ProviderAttribute is specified on the typed DataContext, then the
> database type is guessed by Linq to SQL, based on something like
> internal analysis (a simple query to database?). This way, for example,
> in .NET 3.5 SP1, support for SQL server 2008 has appeared, without
> breaking the specifications.
An essential problem here is that no matter how we can indicate
provider type through ProviderAttribute, other DatabaseProviders
are implemented based on DbLinq.Vendor.Implementation.SqlProvider
which is not publicly available on MONO_STRICT mode. So it will
stop working when the DBLinq core presumes that SqlProvider is
publicly available (i.e. when the provider is built with non-strict
DBLinq).
It might work if the public-at-compile-time type became internal
at runtime, but we cannot build other vendor providers, which is
no-go for us.
> So what if Mono implementation could "guess" the database type, based on
> the connection string or something like this? The implementation would
> either be compliant and support more databases than Linq to SQL. I think
> we could add some internal mechanisms to link to correct database,
> depending on IDbConnection implementation type, for example.
> What do you think of that?
Yes, that's possible and I thought it should be done inside mono
strict mode DataContext. But the problem above blocks to reach there.
Atsushi Eno
Pascal Craponne wrote:
> Hi, glad to read from you again.
>
> I'm not sure I get your point, so I explain more mine:
> 1. All vendors are in the System.Data.Linq.csproj. All as internal.
> 2. The public parts are exactly the same as they are in MS Linq, and we
> don't care here.
> 3. The trick is just that we find a way (somehow) to guess the vendor
> given a IDbConnection or a connection string (I'm more pessimistic about
> the last one).
> Where's the mistake above?
Ahh, OK, I was under the impression that other DB vendors than SQL
Server support won't go into System.Data.Linq.csproj (right now
only DBLinq.SqlServer is there). So, it is 1 :)
So, it won't block "identify by connection string" approach once we
get other vendors there. It could be also done for IDbConnection
by identifying its type i.e. "guess vendor by IDbConnection type".
I guess that's easier, especially considering that .ctor(
IDbConnection,...) is already implemented ;-)
Atsushi Eno