- Added the header access/heapam.h.
- Changed all instances of "length" to "data_length" to quiet
the compiler.
- initialized a few variables. The compiler couldn't see that
the code guaranteed that these would be initialized before
being dereferenced. If anyone wants to check my work follow
the usage of these variables and make sure that this true
and wasn't actually a bug in the original code.
- added a missing break statement to a default case. This
was a benign error but bad style.
- layed out heap_sysattrlen differently. I think this way
makes the structure of the code crystal clear. There should
be no actual difference in the actual behaviour of the code.
Submitted by: darcy@druid.druid.com (D'Arcy J.M. Cain)
NOTE: Makefile.custom is commented out, since it isn't there by default.
If you read the section telling you about it to know to create it,
you can uncomment it while you are there ...
current state of development...namely, we are on 2.0
NOTE:
BTW, the is also a check in postmaster which won't let you use an older
version of the database by checking the version number. The version number
of a database is in data/PG_VERSION (a plain ASCII file).
- Andrew
attributes as tcl arrays. The previous code had problems with some chars
used as delimiter by Tcl. The new code should be more robust.
By: Massimo Dal Zotto <dz@cs.unitn.it>
Async notifies received while a backend is in the middle of a begin/end
transaction block are lost by libpq when the final end command is issued.
The bug is in the routine PQexec of libpq. The routine throws away any
message from the backend when a message of type 'C' is received. This
type of message is sent when the result of a portal query command with
no tuples is returned. Unfortunately this is the case of the end command.
As all async notification are sent only when the transaction is finished,
if they are received in the middle of a transaction they are lost in the
libpq library. I added some tracing code to PQexec and this is the output:
Submitted by: Massimo Dal Zotto <dz@cs.unitn.it>
execute an sql function containing an utility command (create, notify, ...).
The bug is part in the planner, which returns a number of plans different
than the number of commands if there are utility commands in the query, and
in part in the function executor which assumes that all commands are normal
query commands and causes a SIGSEGV trying to execute commands without plan.
Submitted by: Massimo Dal Zotto <dz@cs.unitn.it>
|
|Here's a patch for Version 2 only. It just adds an Assert to catch some
|inconsistencies in the catalog classes.
|
|--
|Bryan Henderson Phone 408-227-6803
|San Jose, California
|
The problem is that the function arguments are not considered as possible key
candidates for index scan and so only a sequential scan is possible inside
the body of a function. I have therefore made some patches to the optimizer
so that indices are now used also by functions. I have also moved the plan
debug message from pg_eval to pg_plan so that it is printed also for plans
genereated for function execution. I had also to add an index rescan to the
executor because it ignored the parameters set in the execution state, they
were flagged as runtime variables in ExecInitIndexScan but then never used
by the executor so that the scan were always done with any key=1. Very odd.
This means that an index rescan is now done twice for each function execution
which uses an index, the first time when the index scan is initialized and
the second when the actual function arguments are finally available for the
execution. I don't know what is the cost of an double index scan but I
suppose it is anyway less than the cost of a full sequential scan, at leat
for large tables. This is my patch, you must also add -DINDEXSCAN_PATCH in
Makefile.global to enable the changes.
Submitted by: Massimo Dal Zotto <dz@cs.unitn.it>
The comparison routines for text and char data type give incorrect results
if the input data contains characters greater than 127. As these routines
perform the comparison using signed char variables all character codes
greater than 127 are interpreted as less than 0. These codes are used to
encode the iso8859 char sets.
The other text-like data types seem to work as expected as they use unsigned
chars in comparisons.
Submitted by: Massimo Dal Zotto <dz@cs.unitn.it>
