Create Prepared.arg[x] property

[Abscissa]

Currently, prepared statements have a .setArg and .getArg. Should replace these with actual property-style accessors.

[Abscissa]

This should be implemented as a nested struct (with op overloading), but a nested struct's inability to access its outer appears to be a problem. In theory, this should be possible to work around (maybe...?), but attempting it appears to be fraught with danger:

• Giving the nested struct access to a refcounted Prepared handle is out because that would create a ref-counting cycle. (And I'm not 100% certain prepared statements will remain refcounted - They no longer have dtors, so ATM the ref-counting is arguably unnecessary. But I still need to investigate whether I can (or even should?) re-enable automatic releasing of statements from the server without breaking auto-purging.)

• Embedding a copy of the outer PreparedImpl struct is obviously out as that would be recursive and infinite-sized.

• As for giving the nested struct a pointer to the outer PreparedImpl:

  • I'm not certain how that may affect @safe-ability once mysql-native gains @safe-ty. (Currently on hold until mysql-native is ready to drop support for the non-@safe versions of vibe.d)

  • I don't want to create issues with anything becoming uncopyable. (I've already put a lot of effort into eliminating all known issues with uncopyable objects in mysql-native.)

So I'm not quite sure what to do and, at the very least, want to hold off until after mysql-native goes @safe.

• I'd rather not go converting anything to classes. I want to minimize or eliminate mysql-native's GC-heap activity, and that's just easier with structs.

Luckily, this isn't a crutial feature anyway, would just be a nicety.

[bausshf]

Another way to go about this would just be to have opIndex on the prepared implementation and have it simply mask the functions.

Then make the functions deprecated and in the future private.

So you'd do:

prepared[0] = foo;
prepared[1] = bar;

[schveiguy]

Ooh, nice idea! I typically use the variadic setArgs.

The right way to do this is to embed the struct that contains the parameters, and use an accessor to give ref access to the struct. Then if you store it outside the accessor call, it makes a copy anyway.

So e.g.:

struct PreparedArgs
{
   Variant[] args;
   opIndexAssign(...) { ... }
   ... // etc.
}

struct Prepared {
   // Variant[] _inParams;
  PreparedArgs args;
}

auto x = conn.prepare("SELECT * FROM `tab` WHERE `id` = ?");
x.args[0] = 5;
auto copiedArgs = x.args;
copiedArgs[0] = 10;
assert(x.args[0] == 5); // didn't affect original
x.args = copiedArgs; // now it does