mysql-native v3.0.0

API Reference Home: [This Version] [Latest Version] [Other Versions]

Function queryValue

Execute an SQL SELECT command or prepared statement and return a single value: the first column of the first row received.

std.typecons.Nullable!(std.variant.VariantN!(32L).VariantN) queryValue (
  Connection conn,
  const(char[]) sql,
  ColumnSpecialization[] csa = null
);

Nullable!Variant queryValue(T...) (
  Connection conn,
  const(char[]) sql,
  T args
)
if (T.length > 0 && !is(T[0] == Variant[]) && !is(T[0] == ColumnSpecialization) && !is(T[0] == ColumnSpecialization[]));

std.typecons.Nullable!(std.variant.VariantN!(32L).VariantN) queryValue (
  Connection conn,
  const(char[]) sql,
  std.variant.VariantN!(32L)[] args
);

std.typecons.Nullable!(std.variant.VariantN!(32L).VariantN) queryValue (
  Connection conn,
  ref Prepared prepared
);

Nullable!Variant queryValue(T...) (
  Connection conn,
  ref Prepared prepared,
  T args
)
if (T.length > 0 && !is(T[0] == Variant[]) && !is(T[0] == ColumnSpecialization) && !is(T[0] == ColumnSpecialization[]));

std.typecons.Nullable!(std.variant.VariantN!(32L).VariantN) queryValue (
  Connection conn,
  ref Prepared prepared,
  std.variant.VariantN!(32L)[] args
);

std.typecons.Nullable!(std.variant.VariantN!(32L).VariantN) queryValue (
  Connection conn,
  ref BackwardCompatPrepared prepared
);

If the query did not produce any rows, or the rows it produced have zero columns, this will return Nullable!Variant(), ie, null. Test for this with result.isNull.

If the query DID produce a result, but the value actually received is NULL, then result.isNull will be FALSE, and result.get will produce a Variant which CONTAINS null. Check for this with result.get.type == typeid(typeof(null)).

If the SQL command does not produce a result set (such as INSERT/CREATE/etc), then MYXNoResultRecieved will be thrown. Use exec instead for such commands.

If args is supplied, the sql string will automatically be used as a prepared statement. Prepared statements are automatically cached by mysql-native, so there's no performance penalty for using this multiple times for the same statement instead of manually preparing a statement.

If args and prepared are both provided, args will be used, and any arguments that are already set in the prepared statement will automatically be replaced with args (note, just like calling Prepared.setArgs, this will also remove all ParameterSpecialization that may have been applied).

Only use the const(char[]) sql overload that doesn't take args when you are not going to be using the same command repeatedly and you are CERTAIN all the data you're sending is properly escaped. Otherwise, consider using overload that takes a Prepared.

If you need to use any ParameterSpecialization, use prepare to manually create a Prepared, and set your parameter specializations using Prepared.setArg or Prepared.setArgs.

Type Mappings

See the MySQL/D Type Mappings tables

Parameters

NameDescription
conn An open Connection to the database.
sql The SQL command to be run.
prepared The prepared statement to be run.
csa Not yet implemented.

Returns

Nullable!Variant: This will be null (check via Nullable.isNull) if the query resulted in an empty result set.

Example

auto myInt = 7;
Nullable!Variant value = myConnection.queryRow("SELECT * FROM `myTable` WHERE `a` = ?", myInt);