MySQL: Datensatz einfügen, falls nicht in der Tabelle vorhanden

Ich versuche die folgende Abfrage auszuführen:

INSERT INTO table_listnames (name, address, tele)
VALUES ('Rupert', 'Somewhere', '022')
WHERE NOT EXISTS (
    SELECT name FROM table_listnames WHERE name='value'
);

Dies gibt jedoch einen Fehler zurück. Grundsätzlich möchte ich keinen Datensatz einfügen, wenn das Feld 'Name' des Datensatzes bereits in einem anderen Datensatz vorhanden ist. Wie kann ich überprüfen, ob der neue Name eindeutig ist?

Ich schlage nicht vor, dass Sie dies tun, da der UNIQUEvon Piskvor und anderen vorgeschlagene Index ein weitaus besserer Weg ist, dies zu tun, aber Sie können tatsächlich das tun, was Sie versucht haben:

CREATE TABLE `table_listnames` (
  `id` int(11) NOT NULL auto_increment,
  `name` varchar(255) NOT NULL,
  `address` varchar(255) NOT NULL,
  `tele` varchar(255) NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB;

Datensatz einfügen:

INSERT INTO table_listnames (name, address, tele)
SELECT * FROM (SELECT 'Rupert', 'Somewhere', '022') AS tmp
WHERE NOT EXISTS (
    SELECT name FROM table_listnames WHERE name = 'Rupert'
) LIMIT 1;

Query OK, 1 row affected (0.00 sec)
Records: 1  Duplicates: 0  Warnings: 0

SELECT * FROM `table_listnames`;

+----+--------+-----------+------+
| id | name   | address   | tele |
+----+--------+-----------+------+
|  1 | Rupert | Somewhere | 022  |
+----+--------+-----------+------+

Versuchen Sie erneut, denselben Datensatz einzufügen:

INSERT INTO table_listnames (name, address, tele)
SELECT * FROM (SELECT 'Rupert', 'Somewhere', '022') AS tmp
WHERE NOT EXISTS (
    SELECT name FROM table_listnames WHERE name = 'Rupert'
) LIMIT 1;

Query OK, 0 rows affected (0.00 sec)
Records: 0  Duplicates: 0  Warnings: 0

+----+--------+-----------+------+
| id | name   | address   | tele |
+----+--------+-----------+------+
|  1 | Rupert | Somewhere | 022  |
+----+--------+-----------+------+

Fügen Sie einen anderen Datensatz ein:

INSERT INTO table_listnames (name, address, tele)
SELECT * FROM (SELECT 'John', 'Doe', '022') AS tmp
WHERE NOT EXISTS (
    SELECT name FROM table_listnames WHERE name = 'John'
) LIMIT 1;

Query OK, 1 row affected (0.00 sec)
Records: 1  Duplicates: 0  Warnings: 0

SELECT * FROM `table_listnames`;

+----+--------+-----------+------+
| id | name   | address   | tele |
+----+--------+-----------+------+
|  1 | Rupert | Somewhere | 022  |
|  2 | John   | Doe       | 022  |
+----+--------+-----------+------+

Und so weiter...

Aktualisieren:

Um #1060 - Duplicate column nameFehler zu vermeiden , falls zwei Werte gleich sind, müssen Sie die Spalten des inneren SELECT benennen:

INSERT INTO table_listnames (name, address, tele)
SELECT * FROM (SELECT 'Unknown' AS name, 'Unknown' AS address, '022' AS tele) AS tmp
WHERE NOT EXISTS (
    SELECT name FROM table_listnames WHERE name = 'Rupert'
) LIMIT 1;

Query OK, 1 row affected (0.00 sec)
Records: 1  Duplicates: 0  Warnings: 0

SELECT * FROM `table_listnames`;

+----+---------+-----------+------+
| id | name    | address   | tele |
+----+---------+-----------+------+
|  1 | Rupert  | Somewhere | 022  |
|  2 | John    | Doe       | 022  |
|  3 | Unknown | Unknown   | 022  |
+----+---------+-----------+------+

INSERT erlaubt keine WHERESyntax .

Was Sie tun können: Erstellen Sie ein UNIQUE INDEXFeld, das eindeutig sein sollte ( name), und verwenden Sie dann entweder:

• normal INSERT(und behandeln Sie den Fehler, wenn der Name bereits existiert)
• INSERT IGNORE(was im Stillen fehlschlägt und eine Warnung (anstelle eines Fehlers) verursacht, wenn der Name bereits vorhanden ist)
• INSERT ... ON DUPLICATE KEY UPDATE(wird UPDATEam Ende ausgeführt, wenn der Name bereits vorhanden ist, siehe Dokumentation )

Hat funktioniert :

INSERT INTO users (full_name, login, password) 
  SELECT 'Mahbub Tito','tito',SHA1('12345') FROM DUAL
WHERE NOT EXISTS 
  (SELECT login FROM users WHERE login='tito');

MySQL bietet eine sehr nette Lösung:

REPLACE INTO `table` VALUES (5, 'John', 'Doe', SHA1('password'));

Sehr einfach zu bedienen, da Sie einen eindeutigen Primärschlüssel deklariert haben (hier mit Wert 5).

INSERT IGNORE INTO `mytable`
SET `field0` = '2',
`field1` = 12345,
`field2` = 12678;

Hier die MySQL-Abfrage, die Datensätze einfügt, wenn sie nicht vorhanden sind, und vorhandene ähnliche Datensätze ignoriert.

----Untested----

Sie können einfach den folgenden Weg verwenden:

INSERT INTO ... ON DUPLICATE KEY UPDATE ...

Auf diese Weise können Sie neue Rohdaten einfügen und bei doppelten Daten eine bestimmte Spalte ersetzen (die besten Spalten sind Zeitstempel).
Beispielsweise :

CREATE TABLE IF NOT EXISTS Devices (
  id         INT(6)       NOT NULL AUTO_INCREMENT,
  unique_id  VARCHAR(100) NOT NULL PRIMARY KEY,
  created_at VARCHAR(100) NOT NULL,
  UNIQUE KEY unique_id (unique_id),
  UNIQUE KEY id (id)
)
  CHARACTER SET utf8
  COLLATE utf8_unicode_ci;

INSERT INTO Devices(unique_id, time) 
VALUES('$device_id', '$current_time') 
ON DUPLICATE KEY UPDATE time = '$current_time';

Wenn Sie wirklich keinen eindeutigen Index für die Tabelle erhalten können, können Sie versuchen ...

INSERT INTO table_listnames (name, address, tele)
    SELECT 'Rupert', 'Somewhere', '022'
        FROM some_other_table
        WHERE NOT EXISTS (SELECT name
                              FROM table_listnames
                              WHERE name='Rupert')
        LIMIT 1;

Um ein ähnliches Problem zu lösen, habe ich die Tabelle so geändert, dass sie eine eindeutige Spalte enthält. Anhand Ihres Beispiels hätte ich bei der Erstellung Folgendes:

name VARCHAR(20),
UNIQUE (name)

Verwenden Sie dann beim Einfügen die folgende Abfrage:

INSERT IGNORE INTO train
set table_listnames='Rupert'

Diese Abfrage funktioniert gut:

INSERT INTO `user` ( `username` , `password` )
    SELECT * FROM (SELECT 'ersks', md5( 'Nepal' )) AS tmp
    WHERE NOT EXISTS (SELECT `username` FROM `user` WHERE `username` = 'ersks' 
    AND `password` = md5( 'Nepal' )) LIMIT 1

Und Sie können die Tabelle mit folgender Abfrage erstellen:

CREATE TABLE IF NOT EXISTS `user` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `username` varchar(30) NOT NULL,
    `password` varchar(32) NOT NULL,
    `status` tinyint(1) DEFAULT '0',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Hinweis: Erstellen Sie eine Tabelle mit der zweiten Abfrage, bevor Sie versuchen, die erste Abfrage zu verwenden.

Brian Hooper: Sie haben fast den Punkt erreicht, aber Sie haben einen Fehler in Ihrer Synatx. Ihre Beilage wird niemals funktionieren. Ich habe in meiner Datenbank getestet und hier ist die richtige Antwort:

INSERT INTO podatki (datum,ura,meritev1,meritev1_sunki,impulzi1,meritev2,meritev2_sunki,impulzi2)
            SELECT '$datum', '$ura', '$meritve1','$sunki1','$impulzi1','$meritve2','$sunki2','$impulzi2'
                FROM dual
                WHERE NOT EXISTS (SELECT datum,ura
                                      FROM podatki
                                      WHERE datum='$datum' and ura='$ura'

Ich gebe Ihnen mein Beispiel für einen Tisch. Das Einfügen ist fast das gleiche wie das, was Bian Hooper geschrieben hat, außer dass ich die Auswahl FROM DUAL aus einer anderen Tabelle übernommen habe. Cind Grüße, Ivan

insert into customer_keyskill(customerID, keySkillID)
select  2,1 from dual
where not exists ( 
    select  customerID  from customer_keyskill 
    where customerID = 2 
    and keySkillID = 1 )

Sie fügen das Ergebnis nicht ein. Sie können die Namensspalte in der Primärspalte definieren oder festlegen, dass sie eindeutig ist.

Ich hatte ein Problem und die von Mike empfohlene Methode funktionierte teilweise. Ich hatte den Fehler Dublicate Column name = '0' und änderte die Syntax Ihrer Abfrage wie folgt

     $tQ = "INSERT  INTO names (name_id, surname_id, sum, sum2, sum3,sum4,sum5) 
                SELECT '$name', '$surname', '$sum', '$sum2', '$sum3','$sum4','$sum5' 
FROM DUAL
                WHERE NOT EXISTS (
                SELECT sum FROM names WHERE name_id = '$name' 
AND surname_id = '$surname') LIMIT 1;";

Das Problem war mit Spaltennamen. sum3 war gleich sum4 und mysql warf republikanische Spaltennamen, und ich schrieb den Code in dieser Syntax und es funktionierte perfekt.

Ich hatte ein ähnliches Problem und musste mehrere einfügen, wenn es nicht vorhanden war. Aus den obigen Beispielen bin ich zu dieser Kombination gekommen ... sie ist hier, nur für den Fall, dass jemand sie brauchen würde.

Hinweis: Ich musste den Namen überall definieren, da MSSQL ihn benötigte ... MySQL funktioniert auch mit *.

INSERT INTO names (name)
SELECT name
FROM
(
  SELECT name
  FROM
  (
     SELECT 'Test 4' as name
  ) AS tmp_single
  WHERE NOT EXISTS
  (
     SELECT name FROM names WHERE name = 'Test 4'
  )
  UNION ALL
  SELECT name
  FROM
  (
     SELECT 'Test 5' as name
  ) AS tmp_single
  WHERE NOT EXISTS
  (
     SELECT name FROM names WHERE name = 'Test 5'
  )
) tmp_all;

MySQL: CREATE TABLE names( OIDint (11) NICHT NULL AUTO_INCREMENT, namevarchar (32) COLLATE utf8_unicode_ci NICHT NULL, PRIMARY KEY ( OID), EINZIGARTIGER SCHLÜSSEL name_UNIQUE( name)) ENGINE = InnoDB AUTO_INCREMENT = 1;

oder

MSSQL: CREATE TABLE [Namen] ([OID] INT IDENTITY (1, 1) NICHT NULL, [Name] NVARCHAR (32) NICHT NULL, PRIMARY KEY CLUSTERED ([OID] ASC)); CREATE UNIQUE NONCLUSTERED INDEX [Index_Names_Name] ON [names] ([name] ASC);

Diese Abfrage kann in PHP-Code verwendet werden.

Ich habe eine ID-Spalte in dieser Tabelle, daher muss ich für alle Spalten außer dieser ID-Spalte auf Duplizierung prüfen:

#need to change values
SET @goodsType = 1, @sybType=5, @deviceId = asdf12345SDFasdf2345;    


INSERT INTO `devices` (`goodsTypeId`, `goodsId`, `deviceId`) #need to change tablename and columnsnames
SELECT * FROM (SELECT @goodsType, @sybType, @deviceId) AS tmp
WHERE NOT EXISTS (
    SELECT 'goodsTypeId' FROM `devices` #need to change tablename and columns names
    WHERE `goodsTypeId` = @goodsType
        AND `goodsId` = @sybType
        AND `deviceId` = @deviceId
) LIMIT 1;

und jetzt wird ein neues Element nur hinzugefügt, wenn keine Zeile mit in der SETZeichenfolge konfigurierten Werten vorhanden ist