MySQL
सम्मिलित करें
खोज…
वाक्य - विन्यास
INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE] [INTO] tbl_name [PARTITION (विभाजन_नाम, ...)] [(col_name, ...)] {VALUES | VALUE} ({expr | DEFAULT}, ...), (...), ... [DUPLICATE KEY पर अपडेट करें col_name = expr [, col_name = expr] ...]
INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE] [INTO] tbl_name [PARTITION (विभाजन_नाम, ...)] SET col_name = {expr | DEFAULT}, ... [ON ON DUPLICATE KEY UPDATE col_name = expr [, col_name = expr] ...]
INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE] [INTO] tbl_name [PARTITION (विभाजन_नाम, ...)] [(col_name, ...)] का चयन करें ... [ON ON DUPLATEATE KEY UPDATE colname = expr [, col_name = expr] ...]
एक एक्सप्रेशन एक्सपर्ट किसी भी कॉलम को संदर्भित कर सकता है जो पहले एक मूल्य सूची में सेट किया गया था। उदाहरण के लिए, आप ऐसा कर सकते हैं क्योंकि col2 के लिए मान col1 को संदर्भित करता है, जिसे पहले सौंपा गया है:
INSERT INTO tbl_name (col1, col2) VALUES (15, col1 * 2);वैल्यू सिंटैक्स का उपयोग करने वाले INSERT स्टेटमेंट कई पंक्तियों को सम्मिलित कर सकते हैं। ऐसा करने के लिए, कॉलम मानों की कई सूचियों को शामिल करें, प्रत्येक कोष्ठक के भीतर संलग्न और अल्पविराम द्वारा अलग किया गया। उदाहरण:
INSERT INTO tbl_name (a, b, c) VALUES (1,2,3), (4,5,6), (7,8,9);प्रत्येक पंक्ति की मान सूची को कोष्ठकों के भीतर संलग्न किया जाना चाहिए। निम्नलिखित कथन अवैध है क्योंकि सूची में मानों की संख्या स्तंभ नामों की संख्या से मेल नहीं खाती:
INSERT INTO tbl_name (a, b, c) VALUES (1,2,3,4,5,6,7,8,9);INSERT ... सिंटैक्स का चयन करें
INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE] [INTO] tbl_name [PARTITION (part_name, ...)] [(col_name, ...)] का चयन करें ... [DUPLICATE KEY पर अपडेट करें colname = expr, ...]INSERT के साथ ... चयन करें, आप जल्दी से एक या कई टेबल से कई पंक्तियों को एक तालिका में सम्मिलित कर सकते हैं। उदाहरण के लिए:
INSERT INTO tbl_temp2 (fld_id) select tbl_temp1.fld_order_id से tbl_temp1 जहां tbl_temp1.fld_order_id - 100;
टिप्पणियों
बेसिक इंसर्ट
INSERT INTO `table_name` (`field_one`, `field_two`) VALUES ('value_one', 'value_two');
इस तुच्छ उदाहरण में, table_name है जहां डेटा जोड़े जाने के लिए, कर रहे हैं field_one और field_two के खिलाफ सेट डेटा, और करने के लिए क्षेत्र हैं value_one और value_two डेटा के खिलाफ करने के लिए कर रहे हैं field_one और field_two क्रमशः।
उन क्षेत्रों को सूचीबद्ध करने के लिए यह अच्छा है कि आप अपने कोड के भीतर डेटा डाल रहे हैं, जैसे कि तालिका में परिवर्तन और नए कॉलम जोड़े जाते हैं, आपका इंसर्ट टूट जाएगा, क्या उन्हें वहां नहीं होना चाहिए
INSERT, DUPLICATE प्रमुख अद्यतन पर
INSERT INTO `table_name`
(`index_field`, `other_field_1`, `other_field_2`)
VALUES
('index_value', 'insert_value', 'other_value')
ON DUPLICATE KEY UPDATE
`other_field_1` = 'update_value',
`other_field_2` = VALUES(`other_field_2`);
यह होगा INSERT में table_name निर्दिष्ट मानों, लेकिन अगर अद्वितीय कुंजी पहले से मौजूद है, यह अद्यतन करेगा other_field_1 एक नया मान है।
कभी-कभी, डुप्लिकेट कुंजी को अपडेट करते समय यह वैल्यू VALUES() का उपयोग करने के लिए काम आता है, ताकि मूल मूल्य को सीधे एक्सेस करने के बजाय INSERT को पास किया गया। इस तरह, आप INSERT और UPDATE का उपयोग करके विभिन्न मान सेट कर सकते हैं। जहां ऊपर के उदाहरण देखें other_field_1 पर सेट है insert_value पर INSERT या करने के लिए update_value पर UPDATE जबकि other_field_2 हमेशा के लिए सेट है other_value ।
डुप्लिकेट कुंजी अपडेट (IODKU) पर सम्मिलित करने के लिए महत्वपूर्ण स्कीमा एक विशिष्ट कुंजी है जिसमें एक डुप्लिकेट क्लैश का संकेत होगा। यह अद्वितीय कुंजी एक प्राथमिक कुंजी हो सकती है या नहीं। यह एकल स्तंभ, या बहु-स्तंभ (समग्र कुंजी) पर एक अद्वितीय कुंजी हो सकती है।
कई पंक्तियों को सम्मिलित करना
INSERT INTO `my_table` (`field_1`, `field_2`) VALUES
('data_1', 'data_2'),
('data_1', 'data_3'),
('data_4', 'data_5');
यह एक INSERT स्टेटमेंट के साथ कई पंक्तियों को एक साथ जोड़ने का एक आसान तरीका है।
इस तरह का 'बैच' इंसर्ट एक-एक करके पंक्तियां डालने से ज्यादा तेज होता है। आमतौर पर, एक एकल बैच में 100 पंक्तियाँ सम्मिलित करना इस तरह से उन सभी को व्यक्तिगत रूप से सम्मिलित करने के रूप में 10 गुना तेज होता है।
मौजूदा पंक्तियों को नजरअंदाज करना
बड़े डेटासेट आयात करते समय, कुछ परिस्थितियों में पंक्तियों को छोड़ना बेहतर हो सकता है, जो आमतौर पर स्तंभ संयम जैसे प्राथमिक प्राथमिक कुंजियों के कारण क्वेरी को विफल करने का कारण होगा। यह INSERT IGNORE का उपयोग करके किया जा सकता है।
निम्नलिखित उदाहरण डेटाबेस पर विचार करें:
SELECT * FROM `people`;
--- Produces:
+----+------+
| id | name |
+----+------+
| 1 | john |
| 2 | anna |
+----+------+
INSERT IGNORE INTO `people` (`id`, `name`) VALUES
('2', 'anna'), --- Without the IGNORE keyword, this record would produce an error
('3', 'mike');
SELECT * FROM `people`;
--- Produces:
+----+--------+
| id | name |
+----+--------+
| 1 | john |
| 2 | anna |
| 3 | mike |
+----+--------+
याद रखने वाली महत्वपूर्ण बात यह है कि INSERT IGNORE अन्य त्रुटियों को भी चुपचाप छोड़ देगा, यहाँ वह है मैसूर की आधिकारिक रिपोर्ट:
डेटा रूपांतरण जो त्रुटियों को ट्रिगर करेगा, यदि कथन निर्दिष्ट नहीं किया गया है तो IGNORE> निर्दिष्ट नहीं किया गया है। IGNORE के साथ, अमान्य मानों को निकटतम मानों में समायोजित किया जाता है और> डाला जाता है; चेतावनी का उत्पादन किया जाता है लेकिन बयान निरस्त नहीं होता है।
नोट: - नीचे का भाग पूर्णता के लिए जोड़ा गया है, लेकिन इसे सर्वोत्तम अभ्यास नहीं माना जाता है (यह विफल होगा, उदाहरण के लिए, यदि तालिका में एक और स्तंभ जोड़ा गया है)।
यदि आप तालिका में सभी कॉलमों के लिए संबंधित कॉलम का मूल्य निर्दिष्ट करते हैं, तो आप INSERT स्टेटमेंट में कॉलम सूची को निम्नानुसार अनदेखा कर सकते हैं:
INSERT INTO `my_table` VALUES
('data_1', 'data_2'),
('data_1', 'data_3'),
('data_4', 'data_5');
INSERT Select (दूसरी तालिका से डेटा सम्मिलित करना)
यह सेलेक्ट स्टेटमेंट वाले दूसरे टेबल से डेटा डालने का मूल तरीका है।
INSERT INTO `tableA` (`field_one`, `field_two`)
SELECT `tableB`.`field_one`, `tableB`.`field_two`
FROM `tableB`
WHERE `tableB`.clmn <> 'someValue'
ORDER BY `tableB`.`sorting_clmn`;
आप कर सकते हैं SELECT * FROM , लेकिन फिर tableA और tableB स्तंभ संख्या मिलान और इसी डेटाटाइप्स होना आवश्यक है।
AUTO_INCREMENT कॉलमों को INSERT में VALUES क्लॉज के रूप में माना जाता है।
यह सिंटैक्स अन्य तालिकाओं से डेटा के साथ (अस्थायी) तालिकाओं को भरना आसान बनाता है, और भी अधिक तब जब डेटा को सम्मिलित पर फ़िल्टर किया जाना है।
AUTO_INCREMENT + LAST_INSERT_ID () के साथ INSERT
जब किसी तालिका में AUTO_INCREMENT PRIMARY KEY , तो आमतौर पर कोई उस कॉलम में सम्मिलित नहीं होता है। इसके बजाय, अन्य सभी कॉलम निर्दिष्ट करें, फिर पूछें कि नई आईडी क्या थी।
CREATE TABLE t (
id SMALLINT UNSIGNED AUTO_INCREMENT NOT NULL,
this ...,
that ...,
PRIMARY KEY(id) );
INSERT INTO t (this, that) VALUES (..., ...);
SELECT LAST_INSERT_ID() INTO @id;
INSERT INTO another_table (..., t_id, ...) VALUES (..., @id, ...);
ध्यान दें कि LAST_INSERT_ID() सत्र से जुड़ा हुआ है, इसलिए भले ही कई कनेक्शन एक ही तालिका में सम्मिलित हो रहे हों, प्रत्येक की अपनी आईडी प्राप्त होती है।
आपके क्लाइंट API के पास संभवतः LAST_INSERT_ID() प्राप्त करने का एक वैकल्पिक तरीका है LAST_INSERT_ID() वास्तव में एक SELECT प्रदर्शन किए बिना और ग्राहक को वापस MySQL के अंदर एक @variable में छोड़ने के बजाय मूल्य को सौंपना। ऐसा आमतौर पर बेहतर होता है।
लंबा, अधिक विस्तृत, उदाहरण
IODKU का "सामान्य" उपयोग कुछ UNIQUE कुंजी के आधार पर "डुप्लिकेट कुंजी" को ट्रिगर करना है, न कि AUTO_INCREMENT PRIMARY KEY । निम्नलिखित ऐसे प्रदर्शित करता है। ध्यान दें कि यह INSERT में id आपूर्ति नहीं करता है।
अनुसरण करने के लिए उदाहरणों के लिए सेटअप:
CREATE TABLE iodku (
id INT AUTO_INCREMENT NOT NULL,
name VARCHAR(99) NOT NULL,
misc INT NOT NULL,
PRIMARY KEY(id),
UNIQUE(name)
) ENGINE=InnoDB;
INSERT INTO iodku (name, misc)
VALUES
('Leslie', 123),
('Sally', 456);
Query OK, 2 rows affected (0.00 sec)
Records: 2 Duplicates: 0 Warnings: 0
+----+--------+------+
| id | name | misc |
+----+--------+------+
| 1 | Leslie | 123 |
| 2 | Sally | 456 |
+----+--------+------+
IODKU का मामला एक "अपडेट" और LAST_INSERT_ID() प्रासंगिक id पुनः प्राप्त करने का कार्य कर रहा है:
INSERT INTO iodku (name, misc)
VALUES
('Sally', 3333) -- should update
ON DUPLICATE KEY UPDATE -- `name` will trigger "duplicate key"
id = LAST_INSERT_ID(id),
misc = VALUES(misc);
SELECT LAST_INSERT_ID(); -- picking up existing value
+------------------+
| LAST_INSERT_ID() |
+------------------+
| 2 |
+------------------+
वह मामला जहां IODKU एक "इन्सर्ट" करता है और LAST_INSERT_ID() नई id पुनः प्राप्त करता है:
INSERT INTO iodku (name, misc)
VALUES
('Dana', 789) -- Should insert
ON DUPLICATE KEY UPDATE
id = LAST_INSERT_ID(id),
misc = VALUES(misc);
SELECT LAST_INSERT_ID(); -- picking up new value
+------------------+
| LAST_INSERT_ID() |
+------------------+
| 3 |
+------------------+
परिणाम तालिका सामग्री:
SELECT * FROM iodku;
+----+--------+------+
| id | name | misc |
+----+--------+------+
| 1 | Leslie | 123 |
| 2 | Sally | 3333 | -- IODKU changed this
| 3 | Dana | 789 | -- IODKU added this
+----+--------+------+
खोई हुई AUTO_INCREMENT आईडी
कई 'इन्सर्ट' फंक्शन आईडी को "बर्न" कर सकते हैं। यहाँ एक उदाहरण है, InnoDB का उपयोग करके (अन्य इंजन अलग तरीके से काम कर सकते हैं):
CREATE TABLE Burn (
id SMALLINT UNSIGNED AUTO_INCREMENT NOT NULL,
name VARCHAR(99) NOT NULL,
PRIMARY KEY(id),
UNIQUE(name)
) ENGINE=InnoDB;
INSERT IGNORE INTO Burn (name) VALUES ('first'), ('second');
SELECT LAST_INSERT_ID(); -- 1
SELECT * FROM Burn ORDER BY id;
+----+--------+
| 1 | first |
| 2 | second |
+----+--------+
INSERT IGNORE INTO Burn (name) VALUES ('second'); -- dup 'IGNOREd', but id=3 is burned
SELECT LAST_INSERT_ID(); -- Still "1" -- can't trust in this situation
SELECT * FROM Burn ORDER BY id;
+----+--------+
| 1 | first |
| 2 | second |
+----+--------+
INSERT IGNORE INTO Burn (name) VALUES ('third');
SELECT LAST_INSERT_ID(); -- now "4"
SELECT * FROM Burn ORDER BY id; -- note that id=3 was skipped over
+----+--------+
| 1 | first |
| 2 | second |
| 4 | third | -- notice that id=3 has been 'burned'
+----+--------+
इस तरह से सोचें (मोटे तौर पर): सबसे पहले यह देखने के लिए कि कितनी पंक्तियाँ डाली जा सकती हैं। फिर उस तालिका के लिए auto_increment से कई मान लें। अंत में, पंक्तियों को सम्मिलित करें, आवश्यकतानुसार आईडी का उपयोग करें, और किसी भी बाएं ओवरों को जलाएं।
यदि सिस्टम शटडाउन और पुनरारंभ हो जाता है, तो एकमात्र समय पुनर्प्राप्त करने योग्य है। पुनः आरंभ करने पर, प्रभावी रूप से MAX(id) किया जाता है। यह उन आईडी का पुन: उपयोग कर सकता है जिन्हें जला दिया गया था या जिन्हें उच्चतम आईडी (एस) के DELETEs द्वारा मुक्त किया गया था।
INSERT का अनिवार्य रूप से कोई भी स्वाद ( REPLACE , जो DELETE + INSERT ) में आईडी जला सकते हैं। InnoDB में, वैश्विक (सत्र नहीं!) चर innodb_autoinc_lock_mode का उपयोग किया जा सकता है जो कि कुछ चल रहा है।
जब एक AUTO INCREMENT id में लंबे स्ट्रिंग्स को "सामान्य" किया जाता है, तो बर्निंग आसानी से हो सकती है। यह आपके द्वारा चुने गए INT के आकार को ओवरफ्लो कर सकता है ।