Ошибка столбец c relhasoids не существует символ 245

4

    SQL error:
ERROR:  column «relhasoids» does not exist
LINE 1: SELECT relhasoids FROM pg_catalog.pg_class WHERE relname='pr...

    In statement:
SELECT relhasoids FROM pg_catalog.pg_class WHERE relname='product'
            AND relnamespace = (SELECT oid FROM pg_catalog.pg_namespace WHERE nspname='public')

1

Я пытаюсь выполнить команду СОЗДАТЬ ТАБЛИЦУ в Postgresql. После создания таблицы, если я введу ТАБЛИЦА имя таблицы , все заработает.

Но я набираю d имя таблицы , я получаю сообщение об ошибке ниже.

ERROR: column c.relhasoids does not exist
LINE 1: ...riggers, c.relrowsecurity, c.relforcerowsecurity, c.relhasoi...

Я попытался DROP DATABASE имя таблицы воссоздать базу данных и повторно создать таблицу несколько раз. Но это не сработало.

Мы ценим любые предложения! Спасибо.

Для всех, кто запускает Postgres как контейнер Docker :

Вместо запуска psql с хоста запустите его изнутри контейнера, например.

docker exec -it postgres_container_name psql your_connection_string

Образ Postgres всегда поставляется с соответствующей — и, следовательно, всегда обновляемой — версией psql < / em>, поэтому вам не нужно беспокоиться о том, чтобы на хост-машине была установлена ​​правильная версия.

$ docker run -it --entrypoint=bash postgres:12
# apt update && apt install pgxnclient postgresql-server-dev-12 && pgxn install ddlx
# psql -U postgres -c "create extension ddlx;"

WITH 
	  rel_kind(k,v) AS (
	         VALUES ('r','TABLE'),
	                ('p','TABLE'),
	                ('v','VIEW'),
	                ('i','INDEX'),
	                ('I','INDEX'),
	                ('S','SEQUENCE'),
	                ('s','SPECIAL'),
	                ('m','MATERIALIZED VIEW'),
	                ('c','TYPE'),
	                ('t','TOAST'),
	                ('f','FOREIGN TABLE')
	  ),
	  typ_type(k,v,v2) AS (
	         VALUES ('b','BASE','TYPE'),
	                ('c','COMPOSITE','TYPE'),
	                ('d','DOMAIN','DOMAIN'),
	                ('e','ENUM','TYPE'),
	                ('p','PSEUDO','TYPE'),
	                ('r','RANGE','TYPE')
	  )
	  SELECT c.oid,
	         'pg_class'::regclass,
	         c.relname AS name,
	         n.nspname AS namespace,
	         pg_get_userbyid(c.relowner) AS owner,
	         coalesce(cc.v,c.relkind::text) AS sql_kind,
	         cast(1::regclass AS text) AS sql_identifier,
	         relacl as acl
	    FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace
	    LEFT JOIN rel_kind AS cc on cc.k = c.relkind
	   WHERE c.oid = 1
	   UNION 
	  SELECT p.oid,
	         'pg_proc'::regclass,
	         p.proname AS name,
	         n.nspname AS namespace,
	         pg_get_userbyid(p.proowner) AS owner,
	         case
	           when p.proisagg then 'AGGREGATE'
	           else 'FUNCTION' 
	         end 
	         AS sql_kind,
	         cast(1::regprocedure AS text) AS sql_identifier,
	         proacl as acl
	    FROM pg_proc p JOIN pg_namespace n ON n.oid=p.pronamespace
	   WHERE p.oid = 1
	   UNION 
	  SELECT t.oid,
	         'pg_type'::regclass,
	         t.typname AS name,
	         n.nspname AS namespace,
	         pg_get_userbyid(t.typowner) AS owner,
	         coalesce(cc.v,tt.v2,t.typtype::text) AS sql_kind,
	         format_type(1,null) AS sql_identifier,
	         null as acl
	    FROM pg_type t JOIN pg_namespace n ON n.oid=t.typnamespace
	    LEFT JOIN typ_type AS tt ON tt.k = t.typtype
	    LEFT JOIN pg_class AS c ON c.oid = t.typrelid
	    LEFT JOIN rel_kind AS cc ON cc.k = c.relkind
	   WHERE t.oid = 1
	   UNION
	  SELECT r.oid,
	         'pg_roles'::regclass,
	         r.rolname as name,
	         null as namespace,
	         null as owner,
	         'ROLE' as sql_kind,
	         quote_ident(r.rolname) as sql_identifier,
	         null as acl
	    FROM pg_roles r
	   WHERE r.oid = 1
	   UNION
	  SELECT r.oid,
	         'pg_rewrite'::regclass,
	         r.rulename as name,
	         null as namespace,
	         null as owner,
	         'RULE' as sql_kind,
	         quote_ident(r.rulename)||' ON '|| 
	           cast(c.oid::regclass as text) sql_identifier,
	         null as acl
	    FROM pg_rewrite r JOIN pg_class c on (c.oid = r.ev_class)
	   WHERE r.oid = 1
	   UNION
	  SELECT n.oid,
	         'pg_namespace'::regclass,
	         n.nspname as name,
	         current_database() as namespace,
	         pg_get_userbyid(n.nspowner) AS owner,
	         'SCHEMA' as sql_kind,
	         quote_ident(n.nspname) as sql_identifier,
	         nspacl as acl
	    FROM pg_namespace n join pg_roles r on r.oid = n.nspowner
	   WHERE n.oid = 1
	   UNION
	  SELECT con.oid,
	         'pg_constraint'::regclass,
	         con.conname as name,
	         c.relname as namespace,
	         null as owner,
	         'CONSTRAINT' as sql_kind,
	         quote_ident(con.conname)
	         ||coalesce(' ON '||cast(c.oid::regclass as text),'') as sql_identifier,
	         null as acl
	    FROM pg_constraint con 
	    left JOIN pg_class c ON (con.conrelid=c.oid)
	    LEFT join (
	         values ('f','FOREIGN KEY'),
	                ('c','CHECK'),
	                ('x','EXCLUDE'),
	                ('u','UNIQUE'),
	                ('p','PRIMARY KEY'),
	                ('t','TRIGGER')
	         ) as tt on tt.column1 = con.contype
	   WHERE con.oid = 1
	   UNION
	  SELECT t.oid,
	         'pg_trigger'::regclass,
	         t.tgname as name,
	         c.relname as namespace,
	         null as owner,
	         'TRIGGER' as sql_kind,
	         format('%I ON %s',t.tgname,cast(c.oid::regclass as text)) as sql_identifier,
	         null as acl
	    FROM pg_trigger t join pg_class c on (t.tgrelid=c.oid)
	   WHERE t.oid = 1
	   UNION
	  SELECT ad.oid,
	         'pg_attrdef'::regclass,
	         a.attname as name,
	         c.relname as namespace,
	         null as owner,
	         'DEFAULT' as sql_kind,
	         format('%s.%I',cast(c.oid::regclass as text),a.attname) as sql_identifier,
	         null as acl
	    FROM pg_attrdef ad 
	    JOIN pg_class c ON (ad.adrelid=c.oid)
	    JOIN pg_attribute a ON (c.oid = a.attrelid and a.attnum=ad.adnum)
	   WHERE ad.oid = 1
	   UNION
	  SELECT op.oid,
	         'pg_operator'::regclass,
	         op.oprname as name,
	         n.nspname as namespace,
	         pg_get_userbyid(op.oprowner) as owner,
	         'OPERATOR' as sql_kind,
	         cast(op.oid::regoperator as text) as sql_identifier,
	         null as acl
	    FROM pg_operator op JOIN pg_namespace n ON n.oid=op.oprnamespace
	   WHERE op.oid = 1
	   UNION
	  SELECT cfg.oid,
	         'pg_ts_config'::regclass,
	         cfg.cfgname as name,
	         n.nspname as namespace,
	         pg_get_userbyid(cfg.cfgowner) as owner,
	         'TEXT SEARCH CONFIGURATION' as sql_kind,
	         cast(cfg.oid::regconfig as text) as sql_identifier,
	         null as acl
	    FROM pg_ts_config cfg JOIN pg_namespace n ON n.oid=cfg.cfgnamespace
	   WHERE cfg.oid = 1
	   UNION
	  SELECT dict.oid,
	         'pg_ts_dict'::regclass,
	         dict.dictname as name,
	         n.nspname as namespace,
	         pg_get_userbyid(dict.dictowner) as owner,
	         'TEXT SEARCH DICTIONARY' as sql_kind,
	         cast(dict.oid::regdictionary as text) as sql_identifier,
	         null as acl
	    FROM pg_ts_dict dict JOIN pg_namespace n ON n.oid=dict.dictnamespace
	   WHERE dict.oid = 1
	   UNION
	  SELECT prs.oid,
	         'pg_ts_parser'::regclass,
	         prs.prsname as name,
	         n.nspname as namespace,
	         null as owner,
	         'TEXT SEARCH PARSER' as sql_kind,
	         format('%s%I',
	           quote_ident(nullif(n.nspname,current_schema()))||'.',prs.prsname) 
	           as sql_identifier,
	         null as acl
	    FROM pg_ts_parser prs JOIN pg_namespace n ON n.oid=prs.prsnamespace
	   WHERE prs.oid = 1
	   UNION
	  SELECT tmpl.oid,
	         'pg_ts_template'::regclass,
	         tmpl.tmplname as name,
	         n.nspname as namespace,
	         null as owner,
	         'TEXT SEARCH TEMPLATE' as sql_kind,
	         format('%s%I',
	           quote_ident(nullif(n.nspname,current_schema()))||'.',tmpl.tmplname) 
	           as sql_identifier,
	         null as acl
	    FROM pg_ts_template tmpl JOIN pg_namespace n ON n.oid=tmpl.tmplnamespace
	   WHERE tmpl.oid = 1
	   UNION
	  SELECT fdw.oid,
	         'pg_foreign_data_wrapper'::regclass,
	         fdw.fdwname as name,
	         null as namespace,
	         pg_get_userbyid(fdw.fdwowner) as owner,
	         'FOREIGN DATA WRAPPER' as sql_kind,
	         quote_ident(fdw.fdwname) as sql_identifier,
	         fdwacl as acl
	    FROM pg_foreign_data_wrapper fdw
	   WHERE fdw.oid = 1
	   UNION
	  SELECT srv.oid,
	         'pg_foreign_server'::regclass,
	         srv.srvname as name,
	         null as namespace,
	         pg_get_userbyid(srv.srvowner) as owner,
	         'SERVER' as sql_kind,
	         quote_ident(srv.srvname) as sql_identifier,
	         srvacl as acl
	    FROM pg_foreign_server srv
	   WHERE srv.oid = 1
	   UNION
	  SELECT ums.umid,
	         'pg_user_mapping'::regclass,
	         null as name,
	         null as namespace,
	         null as owner,
	         'USER MAPPING' as sql_kind,
	         'FOR '||quote_ident(ums.usename)||
	         ' SERVER '||quote_ident(ums.srvname) as sql_identifier,
	         null as acl
	    FROM pg_user_mappings ums
	   WHERE ums.umid = 1
	   UNION
	  SELECT ca.oid,
	         'pg_cast'::regclass,
	         null as name,
	         null as namespace,
	         null as owner,
	         'CAST' as sql_kind,
	         format('(%s AS %s)',
	           format_type(ca.castsource,null),format_type(ca.casttarget,null))
	           as sql_identifier,
	         null as acl
	    FROM pg_cast ca
	   WHERE ca.oid = 1
	   UNION
	  SELECT co.oid,
	         'pg_collation'::regclass,
	         co.collname as name,
	         n.nspname as namespace,
	         pg_get_userbyid(co.collowner) as owner,
	         'COLLATION' as sql_kind,
	         format('%s%I',
	           quote_ident(nullif(n.nspname,current_schema()))||'.',co.collname) 
	           as sql_identifier,
	         null as acl
	    FROM pg_collation co JOIN pg_namespace n ON n.oid=co.collnamespace
	   WHERE co.oid = 1
	   UNION
	  SELECT co.oid,
	         'pg_conversion'::regclass,
	         co.conname as name,
	         n.nspname as namespace,
	         pg_get_userbyid(co.conowner) as owner,
	         'CONVERSION' as sql_kind,
	         format('%s%I',
	           quote_ident(nullif(n.nspname,current_schema()))||'.',co.conname) 
	           as sql_identifier,
	         null as acl
	    FROM pg_conversion co JOIN pg_namespace n ON n.oid=co.connamespace
	   WHERE co.oid = 1
	   UNION
	  SELECT lan.oid,
	         'pg_language'::regclass,
	         lan.lanname as name,
	         null as namespace,
	         pg_get_userbyid(lan.lanowner) as owner,
	         'LANGUAGE' as sql_kind,
	         quote_ident(lan.lanname) as sql_identifier,
	         lan.lanacl as acl
	    FROM pg_language lan
	   WHERE lan.oid = 1
	   UNION
	  SELECT opf.oid,
	         'pg_opfamily'::regclass,
	         opf.opfname as name,
	         n.nspname as namespace,
	         pg_get_userbyid(opf.opfowner) as owner,
	         'OPERATOR FAMILY' as sql_kind,
	         format('%s%I USING %I',
	           quote_ident(nullif(n.nspname,current_schema()))||'.',
	           opf.opfname,
	           am.amname) 
	           as sql_identifier,
	         null as acl
	    FROM pg_opfamily opf JOIN pg_namespace n ON n.oid=opf.opfnamespace
	    JOIN pg_am am on (am.oid=opf.opfmethod)
	   WHERE opf.oid = 1
	   UNION
	  SELECT dat.oid,
	         'pg_database'::regclass,
	         dat.datname as name,
	         null as namespace,
	         pg_get_userbyid(dat.datdba) as owner,
	         'DATABASE' as sql_kind,
	         quote_ident(dat.datname) as sql_identifier,
	         dat.datacl as acl
	    FROM pg_database dat
	   WHERE dat.oid = 1
	   UNION
	  SELECT spc.oid,
	         'pg_tablespace'::regclass,
	         spc.spcname as name,
	         null as namespace,
	         pg_get_userbyid(spc.spcowner) as owner,
	         'TABLESPACE' as sql_kind,
	         quote_ident(spc.spcname) as sql_identifier,
	         spc.spcacl as acl
	    FROM pg_tablespace spc
	   WHERE spc.oid = 1
	   UNION
	  SELECT opc.oid,
	         'pg_opclass'::regclass,
	         opcname as name,
	         n.nspname as namespace,
	         pg_get_userbyid(opc.opcowner) as owner,
	         'OPERATOR CLASS' as sql_kind,
	         format('%s%I USING %I',
	           quote_ident(nullif(n.nspname,current_schema()))||'.',
	           opc.opcname,
	           am.amname) 
	           as sql_identifier,
	         null as acl
	    FROM pg_opclass opc JOIN pg_namespace n ON n.oid=opc.opcnamespace
	    JOIN pg_am am ON am.oid=opc.opcmethod
	   WHERE opc.oid = 1

ERROR:  column p.proisagg does not exist
LINE 41:             when p.proisagg then 'AGGREGATE'
                          ^
HINT:  Perhaps you meant to reference the column "p.prolang".