SQLite - UPSERT * pas * INSÉRER ou REMPLACER

http://en.wikipedia.org/wiki/Upsert

Insérer le processus stocké de mise à jour sur SQL Server

Existe-t-il un moyen intelligent de le faire dans SQLite auquel je n'ai pas pensé?

Fondamentalement, je veux mettre à jour trois des quatre colonnes si l'enregistrement existe, s'il n'existe pas, je veux INSÉRER l'enregistrement avec la valeur par défaut (NUL) pour la quatrième colonne.

L'ID est une clé primaire, il n'y aura donc qu'un seul enregistrement sur UPSERT.

(J'essaie d'éviter la surcharge de SELECT afin de déterminer si j'ai besoin de METTRE À JOUR ou INSÉRER évidemment)

Suggestions?

Je ne peux pas confirmer cette syntaxe sur le site SQLite pour TABLE CREATE. Je n'ai pas construit de démo pour le tester, mais il ne semble pas être supporté ..

Si c'était le cas, j'ai trois colonnes, donc cela ressemblerait à:

CREATE TABLE table1( 
    id INTEGER PRIMARY KEY ON CONFLICT REPLACE, 
    Blob1 BLOB ON CONFLICT REPLACE, 
    Blob2 BLOB ON CONFLICT REPLACE, 
    Blob3 BLOB 
);

mais les deux premiers blobs ne causeront pas de conflit, seul l'ID serait donc je asusme Blob1 et Blob2 ne seraient pas remplacés (comme souhaité)

UPDATEs dans SQLite lorsque les données de liaison sont une transaction complète, ce qui signifie que chaque ligne envoyée à mettre à jour nécessite: Préparer / Lier / Étape / Finaliser les instructions contrairement à INSERT qui permet l'utilisation de la fonction de réinitialisation

La vie d'un objet de déclaration ressemble à ceci:

1. Créez l'objet à l'aide de sqlite3_prepare_v2 ()
2. Liez les valeurs aux paramètres de l'hôte à l'aide des interfaces sqlite3_bind_.
3. Exécutez le SQL en appelant sqlite3_step ()
4. Réinitialisez l'instruction à l'aide de sqlite3_reset (), puis revenez à l'étape 2 et répétez.
5. Détruisez l'objet de déclaration à l'aide de sqlite3_finalize ().

UPDATE Je suppose que c'est lent par rapport à INSERT, mais comment se compare-t-il à SELECT en utilisant la clé primaire?

Peut-être devrais-je utiliser la sélection pour lire la 4e colonne (Blob3) puis utiliser REMPLACER pour écrire un nouvel enregistrement mélangeant la 4e colonne d'origine avec les nouvelles données pour les 3 premières colonnes?

En supposant trois colonnes dans le tableau: ID, NAME, ROLE

MAUVAIS: Cela insérera ou remplacera toutes les colonnes par de nouvelles valeurs pour ID = 1:

INSERT OR REPLACE INTO Employee (id, name, role) 
  VALUES (1, 'John Foo', 'CEO');

MAUVAIS: Cela insérera ou remplacera 2 des colonnes ... la colonne NOM sera définie sur NULL ou la valeur par défaut:

INSERT OR REPLACE INTO Employee (id, role) 
  VALUES (1, 'code monkey');

BON : utilisez la prise en charge UPSERT de la clause de conflit SQLite On dans SQLite! La syntaxe UPSERT a été ajoutée à SQLite avec la version 3.24.0!

UPSERT est une addition de syntaxe spéciale à INSERT qui fait que INSERT se comporte comme une MISE À JOUR ou un no-op si INSERT viole une contrainte d'unicité. UPSERT n'est pas du SQL standard. UPSERT dans SQLite suit la syntaxe établie par PostgreSQL.

BON mais tendu: cela mettra à jour 2 des colonnes. Lorsque ID = 1 existe, le NOM n'est pas affecté. Lorsque ID = 1 n'existe pas, le nom sera la valeur par défaut (NULL).

INSERT OR REPLACE INTO Employee (id, role, name) 
  VALUES (  1, 
            'code monkey',
            (SELECT name FROM Employee WHERE id = 1)
          );

Cela mettra à jour 2 des colonnes. Lorsque ID = 1 existe, le RÔLE ne sera pas affecté. Lorsque ID = 1 n'existe pas, le rôle sera défini sur «Benchwarmer» au lieu de la valeur par défaut.

INSERT OR REPLACE INTO Employee (id, name, role) 
  VALUES (  1, 
            'Susan Bar',
            COALESCE((SELECT role FROM Employee WHERE id = 1), 'Benchwarmer')
          );

INSÉRER OU REMPLACER N'EST PAS équivalent à "UPSERT".

Supposons que j'ai la table Employee avec les champs id, name et role:

INSERT OR REPLACE INTO Employee ("id", "name", "role") VALUES (1, "John Foo", "CEO")
INSERT OR REPLACE INTO Employee ("id", "role") VALUES (1, "code monkey")

Boom, vous avez perdu le nom de l'employé numéro 1. SQLite l'a remplacé par une valeur par défaut.

La sortie attendue d'un UPSERT serait de changer le rôle et de conserver le nom.

La réponse d'Eric B est OK si vous souhaitez conserver une ou peut-être deux colonnes de la ligne existante. Si vous souhaitez conserver un grand nombre de colonnes, cela devient trop lourd rapidement.

Voici une approche qui s'adapte bien à n'importe quel nombre de colonnes de chaque côté. Pour l'illustrer, je supposerai le schéma suivant:

 CREATE TABLE page (
     id      INTEGER PRIMARY KEY,
     name    TEXT UNIQUE,
     title   TEXT,
     content TEXT,
     author  INTEGER NOT NULL REFERENCES user (id),
     ts      TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 );

Notez en particulier que namec'est la clé naturelle de la ligne - idn'est utilisée que pour les clés étrangères, donc le point est pour SQLite de choisir la valeur ID elle-même lors de l'insertion d'une nouvelle ligne. Mais lors de la mise à jour d'une ligne existante en fonction de son name, je veux qu'elle continue d'avoir l'ancienne valeur ID (évidemment!).

J'atteins un vrai UPSERTavec la construction suivante:

 WITH new (name, title, author) AS ( VALUES('about', 'About this site', 42) )
 INSERT OR REPLACE INTO page (id, name, title, content, author)
 SELECT old.id, new.name, new.title, old.content, new.author
 FROM new LEFT JOIN page AS old ON new.name = old.name;

La forme exacte de cette requête peut varier un peu. La clé est l'utilisation de INSERT SELECTavec une jointure externe gauche, pour joindre une ligne existante aux nouvelles valeurs.

Ici, si une ligne n'existait pas auparavant, ce old.idsera le cas NULLet SQLite attribuera alors un ID automatiquement, mais s'il y avait déjà une telle ligne, old.idaura une valeur réelle et celle-ci sera réutilisée. C'est exactement ce que je voulais.

En fait, c'est très flexible. Notez que la tscolonne manque complètement de tous les côtés - car elle a une DEFAULTvaleur, SQLite fera juste la bonne chose dans tous les cas, donc je n'ai pas à m'en occuper moi-même.

Vous pouvez également inclure une colonne sur les deux newet les oldcôtés et puis utiliser par exemple COALESCE(new.content, old.content)dans la partie extérieure SELECTde dire « insérer le nouveau contenu s'il y avait, sinon garder l'ancien contenu » - par exemple , si vous utilisez une requête fixe et liez la nouvelle valeurs avec des espaces réservés.

Si vous faites généralement des mises à jour, je le ferais ..

1. Commencer une transaction
2. Faites la mise à jour
3. Vérifiez le nombre de lignes
4. Si c'est 0 faites l'insert
5. Commettre

Si vous faites généralement des encarts, je

1. Commencer une transaction
2. Essayez un insert
3. Vérifier l'erreur de violation de clé primaire
4. si nous avons une erreur, faites la mise à jour
5. Commettre

De cette façon, vous évitez la sélection et vous êtes transactionnellement solide sur Sqlite.

Cette réponse a été mise à jour et les commentaires ci-dessous ne s'appliquent donc plus.

2018-05-18 STOP PRESSE.

Prise en charge UPSERT dans SQLite!La syntaxe UPSERT a été ajoutée à SQLite avec la version 3.24.0 (en attente)!

UPSERT est une addition de syntaxe spéciale à INSERT qui fait que INSERT se comporte comme une MISE À JOUR ou un no-op si INSERT viole une contrainte d'unicité. UPSERT n'est pas du SQL standard. UPSERT dans SQLite suit la syntaxe établie par PostgreSQL.

alternativement:

Une autre façon complètement différente de procéder est la suivante: dans mon application, j'ai défini mon en ligne rowID pour qu'il soit long.MaxValue lorsque je crée la ligne en mémoire. (MaxValue ne sera jamais utilisé comme un identifiant, vous ne vivrez pas assez longtemps .... Ensuite, si rowID n'est pas cette valeur, il doit déjà être dans la base de données, il a donc besoin d'une MISE À JOUR s'il s'agit de MaxValue, alors il a besoin d'un insert. Cela n'est utile que si vous pouvez suivre les ID de ligne dans votre application.

Je me rends compte que c'est un vieux thread mais j'ai travaillé dans sqlite3 récemment et j'ai trouvé cette méthode qui correspondait mieux à mes besoins de génération dynamique de requêtes paramétrées:

insert or ignore into <table>(<primaryKey>, <column1>, <column2>, ...) values(<primaryKeyValue>, <value1>, <value2>, ...); 
update <table> set <column1>=<value1>, <column2>=<value2>, ... where changes()=0 and <primaryKey>=<primaryKeyValue>; 

C'est toujours 2 requêtes avec une clause where sur la mise à jour mais semble faire l'affaire. J'ai également cette vision en tête que sqlite peut optimiser complètement l'instruction de mise à jour si l'appel à changes () est supérieur à zéro. Qu'il le fasse ou non, cela dépasse mes connaissances, mais un homme peut rêver n'est-ce pas? ;)

Pour les points bonus, vous pouvez ajouter cette ligne qui vous renvoie l'id de la ligne, que ce soit une ligne nouvellement insérée ou une ligne existante.

select case changes() WHEN 0 THEN last_insert_rowid() else <primaryKeyValue> end;

Voici une solution qui est vraiment un UPSERT (UPDATE ou INSERT) au lieu d'un INSERT OR REPLACE (qui fonctionne différemment dans de nombreuses situations).

Cela fonctionne comme ceci:
1. Essayez de mettre à jour si un enregistrement avec le même ID existe.
2. Si la mise à jour n'a modifié aucune ligne (NOT EXISTS(SELECT changes() AS change FROM Contact WHERE change <> 0) ), insérez l'enregistrement.

Donc, soit un enregistrement existant a été mis à jour, soit une insertion sera effectuée.

Le détail important consiste à utiliser la fonction SQL changes () pour vérifier si l'instruction de mise à jour a atteint des enregistrements existants et à exécuter l'instruction d'insertion uniquement si elle n'a atteint aucun enregistrement.

Une chose à mentionner est que la fonction changes () ne renvoie pas les modifications effectuées par des déclencheurs de niveau inférieur (voir http://sqlite.org/lang_corefunc.html#changes ), alors assurez-vous de prendre cela en compte.

Voici le SQL ...

Mise à jour du test:

--Create sample table and records (and drop the table if it already exists)
DROP TABLE IF EXISTS Contact;
CREATE TABLE [Contact] (
  [Id] INTEGER PRIMARY KEY, 
  [Name] TEXT
);
INSERT INTO Contact (Id, Name) VALUES (1, 'Mike');
INSERT INTO Contact (Id, Name) VALUES (2, 'John');

-- Try to update an existing record
UPDATE Contact
SET Name = 'Bob'
WHERE Id = 2;

-- If no record was changed by the update (meaning no record with the same Id existed), insert the record
INSERT INTO Contact (Id, Name)
SELECT 2, 'Bob'
WHERE NOT EXISTS(SELECT changes() AS change FROM Contact WHERE change <> 0);

--See the result
SELECT * FROM Contact;

Insert de test:

--Create sample table and records (and drop the table if it already exists)
DROP TABLE IF EXISTS Contact;
CREATE TABLE [Contact] (
  [Id] INTEGER PRIMARY KEY, 
  [Name] TEXT
);
INSERT INTO Contact (Id, Name) VALUES (1, 'Mike');
INSERT INTO Contact (Id, Name) VALUES (2, 'John');

-- Try to update an existing record
UPDATE Contact
SET Name = 'Bob'
WHERE Id = 3;

-- If no record was changed by the update (meaning no record with the same Id existed), insert the record
INSERT INTO Contact (Id, Name)
SELECT 3, 'Bob'
WHERE NOT EXISTS(SELECT changes() AS change FROM Contact WHERE change <> 0);

--See the result
SELECT * FROM Contact;

À partir de la version 3.24.0, UPSERT est pris en charge par SQLite.

De la documentation :

UPSERT est une addition de syntaxe spéciale à INSERT qui fait que INSERT se comporte comme une MISE À JOUR ou un no-op si INSERT viole une contrainte d'unicité. UPSERT n'est pas du SQL standard. UPSERT dans SQLite suit la syntaxe établie par PostgreSQL. La syntaxe UPSERT a été ajoutée à SQLite avec la version 3.24.0 (en attente).

Un UPSERT est une instruction INSERT ordinaire qui est suivie de la clause spéciale ON CONFLICT

^{Source de l'image: https://www.sqlite.org/images/syntax/upsert-clause.gif}

Vous pouvez en effet faire un upsert dans SQLite, il semble juste un peu différent de celui auquel vous êtes habitué. Cela ressemblerait à quelque chose comme:

INSERT INTO table name (column1, column2) 
VALUES ("value12", "value2") WHERE id = 123 
ON CONFLICT DO UPDATE 
SET column1 = "value1", column2 = "value2" WHERE id = 123

Développer la réponse d'Aristote vous pouvez sélectionner à partir d'une table factice «singleton» (une table de votre propre création avec une seule ligne). Cela évite une certaine duplication.

J'ai également gardé l'exemple portable sur MySQL et SQLite et utilisé une colonne 'date_added' comme exemple de la façon dont vous pouvez définir une colonne uniquement la première fois.

 REPLACE INTO page (
   id,
   name,
   title,
   content,
   author,
   date_added)
 SELECT
   old.id,
   "about",
   "About this site",
   old.content,
   42,
   IFNULL(old.date_added,"21/05/2013")
 FROM singleton
 LEFT JOIN page AS old ON old.name = "about";

La meilleure approche que je connaisse est de faire une mise à jour, suivie d'une insertion. Le "surcoût d'une sélection" est nécessaire, mais ce n'est pas un fardeau terrible puisque vous recherchez sur la clé primaire, ce qui est rapide.

Vous devriez pouvoir modifier les instructions ci-dessous avec vos noms de table et de champ pour faire ce que vous voulez.

--first, update any matches
UPDATE DESTINATION_TABLE DT
SET
  MY_FIELD1 = (
              SELECT MY_FIELD1
              FROM SOURCE_TABLE ST
              WHERE ST.PRIMARY_KEY = DT.PRIMARY_KEY
              )
 ,MY_FIELD2 = (
              SELECT MY_FIELD2
              FROM SOURCE_TABLE ST
              WHERE ST.PRIMARY_KEY = DT.PRIMARY_KEY
              )
WHERE EXISTS(
            SELECT ST2.PRIMARY_KEY
            FROM
              SOURCE_TABLE ST2
             ,DESTINATION_TABLE DT2
            WHERE ST2.PRIMARY_KEY = DT2.PRIMARY_KEY
            );

--second, insert any non-matches
INSERT INTO DESTINATION_TABLE(
  MY_FIELD1
 ,MY_FIELD2
)
SELECT
  ST.MY_FIELD1
 ,NULL AS MY_FIELD2  --insert NULL into this field
FROM
  SOURCE_TABLE ST
WHERE NOT EXISTS(
                SELECT DT2.PRIMARY_KEY
                FROM DESTINATION_TABLE DT2
                WHERE DT2.PRIMARY_KEY = ST.PRIMARY_KEY
                );

Si quelqu'un veut lire ma solution pour SQLite à Cordova, j'ai obtenu cette méthode générique js grâce à la réponse @david ci-dessus.

function    addOrUpdateRecords(tableName, values, callback) {
get_columnNames(tableName, function (data) {
    var columnNames = data;
    myDb.transaction(function (transaction) {
        var query_update = "";
        var query_insert = "";
        var update_string = "UPDATE " + tableName + " SET ";
        var insert_string = "INSERT INTO " + tableName + " SELECT ";
        myDb.transaction(function (transaction) {
            // Data from the array [[data1, ... datan],[()],[()]...]:
            $.each(values, function (index1, value1) {
                var sel_str = "";
                var upd_str = "";
                var remoteid = "";
                $.each(value1, function (index2, value2) {
                    if (index2 == 0) remoteid = value2;
                    upd_str = upd_str + columnNames[index2] + "='" + value2 + "', ";
                    sel_str = sel_str + "'" + value2 + "', ";
                });
                sel_str = sel_str.substr(0, sel_str.length - 2);
                sel_str = sel_str + " WHERE NOT EXISTS(SELECT changes() AS change FROM "+tableName+" WHERE change <> 0);";
                upd_str = upd_str.substr(0, upd_str.length - 2);
                upd_str = upd_str + " WHERE remoteid = '" + remoteid + "';";                    
                query_update = update_string + upd_str;
                query_insert = insert_string + sel_str;  
                // Start transaction:
                transaction.executeSql(query_update);
                transaction.executeSql(query_insert);                    
            });
        }, function (error) {
            callback("Error: " + error);
        }, function () {
            callback("Success");
        });
    });
});
}

Donc, prenez d'abord les noms des colonnes avec cette fonction:

function get_columnNames(tableName, callback) {
myDb.transaction(function (transaction) {
    var query_exec = "SELECT name, sql FROM sqlite_master WHERE type='table' AND name ='" + tableName + "'";
    transaction.executeSql(query_exec, [], function (tx, results) {
        var columnParts = results.rows.item(0).sql.replace(/^[^\(]+\(([^\)]+)\)/g, '$1').split(','); ///// RegEx
        var columnNames = [];
        for (i in columnParts) {
            if (typeof columnParts[i] === 'string')
                columnNames.push(columnParts[i].split(" ")[0]);
        };
        callback(columnNames);
    });
});
}

Générez ensuite les transactions par programme.

"Valeurs" est un tableau que vous devez créer avant et il représente les lignes que vous souhaitez insérer ou mettre à jour dans la table.

"remoteid" est l'identifiant que j'ai utilisé comme référence, car je me synchronise avec mon serveur distant.

Pour l'utilisation du plugin SQLite Cordova, veuillez vous référer au lien officiel

Cette méthode remixe quelques-unes des autres méthodes de réponse dans cette question et intègre l'utilisation de CTE (Common Table Expressions). Je vais introduire la requête puis expliquer pourquoi j'ai fait ce que j'ai fait.

Je voudrais changer le nom de famille de l'employé 300 en DAVIS s'il y a un employé 300. Sinon, j'ajouterai un nouvel employé.

Nom de la table: employés Colonnes: id, prénom, nom

La requête est:

INSERT OR REPLACE INTO employees (employee_id, first_name, last_name)
WITH registered_employees AS ( --CTE for checking if the row exists or not
    SELECT --this is needed to ensure that the null row comes second
        *
    FROM (
        SELECT --an existing row
            *
        FROM
            employees
        WHERE
            employee_id = '300'

        UNION

        SELECT --a dummy row if the original cannot be found
            NULL AS employee_id,
            NULL AS first_name,
            NULL AS last_name
    )
    ORDER BY
        employee_id IS NULL --we want nulls to be last
    LIMIT 1 --we only want one row from this statement
)
SELECT --this is where you provide defaults for what you would like to insert
    registered_employees.employee_id, --if this is null the SQLite default will be used
    COALESCE(registered_employees.first_name, 'SALLY'),
    'DAVIS'
FROM
    registered_employees
;

Fondamentalement, j'ai utilisé le CTE pour réduire le nombre de fois où l'instruction select doit être utilisée pour déterminer les valeurs par défaut. Puisqu'il s'agit d'un CTE, nous sélectionnons simplement les colonnes que nous voulons dans la table et l'instruction INSERT l'utilise.

Vous pouvez maintenant décider quelles valeurs par défaut vous souhaitez utiliser en remplaçant les valeurs nulles, dans la fonction COALESCE par ce que les valeurs devraient être.

À la suite d' Aristote Pagaltzis et de l'idée de la réponseCOALESCE d' Eric B , voici une option positive pour mettre à jour seulement quelques colonnes ou insérer une ligne complète si elle n'existe pas.

Dans ce cas, imaginez que le titre et le contenu doivent être mis à jour, en conservant les autres anciennes valeurs lors de l'existant et en insérant celles fournies lorsque le nom est introuvable:

NOTE id est forcé d'être NULL quand INSERTil est censé être auto-incrémenté. S'il ne s'agit que d'une clé primaire générée, elle COALESCEpeut également être utilisée (voir le commentaire d'Aristote Pagaltzis ).

WITH new (id, name, title, content, author)
     AS ( VALUES(100, 'about', 'About this site', 'Whatever new content here', 42) )
INSERT OR REPLACE INTO page (id, name, title, content, author)
SELECT
     old.id, COALESCE(old.name, new.name),
     new.title, new.content,
     COALESCE(old.author, new.author)
FROM new LEFT JOIN page AS old ON new.name = old.name;

Donc, la règle générale serait, si vous souhaitez conserver les anciennes valeurs, utilisez COALESCE, lorsque vous souhaitez mettre à jour les valeurs, utiliseznew.fieldname

Je pense que c'est peut-être ce que vous recherchez: clause ON CONFLICT .

Si vous définissez votre table comme ceci:

CREATE TABLE table1( 
    id INTEGER PRIMARY KEY ON CONFLICT REPLACE, 
    field1 TEXT 
); 

Maintenant, si vous faites un INSERT avec un identifiant qui existe déjà, SQLite effectue automatiquement la MISE À JOUR au lieu de INSERT.

Hth ...

Si cela ne vous dérange pas de le faire en deux opérations.

Pas:

1) Ajoutez de nouveaux éléments avec "INSÉRER OU IGNORER"

2) Mettre à jour les éléments existants avec "UPDATE"

L'entrée des deux étapes est la même collection d'éléments nouveaux ou pouvant être mis à jour. Fonctionne bien avec les éléments existants qui ne nécessitent aucune modification. Ils seront mis à jour, mais avec les mêmes données et donc le résultat net est sans changement.

Bien sûr, plus lent, etc. Inefficace. Oui.

Facile à écrire le sql et à le maintenir et le comprendre? Absolument.

C'est un compromis à considérer. Fonctionne très bien pour les petits upserts. Fonctionne très bien pour ceux qui ne craignent pas de sacrifier l'efficacité pour la maintenabilité du code.

Ayant juste lu ce fil et déçu qu'il n'était pas facile de se contenter de cette ing "UPSERT", j'ai approfondi ...

Vous pouvez réellement le faire directement et facilement dans SQLITE.

À la place d'utiliser: INSERT INTO

Utilisation: INSERT OR REPLACE INTO

Cela fait exactement ce que vous voulez qu'il fasse!

SELECT COUNT(*) FROM table1 WHERE id = 1;

si COUNT(*) = 0

INSERT INTO table1(col1, col2, cole) VALUES(var1,var2,var3);

sinon si COUNT(*) > 0

UPDATE table1 SET col1 = var4, col2 = var5, col3 = var6 WHERE id = 1;