როგორ ატვირთვეთ მონაცემები ეფექტურად COPY-ის გამოყენებით?

Question

Accepted Answer

**`COPY`** არის PostgreSQL-ის მაღალი წარმადობის ბრძანება **მასობრივი ატვირთვისა და ექსპორტის** შესახებ — დიდი რაოდენობის მონაცემების გადაადგილება ფайლ(ან ნაკადის) და ცხრილის შორის ბევრად უფრო სწრაფი, ვიდრე ცალკეული `INSERT` განცხადებები. ეს არის სტანდარტული ინსტრუმენტი დიდი მონაცემთა ნაკრების აღნიშვნა/გატანისთვის.

## COPY სწრაფი მასობრივი ატვირთვისთვის

```sql
-- load data from a CSV file into a table (server-side; needs file access + privileges)
COPY users (name, email, age) FROM '/path/data.csv' WITH (FORMAT csv, HEADER true);

-- export a table to a CSV file
COPY users TO '/path/export.csv' WITH (FORMAT csv, HEADER true);

-- from psql (client-side — works without server file access): use \copy
\copy users FROM 'data.csv' WITH (FORMAT csv, HEADER true)
```

`COPY` კითხულობს/წერს მთელ ფაილს ერთ ოპერაციაში — დრამატულად უფრო სწრაფი, ვიდრე ათასობით ცალკეული INSERT-ის გაშვება.

## რატომ არის COPY ისე ბევრად უფრო სწრაფი INSERT-ზე

```text
❌ thousands of individual INSERTs:
   each is a separate statement → per-statement overhead, possibly per-row transactions,
   network round-trips → SLOW for large data (can be 10-100x slower)

✅ COPY:
   one bulk operation, minimal overhead, optimized data path → FAST
→ For loading large datasets, COPY is the go-to; INSERTs are for small/individual rows.
```

## COPY vs \copy (სერვერის მხარე vs კლიენტის მხარე)

```text
COPY (SQL command) → reads/writes files on the SERVER, needs superuser/file privileges
\copy (psql command) → reads/writes files on the CLIENT, no special privileges
→ Use \copy when running from your machine against a remote database.
```

## რჩევები დიდი მონაცემთა ნაკრების მასობრივი ატვირთვისთვის

```text
✓ Use COPY (not INSERTs) for large data
✓ Consider dropping/disabling indexes and constraints during a huge load, then
  recreating them after (building an index once is faster than maintaining it per-row)
✓ Load within a single transaction; increase maintenance_work_mem for index rebuilds
✓ For programmatic bulk inserts, use multi-row INSERT or the driver's COPY support
```

## რატომ არის მნიშვნელოვანი

`COPY` არის აუცილებელი PostgreSQL ინსტრუმენტი **ეფექტური მასობრივი მონაცემთა ატვირთვისა და ექსპორტის** შესახებ, და მისი გაგება ღირებული იყო ნებისმიერი სცენარისთვის, რომელიც მოიცავს დიდ მონაცემთა ნაკრებებს — მონაცემთა მიგრაციას, ETL, აღნიშვნა/გატანას, თესლს და ანალიტიკას, რომლებიც არის გავრცელებული რეალური სამყაროს საჭიროებები.

ძირითადი ღირებულება არის **წარმადობა**: დიდი რაოდენობის მონაცემების ატვირთვა ცალკეული `INSERT` განცხადებებით დრამატულად ნელია (პერ-განცხადების ზიდული, რაუნდ-ტრიპები — შესაძლებლად 10-100 ჯერ უფრო ნელი), მაშინ როდესაც `COPY` ატვირთვას შეასრულებს როგორც ერთი অপტიმიზირებული მასობრივი ოპერაცია, რაც ხდის მას დიდი მონაცემთა ნაკრების აღნიშვნისა და გატანის სტანდარტი (ათასი რიგიდან მილიონი რიგამდე).

გაგება *რატომ* არის COPY ისე ბევრად უფრო სწრაფი (მასობრივი ოპერაცია მხოლოდ პერ-რიგის ზიდული) ხსნის, როდის უნდა მიმართოთ მას (დიდი მონაცემები) ვერსუს INSERTs (მცირე/ცალკეული რიგი).

**`COPY`** (სერვერის მხარე SQL ბრძანება, საჭიროებს ფაილის წვდომა/პრივილეგიები) და **`\copy`** (psql კლიენტის მხარე ბრძანება, არ საჭიროებს სპეციალურ პრივილეგიებს — მუშაობს დაშორებული ბაზებით თქვენი მანქანიდან) პრაქტიკული განსხვავება მნიშვნელოვანია რეალურად გამოსაყენებლად სხვადასხვა კონტექსტში.

**მასობრივი ატვირთვის რჩევები** (COPY გამოყენება INSERTs-ის ნაცვლად, ინდექსების გაბუნებული/გადახლიჩა დიდი ტვირთის გარშემო, რადგან ერთი ინდექსის აგება ჯობია მის შენარჩუნებაზე პერ-რიგი, ატვირთვა ტრანზაქციაში) არის ღირებული optimization ცოდნა დიდი აღნიშვნებისთვის.

სანამ მასობრივი მონაცემთა ოპერაციები (მიგრაციები, აღნიშვნები, გატანები, ETL) გავრცელებული იყო, და რადგან COPY არის სტანდარტული, მაღალი წარმადობის სახელი მათი დახმარებისთვის PostgreSQL-ში (მნიშვნელოვნად აჯობებს INSERTs-ს დიდი მონაცემებისთვის), COPY-ის გაგება — მისი წარმადობის სარგებელი, COPY vs \copy განსხვავება, და მასობრივი ატვირთვის საუკეთესო პრაქტიკა — არის ღირებული, პრაქტიკულად საკუთარი ცოდნა ეფექტურად დიდი მონაცემთა ნაკრების მოსახდელად და სკოპირებად Postgres-ში, ხშირი ოპერაციული საჭიროება, სადაც სწორი ინსტრუმენტის გამოყენება (COPY) მნიშვნელოვან განსხვავებას იქმნის.