/cc @kardianos

SGTM

I'll create an example shortly.

I've made this change in a local CL, but one thing I noticed that everywhere else they are referred to as "Parameters" from DefaultParameterConverter to comments. There are two places where we reference something called "args", in the comment above the function // The args are for any placeholder parameters in the query. and in the function argument itself. I think the proper fix is to change the function argument variable to params and then we would be consistent.

In MS-SQL it universally references Parameter for SQL function input values:
https://technet.microsoft.com/en-us/library/ms177436(v=sql.105).aspx

In sqlite, it uses argument for the C API and parameter for the SQL arguments: https://www.sqlite.org/c3ref/bind_blob.html

In postgresql documentation, argument and parameter are both used: https://www.postgresql.org/docs/9.4/static/xfunc-sql.html

I don't care strongly, but I think because we are already using Parameter in parts of the exported API already we should change args to params.
@rsc

CL https://golang.org/cl/33660 mentions this issue.

CL https://golang.org/cl/33663 mentions this issue.

I mailed both a rename per @rsc and just a comment and argument rename per my suggestion. Take the one you'd like.

"named parameter" is the only name used for these in every SQL implementation out there... I think calling them "named arguments" will be very confusing for users. sql.Named sounds like a fine name for the constructor, though.

@rsc, you cool with struct named sql.Param, constructor func sql.Named and renaming func args from args to params?

The "?name" syntax in the SQL string is a parameter. The value passed to Query or Exec is an argument. During the execution of the SQL statement, the argument is bound to the parameter.

@quentinmit, without a citation to what you are talking about, it's very hard to respond usefully. All I will say is that yes, "named parameter" is a widespread (and accurate) term for the concept of the named placeholders in the SQL queries. But the Go value being passed to Query or Exec that is bound to the named parameter during the SQL execution is a named argument.

@kardianos, thanks for the links. The MS-SQL docs are using parameter correctly. They use "value" where I am suggesting using "argument". The sqlite docs are using parameter and argument correctly. The postgresql docs also seem to be using parameter and argument correctly (they're very long and I didn't read the whole page).

We should be precise, like all the other implementations are precise. The value passed to Query/Exec is an argument, not a parameter. The struct should be NamedArg, or NamedArgument, certainly not NamedParameter. It could reasonably be NamedValue but that's in driver and I wasn't sure if that would be too confusing.

CL https://golang.org/cl/33760 mentions this issue.

Sorry posting comment on closed issue. @kardianos you've better to update this too: https://docs.google.com/document/d/1F778e7ZSNiSmbju3jsEWzShcb8lIO4kDyfKDNm4PNd8/edit#