is there any difference between LEFT OUTER JOIN and LEFT_JOIN in SQLite?

[juandent]

Why are there examples of both in the tests? As far as I know they are equivalent..??

[fnc12]

Dunno. Probably it is a mistake. Please give me both links

[juandent]

the file tests\tests4.cpp shows use of both

using als_t = alias_t<Transaccion>;
    using als_a = alias_a<Account>;
    using als_b = alias_b<Account>;

    std::ignore = storage.select(columns(alias_column<als_t>(&Transaccion::fkey_account_other),
                                         alias_column<als_t>(&Transaccion::fkey_account_own),
                                         alias_column<als_a>(&Account::id_account),
                                         alias_column<als_b>(&Account::id_account)),
                                 left_outer_join<als_a>(on(c(alias_column<als_t>(&Transaccion::fkey_account_other)) ==
                                                           alias_column<als_a>(&Account::id_account))),
                                 inner_join<als_b>(on(c(alias_column<als_t>(&Transaccion::fkey_account_own)) ==
                                                      alias_column<als_b>(&Account::id_account))));

    std::ignore = storage.select(columns(alias_column<als_t>(&Transaccion::fkey_account_other),
                                         alias_column<als_t>(&Transaccion::fkey_account_own),
                                         alias_column<als_a>(&Account::id_account),
                                         alias_column<als_b>(&Account::id_account)),
                                 left_join<als_a>(on(c(alias_column<als_t>(&Transaccion::fkey_account_other)) ==
                                                     alias_column<als_a>(&Account::id_account))),
                                 inner_join<als_b>(on(c(alias_column<als_t>(&Transaccion::fkey_account_own)) ==
                                                      alias_column<als_b>(&Account::id_account))));

    std::ignore = storage.select(columns(alias_column<als_t>(&Transaccion::fkey_account_other),
                                         alias_column<als_t>(&Transaccion::fkey_account_own),
                                         alias_column<als_a>(&Account::id_account),
                                         alias_column<als_b>(&Account::id_account)),
                                 join<als_a>(on(c(alias_column<als_t>(&Transaccion::fkey_account_other)) ==
                                                alias_column<als_a>(&Account::id_account))),
                                 inner_join<als_b>(on(c(alias_column<als_t>(&Transaccion::fkey_account_own)) ==
                                                      alias_column<als_b>(&Account::id_account))));

Here we use left_outer_join and left_join which are identical as far as I have found. Also there is no difference between join and inner_join right?

Regards,
Juan

[fnc12]

left_outer_join and left_join are serialized differently. It is important. Also inner_join and join are serialized differently. That is why these queries have different functions and different tests

[juandent]

yes but they operate identically right? I mean left_owner_join is semantically equivalent to left_join and inner_join is semantically equivalent to join according to sqlite.org... .correct?

[fnc12]

I don't know actually 😅 Try to get information at sqlitetutorial.net or sqlite.org

[juandent]

As I found some time ago, the OUTER is "noiseword" not modifying what it targets semantically, so it does not matter - personal taste whether to use it or not... pg 250 of "A Guide to The SQL Standard" Fourth edition, C.J.Date, Hugh Darwen