John's questions

Valor de string incorreto: \'\\xCD\\xCF\\xD7\\xA7\\xC9\\xFA...\\

Tudo no meu servidor deve estar utf8mb4, utf8mb4_uca1400_ai_cientão vamos analisar tudo.

Meu my.iniarquivo no Windows 10 para MariaDB 11.4.2:

[mysql]
default-character-set = utf8mb4

[mysqld]
datadir=C:/WAMP/MariaDB/data
port=3306
innodb_buffer_pool_size=50M
character-set-server=utf8mb4
character-set-client-handshake = FALSE
collation-server = utf8mb4_uca1400_ai_ci
general-log
general-log-file=C:/WAMP/MariaDB/logs/queries.log

[client]
default-character-set = utf8mb4
port=3306
plugin-dir=C:\WAMP\MariaDB/lib/plugin

A consulta local que uso para verificar conjuntos de caracteres e comparações:

SELECT LOWER(VARIABLE_NAME) AS `variable_name`, 
       GLOBAL_VALUE AS `global_value`, 
       DEFAULT_VALUE AS `default_value` 
FROM INFORMATION_SCHEMA.SYSTEM_VARIABLES 
WHERE VARIABLE_NAME LIKE '%CHARACTER_SET_%' 
   OR VARIABLE_NAME LIKE '%COLLATION_%' 
ORDER BY `VARIABLE_NAME` ASC;

Toda vez que faço uma migração de servidor, executo o seguinte:

SET CHARACTER SET 'utf8';
SET collation_connection = 'utf8mb4_uca1400_ai_ci';
SET GLOBAL collation_connection = 'utf8mb4_uca1400_ai_ci';
SET GLOBAL collation_database = 'utf8mb4_uca1400_ai_ci';
SET GLOBAL collation_server = 'utf8mb4_uca1400_ai_ci';

Os SHOW CREATE DATABASEretornos em utf8mb4e utf8mb4_uca1400_ai_ci.

A coluna associada ao erro usa utf8mb4_uca1400_ai_ci.

Isto é para uma mensagem de e-mail com o assunto "[标题]Satisfaça todas as suas fantasias sobre a turnê da mão de Xianxia." 🙄︀ Acho que algo se perdeu na tradução. Não tenho tudo no máximo em conjuntos de caracteres e agrupamentos, embora eu ache que já cobri a maioria das coisas. Então...

O que ainda não defini corretamente para conjuntos de caracteres e/ou ordenação e como posso garantir que tudo o que é possível esteja definido como utf8mb4e utf8mb4_uca1400_ai_ci?

Tenho lido o manual e os tutoriais do MariaDB e aparentemente isso deve funcionar:

EXPLAIN CREATE TABLE `prefix_database2`.`table1` LIKE `prefix_database1`.`table1`;`

O LIKEoperador deve duplicar as colunas e chaves da tabela. Não sei por que estou recebendo o erro de sintaxe.

Como duplico uma tabela em um segundo banco de dados do primeiro, mantendo exatamente as mesmas colunas, chaves, etc.?

• Eu tenho dois servidores de banco de dados, locais e ativos.
• O servidor local está executando o MariaDB 10.11.6, o servidor ativo está executando o 10.11.8.
• Eu tenho exatamente o mesmo usuário global, example@ localhostnos servidores locais e ativos.
• Executei exatamente a mesma consulta SQL ( UPDATE information_schema.TABLES ...) em ambos os servidores.
• As estruturas de banco de dados/tabela/coluna são exatamente as mesmas.
• A consulta funcionou 100% perfeita no servidor local.
• Recebi o seguinte erro no servidor ativo:

Acesso negado ao usuário 'example'@'localhost' ao banco de dados 'information_schema'

• Eu pesquisei e encontrei exatamente os mesmos resultados usando SELECT * FROM mysql.global_priv WHERE 'User'='example';.
• O usuário tem permissões globais, não limitadas a bancos de dados específicos nos servidores locais e ativos.
• No mysql.dbbanco de dados/tabela não há menção ao exampleusuário porque, novamente, ele possui permissões globais .
• No mysql.dbbanco de dados/tabela não há menção ao information_schemabanco de dados em nenhum dos servidores.

Como faço para forçar o MariaDB a permitir que o exampleusuário execute minha UPDATE information_schema.TABLES ...consulta no servidor ativo?

Eu tenho um banco de dados que foi dividido devido a problemas de agrupamento devido a uma migração de servidor.

1. Eu tenho o merge1banco de dados que é o banco de dados mais antigo, livre de dados corrompidos, mas não possui entradas mais recentes.

2. Eu tenho o merge2banco de dados que contém todas as entradas (antigas e novas), porém muitas das entradas mais antigas estão corrompidas (as entradas mais recentes estão bem).

3. Ambos os bancos de dados estão exatamente no mesmo servidor de banco de dados MariaDB. Já sei como fazer coisas como seletores de banco de dados ( merge1.table3).

4. Estou usando o rootusuário MariaDB que não é exposto ao público pois considero isso apenas uma manutenção puramente interna.

5. Não há absolutamente nenhuma diferença estrutural de banco de dados entre os dois bancos de dados e não haverá mudanças estruturais até que esta fusão de banco de dados seja concluída, sem que nenhuma esteja planejada de forma alguma.

Até agora, fiz um bom trabalho com o information_schema.COLUMNSbanco de dados e a tabela ( TABLE_NAMEe COLUMN_NAME). Portanto, tenho uma lista de todas as linhas de cada tabela:

SELECT `COLUMN_NAME` FROM information_schema.`COLUMNS` WHERE `TABLE_SCHEMA`='merge1';

Agora que o "quadro geral" está estabelecido, estou tentando determinar se e como tornar o trabalho mais fácil construindo dinamicamente as consultas, pois há muitas tabelas e algumas têm muitas colunas. Então, vamos que a tabela table3tenha xum número de colunas (duas colunas, dezenas, etc. Eu já sei que a merge1tabela tem 200 entradas básicas, então só preciso de INSERT201+ (um exemplo estático para manter as coisas simples).

Então aqui está meu exemplo aproximado e não funcional:

INSERT INTO merge1.table3 
(
 SELECT `COLUMN_NAME` 
 FROM information_schema.`COLUMNS` WHERE `TABLE_SCHEMA`='merge1'
)
VALUES 
(
 SELECT * FROM merge2.table3 information_schema WHERE id>200
);

O problema parece estar enraizado nos valores que estão sendo inseridos, já que o MariaDB parece estar satisfeito com o subfornecimento SELECTdos nomes das colunas. Talvez eu não esteja construindo dinamicamente a segunda metade da consulta?

Como faço para corrigir/melhorar a consulta para fornecer os nomes das colunas correspondentes sem ser forçado a defini-los estaticamente?

Fiz uma migração de servidor e quando portei os bancos de dados do servidor antigo para o novo houve alguma corrupção de dados. No exemplo, os dados binários IPv6 parecem exatamente iguais, porém as entradas do servidor antigo geralmente são retornadas como vazias. Os registros criados no novo servidor estão corretos. Não houve nenhuma alteração na estrutura do banco de dados.

Como faço para pegar as exportações originais do servidor antigo e importar apenas os novos registros dos bancos de dados do novo servidor?

Fiz uma migração de servidor e estou fazendo uma auditoria. No novo servidor, finalmente tive a liberdade de atualizar o MariaDB para 10.11 (precisava do 10.10 para obter suporte ao Unicode 14.0) e anteriormente estava preso no suporte ao Unicode 5.2.

Eu acompanhei isso via print_r(mysqli_get_charset($db));PHP. Depois de alterar o agrupamento do servidor ( SHOW VARIABLES LIKE '%coll%';) tudo aparece corretamente como utf8mb4_uca1400_ai_ci. Ainda não atualizei os bancos de dados ou tabelas, que estão todos parados, utf8mb4_unicode_520_cio que está bom por enquanto.

O problema é que print_r(mysqli_get_charset($db));retorna utf8mb4_general_ci. Então, investiguei iniciando minha instalação local do MariaDB, já que tenho o log de todas as consultas em execução. Quando você executa esse comando em PHP, ele se traduz na seguinte consulta:

SELECT `DEFAULT_COLLATION_NAME` FROM `information_schema`.`SCHEMATA` WHERE `SCHEMA_NAME`='__database_name_here__';

Ok, então peguei essa consulta e executei-a no servidor ativo e obtive utf8mb4_unicode_520_ci(de novo, tudo bem por enquanto). Por motivos não relacionados, reiniciei o servidor várias vezes, portanto isso não deve ser um problema de "preso na memória".

Então, onde está mysqli_get_charset($db)o utf8mb4_general_ciagrupamento para que eu possa atualizá-lo?

Encontrei pessoas recomendando usar ON DUPLICATE KEY UPDATEvárias UPDATElinhas usando uma única consulta. Infelizmente, ninguém parece estar usando SQL limpo (definindo uma chave primária óbvia ide usando pelo menos duas linhas) e, portanto, não consegui confirmar o efeito em um grau satisfatório.

Presuma que todos os dados na tabela existem e que algumas das quantitylinhas serão diferentes:

INSERT INTO variations (id, name, quantity) 
VALUES 
(1, 'John', 4), 
(2, 'Amy', 5), 
(3, 'Elizabeth', 6) 
ON DUPLICATE KEY UPDATE 
id=VALUES(id), 
name=VALUES(name), 
quantity=VALUES(quantity);

Se as quantidades na tabela são 1, 2 e 3, então o que eu constituí é que a consulta acima deve UPDATEser 4, 5 e 6. No entanto, a execução manual do comando retorna Affected rows: 0e os dados no meu aplicativo estão, sem dúvida, não mudando .

Esclarecimentos:

• As namelinhas podem ter seus valores alterados, estou tentando manter o código simples.
• A idé a chave primária e não há outras chaves.
• Não UPDATE precisa acontecer se todos os dados de toda a linha forem os mesmos entre a consulta e a linha da tabela.
• Às vezes, apenas uma coluna de dados pode ser alterada, às vezes, todas as colunas, exceto, idpodem ser alteradas.
• Não há esclarecimento sobre VALUES()se ele está usando os dados $row(por exemplo, do PHP) ou UPDATEse difere do que já está na linha.
• Não há esclarecimento sobre se todas as colunas devem ser especificadas (além da chave primária ou única).
• A documentação do MariaDB e do MySQL deixa uma nebulosa nuvem mística de incógnitas.
• Estou executando o MariaDB 10.2.6 (MySQL 5.5.5).

Estou tentado a despejar o código em um loop para executar uma UPDATEconsulta por linha , pois não tenho tempo para criar um projeto enorme com isso. Nenhum dos tópicos existentes aqui ou no SO aborda adequadamente o problema de consulta única de UPDATE múltipla (exemplos de uso caseparecem pesadelos monstruosos para construir) e, portanto, espero uma resposta que possa esclarecer isso sem qualquer dúvida, para que eu possa aprender com isso desafio frustrante.

Eu tenho duas colunas, material_size( texttipo) e material_size_temp( text[]tipo de matriz).

Quando eu corria UPDATE parts SET material_size_temp[0] = material_size;, obtinha valores como [0:0]={".021 x 2.450"}em vez de {".021 x 2.450"}.

Como faço para clonar a textcoluna de tipo para a coluna de text[]tipo de matriz?

Como posso referenciar dinamicamente um nome de sequência (como abaixo) usando uma combinação de strings e DECLAREvariáveis? O código abaixo está correto ou existe outro método para fazer isso?

Meu objetivo é fazer isso dentro de um bloco DO/ BEGINpor motivos de desempenho, além de me ajudar a entender o plpgsql fazendo algo útil, então não vou misturar isso ao PHP, a menos que seja realmente necessário.

DO $$
 DECLARE PKEY VARCHAR;
BEGIN

SELECT pg_attribute.attname INTO PKEY 
FROM pg_index, pg_class, pg_attribute 
WHERE pg_class.oid = 'parts1'::regclass 
AND indrelid = pg_class.oid 
AND pg_attribute.attrelid = pg_class.oid 
AND pg_attribute.attnum = any(pg_index.indkey) 
AND indisprimary;

--SELECT setval('parts1_id_seq', (SELECT MAX(pkey) + 1 FROM parts));
SELECT setval('parts1_' || PKEY || '_seq', (SELECT MAX(pkey) + 1 FROM parts));

  END;
$$ LANGUAGE plpgsql;

Então eu executo esta consulta:

SELECT f_copy_tbl('parts','parts1');

...enquanto trabalhava no código baseado nesta resposta e recebo esta mensagem de erro:

ERRO: a relação "partes1" já existe

pgAdmin III não mostra a tabela (e eu obviamente recarreguei a coluna da esquerda pressionando F5 depois de clicar nos itens corretos porque é um efeito de recarga em cascata). Apenas para cobrir minhas bases, eu executo a seguinte consulta:

DROP TABLE IF EXISTS parts1 RESTRICT;

...para o qual o psql retorna:

AVISO: a tabela "partes1" não existe, ignorando

Então, o que é parts1uma referência senão uma tabela?

Quantas consultas? Todas as consultas:

CREATE OR REPLACE FUNCTION f_copy_tbl(_tbl regclass, _newtbl text)
 RETURNS void AS
$func$
BEGIN

-- Copy table
EXECUTE format('CREATE TABLE %I (LIKE %s INCLUDING ALL);', _newtbl, _tbl);

-- Fix serial columns, if any
EXECUTE (
SELECT concat_ws(E'\n'
       , string_agg('CREATE SEQUENCE ' || seq, E';\n') || ';'
       , string_agg(format('ALTER SEQUENCE %s OWNED BY %I.%I;'
                          , seq, _newtbl, a.attname), E'\n')
       , 'ALTER TABLE ' || quote_ident(_newtbl)
       , string_agg(format($$ALTER %I SET DEFAULT nextval('%s'::regclass)$$
                                 , a.attname, seq), E',\n')
       )
FROM   pg_attribute  a
JOIN   pg_attrdef    ad ON ad.adrelid = a.attrelid
                       AND ad.adnum   = a.attnum
     , quote_ident(_newtbl || '_' || a.attname || '_seq') AS seq  -- new seq name
WHERE  a.attrelid = _tbl
AND    a.attnum > 0
AND    NOT a.attisdropped
AND    a.atttypid = ANY ('{int,int8,int2}'::regtype[])
AND    ad.adsrc = 'nextval('''
         || (pg_get_serial_sequence (a.attrelid::regclass::text, a.attname))::regclass
         || '''::regclass)'
);

--Now populate `parts1` table with `parts` table's content...
SELECT f_copy_tbl('parts','parts1');
INSERT INTO parts1 SELECT * FROM parts;

--Now get primary key so we can fix the sequence...
--DECLARE PKEY VARCHAR;
--SELECT pg_attribute.attname INTO PKEY FROM pg_index, pg_class, pg_attribute WHERE pg_class.oid = 'parts1'::regclass AND indrelid = pg_class.oid AND pg_attribute.attrelid = pg_class.oid AND pg_attribute.attnum = any(pg_index.indkey) AND indisprimary;

--Now 
--SELECT setval('parts1_' || INTO PKEY || '_seq', (SELECT MAX(pkey) + 1 FROM parts));


/**********
--Now get highest number of primary key *AND* increment it...
--DECLARE PKEY_NUMBER INTEGER;
--SELECT (PKEY + 1) INTO PKEY_NUMBER FROM parts1 ORDER BY PKEY DESC LIMIT 1;

--Fix primary key's autoincrement...
--ALTER SEQUENCE parts1_id_seq RESTART WITH PKEY_NUMBER;
*********/

END
$func$ LANGUAGE plpgsql VOLATILE;

Ao criar uma ferramenta de gerenciamento de colunas, me deparei com a necessidade de replicar tabelas rapidamente no PostgreSQL para não testar novas ferramentas com tabelas que não são de teste. Para testar efetivamente a nova ferramenta de coluna que pretendo usar na tabela parts, criei essa nova ferramenta para duplicar parts, para terminar com uma parts1tabela. Quando pensei que finalmente tinha resolvido todos os problemas, encontrei o seguinte erro quando a ferramenta de coluna exclui a tabela:

ERRO: não é possível descartar partes da tabela porque outros objetos dependem dela DETALHE: padrão para o ID da coluna parts1 da tabela depende da sequência parts_id_seq1

Passei a maior parte do meu dia trabalhando nessa solução, então, resumindo, posso simplesmente usar funções de string para renomear a SEQUENCE_NAMEvariável para desassociar a partstabela da partstabela ou é um problema mais complicado do que isso? Aqui está a consulta:

DO $$
  DECLARE
    SEQUENCE_NAME VARCHAR;
  BEGIN
    SELECT s.relname INTO SEQUENCE_NAME
    FROM pg_class AS s JOIN pg_depend d ON d.objid = s.oid 
    INNER JOIN pg_class AS t ON d.objid = s.oid AND d.refobjid = t.oid 
    INNER JOIN pg_attribute AS a ON (d.refobjid, d.refobjsubid) = (a.attrelid, a.attnum) 
    INNER JOIN pg_namespace AS n ON n.oid = s.relnamespace 
    WHERE s.relkind = 'S' 
    AND n.nspname = 'public' 
    AND t.relname='parts';

    LOCK TABLE parts;
    CREATE TABLE parts1 (LIKE parts INCLUDING ALL);
    INSERT INTO parts1 SELECT * FROM parts;
    PERFORM setval(SEQUENCE_NAME::regclass, (SELECT max(id) FROM parts)+1);
  END;
$$ LANGUAGE plpgsql;

Eu examinei a documentação do 9.3 e não encontrei nada que sugerisse que eu posso ou não usar dados de uma SELECTconsulta dentro de uma BEGINconsulta. É possível ou terei que recorrer a WITHalgum tipo de consulta?

Estou tentando mesclar duas consultas em uma única BEGINconsulta para descobrir como ser mais eficiente ao executar consultas ao banco de dados. Eu tenho outro projeto que este coelho rastreia de onde eu construí uma ferramenta que duplica rapidamente uma tabela (para que eu possa testar outras ferramentas de banco de dados que estou construindo em vez dos originais), no entanto, ela não replica a chave primária.

Esta primeira consulta busca o sequencenome de uma tabela:

SELECT s.relname AS sequence 
FROM pg_class AS s JOIN pg_depend d ON d.objid = s.oid 
INNER JOIN pg_class AS t ON d.objid = s.oid AND d.refobjid = t.oid 
INNER JOIN pg_attribute AS a ON (d.refobjid, d.refobjsubid) = (a.attrelid, a.attnum) 
INNER JOIN pg_namespace AS n ON n.oid = s.relnamespace 
WHERE s.relkind = 'S' 
AND n.nspname = 'public' 
AND t.relname='parts';

Esta segunda consulta duplica uma tabela, embora já contenha o sequencenome obtido na primeira consulta:

BEGIN;
LOCK TABLE parts; 
CREATE TABLE parts1 (LIKE parts INCLUDING ALL);
INSERT INTO parts1 SELECT * FROM parts;
SELECT setval('parts_id_seq1', (SELECT max(id) FROM parts)+1);
COMMIT;

Eu tenho um cenário um tanto complicado em que uma tabela de teste que criei com uma chave primária não retornará a chave primária. O pgAdmin III informa que não há restrições. Eu tenho todo o log de consulta do PostgreSQL e abaixo tenho a consulta que usei para criar a tabela de teste. Em seguida, soltei a chave primária em uma tabela de teste diferente e usei a consulta gerada (ainda não é uma consulta que executei manualmente) para me ajudar a pesquisar pgAdmin III soltando a chave primária na tabela em questão e não encontrei nada procurando por:

ALTER TABLE public.delete_key_bigserial DROP CONSTRAINT

A string 'DROP CONSTRAINT' aparece apenas uma vez no log de consulta desde 02/12/2014, semanas antes de eu criar as tabelas de teste. Agora entendo que uma chave primária pode ou não ser definida como bigserialou serialaté mesmo criou uma tabela sem uma chave primária definida como id para inteiro e, em seguida, definida idcomo a chave primária (outra lata de worms para todo 'outro dia ).

Em uma pergunta anterior , perguntei sobre como buscar a data_typeinclusão se fosse bigserialou serialpara a qual Erwin Brandstetter tinha uma excelente resposta. Ele forneceu duas consultas em particular, uma para buscar os data_types para todas as colunas e outra para buscar a data_typechave primária. Infelizmente, uma das tabelas de teste com as quais tenho testado não está retornando nenhum resultado.

SELECT a.attrelid::regclass::text, a.attname,
CASE a.atttypid
 WHEN 'int'::regtype  THEN 'serial'
 WHEN 'int8'::regtype THEN 'bigserial'
 WHEN 'int2'::regtype THEN 'smallserial'
 END AS serial_type
FROM   pg_attribute  a
JOIN   pg_constraint c ON c.conrelid  = a.attrelid AND c.conkey[1] = a.attnum 
JOIN   pg_attrdef   ad ON ad.adrelid  = a.attrelid
                       AND ad.adnum   = a.attnum
WHERE  a.attrelid = 'delete_key_bigserial'::regclass
AND    a.attnum > 0
AND    NOT a.attisdropped
AND    a.atttypid = ANY('{int,int8,int2}'::regtype[]) -- integer type
AND    c.contype = 'p'                                -- PK
AND    array_length(c.conkey, 1) = 1                  -- single column
AND    ad.adsrc = 'nextval('''
            || (pg_get_serial_sequence (a.attrelid::regclass::text, a.attname))::regclass
            || '''::regclass)';

A consulta funciona perfeitamente em todas as outras tabelas.

Eu só trabalho com PostgreSQL desde novembro de 2014 e MySQL desde cerca de 2011, então a melhor coisa que posso fazer AFAIK é buscar o máximo de dados relevantes que puder. Aqui está a consulta usada para criar a delete_key_bigserialtabela a partir do log de consulta:

CREATE TABLE public.delete_key_bigserial (id bigserial PRIMARY KEY NOT NULL)
WITH (OIDS = FALSE);

Simplifiquei a consulta de Erwin e usei-a na tabela para comparar os resultados em minha ferramenta de consulta com diferentes tabelas de teste nas quais a consulta funciona perfeitamente bem (em todos os quatro data_types):

SELECT * FROM pg_attribute a 
WHERE a.attrelid = 'delete_key_bigserial'::regclass
AND a.attnum > 0
AND NOT a.attisdropped
AND attname='id'
ORDER BY a.attnum;

+----------+---------+----------+---------------+--------+--------+----------+-------------+
| attrelid | attname | atttypid | attstattarget | attlen | attnum | attndims | attcacheoff |
+----------+---------+----------+---------------+--------+--------+----------+-------------+
| 46390    | id      | 20       | -1            | 8      | 20     | 0        | -1          |
+----------+---------+----------+---------------+--------+--------+----------+-------------+

+-----------+----------+------------+----------+------------+-----------+--------------+
| atttypmod | attbyval | attstorage | attalign | attnotnull | atthasdef | attisdropped |
+-----------+----------+------------+----------+------------+-----------+--------------+
| -1        | f        | p          | d        | t          | t         | f            |
+-----------+----------+------------+----------+------------+-----------+--------------+

+------------+-------------+--------------+--------+------------+---------------+
| attislocal | attinhcount | attcollation | attacl | attoptions | attfdwoptions |
+------------+-------------+--------------+--------+------------+---------------+
| t          | 0           |              |        |            |               |
+------------+-------------+--------------+--------+------------+---------------+

Erwin está derivando o tipo por meio da atttypidcoluna quando outras condições são atendidas, no entanto, a coluna/linha resultante é idêntica a outras tabelas que funcionam. Há outra tabela de catálogo que usei em minhas tentativas de determinar qual data_typeé a chave primária, então decidi comparar os resultados dessa tabela também por meio da seguinte consulta:

SELECT * FROM information_schema.columns
WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
AND table_name='delete_key_bigserial'
AND is_nullable='NO';

A única diferença para qualquer coluna/linha retornada (além do nome da tabela nas colunas table_namee ) era a coluna. A tabela retorna a coluna com o valor , para uma tabela de trabalho a consulta retorna . A (parte inferior da) documentação element_types do PostgreSQL descreve a coluna como:column_defaultdtd_identifierdelete_key_bigserialdtd_identifier201

Um identificador do descritor de tipo de dados do elemento. Atualmente, isso não é útil.

Eu estou supondo que esta é uma moda obsoleta/antiga que é mantida para propósitos herdados, embora possa simplesmente se referir à própria descrição? Não tenho certeza, mas é aqui que estou e nem tenho certeza se estou no caminho certo.

Prefiro lidar com o problema e aprender com o cenário do que desconsiderá-lo simplesmente porque é uma tabela de teste, pois um dia tenho certeza que terei que lidar com esse problema quando não for uma tabela de teste. Ficarei feliz em atualizar minha pergunta com informações relevantes que podem ajudar a rastrear qual é o problema.

Combinei uma maneira de determinar o que data_typeé data_typeusado na sintaxe ao criar uma nova tabela com base na página wiki do PostgreSQL .

Se houver algo errado com minha consulta, preciso realmente saber o que , em um determinado cenário, o prejudicaria no contexto explícito de ter uma consulta ou consultas a serem executadas em um banco de dados/tabela puramente de teste para modificar esse banco de dados/tabela, então execute isto query para testar quaisquer falsos positivos.

SELECT pg_attribute.attname, 
format_type(pg_attribute.atttypid, pg_attribute.atttypmod),
CASE 
WHEN format_type(pg_attribute.atttypid, pg_attribute.atttypmod)='bigint' THEN 'bigserial'
WHEN format_type(pg_attribute.atttypid, pg_attribute.atttypmod)='integer' THEN 'serial'
END AS type
FROM pg_index, pg_class, pg_attribute 
WHERE pg_class.oid = 'delete2'::regclass 
AND indrelid = pg_class.oid 
AND pg_attribute.attrelid = pg_class.oid 
AND pg_attribute.attnum = any(pg_index.indkey) 
AND indisprimary;

Aqui está uma tabela com uma chave primária que não retorna a chave primária com esta consulta:

CREATE TABLE delete_key_bigserial (
  test1 integer,
  id bigserial NOT NULL,
  col1 text,
  col2 text,
  test2 integer
);

Me deparei com uma estranheza em que o PostgreSQL define o data_typeto ARRAYna information_schema.columnstabela. Eu fiz a seguinte consulta para obter algumas informações:

SELECT * FROM information_schema.columns 
WHERE table_schema NOT IN ('pg_catalog', 'information_schema') 
AND table_name='__table_name__';

Percebi a udt_namecoluna e estou me perguntando se é uma maneira confiável de determinar que tipo de array são os dados da coluna.

SELECT column_name, data_type, udt_name FROM information_schema.columns 
WHERE table_schema NOT IN ('pg_catalog', 'information_schema') 
AND table_name='__table_name__';

Atualmente, estou aprendendo as diferenças entre PostgreSQL e MySQL, pois tenho um novo projeto e também pretendo migrar meu software existente do MySQL para o PostgreSQL. Na verdade, comecei a criar uma tabela HTML com uma comparação de comandos (para usuários/bancos de dados/prompt de comando etc.) entre os dois. Depois de ler uma resposta aqui, notei que roleparece ser usado como um grupo. Com o MySQL, tenho dois usuários, basicamente públicos ( DELETE, INSERTe permissões) SELECTe UPDATEum usuário administrador com algumas permissões adicionais.

Então, basicamente, no prompt de comando do Windows 7 (somente desenvolvimento local)...

• Uma função é um usuário, grupo ou um termo vagamente usado específico do PostgreSQL?
• Como faço para conceder apenas permissões específicas a um usuário específico, para todas as tabelas em um banco de dados?
• Como concedo todas as permissões a um usuário específico, para todas as tabelas em um banco de dados?
• Como, se for o caso, uma função se compara a um usuário ao usar GRANTou REVOKEpara permissões de usuário?