Question

如何使用postgres在表格的第2列或第3列之后的表格中添加新列？

我的代码如下

ALTER TABLE n_domains ADD COLUMN contract_nr int after owner_id

Answer 1

不，没有直接的方法可以做到这一点。并且有一个原因 - 每个查询都应该按照它需要的顺序（和格式等）列出它需要的所有字段，从而使得一个表中列的顺序无关紧要。

如果你真的需要这样做，我可以想到一个解决方法：

转储并保存相关表格的说明（使用pg_dump --schema-only --table=<schema.table> ...）
在保存的定义中添加所需的列
重命名已保存定义中的表，以便在您尝试创建时不与旧表的名称冲突
使用此定义创建新表
使用'INSERT INTO <new_table> SELECT field1，field2，<default_for_new_field>，field3，... FROM <old_table>';
重命名旧表
将新表重命名为原始名称
最终放下旧的，重命名的桌子，确保一切正常

Answer 2

列的顺序并不相关，将固定宽度列放在表格的前面可以优化数据的存储布局，它还可以使您的数据更容易在应用程序代码之外使用。

PostgreSQL不支持更改列排序（请参阅PostgreSQL wiki上的Alter column position）;如果表格相对孤立，最好的办法是重新创建表格：

CREATE TABLE foobar_new ( ... );
INSERT INTO foobar_new SELECT ... FROM foobar;
DROP TABLE foobar CASCADE;
ALTER TABLE foobar_new RENAME TO foobar;

如果您对表定义了大量视图或约束，则可以在新列之后重新添加所有列并删除原始列（请参阅PostgreSQL wiki以获取示例）。

Answer 3

这里真正的问题是它还没有完成。目前PostgreSQL的逻辑排序与物理排序相同。这是有问题的，因为您无法获得不同的逻辑顺序，但情况更糟，因为表格未自动自动打包，因此通过移动列你可以获得不同的性能特征。

通过设计意图来证明它是是没有意义的。当提交可接受的补丁时，它有可能在某些时候发生变化。

所有这些都说，依靠列的顺序定位，逻辑还是物理是一个好主意？一定不行。在生产代码中，您永远不应该使用隐式排序或*。为什么使代码比它需要的更脆弱？正确性应始终优先于保存几次击键。

作为一种解决方法，您实际上可以通过recreating the table, or through the "add and reorder" game
修改列排序
另见，

Column tetris重新排序以提高空间效率

Answer 4

列顺序与我相关，所以我创建了这个函数。看看它是否有帮助。它适用于索引，主键和触发器。缺少视图和外键以及其他功能。

示例：

SELECT xaddcolumn('table', 'col3 int NOT NULL DEFAULT 0', 'col2');

源代码：

CREATE OR REPLACE FUNCTION xaddcolumn(ptable text, pcol text, pafter text)  RETURNS void AS $BODY$
DECLARE
    rcol RECORD;
    rkey RECORD;
    ridx RECORD;
    rtgr RECORD;
    vsql text;
    vkey text;
    vidx text;
    cidx text;
    vtgr text;
    ctgr text;
    etgr text;
    vseq text;
    vtype text;
    vcols text;
BEGIN
    EXECUTE 'CREATE TABLE zzz_' || ptable || ' AS SELECT * FROM ' || ptable;
    --colunas
    vseq = '';
    vcols = '';
    vsql = 'CREATE TABLE ' || ptable || '(';
    FOR rcol IN SELECT column_name as col, udt_name as coltype, column_default as coldef,
        is_nullable as is_null, character_maximum_length as len,
        numeric_precision as num_prec, numeric_scale as num_scale
        FROM information_schema.columns
        WHERE table_name = ptable
        ORDER BY ordinal_position
    LOOP
        vtype = rcol.coltype;
        IF (substr(rcol.coldef,1,7) = 'nextval') THEN
            vtype = 'serial';
            vseq = vseq || 'SELECT setval(''' || ptable || '_' || rcol.col || '_seq'''
                || ', max(' || rcol.col || ')) FROM ' || ptable || ';';
        ELSIF (vtype = 'bpchar') THEN
            vtype = 'char';
        END IF;
        vsql = vsql || E'\n' || rcol.col || ' ' || vtype;
        IF (vtype in ('varchar', 'char')) THEN
            vsql = vsql || '(' || rcol.len || ')';
        ELSIF (vtype = 'numeric') THEN
            vsql = vsql || '(' || rcol.num_prec || ',' || rcol.num_scale || ')';
        END IF;
        IF (rcol.is_null = 'NO') THEN
            vsql = vsql || ' NOT NULL';
        END IF;
        IF (rcol.coldef <> '' AND vtype <> 'serial') THEN
            vsql = vsql || ' DEFAULT ' || rcol.coldef;
        END IF;
        vsql = vsql || E',';
        vcols = vcols || rcol.col || ',';
        --
        IF (rcol.col = pafter) THEN
            vsql = vsql || E'\n' || pcol || ',';
        END IF;
    END LOOP;
    vcols = substr(vcols,1,length(vcols)-1);
    --keys
    vkey = '';
    FOR rkey IN SELECT constraint_name as name, column_name as col
        FROM information_schema.key_column_usage
        WHERE table_name = ptable
    LOOP
        IF (vkey = '') THEN
            vkey = E'\nCONSTRAINT ' || rkey.name || ' PRIMARY KEY (';
        END IF;
        vkey = vkey || rkey.col || ',';
    END LOOP;
    IF (vkey <> '') THEN
        vsql = vsql || substr(vkey,1,length(vkey)-1) || ') ';
    END IF;
    vsql = substr(vsql,1,length(vsql)-1) || ') WITHOUT OIDS';
    --index
    vidx = '';
    cidx = '';
    FOR ridx IN SELECT s.indexrelname as nome, a.attname as col
        FROM pg_index i LEFT JOIN pg_class c ON c.oid = i.indrelid
        LEFT JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ANY(i.indkey)
        LEFT JOIN pg_stat_user_indexes s USING (indexrelid)
        WHERE c.relname = ptable AND i.indisunique != 't' AND i.indisprimary != 't'
        ORDER BY s.indexrelname
    LOOP
        IF (ridx.nome <> cidx) THEN
            IF (vidx <> '') THEN
                vidx = substr(vidx,1,length(vidx)-1) || ');';
            END IF;
            cidx = ridx.nome;
            vidx = vidx || E'\nCREATE INDEX ' || cidx || ' ON ' || ptable || ' (';
        END IF;
        vidx = vidx || ridx.col || ',';
    END LOOP;
    IF (vidx <> '') THEN
        vidx = substr(vidx,1,length(vidx)-1) || ')';
    END IF;
    --trigger
    vtgr = '';
    ctgr = '';
    etgr = '';
    FOR rtgr IN SELECT trigger_name as nome, event_manipulation as eve,
        action_statement as act, condition_timing as cond
        FROM information_schema.triggers
        WHERE event_object_table = ptable
    LOOP
        IF (rtgr.nome <> ctgr) THEN
            IF (vtgr <> '') THEN
                vtgr = replace(vtgr, '_@eve_', substr(etgr,1,length(etgr)-3));
            END IF;
            etgr = '';
            ctgr = rtgr.nome;
            vtgr = vtgr || 'CREATE TRIGGER ' || ctgr || ' ' || rtgr.cond || ' _@eve_ '
                || 'ON ' || ptable || ' FOR EACH ROW ' || rtgr.act || ';';
        END IF;
        etgr = etgr || rtgr.eve || ' OR ';
    END LOOP;
    IF (vtgr <> '') THEN
        vtgr = replace(vtgr, '_@eve_', substr(etgr,1,length(etgr)-3));
    END IF;
    --exclui velha e cria nova
    EXECUTE 'DROP TABLE ' || ptable;
    IF (EXISTS (SELECT sequence_name FROM information_schema.sequences
        WHERE sequence_name = ptable||'_id_seq'))
    THEN
        EXECUTE 'DROP SEQUENCE '||ptable||'_id_seq';
    END IF;
    EXECUTE vsql;
    --dados na nova
    EXECUTE 'INSERT INTO ' || ptable || '(' || vcols || ')' ||
        E'\nSELECT ' || vcols || ' FROM zzz_' || ptable;
    EXECUTE vseq;
    EXECUTE vidx;
    EXECUTE vtgr;
    EXECUTE 'DROP TABLE zzz_' || ptable;
END;
$BODY$ LANGUAGE plpgsql VOLATILE COST 100;

Answer 5

列的顺序在关系数据库中完全无关

是

例如，如果你使用Python，你会这样做：

cursor.execute( "SELECT id, name FROM users" )
for id, name in cursor:
    print id, name

或者你会这样做：

cursor.execute( "SELECT * FROM users" )
for row in cursor:
    print row['id'], row['name']

但是没有理智的人会使用这样的位置结果：

cursor.execute( "SELECT * FROM users" )
for id, name in cursor:
   print id, name

Answer 6

@Jeremy Gustie上面的解决方案几乎可以正常工作，但如果顺序关闭则会做错事（如果重新排序的序数使不兼容的类型匹配则完全失败）。试一试：

CREATE TABLE test1 (one varchar, two varchar, three varchar);
CREATE TABLE test2 (three varchar, two varchar, one varchar);
INSERT INTO test1 (one, two, three) VALUES ('one', 'two', 'three');
INSERT INTO test2 SELECT * FROM test1;
SELECT * FROM test2;

结果显示问题：

testdb=> select * from test2;
 three | two |  one
-------+-----+-------
 one   | two | three
(1 row)

您可以通过在插入中指定列名来解决此问题：

INSERT INTO test2 (one, two, three) SELECT * FROM test1;

这会给你你真正想要的东西：

testdb=> select * from test2;
 three | two | one
-------+-----+-----
 three | two | one
(1 row)

问题来自于你有遗产但没有这样做，正如我在peufeu的回复评论中所述。

更新：我想到你可以通过在SELECT子句中指定列名来对INSERT子句中的列名做同样的事情。您只需重新排序它们以匹配目标表中的序数：

INSERT INTO test2 SELECT three, two, one FROM test1;

你当然可以两者都做得非常明确：

INSERT INTO test2 (one, two, three) SELECT one, two, three FROM test1;

这样可以得到与上面相同的结果，列值可以正确匹配。

Answer 7

嗯，这对 DBA 来说是一种视觉上的好处，可以在引擎中实现，但性能损失很小。将列顺序表添加到 pg_catalog 或最适合的位置。将其保存在内存中并在某些查询之前使用它。为什么要考虑这么小的眼睛糖果。

Answer 8

@ Milen A. Radev

具有设定的列顺序的无关需求并不总是由提取它们的查询定义。来自pg_fetch_row的值不包含关联的列名，因此需要由SQL语句定义列。

简单的select * from需要固有的表结构知识，如果列的顺序发生变化，有时会导致问题。

使用pg_fetch_assoc是一种更可靠的方法，因为您可以引用列名称，因此使用简单的select * from。

如何使用postgres在表中的第2列或第3列之后的表中添加新列？

8 个答案: