summaryrefslogtreecommitdiff
path: root/reference/bug/list
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.