SQLite - UPSERT * nie * WSTAW lub WYMIANA

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

Wstaw aktualizację przechowywaną proc na SQL Server

Czy jest jakiś sprytny sposób na zrobienie tego w SQLite, o którym nie myślałem?

Zasadniczo chcę zaktualizować trzy z czterech kolumn, jeśli rekord istnieje, jeśli nie istnieje, chcę WSTAWić rekord z wartością domyślną (NUL) dla czwartej kolumny.

Identyfikator jest kluczem podstawowym, więc UPSERT będzie miał tylko jeden rekord.

(Próbuję uniknąć narzutu SELECT, aby ustalić, czy muszę oczywiście ZAKTUALIZOWAĆ, czy WSTAWIĆ)

Propozycje?

Nie mogę potwierdzić tej składni na stronie SQLite dla TABLE CREATE. Nie zbudowałem wersji demo, aby ją przetestować, ale wydaje się, że nie jest obsługiwana.

Gdyby tak było, mam trzy kolumny, więc faktycznie wyglądałoby to tak:

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

ale pierwsze dwa obiekty BLOB nie spowodują konfliktu, tylko identyfikator byłby więc więc asusme Blob1 i Blob2 nie zostaną zastąpione (zgodnie z życzeniem)

AKTUALIZACJE w SQLite, gdy powiązanie danych jest kompletną transakcją, co oznacza, że ​​każdy wysłany wiersz do aktualizacji wymaga: Przygotuj / Powiąż / Krok / Zakończ instrukcje w przeciwieństwie do INSERT, który pozwala na użycie funkcji resetowania

Życie obiektu instrukcji przebiega mniej więcej tak:

1. Utwórz obiekt za pomocą sqlite3_prepare_v2 ()
2. Powiąż wartości z parametrami hosta za pomocą interfejsów sqlite3_bind_.
3. Uruchom SQL, wywołując sqlite3_step ()
4. Zresetuj instrukcję za pomocą sqlite3_reset (), a następnie wróć do kroku 2 i powtórz.
5. Zniszcz obiekt instrukcji za pomocą narzędzia sqlite3_finalize ().

AKTUALIZACJA Zgaduję, że jest powolny w porównaniu do INSERT, ale jak to się ma do SELECT przy użyciu klucza podstawowego?

Być może powinienem użyć polecenia select, aby odczytać czwartą kolumnę (Blob3), a następnie użyć REPLACE, aby napisać nowy rekord mieszający oryginalną czwartą kolumnę z nowymi danymi dla pierwszych 3 kolumn?

Zakładając trzy kolumny w tabeli: ID, NAZWA, ROLA

ZŁE: Spowoduje to wstawienie lub zastąpienie wszystkich kolumn nowymi wartościami dla ID = 1:

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

ŹLE: Spowoduje to wstawienie lub zastąpienie 2 kolumn ... kolumna NAME zostanie ustawiona na NULL lub wartość domyślna:

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

DOBRY : Użyj klauzuli konfliktu SQLite Obsługa UPSERT w SQLite! Składnia UPSERT została dodana do SQLite w wersji 3.24.0!

UPSERT to specjalny dodatek do składni INSERT, który powoduje, że INSERT zachowuje się jak AKTUALIZACJA lub nie działa, jeśli INSERT naruszy ograniczenie związane z unikalnością. UPSERT nie jest standardowym SQL. UPSERT w SQLite jest zgodny ze składnią ustaloną przez PostgreSQL.

DOBRY, ale delikatny: zaktualizuje 2 kolumny. Gdy ID = 1 istnieje, NAZWA nie ulegnie zmianie. Gdy ID = 1 nie istnieje, nazwa będzie domyślna (NULL).

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

Spowoduje to zaktualizowanie 2 kolumn. Gdy istnieje identyfikator = 1, nie ma to wpływu na rolę ROLE. Gdy ID = 1 nie istnieje, rola zostanie ustawiona na „Ogrzewacz stołowy” zamiast wartości domyślnej.

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

WSTAW LUB WYMIANA NIE JEST równoważne z „UPSERT”.

Powiedzmy, że mam tabelę Pracownik z polami id, nazwa i rola:

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, straciłeś nazwisko pracownika numer 1. SQLite zastąpił go wartością domyślną.

Oczekiwanym wyjściem UPSERT byłaby zmiana roli i zachowanie nazwy.

Odpowiedź Erica B jest OK, jeśli chcesz zachować tylko jedną lub dwie kolumny z istniejącego wiersza. Jeśli chcesz zachować wiele kolumn, staje się zbyt kłopotliwy.

Oto podejście, które dobrze skaluje się do dowolnej liczby kolumn po obu stronach. Aby to zilustrować, przyjmuję następujący schemat:

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

Zwróć uwagę w szczególności, że namejest to naturalny klucz wiersza - idjest używany tylko dla kluczy obcych, więc chodzi o to, aby SQLite sam wybrał wartość identyfikatora podczas wstawiania nowego wiersza. Ale aktualizując istniejący wiersz na jego podstawie name, chcę, aby nadal miał starą wartość identyfikatora (oczywiście!).

Osiągam prawdę UPSERTdzięki następującym konstrukcjom:

 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;

Dokładna forma tego zapytania może się nieco różnić. Kluczem jest użycieINSERT SELECT z lewym łączeniem zewnętrznym, aby połączyć istniejący wiersz z nowymi wartościami.

Tutaj, jeśli wiersz wcześniej nie istniał, old.idbędzie, NULLa SQLite automatycznie przypisze identyfikator, ale jeśli już taki wiersz był, old.idbędzie miał rzeczywistą wartość i zostanie on ponownie wykorzystany. Właśnie tego chciałem.

W rzeczywistości jest to bardzo elastyczne. Zwróć uwagę, że tskolumna jest kompletnie brakująca ze wszystkich stron - ponieważ ma DEFAULTwartość, SQLite i tak zrobi właściwą rzecz w każdym przypadku, więc nie muszę się tym zajmować.

Można również dołączyć kolumnę na obu newi oldpo bokach, a następnie użyć na przykład COALESCE(new.content, old.content)w zewnętrznej SELECTpowiedzieć „Włóż nowe treści, jeśli nie było w ogóle, inaczej zachować starą treść” - np jeśli używasz stałego zapytania i są wiążące nowa wartości z symbolami zastępczymi.

Jeśli generalnie wykonujesz aktualizacje, zrobiłbym ...

1. Rozpocznij transakcję
2. Wykonaj aktualizację
3. Sprawdź liczbę wierszy
4. Jeśli jest 0, wstaw wstawkę
5. Popełnić

Jeśli ogólnie robisz wstawki, zrobiłbym to

1. Rozpocznij transakcję
2. Wypróbuj wkładkę
3. Sprawdź błąd naruszenia klucza podstawowego
4. jeśli wystąpi błąd, wykonaj aktualizację
5. Popełnić

W ten sposób unikasz wyboru i jesteś transakcyjnie zdrowy na Sqlite.

Ta odpowiedź została zaktualizowana, więc poniższe komentarze nie mają już zastosowania.

2018-05-18 STOP PRESS.

Obsługa UPSERT w SQLite!Składnia UPSERT została dodana do SQLite w wersji 3.24.0 (w toku)!

UPSERT to specjalny dodatek do składni INSERT, który powoduje, że INSERT zachowuje się jak AKTUALIZACJA lub nie działa, jeśli INSERT naruszy ograniczenie związane z unikalnością. UPSERT nie jest standardowym SQL. UPSERT w SQLite jest zgodny ze składnią ustaloną przez PostgreSQL.

alternatywnie:

Innym całkowicie odmiennym sposobem jest: w mojej aplikacji ustawiam w wierszu memoryID wartość long.MaxValue podczas tworzenia wiersza w pamięci. (MaxValue nigdy nie zostanie użyty jako identyfikator, którego nie będziesz żył wystarczająco długo ... Zatem jeśli rowID nie jest taką wartością, to musi już znajdować się w bazie danych, więc potrzebuje UPDATE, jeśli jest MaxValue, wówczas wymaga wstawienia. Jest to przydatne tylko wtedy, gdy możesz śledzić rowIDs w swojej aplikacji.

Zdaję sobie sprawę, że to stary wątek, ale ostatnio pracowałem w sqlite3 i opracowałem tę metodę, która lepiej odpowiada moim potrzebom dynamicznego generowania sparametryzowanych zapytań:

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

Nadal są 2 zapytania z klauzulą ​​where w aktualizacji, ale wydaje się, że załatwia sprawę. Mam też w głowie tę wizję, że sqlite może całkowicie zoptymalizować instrukcję aktualizacji, jeśli wywołanie change () jest większe od zera. Niezależnie od tego, czy tak się dzieje, czy nie, ale człowiek może śnić, prawda? ;)

W przypadku punktów bonusowych możesz dołączyć tę linię, która zwraca identyfikator wiersza, niezależnie od tego, czy jest to nowo wstawiony wiersz, czy istniejący wiersz.

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

Oto rozwiązanie, które naprawdę jest UPSERT (UPDATE lub INSERT) zamiast INSERT OR REPLACE (który działa inaczej w wielu sytuacjach).

Działa to tak:
1. Spróbuj zaktualizować, jeśli istnieje rekord o tym samym identyfikatorze.
2. Jeśli aktualizacja nie zmieniła żadnych wierszy ( NOT EXISTS(SELECT changes() AS change FROM Contact WHERE change <> 0)), następnie wstaw rekord.

Tak więc albo istniejący rekord został zaktualizowany, albo zostanie wstawione.

Ważnym szczegółem jest użycie funkcji SQL zmian () do sprawdzenia, czy instrukcja aktualizacji trafiła do istniejących rekordów i wykonanie instrukcji insert tylko, jeśli nie trafiła do żadnego rekordu.

Należy wspomnieć, że funkcja zmiany () nie zwraca zmian wykonanych przez wyzwalacze niższego poziomu (patrz http://sqlite.org/lang_corefunc.html#changes ), więc pamiętaj o tym.

Oto SQL ...

Aktualizacja testowa:

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

Wkładka testowa:

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

Począwszy od wersji 3.24.0 UPSERT jest obsługiwany przez SQLite.

Z dokumentacji :

UPSERT to specjalny dodatek do składni INSERT, który powoduje, że INSERT zachowuje się jak AKTUALIZACJA lub nie działa, jeśli INSERT naruszy ograniczenie związane z unikalnością. UPSERT nie jest standardowym SQL. UPSERT w SQLite jest zgodny ze składnią ustaloną przez PostgreSQL. Składnia UPSERT została dodana do SQLite w wersji 3.24.0 (w toku).

UPSERT to zwykła instrukcja INSERT, po której następuje specjalna klauzula ON CONFLICT

^{Źródło obrazu: https://www.sqlite.org/images/syntax/upsert-clause.gif}

Rzeczywiście możesz zrobić wstawkę w SQLite, wygląda ona nieco inaczej niż zwykle. Wyglądałoby to tak:

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

Rozwijając odpowiedź Arystotelesa, możesz WYBRAĆ z obojętnego stołu „singleton” (stół własnego dzieła z jednym rzędem). Pozwala to uniknąć powielania.

Zachowałem również przykład przenośny między MySQL i SQLite i wykorzystałem kolumnę „data_added” jako przykład tego, jak można ustawić kolumnę tylko za pierwszym razem.

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

Najlepszym podejściem, jakie znam, jest aktualizacja, a następnie wstawienie. „Narzut zaznaczenia” jest konieczny, ale nie jest to straszne obciążenie, ponieważ szukasz klucza podstawowego, który jest szybki.

Powinieneś być w stanie zmodyfikować poniższe instrukcje za pomocą nazw tabel i pól, aby robić to, co chcesz.

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

Jeśli ktoś chce przeczytać moje rozwiązanie dla SQLite w Cordova, dostałem tę ogólną metodę js dzięki powyższej odpowiedzi @david.

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");
        });
    });
});
}

Więc najpierw wybierz nazwy kolumn za pomocą tej funkcji:

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

Następnie zbuduj transakcje programowo.

„Wartości” to tablica, którą powinieneś zbudować wcześniej i reprezentuje ona wiersze, które chcesz wstawić lub zaktualizować w tabeli.

„remoteid” to identyfikator, którego użyłem jako odniesienia, ponieważ synchronizuję się z moim zdalnym serwerem.

Aby skorzystać z wtyczki SQLite Cordova, zapoznaj się z oficjalnym linkiem

Ta metoda remiksuje kilka innych metod z odpowiedzi na to pytanie i obejmuje użycie CTE (Common Table Expressions). Przedstawię zapytanie, a następnie wyjaśnię, dlaczego zrobiłem to, co zrobiłem.

Chciałbym zmienić nazwisko pracownika 300 na DAVIS, jeśli istnieje pracownik 300. W przeciwnym razie dodam nowego pracownika.

Nazwa tabeli: pracownicy Kolumny: id, imię, nazwisko

Zapytanie to:

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
;

Zasadniczo użyłem CTE, aby zmniejszyć liczbę przypadków, gdy instrukcja select musi być użyta do ustalenia wartości domyślnych. Ponieważ jest to CTE, po prostu wybieramy kolumny, które chcemy z tabeli, a instrukcja INSERT używa tego.

Teraz możesz zdecydować, jakie wartości domyślne chcesz zastosować, zastępując wartości null w funkcji COALESCE odpowiednimi wartościami.

Podążając za Arystotelesem Pagaltzisem i pomysłem COALESCEz odpowiedzi Erica B , tutaj jest opcja upsert, aby zaktualizować tylko kilka kolumn lub wstawić pełny wiersz, jeśli nie istnieje.

W takim przypadku wyobraź sobie, że tytuł i treść powinny zostać zaktualizowane, zachowując pozostałe stare wartości, gdy istnieją i wstawiając dostarczone, gdy nie znaleziono nazwy:

UWAGA id jest wymuszone, aby mieć wartość NULL, gdy INSERTma to być autowzrost. Jeśli jest to tylko wygenerowany klucz podstawowy, COALESCEmożna go również użyć (patrz komentarz Arystotelesa Pagaltza ).

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;

Tak więc ogólna zasada brzmi: jeśli chcesz zachować stare wartości, użyj COALESCE, gdy chcesz zaktualizować wartości, użyjnew.fieldname

Myślę, że może to być to, czego szukasz: klauzula ON CONFLICT .

Jeśli zdefiniujesz swoją tabelę w ten sposób:

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

Teraz, jeśli wykonasz INSERT z identyfikatorem, który już istnieje, SQLite automatycznie wykonuje UPDATE zamiast INSERT.

Hth ...

Jeśli nie masz nic przeciwko robieniu tego w dwóch operacjach.

Kroki:

1) Dodaj nowe elementy za pomocą „INSERT OR IGNORE”

2) Zaktualizuj istniejące elementy za pomocą „UPDATE”

Dane wejściowe do obu kroków to ta sama kolekcja nowych lub aktualizowanych elementów. Działa dobrze z istniejącymi elementami, które nie wymagają zmian. Będą aktualizowane, ale z tymi samymi danymi, a zatem wynik netto nie będzie żadnych zmian.

Jasne, wolniejsze itp. Nieefektywne. Tak.

Łatwo napisać sql, utrzymać i zrozumieć? Zdecydowanie.

To kompromis do rozważenia. Działa świetnie w przypadku małych upserts. Działa świetnie dla tych, którym nie przeszkadza poświęcenie wydajności w celu utrzymania kodu.

Po przeczytaniu tego wątku i rozczarowaniu, że nie było łatwo przejść do tego „UPSERT”, zbadałem dalej ...

Możesz to zrobić bezpośrednio i łatwo w SQLITE.

Zamiast używać: INSERT INTO

Posługiwać się: INSERT OR REPLACE INTO

To robi dokładnie to, co chcesz!

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

gdyby COUNT(*) = 0

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

inaczej jeśli COUNT(*) > 0

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