pgsql հրամաններ. Postgres հրամաններ և սցենարներ: Ստանալով առկա տվյալների տեսակների ցանկը

postgres=# ՍՏԵՂԾԵԼ ՏՎՅԱԼՆԵՐԻ ԲԱԶԱՆ test_database; CREATE DATABASE postgres=# ՍՏԵՂԾԵԼ Օգտվողի test_user «qwerty» գաղտնաբառով; ՍՏԵՂԾԵԼ ԴԵՐ postgres=# ՏՐԱՄԱԴՐԵԼ ԲՈԼՈՐ արտոնությունները ՏՎՅԱԼՆԵՐԻ ԲԱԶՄՈՒՄ test_database test_user-ին; ԳՐԱՆՏ

Շելլից դուրս գալու համար մուտքագրեք \q հրամանը:

Այժմ փորձենք աշխատել ստեղծված տվյալների բազայի հետ test_user-ի անունից.

psql -h localhost test_database test_user

Եկեք ստեղծենք նոր աղյուսակ.

Test_database=> ՍՏԵՂԾԵԼ SEQUENCE user_ids; CREATE SEQUENCE test_database=> CREATE TABLE users (id INTEGER PRIMARY KEY DEFAULT NEXTVAL("user_ids"), login CHAR(64), password CHAR(64)); ԾԱՆՈՒՑՈՒՄ. ՍՏԵՂԾԵՔ ԱՂՅՈՒՍԱԿ / ՀԻՄՆԱԿԱՆ ԲԱՆԱԼԸ կՍՏԵՂԾԻ բացահայտ ինդեքս «users_pkey» ՍԵՂԱՆԱԿԻ «Օգտագործողների» ՀԱՄԱՐ ՍՏԵՂԾԵՔ ԱՂՅՈՒՍԱԿ

Օգտատիրոջ ջնջում

Օգտատիրոջը ջնջելու համար պետք է նրա իրավունքները փոխանցեք մեկ ուրիշին, այնուհետև միայն ջնջեք

ՎԵՐԱՍԱՀՄԱՆԵԼ Doomed_role-ին Սեփականատեր Հաջորդի_դերին; ԿԱՌԱՎԱՐՈՒՄ, որը պատկանում է doomed_role-ին;

- կրկնել նախորդ հրամանները կլաստերի յուրաքանչյուր բազայի համար

DROP ROLE doomed_role;

Postgres աղյուսակի կրկնօրինակի սցենար:

#!/bin/bash DBNAMES="web"; USER = "postgres"; DB_NAME = "վեբ"; NEW_OWNER="user_remote"; DATE_Y=`/bin/date "+%y"` DATE_M=`/bin/date "+%m"` DATE_D=`/bin/date "+%d"` SERVICE="pgdump" BACKUP_DIR="/var/ backup_db/20$(DATE_Y)/$(DATE_M)/$(DATE_D)" mkdir -p $BACKUP_DIR; tbl-ի համար `psql -qAt -c "ընտրեք սեղանի անունը pg_tables-ից, որտեղ schemaname = "public";" $(DB_NAME)` \ `psql -qAt -c "ընտրեք sequence_name-ը information_schema.sequences-ից, որտեղ sequence_schema = "public";" $(DB_NAME)` \ `psql -qAt -c "ընտրեք table_name-ը information_schema.views-ից, որտեղ table_schema = "public";" $(DB_NAME)` ; do echo «Արտահանում $tbl աղյուսակը db $(DB_NAME)-ից դեպի ֆայլ tables3/$tbl.backup" #pg_dump --format p --verbose --table public։$tbl $(DB_NAME) > $BACKUP_DIR/$tbl pg_dump - -format p --verbose --table public.$tbl $(DB_NAME) | gzip > $BACKUP_DIR/$tbl #pg_dump -a -d -t public.$tbl $(DB_NAME) > աղյուսակներ3/$tbl.sql կատարված է #################ՊԱՇՏՊԱՆՈՒՄ POSTGRES FUNCTIONS # Թափել տվյալների բազան առանց ամսաթվի, որպեսզի դրանք դուրս բերվեն դրանից հետագա գործառույթները pg_dump -Fc -s -f $BACKUP_DIR/db_dump $(DB_NAME) /bin/sleep 4; # Ստեղծել ցուցակի ֆունկցիա pg_restore -l $BACKUP_DIR/db_dump | grep FUNCTION > $BACKUP_DIR/function_list ##Ինչպես վերականգնել ֆունկցիաները ######################## #pg_restore -h localhost -U օգտվողի անուն -d բազային անունը - L function_list db_dump ########################

Postgres աղյուսակի կրկնօրինակի սցենար: գրված է perl-ով

Կատարել user'a - postgres-ի տակից: Եթե ​​crons-ում, ապա նաև postgresql օգտագործողի տակից։

#!/usr/bin/env perl օգտագործել խիստ; օգտագործել նախազգուշացումներ; my $database_name = "book_library"; իմ $ հարցումը =<<"EOT"; SELECT n.nspname as table_schema, c.relname as table_name FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE c.relkind IN ("r","") AND n.nspname NOT IN ("pg_catalog", "information_schema") AND n.nspname NOT LIKE "^pg_%" ; EOT $query =~ s/\n\s*/ /g; my @results = `echo "$query" | psql -At $database_name`; foreach (@results) { chomp; my ($schema, $table) = split /\|/, $_; next unless ($schema && $table); my $cmd = "pg_dump -U postgres -Fp -t $schema.$table -f $schema.$table.dump $database_name"; system($cmd); } #If you wanted to restore only a single function: ##pg_restore -U $username --dbname=$dbname --function=$functionname(args) #If you wanted to restore only a single table: ##pg_restore -U $username --dbname=$dbname --table=$tablename

Ամբողջական տեքստի որոնման բառարաններ postgresql-ում

Տվյալների բազայի կրկնօրինակում հեռավոր մեքենայից

PGPASSWORD="PASSWORD" pg_dump -h $HOSTNAME -U databaseuser -Fc --verbose "database.itc-life.ru" | gzip > databasename.gz

Կրկնօրինակեք և վերականգնեք աղյուսակները

AT PostgreSQLԿա երկու կոմունալ կրկնօրինակում pg_dump և pg_dumpall: pg_dump-ն օգտագործվում է մեկ տվյալների բազայի կրկնօրինակման համար, pg_dumpall-ն օգտագործվում է բոլոր տվյալների բազաները և սերվերն ամբողջությամբ կրկնօրինակելու համար (պետք է գործարկվի postgresql superuser-ի ներքո):

Տվյալների բազայի կրկնօրինակի ստեղծում mydb, սեղմված

Pg_dump -h localhost -p 5432 -U someuser -F c -b -v -f mydb.backup mydb

Տվյալների բազայի կրկնօրինակի ստեղծում mydb, որպես պարզ տեքստային ֆայլ, ներառյալ տվյալների բազա ստեղծելու հրաման

pg_dump -h localhost -p 5432 -U someuser -C -F p -b -v -f mydb.backup mydb

Տվյալների բազայի կրկնօրինակի ստեղծում mydb, սեղմված ձևով, աղյուսակներով, որոնք պարունակում են անվանման մեջ վճարումներ

Pg_dump -h localhost -p 5432 -U someuser -F c -b -v -t *payments* -f payment_tables.backup mydb

Միայն մեկ, կոնկրետ աղյուսակի տվյալների աղբանոց: Եթե ​​Ձեզ անհրաժեշտ է կրկնօրինակել մի քանի աղյուսակներ, ապա այդ աղյուսակների անունները նշված են ստեղնով -տյուրաքանչյուր սեղանի համար:

pg_dump -a -t table_name -f file_name database_name

Ստեղծեք սեղմված կրկնօրինակ գզ

pg_dump -h localhost -O -F p -c -U postgres mydb | gzip -c > mydb.gz

Առավել հաճախ օգտագործվող տարբերակների ցանկը.

H հոսթ - հյուրընկալող, եթե նշված չէ, ապա օգտագործվում է localhost PGHOST.

P նավահանգիստ - նավահանգիստ, եթե նշված չէ, ապա օգտագործվում է 5432 կամ արժեք շրջակա միջավայրի փոփոխականից PGPORT.

U - օգտագործող, եթե նշված չէ, ապա օգտագործվում է ընթացիկ օգտվողը, արժեքը կարող է նշվել նաև շրջակա միջավայրի փոփոխականում PGUSER.

A, --data-only - միայն dump-ի տվյալները, տվյալները և սխեման պահվում են լռելյայն:

Բ - աղբանոցում ներառել խոշոր օբյեկտներ (բլոգեր):

S, --schema-only - Միայն սխեմաները թափել:

C, --create - ավելացնում է հրաման տվյալների բազա ստեղծելու համար:

C - ավելացնում է հրամաններ՝ ջնջելու (թողնել) օբյեկտները (աղյուսակներ, դիտումներ և այլն):

O - մի ավելացրեք հրամաններ օբյեկտի սեփականատիրոջը սահմանելու համար (աղյուսակներ, դիտումներ և այլն):

F, --ձևաչափ (c|t|p) — ելքի ձևաչափ, սովորույթ, խեժ,կամ պարզ տեքստ.

T, --table=TABLE - նշեք կոնկրետ աղյուսակ աղբավայրի համար:

V, --verbose - ելքային մանրամասն տեղեկատվություն:

D, --attribute-inserts - dump օգտագործելով հրամանը ՆԵՐԴՐԵԼգույքի անվանումների ցանկով։

Կրկնօրինակեք բոլոր տվյալների բազաները՝ օգտագործելով pg_dumpall հրամանը:

pg_dumpall > all.sql # ստուգեք կրկնօրինակում grep «^[\]connect» all.sql \connect db1 \connect db2

PostgreSQL-ն ունի երկու կոմունալ ծրագիր վերականգնումպահեստային հիմքեր.

• psql- վերականգնել կրկնօրինակները, որոնք պահվում են պարզ տեքստային ֆայլում (պարզ տեքստ);
• pg_restore— սեղմված կրկնօրինակների վերականգնում (խեժ);

Տվյալների բազայի վերականգնում և

#pg_restore -v -e -d dbname dbname.dump

Ամբողջ կրկնօրինակի վերականգնում սխալների անտեսմամբ

psql -h localhost -U someuser -d dbname -f mydb.sql

Ամբողջական կրկնօրինակի վերականգնում, կանգ առնելով առաջին սխալի վրա

psql -h localhost -U someuser --set ON_ERROR_STOP=on -f mydb.sql

վերականգնվելու համար կուպր-արխիվ մենք պետք է նախ ստեղծենք տվյալների բազա՝ օգտագործելով CREATE DATABASE mydb; (եթե կրկնօրինակը ստեղծելիս -C տարբերակը նշված չի եղել) և վերականգնել

pg_restore --dbname=mydb --jobs=4 --բառս mydb.backup

Սեղմված տվյալների բազայի կրկնօրինակի վերականգնում գզ

Gunzip mydb.gz psql -U postgres -d mydb -f mydb

Սկսած 9.2 տարբերակից, միայն աղյուսակների կառուցվածքը կարող է վերականգնվել՝ օգտագործելով --section տարբերակը

# ստեղծել տվյալների բազա ՍՏԵՂԾԵԼ ՏՎՅԱԼՆԵՐԻ ԲԱԶԱՆ mydb2; #վերականգնել pg_restore --dbname=mydb2 --section=pre-data --jobs=4 mydb.backup

Սեղանի սպասարկում

VACUUM ANALYZE աղյուսակ; REINDEX ՏՎՅԱԼՆԵՐԻ ԲԱԶԱՆ dbName; REINDEX TABLE ներդիրի անունը;

Տվյալների գրացուցակի փոխանցում

Պարզեք ընթացիկ ուղին

# ճանապարհ 1 $ su - postgres $ psql psql > ՑՈՒՑԱԴՐԵԼ տվյալների_գրացուցակը; # ճանապարհ 2 $ ps կացին | grep «postgres -D»

Ստեղծեք նոր գրացուցակ, նշանակեք օգտվող և սկզբնավորեք

mkdir -p /pathto/postgresql/data chown -R postgres:postgres /pathto/postgresql su - postgres initdb -D /pathto/postgresql/data

Այժմ մենք պետք է շտկենք ֆայլը սկսվող ծառայության միջոցով postgresql

# under arch linux sudo vim /etc/systemd/system/multi-user.target.wants/postgresql.service Միջավայր =PGROOT=/pathto/postgresql/ PIDFile =/pathto/postgresql/data/postmaster.pid

Սեղանի մաքրում

Սեղանի մաքրում սեղանի անվանումըև զրոյացնել հաշվիչը ID-ով:

CRUNCATE TABLE աղյուսակի անվանումը ՎԵՐԱՍկսել նույնականացման ԿԱՍԿԱԴ;

ԿԱՍԿԱԴանհրաժեշտ է դեպքում սեղանի անվանումըկապված մեկ այլ աղյուսակի հետ:

NULL-ի հեռացում դաշտից

ALTER TABLE ֆիլմեր ALTER COLUMN year DROP NOT NULL;

Աշխատում է pgbouncer-ը

su -s /bin/sh - postgres -c "/usr/sbin/pgbouncer -d --verbose /etc/pgbouncer/pgbouncer.ini"

Օգտագործողներին հեռացնել տվյալների բազայից

SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = "mydb";`

Բարև բոլորին, այսօր ես ուզում եմ մի փոքր հիշեցում անել PostgreSQL հիմնական հրամանների մասին: Դուք կարող եք աշխատել PostgreSQL-ի հետ ինչպես ինտերակտիվ, այնպես էլ հրամանի տողից: Ծրագիրը psql է: Համոզված եմ, որ այս ցանկը շատ օգտակար կլինի ձեզ համար և կխնայի ձեր ժամանակը տարբեր ռեսուրսների միջոցով փնտրելու համար: Հիշեցնեմ, որ սա բաց կոդով նախագիծ է, որը հիմնված է Postgres DBMS-ի վրա, թողարկվել է 1986 թվականին, այն մշակվում է PGDG գլոբալ զարգացման խմբի կողմից, ըստ էության այն 5-8 հոգի է, բայց չնայած դրան, այն շատ է զարգանում։ ինտենսիվորեն՝ ներկայացնելով բոլոր նոր գործառույթները և շտկելով հին սխալներն ու սխալները:

Հիմնական PostgreSQL հրամանները ինտերակտիվ ռեժիմում.

• \connect db_name - միացեք տվյալների բազայի db_name անունով
• \du - օգտագործողների ցուցակ
• \dp (կամ \z) - աղյուսակների, դիտումների, հաջորդականությունների ցանկ, դրանց մուտքի իրավունքներ
• \di - ինդեքսներ
• \ds - հաջորդականություններ
• \dt - աղյուսակների ցանկ
• \dt+ - նկարագրությամբ բոլոր աղյուսակների ցանկը
• \dt *s* - անվանման մեջ s պարունակող բոլոր աղյուսակների ցանկը
• \dv - դիտումներ
• \dS - համակարգի աղյուսակներ
• \d+ - աղյուսակի նկարագրություն
• \o - հարցման արդյունքները ուղարկեք ֆայլ
• \l - տվյալների շտեմարանների ցանկ
• \i - կարդալ մուտքային տվյալները ֆայլից
• \e - բացում է հարցման բուֆերի ընթացիկ բովանդակությունը խմբագրում (եթե այլ բան նախատեսված չէ EDITOR փոփոխական միջավայրում, այն կօգտագործվի լռելյայնորեն vi-ով)
• \d «աղյուսակի_անուն» – աղյուսակի նկարագրություն
• \i հրաման է գործարկում արտաքին ֆայլից, օրինակ՝ \i /my/directory/my.sql
• \pset - ֆորմատավորման տարբերակները սահմանելու հրաման
• \echo - ցուցադրում է հաղորդագրություն
• \set - Սահմանում է շրջակա միջավայրի փոփոխականի արժեքը: Առանց պարամետրերի, ցուցադրում է ընթացիկ փոփոխականների ցանկը (\unset - deletes):
• \? - psql հղում
• \help - SQL հղում
• \q (կամ Ctrl+D) - դուրս գալ ծրագրից

PostgreSQL-ի հետ աշխատել հրամանի տողից.

• -c (կամ --հրաման) - գործարկել SQL հրամանը՝ առանց ինտերակտիվ ռեժիմի անցնելու
• -f file.sql - հրամաններ կատարել file file.sql-ից
• -l (կամ --list) թվարկում է առկա տվյալների բազաները
• -U (կամ --username) - նշեք օգտվողի անունը (օրինակ, postgres)
• -W (կամ --password) - գաղտնաբառի հուշում
• -d dbname - միանալ dbname տվյալների բազային
• -h - հյուրընկալողի անունը (սերվեր)
• -s - քայլ առ քայլ ռեժիմ, այսինքն, դուք պետք է հաստատեք բոլոր հրամանները
• -S - մեկ տող ռեժիմ, այսինքն՝ նոր տողը կկատարի հարցումը (ազատվում է, SQL կառուցվածքի վերջում)
• -V - PostgreSQL տարբերակ առանց ինտերակտիվ ռեժիմ մտնելու

Օրինակներ.

psql -U postgres -d dbname -c «ՍՏԵՂԾԵԼ ՍԵՂԱՆԱԿ my(some_id սերիական PRIMARY KEY, some_text text);» - հրամանի կատարում dbname տվյալների բազայում:

psql -d dbname -H -c «SELECT * FROM my» -o my.html - ելքային հարցման արդյունքը html ֆայլ:

PostgreSQL կոմունալ ծառայություններ (ծրագրեր).

• createb և dropdb - ստեղծել և թողնել տվյալների բազա (համապատասխանաբար)
• Creativeuser and dropuser - ստեղծել և օգտագործող (համապատասխանաբար)
• pg_ctl-ը ծրագիր է, որը նախատեսված է ընդհանուր կառավարման առաջադրանքները լուծելու համար (սկսել, դադարեցնել, սահմանել պարամետրերը և այլն):
• postmaster - PostgreSQL բազմաֆունկցիոնալ սերվերի մոդուլ (վրիպազերծման մակարդակների, նավահանգիստների, տվյալների գրացուցակների կազմաձևում)
• initdb - ստեղծել նոր PostgreSQL կլաստերներ
• initlocation - տվյալների բազաների երկրորդային պահպանման համար դիրեկտորիաներ ստեղծելու ծրագիր
• vacuumdb - տվյալների բազայի ֆիզիկական և վերլուծական սպասարկում
• pg_dump - տվյալների արխիվացում և վերականգնում
• pg_dumpall - կրկնօրինակեք ամբողջ PostgreSQL կլաստերը
• pg_restore - վերականգնել տվյալների բազան արխիվներից (.tar, .tar.gz)

Կրկնօրինակման օրինակներ.

mydb տվյալների բազայի կրկնօրինակի ստեղծում՝ սեղմված ձևով

Pg_dump -h localhost -p 5440 -U someuser -F c -b -v -f mydb.backup mydb

Mydb տվյալների բազայի կրկնօրինակի ստեղծում՝ որպես պարզ տեքստային ֆայլ, ներառյալ տվյալների բազա ստեղծելու հրաման

pg_dump -h localhost -p 5432 -U someuser -C -F p -b -v -f mydb.backup mydb

mydb տվյալների բազայի կրկնօրինակի ստեղծում՝ սեղմված ձևով, աղյուսակներով, որոնք պարունակում են վճարումներ անունով

Pg_dump -h localhost -p 5432 -U someuser -F c -b -v -t *payments* -f payment_tables.backup mydb

Միայն մեկ, կոնկրետ աղյուսակի տվյալների աղբանոց: Եթե ​​մեկից ավելի աղյուսակներ պետք է պահուստավորվեն, ապա աղյուսակների անունները թվարկվում են՝ օգտագործելով -t տարբերակը յուրաքանչյուր աղյուսակի համար:

pg_dump -a -t table_name -f file_name database_name

Ստեղծեք կրկնօրինակում gz սեղմումով

Pg_dump -h localhost -O -F p -c -U postgres mydb | gzip -c > mydb.gz

Առավել հաճախ օգտագործվող տարբերակների ցանկը.

• -h հոսթ - հոսթ, եթե նշված չէ, ապա օգտագործվում է localhost կամ արժեքը PGHOST միջավայրի փոփոխականից:
• -p port - port, եթե նշված չէ, ապա օգտագործվում է 5432 կամ արժեքը PGPORT միջավայրի փոփոխականից:
• -u - օգտվող, եթե նշված չէ, ապա օգտագործվում է ընթացիկ օգտվողը, արժեքը կարող է նշվել նաև PGUSER միջավայրի փոփոխականում:
• -a, -data-only - միայն տվյալների աղբահանություն, լռելյայն պահպանեք տվյալները և սխեման:
• -b - աղբանոցում ներառել խոշոր օբյեկտներ (բլոգեր):
• -s, -schema-only - միայն թափել սխեմաները:
• -C, -create - ավելացնում է տվյալների բազա ստեղծելու հրաման:
• -c - ավելացնում է հրամաններ՝ ջնջելու (թողնել) օբյեկտները (աղյուսակներ, դիտումներ և այլն):
• -O Մի ավելացրեք հրամաններ օբյեկտի (աղյուսակներ, դիտումներ և այլն) սեփականատիրոջ սահմանելու համար:
• -F, -format (c|t|p) - թողարկեք ելքային ձևաչափը, սովորական, tar կամ պարզ տեքստը:
• -t, -table=TABLE - Նշեք հատուկ աղյուսակ, որը պետք է թափել:
• -v, -verbose - բառացի ելք:
• -D, -attribute-inserts Dump-ը օգտագործելով INSERT հրամանը գույքի անունների ցանկով:

Կրկնօրինակեք բոլոր տվյալների բազաները՝ օգտագործելով pg_dumpall հրամանը:

pg_dumpall > all.sql

Սեղանների վերականգնում պահուստներից (պահուստավորում).

psql - վերականգնել կրկնօրինակները, որոնք պահվում են պարզ տեքստային ֆայլում (պարզ տեքստ);
pg_restore - վերականգնել սեղմված կրկնօրինակները (tar);

Ամբողջ կրկնօրինակի վերականգնում սխալների անտեսմամբ

psql -h localhost -U someuser -d dbname -f mydb.sql

Ամբողջական կրկնօրինակի վերականգնում, կանգ առնելով առաջին սխալի վրա

psql -h localhost -U someuser -set ON_ERROR_STOP=on -f mydb.sql

tarball-ից վերականգնելու համար նախ պետք է ստեղծել տվյալների բազա CREATE DATABASE mydb; (եթե կրկնօրինակը ստեղծելիս -C տարբերակը նշված չի եղել) և վերականգնել

pg_restore -dbname=mydb -jobs=4 -բառը mydb.backup

gz-ով սեղմված տվյալների բազայի կրկնօրինակի վերականգնում

psql -U postgres -d mydb -f mydb

Կարծում եմ՝ postgresql տվյալների բազան այժմ ավելի հասկանալի կլինի ձեզ համար։ Հուսով եմ, որ PostgreSQL հրամանների այս ցանկը օգտակար է եղել ձեզ համար:

Այս հոդվածում ես ցույց կտամ կառավարման 15 ամենաօգտակար հրամանները postgreSQL.

1. Ինչպե՞ս փոխել root գաղտնաբառը PostgreSQL-ում:

$ /usr/local/pgsql/bin/psql postgres postgresԳաղտնաբառ՝ (հին գաղտնաբառ) # ՓՈՓՈԽԵԼ ՕԳՏԱԳՈՐԾՈՂԻ գրառումները գաղտնաբառով «tmppassword»; $ /usr/local/pgsql/bin/psql postgres postgresԳաղտնաբառ: (tmppassword)

Նույն կերպ է աշխատում սովորական օգտատիրոջ գաղտնաբառը փոխելը: Root օգտվողը կարող է փոխել գաղտնաբառը ցանկացած օգտագործողի համար:

# ՓՈՓՈԽԵԼ Օգտվողի օգտանունը «tmppassword» գաղտնաբառով;

2. Ինչպե՞ս դնել PostgreSQL-ն ավտոմատ մեկնարկի:

$ su - արմատ # tar xvfz postgresql-8.3.7.tar.gz # cd postgresql-8.3.7 # cp contrib/start-scripts/linux /etc/rc.d/init.d/postgresql # chmod a+x / etc/rc.d/init.d/postgresql

3. Ստուգեք սերվերի կարգավիճակը

$ /etc/init.d/postgresql կարգավիճակըԳաղտնաբառ՝ pg_ctl. սերվերն աշխատում է (PID՝ 6171) /usr/local/pgsql/bin/postgres «-D» «/usr/local/pgsql/data» [ ՄեկնաբանությունԱյս հաղորդագրությունը ցույց է տալիս, որ սերվերը աշխատում է և աշխատում է ճիշտ] $ /etc/init.d/postgresql կարգավիճակըԳաղտնաբառ՝ pg_ctl. սերվերը չի աշխատում [ ՄեկնաբանությունԱյս հաղորդագրությունը ցույց է տալիս, որ սերվերը չի աշխատում]

4. Ինչպե՞ս սկսել, դադարեցնել, վերագործարկել PostgreSQL-ը:

# ծառայության postgresql կանգառ PostgreSQL-ի դադարեցում. սերվերը դադարեցրեց լավ # ծառայության postgresql մեկնարկըՍկսում ենք PostgreSQL. լավ # ծառայության postgresql վերագործարկում PostgreSQL-ի վերագործարկում. սերվերը դադարել է

5. Ինչպե՞ս տեսնել, թե PostgreSQL-ի որ տարբերակն է աշխատում:

$ /usr/local/pgsql/bin/psql թեստԲարի գալուստ psql 8.3.7՝ PostgreSQL ինտերակտիվ տերմինալ: Տեսակ՝ \հեղինակային իրավունք բաշխման պայմանների համար \h SQL հրամանների օգնության համար \? psql հրամանների օգնության համար \g կամ վերջացրեք կետ-ստորակետով՝ հարցումը կատարելու համար \q դուրս գալու թեստ=# selectversion();տարբերակ ————————————————————————————————- PostgreSQL 8.3.7 i686-pc-linux-gnu-ում, կազմված GCC-ի կողմից gcc (GCC) 4.1.2 20071124 (Red Hat 4.1.2-42) (1 տող) թեստ=#

5. Ինչպե՞ս ստեղծել օգտատեր PostgreSQL-ում:

Դրա համար երկու եղանակ կա..

Մեթոդ 1:Մենք օգտվող ենք ստեղծում PSQL թաղանթում՝ օգտագործելով CREATE USER հրամանը:

# ՍՏԵՂԾԵԼ ՕԳՏԱԳՈՐԾՈՂԻ ramesh գաղտնաբառով 'tmppassword';ՍՏԵՂԾԵԼ ԴԵՐ

Մեթոդ2: Մենք օգտատեր ենք ստեղծում createuser shell հրամանի միջոցով։

$ /usr/local/pgsql/bin/createuser sathiyaԱրդյո՞ք նոր դերը կլինի գերօգտագործող: (y/n) Արդյո՞ք նոր դերին թույլ տրվի ստեղծել տվյալների բազաներ: (y/n) Արդյո՞ք նոր դերին թույլ տրվի ստեղծել ավելի շատ նոր դերեր: (y/n) n ՍՏԵՂԾԵԼ ԴԵՐ

6. Ինչպե՞ս ստեղծել տվյալների բազա PostgreSQL-ում:

Դրա համար կա 2 մեթոդ.

Մեթոդ1: Ստեղծեք տվյալների բազա՝ օգտագործելով PSQL shell-ը՝ օգտագործելով CREATE DATABASE հրամանը:

# Ստեղծել տվյալների բազա mydb ՍԵՓԱԿԱՏԵՐՈՎ ramesh;ՍՏԵՂԾԵԼ ՏՎՅԱԼՆԵՐԻ ԲԱԶԱՆ

Մեթոդ2: Մենք օգտագործում ենք createb հրամանը։

$ /usr/local/pgsql/bin/createdb mydb -O rameshՍՏԵՂԾԵԼ ՏՎՅԱԼՆԵՐԻ ԲԱԶԱՆ

7. Ստանալով բոլոր տվյալների բազաների ցանկը Postgresql-ում:

# \լՏվյալների բազաների ցանկ Անունը | Սեփականատեր | Կոդավորում ———-+———-+———- կրկնօրինակում | postgres | UTF8 mydb | ռամեշ | UTF8 postgres | postgres | UTF8 կաղապար0 | postgres | UTF8 կաղապար1 | postgres | UTF8

8. Ինչպե՞ս ջնջել տվյալների բազան PostgreSQL-ում:

# \լՏվյալների բազաների ցանկ Անունը | Սեփականատեր | Կոդավորում ———-+———-+———- կրկնօրինակում | postgres | UTF8 mydb | ռամեշ | UTF8 postgres | postgres | UTF8 կաղապար0 | postgres | UTF8 կաղապար1 | postgres | UTF8# ԿԱՌՆԵԼ ՏՎՅԱԼՆԵՐԻ ԲԱԶԱՆ mydb;ԿԱՌՆԵԼ ՏՎՅԱԼՆԵՐԻ ԲԱԶԱՆ

9. Օգտագործելով ներկառուցված օգնություն հրամաններին

Թիմ \? ցույց կտա օգնության գիծ psql հրամանի համար: \h CREATE-ը ցույց կտա օգնություն բոլոր հրամանների համար, որոնք սկսվում են CREATE-ով:

# \? # \h ՍՏԵՂԾԵԼ # \h ՍՏԵՂԾԵԼ ԻԴԵՔՍ

10. Ինչպե՞ս ստանալ Postgresql-ում տվյալների բազայի բոլոր աղյուսակների ցանկը:

# \դ

Դատարկ տվյալների բազայի համար դուք կստանաք «Հարաբերություններ չեն գտնվել» հաղորդագրությունը:

11. Ինչպե՞ս կարող եմ պարզել հարցման կատարման ժամանակը:

# \timing - այս հրամանը կատարելուց հետո յուրաքանչյուր հաջորդ հարցում ցույց կտա կատարման ժամանակը։

# \ժամկԺամկետները միացված են: # SELECT * pg_catalog.pg_attribute-ից;Ժամանակը՝ 9,583 մվ

12. Ինչպե՞ս կրկնօրինակել և վերականգնել տվյալների բազաները և աղյուսակները PostgreSQL-ում:

Այս հարցը բավականին մեծ է, և ես այն կհրապարակեմ ավելի ուշ առանձին հոդվածով։

13. Ինչպե՞ս թվարկել հասանելի գործառույթները PostgreSQL-ում:

Հասանելի գործառույթների ցանկի համար ասեք \df+

# \Դ Ֆ # \df+

14. Ինչպե՞ս խմբագրել PostgreSQL հարցումը խմբագրում:

# \է

\e-ը կբացի խմբագիր, որտեղ կարող եք խմբագրել հարցումը և պահպանել այն:

15. Որտեղ կարող եմ գտնել postgreSQL պատմության ֆայլը:

Ինչպես ~/.bash_history ֆայլը, postgreSQL-ը պահում է բոլոր sql հրամանները ~/.psql_history ֆայլում:

$ cat ~/.psql_historyփոխել օգտվողի գրառումները «tmppassword» գաղտնաբառով; \h փոխել օգտվողի ընտրած տարբերակը(); ստեղծել օգտվողի ramesh գաղտնաբառով 'tmppassword'; \times ընտրել * pg_catalog.pg_attribute-ից;

Վերջին թարմացումը՝ 17.03.2018

Աղյուսակները ստեղծվում են CREATE TABLE հրամանի միջոցով, որին հաջորդում է աղյուսակի անունը: Այս հրամանով կարող եք նաև օգտագործել մի շարք օպերատորներ, որոնք սահմանում են աղյուսակի սյունակները և դրանց հատկանիշները: Աղյուսակ ստեղծելու ընդհանուր շարահյուսությունը հետևյալն է.

ՍՏԵՂԾԵՔ աղյուսակի_անունը (սյունակի_անուն1 տվյալների_տեսակ սյունակի_հատկանիշներ1, սյունակի_անուն2 տվյալների_տիպի սյունակ2 ատրիբուտներ, ..................................... .... .......... սյունակի_անունN տվյալների_տեսակ սյունակի_հատկանիշներN, աղյուսակ_հատկանիշներ);

Աղյուսակի անունից հետո բոլոր սյունակների բնութագրերը նշված են փակագծերում: Ավելին, յուրաքանչյուր սյունակի համար դուք պետք է նշեք անունը և տվյալների տեսակը, որը այն կներկայացնի: Տվյալների տեսակը որոշում է, թե ինչ տվյալներ (թվեր, տողեր և այլն) կարող է պարունակել սյունակը:

Օրինակ, եկեք տվյալների բազայում աղյուսակ ստեղծենք pgAdmin-ի միջոցով: Դա անելու համար նախ ընտրեք թիրախային տվյալների բազան pgAdmin-ում, աջ սեղմեք դրա վրա և ընտրեք Հարցման գործիք... տարրը համատեքստի ընտրացանկում.

Դրանից հետո կբացվի SQL կոդը մուտքագրելու դաշտ։ Ավելին, աղյուսակը կստեղծվի հատուկ տվյալների բազայի համար, որի համար մենք կբացենք այս դաշտը SQL մուտքագրելու համար։

ՍՏԵՂԾԵԼ ՍԵՂԱՆԻ հաճախորդներ (Id SERIALE PRIMARY KEY, FirstName CHARACTER VARYING(30), LastName CHARACTER VARYING(30), Email CHARACTER VARYING(30), Age INTEGER);

Այս դեպքում Հաճախորդների աղյուսակում սահմանված են հինգ սյունակներ՝ Id, FirstName, LastName, Age, Email: Առաջին սյունակը՝ Id, ներկայացնում է հաճախորդի ID-ն, այն ծառայում է որպես հիմնական բանալի և, հետևաբար, ՍԵՐԻԱԼ տիպի է: Փաստորեն, այս սյունակում կպահվի 1, 2, 3 և այլն թվային արժեքը, որը յուրաքանչյուր նոր տողի համար ավտոմատ կավելանա մեկով:

Հաջորդ երեք սյունակները ներկայացնում են հաճախորդի անունը, ազգանունը և էլ.փոստի հասցեն և տիպի CHARACTER VARYING(30), ինչը նշանակում է, որ դրանք ներկայացնում են 30 նիշից ոչ ավելի տող:

Վերջին սյունակը՝ Տարիքը, ներկայացնում է օգտատիրոջ տարիքը և INTEGER տիպի է, այսինքն՝ պահում է թվեր։

Եվ այս հրամանը կատարելուց հետո հաճախորդների աղյուսակը կավելացվի ընտրված տվյալների բազայում։

Աղյուսակների ջնջում

Աղյուսակներ բաց թողնելու համար օգտագործեք DROP TABLE հրամանը, որն ունի հետևյալ շարահյուսությունը.

ԿԱՌՆԵԼ ՍԵՂԱՆԱԿ 1 [, աղյուսակ2, ...];

Օրինակ՝ ջնջելով հաճախորդների աղյուսակը։

15 Օգտակար PostgreSQL հրամաններ

Ցանցում կան բազմաթիվ PostgreSQL ձեռնարկներ, որոնք նկարագրում են հիմնական հրամանները: Բայց աշխատանքի մեջ ավելի խորանալիս կան այնպիսի գործնական խնդիրներ, որոնք պահանջում են առաջադեմ հրամաններ։

Նման հրամանները կամ հատվածները հազվադեպ են փաստաթղթավորված: Դիտարկենք մի քանի օրինակ, որոնք օգտակար են ինչպես մշակողների, այնպես էլ տվյալների բազայի ադմինիստրատորների համար:

Տվյալների բազայի մասին տեղեկատվության ստացում

Տվյալների բազայի չափը

Տվյալների բազայի ֆայլերի (պահեստի) ֆիզիկական չափը ստանալու համար օգտագործեք հետևյալ հարցումը.

SELECT pg_database_size(current_database());

Արդյունքը կներկայացվի որպես 41809016 թիվ:

current_database()-ը ֆունկցիա է, որը վերադարձնում է ընթացիկ տվյալների բազայի անունը: Փոխարենը, դուք կարող եք մուտքագրել անունը տեքստում.

SELECT pg_database_size("my_database");

Մարդկանց համար ընթեռնելի տեղեկատվություն ստանալու համար մենք օգտագործում ենք pg_size_pretty ֆունկցիան.

SELECT pg_size_pretty(pg_database_size(current_database()));

Արդյունքում մենք ստանում ենք այնպիսի տեղեկատվություն, ինչպիսին է 40 Մբ:

Աղյուսակների ցանկ

Երբեմն դուք պետք է ստանաք տվյալների բազայի աղյուսակների ցանկը: Դա անելու համար մենք օգտագործում ենք հետևյալ հարցումը.

SELECT table_name FROM information_schema.tables WHERE table_schema NOT IN ("information_schema","pg_catalog");

information_schema - տվյալների բազայի ստանդարտ սխեման, որը պարունակում է դիտումների (դիտումների) հավաքածուներ, ինչպիսիք են աղյուսակները, դաշտերը և այլն: Աղյուսակի տեսքը պարունակում է տեղեկատվություն տվյալների բազայի բոլոր աղյուսակների մասին:

Ստորև նկարագրված հարցումը կընտրի բոլոր աղյուսակները ընթացիկ տվյալների բազայի նշված սխեմայից.

SELECT table_name FROM information_schema.tables WHERE table_schema NOT IN ("information_schema", "pg_catalog") AND table_schema IN("public", "myschema");

Վերջին IN կետում դուք կարող եք նշել կոնկրետ սխեմայի անունը:

Սեղանի չափը

Տվյալների բազայի չափը ստանալուն զուգահեռ՝ աղյուսակի տվյալների չափը կարելի է հաշվարկել՝ օգտագործելով համապատասխան ֆունկցիան.

SELECT pg_relation_size ("accounts");

pg_relation_size ֆունկցիան վերադարձնում է այն չափը, որը տվյալ աղյուսակի կամ ինդեքսի նշված շերտը զբաղեցնում է սկավառակի վրա։

Ամենամեծ սեղանի անվանումը

Ընթացիկ տվյալների բազայում աղյուսակների ցանկը ցուցադրելու համար՝ դասավորված ըստ աղյուսակի չափի, կատարեք հետևյալ հարցումը.

SELECT relname, relpages FROM pg_class ORDER BY relpages DESC;

Ամենամեծ աղյուսակի մասին տեղեկատվությունը ցուցադրելու համար մենք սահմանափակում ենք հարցումը՝ օգտագործելով LIMIT.

SELECT relname, relpages FROM pg_class ORDER BY relpages DESC LIMIT 1;

relname-ը աղյուսակի, ինդեքսի, տեսքի և այլնի անունն է:
relpages - սկավառակի վրա այս աղյուսակի ներկայացման չափը էջերի քանակով (լռելյայն մեկ էջը 8 ԿԲ է):
pg_class-ը համակարգային աղյուսակ է, որը պարունակում է տեղեկատվություն տվյալների բազայի աղյուսակի հարաբերությունների մասին:

Կապակցված օգտվողների ցանկը

Միացված օգտատերերի անունը, IP-ն և օգտագործված պորտը պարզելու համար կատարեք հետևյալ հարցումը.

SELECT dataname, usename,client_addr,client_port FROM pg_stat_activity;

Օգտագործողի գործունեություն

Որոշակի օգտագործողի կապի ակտիվությունը պարզելու համար օգտագործեք հետևյալ հարցումը.

SELECT dataname FROM pg_stat_activity WHERE usename = "deuser";

Աշխատեք տվյալների և աղյուսակի դաշտերի հետ

Կրկնվող տողերի հեռացում

Եթե ​​այնպես է պատահել, որ աղյուսակը չունի հիմնական բանալի (հիմնական բանալի), ապա գրառումների մեջ անպայման կլինեն կրկնօրինակներ։ Եթե ​​նման սեղանի համար, հատկապես մեծ, անհրաժեշտ է սահմանել սահմանափակումներ (սահմանափակումներ) ամբողջականությունը ստուգելու համար, ապա հեռացնել հետևյալ տարրերը.

• կրկնօրինակ տողեր
• իրավիճակներ, երբ մեկ կամ մի քանի սյունակներ կրկնօրինակվում են (եթե այդ սյունակները պետք է օգտագործվեն որպես հիմնական բանալի):

Դիտարկենք հաճախորդի տվյալներով աղյուսակը, որտեղ ամբողջ տողը կրկնօրինակված է (երկրորդն անընդմեջ):

Հետևյալ հարցումը կօգնի հեռացնել բոլոր կրկնօրինակները.

Ջնջել հաճախորդներից, որտեղ ctid NOT IN (SELECT max(ctid) FROM customers GROUP BY հաճախորդների.*);

ctid դաշտը, որը եզակի է յուրաքանչյուր գրառման համար, լռելյայն թաքնված է, բայց այն առկա է յուրաքանչյուր աղյուսակում:

Վերջին հարցումը ռեսուրսների ինտենսիվ է, ուստի զգույշ եղեք այն աշխատանքային նախագծի վրա կատարելիս:

Այժմ հաշվի առեք այն դեպքը, երբ դաշտի արժեքները կրկնվում են:

Եթե ​​ընդունելի է կրկնօրինակները ջնջել առանց բոլոր տվյալները պահելու, կատարեք հետևյալ հարցումը.

Ջնջել հաճախորդներից WHERE ctid NOT IN (SELECT max(ctid) FROM customers GROUP BY customer_id);

Եթե ​​տվյալները կարևոր են, ապա նախ պետք է գտնել կրկնօրինակներով գրառումներ.

SELECT * FROM customers WHERE ctid NOT IN (SELECT max(ctid) FROM customers GROUP BY customer_id);

Նման գրառումները ջնջելուց առաջ դուք կարող եք դրանք տեղափոխել ժամանակավոր աղյուսակ կամ փոխարինել դրանցում առկա customer_id արժեքը մեկ այլով:

Վերը նկարագրված գրառումները ջնջելու խնդրանքի ընդհանուր ձևը հետևյալն է.

DELETE FROM table_name-ից WHERE ctid NOT IN (SELECT max(ctid) FROM table_name GROUP BY սյունակ1, );

Անվտանգ դաշտի տեսակի փոփոխություն

Նման առաջադրանք այս ցանկում ներառելու մասին կարող է հարց լինել։ Իրոք, PostgreSQL-ում դաշտի տեսակը փոխելը շատ պարզ է՝ օգտագործելով ALTER հրամանը: Որպես օրինակ, նորից նայենք հաճախորդների աղյուսակին:

Customer_id դաշտը օգտագործում է varchar տողերի տվյալների տեսակը: Սա սխալ է, քանի որ այս դաշտը պետք է պահի հաճախորդների ID-ները, որոնք ամբողջ թվի ձևաչափով են: Varchar-ի օգտագործումն արդարացված չէ։ Փորձենք շտկել այս թյուրիմացությունը՝ օգտագործելով ALTER հրամանը.

ALTER TABLE հաճախորդներ ALTER COLUMN customer_id TYPE ամբողջ թիվ;

Բայց կատարման արդյունքում մենք ստանում ենք սխալ.

ՍԽԱԼ. «customer_id» սյունակը չի կարող ավտոմատ կերպով փոխանցվել ամբողջ թիվ մուտքագրելու համար
SQL վիճակը՝ 42804
Հուշում. Նշեք Օգտագործելով արտահայտություն՝ փոխակերպումն իրականացնելու համար:

Սա նշանակում է, որ դուք չեք կարող պարզապես վերցնել և փոխել դաշտի տեսակը, երբ աղյուսակում տվյալներ կան: Քանի որ օգտագործվել է varchar տեսակը, DBMS-ը չի կարող որոշել, թե արդյոք արժեքը ամբողջ թիվ է: Թեեւ տվյալները համապատասխանում են այս տեսակին։ Այս կետը պարզաբանելու համար սխալի հաղորդագրությունն առաջարկում է օգտագործել USING կետը՝ մեր տվյալները ամբողջ թվի ճիշտ փոխակերպելու համար.

ALTER TABLE հաճախորդներ ALTER COLUMN customer_id TYPE integer USING (customer_id::integer);

Արդյունքում ամեն ինչ անցել է առանց սխալների.

Խնդրում ենք նկատի ունենալ, որ USING-ն օգտագործելիս, բացի կոնկրետ արտահայտությունից, հնարավոր է օգտագործել ֆունկցիաներ, այլ դաշտեր և օպերատորներ:

Օրինակ, եկեք customer_id դաշտը դարձնենք varchar , բայց տվյալների ձևաչափի փոխակերպմամբ.

ALTER TABLE հաճախորդներ ALTER COLUMN customer_id TYPE varchar USING (customer_id || «-» || first_name);

Արդյունքում աղյուսակը կունենա հետևյալ տեսքը.

Որոնեք «կորցրած» արժեքներ

Զգույշ եղեք հաջորդականությունները որպես հիմնական բանալի օգտագործելիս. նշանակելիս հաջորդականության որոշ տարրեր պատահաբար բաց են թողնում, աղյուսակի հետ աշխատելու արդյունքում որոշ գրառումներ ջնջվում են։ Նման արժեքները կարող են կրկին օգտագործվել, բայց դժվար է գտնել մեծ աղյուսակներում:

Դիտարկենք որոնման երկու տարբերակ:

Առաջին ճանապարհը
Եկեք կատարենք հետևյալ հարցումը՝ «կորցրած» արժեքով միջակայքի սկիզբը գտնելու համար.

SELECT customer_id + 1 FROM customers mo WHERE NOT EXISTS (SELECT NULL FROM customers mi WHERE mi.customer_id = mo.customer_id + 1) ORDER BY customer_id;

Արդյունքում մենք ստանում ենք արժեքները՝ 5, 9 և 11:

Եթե ​​Ձեզ անհրաժեշտ է գտնել ոչ միայն առաջին երևույթը, այլև բացակայող բոլոր արժեքները, օգտագործեք հետևյալ (ռեսուրսային ինտենսիվ) հարցումը.

seq_max AS-ով (SELECT max(customer_id) FROM customers), seq_min AS (SELECT min(customer_id) FROM customers) SELECT * FROM generate_series((SELECT min FROM seq_min),(SELECT max FROM seq_max)) EXCEPT SELECT customer_id FROM customers;

Արդյունքում մենք տեսնում ենք հետևյալ արդյունքը՝ 5, 9 և 6։

Երկրորդ ճանապարհ
Ստացեք այն հաջորդականության անվանումը, որը կապված է customer_id-ի հետ.

SELECT pg_get_serial_sequence("customers", "customer_id");

Եվ գտեք բոլոր բացակայող նույնացուցիչները.

Հերթականության_info AS-ով (SELECT start_value, last_value FROM "SchemaName".."SequenceName") SELECT generate_series ((sequence_info.start_value), (sequence_info.last_value)) FROM sequence_info EXCEPT SELECT customer_id FROM customers;

Աղյուսակում տողերի քանակի հաշվում

Տողերի քանակը հաշվարկվում է ստանդարտ հաշվառման ֆունկցիայի միջոցով, սակայն այն կարող է օգտագործվել լրացուցիչ պայմաններով:

Աղյուսակում տողերի ընդհանուր քանակը.

SELECT count(*) FROM աղյուսակից;

Տողերի քանակը պայմանով, որ նշված դաշտը չի պարունակում NULL.

SELECT count(col_name) FROM աղյուսակից;

Նշված դաշտի համար եզակի տողերի քանակը.

SELECT count (տարբեր col_name) FROM աղյուսակից;

Օգտագործելով գործարքներ

Գործարքը միավորում է գործողությունների հաջորդականությունը մեկ գործողության մեջ: Դրա առանձնահատկությունն այն է, որ գործարքի կատարման սխալի դեպքում գործողությունների ոչ մի արդյունք չի պահպանվի տվյալների բազայում։

Սկսենք գործարքը BEGIN հրամանով:

ՍԿՍԵԼ-ից հետո բոլոր գործողությունները հետ վերադարձնելու համար օգտագործեք ROLLBACK հրամանը:

Իսկ կիրառելու համար՝ COMMI հրամանը։

Գործարկվող հարցումների դիտում և ավարտում

Հարցումների մասին տեղեկություններ ստանալու համար գործարկեք հետևյալ հրամանը.

SELECT pid, տարիք(query_start, clock_timestamp()), usename, հարցում FROM pg_stat_activity WHERE հարցում != " «ԵՎ հարցումը ՉԻ Հավանում «%pg_stat_activity%» ՊԱՏՎԻՐԵԼ ԸՍՏ query_start desc;

Հատուկ հարցումը դադարեցնելու համար գործարկեք հետևյալ հրամանը՝ նշելով գործընթացի id (pid).

SELECT pg_cancel_backend(procpid);

Հարցումը դադարեցնելու համար գործարկեք՝

SELECT pg_terminate_backend(procpid);

Աշխատեք կոնֆիգուրացիայի հետ

Կլաստերային օրինակի գտնվելու վայրը գտնելը և փոխելը

Հնարավոր է իրավիճակ, երբ մի քանի PostgreSQL օրինակներ կազմաձևված են նույն օպերացիոն համակարգի վրա, որոնք «նստում» են տարբեր նավահանգիստների վրա: Այս դեպքում յուրաքանչյուր ատյանի ֆիզիկական տեղակայման ուղի գտնելը բավականին նյարդային խնդիր է: Այս տեղեկատվությունը ստանալու համար կատարեք հետևյալ հարցումը հետաքրքրությունների կլաստերի ցանկացած տվյալների բազայի նկատմամբ.

ՑՈՒՑԱԴՐԵԼ տվյալների_գրացուցակը;

Փոխեք գտնվելու վայրը մեկ այլ՝ օգտագործելով հրամանը.

SET data_directory to new_directory_path;

Սակայն փոփոխություններն ուժի մեջ մտնելու համար անհրաժեշտ է վերաբեռնում:

Ստանալով առկա տվյալների տեսակների ցանկը

Ստացեք հասանելի տվյալների տեսակների ցանկը, օգտագործելով հրամանը.

SELECT typname, typen from pg_type where type="b";

typname-ը տվյալների տեսակի անունն է:
typlen - տվյալների տեսակի չափը:

DBMS-ի կարգավորումների փոփոխություն առանց վերագործարկման

PostgreSQL կարգավորումները տեղակայված են հատուկ ֆայլերում, ինչպիսիք են postgresql.conf և pg_hba.conf: Այս ֆայլերը փոխելուց հետո ձեզ անհրաժեշտ է DBMS՝ կարգավորումները նորից ստանալու համար: Դա անելու համար տվյալների բազայի սերվերը վերագործարկվում է: Հասկանալի է, որ դուք պետք է դա անեք, բայց նախագծի արտադրական տարբերակում, որն օգտագործվում է հազարավոր օգտատերերի կողմից, դա շատ անցանկալի է: Հետևաբար, PostgreSQL-ն ունի գործառույթ, որի միջոցով կարող եք փոփոխություններ կատարել առանց սերվերի վերագործարկման.

SELECT pg_reload_conf();

Բայց, ցավոք, դա չի վերաբերում բոլոր պարամետրերին: Որոշ դեպքերում կարգավորումները կիրառելու համար պահանջվում է վերաբեռնում:

Մենք դիտել ենք հրամաններ, որոնք կհեշտացնեն գործը ծրագրավորողների և DBA-ների համար՝ օգտագործելով PostgreSQL: Բայց սա բոլոր հնարավոր մեթոդները չէ: Եթե ​​հանդիպեք հետաքրքիր առաջադրանքների, գրեք դրանց մասին մեկնաբանություններում։ Եկեք կիսենք մեր օգտակար փորձը: