Support database specific extensions

[irar2]

There are several keywords supported by Swift-Kuery that are not supported by some databases. At the moment we are aware of the following:

keyword	PostgreSQL	SQLite	MySQL	DB2
RETURNING	yes	no	no	no
ANY (subquery)	yes	no	yes
OFFSET without LIMIT	yes	no	no
FULL JOIN	yes	no	no
RIGHT JOIN	yes	no	yes

We propose to deal with each problem in a different way, because we are trying to find a trade-off between supporting as much as possible and still keeping Swift-Kuery reasonable:

• RETURNING - remove the current support. Allow RETURNING using raw, i.e. add raw(String) method to Insert and Update that will append the contents of the String to the query
• ANY - add a flag to QueryBuilder to indicate if ANY is supported, and throw an error during build of a query with ANY if it is not
• OFFSET - don't allow OFFSET without LIMIT
• JOINs - allow raw type of JOIN in Join enumeration

It is also possible to insert queries in raw queries, for example to support RETURNING in DB2:

let insert = Insert(...)
let insertDescription = connection.descriptionOf(insert)
let rawQuery = "SELECT * FROM FINAL table (\insertDescription)"
connection.execute(rawQuery) 

[ianpartridge]

I think this is a good approach. I'll carry on raising SQLite issues as I find them. We can close them in future.

[naithar]

@irar2 as mentioned in #52 and this comment: link, I'll move extension discussions to this issue, so there is no multiple issues for the same feature.

In this commit i've implemented an initial implementation of Extensions.

However, we are not sure your injection points are sufficient

Does injection points mean Position that is used by Extendable protocol? It's designed to be query independent, so for every query the Position should be different.

and also the use of priorities in case of several extensions at the same position worries us.

Doest it mean that there should be no multiple extensions on the same position or that usage of priorities could be error prone if not used correctly?

[irar2]

Hi @naithar,

Yes, by injection points I meant Position, and in my opinion Position is not flexible enough, it defines 5 points (for Select), and we prefer something more universal.

We think that priorities are error prone in this case.

[naithar]

@irar2
String's Range could also be used for injection. The building of a query should probably be changed for this to work, since extension should receive parts of query which in SELECT's case is SELECT, FROM, WHERE and the others. It also should be aware of other extensions that is currently applied to the query to not cause any errors.
The extesion's build method could probably be like:

func injectExtension(into queryParts: [String]) -> [String]

or

func injectExtension(into query: String, to: Range) -> String

Priorities was designed to work with Position atm, so it won't be needed if we find a way to inject extension without it.