| Age | Commit message (Collapse) | Author |
|---|
|
|
|
|
|
|
|
We added a new argument to the `select()` functions in
f30a4dafa5736c58bda54569ec9f46e6fdb2e200 to allow columns to be excluded
from the YAML output. Update the test to include the new argument in its
call.
I was getting this error about the `C` type parameter on the function:
error[E0282]: type annotations needed
--> src/select.rs:152:23
|
152 | let got = select(&conn, "test", "1", None).unwrap();
| ^^^^^^ cannot infer type for type parameter `C` declared on the function `select`
For more information about this error, try `rustc --explain E0282`.
The error makes sense in a way, but it also doesn't at all, because I'm
not passing a `Some` value into the function. If it's a `None`, then
what need is there to specify a type that's never used?
I wonder if there's a way to get this to work in a way that doesn't
require me to specify the type parameter when passing `None` for
`exclude_columns`.
|
|
If no excluded columns are given, exclude the primary key column by
default. Otherwise, exclude only those columns in the `exclude_columns`
list.
|
|
Instead of only excluding the primary key column, exclude any columns in
the given list. This allows us to pass a list of excluded columns on the
command line.
|
|
|
|
No longer need this.
|
|
If no records were found, continue to return `Yaml::Null`. If a single
record was found, return a `Yaml::Hash`. Otherwise, return a
`Yaml::Array` containing all the records.
|
|
|
|
We switched this to a `yaml_rust::yaml::Hash`.
|
|
This is implemented now.
|
|
|
|
Add a new function that allows using a specified column name for
selection. The `select()` function will default to using the table's
primary key column.
Still need to update the references to the "id" column in the function.
|
|
|
|
|
|
The primary key shouldn't be editable, so don't include it in the
resulting YAML.
|
|
I had used `to_string()` before because the in-progress code wouldn't
let me use `to_owned()`. Now that I've changed things around, this is
possible.
|
|
Change `column_names` from `Vec<yaml_rust::Yaml::String>` to
`Vec<String>`. This way we don't have to clone the `yaml_rust::Yaml`
value to insert into the `yaml_rust::yaml::Hash`.
Had some issues getting this to work. I tried calling
`stmt.column_names()` on its own, but this caused a borrow checker
error, as that creates an immutable borrow, while the `stmt.query_map()`
call is a mutable borrow, and we can't do both.
Found this ticket that describes exactly the problem I was having:
https://github.com/rusqlite/rusqlite/pull/523
Turns out I had the right idea to begin with: I needed to collect the
column names into a `Vec`. But don't use a `Vec` of `yaml_rust::Yaml`
values, because that requires excess cloning.
|
|
Instead of my earlier `std::collections::HashMap`, build the type we
want to return directly in the row closure.
Required copying some data like the column names, but I don't see a way
around that. I suppose we could make `yaml_rust::Yaml`s from the column
headers in the row closure too instead of copying an existing column
header that we otherwise never use.
This nearly passes the test I have for this function, but it includes
the `id` column in the `Yaml` hash. The primary key column will need to
be removed.
|
|
|
|
Not quite what the `yaml_rust::Yaml` output should be, but getting
closer.
|
|
|
|
|
|
It turns out that adding the primary key column name to the query via a
prepared parameter was causing it to be set as a literal instead of a
column name. The resulting SQL was:
SELECT
*
FROM test
WHERE 'id' = '1';
instead of:
SELECT
*
FROM test
WHERE "id" = '1';
When the `id` column is hard-coded, this works correctly, producing the
right SQL and extracting the correct record.
We'll need to update this to add the column name via the format string
like we've done with the table name so we can make it dynamic.
|
|
Add the `modern_sqlite` feature in order to use the `expanded_sql()`
method. This shows us the SQL query with parameters expanded.
|
|
Had one iteration too many over each column.
|
|
|
|
Can't get the info from inside the closure it seems. The row iterator
doesn't seem to be looping. Not sure what the story is yet. Maybe I'm
not converting the data types correctly.
|
|
|
|
Still a work in progress. Trying to figure out what makes the most sense
for converting between the different types in SQLite and YAML.
This code still has some compilation errors.
|
|
It turns out the previous code failed with error:
thread 'select::tests::select_extracts_a_database_record_as_yaml'
panicked at 'called `Result::unwrap()` on an `Err` value:
SqliteFailure(Error { code: Unknown, extended_code: 1 }, Some("near
\":table\": syntax error"))', src/select.rs:11:9
Seems that I can't use named parameters to pass the table name to
`FROM`. Use string formatting for that instead.
Converted the named parameter array to a `rusqlite::named_params!` macro
when I read about it, as that seems a bit more concise.
|
|
|
