kowainik / mysql-not-so-simple Goto Github PK

This is useful for further pattern-matching on the value.

And, probably, implement Show instance using this function?..

Subtask of #49
Depends on #55

Currently this function doesn't return error. But it should. Can be done separately. Probably will involve adding new constructor to MySqlError data type.

Useful for debugging purposes

So if we change API, we can just change single function and then regenerate all instances.

To give better error messages.

Subtask on #49

Just like in sqlite-simple library.

Probably can think of human-readable name as well (to be able to add it to custom Prelude).

Blocked by #6

Subtask of #49

Add this function:

queryNamed :: ... => MySQLConn -> Query -> [NamedParam] -> m [row]

using extractNames from MySql.Named as a black box.

MySql doesn't have booleans. So Bool is Int64 0 or 1 🤷‍♀️

Subtask of #49

Same as #53 but for executeNamed

Should be for TIMESTAMP column type

Currently when we failed to parse row we specify the id of the column that was failed to parse. But we can go even further. We can use ColumnDef to tell even more about failing column. The datatype is quite useful:

• https://hackage.haskell.org/package/mysql-haskell-0.8.3.0/docs/Database-MySQL-Protocol-ColumnDef.html#t:ColumnDef

We have list of all column definitions here:

https://github.com/Holmusk/mysql-not-so-simple/blob/28fcb4059bd91dade5587071dd137ddf032d77ac/src/MySql/Query.hs#L74

We can do this by adding [ColumnDef] field to the MatcherState and then use it later when we throw error.

MySQL doesn't support named parameters on the protocol level. So the only possible way to implement named parameters in our library is the following:

1. Introduce data type data NamedParam = NamedParam Text Param (where Text is the name of the parameter).
2. Implement functions executeNamed and queryNamed with types:

queryNamed :: FromRow row => MySQLConn -> Query -> [NamedParam] -> IO [row]

These function will parse Query and replace all occurrences of :nameOfTheParameter with ? and rearrange arguments in [NamedParam] list according to their occurrence in the Query. And then these functions just delegate their arguments to query and execute functions.

Regarding parsing of Query: I propose that after : only alphanumeric characters and underscores are allowed. I hope that : is not used anywhere in MySQL...

Any thoughts on this?

Currently we don't have tests so testing on CI doesn't make much sense and won't be very useful because without tests we can't verify that tests are actually working on the CI. If we do this issue right now, we probably will need to do it again after we have MySQL tests.

Using Generic capabilities

And don't forget to update property-based tests.

Every error has the following string at the beginning:

"MySql error: "

Probably can refactor it to not repeat this particular part every time.

To not depend on mysql-haskell library and be able to connect and execute queries without bringing extra dependency.

Subtask of #49

Just to test our functions

We will have single table with columns of different types (INT, TEXT, Double, TIMESTAMP) so later we can write tests. And, also, add PRIMARY KEY and stuff like that.

Apparently, mysql-haskell can't read two (and more) files in a row without throwing the exception two times before it works on the third run. So the dirty hack is to add the function which will take the list of files, read it and concatenate together as one big text and after run the MySQL.executeMany_ on that and hope that it won't fail.

OK data type contains information about this. And MySQL doesn't support RETURNING id clause. Maybe it makes sense to have something like:

newtype Id32 = Id32 Int32

executeReturningId :: MySQLConn -> Query -> IO Id32

They should take MySQLConnection as an argument so we could reuse them later with our WithDb constraint.

This line:

https://github.com/Holmusk/mysql-not-so-simple/blob/0b064fa8a2395d4985860f47b6de914d702b93e2/src/MySql/Row.hs#L118

The following is quite problematic, especially if we're going to store everything as TEXT:

https://github.com/Holmusk/mysql-not-so-simple/blob/cc1a479ae6f8ec5d388e84a244500337be43ee71/test/Test/Gen.hs#L31

Sometimes you call functions with a lot of SQL queries but current error reporting only shows the error without the SQL query itself. Because of that it's not that easy to find which query is not working. It would be better to add Query as well to relevant error constructors.

It's enough to test only tuples of length 2 and 3. And by induction we get proper behavior for tuple of every size.

Subtask of #49

Just as pure function for now (to make things easier).