MySQL: Insertar registro si no existe en la tabla

Estoy tratando de ejecutar la siguiente consulta:

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

Pero esto devuelve un error. Básicamente no quiero insertar un registro si el campo 'nombre' del registro ya existe en otro registro, ¿cómo verificar si el nuevo nombre es único?

No estoy sugiriendo que hagas esto, ya que el UNIQUEíndice sugerido por Piskvor y otros es una forma mucho mejor de hacerlo, pero puedes hacer lo que estabas intentando:

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;

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

Intente insertar el mismo registro nuevamente:

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

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

Y así...

Actualizar:

Para evitar #1060 - Duplicate column nameerrores en caso de que dos valores sean iguales, debe nombrar las columnas del 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 no permite WHEREen la sintaxis .

Lo que puede hacer: cree un UNIQUE INDEXcampo que debe ser único ( name), luego use:

• normal INSERT(y maneje el error si el nombre ya existe)
• INSERT IGNORE(que fallará silenciosamente causará una advertencia (en lugar de error) si el nombre ya existe)
• INSERT ... ON DUPLICATE KEY UPDATE(que ejecutará UPDATEal final si el nombre ya existe, consulte la documentación )

Trabajó :

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 proporciona una solución muy linda:

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

Muy fácil de usar ya que ha declarado una clave primaria única (aquí con valor 5).

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

Aquí la consulta mysql, que inserta registros si no existen e ignorará los registros similares existentes.

----Untested----

Puede usar fácilmente la siguiente manera:

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

De esta manera, puede insertar cualquier nueva materia prima y, si tiene datos duplicados, reemplace la columna específica (las mejores columnas son las marcas de tiempo).
Por ejemplo :

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

Si realmente no puede obtener un índice único en la tabla, puede intentar ...

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 un problema similar, he modificado la tabla para tener una columna única. Usando su ejemplo, en la creación tendría algo como:

name VARCHAR(20),
UNIQUE (name)

y luego use la siguiente consulta al insertarlo:

INSERT IGNORE INTO train
set table_listnames='Rupert'

Esta consulta funciona bien:

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

Y puede crear la tabla usando la siguiente 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: Cree una tabla usando la segunda consulta antes de intentar usar la primera consulta.

Brian Hooper: Casi llegas al punto pero tienes un error en tu synatx. Su inserto nunca funcionará. Probé en mi base de datos y aquí está la respuesta correcta:

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'

Te estoy dando mi ejemplo de y mesa. Insertar es casi lo mismo que escribió Bian Hooper, excepto que puse el select FROM DUAL en otra tabla. Saludos cordiales, 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 )

Estás insertando no actualizando el resultado. Puede definir la columna de nombre en la columna primaria o establecerla como única.

Tuve un problema, y ​​el método que Mike aconsejó funcionó en parte, tuve un error Dublicate Column name = '0', y cambié la sintaxis de su 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;";

El problema fue con los nombres de columna. sum3 era igual a sum4 y mysql arrojó nombres de columna duplicados, y escribí el código en esta sintaxis y funcionó perfectamente,

Tuve un problema similar y necesitaba insertar múltiples si no existía. Entonces, a partir de los ejemplos anteriores, llegué a esta combinación ... está aquí en caso de que alguien la necesite.

Aviso: tuve que definir el nombre en todas partes, ya que MSSQL lo requería ... MySQL también funciona con *.

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;

o

MSSQL: CREATE TABLE [nombres] ([OID] IDENTIFICACIÓN INT (1, 1) NO NULL, [nombre] NVARCHAR (32) NO NULL, CLAVE PRIMARIA CLUSIFICADA ([OID] ASC)); CREAR ÍNDICE ÚNICO NO AGRUPADO [Index_Names_Name] ON [nombres] ([nombre] ASC);

Esta consulta se puede usar en código PHP.

Tengo una columna de ID en esta tabla, así que necesito verificar la duplicación de todas las columnas, excepto esta columna 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;

y ahora se agregará un nuevo elemento solo en caso de que no exista una fila con valores configurados en SETcadena