blob: 826c7018000edaf34ac278adfb829bf076963c4b (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
+ Warning on #pragma once in the main file
Current implementation changes libcpp's internal state to make the logic
work and filters the warning via libcpp's diagnostics callback.
An alternative approach would be to actually #include the header into
stdin rather than sourcing, just it like we do for the at-once mode.
This would require filtering stderr and removing all the "Included
from ..." lines (good we can choose the file id so can work around
translation). Also, the rather non-trivial header inclusion logic
(odb/include.?xx) will have to be adjusted. See also paper notes.
+ Statement name truncation in PostgreSQL [pgsql]
There seems to be a limit on the prepared statement name in PG. The result
is that the names are no longer unique (statement already exists error).
What we can do to help with that is put the statement kind (perists, find,
etc.) part at the beginning of the name rather than at the end as we do
now.
See email from <abellina@gmail.com>/11-Jun-2014.
In addition, implemented warning when an SQL name (statements and others)
exceed the default limit of 63 characters.
+ stderr_tracer doesn't trace statement preparation [2.4.0]
If a statement is invalid, then it will fail during preparation. However,
currently, there is no way to see that statement since stderr_tracer doesn't
trace this event.
Options:
* trace preparation by default - too much info
* allow changing behavior at runtime - not thread safe
* support via bool flag and make user instantiate - burdensome
* support via bool flag and instantiate stderr_full_tracer - code bloat
but seems the best option
+ C++11 support is not trully header only [c++11]
Added a new class details::function_wrapper<F>, which can be used similarly
to std::function<F>. In particular, C++11 code can construct a
function_wrapper from a lambda, or a std::function, or another
function_wrapper. But it differs from std::function in this respect:
C++98 code can declare and define function_wrapper objects.
Now all builds (98 or 11) of libodb keep their callbacks in
function_wrappers. C++11 user code can register std::functions or lambdas as
callbacks, and the glue that turns those into function_wrappers for libodb is
header-only.
This technique is currently used for data migrations and query factories.
|
