Why PostgreSQL does not like UPPERCASE table names

Question

I have recently tried to create some tables in PostgreSQL all in uppercase names. However in order to query them I need to put the table name inside the "TABLE_NAME". Is there any way to avoid this and tell the postgres to work with uppercase name as normal ?

UPDATE

this query create a table with lowercase table_name

create table TABLE_NAME 
(
id integer,
name varchar(255)
)

However, this query creates a table with uppercase name "TABLE_NAME"

create table "TABLE_NAME"
(
id integer,
name varchar(255)
)

the problem is the quotations are part of the name now!! in my case I do not create the tables manually, another Application creates the table and the names are in capital letters. this cause problems when I want to use CQL filters via Geoserver.

Answer 1

The question implies that double quotes, when used to force PostgreSQL to recognize casing for an identifier name, actually become part of the identifier name. That's not correct. What does happen is that if you use double quotes to force casing, then you must always use double quotes to reference that identifier.

Background:

In PostgreSQL, names of identifiers are always folded to lowercase unless you surround the identifier name with double quotes. This can lead to confusion.

Consider what happens if you run these two statements in sequence:

CREATE TABLE my_table (
    t_id serial,
    some_value text
);

That creates a table named my_table.

Now, try to run this:

CREATE TABLE My_Table (
    t_id serial,
    some_value text
);

PostgreSQL ignores the uppercasing (because the table name is not surrounded by quotes) and tries to make another table called my_table. When that happens, it throws an error:

ERROR:  relation "my_table" already exists

To make a table with uppercase letters, you'd have to run:

CREATE TABLE "My_Table" (
    t_id serial,
    some_value text
);

Now you have two tables in your database:

 Schema |           Name            | Type  |  Owner   
--------+---------------------------+-------+----------
 public | My_Table                  | table | postgres
 public | my_table                  | table | postgres

The only way to ever access My_Table is to then surround the identifier name with double quotes, as in:

SELECT * FROM "My_Table"

If you leave the identifier unquoted, then PostgreSQL would fold it to lowercase and query my_table.

Answer 2

In simple words, Postgres treats the data in (double-quotes) "" as case-sensitive. And remaining as lowercase.

Example: we can create 2-columns with names DETAILS and details and while querying:

select "DETAILS" 

return DETAILS column data and

select details/DETAILS/Details/"details"

returns details column data.

Answer 3

put table name into double quotes if you want postgres to preserve case for relation names.

Quoting an identifier also makes it case-sensitive, whereas unquoted names are always folded to lower case. For example, the identifiers FOO, foo, and "foo" are considered the same by PostgreSQL, but "Foo" and "FOO" are different from these three and each other. (The folding of unquoted names to lower case in PostgreSQL is incompatible with the SQL standard, which says that unquoted names should be folded to upper case. Thus, foo should be equivalent to "FOO" not "foo" according to the standard. If you want to write portable applications you are advised to always quote a particular name or never quote it.)

from docs (emphasis mine)

example with quoting:

t=# create table "UC_TNAME" (i int);
CREATE TABLE
t=# \dt+ UC

t=# \dt+ "UC_TNAME"
                      List of relations
 Schema |   Name   | Type  |  Owner   |  Size   | Description
--------+----------+-------+----------+---------+-------------
 public | UC_TNAME | table | postgres | 0 bytes |
(1 row)

example without quoting:

t=# create table UC_TNAME (i int);
CREATE TABLE
t=# \dt+ UC_TNAME
                      List of relations
 Schema |   Name   | Type  |  Owner   |  Size   | Description
--------+----------+-------+----------+---------+-------------
 public | uc_tname | table | postgres | 0 bytes |
(1 row)

So if you created table with quotes, you should not skip quotes querying it. But if you skipped quotes creating object, the name was folded to lowercase and so will be with uppercase name in query - this way you "won't notice" it.