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

问题描述 投票：55回答：7

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

我的代码如下所示

ALTER TABLE n_domains ADD COLUMN contract_nr int after owner_id
postgresql
7个回答
54
投票

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

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

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

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

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）。

4
投票

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

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

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

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

也可以看看，

2
投票

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

例：

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;
0
投票

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

是。

例如，如果你使用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
-1
投票

@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;

这为您提供了与上面相同的结果，列值正确匹配。

-2
投票

@ Milen A. Radev

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

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

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

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.