Re: FW: Question about the postgres resultset implementation

[Oliver Jowett <oliver(at)opencloud(dot)com>]

Tornroth, Phill wrote:

> I did some tinkering of my own and found that one of the problems with
> making the driver less cumbersome is the fact that findColumn() is currently
> case insensitive. I don't know if this is required by the jdbc spec, but it
> seems all the field names come back lower case (in the fields[] array), and
> so I could replace the implementation without understanding how to prevent
> the case of the field names from changing (changing from the case they were
> sent in as).

They come back lower-case because that's how they are in the actual 
schema. Unless you quote identifiers, they get smashed to lowercase by 
the backend:

> > test=> create table t1(lowercase integer, UPPERCASE integer, "QUOTEDUPPERCASE" integer);
> > CREATE TABLE
> > test=> select * from t1;
> >  lowercase | uppercase | QUOTEDUPPERCASE 
> > -----------+-----------+-----------------
> > (0 rows)

> At any rate, if case insensitivity could be thrown out then a very fast
> implementation could be worked out. As is, the following code was a marked
> improvement:

That change is slightly buggy as you *can* get uppercase characters in a 
field name.

We can't entirely discard case-insensitivy as JDBC requires that column 
names are found case-insensitively. This actually makes the use of 
column names somewhat unreliable if you ever have two columns with names 
that only differ by case. From the JDBC javadoc:

> > Column names used as input to getter methods are case insensitive. When
> > a getter method is called with a column name and several columns have
> > the same name, the value of the first matching column will be returned.
> > The column name option is designed to be used when column names are used
> > in the SQL query that generated the result set. For columns that are NOT
> > explicitly named in the query, it is best to use column numbers. If
> > column names are used, there is no way for the programmer to guarantee
> > that they actually refer to the intended columns.

(I am assuming that "findColumn" is considered a getter method.. the 
javadoc is vague as ever)

Nevertheless, we could certainly use a hashmap to speed up field 
lookups. This should be pretty trivial to implement, expect a patch shortly.

(hah, in fact I see that Kris got there first..)

-O