Imported From: https://issues.scala-lang.org/browse/SI-8261?orig=1
Reporter: @retronym
Affected Versions: 2.11.0-M8

@retronym said:
As (finally) seen in: https://jenkins-dbuild.typesafe.com:8499/job/Community-2.11.x-retronym/14/console

@retronym said:
/cc Simon + Adriaan + Stefan.

Marking as blocker so we make a decision on this one. I haven't looked that the pattern of code in Slick that closely yet to know where the fix ought to be.

@szeiger said:
There is a related problem in Slick: SQL interpolation is limited to 22 variables. Both are caused by the use of auto-tupling in the .sql and .sqlu extension methods. The standard procedure there is to use varargs but we need an implicit SetParameter[_] for each element based on the element's type, so we reply on auto-tupling and provide SetParameter instances for all tuples. A possible fix for the second problem (which would also take care of the first) is to make these methods macros with varargs params. The macro could generate the correct SetParameter on the fly. Since the return type does not depend on the parameter types, it should be possible to write these methods as black-box macros.

@clhodapp said:
What about just doing something like [https://gist.github.com/clhodapp/e2e8726e063f8ddee503]?

@szeiger said:
@clhodapp That looks like a very nice solution

@clhodapp said (edited on Feb 12, 2014 11:43:31 AM UTC):
The only drawback is that you get an allocation for each argument, but I don't think that's avoidable while fixing the problem.

@szeiger said:
A macro-based implementation could avoid the extra allocation. It would turn a call like sql(i, s) into _sql_raw(i, s)(new SeqSetParameter(implicitly[SetParameter[i.type]], implicitly[SetParameter[s.type]]))

@adriaanm said (edited on Feb 13, 2014 2:13:06 AM UTC):
Cool, so, it sounds like we can leave ()-insertion deprecated.
Please reopen and assign to me if I misunderstood.

Samuel Halliday (fommil) said:
I just got stung by this. I don't understand how Chris' example helps here. How is one supposed to write a sql or sqlu query now?

e.g. for https://typesafe.com/activator/template/slick-plainsql-2.1#code/src/main/scala/Interpolation.scala

@clhodapp said:
My example was a way for SLICK itself to migrate from autotupling to varargs. It shouldn't affect source compatibility if they move to use it, but I think they may be moving to macros.

@szeiger said:
In Slick 2.1 you'll have to live with the warnings (or disable them). Macro-based versions of the SQL interpolators are coming in 2.2: slick/slick#834. They don't need auto-tupling and they're not limited to 22 parameters anymore.

Samuel Halliday (fommil) said:
I would like to use Slick in raw SQL mode on 2.11, but our project uses fatal warnings. Is there any way to turn off this specific warning from the compiler? Is there a Slick ticket that I can follow to know when this issue has been addressed?

@som-snytt said:
I asked this recently on the ML, because I overlooked this ticket.

One might have expected -source:2.10 to turn off language-level deprecations in 2.11. That might be a bug in the particular deprecation.

Also, deprecation should fall under -Xlint:deprecation as in javac. Then, Xlint could delegate deprecation to a pluggable mechanism. (As a suggested feature.)