MySQL: Inserir registro se não existir na tabela

Estou tentando executar a seguinte consulta:

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

Mas isso retorna um erro. Basicamente, não quero inserir um registro se o campo 'nome' do registro já existir em outro registro - como verificar se o novo nome é exclusivo?

Na verdade, não estou sugerindo que você faça isso, pois o UNIQUEíndice sugerido por Piskvor e outros é uma maneira muito melhor de fazê-lo, mas você pode realmente fazer o que estava tentando:

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;

Inserir um registro:

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  |
+----+--------+-----------+------+

Tente inserir o mesmo registro novamente:

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  |
+----+--------+-----------+------+

Insira um registro diferente:

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  |
+----+--------+-----------+------+

E assim por diante...

Atualizar:

Para evitar #1060 - Duplicate column nameerros no caso de dois valores serem iguais, você deve nomear as colunas do SELECT interno:

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 não permite WHEREna sintaxe .

O que você pode fazer: crie um UNIQUE INDEXno campo que deve ser exclusivo ( name) e use:

• normal INSERT(e lide com o erro se o nome já existir)
• INSERT IGNORE(que falhará silenciosamente causa um aviso (em vez de erro) se o nome já existir)
• INSERT ... ON DUPLICATE KEY UPDATE(que executará UPDATEno final se o nome já existir, consulte a documentação )

Trabalhou:

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');

O MySQL fornece uma solução muito fofa:

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

Muito fácil de usar, pois você declarou uma chave primária exclusiva (aqui com o valor 5).

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

Aqui, a consulta mysql, que insere registros, se não existir, ignorará os registros semelhantes existentes.

----Untested----

Você pode usar facilmente da seguinte maneira:

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

Dessa maneira, você pode inserir novos dados brutos e, se houver dados duplicados, substituir a coluna específica (as melhores colunas são os carimbos de data e hora).
Por exemplo :

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';

Se você realmente não consegue obter um índice exclusivo sobre a tabela, tente ...

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;

Para superar um problema semelhante, modifiquei a tabela para ter uma coluna exclusiva. Usando seu exemplo, na criação, eu teria algo como:

name VARCHAR(20),
UNIQUE (name)

e use a seguinte consulta ao inseri-lo:

INSERT IGNORE INTO train
set table_listnames='Rupert'

Esta consulta funciona bem:

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

E você pode criar a tabela usando a seguinte consulta:

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 ;

Nota: Crie a tabela usando a segunda consulta antes de tentar usar a primeira consulta.

Brian Hooper: Você quase acertou no alvo, mas você tem um erro na sua sintaxe. Sua inserção nunca funcionará. Eu testei no meu banco de dados e aqui está a resposta certa:

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'

Estou lhe dando meu exemplo da tabela y. Insert é quase o mesmo que Bian Hooper escreveu, exceto que eu coloquei o select FROM DUAL em outra tabela. Cind cumprimentos, 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 )

Você está inserindo não atualizando o resultado. Você pode definir a coluna de nome na coluna principal ou defini-la como única.

Tive um problema e o método que Mike aconselhou funcionou parcialmente, tive um erro Dublicate Column name = '0' e alterei a sintaxe da sua consulta como esta`

     $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;";

O problema estava com os nomes das colunas. sum3 era igual a sum4 e o mysql lançou nomes de colunas dublicate, e eu escrevi o código nessa sintaxe e funcionou perfeitamente,

Eu tive um problema semelhante e precisava inserir vários, se não existir. Então, pelos exemplos acima, cheguei a essa combinação ... está aqui apenas no caso de alguém precisar.

Nota: Eu tive que definir o nome em todos os lugares, conforme exigido pelo MSSQL ... O MySQL também trabalha com *.

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) NOT NULL AUTO_INCREMENT, namevarchar (32) COLLATE utf8_unicode_ci NOT NULL, PRIMARY KEY ( OID), UNIQUE KEY name_UNIQUE( name)) ENGINE = InnoDB AUTO_INCREMENT = 1;

ou

MSSQL: CREATE TABLE [nomes] ([OID] INT IDENTITY (1, 1) NÃO NULL, [nome] NVARCHAR (32) NÃO NULL, CHAVE PRIMÁRIA CLUSTERED ([OID] ASC)); CRIAR ÍNDICE EXCLUSIVO NÃO EXCLUSIVO [Index_Names_Name] ON [names] ([name] ASC);

Esta consulta pode ser usada no código PHP.

Eu tenho uma coluna de ID nesta tabela, portanto, preciso verificar se há duplicação para todas as colunas, exceto esta coluna de ID:

#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;

e agora o novo item será adicionado apenas no caso de não existir uma linha com valores configurados na SETsequência