PostgreSQL
 sql >> डेटाबेस >  >> RDS >> PostgreSQL

JSON तर्कों का उपयोग करके बल्क INSERT फ़ंक्शन को पोस्टग्रेज करता है

हजारों रिकॉर्ड के लिए

1. इनपुट पंक्तियों की एक अस्थायी तालिका बनाएं, जिसमें आपके मान शामिल हों $1 , $2 , $3 . अपलोड करने का सबसे तेज़ तरीका है COPY - या \copy psql का मेटा-कमांड यदि डेटा एक ही मशीन पर नहीं है। मान लीजिए यह तालिका:

CREATE TEMP TABLE tmp(id int PRIMARY KEY, val1 text, val2 text);

मैंने एक पीके बाधा जोड़ा, जो पूरी तरह से वैकल्पिक है, लेकिन यह सुनिश्चित करता है कि हम अद्वितीय गैर-शून्य int मानों से निपट रहे हैं। यदि आप इनपुट डेटा की पुष्टि कर सकते हैं, तो आपको बाधा की आवश्यकता नहीं है।

2. डेटा-संशोधित सीटीई के साथ अपने आदेशों को श्रृंखलाबद्ध करें। जैसा कि हमने आपके पिछला प्रश्न के तहत निर्धारित किया है। , इस विशेष ऑपरेशन में ध्यान रखने के लिए कोई दौड़ की स्थिति नहीं है।

WITH ins1 AS (
   INSERT INTO table1 AS t1 (id, val1, val2)
   SELECT id, val1, val2 FROM tmp ON CONFLICT DO NOTHING
   RETURNING t1.id, t1.val1, t1.val2  -- only actually inserted rows returned
   )
, ins2 AS (
   INSERT INTO table2 (table1_id, val1)
   SELECT id, val1 FROM ins1
   )
UPDATE table3 t3
SET    val2 = i.val2
     , time = now()
FROM   ins1 i
WHERE  t3.table1_id = i.id;

चरण 1 और 2 को उसी सत्र . में चलना चाहिए (जरूरी नहीं कि एक ही लेन-देन), क्योंकि अस्थायी तालिकाओं का दायरा एक ही सत्र के लिए बाध्य है।

ध्यान दें, UPDATE केवल पहले INSERT . पर निर्भर करता है , दूसरे INSERT . की सफलता गारंटी है, क्योंकि कोई ON CONFLICT DO NOTHING . है और दूसरे INSERT . में कोई विरोध होने पर पूरा ऑपरेशन वापस ले लिया जाएगा ।

संबंधित:

केवल कुछ रिकॉर्ड के लिए

विभिन्न विकल्प हैं कैसे। किसी फ़ंक्शन में JSON सरणी पास करने का आपका विचार उनमें से एक है। यदि ऑब्जेक्ट लक्ष्य तालिका से मेल खाते हैं, तो आप json_populate_recordset() एक ही INSERT . में सवाल। या बस INSERT . का उपयोग करें (तैयार बयान के रूप में) बिना फंक्शन रैपर के।

INSERT INTO target_tbl  -- it's ok to omit target columns here
SELECT *
FROM   json_populate_recordset(null::target_tbl,  -- use same table type
          json '[{ "id": "1", "val1": "1-val1", "val2": "1-val2" },
                 { "id": "2", "val1": "2-val1", "val2": "2-val2" },
                 { "id": "3", "val1": "3-val1", "val2": "3-val2" },
                 { "id": "4", "val1": "4-val1", "val2": "4-val2" }]');

केवल कुछ स्तंभों के लिए आप प्रत्येक स्तंभ के लिए एक सरणी भी पास कर सकते हैं और समानांतर में उनके माध्यम से लूप कर सकते हैं। आप इसे ऐरे इंडेक्स पर एक साधारण लूप के साथ कर सकते हैं। पोस्टग्रेज 9.4 के बाद से सुविधाजनक unnest() . भी है एक ही क्वेरी में यह सब करने के लिए कई मापदंडों के साथ:

सबसे अच्छा समाधान उस डेटा प्रारूप पर निर्भर करता है जो आपके पास है




  1. Database
  2.   
  3. Mysql
  4.   
  5. Oracle
  6.   
  7. Sqlserver
  8.   
  9. PostgreSQL
  10.   
  11. Access
  12.   
  13. SQLite
  14.   
  15. MariaDB
  1. बाएं बाहरी जुड़ने के साथ धीमी क्वेरी और शून्य स्थिति है

  2. यदि पोस्टग्रेएसक्यूएल में मौजूद नहीं है तो अद्वितीय इंडेक्स बनाएं

  3. संयोजन मतभेदों को पोस्टग्रेज करता है। ओएसएक्स वी उबंटू

  4. PostgreSQL:मैं किसी फ़ंक्शन के अंदर से search_path कैसे सेट करूं?

  5. यूनियन ऑल व्यू पर धीमी क्वेरी